This is an archive of the discontinued LLVM Phabricator instance.

Differential D23256

Teach the analysis manager about inter-analysis dependencies.
AbandonedPublic

Authored by silvas on Aug 7 2016, 11:08 PM.

Details

Reviewers
chandlerc
davidxl
mehdi_amini
hfinkel
Summary

This unifies analysis management for all IRUnitT's and adds dependency tracking.
The two are fairly of interrelated, since recursively invalidating transitive dependencies is difficult to do across separate analysis managers. Also, keeping track of the stack of analyses we are currently computing is difficult across separate analysis managers.

test/Other/analysis-manager/transitive-invalidation.ll shows a compelling test case.

I've used this in combination with http://reviews.llvm.org/D21921 to run the LTO pipeline on test-suite + SPEC cpu2006 with Asserts+ASan.
The two failures that remain are not related to this patch or approach (https://llvm.org/bugs/show_bug.cgi?id=28825 and https://llvm.org/bugs/show_bug.cgi?id=28888).

I've tried to retain the basic structure of the existing analysis manager code, but it still required touching quite a few lines and so the diff makes it look like it was totally rewritten.
A more incremental view of the patch can be seen here: https://github.com/llvm-mirror/llvm/compare/master...chisophugis:analysis-manager?expand=1

This patch requires making a small adjustment to every analysis and transform pass in tree (mostly, removing template parameters from AnalysisManager, and also removing use of the proxies), so there's a large number of mechanical changes.

This tracks downward invalidation using a dummy analysis called ParentIRUnitTrackingAnalysis.
By reusing the dependency tracking machinery, we get fine-grained invalidation of inner IRUnit's.
E.g. invaliding analyses on a single function doesn't invalidate loop analyses on all functions, which is a bug / fallout of the proxy approach (the InnerAnalysisManagerProxy calls "clear" on the entire LoopAnalysisManager).
TODO: test case for that

Diff Detail

Event Timeline

silvas updated this revision to Diff 67125.Aug 7 2016, 11:08 PM
silvas retitled this revision from to Teach the analysis manager about dependencies..
silvas updated this object.
silvas added reviewers: chandlerc, mehdi_amini, hfinkel, davidxl.
silvas added a subscriber: llvm-commits.
Herald added subscribers: mzolotukhin, mehdi_amini, sanjoy. · View Herald TranscriptAug 7 2016, 11:08 PM
silvas updated this revision to Diff 67126.Aug 7 2016, 11:31 PM

Add a test case of globals-aa invalidating AAManager to test/Other/analysis-manager/transitive-invalidation.ll.

silvas retitled this revision from Teach the analysis manager about dependencies. to Teach the analysis manager about inter-analysis dependencies..Aug 7 2016, 11:31 PM
davidxl edited edge metadata.Aug 8 2016, 9:47 AM

May I suggest a way to do reduce the diff?

  1. first do a nfc change with

typedef AnalysisManager<Function> FuncAnalysisManager;
....

and replace all AnalysisManager<function> with the typedef

  1. after that is in, this patch can be simplified with

typedef AnalysisManager FuncAnalysisManager;
...

  1. if 2) goes in, do another NFC to remove the typedef.
eraman added a subscriber: eraman.Aug 8 2016, 2:34 PM
silvas added a comment.Aug 8 2016, 3:08 PM
In D23256#508756, @davidxl wrote:

May I suggest a way to do reduce the diff?

  1. first do a nfc change with

typedef AnalysisManager<Function> FuncAnalysisManager;
....

and replace all AnalysisManager<function> with the typedef

  1. after that is in, this patch can be simplified with

typedef AnalysisManager FuncAnalysisManager;
...

  1. if 2) goes in, do another NFC to remove the typedef.

Good suggestion. I'll try that (we already have the typedef's. We just don't use them consistently)

silvas updated this revision to Diff 67255.Aug 8 2016, 6:10 PM
silvas edited edge metadata.

Update based on David's suggestion.

This significantly reduces the diff from master. Hopefully it should be more tractable to review now.

Also a quick reminder that a more incremental view can be seen in: https://github.com/llvm-mirror/llvm/compare/master...chisophugis:analysis-manager

mehdi_amini added inline comments.Aug 8 2016, 11:30 PM
include/llvm/Analysis/AliasAnalysis.h
894

Wasn't the point of the refactoring with typedef to avoid this kind of diff?

silvas added inline comments.Aug 8 2016, 11:55 PM
include/llvm/Analysis/AliasAnalysis.h
894

I didn't eliminate all cases, but I did catch most. This case had a diff hunk that included a proxy change (below) so I kept it in this diff.

(I had to sort through hundreds of diff hunks so I was literally doing y/n to git checkout -p in order to get through them in a reasonable time)

mehdi_amini added inline comments.Aug 9 2016, 12:11 AM
include/llvm/Analysis/AliasAnalysis.h
894

Sure, I just wanted to be sure the patch was really ready before looking more into it.

Thanks for taking the time to reduce it!

silvas abandoned this revision.Mar 25 2020, 6:29 PM
Herald added subscribers: asbirlea, dexonsmith, zzheng. · View Herald TranscriptMar 25 2020, 6:29 PM

Revision Contents

PathSize
include/
llvm/
Analysis/
17 lines
2 lines
4 lines
2 lines
4 lines
4 lines
2 lines
2 lines
82 lines
8 lines
4 lines
2 lines
4 lines
2 lines
4 lines
6 lines
2 lines
4 lines
8 lines
44 lines
2 lines
2 lines
2 lines
4 lines
4 lines
6 lines
4 lines
2 lines
2 lines
4 lines
2 lines
2 lines
Bitcode/
2 lines
CodeGen/
2 lines
2 lines
IR/
6 lines
6 lines
1059 lines
46 lines
8 lines
Passes/
29 lines
Transforms/
2 lines
IPO/
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
InstCombine/
2 lines
2 lines
6 lines
2 lines
Scalar/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
Utils/
2 lines
2 lines
2 lines
2 lines
4 lines
6 lines
2 lines
2 lines
Vectorize/
2 lines
2 lines
lib/
Analysis/
2 lines
3 lines
2 lines
6 lines
4 lines
2 lines
2 lines
11 lines
3 lines
5 lines
10 lines
4 lines
2 lines
14 lines
4 lines
8 lines
17 lines
8 lines
4 lines
5 lines
4 lines
2 lines
2 lines
6 lines
5 lines
7 lines
5 lines
2 lines
2 lines
6 lines
6 lines
2 lines
Bitcode/
Writer/
2 lines
CodeGen/
2 lines
2 lines
IR/
6 lines
12 lines
9 lines
8 lines
Passes/
46 lines
7 lines
Transforms/
IPO/
2 lines
2 lines
6 lines
2 lines
2 lines
9 lines
2 lines
6 lines
8 lines
2 lines
2 lines
2 lines
8 lines
2 lines
2 lines
2 lines
InstCombine/
2 lines
Instrumentation/
2 lines
2 lines
2 lines
24 lines
Scalar/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
13 lines
2 lines
14 lines
9 lines
5 lines
16 lines
12 lines
13 lines
8 lines
12 lines
16 lines
6 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
Utils/
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
2 lines
Vectorize/
5 lines
2 lines
test/
Other/
analysis-manager/
30 lines
8 lines
tools/
opt/
18 lines
unittests/
Analysis/
59 lines
30 lines
IR/
52 lines
6 lines

Diff 67126

include/llvm/Analysis/AliasAnalysis.h

Show First 20 Lines • Show All 872 Lines • ▼ Show 20 Lines template <typename AnalysisT> void registerFunctionAnalysis() {
ResultGetters.push_back(&getFunctionAAResultImpl<AnalysisT>); ResultGetters.push_back(&getFunctionAAResultImpl<AnalysisT>);
} }
/// Register a specific AA result. /// Register a specific AA result.
template <typename AnalysisT> void registerModuleAnalysis() { template <typename AnalysisT> void registerModuleAnalysis() {
ResultGetters.push_back(&getModuleAAResultImpl<AnalysisT>); ResultGetters.push_back(&getModuleAAResultImpl<AnalysisT>);
} }
Result run(Function &F, AnalysisManager<Function> &AM) { Result run(Function &F, AnalysisManager &AM) {
Result R(AM.getResult<TargetLibraryAnalysis>(F)); Result R(AM.getResult<TargetLibraryAnalysis>(F));
for (auto &Getter : ResultGetters) for (auto &Getter : ResultGetters)
(*Getter)(F, AM, R); (*Getter)(F, AM, R);
return R; return R;
} }
private: private:
friend AnalysisInfoMixin<AAManager>; friend AnalysisInfoMixin<AAManager>;
static char PassID; static char PassID;
SmallVector<void (*)(Function &F, AnalysisManager<Function> &AM, SmallVector<void (*)(Function &F, AnalysisManager &AM, AAResults &AAResults),
AAResults &AAResults), 4>
4> ResultGetters; ResultGetters;
mehdi_aminiUnsubmitted
Not Done
ReplyInline Actions

Wasn't the point of the refactoring with typedef to avoid this kind of diff?

mehdi_amini: Wasn't the point of the refactoring with typedef to avoid this kind of diff?
silvasAuthorUnsubmitted
Not Done
ReplyInline Actions

I didn't eliminate all cases, but I did catch most. This case had a diff hunk that included a proxy change (below) so I kept it in this diff.

(I had to sort through hundreds of diff hunks so I was literally doing y/n to git checkout -p in order to get through them in a reasonable time)

silvas: I didn't eliminate all cases, but I did catch most. This case had a diff hunk that included a…
mehdi_aminiUnsubmitted
Not Done
ReplyInline Actions

Sure, I just wanted to be sure the patch was really ready before looking more into it.

Thanks for taking the time to reduce it!

mehdi_amini: Sure, I just wanted to be sure the patch was really ready before looking more into it. Thanks…
template <typename AnalysisT> template <typename AnalysisT>
static void getFunctionAAResultImpl(Function &F, static void getFunctionAAResultImpl(Function &F, AnalysisManager &AM,
AnalysisManager<Function> &AM,
AAResults &AAResults) { AAResults &AAResults) {
AAResults.addAAResult(AM.template getResult<AnalysisT>(F)); AAResults.addAAResult(AM.template getResult<AnalysisT>(F));
} }
template <typename AnalysisT> template <typename AnalysisT>
static void getModuleAAResultImpl(Function &F, AnalysisManager<Function> &AM, static void getModuleAAResultImpl(Function &F, AnalysisManager &AM,
AAResults &AAResults) { AAResults &AAResults) {
auto &MAM = if (auto *R = AM.template getCachedResult<AnalysisT>(*F.getParent()))
AM.getResult<ModuleAnalysisManagerFunctionProxy>(F).getManager();
if (auto *R = MAM.template getCachedResult<AnalysisT>(*F.getParent()))
AAResults.addAAResult(*R); AAResults.addAAResult(*R);
} }
}; };
/// A wrapper pass to provide the legacy pass manager access to a suitably /// A wrapper pass to provide the legacy pass manager access to a suitably
/// prepared AAResults object. /// prepared AAResults object.
class AAResultsWrapperPass : public FunctionPass { class AAResultsWrapperPass : public FunctionPass {
std::unique_ptr<AAResults> AAR; std::unique_ptr<AAResults> AAR;
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

include/llvm/Analysis/AliasAnalysisEvaluator.h

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines AAEvaluator(AAEvaluator &&Arg)
MustAliasCount(Arg.MustAliasCount), NoModRefCount(Arg.NoModRefCount), MustAliasCount(Arg.MustAliasCount), NoModRefCount(Arg.NoModRefCount),
ModCount(Arg.ModCount), RefCount(Arg.RefCount), ModCount(Arg.ModCount), RefCount(Arg.RefCount),
ModRefCount(Arg.ModRefCount) { ModRefCount(Arg.ModRefCount) {
Arg.FunctionCount = 0; Arg.FunctionCount = 0;
} }
~AAEvaluator(); ~AAEvaluator();
/// \brief Run the pass over the function. /// \brief Run the pass over the function.
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
private: private:
// Allow the legacy pass to run this using an internal API. // Allow the legacy pass to run this using an internal API.
friend class AAEvalLegacyPass; friend class AAEvalLegacyPass;
void runInternal(Function &F, AAResults &AA); void runInternal(Function &F, AAResults &AA);
}; };
/// Create a wrapper of the above for the legacy pass manager. /// Create a wrapper of the above for the legacy pass manager.
FunctionPass *createAAEvalPass(); FunctionPass *createAAEvalPass();
} }
#endif #endif

include/llvm/Analysis/AssumptionCache.h

Show First 20 Lines • Show All 100 Lines • ▼ Show 20 Linespublic:
typedef AssumptionCache Result; typedef AssumptionCache Result;
AssumptionAnalysis() {} AssumptionAnalysis() {}
AssumptionAnalysis(const AssumptionAnalysis &Arg) {} AssumptionAnalysis(const AssumptionAnalysis &Arg) {}
AssumptionAnalysis(AssumptionAnalysis &&Arg) {} AssumptionAnalysis(AssumptionAnalysis &&Arg) {}
AssumptionAnalysis &operator=(const AssumptionAnalysis &RHS) { return *this; } AssumptionAnalysis &operator=(const AssumptionAnalysis &RHS) { return *this; }
AssumptionAnalysis &operator=(AssumptionAnalysis &&RHS) { return *this; } AssumptionAnalysis &operator=(AssumptionAnalysis &&RHS) { return *this; }
AssumptionCache run(Function &F, FunctionAnalysisManager &) { AssumptionCache run(Function &F, AnalysisManager &) {
return AssumptionCache(F); return AssumptionCache(F);
} }
}; };
/// \brief Printer pass for the \c AssumptionAnalysis results. /// \brief Printer pass for the \c AssumptionAnalysis results.
class AssumptionPrinterPass : public PassInfoMixin<AssumptionPrinterPass> { class AssumptionPrinterPass : public PassInfoMixin<AssumptionPrinterPass> {
raw_ostream &OS; raw_ostream &OS;
public: public:
explicit AssumptionPrinterPass(raw_ostream &OS) : OS(OS) {} explicit AssumptionPrinterPass(raw_ostream &OS) : OS(OS) {}
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
/// \brief An immutable pass that tracks lazily created \c AssumptionCache /// \brief An immutable pass that tracks lazily created \c AssumptionCache
/// objects. /// objects.
/// ///
/// This is essentially a workaround for the legacy pass manager's weaknesses /// This is essentially a workaround for the legacy pass manager's weaknesses
/// which associates each assumption cache with Function and clears it if the /// which associates each assumption cache with Function and clears it if the
/// function is deleted. The nature of the AssumptionCache is that it is not /// function is deleted. The nature of the AssumptionCache is that it is not
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

include/llvm/Analysis/BasicAliasAnalysis.h

Show First 20 Lines • Show All 192 Lines • ▼ Show 20 Lines
/// Analysis pass providing a never-invalidated alias analysis result. /// Analysis pass providing a never-invalidated alias analysis result.
class BasicAA : public AnalysisInfoMixin<BasicAA> { class BasicAA : public AnalysisInfoMixin<BasicAA> {
friend AnalysisInfoMixin<BasicAA>; friend AnalysisInfoMixin<BasicAA>;
static char PassID; static char PassID;
public: public:
typedef BasicAAResult Result; typedef BasicAAResult Result;
BasicAAResult run(Function &F, AnalysisManager<Function> &AM); BasicAAResult run(Function &F, AnalysisManager &AM);
}; };
/// Legacy wrapper pass to provide the BasicAAResult object. /// Legacy wrapper pass to provide the BasicAAResult object.
class BasicAAWrapperPass : public FunctionPass { class BasicAAWrapperPass : public FunctionPass {
std::unique_ptr<BasicAAResult> Result; std::unique_ptr<BasicAAResult> Result;
virtual void anchor(); virtual void anchor();
Show All 21 Lines

include/llvm/Analysis/BlockFrequencyInfo.h

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Linesclass BlockFrequencyAnalysis
friend AnalysisInfoMixin<BlockFrequencyAnalysis>; friend AnalysisInfoMixin<BlockFrequencyAnalysis>;
static char PassID; static char PassID;
public: public:
/// \brief Provide the result typedef for this analysis pass. /// \brief Provide the result typedef for this analysis pass.
typedef BlockFrequencyInfo Result; typedef BlockFrequencyInfo Result;
/// \brief Run the analysis pass over a function and produce BFI. /// \brief Run the analysis pass over a function and produce BFI.
Result run(Function &F, AnalysisManager<Function> &AM); Result run(Function &F, AnalysisManager &AM);
}; };
/// \brief Printer pass for the \c BlockFrequencyInfo results. /// \brief Printer pass for the \c BlockFrequencyInfo results.
class BlockFrequencyPrinterPass class BlockFrequencyPrinterPass
: public PassInfoMixin<BlockFrequencyPrinterPass> { : public PassInfoMixin<BlockFrequencyPrinterPass> {
raw_ostream &OS; raw_ostream &OS;
public: public:
explicit BlockFrequencyPrinterPass(raw_ostream &OS) : OS(OS) {} explicit BlockFrequencyPrinterPass(raw_ostream &OS) : OS(OS) {}
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
/// \brief Legacy analysis pass which computes \c BlockFrequencyInfo. /// \brief Legacy analysis pass which computes \c BlockFrequencyInfo.
class BlockFrequencyInfoWrapperPass : public FunctionPass { class BlockFrequencyInfoWrapperPass : public FunctionPass {
BlockFrequencyInfo BFI; BlockFrequencyInfo BFI;
public: public:
static char ID; static char ID;
Show All 17 Lines

include/llvm/Analysis/BranchProbabilityInfo.h

Show First 20 Lines • Show All 179 Lines • ▼ Show 20 Linesclass BranchProbabilityAnalysis
friend AnalysisInfoMixin<BranchProbabilityAnalysis>; friend AnalysisInfoMixin<BranchProbabilityAnalysis>;
static char PassID; static char PassID;
public: public:
/// \brief Provide the result typedef for this analysis pass. /// \brief Provide the result typedef for this analysis pass.
typedef BranchProbabilityInfo Result; typedef BranchProbabilityInfo Result;
/// \brief Run the analysis pass over a function and produce BPI. /// \brief Run the analysis pass over a function and produce BPI.
BranchProbabilityInfo run(Function &F, AnalysisManager<Function> &AM); BranchProbabilityInfo run(Function &F, AnalysisManager &AM);
}; };
/// \brief Printer pass for the \c BranchProbabilityAnalysis results. /// \brief Printer pass for the \c BranchProbabilityAnalysis results.
class BranchProbabilityPrinterPass class BranchProbabilityPrinterPass
: public PassInfoMixin<BranchProbabilityPrinterPass> { : public PassInfoMixin<BranchProbabilityPrinterPass> {
raw_ostream &OS; raw_ostream &OS;
public: public:
explicit BranchProbabilityPrinterPass(raw_ostream &OS) : OS(OS) {} explicit BranchProbabilityPrinterPass(raw_ostream &OS) : OS(OS) {}
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
/// \brief Legacy analysis pass which computes \c BranchProbabilityInfo. /// \brief Legacy analysis pass which computes \c BranchProbabilityInfo.
class BranchProbabilityInfoWrapperPass : public FunctionPass { class BranchProbabilityInfoWrapperPass : public FunctionPass {
BranchProbabilityInfo BPI; BranchProbabilityInfo BPI;
public: public:
static char ID; static char ID;
Show All 18 Lines

include/llvm/Analysis/CFLAndersAliasAnalysis.h

Show First 20 Lines • Show All 102 Lines • ▼ Show 20 Lines
/// in particular to leverage invalidation to trigger re-computation. /// in particular to leverage invalidation to trigger re-computation.
class CFLAndersAA : public AnalysisInfoMixin<CFLAndersAA> { class CFLAndersAA : public AnalysisInfoMixin<CFLAndersAA> {
friend AnalysisInfoMixin<CFLAndersAA>; friend AnalysisInfoMixin<CFLAndersAA>;
static char PassID; static char PassID;
public: public:
typedef CFLAndersAAResult Result; typedef CFLAndersAAResult Result;
CFLAndersAAResult run(Function &F, AnalysisManager<Function> &AM); CFLAndersAAResult run(Function &F, AnalysisManager &AM);
}; };
/// Legacy wrapper pass to provide the CFLAndersAAResult object. /// Legacy wrapper pass to provide the CFLAndersAAResult object.
class CFLAndersAAWrapperPass : public ImmutablePass { class CFLAndersAAWrapperPass : public ImmutablePass {
std::unique_ptr<CFLAndersAAResult> Result; std::unique_ptr<CFLAndersAAResult> Result;
public: public:
static char ID; static char ID;
Show All 19 Lines

include/llvm/Analysis/CFLSteensAliasAnalysis.h

Show First 20 Lines • Show All 121 Lines • ▼ Show 20 Lines
/// in particular to leverage invalidation to trigger re-computation of sets. /// in particular to leverage invalidation to trigger re-computation of sets.
class CFLSteensAA : public AnalysisInfoMixin<CFLSteensAA> { class CFLSteensAA : public AnalysisInfoMixin<CFLSteensAA> {
friend AnalysisInfoMixin<CFLSteensAA>; friend AnalysisInfoMixin<CFLSteensAA>;
static char PassID; static char PassID;
public: public:
typedef CFLSteensAAResult Result; typedef CFLSteensAAResult Result;
CFLSteensAAResult run(Function &F, AnalysisManager<Function> &AM); CFLSteensAAResult run(Function &F, AnalysisManager &AM);
}; };
/// Legacy wrapper pass to provide the CFLSteensAAResult object. /// Legacy wrapper pass to provide the CFLSteensAAResult object.
class CFLSteensAAWrapperPass : public ImmutablePass { class CFLSteensAAWrapperPass : public ImmutablePass {
std::unique_ptr<CFLSteensAAResult> Result; std::unique_ptr<CFLSteensAAResult> Result;
public: public:
static char ID; static char ID;
Show All 19 Lines

include/llvm/Analysis/CGSCCPassManager.h

Show All 28 Lines
extern template class PassManager<LazyCallGraph::SCC>; extern template class PassManager<LazyCallGraph::SCC>;
/// \brief The CGSCC pass manager. /// \brief The CGSCC pass manager.
/// ///
/// See the documentation for the PassManager template for details. It runs /// See the documentation for the PassManager template for details. It runs
/// a sequency of SCC passes over each SCC that the manager is run over. This /// a sequency of SCC passes over each SCC that the manager is run over. This
/// typedef serves as a convenient way to refer to this construct. /// typedef serves as a convenient way to refer to this construct.
typedef PassManager<LazyCallGraph::SCC> CGSCCPassManager; typedef PassManager<LazyCallGraph::SCC> CGSCCPassManager;
extern template class AnalysisManager<LazyCallGraph::SCC>;
/// \brief The CGSCC analysis manager.
///
/// See the documentation for the AnalysisManager template for detail
/// documentation. This typedef serves as a convenient way to refer to this
/// construct in the adaptors and proxies used to integrate this into the larger
/// pass manager infrastructure.
typedef AnalysisManager<LazyCallGraph::SCC> CGSCCAnalysisManager;
extern template class InnerAnalysisManagerProxy<CGSCCAnalysisManager, Module>;
/// A proxy from a \c CGSCCAnalysisManager to a \c Module.
typedef InnerAnalysisManagerProxy<CGSCCAnalysisManager, Module>
CGSCCAnalysisManagerModuleProxy;
extern template class OuterAnalysisManagerProxy<ModuleAnalysisManager,
LazyCallGraph::SCC>;
/// A proxy from a \c ModuleAnalysisManager to an \c SCC.
typedef OuterAnalysisManagerProxy<ModuleAnalysisManager, LazyCallGraph::SCC>
ModuleAnalysisManagerCGSCCProxy;
/// \brief The core module pass which does a post-order walk of the SCCs and /// \brief The core module pass which does a post-order walk of the SCCs and
/// runs a CGSCC pass over each one. /// runs a CGSCC pass over each one.
/// ///
/// Designed to allow composition of a CGSCCPass(Manager) and /// Designed to allow composition of a CGSCCPass(Manager) and
/// a ModulePassManager. Note that this pass must be run with a module analysis /// a ModulePassManager.
/// manager as it uses the LazyCallGraph analysis. It will also run the
/// \c CGSCCAnalysisManagerModuleProxy analysis prior to running the CGSCC
/// pass over the module to enable a \c FunctionAnalysisManager to be used
/// within this run safely.
template <typename CGSCCPassT> template <typename CGSCCPassT>
class ModuleToPostOrderCGSCCPassAdaptor class ModuleToPostOrderCGSCCPassAdaptor
: public PassInfoMixin<ModuleToPostOrderCGSCCPassAdaptor<CGSCCPassT>> { : public PassInfoMixin<ModuleToPostOrderCGSCCPassAdaptor<CGSCCPassT>> {
public: public:
explicit ModuleToPostOrderCGSCCPassAdaptor(CGSCCPassT Pass, bool DebugLogging = false) explicit ModuleToPostOrderCGSCCPassAdaptor(CGSCCPassT Pass, bool DebugLogging = false)
: Pass(std::move(Pass)), DebugLogging(DebugLogging) {} : Pass(std::move(Pass)), DebugLogging(DebugLogging) {}
// We have to explicitly define all the special member functions because MSVC // We have to explicitly define all the special member functions because MSVC
// refuses to generate them. // refuses to generate them.
Show All 10 Linespublic:
} }
ModuleToPostOrderCGSCCPassAdaptor & ModuleToPostOrderCGSCCPassAdaptor &
operator=(ModuleToPostOrderCGSCCPassAdaptor RHS) { operator=(ModuleToPostOrderCGSCCPassAdaptor RHS) {
swap(*this, RHS); swap(*this, RHS);
return *this; return *this;
} }
/// \brief Runs the CGSCC pass across every SCC in the module. /// \brief Runs the CGSCC pass across every SCC in the module.
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM) { PreservedAnalyses run(Module &M, AnalysisManager &AM) {
// Setup the CGSCC analysis manager from its proxy.
CGSCCAnalysisManager &CGAM =
AM.getResult<CGSCCAnalysisManagerModuleProxy>(M).getManager();
// Get the call graph for this module. // Get the call graph for this module.
LazyCallGraph &CG = AM.getResult<LazyCallGraphAnalysis>(M); LazyCallGraph &CG = AM.getResult<LazyCallGraphAnalysis>(M);
PreservedAnalyses PA = PreservedAnalyses::all(); PreservedAnalyses PA = PreservedAnalyses::all();
for (LazyCallGraph::RefSCC &RC : CG.postorder_ref_sccs()) { for (LazyCallGraph::RefSCC &RC : CG.postorder_ref_sccs()) {
if (DebugLogging) if (DebugLogging)
dbgs() << "Running an SCC pass across the RefSCC: " << RC << "\n"; dbgs() << "Running an SCC pass across the RefSCC: " << RC << "\n";
for (LazyCallGraph::SCC &C : RC) { for (LazyCallGraph::SCC &C : RC) {
PreservedAnalyses PassPA = Pass.run(C, CGAM); PreservedAnalyses PassPA = Pass.run(C, AM);
// We know that the CGSCC pass couldn't have invalidated any other // We know that the CGSCC pass couldn't have invalidated any other
// SCC's analyses (that's the contract of a CGSCC pass), so // SCC's analyses (that's the contract of a CGSCC pass), so
// directly handle the CGSCC analysis manager's invalidation here. We // directly handle the CGSCC analysis manager's invalidation here. We
// also update the preserved set of analyses to reflect that invalidated // also update the preserved set of analyses to reflect that invalidated
// analyses are now safe to preserve. // analyses are now safe to preserve.
// FIXME: This isn't quite correct. We need to handle the case where the // FIXME: This isn't quite correct. We need to handle the case where the
// pass updated the CG, particularly some child of the current SCC, and // pass updated the CG, particularly some child of the current SCC, and
// invalidate its analyses. // invalidate its analyses.
PassPA = CGAM.invalidate(C, std::move(PassPA)); PassPA = AM.invalidate(C, std::move(PassPA));
// Then intersect the preserved set so that invalidation of module // Then intersect the preserved set so that invalidation of module
// analyses will eventually occur when the module pass completes. // analyses will eventually occur when the module pass completes.
PA.intersect(std::move(PassPA)); PA.intersect(std::move(PassPA));
} }
} }
// By definition we preserve the proxy. This precludes *any* invalidation
// of CGSCC analyses by the proxy, but that's OK because we've taken
// care to invalidate analyses in the CGSCC analysis manager
// incrementally above.
PA.preserve<CGSCCAnalysisManagerModuleProxy>();
return PA; return PA;
} }
private: private:
CGSCCPassT Pass; CGSCCPassT Pass;
bool DebugLogging; bool DebugLogging;
}; };
/// \brief A function to deduce a function pass type and wrap it in the /// \brief A function to deduce a function pass type and wrap it in the
/// templated adaptor. /// templated adaptor.
template <typename CGSCCPassT> template <typename CGSCCPassT>
ModuleToPostOrderCGSCCPassAdaptor<CGSCCPassT> ModuleToPostOrderCGSCCPassAdaptor<CGSCCPassT>
createModuleToPostOrderCGSCCPassAdaptor(CGSCCPassT Pass, bool DebugLogging = false) { createModuleToPostOrderCGSCCPassAdaptor(CGSCCPassT Pass, bool DebugLogging = false) {
return ModuleToPostOrderCGSCCPassAdaptor<CGSCCPassT>(std::move(Pass), DebugLogging); return ModuleToPostOrderCGSCCPassAdaptor<CGSCCPassT>(std::move(Pass), DebugLogging);
} }
extern template class InnerAnalysisManagerProxy<FunctionAnalysisManager,
LazyCallGraph::SCC>;
/// A proxy from a \c FunctionAnalysisManager to an \c SCC.
typedef InnerAnalysisManagerProxy<FunctionAnalysisManager, LazyCallGraph::SCC>
FunctionAnalysisManagerCGSCCProxy;
extern template class OuterAnalysisManagerProxy<CGSCCAnalysisManager, Function>;
/// A proxy from a \c CGSCCAnalysisManager to a \c Function.
typedef OuterAnalysisManagerProxy<CGSCCAnalysisManager, Function>
CGSCCAnalysisManagerFunctionProxy;
/// \brief Adaptor that maps from a SCC to its functions. /// \brief Adaptor that maps from a SCC to its functions.
/// ///
/// Designed to allow composition of a FunctionPass(Manager) and /// Designed to allow composition of a FunctionPass(Manager) and
/// a CGSCCPassManager. Note that if this pass is constructed with a pointer /// a CGSCCPassManager.
/// to a \c CGSCCAnalysisManager it will run the
/// \c FunctionAnalysisManagerCGSCCProxy analysis prior to running the function
/// pass over the SCC to enable a \c FunctionAnalysisManager to be used
/// within this run safely.
template <typename FunctionPassT> template <typename FunctionPassT>
class CGSCCToFunctionPassAdaptor class CGSCCToFunctionPassAdaptor
: public PassInfoMixin<CGSCCToFunctionPassAdaptor<FunctionPassT>> { : public PassInfoMixin<CGSCCToFunctionPassAdaptor<FunctionPassT>> {
public: public:
explicit CGSCCToFunctionPassAdaptor(FunctionPassT Pass, bool DebugLogging = false) explicit CGSCCToFunctionPassAdaptor(FunctionPassT Pass, bool DebugLogging = false)
: Pass(std::move(Pass)), DebugLogging(DebugLogging) {} : Pass(std::move(Pass)), DebugLogging(DebugLogging) {}
// We have to explicitly define all the special member functions because MSVC // We have to explicitly define all the special member functions because MSVC
// refuses to generate them. // refuses to generate them.
CGSCCToFunctionPassAdaptor(const CGSCCToFunctionPassAdaptor &Arg) CGSCCToFunctionPassAdaptor(const CGSCCToFunctionPassAdaptor &Arg)
: Pass(Arg.Pass), DebugLogging(Arg.DebugLogging) {} : Pass(Arg.Pass), DebugLogging(Arg.DebugLogging) {}
CGSCCToFunctionPassAdaptor(CGSCCToFunctionPassAdaptor &&Arg) CGSCCToFunctionPassAdaptor(CGSCCToFunctionPassAdaptor &&Arg)
: Pass(std::move(Arg.Pass)), DebugLogging(Arg.DebugLogging) {} : Pass(std::move(Arg.Pass)), DebugLogging(Arg.DebugLogging) {}
friend void swap(CGSCCToFunctionPassAdaptor &LHS, friend void swap(CGSCCToFunctionPassAdaptor &LHS,
CGSCCToFunctionPassAdaptor &RHS) { CGSCCToFunctionPassAdaptor &RHS) {
using std::swap; using std::swap;
swap(LHS.Pass, RHS.Pass); swap(LHS.Pass, RHS.Pass);
swap(LHS.DebugLogging, RHS.DebugLogging); swap(LHS.DebugLogging, RHS.DebugLogging);
} }
CGSCCToFunctionPassAdaptor &operator=(CGSCCToFunctionPassAdaptor RHS) { CGSCCToFunctionPassAdaptor &operator=(CGSCCToFunctionPassAdaptor RHS) {
swap(*this, RHS); swap(*this, RHS);
return *this; return *this;
} }
/// \brief Runs the function pass across every function in the module. /// \brief Runs the function pass across every function in the module.
PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM) { PreservedAnalyses run(LazyCallGraph::SCC &C, AnalysisManager &AM) {
// Setup the function analysis manager from its proxy.
FunctionAnalysisManager &FAM =
AM.getResult<FunctionAnalysisManagerCGSCCProxy>(C).getManager();
if (DebugLogging) if (DebugLogging)
dbgs() << "Running function passes across an SCC: " << C << "\n"; dbgs() << "Running function passes across an SCC: " << C << "\n";
PreservedAnalyses PA = PreservedAnalyses::all(); PreservedAnalyses PA = PreservedAnalyses::all();
for (LazyCallGraph::Node &N : C) { for (LazyCallGraph::Node &N : C) {
PreservedAnalyses PassPA = Pass.run(N.getFunction(), FAM); PreservedAnalyses PassPA = Pass.run(N.getFunction(), AM);
// We know that the function pass couldn't have invalidated any other // We know that the function pass couldn't have invalidated any other
// function's analyses (that's the contract of a function pass), so // function's analyses (that's the contract of a function pass), so
// directly handle the function analysis manager's invalidation here. // directly handle the function analysis manager's invalidation here.
// Also, update the preserved analyses to reflect that once invalidated // Also, update the preserved analyses to reflect that once invalidated
// these can again be preserved. // these can again be preserved.
PassPA = FAM.invalidate(N.getFunction(), std::move(PassPA)); PassPA = AM.invalidate(N.getFunction(), std::move(PassPA));
// Then intersect the preserved set so that invalidation of module // Then intersect the preserved set so that invalidation of module
// analyses will eventually occur when the module pass completes. // analyses will eventually occur when the module pass completes.
PA.intersect(std::move(PassPA)); PA.intersect(std::move(PassPA));
} }
// By definition we preserve the proxy. This precludes *any* invalidation
// of function analyses by the proxy, but that's OK because we've taken
// care to invalidate analyses in the function analysis manager
// incrementally above.
// FIXME: We need to update the call graph here to account for any deleted // FIXME: We need to update the call graph here to account for any deleted
// edges! // edges!
PA.preserve<FunctionAnalysisManagerCGSCCProxy>();
return PA; return PA;
} }
private: private:
FunctionPassT Pass; FunctionPassT Pass;
bool DebugLogging; bool DebugLogging;
}; };
static inline IRUnitKind getIRUnitKindID(LazyCallGraph::SCC *) {
return IRK_CGSCC;
}
static inline Module *getStaticParentIRUnit(LazyCallGraph::SCC &C) {
assert(C.size() != 0 && "Empty SCC?");
return C.begin()->getFunction().getParent();
}
extern template struct ParentIRUnitTrackingAnalysis<LazyCallGraph::SCC>;
/// \brief A function to deduce a function pass type and wrap it in the /// \brief A function to deduce a function pass type and wrap it in the
/// templated adaptor. /// templated adaptor.
template <typename FunctionPassT> template <typename FunctionPassT>
CGSCCToFunctionPassAdaptor<FunctionPassT> CGSCCToFunctionPassAdaptor<FunctionPassT>
createCGSCCToFunctionPassAdaptor(FunctionPassT Pass, bool DebugLogging = false) { createCGSCCToFunctionPassAdaptor(FunctionPassT Pass, bool DebugLogging = false) {
return CGSCCToFunctionPassAdaptor<FunctionPassT>(std::move(Pass), return CGSCCToFunctionPassAdaptor<FunctionPassT>(std::move(Pass),
DebugLogging); DebugLogging);
} }
} }
#endif #endif

include/llvm/Analysis/CallGraph.h

Show First 20 Lines • Show All 285 Lines • ▼ Show 20 Linesprivate:
void DropRef() { --NumReferences; } void DropRef() { --NumReferences; }
void AddRef() { ++NumReferences; } void AddRef() { ++NumReferences; }
/// \brief A special function that should only be used by the CallGraph class. /// \brief A special function that should only be used by the CallGraph class.
void allReferencesDropped() { NumReferences = 0; } void allReferencesDropped() { NumReferences = 0; }
}; };
/// \brief An analysis pass to compute the \c CallGraph for a \c Module. /// \brief An analysis pass to compute the \c CallGraph for a \c Module.
///
/// This class implements the concept of an analysis pass used by the \c
/// ModuleAnalysisManager to run an analysis over a module and cache the
/// resulting data.
class CallGraphAnalysis : public AnalysisInfoMixin<CallGraphAnalysis> { class CallGraphAnalysis : public AnalysisInfoMixin<CallGraphAnalysis> {
friend AnalysisInfoMixin<CallGraphAnalysis>; friend AnalysisInfoMixin<CallGraphAnalysis>;
static char PassID; static char PassID;
public: public:
/// \brief A formulaic typedef to inform clients of the result type. /// \brief A formulaic typedef to inform clients of the result type.
typedef CallGraph Result; typedef CallGraph Result;
/// \brief Compute the \c CallGraph for the module \c M. /// \brief Compute the \c CallGraph for the module \c M.
/// ///
/// The real work here is done in the \c CallGraph constructor. /// The real work here is done in the \c CallGraph constructor.
CallGraph run(Module &M, ModuleAnalysisManager &) { return CallGraph(M); } CallGraph run(Module &M, AnalysisManager &) { return CallGraph(M); }
}; };
/// \brief Printer pass for the \c CallGraphAnalysis results. /// \brief Printer pass for the \c CallGraphAnalysis results.
class CallGraphPrinterPass : public PassInfoMixin<CallGraphPrinterPass> { class CallGraphPrinterPass : public PassInfoMixin<CallGraphPrinterPass> {
raw_ostream &OS; raw_ostream &OS;
public: public:
explicit CallGraphPrinterPass(raw_ostream &OS) : OS(OS) {} explicit CallGraphPrinterPass(raw_ostream &OS) : OS(OS) {}
PreservedAnalyses run(Module &M, AnalysisManager<Module> &AM); PreservedAnalyses run(Module &M, AnalysisManager &AM);
}; };
/// \brief The \c ModulePass which wraps up a \c CallGraph and the logic to /// \brief The \c ModulePass which wraps up a \c CallGraph and the logic to
/// build it. /// build it.
/// ///
/// This class exposes both the interface to the call graph container and the /// This class exposes both the interface to the call graph container and the
/// module pass which runs over a module of IR and produces the call graph. The /// module pass which runs over a module of IR and produces the call graph. The
/// call graph interface is entirelly a wrapper around a \c CallGraph object /// call graph interface is entirelly a wrapper around a \c CallGraph object
▲ Show 20 Lines • Show All 179 Lines • Show Last 20 Lines

include/llvm/Analysis/DemandedBits.h

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Linesclass DemandedBitsAnalysis : public AnalysisInfoMixin<DemandedBitsAnalysis> {
static char PassID; static char PassID;
public: public:
/// \brief Provide the result typedef for this analysis pass. /// \brief Provide the result typedef for this analysis pass.
typedef DemandedBits Result; typedef DemandedBits Result;
/// \brief Run the analysis pass over a function and produce demanded bits /// \brief Run the analysis pass over a function and produce demanded bits
/// information. /// information.
DemandedBits run(Function &F, AnalysisManager<Function> &AM); DemandedBits run(Function &F, AnalysisManager &AM);
}; };
/// \brief Printer pass for DemandedBits /// \brief Printer pass for DemandedBits
class DemandedBitsPrinterPass : public PassInfoMixin<DemandedBitsPrinterPass> { class DemandedBitsPrinterPass : public PassInfoMixin<DemandedBitsPrinterPass> {
raw_ostream &OS; raw_ostream &OS;
public: public:
explicit DemandedBitsPrinterPass(raw_ostream &OS) : OS(OS) {} explicit DemandedBitsPrinterPass(raw_ostream &OS) : OS(OS) {}
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
/// Create a demanded bits analysis pass. /// Create a demanded bits analysis pass.
FunctionPass *createDemandedBitsWrapperPass(); FunctionPass *createDemandedBitsWrapperPass();
} // End llvm namespace } // End llvm namespace
#endif #endif

include/llvm/Analysis/DependenceAnalysis.h

Show First 20 Lines • Show All 922 Lines • ▼ Show 20 Lines private:
bool tryDelinearize(Instruction *Src, Instruction *Dst, bool tryDelinearize(Instruction *Src, Instruction *Dst,
SmallVectorImpl<Subscript> &Pair); SmallVectorImpl<Subscript> &Pair);
}; // class DependenceInfo }; // class DependenceInfo
/// \brief AnalysisPass to compute dependence information in a function /// \brief AnalysisPass to compute dependence information in a function
class DependenceAnalysis : public AnalysisInfoMixin<DependenceAnalysis> { class DependenceAnalysis : public AnalysisInfoMixin<DependenceAnalysis> {
public: public:
typedef DependenceInfo Result; typedef DependenceInfo Result;
Result run(Function &F, FunctionAnalysisManager &FAM); Result run(Function &F, AnalysisManager &AM);
private: private:
static char PassID; static char PassID;
friend struct AnalysisInfoMixin<DependenceAnalysis>; friend struct AnalysisInfoMixin<DependenceAnalysis>;
}; // class DependenceAnalysis }; // class DependenceAnalysis
/// \brief Legacy pass manager pass to access dependence information /// \brief Legacy pass manager pass to access dependence information
class DependenceAnalysisWrapperPass : public FunctionPass { class DependenceAnalysisWrapperPass : public FunctionPass {
Show All 24 Lines

include/llvm/Analysis/DominanceFrontier.h

Show First 20 Lines • Show All 172 Lines • ▼ Show 20 Linesclass DominanceFrontierAnalysis
friend AnalysisInfoMixin<DominanceFrontierAnalysis>; friend AnalysisInfoMixin<DominanceFrontierAnalysis>;
static char PassID; static char PassID;
public: public:
/// \brief Provide the result typedef for this analysis pass. /// \brief Provide the result typedef for this analysis pass.
typedef DominanceFrontier Result; typedef DominanceFrontier Result;
/// \brief Run the analysis pass over a function and produce a dominator tree. /// \brief Run the analysis pass over a function and produce a dominator tree.
DominanceFrontier run(Function &F, AnalysisManager<Function> &AM); DominanceFrontier run(Function &F, AnalysisManager &AM);
}; };
/// \brief Printer pass for the \c DominanceFrontier. /// \brief Printer pass for the \c DominanceFrontier.
class DominanceFrontierPrinterPass class DominanceFrontierPrinterPass
: public PassInfoMixin<DominanceFrontierPrinterPass> { : public PassInfoMixin<DominanceFrontierPrinterPass> {
raw_ostream &OS; raw_ostream &OS;
public: public:
explicit DominanceFrontierPrinterPass(raw_ostream &OS); explicit DominanceFrontierPrinterPass(raw_ostream &OS);
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
} // End llvm namespace } // End llvm namespace
#endif #endif

include/llvm/Analysis/GlobalsModRef.h

Show First 20 Lines • Show All 119 Lines • ▼ Show 20 Lines
/// Analysis pass providing a never-invalidated alias analysis result. /// Analysis pass providing a never-invalidated alias analysis result.
class GlobalsAA : public AnalysisInfoMixin<GlobalsAA> { class GlobalsAA : public AnalysisInfoMixin<GlobalsAA> {
friend AnalysisInfoMixin<GlobalsAA>; friend AnalysisInfoMixin<GlobalsAA>;
static char PassID; static char PassID;
public: public:
typedef GlobalsAAResult Result; typedef GlobalsAAResult Result;
GlobalsAAResult run(Module &M, AnalysisManager<Module> &AM); GlobalsAAResult run(Module &M, AnalysisManager &AM);
}; };
/// Legacy wrapper pass to provide the GlobalsAAResult object. /// Legacy wrapper pass to provide the GlobalsAAResult object.
class GlobalsAAWrapperPass : public ModulePass { class GlobalsAAWrapperPass : public ModulePass {
std::unique_ptr<GlobalsAAResult> Result; std::unique_ptr<GlobalsAAResult> Result;
public: public:
static char ID; static char ID;
Show All 20 Lines

include/llvm/Analysis/IVUsers.h

Show First 20 Lines • Show All 202 Lines • ▼ Show 20 Lines
/// Analysis pass that exposes the \c IVUsers for a loop. /// Analysis pass that exposes the \c IVUsers for a loop.
class IVUsersAnalysis : public AnalysisInfoMixin<IVUsersAnalysis> { class IVUsersAnalysis : public AnalysisInfoMixin<IVUsersAnalysis> {
friend AnalysisInfoMixin<IVUsersAnalysis>; friend AnalysisInfoMixin<IVUsersAnalysis>;
static char PassID; static char PassID;
public: public:
typedef IVUsers Result; typedef IVUsers Result;
IVUsers run(Loop &L, AnalysisManager<Loop> &AM); IVUsers run(Loop &L, AnalysisManager &AM);
}; };
/// Printer pass for the \c IVUsers for a loop. /// Printer pass for the \c IVUsers for a loop.
class IVUsersPrinterPass : public PassInfoMixin<IVUsersPrinterPass> { class IVUsersPrinterPass : public PassInfoMixin<IVUsersPrinterPass> {
raw_ostream &OS; raw_ostream &OS;
public: public:
explicit IVUsersPrinterPass(raw_ostream &OS) : OS(OS) {} explicit IVUsersPrinterPass(raw_ostream &OS) : OS(OS) {}
PreservedAnalyses run(Loop &L, AnalysisManager<Loop> &AM); PreservedAnalyses run(Loop &L, AnalysisManager &AM);
}; };
} }
#endif #endif

include/llvm/Analysis/LazyCallGraph.h

Show First 20 Lines • Show All 976 Lines • ▼ Show 20 Lines
public: public:
/// Inform generic clients of the result type. /// Inform generic clients of the result type.
typedef LazyCallGraph Result; typedef LazyCallGraph Result;
/// Compute the \c LazyCallGraph for the module \c M. /// Compute the \c LazyCallGraph for the module \c M.
/// ///
/// This just builds the set of entry points to the call graph. The rest is /// This just builds the set of entry points to the call graph. The rest is
/// built lazily as it is walked. /// built lazily as it is walked.
LazyCallGraph run(Module &M, ModuleAnalysisManager &) { LazyCallGraph run(Module &M, AnalysisManager &) {
return LazyCallGraph(M); return LazyCallGraph(M);
} }
}; };
/// A pass which prints the call graph to a \c raw_ostream. /// A pass which prints the call graph to a \c raw_ostream.
/// ///
/// This is primarily useful for testing the analysis. /// This is primarily useful for testing the analysis.
class LazyCallGraphPrinterPass class LazyCallGraphPrinterPass
: public PassInfoMixin<LazyCallGraphPrinterPass> { : public PassInfoMixin<LazyCallGraphPrinterPass> {
raw_ostream &OS; raw_ostream &OS;
public: public:
explicit LazyCallGraphPrinterPass(raw_ostream &OS); explicit LazyCallGraphPrinterPass(raw_ostream &OS);
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM); PreservedAnalyses run(Module &M, AnalysisManager &AM);
}; };
/// A pass which prints the call graph as a DOT file to a \c raw_ostream. /// A pass which prints the call graph as a DOT file to a \c raw_ostream.
/// ///
/// This is primarily useful for visualization purposes. /// This is primarily useful for visualization purposes.
class LazyCallGraphDOTPrinterPass class LazyCallGraphDOTPrinterPass
: public PassInfoMixin<LazyCallGraphDOTPrinterPass> { : public PassInfoMixin<LazyCallGraphDOTPrinterPass> {
raw_ostream &OS; raw_ostream &OS;
public: public:
explicit LazyCallGraphDOTPrinterPass(raw_ostream &OS); explicit LazyCallGraphDOTPrinterPass(raw_ostream &OS);
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM); PreservedAnalyses run(Module &M, AnalysisManager &AM);
}; };
} }
#endif #endif

include/llvm/Analysis/LazyValueInfo.h

Show First 20 Lines • Show All 100 Lines • ▼ Show 20 Linespublic:
// For old PM pass. Delete once LazyValueInfoWrapperPass is gone. // For old PM pass. Delete once LazyValueInfoWrapperPass is gone.
void releaseMemory(); void releaseMemory();
}; };
/// \brief Analysis to compute lazy value information. /// \brief Analysis to compute lazy value information.
class LazyValueAnalysis : public AnalysisInfoMixin<LazyValueAnalysis> { class LazyValueAnalysis : public AnalysisInfoMixin<LazyValueAnalysis> {
public: public:
typedef LazyValueInfo Result; typedef LazyValueInfo Result;
Result run(Function &F, FunctionAnalysisManager &FAM); Result run(Function &F, AnalysisManager &AM);
private: private:
static char PassID; static char PassID;
friend struct AnalysisInfoMixin<LazyValueAnalysis>; friend struct AnalysisInfoMixin<LazyValueAnalysis>;
}; };
/// Wrapper around LazyValueInfo. /// Wrapper around LazyValueInfo.
class LazyValueInfoWrapperPass : public FunctionPass { class LazyValueInfoWrapperPass : public FunctionPass {
Show All 24 Lines

include/llvm/Analysis/LoopAccessAnalysis.h

Show First 20 Lines • Show All 769 Lines • ▼ Show 20 Lines
/// specifics of what information is provided. /// specifics of what information is provided.
class LoopAccessAnalysis class LoopAccessAnalysis
: public AnalysisInfoMixin<LoopAccessAnalysis> { : public AnalysisInfoMixin<LoopAccessAnalysis> {
friend AnalysisInfoMixin<LoopAccessAnalysis>; friend AnalysisInfoMixin<LoopAccessAnalysis>;
static char PassID; static char PassID;
public: public:
typedef LoopAccessInfo Result; typedef LoopAccessInfo Result;
Result run(Loop &, AnalysisManager<Loop> &); Result run(Loop &, AnalysisManager &);
static StringRef name() { return "LoopAccessAnalysis"; } static StringRef name() { return "LoopAccessAnalysis"; }
}; };
/// \brief Printer pass for the \c LoopAccessInfo results. /// \brief Printer pass for the \c LoopAccessInfo results.
class LoopAccessInfoPrinterPass class LoopAccessInfoPrinterPass
: public PassInfoMixin<LoopAccessInfoPrinterPass> { : public PassInfoMixin<LoopAccessInfoPrinterPass> {
raw_ostream &OS; raw_ostream &OS;
public: public:
explicit LoopAccessInfoPrinterPass(raw_ostream &OS) : OS(OS) {} explicit LoopAccessInfoPrinterPass(raw_ostream &OS) : OS(OS) {}
PreservedAnalyses run(Loop &L, AnalysisManager<Loop> &AM); PreservedAnalyses run(Loop &L, AnalysisManager &AM);
}; };
inline Instruction *MemoryDepChecker::Dependence::getSource( inline Instruction *MemoryDepChecker::Dependence::getSource(
const LoopAccessInfo &LAI) const { const LoopAccessInfo &LAI) const {
return LAI.getDepChecker().getMemoryInstructions()[Source]; return LAI.getDepChecker().getMemoryInstructions()[Source];
} }
inline Instruction *MemoryDepChecker::Dependence::getDestination( inline Instruction *MemoryDepChecker::Dependence::getDestination(
const LoopAccessInfo &LAI) const { const LoopAccessInfo &LAI) const {
return LAI.getDepChecker().getMemoryInstructions()[Destination]; return LAI.getDepChecker().getMemoryInstructions()[Destination];
} }
} // End llvm namespace } // End llvm namespace
#endif #endif

include/llvm/Analysis/LoopInfo.h

Show First 20 Lines • Show All 788 Lines • ▼ Show 20 Lines
/// \brief Analysis pass that exposes the \c LoopInfo for a function. /// \brief Analysis pass that exposes the \c LoopInfo for a function.
class LoopAnalysis : public AnalysisInfoMixin<LoopAnalysis> { class LoopAnalysis : public AnalysisInfoMixin<LoopAnalysis> {
friend AnalysisInfoMixin<LoopAnalysis>; friend AnalysisInfoMixin<LoopAnalysis>;
static char PassID; static char PassID;
public: public:
typedef LoopInfo Result; typedef LoopInfo Result;
LoopInfo run(Function &F, AnalysisManager<Function> &AM); LoopInfo run(Function &F, AnalysisManager &AM);
}; };
/// \brief Printer pass for the \c LoopAnalysis results. /// \brief Printer pass for the \c LoopAnalysis results.
class LoopPrinterPass : public PassInfoMixin<LoopPrinterPass> { class LoopPrinterPass : public PassInfoMixin<LoopPrinterPass> {
raw_ostream &OS; raw_ostream &OS;
public: public:
explicit LoopPrinterPass(raw_ostream &OS) : OS(OS) {} explicit LoopPrinterPass(raw_ostream &OS) : OS(OS) {}
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
/// \brief Verifier pass for the \c LoopAnalysis results. /// \brief Verifier pass for the \c LoopAnalysis results.
struct LoopVerifierPass : public PassInfoMixin<LoopVerifierPass> { struct LoopVerifierPass : public PassInfoMixin<LoopVerifierPass> {
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
/// \brief The legacy pass manager's analysis pass to compute loop information. /// \brief The legacy pass manager's analysis pass to compute loop information.
class LoopInfoWrapperPass : public FunctionPass { class LoopInfoWrapperPass : public FunctionPass {
LoopInfo LI; LoopInfo LI;
public: public:
static char ID; // Pass identification, replacement for typeid static char ID; // Pass identification, replacement for typeid
Show All 21 Lines
class PrintLoopPass : public PassInfoMixin<PrintLoopPass> { class PrintLoopPass : public PassInfoMixin<PrintLoopPass> {
raw_ostream &OS; raw_ostream &OS;
std::string Banner; std::string Banner;
public: public:
PrintLoopPass(); PrintLoopPass();
PrintLoopPass(raw_ostream &OS, const std::string &Banner = ""); PrintLoopPass(raw_ostream &OS, const std::string &Banner = "");
PreservedAnalyses run(Loop &L, AnalysisManager<Loop> &); PreservedAnalyses run(Loop &L, AnalysisManager &);
}; };
} // End llvm namespace } // End llvm namespace
#endif #endif

include/llvm/Analysis/LoopPassManager.h

Show All 23 Lines
extern template class PassManager<Loop>; extern template class PassManager<Loop>;
/// \brief The loop pass manager. /// \brief The loop pass manager.
/// ///
/// See the documentation for the PassManager template for details. It runs a /// See the documentation for the PassManager template for details. It runs a
/// sequency of loop passes over each loop that the manager is run over. This /// sequency of loop passes over each loop that the manager is run over. This
/// typedef serves as a convenient way to refer to this construct. /// typedef serves as a convenient way to refer to this construct.
typedef PassManager<Loop> LoopPassManager; typedef PassManager<Loop> LoopPassManager;
extern template class AnalysisManager<Loop>;
/// \brief The loop analysis manager.
///
/// See the documentation for the AnalysisManager template for detail
/// documentation. This typedef serves as a convenient way to refer to this
/// construct in the adaptors and proxies used to integrate this into the larger
/// pass manager infrastructure.
typedef AnalysisManager<Loop> LoopAnalysisManager;
extern template class InnerAnalysisManagerProxy<LoopAnalysisManager, Function>;
/// A proxy from a \c LoopAnalysisManager to a \c Function.
typedef InnerAnalysisManagerProxy<LoopAnalysisManager, Function>
LoopAnalysisManagerFunctionProxy;
extern template class OuterAnalysisManagerProxy<FunctionAnalysisManager, Loop>;
/// A proxy from a \c FunctionAnalysisManager to a \c Loop.
typedef OuterAnalysisManagerProxy<FunctionAnalysisManager, Loop>
FunctionAnalysisManagerLoopProxy;
/// Returns the minimum set of Analyses that all loop passes must preserve. /// Returns the minimum set of Analyses that all loop passes must preserve.
PreservedAnalyses getLoopPassPreservedAnalyses(); PreservedAnalyses getLoopPassPreservedAnalyses();
/// \brief Adaptor that maps from a function to its loops. /// \brief Adaptor that maps from a function to its loops.
/// ///
/// Designed to allow composition of a LoopPass(Manager) and a /// Designed to allow composition of a LoopPass(Manager) and a
/// FunctionPassManager. Note that if this pass is constructed with a \c /// FunctionPassManager.
/// FunctionAnalysisManager it will run the \c LoopAnalysisManagerFunctionProxy
/// analysis prior to running the loop passes over the function to enable a \c
/// LoopAnalysisManager to be used within this run safely.
template <typename LoopPassT> template <typename LoopPassT>
class FunctionToLoopPassAdaptor class FunctionToLoopPassAdaptor
: public PassInfoMixin<FunctionToLoopPassAdaptor<LoopPassT>> { : public PassInfoMixin<FunctionToLoopPassAdaptor<LoopPassT>> {
public: public:
explicit FunctionToLoopPassAdaptor(LoopPassT Pass) explicit FunctionToLoopPassAdaptor(LoopPassT Pass)
: Pass(std::move(Pass)) {} : Pass(std::move(Pass)) {}
// We have to explicitly define all the special member functions because MSVC // We have to explicitly define all the special member functions because MSVC
// refuses to generate them. // refuses to generate them.
FunctionToLoopPassAdaptor(const FunctionToLoopPassAdaptor &Arg) FunctionToLoopPassAdaptor(const FunctionToLoopPassAdaptor &Arg)
: Pass(Arg.Pass) {} : Pass(Arg.Pass) {}
FunctionToLoopPassAdaptor(FunctionToLoopPassAdaptor &&Arg) FunctionToLoopPassAdaptor(FunctionToLoopPassAdaptor &&Arg)
: Pass(std::move(Arg.Pass)) {} : Pass(std::move(Arg.Pass)) {}
friend void swap(FunctionToLoopPassAdaptor &LHS, friend void swap(FunctionToLoopPassAdaptor &LHS,
FunctionToLoopPassAdaptor &RHS) { FunctionToLoopPassAdaptor &RHS) {
using std::swap; using std::swap;
swap(LHS.Pass, RHS.Pass); swap(LHS.Pass, RHS.Pass);
} }
FunctionToLoopPassAdaptor &operator=(FunctionToLoopPassAdaptor RHS) { FunctionToLoopPassAdaptor &operator=(FunctionToLoopPassAdaptor RHS) {
swap(*this, RHS); swap(*this, RHS);
return *this; return *this;
} }
/// \brief Runs the loop passes across every loop in the function. /// \brief Runs the loop passes across every loop in the function.
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM) { PreservedAnalyses run(Function &F, AnalysisManager &AM) {
// Setup the loop analysis manager from its proxy.
LoopAnalysisManager &LAM =
AM.getResult<LoopAnalysisManagerFunctionProxy>(F).getManager();
// Get the loop structure for this function // Get the loop structure for this function
LoopInfo &LI = AM.getResult<LoopAnalysis>(F); LoopInfo &LI = AM.getResult<LoopAnalysis>(F);
PreservedAnalyses PA = PreservedAnalyses::all(); PreservedAnalyses PA = PreservedAnalyses::all();
// We want to visit the loops in reverse post-order. We'll build the stack // We want to visit the loops in reverse post-order. We'll build the stack
// of loops to visit in Loops by first walking the loops in pre-order. // of loops to visit in Loops by first walking the loops in pre-order.
SmallVector<Loop *, 2> Loops; SmallVector<Loop *, 2> Loops;
SmallVector<Loop *, 2> WorkList(LI.begin(), LI.end()); SmallVector<Loop *, 2> WorkList(LI.begin(), LI.end());
while (!WorkList.empty()) { while (!WorkList.empty()) {
Loop *L = WorkList.pop_back_val(); Loop *L = WorkList.pop_back_val();
WorkList.insert(WorkList.end(), L->begin(), L->end()); WorkList.insert(WorkList.end(), L->begin(), L->end());
Loops.push_back(L); Loops.push_back(L);
} }
// Now pop each element off of the stack to visit the loops in reverse // Now pop each element off of the stack to visit the loops in reverse
// post-order. // post-order.
for (auto *L : reverse(Loops)) { for (auto *L : reverse(Loops)) {
PreservedAnalyses PassPA = Pass.run(*L, LAM); PreservedAnalyses PassPA = Pass.run(*L, AM);
assert(PassPA.preserved(getLoopPassPreservedAnalyses()) && assert(PassPA.preserved(getLoopPassPreservedAnalyses()) &&
"Loop passes must preserve all relevant analyses"); "Loop passes must preserve all relevant analyses");
// We know that the loop pass couldn't have invalidated any other loop's // We know that the loop pass couldn't have invalidated any other loop's
// analyses (that's the contract of a loop pass), so directly handle the // analyses (that's the contract of a loop pass), so directly handle the
// loop analysis manager's invalidation here. Also, update the // loop analysis manager's invalidation here. Also, update the
// preserved analyses to reflect that once invalidated these can again // preserved analyses to reflect that once invalidated these can again
// be preserved. // be preserved.
PassPA = LAM.invalidate(*L, std::move(PassPA)); PassPA = AM.invalidate(*L, std::move(PassPA));
// Then intersect the preserved set so that invalidation of module // Then intersect the preserved set so that invalidation of module
// analyses will eventually occur when the module pass completes. // analyses will eventually occur when the module pass completes.
PA.intersect(std::move(PassPA)); PA.intersect(std::move(PassPA));
} }
// By definition we preserve the proxy. This precludes *any* invalidation of
// loop analyses by the proxy, but that's OK because we've taken care to
// invalidate analyses in the loop analysis manager incrementally above.
PA.preserve<LoopAnalysisManagerFunctionProxy>();
return PA; return PA;
} }
private: private:
LoopPassT Pass; LoopPassT Pass;
}; };
static inline IRUnitKind getIRUnitKindID(Loop *) { return IRK_Loop; }
static inline Function *getStaticParentIRUnit(Loop &L) {
return L.getHeader()->getParent();
}
extern template struct ParentIRUnitTrackingAnalysis<Loop>;
/// \brief A function to deduce a loop pass type and wrap it in the templated /// \brief A function to deduce a loop pass type and wrap it in the templated
/// adaptor. /// adaptor.
template <typename LoopPassT> template <typename LoopPassT>
FunctionToLoopPassAdaptor<LoopPassT> FunctionToLoopPassAdaptor<LoopPassT>
createFunctionToLoopPassAdaptor(LoopPassT Pass) { createFunctionToLoopPassAdaptor(LoopPassT Pass) {
return FunctionToLoopPassAdaptor<LoopPassT>(std::move(Pass)); return FunctionToLoopPassAdaptor<LoopPassT>(std::move(Pass));
} }
} }
#endif // LLVM_ANALYSIS_LOOPPASSMANAGER_H #endif // LLVM_ANALYSIS_LOOPPASSMANAGER_H

include/llvm/Analysis/MemoryDependenceAnalysis.h

Show First 20 Lines • Show All 473 Lines • ▼ Show 20 Lines
class MemoryDependenceAnalysis class MemoryDependenceAnalysis
: public AnalysisInfoMixin<MemoryDependenceAnalysis> { : public AnalysisInfoMixin<MemoryDependenceAnalysis> {
friend AnalysisInfoMixin<MemoryDependenceAnalysis>; friend AnalysisInfoMixin<MemoryDependenceAnalysis>;
static char PassID; static char PassID;
public: public:
typedef MemoryDependenceResults Result; typedef MemoryDependenceResults Result;
MemoryDependenceResults run(Function &F, AnalysisManager<Function> &AM); MemoryDependenceResults run(Function &F, AnalysisManager &AM);
}; };
/// A wrapper analysis pass for the legacy pass manager that exposes a \c /// A wrapper analysis pass for the legacy pass manager that exposes a \c
/// MemoryDepnedenceResults instance. /// MemoryDepnedenceResults instance.
class MemoryDependenceWrapperPass : public FunctionPass { class MemoryDependenceWrapperPass : public FunctionPass {
Optional<MemoryDependenceResults> MemDep; Optional<MemoryDependenceResults> MemDep;
public: public:
MemoryDependenceWrapperPass(); MemoryDependenceWrapperPass();
Show All 18 Lines

include/llvm/Analysis/ObjCARCAliasAnalysis.h

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Lines
/// Analysis pass providing a never-invalidated alias analysis result. /// Analysis pass providing a never-invalidated alias analysis result.
class ObjCARCAA : public AnalysisInfoMixin<ObjCARCAA> { class ObjCARCAA : public AnalysisInfoMixin<ObjCARCAA> {
friend AnalysisInfoMixin<ObjCARCAA>; friend AnalysisInfoMixin<ObjCARCAA>;
static char PassID; static char PassID;
public: public:
typedef ObjCARCAAResult Result; typedef ObjCARCAAResult Result;
ObjCARCAAResult run(Function &F, AnalysisManager<Function> &AM); ObjCARCAAResult run(Function &F, AnalysisManager &AM);
}; };
/// Legacy wrapper pass to provide the ObjCARCAAResult object. /// Legacy wrapper pass to provide the ObjCARCAAResult object.
class ObjCARCAAWrapperPass : public ImmutablePass { class ObjCARCAAWrapperPass : public ImmutablePass {
std::unique_ptr<ObjCARCAAResult> Result; std::unique_ptr<ObjCARCAAResult> Result;
public: public:
static char ID; static char ID;
Show All 15 Lines

include/llvm/Analysis/OptimizationDiagnosticInfo.h

Show First 20 Lines • Show All 177 Lines • ▼ Show 20 Linesclass OptimizationRemarkEmitterAnalysis
friend AnalysisInfoMixin<OptimizationRemarkEmitterAnalysis>; friend AnalysisInfoMixin<OptimizationRemarkEmitterAnalysis>;
static char PassID; static char PassID;
public: public:
/// \brief Provide the result typedef for this analysis pass. /// \brief Provide the result typedef for this analysis pass.
typedef OptimizationRemarkEmitter Result; typedef OptimizationRemarkEmitter Result;
/// \brief Run the analysis pass over a function and produce BFI. /// \brief Run the analysis pass over a function and produce BFI.
Result run(Function &F, AnalysisManager<Function> &AM); Result run(Function &F, AnalysisManager &AM);
}; };
} }
#endif // LLVM_IR_OPTIMIZATIONDIAGNOSTICINFO_H #endif // LLVM_IR_OPTIMIZATIONDIAGNOSTICINFO_H

include/llvm/Analysis/PostDominators.h

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Linesclass PostDominatorTreeAnalysis
static char PassID; static char PassID;
public: public:
/// \brief Provide the result typedef for this analysis pass. /// \brief Provide the result typedef for this analysis pass.
typedef PostDominatorTree Result; typedef PostDominatorTree Result;
/// \brief Run the analysis pass over a function and produce a post dominator /// \brief Run the analysis pass over a function and produce a post dominator
/// tree. /// tree.
PostDominatorTree run(Function &F, FunctionAnalysisManager &); PostDominatorTree run(Function &F, AnalysisManager &);
}; };
/// \brief Printer pass for the \c PostDominatorTree. /// \brief Printer pass for the \c PostDominatorTree.
class PostDominatorTreePrinterPass class PostDominatorTreePrinterPass
: public PassInfoMixin<PostDominatorTreePrinterPass> { : public PassInfoMixin<PostDominatorTreePrinterPass> {
raw_ostream &OS; raw_ostream &OS;
public: public:
explicit PostDominatorTreePrinterPass(raw_ostream &OS); explicit PostDominatorTreePrinterPass(raw_ostream &OS);
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
struct PostDominatorTreeWrapperPass : public FunctionPass { struct PostDominatorTreeWrapperPass : public FunctionPass {
static char ID; // Pass identification, replacement for typeid static char ID; // Pass identification, replacement for typeid
PostDominatorTree DT; PostDominatorTree DT;
PostDominatorTreeWrapperPass() : FunctionPass(ID) { PostDominatorTreeWrapperPass() : FunctionPass(ID) {
initializePostDominatorTreeWrapperPassPass(*PassRegistry::getPassRegistry()); initializePostDominatorTreeWrapperPassPass(*PassRegistry::getPassRegistry());
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

include/llvm/Analysis/ProfileSummaryInfo.h

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Linespublic:
ProfileSummaryAnalysis(ProfileSummaryAnalysis &&Arg) {} ProfileSummaryAnalysis(ProfileSummaryAnalysis &&Arg) {}
ProfileSummaryAnalysis &operator=(const ProfileSummaryAnalysis &RHS) { ProfileSummaryAnalysis &operator=(const ProfileSummaryAnalysis &RHS) {
return *this; return *this;
} }
ProfileSummaryAnalysis &operator=(ProfileSummaryAnalysis &&RHS) { ProfileSummaryAnalysis &operator=(ProfileSummaryAnalysis &&RHS) {
return *this; return *this;
} }
Result run(Module &M, ModuleAnalysisManager &); Result run(Module &M, AnalysisManager &);
private: private:
friend AnalysisInfoMixin<ProfileSummaryAnalysis>; friend AnalysisInfoMixin<ProfileSummaryAnalysis>;
static char PassID; static char PassID;
}; };
/// \brief Printer pass that uses \c ProfileSummaryAnalysis. /// \brief Printer pass that uses \c ProfileSummaryAnalysis.
class ProfileSummaryPrinterPass class ProfileSummaryPrinterPass
: public PassInfoMixin<ProfileSummaryPrinterPass> { : public PassInfoMixin<ProfileSummaryPrinterPass> {
raw_ostream &OS; raw_ostream &OS;
public: public:
explicit ProfileSummaryPrinterPass(raw_ostream &OS) : OS(OS) {} explicit ProfileSummaryPrinterPass(raw_ostream &OS) : OS(OS) {}
PreservedAnalyses run(Module &M, AnalysisManager<Module> &AM); PreservedAnalyses run(Module &M, AnalysisManager &AM);
}; };
} // end namespace llvm } // end namespace llvm
#endif #endif

include/llvm/Analysis/RegionInfo.h

Show First 20 Lines • Show All 931 Lines • ▼ Show 20 Lines
/// \brief Analysis pass that exposes the \c RegionInfo for a function. /// \brief Analysis pass that exposes the \c RegionInfo for a function.
class RegionInfoAnalysis : public AnalysisInfoMixin<RegionInfoAnalysis> { class RegionInfoAnalysis : public AnalysisInfoMixin<RegionInfoAnalysis> {
friend AnalysisInfoMixin<RegionInfoAnalysis>; friend AnalysisInfoMixin<RegionInfoAnalysis>;
static char PassID; static char PassID;
public: public:
typedef RegionInfo Result; typedef RegionInfo Result;
RegionInfo run(Function &F, AnalysisManager<Function> &AM); RegionInfo run(Function &F, AnalysisManager &AM);
}; };
/// \brief Printer pass for the \c RegionInfo. /// \brief Printer pass for the \c RegionInfo.
class RegionInfoPrinterPass : public PassInfoMixin<RegionInfoPrinterPass> { class RegionInfoPrinterPass : public PassInfoMixin<RegionInfoPrinterPass> {
raw_ostream &OS; raw_ostream &OS;
public: public:
explicit RegionInfoPrinterPass(raw_ostream &OS); explicit RegionInfoPrinterPass(raw_ostream &OS);
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
/// \brief Verifier pass for the \c RegionInfo. /// \brief Verifier pass for the \c RegionInfo.
struct RegionInfoVerifierPass : PassInfoMixin<RegionInfoVerifierPass> { struct RegionInfoVerifierPass : PassInfoMixin<RegionInfoVerifierPass> {
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
template <> template <>
template <> template <>
inline BasicBlock * inline BasicBlock *
RegionNodeBase<RegionTraits<Function>>::getNodeAs<BasicBlock>() const { RegionNodeBase<RegionTraits<Function>>::getNodeAs<BasicBlock>() const {
assert(!isSubRegion() && "This is not a BasicBlock RegionNode!"); assert(!isSubRegion() && "This is not a BasicBlock RegionNode!");
return getEntry(); return getEntry();
Show All 29 Lines

include/llvm/Analysis/ScalarEvolution.h

Show First 20 Lines • Show All 1,675 Lines • ▼ Show 20 Lines
class ScalarEvolutionAnalysis class ScalarEvolutionAnalysis
: public AnalysisInfoMixin<ScalarEvolutionAnalysis> { : public AnalysisInfoMixin<ScalarEvolutionAnalysis> {
friend AnalysisInfoMixin<ScalarEvolutionAnalysis>; friend AnalysisInfoMixin<ScalarEvolutionAnalysis>;
static char PassID; static char PassID;
public: public:
typedef ScalarEvolution Result; typedef ScalarEvolution Result;
ScalarEvolution run(Function &F, AnalysisManager<Function> &AM); ScalarEvolution run(Function &F, AnalysisManager &AM);
}; };
/// Printer pass for the \c ScalarEvolutionAnalysis results. /// Printer pass for the \c ScalarEvolutionAnalysis results.
class ScalarEvolutionPrinterPass class ScalarEvolutionPrinterPass
: public PassInfoMixin<ScalarEvolutionPrinterPass> { : public PassInfoMixin<ScalarEvolutionPrinterPass> {
raw_ostream &OS; raw_ostream &OS;
public: public:
explicit ScalarEvolutionPrinterPass(raw_ostream &OS) : OS(OS) {} explicit ScalarEvolutionPrinterPass(raw_ostream &OS) : OS(OS) {}
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
class ScalarEvolutionWrapperPass : public FunctionPass { class ScalarEvolutionWrapperPass : public FunctionPass {
std::unique_ptr<ScalarEvolution> SE; std::unique_ptr<ScalarEvolution> SE;
public: public:
static char ID; static char ID;
▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines

include/llvm/Analysis/ScalarEvolutionAliasAnalysis.h

Show All 39 Lines
/// Analysis pass providing a never-invalidated alias analysis result. /// Analysis pass providing a never-invalidated alias analysis result.
class SCEVAA : public AnalysisInfoMixin<SCEVAA> { class SCEVAA : public AnalysisInfoMixin<SCEVAA> {
friend AnalysisInfoMixin<SCEVAA>; friend AnalysisInfoMixin<SCEVAA>;
static char PassID; static char PassID;
public: public:
typedef SCEVAAResult Result; typedef SCEVAAResult Result;
SCEVAAResult run(Function &F, AnalysisManager<Function> &AM); SCEVAAResult run(Function &F, AnalysisManager &AM);
}; };
/// Legacy wrapper pass to provide the SCEVAAResult object. /// Legacy wrapper pass to provide the SCEVAAResult object.
class SCEVAAWrapperPass : public FunctionPass { class SCEVAAWrapperPass : public FunctionPass {
std::unique_ptr<SCEVAAResult> Result; std::unique_ptr<SCEVAAResult> Result;
public: public:
static char ID; static char ID;
Show All 16 Lines

include/llvm/Analysis/ScopedNoAliasAA.h

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
/// Analysis pass providing a never-invalidated alias analysis result. /// Analysis pass providing a never-invalidated alias analysis result.
class ScopedNoAliasAA : public AnalysisInfoMixin<ScopedNoAliasAA> { class ScopedNoAliasAA : public AnalysisInfoMixin<ScopedNoAliasAA> {
friend AnalysisInfoMixin<ScopedNoAliasAA>; friend AnalysisInfoMixin<ScopedNoAliasAA>;
static char PassID; static char PassID;
public: public:
typedef ScopedNoAliasAAResult Result; typedef ScopedNoAliasAAResult Result;
ScopedNoAliasAAResult run(Function &F, AnalysisManager<Function> &AM); ScopedNoAliasAAResult run(Function &F, AnalysisManager &AM);
}; };
/// Legacy wrapper pass to provide the ScopedNoAliasAAResult object. /// Legacy wrapper pass to provide the ScopedNoAliasAAResult object.
class ScopedNoAliasAAWrapperPass : public ImmutablePass { class ScopedNoAliasAAWrapperPass : public ImmutablePass {
std::unique_ptr<ScopedNoAliasAAResult> Result; std::unique_ptr<ScopedNoAliasAAResult> Result;
public: public:
static char ID; static char ID;
Show All 20 Lines

include/llvm/Analysis/TargetLibraryInfo.h

Show First 20 Lines • Show All 300 Lines • ▼ Show 20 Linespublic:
TargetLibraryAnalysis(TargetLibraryAnalysis &&Arg) TargetLibraryAnalysis(TargetLibraryAnalysis &&Arg)
: PresetInfoImpl(std::move(Arg.PresetInfoImpl)), Impls(std::move(Arg.Impls)) {} : PresetInfoImpl(std::move(Arg.PresetInfoImpl)), Impls(std::move(Arg.Impls)) {}
TargetLibraryAnalysis &operator=(TargetLibraryAnalysis &&RHS) { TargetLibraryAnalysis &operator=(TargetLibraryAnalysis &&RHS) {
PresetInfoImpl = std::move(RHS.PresetInfoImpl); PresetInfoImpl = std::move(RHS.PresetInfoImpl);
Impls = std::move(RHS.Impls); Impls = std::move(RHS.Impls);
return *this; return *this;
} }
TargetLibraryInfo run(Module &M, ModuleAnalysisManager &); TargetLibraryInfo run(Module &M, AnalysisManager &);
TargetLibraryInfo run(Function &F, FunctionAnalysisManager &); TargetLibraryInfo run(Function &F, AnalysisManager &);
private: private:
friend AnalysisInfoMixin<TargetLibraryAnalysis>; friend AnalysisInfoMixin<TargetLibraryAnalysis>;
static char PassID; static char PassID;
Optional<TargetLibraryInfoImpl> PresetInfoImpl; Optional<TargetLibraryInfoImpl> PresetInfoImpl;
StringMap<std::unique_ptr<TargetLibraryInfoImpl>> Impls; StringMap<std::unique_ptr<TargetLibraryInfoImpl>> Impls;
Show All 23 Lines

include/llvm/Analysis/TargetTransformInfo.h

Show First 20 Lines • Show All 1,022 Lines • ▼ Show 20 Lines TargetIRAnalysis &operator=(const TargetIRAnalysis &RHS) {
TTICallback = RHS.TTICallback; TTICallback = RHS.TTICallback;
return *this; return *this;
} }
TargetIRAnalysis &operator=(TargetIRAnalysis &&RHS) { TargetIRAnalysis &operator=(TargetIRAnalysis &&RHS) {
TTICallback = std::move(RHS.TTICallback); TTICallback = std::move(RHS.TTICallback);
return *this; return *this;
} }
Result run(const Function &F, AnalysisManager<Function> &); Result run(const Function &F, AnalysisManager &);
private: private:
friend AnalysisInfoMixin<TargetIRAnalysis>; friend AnalysisInfoMixin<TargetIRAnalysis>;
static char PassID; static char PassID;
/// \brief The callback used to produce a result. /// \brief The callback used to produce a result.
/// ///
/// We use a completely opaque callback so that targets can provide whatever /// We use a completely opaque callback so that targets can provide whatever
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

include/llvm/Analysis/TypeBasedAliasAnalysis.h

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
/// Analysis pass providing a never-invalidated alias analysis result. /// Analysis pass providing a never-invalidated alias analysis result.
class TypeBasedAA : public AnalysisInfoMixin<TypeBasedAA> { class TypeBasedAA : public AnalysisInfoMixin<TypeBasedAA> {
friend AnalysisInfoMixin<TypeBasedAA>; friend AnalysisInfoMixin<TypeBasedAA>;
static char PassID; static char PassID;
public: public:
typedef TypeBasedAAResult Result; typedef TypeBasedAAResult Result;
TypeBasedAAResult run(Function &F, AnalysisManager<Function> &AM); TypeBasedAAResult run(Function &F, AnalysisManager &AM);
}; };
/// Legacy wrapper pass to provide the TypeBasedAAResult object. /// Legacy wrapper pass to provide the TypeBasedAAResult object.
class TypeBasedAAWrapperPass : public ImmutablePass { class TypeBasedAAWrapperPass : public ImmutablePass {
std::unique_ptr<TypeBasedAAResult> Result; std::unique_ptr<TypeBasedAAResult> Result;
public: public:
static char ID; static char ID;
Show All 20 Lines

include/llvm/Bitcode/BitcodeWriterPass.h

Show First 20 Lines • Show All 61 Lines • ▼ Show 20 Lines explicit BitcodeWriterPass(raw_ostream &OS,
bool ShouldPreserveUseListOrder = false, bool ShouldPreserveUseListOrder = false,
bool EmitSummaryIndex = false, bool EmitSummaryIndex = false,
bool EmitModuleHash = false) bool EmitModuleHash = false)
: OS(OS), ShouldPreserveUseListOrder(ShouldPreserveUseListOrder), : OS(OS), ShouldPreserveUseListOrder(ShouldPreserveUseListOrder),
EmitSummaryIndex(EmitSummaryIndex), EmitModuleHash(EmitModuleHash) {} EmitSummaryIndex(EmitSummaryIndex), EmitModuleHash(EmitModuleHash) {}
/// \brief Run the bitcode writer pass, and output the module to the selected /// \brief Run the bitcode writer pass, and output the module to the selected
/// output stream. /// output stream.
PreservedAnalyses run(Module &M, ModuleAnalysisManager &); PreservedAnalyses run(Module &M, AnalysisManager &);
static StringRef name() { return "BitcodeWriterPass"; } static StringRef name() { return "BitcodeWriterPass"; }
}; };
} }
#endif #endif

include/llvm/CodeGen/PreISelIntrinsicLowering.h

Show All 13 Lines
#define LLVM_CODEGEN_PREISELINTRINSICLOWERING_H #define LLVM_CODEGEN_PREISELINTRINSICLOWERING_H
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
struct PreISelIntrinsicLoweringPass struct PreISelIntrinsicLoweringPass
: PassInfoMixin<PreISelIntrinsicLoweringPass> { : PassInfoMixin<PreISelIntrinsicLoweringPass> {
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM); PreservedAnalyses run(Module &M, AnalysisManager &AM);
}; };
} }
#endif // LLVM_CODEGEN_PREISELINTRINSICLOWERING_H #endif // LLVM_CODEGEN_PREISELINTRINSICLOWERING_H

include/llvm/CodeGen/UnreachableBlockElim.h

Show All 24 Lines
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
class UnreachableBlockElimPass class UnreachableBlockElimPass
: public PassInfoMixin<UnreachableBlockElimPass> { : public PassInfoMixin<UnreachableBlockElimPass> {
public: public:
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
} // end namespace llvm } // end namespace llvm
#endif // LLVM_LIB_CODEGEN_UNREACHABLEBLOCKELIM_H #endif // LLVM_LIB_CODEGEN_UNREACHABLEBLOCKELIM_H

include/llvm/IR/Dominators.h

Show First 20 Lines • Show All 202 Lines • ▼ Show 20 Linesclass DominatorTreeAnalysis : public AnalysisInfoMixin<DominatorTreeAnalysis> {
friend AnalysisInfoMixin<DominatorTreeAnalysis>; friend AnalysisInfoMixin<DominatorTreeAnalysis>;
static char PassID; static char PassID;
public: public:
/// \brief Provide the result typedef for this analysis pass. /// \brief Provide the result typedef for this analysis pass.
typedef DominatorTree Result; typedef DominatorTree Result;
/// \brief Run the analysis pass over a function and produce a dominator tree. /// \brief Run the analysis pass over a function and produce a dominator tree.
DominatorTree run(Function &F, AnalysisManager<Function> &); DominatorTree run(Function &F, AnalysisManager &);
}; };
/// \brief Printer pass for the \c DominatorTree. /// \brief Printer pass for the \c DominatorTree.
class DominatorTreePrinterPass class DominatorTreePrinterPass
: public PassInfoMixin<DominatorTreePrinterPass> { : public PassInfoMixin<DominatorTreePrinterPass> {
raw_ostream &OS; raw_ostream &OS;
public: public:
explicit DominatorTreePrinterPass(raw_ostream &OS); explicit DominatorTreePrinterPass(raw_ostream &OS);
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
/// \brief Verifier pass for the \c DominatorTree. /// \brief Verifier pass for the \c DominatorTree.
struct DominatorTreeVerifierPass : PassInfoMixin<DominatorTreeVerifierPass> { struct DominatorTreeVerifierPass : PassInfoMixin<DominatorTreeVerifierPass> {
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
/// \brief Legacy analysis pass which computes a \c DominatorTree. /// \brief Legacy analysis pass which computes a \c DominatorTree.
class DominatorTreeWrapperPass : public FunctionPass { class DominatorTreeWrapperPass : public FunctionPass {
DominatorTree DT; DominatorTree DT;
public: public:
static char ID; static char ID;
Show All 24 Lines

include/llvm/IR/IRPrintingPasses.h

Show All 24 Lines
namespace llvm { namespace llvm {
class BasicBlockPass; class BasicBlockPass;
class Function; class Function;
class FunctionPass; class FunctionPass;
class Module; class Module;
class ModulePass; class ModulePass;
class PreservedAnalyses; class PreservedAnalyses;
class raw_ostream; class raw_ostream;
template <typename IRUnitT> class AnalysisManager; class AnalysisManager;
/// \brief Create and return a pass that writes the module to the specified /// \brief Create and return a pass that writes the module to the specified
/// \c raw_ostream. /// \c raw_ostream.
ModulePass *createPrintModulePass(raw_ostream &OS, ModulePass *createPrintModulePass(raw_ostream &OS,
const std::string &Banner = "", const std::string &Banner = "",
bool ShouldPreserveUseListOrder = false); bool ShouldPreserveUseListOrder = false);
/// \brief Create and return a pass that prints functions to the specified /// \brief Create and return a pass that prints functions to the specified
Show All 21 Linesclass PrintModulePass {
std::string Banner; std::string Banner;
bool ShouldPreserveUseListOrder; bool ShouldPreserveUseListOrder;
public: public:
PrintModulePass(); PrintModulePass();
PrintModulePass(raw_ostream &OS, const std::string &Banner = "", PrintModulePass(raw_ostream &OS, const std::string &Banner = "",
bool ShouldPreserveUseListOrder = false); bool ShouldPreserveUseListOrder = false);
PreservedAnalyses run(Module &M, AnalysisManager<Module> &); PreservedAnalyses run(Module &M, AnalysisManager &);
static StringRef name() { return "PrintModulePass"; } static StringRef name() { return "PrintModulePass"; }
}; };
/// \brief Pass for printing a Function as LLVM's text IR assembly. /// \brief Pass for printing a Function as LLVM's text IR assembly.
/// ///
/// Note: This pass is for use with the new pass manager. Use the create...Pass /// Note: This pass is for use with the new pass manager. Use the create...Pass
/// functions above to create passes for use with the legacy pass manager. /// functions above to create passes for use with the legacy pass manager.
class PrintFunctionPass { class PrintFunctionPass {
raw_ostream &OS; raw_ostream &OS;
std::string Banner; std::string Banner;
public: public:
PrintFunctionPass(); PrintFunctionPass();
PrintFunctionPass(raw_ostream &OS, const std::string &Banner = ""); PrintFunctionPass(raw_ostream &OS, const std::string &Banner = "");
PreservedAnalyses run(Function &F, AnalysisManager<Function> &); PreservedAnalyses run(Function &F, AnalysisManager &);
static StringRef name() { return "PrintFunctionPass"; } static StringRef name() { return "PrintFunctionPass"; }
}; };
} // End llvm namespace } // End llvm namespace
#endif #endif

include/llvm/IR/PassManager.h

Show First 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
private: private:
// Note that this must not be -1 or -2 as those are already used by the // Note that this must not be -1 or -2 as those are already used by the
// SmallPtrSet. // SmallPtrSet.
static const uintptr_t AllPassesID = (intptr_t)(-3); static const uintptr_t AllPassesID = (intptr_t)(-3);
SmallPtrSet<void *, 2> PreservedPassIDs; SmallPtrSet<void *, 2> PreservedPassIDs;
}; };
// Forward declare the analysis manager template. // The key used for holding analyses registered in the analysis manager.
template <typename IRUnitT> class AnalysisManager; struct AnalysisKey {
void *AnalysisID;
IRUnitKind IRUnitKindID;
};
static inline IRUnitKind getIRUnitKindID(Function *) { return IRK_Function; }
static inline IRUnitKind getIRUnitKindID(Module *) { return IRK_Module; }
static inline Module *getStaticParentIRUnit(Function &F) { return F.getParent(); }
static inline Module *getStaticParentIRUnit(Module &M) { return nullptr; }
// Provide DenseMapInfo for AnalysisKey
template <> struct DenseMapInfo<AnalysisKey> {
static inline AnalysisKey getEmptyKey() { return {nullptr, IRK_Module}; }
static inline AnalysisKey getTombstoneKey() {
return {nullptr, IRK_Function};
}
static unsigned getHashValue(const AnalysisKey &Val) {
return hash_combine(Val.AnalysisID, Val.IRUnitKindID);
}
static bool isEqual(const AnalysisKey &LHS, const AnalysisKey &RHS) {
return LHS.AnalysisID == RHS.AnalysisID &&
LHS.IRUnitKindID == RHS.IRUnitKindID;
}
};
/// A CRTP mix-in to automatically provide informational APIs needed for /// A CRTP mix-in to automatically provide informational APIs needed for
/// passes. /// passes.
/// ///
/// This provides some boiler plate for types that are passes. /// This provides some boiler plate for types that are passes.
template <typename DerivedT> struct PassInfoMixin { template <typename DerivedT> struct PassInfoMixin {
/// Returns the name of the derived pass type. /// Returns the name of the derived pass type.
static StringRef name() { static StringRef name() {
Show All 23 Linesstruct AnalysisInfoMixin : PassInfoMixin<DerivedT> {
/// for each instantiation and are definitively emitted once for each /// for each instantiation and are definitively emitted once for each
/// instantiation. The only currently known platform with this limitation are /// instantiation. The only currently known platform with this limitation are
/// Windows DLL builds, specifically building each part of LLVM as a DLL. If /// Windows DLL builds, specifically building each part of LLVM as a DLL. If
/// we ever remove that build configuration, this mixin can provide the /// we ever remove that build configuration, this mixin can provide the
/// static PassID as well. /// static PassID as well.
static void *ID() { return (void *)&DerivedT::PassID; } static void *ID() { return (void *)&DerivedT::PassID; }
}; };
/// \brief Manages a sequence of passes over units of IR. class AnalysisManager;
///
/// A pass manager contains a sequence of passes to run over units of IR. It is
/// itself a valid pass over that unit of IR, and when over some given IR will
/// run each pass in sequence. This is the primary and most basic building
/// block of a pass pipeline.
///
/// If it is run with an \c AnalysisManager<IRUnitT> argument, it will propagate
/// that analysis manager to each pass it runs, as well as calling the analysis
/// manager's invalidation routine with the PreservedAnalyses of each pass it
/// runs.
template <typename IRUnitT>
class PassManager : public PassInfoMixin<PassManager<IRUnitT>> {
public:
/// \brief Construct a pass manager.
///
/// It can be passed a flag to get debug logging as the passes are run.
PassManager(bool DebugLogging = false) : DebugLogging(DebugLogging) {}
// We have to explicitly define all the special member functions because MSVC
// refuses to generate them.
PassManager(PassManager &&Arg)
: Passes(std::move(Arg.Passes)),
DebugLogging(std::move(Arg.DebugLogging)) {}
PassManager &operator=(PassManager &&RHS) {
Passes = std::move(RHS.Passes);
DebugLogging = std::move(RHS.DebugLogging);
return *this;
}
/// \brief Run all of the passes in this manager over the IR.
PreservedAnalyses run(IRUnitT &IR, AnalysisManager<IRUnitT> &AM) {
PreservedAnalyses PA = PreservedAnalyses::all();
if (DebugLogging)
dbgs() << "Starting " << getTypeName<IRUnitT>() << " pass manager run.\n";
for (unsigned Idx = 0, Size = Passes.size(); Idx != Size; ++Idx) {
if (DebugLogging)
dbgs() << "Running pass: " << Passes[Idx]->name() << " on "
<< IR.getName() << "\n";
PreservedAnalyses PassPA = Passes[Idx]->run(IR, AM); // This is used internally by the analysis manager to track dependencies on
// parent IRUnit's.
// Update the analysis manager as each pass runs and potentially template <typename IRUnitT>
// invalidates analyses. We also update the preserved set of analyses struct ParentIRUnitTrackingAnalysis
// based on what analyses we have already handled the invalidation for : public AnalysisInfoMixin<ParentIRUnitTrackingAnalysis<IRUnitT>> {
// here and don't need to invalidate when finished. typedef int Result; // Dummy.
PassPA = AM.invalidate(IR, std::move(PassPA)); Result run(IRUnitT &, AnalysisManager &) { return 0; }
static char PassID;
// Finally, we intersect the final preserved analyses to compute the
// aggregate preserved set for this pass manager.
PA.intersect(std::move(PassPA));
// FIXME: Historically, the pass managers all called the LLVM context's
// yield function here. We don't have a generic way to acquire the
// context and it isn't yet clear what the right pattern is for yielding
// in the new pass manager so it is currently omitted.
//IR.getContext().yield();
}
if (DebugLogging)
dbgs() << "Finished " << getTypeName<IRUnitT>() << " pass manager run.\n";
return PA;
}
template <typename PassT> void addPass(PassT Pass) {
typedef detail::PassModel<IRUnitT, PassT> PassModelT;
Passes.emplace_back(new PassModelT(std::move(Pass)));
}
private:
typedef detail::PassConcept<IRUnitT> PassConceptT;
PassManager(const PassManager &) = delete;
PassManager &operator=(const PassManager &) = delete;
std::vector<std::unique_ptr<PassConceptT>> Passes;
/// \brief Flag indicating whether we should do debug logging.
bool DebugLogging;
}; };
extern template struct ParentIRUnitTrackingAnalysis<Module>;
extern template class PassManager<Module>; extern template struct ParentIRUnitTrackingAnalysis<Function>;
/// \brief Convenience typedef for a pass manager over modules.
typedef PassManager<Module> ModulePassManager;
extern template class PassManager<Function>;
/// \brief Convenience typedef for a pass manager over functions.
typedef PassManager<Function> FunctionPassManager;
namespace detail { namespace detail {
/// \brief A CRTP base used to implement analysis managers. /// \brief A CRTP base used to implement analysis managers.
/// ///
/// This class template serves as the boiler plate of an analysis manager. Any /// This class template serves as the boiler plate of an analysis manager. Any
/// analysis manager can be implemented on top of this base class. Any /// analysis manager can be implemented on top of this base class. Any
/// implementation will be required to provide specific hooks: /// implementation will be required to provide specific hooks:
/// ///
/// - getResultImpl /// - getResultImpl
/// - getCachedResultImpl /// - getCachedResultImpl
/// - invalidateImpl /// - invalidateImpl
/// ///
/// The details of the call pattern are within. /// The details of the call pattern are within.
/// ///
/// Note that there is also a generic analysis manager template which implements /// Note that there is also a generic analysis manager template which implements
/// the above required functions along with common datastructures used for /// the above required functions along with common datastructures used for
/// managing analyses. This base class is factored so that if you need to /// managing analyses. This base class is factored so that if you need to
/// customize the handling of a specific IR unit, you can do so without /// customize the handling of a specific IR unit, you can do so without
/// replicating *all* of the boilerplate. /// replicating *all* of the boilerplate.
template <typename DerivedT, typename IRUnitT> class AnalysisManagerBase { template <typename DerivedT>
class AnalysisManagerBase {
DerivedT *derived_this() { return static_cast<DerivedT *>(this); } DerivedT *derived_this() { return static_cast<DerivedT *>(this); }
const DerivedT *derived_this() const { const DerivedT *derived_this() const {
return static_cast<const DerivedT *>(this); return static_cast<const DerivedT *>(this);
} }
AnalysisManagerBase(const AnalysisManagerBase &) = delete; AnalysisManagerBase(const AnalysisManagerBase &) = delete;
AnalysisManagerBase &operator=(const AnalysisManagerBase &) = delete; AnalysisManagerBase &operator=(const AnalysisManagerBase &) = delete;
protected: protected:
typedef detail::AnalysisResultConcept<IRUnitT> ResultConceptT; typedef detail::AnalysisResultConcept ResultConceptT;
typedef detail::AnalysisPassConcept<IRUnitT> PassConceptT; typedef detail::AnalysisPassConcept PassConceptT;
// FIXME: Provide template aliases for the models when we're using C++11 in // FIXME: Provide template aliases for the models when we're using C++11 in
// a mode supporting them. // a mode supporting them.
// We have to explicitly define all the special member functions because MSVC // We have to explicitly define all the special member functions because MSVC
// refuses to generate them. // refuses to generate them.
AnalysisManagerBase() {} AnalysisManagerBase() {}
AnalysisManagerBase(AnalysisManagerBase &&Arg) AnalysisManagerBase(AnalysisManagerBase &&Arg)
: AnalysisPasses(std::move(Arg.AnalysisPasses)) {} : AnalysisPasses(std::move(Arg.AnalysisPasses)) {}
AnalysisManagerBase &operator=(AnalysisManagerBase &&RHS) { AnalysisManagerBase &operator=(AnalysisManagerBase &&RHS) {
AnalysisPasses = std::move(RHS.AnalysisPasses); AnalysisPasses = std::move(RHS.AnalysisPasses);
return *this; return *this;
} }
public: public:
/// \brief Get the result of an analysis pass for this module. /// \brief Get the result of an analysis pass for this module.
/// ///
/// If there is not a valid cached result in the manager already, this will /// If there is not a valid cached result in the manager already, this will
/// re-run the analysis to produce a valid result. /// re-run the analysis to produce a valid result.
template <typename PassT> typename PassT::Result &getResult(IRUnitT &IR) { template <typename PassT, typename IRUnitT>
assert(AnalysisPasses.count(PassT::ID()) && typename PassT::Result &getResult(IRUnitT &IR) {
AnalysisKey AK = {PassT::ID(), getIRUnitKindID(&IR)};
assert(AnalysisPasses.count(AK) &&
"This analysis pass was not registered prior to being queried"); "This analysis pass was not registered prior to being queried");
ResultConceptT &ResultConcept = ResultConceptT &ResultConcept = derived_this()->getResultImpl(AK, IR);
derived_this()->getResultImpl(PassT::ID(), IR);
typedef detail::AnalysisResultModel<IRUnitT, PassT, typename PassT::Result> typedef detail::AnalysisResultModel<IRUnitT, PassT, typename PassT::Result>
ResultModelT; ResultModelT;
return static_cast<ResultModelT &>(ResultConcept).Result; return static_cast<ResultModelT &>(ResultConcept).Result;
} }
/// \brief Get the cached result of an analysis pass for this module. /// \brief Get the cached result of an analysis pass for this module.
/// ///
/// This method never runs the analysis. /// This method never runs the analysis.
/// ///
/// \returns null if there is no cached result. /// \returns null if there is no cached result.
template <typename PassT> template <typename PassT, typename IRUnitT>
typename PassT::Result *getCachedResult(IRUnitT &IR) const { typename PassT::Result *getCachedResult(IRUnitT &IR) const {
assert(AnalysisPasses.count(PassT::ID()) && AnalysisKey AK = {PassT::ID(), getIRUnitKindID(&IR)};
assert(AnalysisPasses.count(AK) &&
"This analysis pass was not registered prior to being queried"); "This analysis pass was not registered prior to being queried");
ResultConceptT *ResultConcept = ResultConceptT *ResultConcept = derived_this()->getCachedResultImpl(AK, IR);
derived_this()->getCachedResultImpl(PassT::ID(), IR);
if (!ResultConcept) if (!ResultConcept)
return nullptr; return nullptr;
typedef detail::AnalysisResultModel<IRUnitT, PassT, typename PassT::Result> typedef detail::AnalysisResultModel<IRUnitT, PassT, typename PassT::Result>
ResultModelT; ResultModelT;
return &static_cast<ResultModelT *>(ResultConcept)->Result; return &static_cast<ResultModelT *>(ResultConcept)->Result;
} }
Show All 10 Linespublic:
/// ///
/// While this returns whether or not the pass type was already registered, /// While this returns whether or not the pass type was already registered,
/// there in't an independent way to query that as that would be prone to /// there in't an independent way to query that as that would be prone to
/// risky use when *querying* the analysis manager. Instead, the only /// risky use when *querying* the analysis manager. Instead, the only
/// supported use case is avoiding duplicate registry of an analysis. This /// supported use case is avoiding duplicate registry of an analysis. This
/// interface also lends itself to minimizing the number of times we have to /// interface also lends itself to minimizing the number of times we have to
/// do lookups for analyses or construct complex passes only to throw them /// do lookups for analyses or construct complex passes only to throw them
/// away. /// away.
template <typename PassBuilderT> bool registerPass(PassBuilderT PassBuilder) { template <typename IRUnitT, typename PassBuilderT>
bool registerPass(PassBuilderT PassBuilder) {
typedef decltype(PassBuilder()) PassT; typedef decltype(PassBuilder()) PassT;
typedef detail::AnalysisPassModel<IRUnitT, PassT> PassModelT; typedef detail::AnalysisPassModel<IRUnitT, PassT> PassModelT;
auto &PassPtr = AnalysisPasses[PassT::ID()]; AnalysisKey AK = {PassT::ID(), getIRUnitKindID((IRUnitT *)nullptr)};
auto &PassPtr = AnalysisPasses[AK];
if (PassPtr) if (PassPtr)
// Already registered this pass type! // Already registered this pass type!
return false; return false;
// Construct a new model around the instance returned by the builder. // Construct a new model around the instance returned by the builder.
PassPtr.reset(new PassModelT(PassBuilder())); PassPtr.reset(new PassModelT(PassBuilder()));
return true; return true;
} }
/// \brief Invalidate a specific analysis pass for an IR module. /// \brief Invalidate a specific analysis pass for an IR module.
/// ///
/// Note that the analysis result can disregard invalidation. /// Note that the analysis result can disregard invalidation.
template <typename PassT> void invalidate(IRUnitT &IR) { template <typename PassT, typename IRUnitT> void invalidate(IRUnitT &IR) {
assert(AnalysisPasses.count(PassT::ID()) && AnalysisKey AK = {PassT::ID(), getIRUnitKindID(&IR)};
assert(AnalysisPasses.count(AK) &&
"This analysis pass was not registered prior to being invalidated"); "This analysis pass was not registered prior to being invalidated");
derived_this()->invalidateImpl(PassT::ID(), IR); derived_this()->invalidateImpl(AK, IR);
} }
/// \brief Invalidate analyses cached for an IR unit. /// \brief Invalidate analyses cached for an IR unit.
/// ///
/// Walk through all of the analyses pertaining to this unit of IR and /// Walk through all of the analyses pertaining to this unit of IR and
/// invalidate them unless they are preserved by the PreservedAnalyses set. /// invalidate them unless they are preserved by the PreservedAnalyses set.
/// We accept the PreservedAnalyses set by value and update it with each /// We accept the PreservedAnalyses set by value and update it with each
/// analyis pass which has been successfully invalidated and thus can be /// analyis pass which has been successfully invalidated and thus can be
/// preserved going forward. The updated set is returned. /// preserved going forward. The updated set is returned.
template <typename IRUnitT>
PreservedAnalyses invalidate(IRUnitT &IR, PreservedAnalyses PA) { PreservedAnalyses invalidate(IRUnitT &IR, PreservedAnalyses PA) {
return derived_this()->invalidateImpl(IR, std::move(PA)); return derived_this()->invalidateImpl(IR, std::move(PA));
} }
protected: protected:
/// \brief Lookup a registered analysis pass. /// \brief Lookup a registered analysis pass.
PassConceptT &lookupPass(void *PassID) { PassConceptT &lookupPass(AnalysisKey AK) {
typename AnalysisPassMapT::iterator PI = AnalysisPasses.find(PassID); typename AnalysisPassMapT::iterator PI = AnalysisPasses.find(AK);
assert(PI != AnalysisPasses.end() && assert(PI != AnalysisPasses.end() &&
"Analysis passes must be registered prior to being queried!"); "Analysis passes must be registered prior to being queried!");
return *PI->second; return *PI->second;
} }
/// \brief Lookup a registered analysis pass. /// \brief Lookup a registered analysis pass.
const PassConceptT &lookupPass(void *PassID) const { const PassConceptT &lookupPass(AnalysisKey AK) const {
typename AnalysisPassMapT::const_iterator PI = AnalysisPasses.find(PassID); typename AnalysisPassMapT::const_iterator PI = AnalysisPasses.find(AK);
assert(PI != AnalysisPasses.end() && assert(PI != AnalysisPasses.end() &&
"Analysis passes must be registered prior to being queried!"); "Analysis passes must be registered prior to being queried!");
return *PI->second; return *PI->second;
} }
private: private:
/// \brief Map type from module analysis pass ID to pass concept pointer. /// \brief Map type from module analysis pass ID to pass concept pointer.
typedef DenseMap<void *, std::unique_ptr<PassConceptT>> AnalysisPassMapT; typedef DenseMap<AnalysisKey, std::unique_ptr<PassConceptT>> AnalysisPassMapT;
/// \brief Collection of module analysis passes, indexed by ID. /// \brief Collection of module analysis passes, indexed by ID.
AnalysisPassMapT AnalysisPasses; AnalysisPassMapT AnalysisPasses;
}; };
} // End namespace detail } // End namespace detail
struct PerIRUnitAnalysisResultListElement;
struct DependentTrackingNode {
std::list<PerIRUnitAnalysisResultListElement>::iterator Dependent;
// This is a backpointer to allow deletion by somebody with just an
// iterator.
std::list<DependentTrackingNode> &OwnerList;
};
struct PerIRUnitAnalysisResultListElement {
PerIRUnitAnalysisResultListElement(
AnalysisKey AK_,
std::unique_ptr<detail::AnalysisResultConcept> AnalysisResult_,
TypeErasedIRUnitID ID_)
: AK(AK_), Result(std::move(AnalysisResult_)), ID(ID_) {}
AnalysisKey AK;
std::unique_ptr<detail::AnalysisResultConcept> Result;
std::list<DependentTrackingNode> Dependents;
std::vector<std::list<DependentTrackingNode>::iterator>
DependentTrackingNodesThatPointAtMe;
// This is needed so that we can invalidate this analysis result with
// just an iterator to this struct.
TypeErasedIRUnitID ID;
};
/// \brief A generic analysis pass manager with lazy running and caching of /// \brief A generic analysis pass manager with lazy running and caching of
/// results. /// results.
/// ///
/// This analysis manager can be used for any IR unit where the address of the /// This analysis manager can be used for any IR unit where the address of the
/// IR unit sufficies as its identity. It manages the cache for a unit of IR via /// IR unit sufficies as its identity. It manages the cache for a unit of IR via
/// the address of each unit of IR cached. /// the address of each unit of IR cached.
template <typename IRUnitT> class AnalysisManager : public detail::AnalysisManagerBase<AnalysisManager> {
class AnalysisManager friend class detail::AnalysisManagerBase<AnalysisManager>;
: public detail::AnalysisManagerBase<AnalysisManager<IRUnitT>, IRUnitT> { typedef detail::AnalysisManagerBase<AnalysisManager> BaseT;
friend class detail::AnalysisManagerBase<AnalysisManager<IRUnitT>, IRUnitT>;
typedef detail::AnalysisManagerBase<AnalysisManager<IRUnitT>, IRUnitT> BaseT;
typedef typename BaseT::ResultConceptT ResultConceptT; typedef typename BaseT::ResultConceptT ResultConceptT;
typedef typename BaseT::PassConceptT PassConceptT; typedef typename BaseT::PassConceptT PassConceptT;
public: public:
// Most public APIs are inherited from the CRTP base class. // Most public APIs are inherited from the CRTP base class.
/// \brief Construct an empty analysis manager. /// \brief Construct an empty analysis manager.
/// ///
Show All 32 Lines void clear() {
AnalysisResults.clear(); AnalysisResults.clear();
AnalysisResultLists.clear(); AnalysisResultLists.clear();
} }
private: private:
AnalysisManager(const AnalysisManager &) = delete; AnalysisManager(const AnalysisManager &) = delete;
AnalysisManager &operator=(const AnalysisManager &) = delete; AnalysisManager &operator=(const AnalysisManager &) = delete;
/// \brief List of function analysis pass IDs and associated concept pointers.
///
/// Requires iterators to be valid across appending new entries and arbitrary
/// erases. Provides both the pass ID and concept pointer such that it is
/// half of a bijection and provides storage for the actual result concept.
/// Also does dependency tracking.
typedef std::list<PerIRUnitAnalysisResultListElement> AnalysisResultListT;
/// \brief Get an analysis result, running the pass if necessary. /// \brief Get an analysis result, running the pass if necessary.
ResultConceptT &getResultImpl(void *PassID, IRUnitT &IR) { template <typename IRUnitT>
ResultConceptT &getResultImpl(AnalysisKey AK, IRUnitT &IR) {
typename AnalysisResultMapT::iterator RI; typename AnalysisResultMapT::iterator RI;
bool Inserted; bool Inserted;
std::tie(RI, Inserted) = AnalysisResults.insert(std::make_pair( std::tie(RI, Inserted) = AnalysisResults.insert(
std::make_pair(PassID, &IR), typename AnalysisResultListT::iterator())); std::make_pair(std::make_pair(AK, static_cast<TypeErasedIRUnitID>(&IR)),
typename AnalysisResultListT::iterator()));
AnalysisResultListT::iterator ThisResult = RI->second;
// If we don't have a cached result for this function, look up the pass and // If we don't have a cached result for this function, look up the pass and
// run it to produce a result, which we then add to the cache. // run it to produce a result, which we then add to the cache.
if (Inserted) { if (Inserted) {
auto &P = this->lookupPass(PassID); auto &P = this->lookupPass(AK);
if (DebugLogging) if (DebugLogging)
dbgs() << "Running analysis: " << P.name() << "\n"; dbgs() << "Running analysis: " << P.name() << "\n";
AnalysisResultListT &ResultList = AnalysisResultLists[&IR]; std::unique_ptr<AnalysisResultListT> &ResultListPtr =
ResultList.emplace_back(PassID, P.run(IR, *this)); AnalysisResultLists[static_cast<TypeErasedIRUnitID>(&IR)];
if (!ResultListPtr)
// P.run may have inserted elements into AnalysisResults and invalidated ResultListPtr = make_unique<AnalysisResultListT>();
// RI. AnalysisResultListT &ResultList = *ResultListPtr;
RI = AnalysisResults.find(std::make_pair(PassID, &IR)); ResultList.emplace_back(
assert(RI != AnalysisResults.end() && "we just inserted it!"); AK, std::unique_ptr<detail::AnalysisResultConcept>(nullptr),
static_cast<TypeErasedIRUnitID>(&IR));
RI->second = std::prev(ResultList.end()); PerIRUnitAnalysisResultListElement &E = ResultList.back();
ThisResult = std::prev(ResultList.end());
RI->second = ThisResult;
InFlightAnalysesStack.push_back(ThisResult);
// Set up the parent IR unit tracking analysis.
// The dependency link will invalidate this result when invalidating
// analysis result for the parent IRUnit.
if (auto *P = getStaticParentIRUnit(IR)) {
typedef
typename std::remove_reference<decltype(*P)>::type ParentIRUnitT;
this->getResult<ParentIRUnitTrackingAnalysis<ParentIRUnitT>>(*P);
}
// Run the analysis and get the result.
E.Result = P.run(static_cast<TypeErasedIRUnitID>(&IR), *this);
InFlightAnalysesStack.pop_back();
}
// Add dependency tracking links.
if (!InFlightAnalysesStack.empty()) {
auto I = InFlightAnalysesStack.back();
ThisResult->Dependents.push_back({I, ThisResult->Dependents});
I->DependentTrackingNodesThatPointAtMe.push_back(
std::prev(ThisResult->Dependents.end()));
} }
return *RI->second->second; return *ThisResult->Result;
} }
/// \brief Get a cached analysis result or return null. /// \brief Get a cached analysis result or return null.
ResultConceptT *getCachedResultImpl(void *PassID, IRUnitT &IR) const { template <typename IRUnitT>
typename AnalysisResultMapT::const_iterator RI = ResultConceptT *getCachedResultImpl(AnalysisKey AK, IRUnitT &IR) const {
AnalysisResults.find(std::make_pair(PassID, &IR)); typename AnalysisResultMapT::const_iterator RI = AnalysisResults.find(
return RI == AnalysisResults.end() ? nullptr : &*RI->second->second; std::make_pair(AK, static_cast<TypeErasedIRUnitID>(&IR)));
bool Cached = RI != AnalysisResults.end();
if (!Cached)
return nullptr;
AnalysisResultListT::iterator ThisResult = RI->second;
// Add dependency tracking links.
if (!InFlightAnalysesStack.empty()) {
auto I = InFlightAnalysesStack.back();
ThisResult->Dependents.push_back({I, ThisResult->Dependents});
I->DependentTrackingNodesThatPointAtMe.push_back(
std::prev(ThisResult->Dependents.end()));
}
return ThisResult->Result.get();
} }
/// \brief Invalidate a function pass result. /// \brief Invalidate a function pass result.
void invalidateImpl(void *PassID, IRUnitT &IR) { template <typename IRUnitT> void invalidateImpl(AnalysisKey AK, IRUnitT &IR) {
typename AnalysisResultMapT::iterator RI = invalidateImplImpl(AK, static_cast<TypeErasedIRUnitID>(&IR));
AnalysisResults.find(std::make_pair(PassID, &IR)); }
/// \brief Invalidate a function pass result.
/// This includes walking its dependencies and invalidating them.
///
/// Returns an iterator to the next element in the list (after all
/// dependencies have been invalidated, which may have removed elements
/// from the list).
typename AnalysisResultListT::iterator
invalidateImplImpl(AnalysisKey AK, TypeErasedIRUnitID ID) {
auto MapKey = std::make_pair(AK, ID);
typename AnalysisResultMapT::iterator RI = AnalysisResults.find(MapKey);
if (RI == AnalysisResults.end()) if (RI == AnalysisResults.end())
return; return typename AnalysisResultListT::iterator();
if (DebugLogging) if (DebugLogging)
dbgs() << "Invalidating analysis: " << this->lookupPass(PassID).name() dbgs() << "Invalidating analysis: " << this->lookupPass(AK).name()
<< "\n"; << "\n";
AnalysisResultLists[&IR].erase(RI->second); auto I = RI->second;
AnalysisResults.erase(RI); auto &L = *AnalysisResultLists[ID];
auto &D = I->Dependents;
// Invalidate all dependents.
while (!D.empty()) {
auto &Element = *D.front().Dependent;
// This recursive call will delete (at least) this element of `D`.
invalidateImplImpl(Element.AK, Element.ID);
}
// Remove any dependent tracking nodes that are tracking a dependency
// on this analysis result.
// This analysis result is about to be erased and those pointers can't
// be allowed to dangle.
for (auto DepNodeIt : I->DependentTrackingNodesThatPointAtMe)
DepNodeIt->OwnerList.erase(DepNodeIt);
auto Ret = L.erase(I); // This returns the iterator to the next element.
AnalysisResults.erase(MapKey); // RI may have been invalidated, so use the key.
return Ret;
} }
/// \brief Invalidate the results for a function.. /// \brief Invalidate the results for a function..
template <typename IRUnitT>
PreservedAnalyses invalidateImpl(IRUnitT &IR, PreservedAnalyses PA) { PreservedAnalyses invalidateImpl(IRUnitT &IR, PreservedAnalyses PA) {
// Short circuit for a common case of all analyses being preserved. // Short circuit for a common case of all analyses being preserved.
if (PA.areAllPreserved()) if (PA.areAllPreserved())
return PA; return PA;
if (DebugLogging) if (DebugLogging)
dbgs() << "Invalidating all non-preserved analyses for: " << IR.getName() dbgs() << "Invalidating all non-preserved analyses for: " << IR.getName()
<< "\n"; << "\n";
// Clear all the invalidated results associated specifically with this // Clear all the invalidated results associated specifically with this
// function. // function.
SmallVector<void *, 8> InvalidatedPassIDs; SmallVector<AnalysisKey, 8> InvalidatedAnalysisKeys;
AnalysisResultListT &ResultsList = AnalysisResultLists[&IR]; std::unique_ptr<AnalysisResultListT> &ResultsListPtr =
AnalysisResultLists[static_cast<TypeErasedIRUnitID>(&IR)];
if (!ResultsListPtr)
ResultsListPtr = make_unique<AnalysisResultListT>();
AnalysisResultListT &ResultsList = *ResultsListPtr;
for (typename AnalysisResultListT::iterator I = ResultsList.begin(), for (typename AnalysisResultListT::iterator I = ResultsList.begin(),
E = ResultsList.end(); E = ResultsList.end();
I != E;) { I != E;) {
void *PassID = I->first; AnalysisKey AK = I->AK;
// Pass the invalidation down to the pass itself to see if it thinks it is // Pass the invalidation down to the pass itself to see if it thinks it is
// necessary. The analysis pass can return false if no action on the part // necessary. The analysis pass can return false if no action on the part
// of the analysis manager is required for this invalidation event. // of the analysis manager is required for this invalidation event.
if (I->second->invalidate(IR, PA)) { if (I->Result->invalidate(static_cast<TypeErasedIRUnitID>(&IR), PA))
if (DebugLogging) I = invalidateImplImpl(AK, static_cast<TypeErasedIRUnitID>(&IR));
dbgs() << "Invalidating analysis: " << this->lookupPass(PassID).name() else
<< "\n";
InvalidatedPassIDs.push_back(I->first);
I = ResultsList.erase(I);
} else {
++I; ++I;
}
// After handling each pass, we mark it as preserved. Once we've // After handling each pass, we mark it as preserved. Once we've
// invalidated any stale results, the rest of the system is allowed to // invalidated any stale results, the rest of the system is allowed to
// start preserving this analysis again. // start preserving this analysis again.
PA.preserve(PassID); PA.preserve(AK.AnalysisID);
} }
while (!InvalidatedPassIDs.empty())
AnalysisResults.erase(
std::make_pair(InvalidatedPassIDs.pop_back_val(), &IR));
if (ResultsList.empty()) if (ResultsList.empty())
AnalysisResultLists.erase(&IR); AnalysisResultLists.erase(static_cast<TypeErasedIRUnitID>(&IR));
return PA; return PA;
} }
/// \brief List of function analysis pass IDs and associated concept pointers.
///
/// Requires iterators to be valid across appending new entries and arbitrary
/// erases. Provides both the pass ID and concept pointer such that it is
/// half of a bijection and provides storage for the actual result concept.
typedef std::list<std::pair<
void *, std::unique_ptr<detail::AnalysisResultConcept<IRUnitT>>>>
AnalysisResultListT;
/// \brief Map type from function pointer to our custom list type. /// \brief Map type from function pointer to our custom list type.
typedef DenseMap<IRUnitT *, AnalysisResultListT> AnalysisResultListMapT; typedef DenseMap<TypeErasedIRUnitID, std::unique_ptr<AnalysisResultListT>>
AnalysisResultListMapT;
/// \brief Map from function to a list of function analysis results. /// \brief Map from function to a list of function analysis results.
/// ///
/// Provides linear time removal of all analysis results for a function and /// Provides linear time removal of all analysis results for a function and
/// the ultimate storage for a particular cached analysis result. /// the ultimate storage for a particular cached analysis result.
AnalysisResultListMapT AnalysisResultLists; AnalysisResultListMapT AnalysisResultLists;
/// \brief Map type from a pair of analysis ID and function pointer to an /// \brief Map type from a pair of analysis ID and function pointer to an
/// iterator into a particular result list. /// iterator into a particular result list.
typedef DenseMap<std::pair<void *, IRUnitT *>, typedef DenseMap<std::pair<AnalysisKey, TypeErasedIRUnitID>,
typename AnalysisResultListT::iterator> typename AnalysisResultListT::iterator>
AnalysisResultMapT; AnalysisResultMapT;
/// \brief Map from an analysis ID and function to a particular cached /// \brief Map from an analysis ID and function to a particular cached
/// analysis result. /// analysis result.
AnalysisResultMapT AnalysisResults; AnalysisResultMapT AnalysisResults;
/// \brief A stack of analyses currently being computed.
SmallVector<AnalysisResultListT::iterator, 8> InFlightAnalysesStack;
/// \brief A flag indicating whether debug logging is enabled. /// \brief A flag indicating whether debug logging is enabled.
bool DebugLogging; bool DebugLogging;
}; };
extern template class AnalysisManager<Module>; /// \brief Manages a sequence of passes over units of IR.
/// \brief Convenience typedef for the Module analysis manager. ///
typedef AnalysisManager<Module> ModuleAnalysisManager; /// A pass manager contains a sequence of passes to run over units of IR. It is
/// itself a valid pass over that unit of IR, and when over some given IR will
extern template class AnalysisManager<Function>; /// run each pass in sequence. This is the primary and most basic building
/// \brief Convenience typedef for the Function analysis manager. /// block of a pass pipeline.
typedef AnalysisManager<Function> FunctionAnalysisManager; template <typename IRUnitT>
class PassManager : public PassInfoMixin<PassManager<IRUnitT>> {
/// \brief A module analysis which acts as a proxy for a function analysis
/// manager.
///
/// This primarily proxies invalidation information from the module analysis
/// manager and module pass manager to a function analysis manager. You should
/// never use a function analysis manager from within (transitively) a module
/// pass manager unless your parent module pass has received a proxy result
/// object for it.
///
/// Note that the proxy's result is a move-only object and represents ownership
/// of the validity of the analyses in the \c FunctionAnalysisManager it
/// provides.
template <typename AnalysisManagerT, typename IRUnitT>
class InnerAnalysisManagerProxy
: public AnalysisInfoMixin<
InnerAnalysisManagerProxy<AnalysisManagerT, IRUnitT>> {
public:
class Result {
public: public:
explicit Result(AnalysisManagerT &AM) : AM(&AM) {} /// \brief Construct a pass manager.
Result(Result &&Arg) : AM(std::move(Arg.AM)) { ///
// We have to null out the analysis manager in the moved-from state /// It can be passed a flag to get debug logging as the passes are run.
// because we are taking ownership of the responsibilty to clear the PassManager(bool DebugLogging = false) : DebugLogging(DebugLogging) {}
// analysis state.
Arg.AM = nullptr;
}
Result &operator=(Result &&RHS) {
AM = RHS.AM;
// We have to null out the analysis manager in the moved-from state
// because we are taking ownership of the responsibilty to clear the
// analysis state.
RHS.AM = nullptr;
return *this;
}
~Result() {
// AM is cleared in a moved from state where there is nothing to do.
if (!AM)
return;
// Clear out the analysis manager if we're being destroyed -- it means we
// didn't even see an invalidate call when we got invalidated.
AM->clear();
}
/// \brief Accessor for the analysis manager.
AnalysisManagerT &getManager() { return *AM; }
/// \brief Handler for invalidation of the module.
///
/// If this analysis itself is preserved, then we assume that the set of \c
/// Function objects in the \c Module hasn't changed and thus we don't need
/// to invalidate *all* cached data associated with a \c Function* in the \c
/// FunctionAnalysisManager.
///
/// Regardless of whether this analysis is marked as preserved, all of the
/// analyses in the \c FunctionAnalysisManager are potentially invalidated
/// based on the set of preserved analyses.
bool invalidate(IRUnitT &IR, const PreservedAnalyses &PA) {
// If this proxy isn't marked as preserved, then we can't even invalidate
// individual function analyses, there may be an invalid set of Function
// objects in the cache making it impossible to incrementally preserve
// them. Just clear the entire manager.
if (!PA.preserved(InnerAnalysisManagerProxy::ID()))
AM->clear();
// Return false to indicate that this result is still a valid proxy.
return false;
}
private:
AnalysisManagerT *AM;
};
explicit InnerAnalysisManagerProxy(AnalysisManagerT &AM) : AM(&AM) {}
// We have to explicitly define all the special member functions because MSVC // We have to explicitly define all the special member functions because MSVC
// refuses to generate them. // refuses to generate them.
InnerAnalysisManagerProxy(const InnerAnalysisManagerProxy &Arg) PassManager(PassManager &&Arg)
: AM(Arg.AM) {} : Passes(std::move(Arg.Passes)),
InnerAnalysisManagerProxy(InnerAnalysisManagerProxy &&Arg) DebugLogging(std::move(Arg.DebugLogging)) {}
: AM(std::move(Arg.AM)) {} PassManager &operator=(PassManager &&RHS) {
InnerAnalysisManagerProxy &operator=(InnerAnalysisManagerProxy RHS) { Passes = std::move(RHS.Passes);
std::swap(AM, RHS.AM); DebugLogging = std::move(RHS.DebugLogging);
return *this; return *this;
} }
/// \brief Run the analysis pass and create our proxy result object. /// \brief Run all of the passes in this manager over the IR.
/// PreservedAnalyses run(IRUnitT &IR, AnalysisManager &AM) {
/// This doesn't do any interesting work, it is primarily used to insert our PreservedAnalyses PA = PreservedAnalyses::all();
/// proxy result object into the module analysis cache so that we can proxy
/// invalidation to the function analysis manager.
///
/// In debug builds, it will also assert that the analysis manager is empty
/// as no queries should arrive at the function analysis manager prior to
/// this analysis being requested.
Result run(IRUnitT &IR, AnalysisManager<IRUnitT> &) { return Result(*AM); }
private: if (DebugLogging)
friend AnalysisInfoMixin< dbgs() << "Starting " << getTypeName<IRUnitT>() << " pass manager run.\n";
InnerAnalysisManagerProxy<AnalysisManagerT, IRUnitT>>;
static char PassID;
AnalysisManagerT *AM; for (unsigned Idx = 0, Size = Passes.size(); Idx != Size; ++Idx) {
}; if (DebugLogging)
dbgs() << "Running pass: " << Passes[Idx]->name() << " on "
<< IR.getName() << "\n";
template <typename AnalysisManagerT, typename IRUnitT> PreservedAnalyses PassPA = Passes[Idx]->run(IR, AM);
char InnerAnalysisManagerProxy<AnalysisManagerT, IRUnitT>::PassID;
extern template class InnerAnalysisManagerProxy<FunctionAnalysisManager, // Update the analysis manager as each pass runs and potentially
Module>; // invalidates analyses. We also update the preserved set of analyses
/// Provide the \c FunctionAnalysisManager to \c Module proxy. // based on what analyses we have already handled the invalidation for
typedef InnerAnalysisManagerProxy<FunctionAnalysisManager, Module> // here and don't need to invalidate when finished.
FunctionAnalysisManagerModuleProxy; PassPA = AM.invalidate(IR, std::move(PassPA));
/// \brief A function analysis which acts as a proxy for a module analysis
/// manager.
///
/// This primarily provides an accessor to a parent module analysis manager to
/// function passes. Only the const interface of the module analysis manager is
/// provided to indicate that once inside of a function analysis pass you
/// cannot request a module analysis to actually run. Instead, the user must
/// rely on the \c getCachedResult API.
///
/// This proxy *doesn't* manage the invalidation in any way. That is handled by
/// the recursive return path of each layer of the pass manager and the
/// returned PreservedAnalysis set.
template <typename AnalysisManagerT, typename IRUnitT>
class OuterAnalysisManagerProxy
: public AnalysisInfoMixin<
OuterAnalysisManagerProxy<AnalysisManagerT, IRUnitT>> {
public:
/// \brief Result proxy object for \c OuterAnalysisManagerProxy.
class Result {
public:
explicit Result(const AnalysisManagerT &AM) : AM(&AM) {}
// We have to explicitly define all the special member functions because
// MSVC refuses to generate them.
Result(const Result &Arg) : AM(Arg.AM) {}
Result(Result &&Arg) : AM(std::move(Arg.AM)) {}
Result &operator=(Result RHS) {
std::swap(AM, RHS.AM);
return *this;
}
const AnalysisManagerT &getManager() const { return *AM; } // Finally, we intersect the final preserved analyses to compute the
// aggregate preserved set for this pass manager.
PA.intersect(std::move(PassPA));
/// \brief Handle invalidation by ignoring it, this pass is immutable. // FIXME: Historically, the pass managers all called the LLVM context's
bool invalidate(IRUnitT &) { return false; } // yield function here. We don't have a generic way to acquire the
// context and it isn't yet clear what the right pattern is for yielding
// in the new pass manager so it is currently omitted.
//IR.getContext().yield();
}
private: if (DebugLogging)
const AnalysisManagerT *AM; dbgs() << "Finished " << getTypeName<IRUnitT>() << " pass manager run.\n";
};
OuterAnalysisManagerProxy(const AnalysisManagerT &AM) : AM(&AM) {} return PA;
// We have to explicitly define all the special member functions because MSVC
// refuses to generate them.
OuterAnalysisManagerProxy(const OuterAnalysisManagerProxy &Arg)
: AM(Arg.AM) {}
OuterAnalysisManagerProxy(OuterAnalysisManagerProxy &&Arg)
: AM(std::move(Arg.AM)) {}
OuterAnalysisManagerProxy &operator=(OuterAnalysisManagerProxy RHS) {
std::swap(AM, RHS.AM);
return *this;
} }
/// \brief Run the analysis pass and create our proxy result object. template <typename PassT> void addPass(PassT Pass) {
/// Nothing to see here, it just forwards the \c AM reference into the typedef detail::PassModel<IRUnitT, PassT> PassModelT;
/// result. Passes.emplace_back(new PassModelT(std::move(Pass)));
Result run(IRUnitT &, AnalysisManager<IRUnitT> &) { return Result(*AM); } }
private: private:
friend AnalysisInfoMixin< typedef detail::PassConcept<IRUnitT> PassConceptT;
OuterAnalysisManagerProxy<AnalysisManagerT, IRUnitT>>;
static char PassID; PassManager(const PassManager &) = delete;
PassManager &operator=(const PassManager &) = delete;
std::vector<std::unique_ptr<PassConceptT>> Passes;
const AnalysisManagerT *AM; /// \brief Flag indicating whether we should do debug logging.
bool DebugLogging;
}; };
template <typename AnalysisManagerT, typename IRUnitT> extern template class PassManager<Module>;
char OuterAnalysisManagerProxy<AnalysisManagerT, IRUnitT>::PassID; /// \brief Convenience typedef for a pass manager over modules.
typedef PassManager<Module> ModulePassManager;
extern template class PassManager<Function>;
/// \brief Convenience typedef for a pass manager over functions.
typedef PassManager<Function> FunctionPassManager;
extern template class OuterAnalysisManagerProxy<ModuleAnalysisManager,
Function>;
/// Provide the \c ModuleAnalysisManager to \c Fucntion proxy.
typedef OuterAnalysisManagerProxy<ModuleAnalysisManager, Function>
ModuleAnalysisManagerFunctionProxy;
/// \brief Trivial adaptor that maps from a module to its functions. /// \brief Trivial adaptor that maps from a module to its functions.
/// ///
/// Designed to allow composition of a FunctionPass(Manager) and /// Designed to allow composition of a FunctionPass(Manager) and
/// a ModulePassManager. Note that if this pass is constructed with a pointer /// a ModulePassManager.
/// to a \c ModuleAnalysisManager it will run the
/// \c FunctionAnalysisManagerModuleProxy analysis prior to running the function
/// pass over the module to enable a \c FunctionAnalysisManager to be used
/// within this run safely.
/// ///
/// Function passes run within this adaptor can rely on having exclusive access /// Function passes run within this adaptor can rely on having exclusive access
/// to the function they are run over. They should not read or modify any other /// to the function they are run over. They should not read or modify any other
/// functions! Other threads or systems may be manipulating other functions in /// functions! Other threads or systems may be manipulating other functions in
/// the module, and so their state should never be relied on. /// the module, and so their state should never be relied on.
/// FIXME: Make the above true for all of LLVM's actual passes, some still /// FIXME: Make the above true for all of LLVM's actual passes, some still
/// violate this principle. /// violate this principle.
/// ///
Show All 21 Lines friend void swap(ModuleToFunctionPassAdaptor &LHS,
swap(LHS.Pass, RHS.Pass); swap(LHS.Pass, RHS.Pass);
} }
ModuleToFunctionPassAdaptor &operator=(ModuleToFunctionPassAdaptor RHS) { ModuleToFunctionPassAdaptor &operator=(ModuleToFunctionPassAdaptor RHS) {
swap(*this, RHS); swap(*this, RHS);
return *this; return *this;
} }
/// \brief Runs the function pass across every function in the module. /// \brief Runs the function pass across every function in the module.
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM) { PreservedAnalyses run(Module &M, AnalysisManager &AM) {
// Setup the function analysis manager from its proxy.
FunctionAnalysisManager &FAM =
AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
PreservedAnalyses PA = PreservedAnalyses::all(); PreservedAnalyses PA = PreservedAnalyses::all();
for (Function &F : M) { for (Function &F : M) {
if (F.isDeclaration()) if (F.isDeclaration())
continue; continue;
PreservedAnalyses PassPA = Pass.run(F, FAM); PreservedAnalyses PassPA = Pass.run(F, AM);
// We know that the function pass couldn't have invalidated any other // We know that the function pass couldn't have invalidated any other
// function's analyses (that's the contract of a function pass), so // function's analyses (that's the contract of a function pass), so
// directly handle the function analysis manager's invalidation here and // directly handle the function analysis manager's invalidation here and
// update our preserved set to reflect that these have already been // update our preserved set to reflect that these have already been
// handled. // handled.
PassPA = FAM.invalidate(F, std::move(PassPA)); PassPA = AM.invalidate(F, std::move(PassPA));
// Then intersect the preserved set so that invalidation of module // Then intersect the preserved set so that invalidation of module
// analyses will eventually occur when the module pass completes. // analyses will eventually occur when the module pass completes.
PA.intersect(std::move(PassPA)); PA.intersect(std::move(PassPA));
} }
// By definition we preserve the proxy. This precludes *any* invalidation PA.preserve<ParentIRUnitTrackingAnalysis<Module>>();
// of function analyses by the proxy, but that's OK because we've taken
// care to invalidate analyses in the function analysis manager
// incrementally above.
PA.preserve<FunctionAnalysisManagerModuleProxy>();
return PA; return PA;
} }
private: private:
FunctionPassT Pass; FunctionPassT Pass;
}; };
/// \brief A function to deduce a function pass type and wrap it in the /// \brief A function to deduce a function pass type and wrap it in the
Show All 12 Lines
struct RequireAnalysisPass : PassInfoMixin<RequireAnalysisPass<AnalysisT>> { struct RequireAnalysisPass : PassInfoMixin<RequireAnalysisPass<AnalysisT>> {
/// \brief Run this pass over some unit of IR. /// \brief Run this pass over some unit of IR.
/// ///
/// This pass can be run over any unit of IR and use any analysis manager /// This pass can be run over any unit of IR and use any analysis manager
/// provided they satisfy the basic API requirements. When this pass is /// provided they satisfy the basic API requirements. When this pass is
/// created, these methods can be instantiated to satisfy whatever the /// created, these methods can be instantiated to satisfy whatever the
/// context requires. /// context requires.
template <typename IRUnitT> template <typename IRUnitT>
PreservedAnalyses run(IRUnitT &Arg, AnalysisManager<IRUnitT> &AM) { PreservedAnalyses run(IRUnitT &Arg, AnalysisManager &AM) {
(void)AM.template getResult<AnalysisT>(Arg); (void)AM.template getResult<AnalysisT>(Arg);
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
}; };
/// \brief A template utility pass to force an analysis result to be /// \brief A template utility pass to force an analysis result to be
/// invalidated. /// invalidated.
/// ///
/// This is a no-op pass which simply forces a specific analysis result to be /// This is a no-op pass which simply forces a specific analysis result to be
/// invalidated when it is run. /// invalidated when it is run.
template <typename AnalysisT> template <typename AnalysisT>
struct InvalidateAnalysisPass struct InvalidateAnalysisPass
: PassInfoMixin<InvalidateAnalysisPass<AnalysisT>> { : PassInfoMixin<InvalidateAnalysisPass<AnalysisT>> {
/// \brief Run this pass over some unit of IR. /// \brief Run this pass over some unit of IR.
/// ///
/// This pass can be run over any unit of IR and use any analysis manager /// This pass can be run over any unit of IR and use any analysis manager
/// provided they satisfy the basic API requirements. When this pass is /// provided they satisfy the basic API requirements. When this pass is
/// created, these methods can be instantiated to satisfy whatever the /// created, these methods can be instantiated to satisfy whatever the
/// context requires. /// context requires.
template <typename IRUnitT> template <typename IRUnitT>
PreservedAnalyses run(IRUnitT &Arg, AnalysisManager<IRUnitT> &AM) { PreservedAnalyses run(IRUnitT &Arg, AnalysisManager &AM) {
// We have to directly invalidate the analysis result as we can't // We have to directly invalidate the analysis result as we can't
// enumerate all other analyses and use the preserved set to control it. // enumerate all other analyses and use the preserved set to control it.
AM.template invalidate<AnalysisT>(Arg); AM.template invalidate<AnalysisT>(Arg);
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
}; };
/// \brief A utility pass that does nothing but preserves no analyses. /// \brief A utility pass that does nothing but preserves no analyses.
/// ///
/// As a consequence fo not preserving any analyses, this pass will force all /// As a consequence fo not preserving any analyses, this pass will force all
/// analysis passes to be re-run to produce fresh results if any are needed. /// analysis passes to be re-run to produce fresh results if any are needed.
struct InvalidateAllAnalysesPass : PassInfoMixin<InvalidateAllAnalysesPass> { struct InvalidateAllAnalysesPass : PassInfoMixin<InvalidateAllAnalysesPass> {
/// \brief Run this pass over some unit of IR. /// \brief Run this pass over some unit of IR.
template <typename IRUnitT> template <typename IRUnitT>
PreservedAnalyses run(IRUnitT &, AnalysisManager<IRUnitT> &) { PreservedAnalyses run(IRUnitT &, AnalysisManager &) {
return PreservedAnalyses::none(); return PreservedAnalyses::none();
} }
}; };
/// A utility pass template that simply runs another pass multiple times. /// A utility pass template that simply runs another pass multiple times.
/// ///
/// This can be useful when debugging or testing passes. It also serves as an /// This can be useful when debugging or testing passes. It also serves as an
/// example of how to extend the pass manager in ways beyond composition. /// example of how to extend the pass manager in ways beyond composition.
Show All 11 Lines friend void swap(RepeatedPass &LHS, RepeatedPass &RHS) {
swap(LHS.P, RHS.P); swap(LHS.P, RHS.P);
} }
RepeatedPass &operator=(RepeatedPass RHS) { RepeatedPass &operator=(RepeatedPass RHS) {
swap(*this, RHS); swap(*this, RHS);
return *this; return *this;
} }
template <typename IRUnitT, typename... Ts> template <typename IRUnitT, typename... Ts>
PreservedAnalyses run(IRUnitT &Arg, AnalysisManager<IRUnitT> &AM, PreservedAnalyses run(IRUnitT &Arg, AnalysisManager &AM, Ts... Args) {
Ts... Args) {
auto PA = PreservedAnalyses::all(); auto PA = PreservedAnalyses::all();
for (int i = 0; i < Count; ++i) for (int i = 0; i < Count; ++i)
PA.intersect(P.run(Arg, AM, Args...)); PA.intersect(P.run(Arg, AM, Args...));
return PA; return PA;
} }
private: private:
int Count; int Count;
Show All 11 Lines

include/llvm/IR/PassManagerInternal.h

Show All 17 Lines
#ifndef LLVM_IR_PASSMANAGERINTERNAL_H #ifndef LLVM_IR_PASSMANAGERINTERNAL_H
#define LLVM_IR_PASSMANAGERINTERNAL_H #define LLVM_IR_PASSMANAGERINTERNAL_H
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
namespace llvm { namespace llvm {
template <typename IRUnitT> class AnalysisManager; /// More semantically meaningful name for opaque handle type.
typedef void *TypeErasedIRUnitID;
enum IRUnitKind { IRK_Loop, IRK_Function, IRK_CGSCC, IRK_Module };
class AnalysisManager;
class PreservedAnalyses; class PreservedAnalyses;
/// \brief Implementation details of the pass manager interfaces. /// \brief Implementation details of the pass manager interfaces.
namespace detail { namespace detail {
/// \brief Template for the abstract base class used to dispatch /// \brief Template for the abstract base class used to dispatch
/// polymorphically over pass objects. /// polymorphically over pass objects.
template <typename IRUnitT> struct PassConcept { template <typename IRUnitT> struct PassConcept {
// Boiler plate necessary for the container of derived classes. // Boiler plate necessary for the container of derived classes.
virtual ~PassConcept() {} virtual ~PassConcept() {}
/// \brief The polymorphic API which runs the pass over a given IR entity. /// \brief The polymorphic API which runs the pass over a given IR entity.
virtual PreservedAnalyses run(IRUnitT &IR, AnalysisManager<IRUnitT> &AM) = 0; virtual PreservedAnalyses run(IRUnitT &IR, AnalysisManager &AM) = 0;
/// \brief Polymorphic method to access the name of a pass. /// \brief Polymorphic method to access the name of a pass.
virtual StringRef name() = 0; virtual StringRef name() = 0;
}; };
/// \brief A template wrapper used to implement the polymorphic API. /// \brief A template wrapper used to implement the polymorphic API.
/// ///
/// Can be instantiated for any object which provides a \c run method accepting /// Can be instantiated for any object which provides a \c run method accepting
/// an \c IRUnitT& and an \c AnalysisManager<IRUnit>&. It requires the pass to /// an \c IRUnitT& and an \c AnalysisManager&. It requires the pass to
/// be a copyable object. /// be a copyable object.
template <typename IRUnitT, typename PassT, template <typename IRUnitT, typename PassT,
typename PreservedAnalysesT = PreservedAnalyses> typename PreservedAnalysesT = PreservedAnalyses>
struct PassModel : PassConcept<IRUnitT> { struct PassModel : PassConcept<IRUnitT> {
explicit PassModel(PassT Pass) : Pass(std::move(Pass)) {} explicit PassModel(PassT Pass) : Pass(std::move(Pass)) {}
// We have to explicitly define all the special member functions because MSVC // We have to explicitly define all the special member functions because MSVC
// refuses to generate them. // refuses to generate them.
PassModel(const PassModel &Arg) : Pass(Arg.Pass) {} PassModel(const PassModel &Arg) : Pass(Arg.Pass) {}
PassModel(PassModel &&Arg) : Pass(std::move(Arg.Pass)) {} PassModel(PassModel &&Arg) : Pass(std::move(Arg.Pass)) {}
friend void swap(PassModel &LHS, PassModel &RHS) { friend void swap(PassModel &LHS, PassModel &RHS) {
using std::swap; using std::swap;
swap(LHS.Pass, RHS.Pass); swap(LHS.Pass, RHS.Pass);
} }
PassModel &operator=(PassModel RHS) { PassModel &operator=(PassModel RHS) {
swap(*this, RHS); swap(*this, RHS);
return *this; return *this;
} }
PreservedAnalysesT run(IRUnitT &IR, AnalysisManager<IRUnitT> &AM) override { PreservedAnalysesT run(IRUnitT &IR, AnalysisManager &AM) override {
return Pass.run(IR, AM); return Pass.run(IR, AM);
} }
StringRef name() override { return PassT::name(); } StringRef name() override { return PassT::name(); }
PassT Pass; PassT Pass;
}; };
/// \brief Abstract concept of an analysis result. /// \brief Abstract concept of an analysis result.
/// ///
/// This concept is parameterized over the IR unit that this result pertains /// This concept is parameterized over the IR unit that this result pertains
/// to. /// to.
template <typename IRUnitT> struct AnalysisResultConcept { struct AnalysisResultConcept {
virtual ~AnalysisResultConcept() {} virtual ~AnalysisResultConcept() {}
/// \brief Method to try and mark a result as invalid. /// \brief Method to try and mark a result as invalid.
/// ///
/// When the outer analysis manager detects a change in some underlying /// When the outer analysis manager detects a change in some underlying
/// unit of the IR, it will call this method on all of the results cached. /// unit of the IR, it will call this method on all of the results cached.
/// ///
/// This method also receives a set of preserved analyses which can be used /// This method also receives a set of preserved analyses which can be used
/// to avoid invalidation because the pass which changed the underlying IR /// to avoid invalidation because the pass which changed the underlying IR
/// took care to update or preserve the analysis result in some way. /// took care to update or preserve the analysis result in some way.
/// ///
/// \returns true if the result is indeed invalid (the default). /// \returns true if the result is indeed invalid (the default).
virtual bool invalidate(IRUnitT &IR, const PreservedAnalyses &PA) = 0; virtual bool invalidate(TypeErasedIRUnitID IR,
const PreservedAnalyses &PA) = 0;
}; };
/// \brief SFINAE metafunction for computing whether \c ResultT provides an /// \brief SFINAE metafunction for computing whether \c ResultT provides an
/// \c invalidate member function. /// \c invalidate member function.
template <typename IRUnitT, typename ResultT> class ResultHasInvalidateMethod { template <typename IRUnitT, typename ResultT> class ResultHasInvalidateMethod {
typedef char SmallType; typedef char SmallType;
struct BigType { struct BigType {
char a, b; char a, b;
Show All 21 Linestemplate <typename IRUnitT, typename PassT, typename ResultT,
ResultHasInvalidateMethod<IRUnitT, ResultT>::Value> ResultHasInvalidateMethod<IRUnitT, ResultT>::Value>
struct AnalysisResultModel; struct AnalysisResultModel;
/// \brief Specialization of \c AnalysisResultModel which provides the default /// \brief Specialization of \c AnalysisResultModel which provides the default
/// invalidate functionality. /// invalidate functionality.
template <typename IRUnitT, typename PassT, typename ResultT, template <typename IRUnitT, typename PassT, typename ResultT,
typename PreservedAnalysesT> typename PreservedAnalysesT>
struct AnalysisResultModel<IRUnitT, PassT, ResultT, PreservedAnalysesT, false> struct AnalysisResultModel<IRUnitT, PassT, ResultT, PreservedAnalysesT, false>
: AnalysisResultConcept<IRUnitT> { : AnalysisResultConcept {
explicit AnalysisResultModel(ResultT Result) : Result(std::move(Result)) {} explicit AnalysisResultModel(ResultT Result) : Result(std::move(Result)) {}
// We have to explicitly define all the special member functions because MSVC // We have to explicitly define all the special member functions because MSVC
// refuses to generate them. // refuses to generate them.
AnalysisResultModel(const AnalysisResultModel &Arg) : Result(Arg.Result) {} AnalysisResultModel(const AnalysisResultModel &Arg) : Result(Arg.Result) {}
AnalysisResultModel(AnalysisResultModel &&Arg) AnalysisResultModel(AnalysisResultModel &&Arg)
: Result(std::move(Arg.Result)) {} : Result(std::move(Arg.Result)) {}
friend void swap(AnalysisResultModel &LHS, AnalysisResultModel &RHS) { friend void swap(AnalysisResultModel &LHS, AnalysisResultModel &RHS) {
using std::swap; using std::swap;
swap(LHS.Result, RHS.Result); swap(LHS.Result, RHS.Result);
} }
AnalysisResultModel &operator=(AnalysisResultModel RHS) { AnalysisResultModel &operator=(AnalysisResultModel RHS) {
swap(*this, RHS); swap(*this, RHS);
return *this; return *this;
} }
/// \brief The model bases invalidation solely on being in the preserved set. /// \brief The model bases invalidation solely on being in the preserved set.
// //
// FIXME: We should actually use two different concepts for analysis results // FIXME: We should actually use two different concepts for analysis results
// rather than two different models, and avoid the indirect function call for // rather than two different models, and avoid the indirect function call for
// ones that use the trivial behavior. // ones that use the trivial behavior.
bool invalidate(IRUnitT &, const PreservedAnalysesT &PA) override { bool invalidate(TypeErasedIRUnitID IR,
const PreservedAnalysesT &PA) override {
return !PA.preserved(PassT::ID()); return !PA.preserved(PassT::ID());
} }
ResultT Result; ResultT Result;
}; };
/// \brief Specialization of \c AnalysisResultModel which delegates invalidate /// \brief Specialization of \c AnalysisResultModel which delegates invalidate
/// handling to \c ResultT. /// handling to \c ResultT.
template <typename IRUnitT, typename PassT, typename ResultT, template <typename IRUnitT, typename PassT, typename ResultT,
typename PreservedAnalysesT> typename PreservedAnalysesT>
struct AnalysisResultModel<IRUnitT, PassT, ResultT, PreservedAnalysesT, true> struct AnalysisResultModel<IRUnitT, PassT, ResultT, PreservedAnalysesT, true>
: AnalysisResultConcept<IRUnitT> { : AnalysisResultConcept {
explicit AnalysisResultModel(ResultT Result) : Result(std::move(Result)) {} explicit AnalysisResultModel(ResultT Result) : Result(std::move(Result)) {}
// We have to explicitly define all the special member functions because MSVC // We have to explicitly define all the special member functions because MSVC
// refuses to generate them. // refuses to generate them.
AnalysisResultModel(const AnalysisResultModel &Arg) : Result(Arg.Result) {} AnalysisResultModel(const AnalysisResultModel &Arg) : Result(Arg.Result) {}
AnalysisResultModel(AnalysisResultModel &&Arg) AnalysisResultModel(AnalysisResultModel &&Arg)
: Result(std::move(Arg.Result)) {} : Result(std::move(Arg.Result)) {}
friend void swap(AnalysisResultModel &LHS, AnalysisResultModel &RHS) { friend void swap(AnalysisResultModel &LHS, AnalysisResultModel &RHS) {
using std::swap; using std::swap;
swap(LHS.Result, RHS.Result); swap(LHS.Result, RHS.Result);
} }
AnalysisResultModel &operator=(AnalysisResultModel RHS) { AnalysisResultModel &operator=(AnalysisResultModel RHS) {
swap(*this, RHS); swap(*this, RHS);
return *this; return *this;
} }
/// \brief The model delegates to the \c ResultT method. /// \brief The model delegates to the \c ResultT method.
bool invalidate(IRUnitT &IR, const PreservedAnalysesT &PA) override { bool invalidate(TypeErasedIRUnitID IR,
return Result.invalidate(IR, PA); const PreservedAnalysesT &PA) override {
return Result.invalidate(*(IRUnitT *)IR, PA);
} }
ResultT Result; ResultT Result;
}; };
/// \brief Abstract concept of an analysis pass. /// \brief Abstract concept of an analysis pass.
/// ///
/// This concept is parameterized over the IR unit that it can run over and /// This concept is parameterized over the IR unit that it can run over and
/// produce an analysis result. /// produce an analysis result.
template <typename IRUnitT> struct AnalysisPassConcept { struct AnalysisPassConcept {
virtual ~AnalysisPassConcept() {} virtual ~AnalysisPassConcept() {}
/// \brief Method to run this analysis over a unit of IR. /// \brief Method to run this analysis over a unit of IR.
/// \returns A unique_ptr to the analysis result object to be queried by /// \returns A unique_ptr to the analysis result object to be queried by
/// users. /// users.
virtual std::unique_ptr<AnalysisResultConcept<IRUnitT>> virtual std::unique_ptr<AnalysisResultConcept>
run(IRUnitT &IR, AnalysisManager<IRUnitT> &AM) = 0; run(TypeErasedIRUnitID IR, AnalysisManager &AM) = 0;
/// \brief Polymorphic method to access the name of a pass. /// \brief Polymorphic method to access the name of a pass.
virtual StringRef name() = 0; virtual StringRef name() = 0;
}; };
/// \brief Wrapper to model the analysis pass concept. /// \brief Wrapper to model the analysis pass concept.
/// ///
/// Can wrap any type which implements a suitable \c run method. The method /// Can wrap any type which implements a suitable \c run method. The method
/// must accept an \c IRUnitT& and an \c AnalysisManager<IRUnitT>& as arguments /// must accept an \c IRUnitT& and an \c AnalysisManager& as arguments
/// and produce an object which can be wrapped in a \c AnalysisResultModel. /// and produce an object which can be wrapped in a \c AnalysisResultModel.
template <typename IRUnitT, typename PassT> template <typename IRUnitT, typename PassT>
struct AnalysisPassModel : AnalysisPassConcept<IRUnitT> { struct AnalysisPassModel : AnalysisPassConcept {
explicit AnalysisPassModel(PassT Pass) : Pass(std::move(Pass)) {} explicit AnalysisPassModel(PassT Pass) : Pass(std::move(Pass)) {}
// We have to explicitly define all the special member functions because MSVC // We have to explicitly define all the special member functions because MSVC
// refuses to generate them. // refuses to generate them.
AnalysisPassModel(const AnalysisPassModel &Arg) : Pass(Arg.Pass) {} AnalysisPassModel(const AnalysisPassModel &Arg) : Pass(Arg.Pass) {}
AnalysisPassModel(AnalysisPassModel &&Arg) : Pass(std::move(Arg.Pass)) {} AnalysisPassModel(AnalysisPassModel &&Arg) : Pass(std::move(Arg.Pass)) {}
friend void swap(AnalysisPassModel &LHS, AnalysisPassModel &RHS) { friend void swap(AnalysisPassModel &LHS, AnalysisPassModel &RHS) {
using std::swap; using std::swap;
swap(LHS.Pass, RHS.Pass); swap(LHS.Pass, RHS.Pass);
} }
AnalysisPassModel &operator=(AnalysisPassModel RHS) { AnalysisPassModel &operator=(AnalysisPassModel RHS) {
swap(*this, RHS); swap(*this, RHS);
return *this; return *this;
} }
// FIXME: Replace PassT::Result with type traits when we use C++11. // FIXME: Replace PassT::Result with type traits when we use C++11.
typedef AnalysisResultModel<IRUnitT, PassT, typename PassT::Result> typedef AnalysisResultModel<IRUnitT, PassT, typename PassT::Result>
ResultModelT; ResultModelT;
/// \brief The model delegates to the \c PassT::run method. /// \brief The model delegates to the \c PassT::run method.
/// ///
/// The return is wrapped in an \c AnalysisResultModel. /// The return is wrapped in an \c AnalysisResultModel.
std::unique_ptr<AnalysisResultConcept<IRUnitT>> std::unique_ptr<AnalysisResultConcept> run(TypeErasedIRUnitID IR,
run(IRUnitT &IR, AnalysisManager<IRUnitT> &AM) override { AnalysisManager &AM) override {
return make_unique<ResultModelT>(Pass.run(IR, AM)); return make_unique<ResultModelT>(Pass.run(*(IRUnitT *)IR, AM));
} }
/// \brief The model delegates to a static \c PassT::name method. /// \brief The model delegates to a static \c PassT::name method.
/// ///
/// The returned string ref must point to constant immutable data! /// The returned string ref must point to constant immutable data!
StringRef name() override { return PassT::name(); } StringRef name() override { return PassT::name(); }
PassT Pass; PassT Pass;
}; };
} // End namespace detail } // End namespace detail
} }
#endif #endif

include/llvm/IR/Verifier.h

Show First 20 Lines • Show All 59 Lines • ▼ Show 20 Linesclass VerifierAnalysis : public AnalysisInfoMixin<VerifierAnalysis> {
friend AnalysisInfoMixin<VerifierAnalysis>; friend AnalysisInfoMixin<VerifierAnalysis>;
static char PassID; static char PassID;
public: public:
struct Result { struct Result {
bool IRBroken, DebugInfoBroken; bool IRBroken, DebugInfoBroken;
}; };
static void *ID() { return (void *)&PassID; } static void *ID() { return (void *)&PassID; }
Result run(Module &M, ModuleAnalysisManager &); Result run(Module &M, AnalysisManager &);
Result run(Function &F, FunctionAnalysisManager &); Result run(Function &F, AnalysisManager &);
}; };
/// Check a module for errors, but report debug info errors separately. /// Check a module for errors, but report debug info errors separately.
/// Otherwise behaves as the normal verifyModule. Debug info errors can be /// Otherwise behaves as the normal verifyModule. Debug info errors can be
/// "recovered" from by stripping the debug info. /// "recovered" from by stripping the debug info.
bool verifyModule(bool &BrokenDebugInfo, const Module &M, raw_ostream *OS); bool verifyModule(bool &BrokenDebugInfo, const Module &M, raw_ostream *OS);
/// \brief Create a verifier pass. /// \brief Create a verifier pass.
/// ///
/// Check a module or function for validity. This is essentially a pass wrapped /// Check a module or function for validity. This is essentially a pass wrapped
/// around the above verifyFunction and verifyModule routines and /// around the above verifyFunction and verifyModule routines and
/// functionality. When the pass detects a verification error it is always /// functionality. When the pass detects a verification error it is always
/// printed to stderr, and by default they are fatal. You can override that by /// printed to stderr, and by default they are fatal. You can override that by
/// passing \c false to \p FatalErrors. /// passing \c false to \p FatalErrors.
/// ///
/// Note that this creates a pass suitable for the legacy pass manager. It has /// Note that this creates a pass suitable for the legacy pass manager. It has
/// nothing to do with \c VerifierPass. /// nothing to do with \c VerifierPass.
class VerifierPass : public PassInfoMixin<VerifierPass> { class VerifierPass : public PassInfoMixin<VerifierPass> {
bool FatalErrors; bool FatalErrors;
public: public:
explicit VerifierPass(bool FatalErrors = true) : FatalErrors(FatalErrors) {} explicit VerifierPass(bool FatalErrors = true) : FatalErrors(FatalErrors) {}
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM); PreservedAnalyses run(Module &M, AnalysisManager &AM);
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
} // End llvm namespace } // End llvm namespace
#endif #endif

include/llvm/Passes/PassBuilder.h

Show First 20 Lines • Show All 119 Lines • ▼ Show 20 Lines enum OptimizationLevel {
/// any effort taken to reduce the size is worth it regardless of the /// any effort taken to reduce the size is worth it regardless of the
/// execution time impact. You should expect this level to produce rather /// execution time impact. You should expect this level to produce rather
/// slow, but very small, code. /// slow, but very small, code.
Oz Oz
}; };
explicit PassBuilder(TargetMachine *TM = nullptr) : TM(TM) {} explicit PassBuilder(TargetMachine *TM = nullptr) : TM(TM) {}
/// \brief Cross register the analysis managers through their proxies.
///
/// This is an interface that can be used to cross register each
// AnalysisManager with all the others analysis managers.
void crossRegisterProxies(LoopAnalysisManager &LAM,
FunctionAnalysisManager &FAM,
CGSCCAnalysisManager &CGAM,
ModuleAnalysisManager &MAM);
/// \brief Registers all available module analysis passes. /// \brief Registers all available module analysis passes.
/// ///
/// This is an interface that can be used to populate a \c /// This is an interface that can be used to populate an \c
/// ModuleAnalysisManager with all registered module analyses. Callers can /// AnalysisManager with all registered module analyses. Callers can
/// still manually register any additional analyses. Callers can also /// still manually register any additional analyses. Callers can also
/// pre-register analyses and this will not override those. /// pre-register analyses and this will not override those.
void registerModuleAnalyses(ModuleAnalysisManager &MAM); void registerModuleAnalyses(AnalysisManager &AM);
/// \brief Registers all available CGSCC analysis passes. /// \brief Registers all available CGSCC analysis passes.
/// ///
/// This is an interface that can be used to populate a \c CGSCCAnalysisManager /// This is an interface that can be used to populate an \c AnalysisManager
/// with all registered CGSCC analyses. Callers can still manually register any /// with all registered CGSCC analyses. Callers can still manually register any
/// additional analyses. Callers can also pre-register analyses and this will /// additional analyses. Callers can also pre-register analyses and this will
/// not override those. /// not override those.
void registerCGSCCAnalyses(CGSCCAnalysisManager &CGAM); void registerCGSCCAnalyses(AnalysisManager &AM);
/// \brief Registers all available function analysis passes. /// \brief Registers all available function analysis passes.
/// ///
/// This is an interface that can be used to populate a \c /// This is an interface that can be used to populate an \c
/// FunctionAnalysisManager with all registered function analyses. Callers can /// AnalysisManager with all registered function analyses. Callers can
/// still manually register any additional analyses. Callers can also /// still manually register any additional analyses. Callers can also
/// pre-register analyses and this will not override those. /// pre-register analyses and this will not override those.
void registerFunctionAnalyses(FunctionAnalysisManager &FAM); void registerFunctionAnalyses(AnalysisManager &AM);
/// \brief Registers all available loop analysis passes. /// \brief Registers all available loop analysis passes.
/// ///
/// This is an interface that can be used to populate a \c LoopAnalysisManager /// This is an interface that can be used to populate an \c AnalysisManager
/// with all registered loop analyses. Callers can still manually register any /// with all registered loop analyses. Callers can still manually register any
/// additional analyses. /// additional analyses.
void registerLoopAnalyses(LoopAnalysisManager &LAM); void registerLoopAnalyses(AnalysisManager &AM);
/// \brief Add a per-module default optimization pipeline to a pass manager. /// \brief Add a per-module default optimization pipeline to a pass manager.
/// ///
/// This provides a good default optimization pipeline for per-module /// This provides a good default optimization pipeline for per-module
/// optimization and code generation without any link-time optimization. It /// optimization and code generation without any link-time optimization. It
/// typically correspond to frontend "-O[123]" options for optimization /// typically correspond to frontend "-O[123]" options for optimization
/// levels \c O1, \c O2 and \c O3 resp. /// levels \c O1, \c O2 and \c O3 resp.
void addPerModuleDefaultPipeline(ModulePassManager &MPM, void addPerModuleDefaultPipeline(ModulePassManager &MPM,
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines

include/llvm/Transforms/GCOVProfiler.h

Show All 15 Lines
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
#include "llvm/Transforms/Instrumentation.h" #include "llvm/Transforms/Instrumentation.h"
namespace llvm { namespace llvm {
/// The gcov-style instrumentation pass /// The gcov-style instrumentation pass
class GCOVProfilerPass : public PassInfoMixin<GCOVProfilerPass> { class GCOVProfilerPass : public PassInfoMixin<GCOVProfilerPass> {
public: public:
GCOVProfilerPass(const GCOVOptions &Options = GCOVOptions::getDefault()) : GCOVOpts(Options) { } GCOVProfilerPass(const GCOVOptions &Options = GCOVOptions::getDefault()) : GCOVOpts(Options) { }
PreservedAnalyses run(Module &M, AnalysisManager<Module> &AM); PreservedAnalyses run(Module &M, AnalysisManager &AM);
private: private:
GCOVOptions GCOVOpts; GCOVOptions GCOVOpts;
}; };
} // End llvm namespace } // End llvm namespace
#endif #endif

include/llvm/Transforms/IPO/ConstantMerge.h

Show All 22 Lines
#include "llvm/IR/Module.h" #include "llvm/IR/Module.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
/// A pass that merges duplicate global constants into a single constant. /// A pass that merges duplicate global constants into a single constant.
class ConstantMergePass : public PassInfoMixin<ConstantMergePass> { class ConstantMergePass : public PassInfoMixin<ConstantMergePass> {
public: public:
PreservedAnalyses run(Module &M, ModuleAnalysisManager &); PreservedAnalyses run(Module &M, AnalysisManager &);
}; };
} }
#endif // LLVM_TRANSFORMS_IPO_CONSTANTMERGE_H #endif // LLVM_TRANSFORMS_IPO_CONSTANTMERGE_H

include/llvm/Transforms/IPO/CrossDSOCFI.h

Show All 15 Lines
#define LLVM_TRANSFORMS_IPO_CROSSDSOCFI_H #define LLVM_TRANSFORMS_IPO_CROSSDSOCFI_H
#include "llvm/IR/Module.h" #include "llvm/IR/Module.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
class CrossDSOCFIPass : public PassInfoMixin<CrossDSOCFIPass> { class CrossDSOCFIPass : public PassInfoMixin<CrossDSOCFIPass> {
public: public:
PreservedAnalyses run(Module &M, AnalysisManager<Module> &AM); PreservedAnalyses run(Module &M, AnalysisManager &AM);
}; };
} }
#endif // LLVM_TRANSFORMS_IPO_CROSSDSOCFI_H #endif // LLVM_TRANSFORMS_IPO_CROSSDSOCFI_H

include/llvm/Transforms/IPO/DeadArgumentElimination.h

Show First 20 Lines • Show All 104 Lines • ▼ Show 20 Linespublic:
/// This allows this pass to do double-duty as the dead arg hacking pass /// This allows this pass to do double-duty as the dead arg hacking pass
/// (used only by bugpoint). /// (used only by bugpoint).
bool ShouldHackArguments = false; bool ShouldHackArguments = false;
public: public:
DeadArgumentEliminationPass(bool ShouldHackArguments_ = false) DeadArgumentEliminationPass(bool ShouldHackArguments_ = false)
: ShouldHackArguments(ShouldHackArguments_) {} : ShouldHackArguments(ShouldHackArguments_) {}
PreservedAnalyses run(Module &M, ModuleAnalysisManager &); PreservedAnalyses run(Module &M, AnalysisManager &);
private: private:
Liveness MarkIfNotLive(RetOrArg Use, UseVector &MaybeLiveUses); Liveness MarkIfNotLive(RetOrArg Use, UseVector &MaybeLiveUses);
Liveness SurveyUse(const Use *U, UseVector &MaybeLiveUses, Liveness SurveyUse(const Use *U, UseVector &MaybeLiveUses,
unsigned RetValNum = -1U); unsigned RetValNum = -1U);
Liveness SurveyUses(const Value *V, UseVector &MaybeLiveUses); Liveness SurveyUses(const Value *V, UseVector &MaybeLiveUses);
void SurveyFunction(const Function &F); void SurveyFunction(const Function &F);
Show All 12 Lines

include/llvm/Transforms/IPO/ElimAvailExtern.h

Show All 18 Lines
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
/// A pass that transforms external global definitions into declarations. /// A pass that transforms external global definitions into declarations.
class EliminateAvailableExternallyPass class EliminateAvailableExternallyPass
: public PassInfoMixin<EliminateAvailableExternallyPass> { : public PassInfoMixin<EliminateAvailableExternallyPass> {
public: public:
PreservedAnalyses run(Module &M, ModuleAnalysisManager &); PreservedAnalyses run(Module &M, AnalysisManager &);
}; };
} }
#endif // LLVM_TRANSFORMS_IPO_ELIMAVAILEXTERN_H #endif // LLVM_TRANSFORMS_IPO_ELIMAVAILEXTERN_H

include/llvm/Transforms/IPO/ForceFunctionAttrs.h

Show All 16 Lines
#include "llvm/IR/Module.h" #include "llvm/IR/Module.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
/// Pass which forces specific function attributes into the IR, primarily as /// Pass which forces specific function attributes into the IR, primarily as
/// a debugging tool. /// a debugging tool.
struct ForceFunctionAttrsPass : PassInfoMixin<ForceFunctionAttrsPass> { struct ForceFunctionAttrsPass : PassInfoMixin<ForceFunctionAttrsPass> {
PreservedAnalyses run(Module &M, ModuleAnalysisManager &); PreservedAnalyses run(Module &M, AnalysisManager &);
}; };
/// Create a legacy pass manager instance of a pass to force function attrs. /// Create a legacy pass manager instance of a pass to force function attrs.
Pass *createForceFunctionAttrsLegacyPass(); Pass *createForceFunctionAttrsLegacyPass();
} }
#endif // LLVM_TRANSFORMS_IPO_FORCEFUNCTIONATTRS_H #endif // LLVM_TRANSFORMS_IPO_FORCEFUNCTIONATTRS_H

include/llvm/Transforms/IPO/FunctionAttrs.h

Show All 24 Lines
/// By operating in post-order, this pass computes precise attributes for /// By operating in post-order, this pass computes precise attributes for
/// called functions prior to processsing their callers. This "bottom-up" /// called functions prior to processsing their callers. This "bottom-up"
/// approach allows powerful interprocedural inference of function attributes /// approach allows powerful interprocedural inference of function attributes
/// like memory access patterns, etc. It can discover functions that do not /// like memory access patterns, etc. It can discover functions that do not
/// access memory, or only read memory, and give them the readnone/readonly /// access memory, or only read memory, and give them the readnone/readonly
/// attribute. It also discovers function arguments that are not captured by /// attribute. It also discovers function arguments that are not captured by
/// the function and marks them with the nocapture attribute. /// the function and marks them with the nocapture attribute.
struct PostOrderFunctionAttrsPass : PassInfoMixin<PostOrderFunctionAttrsPass> { struct PostOrderFunctionAttrsPass : PassInfoMixin<PostOrderFunctionAttrsPass> {
PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM); PreservedAnalyses run(LazyCallGraph::SCC &C, AnalysisManager &AM);
}; };
/// Create a legacy pass manager instance of a pass to compute function attrs /// Create a legacy pass manager instance of a pass to compute function attrs
/// in post-order. /// in post-order.
Pass *createPostOrderFunctionAttrsLegacyPass(); Pass *createPostOrderFunctionAttrsLegacyPass();
/// A pass to do RPO deduction and propagation of function attributes. /// A pass to do RPO deduction and propagation of function attributes.
/// ///
/// This pass provides a general RPO or "top down" propagation of /// This pass provides a general RPO or "top down" propagation of
/// function attributes. For a few (rare) cases, we can deduce significantly /// function attributes. For a few (rare) cases, we can deduce significantly
/// more about function attributes by working in RPO, so this pass /// more about function attributes by working in RPO, so this pass
/// provides the compliment to the post-order pass above where the majority of /// provides the compliment to the post-order pass above where the majority of
/// deduction is performed. /// deduction is performed.
// FIXME: Currently there is no RPO CGSCC pass structure to slide into and so // FIXME: Currently there is no RPO CGSCC pass structure to slide into and so
// this is a boring module pass, but eventually it should be an RPO CGSCC pass // this is a boring module pass, but eventually it should be an RPO CGSCC pass
// when such infrastructure is available. // when such infrastructure is available.
class ReversePostOrderFunctionAttrsPass class ReversePostOrderFunctionAttrsPass
: public PassInfoMixin<ReversePostOrderFunctionAttrsPass> { : public PassInfoMixin<ReversePostOrderFunctionAttrsPass> {
public: public:
PreservedAnalyses run(Module &M, AnalysisManager<Module> &AM); PreservedAnalyses run(Module &M, AnalysisManager &AM);
}; };
} }
#endif // LLVM_TRANSFORMS_IPO_FUNCTIONATTRS_H #endif // LLVM_TRANSFORMS_IPO_FUNCTIONATTRS_H

include/llvm/Transforms/IPO/FunctionImport.h

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Linesprivate:
std::function<std::unique_ptr<Module>(StringRef Identifier)> ModuleLoader; std::function<std::unique_ptr<Module>(StringRef Identifier)> ModuleLoader;
}; };
/// The function importing pass /// The function importing pass
class FunctionImportPass : public PassInfoMixin<FunctionImportPass> { class FunctionImportPass : public PassInfoMixin<FunctionImportPass> {
public: public:
FunctionImportPass(const ModuleSummaryIndex *Index = nullptr) FunctionImportPass(const ModuleSummaryIndex *Index = nullptr)
: Index(Index) {} : Index(Index) {}
PreservedAnalyses run(Module &M, AnalysisManager<Module> &AM); PreservedAnalyses run(Module &M, AnalysisManager &AM);
private: private:
const ModuleSummaryIndex *Index; const ModuleSummaryIndex *Index;
}; };
/// Compute all the imports and exports for every module in the Index. /// Compute all the imports and exports for every module in the Index.
/// ///
/// \p ModuleToDefinedGVSummaries contains for each Module a map /// \p ModuleToDefinedGVSummaries contains for each Module a map
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

include/llvm/Transforms/IPO/GlobalDCE.h

Show All 21 Lines
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
#include <unordered_map> #include <unordered_map>
namespace llvm { namespace llvm {
/// Pass to remove unused function declarations. /// Pass to remove unused function declarations.
class GlobalDCEPass : public PassInfoMixin<GlobalDCEPass> { class GlobalDCEPass : public PassInfoMixin<GlobalDCEPass> {
public: public:
PreservedAnalyses run(Module &M, ModuleAnalysisManager &); PreservedAnalyses run(Module &M, AnalysisManager &);
private: private:
SmallPtrSet<GlobalValue*, 32> AliveGlobals; SmallPtrSet<GlobalValue*, 32> AliveGlobals;
SmallPtrSet<Constant *, 8> SeenConstants; SmallPtrSet<Constant *, 8> SeenConstants;
std::unordered_multimap<Comdat *, GlobalValue *> ComdatMembers; std::unordered_multimap<Comdat *, GlobalValue *> ComdatMembers;
/// Mark the specific global value as needed, and /// Mark the specific global value as needed, and
/// recursively mark anything that it uses as also needed. /// recursively mark anything that it uses as also needed.
void GlobalIsNeeded(GlobalValue *GV); void GlobalIsNeeded(GlobalValue *GV);
void MarkUsedGlobalsAsNeeded(Constant *C); void MarkUsedGlobalsAsNeeded(Constant *C);
bool RemoveUnusedGlobalValue(GlobalValue &GV); bool RemoveUnusedGlobalValue(GlobalValue &GV);
}; };
} }
#endif // LLVM_TRANSFORMS_IPO_GLOBALDCE_H #endif // LLVM_TRANSFORMS_IPO_GLOBALDCE_H

include/llvm/Transforms/IPO/GlobalOpt.h

Show All 18 Lines
#include "llvm/IR/Module.h" #include "llvm/IR/Module.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
/// Optimize globals that never have their address taken. /// Optimize globals that never have their address taken.
class GlobalOptPass : public PassInfoMixin<GlobalOptPass> { class GlobalOptPass : public PassInfoMixin<GlobalOptPass> {
public: public:
PreservedAnalyses run(Module &M, AnalysisManager<Module> &AM); PreservedAnalyses run(Module &M, AnalysisManager &AM);
}; };
} }
#endif // LLVM_TRANSFORMS_IPO_GLOBALOPT_H #endif // LLVM_TRANSFORMS_IPO_GLOBALOPT_H

include/llvm/Transforms/IPO/InferFunctionAttrs.h

Show All 18 Lines
#include "llvm/IR/Module.h" #include "llvm/IR/Module.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
/// A pass which infers function attributes from the names and signatures of /// A pass which infers function attributes from the names and signatures of
/// function declarations in a module. /// function declarations in a module.
struct InferFunctionAttrsPass : PassInfoMixin<InferFunctionAttrsPass> { struct InferFunctionAttrsPass : PassInfoMixin<InferFunctionAttrsPass> {
PreservedAnalyses run(Module &M, AnalysisManager<Module> &AM); PreservedAnalyses run(Module &M, AnalysisManager &AM);
}; };
/// Create a legacy pass manager instance of a pass to infer function /// Create a legacy pass manager instance of a pass to infer function
/// attributes. /// attributes.
Pass *createInferFunctionAttrsLegacyPass(); Pass *createInferFunctionAttrsLegacyPass();
} }
#endif // LLVM_TRANSFORMS_IPO_INFERFUNCTIONATTRS_H #endif // LLVM_TRANSFORMS_IPO_INFERFUNCTIONATTRS_H

include/llvm/Transforms/IPO/Internalize.h

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Linespublic:
/// Run the internalizer on \p TheModule, returns true if any changes was /// Run the internalizer on \p TheModule, returns true if any changes was
/// made. /// made.
/// ///
/// If the CallGraph \p CG is supplied, it will be updated when /// If the CallGraph \p CG is supplied, it will be updated when
/// internalizing a function (by removing any edge from the "external node") /// internalizing a function (by removing any edge from the "external node")
bool internalizeModule(Module &TheModule, CallGraph *CG = nullptr); bool internalizeModule(Module &TheModule, CallGraph *CG = nullptr);
PreservedAnalyses run(Module &M, AnalysisManager<Module> &AM); PreservedAnalyses run(Module &M, AnalysisManager &AM);
}; };
/// Helper function to internalize functions and variables in a Module. /// Helper function to internalize functions and variables in a Module.
inline bool inline bool
internalizeModule(Module &TheModule, internalizeModule(Module &TheModule,
std::function<bool(const GlobalValue &)> MustPreserveGV, std::function<bool(const GlobalValue &)> MustPreserveGV,
CallGraph *CG = nullptr) { CallGraph *CG = nullptr) {
return InternalizePass(std::move(MustPreserveGV)) return InternalizePass(std::move(MustPreserveGV))
.internalizeModule(TheModule, CG); .internalizeModule(TheModule, CG);
} }
} // end namespace llvm } // end namespace llvm
#endif // LLVM_TRANSFORMS_IPO_INTERNALIZE_H #endif // LLVM_TRANSFORMS_IPO_INTERNALIZE_H

include/llvm/Transforms/IPO/LowerTypeTests.h

Show First 20 Lines • Show All 199 Lines • ▼ Show 20 Linesstruct ByteArrayBuilder {
void allocate(const std::set<uint64_t> &Bits, uint64_t BitSize, void allocate(const std::set<uint64_t> &Bits, uint64_t BitSize,
uint64_t &AllocByteOffset, uint8_t &AllocMask); uint64_t &AllocByteOffset, uint8_t &AllocMask);
}; };
} // end namespace lowertypetests } // end namespace lowertypetests
class LowerTypeTestsPass : public PassInfoMixin<LowerTypeTestsPass> { class LowerTypeTestsPass : public PassInfoMixin<LowerTypeTestsPass> {
public: public:
PreservedAnalyses run(Module &M, AnalysisManager<Module> &AM); PreservedAnalyses run(Module &M, AnalysisManager &AM);
}; };
} // end namespace llvm } // end namespace llvm
#endif // LLVM_TRANSFORMS_IPO_LOWERTYPETESTS_H #endif // LLVM_TRANSFORMS_IPO_LOWERTYPETESTS_H

include/llvm/Transforms/IPO/PartialInlining.h

Show All 17 Lines
#include "llvm/IR/Module.h" #include "llvm/IR/Module.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
/// Pass to remove unused function declarations. /// Pass to remove unused function declarations.
class PartialInlinerPass : public PassInfoMixin<PartialInlinerPass> { class PartialInlinerPass : public PassInfoMixin<PartialInlinerPass> {
public: public:
PreservedAnalyses run(Module &M, ModuleAnalysisManager &); PreservedAnalyses run(Module &M, AnalysisManager &);
}; };
} }
#endif // LLVM_TRANSFORMS_IPO_PARTIALINLINING_H #endif // LLVM_TRANSFORMS_IPO_PARTIALINLINING_H

include/llvm/Transforms/IPO/SCCP.h

Show All 22 Lines
#include "llvm/IR/Module.h" #include "llvm/IR/Module.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
/// Pass to perform interprocedural constant propagation. /// Pass to perform interprocedural constant propagation.
class IPSCCPPass : public PassInfoMixin<IPSCCPPass> { class IPSCCPPass : public PassInfoMixin<IPSCCPPass> {
public: public:
PreservedAnalyses run(Module &M, AnalysisManager<Module> &AM); PreservedAnalyses run(Module &M, AnalysisManager &AM);
}; };
} }
#endif // LLVM_TRANSFORMS_IPO_SCCP_H #endif // LLVM_TRANSFORMS_IPO_SCCP_H

include/llvm/Transforms/IPO/StripDeadPrototypes.h

Show All 18 Lines
#include "llvm/IR/Module.h" #include "llvm/IR/Module.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
/// Pass to remove unused function declarations. /// Pass to remove unused function declarations.
struct StripDeadPrototypesPass : PassInfoMixin<StripDeadPrototypesPass> { struct StripDeadPrototypesPass : PassInfoMixin<StripDeadPrototypesPass> {
PreservedAnalyses run(Module &M, ModuleAnalysisManager &); PreservedAnalyses run(Module &M, AnalysisManager &);
}; };
} }
#endif // LLVM_TRANSFORMS_IPO_STRIPDEADPROTOTYPES_H #endif // LLVM_TRANSFORMS_IPO_STRIPDEADPROTOTYPES_H

include/llvm/Transforms/IPO/WholeProgramDevirt.h

Show First 20 Lines • Show All 209 Lines • ▼ Show 20 Lines
// byte/bit offset to OffsetByte/OffsetBit. // byte/bit offset to OffsetByte/OffsetBit.
void setAfterReturnValues(MutableArrayRef<VirtualCallTarget> Targets, void setAfterReturnValues(MutableArrayRef<VirtualCallTarget> Targets,
uint64_t AllocAfter, unsigned BitWidth, uint64_t AllocAfter, unsigned BitWidth,
int64_t &OffsetByte, uint64_t &OffsetBit); int64_t &OffsetByte, uint64_t &OffsetBit);
} // end namespace wholeprogramdevirt } // end namespace wholeprogramdevirt
struct WholeProgramDevirtPass : public PassInfoMixin<WholeProgramDevirtPass> { struct WholeProgramDevirtPass : public PassInfoMixin<WholeProgramDevirtPass> {
PreservedAnalyses run(Module &M, ModuleAnalysisManager &); PreservedAnalyses run(Module &M, AnalysisManager &);
}; };
} // end namespace llvm } // end namespace llvm
#endif // LLVM_TRANSFORMS_IPO_WHOLEPROGRAMDEVIRT_H #endif // LLVM_TRANSFORMS_IPO_WHOLEPROGRAMDEVIRT_H

include/llvm/Transforms/InstCombine/InstCombine.h

Show All 37 Lines InstCombinePass(InstCombinePass &&Arg)
: Worklist(std::move(Arg.Worklist)), : Worklist(std::move(Arg.Worklist)),
ExpensiveCombines(Arg.ExpensiveCombines) {} ExpensiveCombines(Arg.ExpensiveCombines) {}
InstCombinePass &operator=(InstCombinePass &&RHS) { InstCombinePass &operator=(InstCombinePass &&RHS) {
Worklist = std::move(RHS.Worklist); Worklist = std::move(RHS.Worklist);
ExpensiveCombines = RHS.ExpensiveCombines; ExpensiveCombines = RHS.ExpensiveCombines;
return *this; return *this;
} }
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
/// \brief The legacy pass manager's instcombine pass. /// \brief The legacy pass manager's instcombine pass.
/// ///
/// This is a basic whole-function wrapper around the instcombine utility. It /// This is a basic whole-function wrapper around the instcombine utility. It
/// will try to combine all instructions in the function. /// will try to combine all instructions in the function.
class InstructionCombiningPass : public FunctionPass { class InstructionCombiningPass : public FunctionPass {
InstCombineWorklist Worklist; InstCombineWorklist Worklist;
Show All 16 Lines

include/llvm/Transforms/InstrProfiling.h

Show All 23 Lines
/// Instrumenation based profiling lowering pass. This pass lowers /// Instrumenation based profiling lowering pass. This pass lowers
/// the profile instrumented code generated by FE or the IR based /// the profile instrumented code generated by FE or the IR based
/// instrumentation pass. /// instrumentation pass.
class InstrProfiling : public PassInfoMixin<InstrProfiling> { class InstrProfiling : public PassInfoMixin<InstrProfiling> {
public: public:
InstrProfiling() {} InstrProfiling() {}
InstrProfiling(const InstrProfOptions &Options) : Options(Options) {} InstrProfiling(const InstrProfOptions &Options) : Options(Options) {}
PreservedAnalyses run(Module &M, AnalysisManager<Module> &AM); PreservedAnalyses run(Module &M, AnalysisManager &AM);
bool run(Module &M); bool run(Module &M);
private: private:
InstrProfOptions Options; InstrProfOptions Options;
Module *M; Module *M;
struct PerFunctionProfileData { struct PerFunctionProfileData {
uint32_t NumValueSites[IPVK_Last + 1]; uint32_t NumValueSites[IPVK_Last + 1];
GlobalVariable *RegionCounters; GlobalVariable *RegionCounters;
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

include/llvm/Transforms/PGOInstrumentation.h

Show All 16 Lines
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
#include "llvm/Transforms/Instrumentation.h" #include "llvm/Transforms/Instrumentation.h"
namespace llvm { namespace llvm {
/// The instrumentation (profile-instr-gen) pass for IR based PGO. /// The instrumentation (profile-instr-gen) pass for IR based PGO.
class PGOInstrumentationGen : public PassInfoMixin<PGOInstrumentationGen> { class PGOInstrumentationGen : public PassInfoMixin<PGOInstrumentationGen> {
public: public:
PreservedAnalyses run(Module &M, AnalysisManager<Module> &AM); PreservedAnalyses run(Module &M, AnalysisManager &AM);
}; };
/// The profile annotation (profile-instr-use) pass for IR based PGO. /// The profile annotation (profile-instr-use) pass for IR based PGO.
class PGOInstrumentationUse : public PassInfoMixin<PGOInstrumentationUse> { class PGOInstrumentationUse : public PassInfoMixin<PGOInstrumentationUse> {
public: public:
PreservedAnalyses run(Module &M, AnalysisManager<Module> &AM); PreservedAnalyses run(Module &M, AnalysisManager &AM);
PGOInstrumentationUse(std::string Filename = ""); PGOInstrumentationUse(std::string Filename = "");
private: private:
std::string ProfileFileName; std::string ProfileFileName;
}; };
/// The indirect function call promotion pass. /// The indirect function call promotion pass.
class PGOIndirectCallPromotion : public PassInfoMixin<PGOIndirectCallPromotion> { class PGOIndirectCallPromotion : public PassInfoMixin<PGOIndirectCallPromotion> {
public: public:
PGOIndirectCallPromotion(bool IsInLTO = false) : InLTO(IsInLTO) {} PGOIndirectCallPromotion(bool IsInLTO = false) : InLTO(IsInLTO) {}
PreservedAnalyses run(Module &M, AnalysisManager<Module> &AM); PreservedAnalyses run(Module &M, AnalysisManager &AM);
private: private:
bool InLTO; bool InLTO;
}; };
} // End llvm namespace } // End llvm namespace
#endif #endif

include/llvm/Transforms/SampleProfile.h

Show All 14 Lines
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
/// The sample profiler data loader pass. /// The sample profiler data loader pass.
class SampleProfileLoaderPass : public PassInfoMixin<SampleProfileLoaderPass> { class SampleProfileLoaderPass : public PassInfoMixin<SampleProfileLoaderPass> {
public: public:
PreservedAnalyses run(Module &M, AnalysisManager<Module> &AM); PreservedAnalyses run(Module &M, AnalysisManager &AM);
}; };
} // End llvm namespace } // End llvm namespace
#endif #endif

include/llvm/Transforms/Scalar/ADCE.h

Show All 23 Lines
/// A DCE pass that assumes instructions are dead until proven otherwise. /// A DCE pass that assumes instructions are dead until proven otherwise.
/// ///
/// This pass eliminates dead code by optimistically assuming that all /// This pass eliminates dead code by optimistically assuming that all
/// instructions are dead until proven otherwise. This allows it to eliminate /// instructions are dead until proven otherwise. This allows it to eliminate
/// dead computations that other DCE passes do not catch, particularly involving /// dead computations that other DCE passes do not catch, particularly involving
/// loop computations. /// loop computations.
struct ADCEPass : PassInfoMixin<ADCEPass> { struct ADCEPass : PassInfoMixin<ADCEPass> {
PreservedAnalyses run(Function &F, FunctionAnalysisManager &); PreservedAnalyses run(Function &F, AnalysisManager &);
}; };
} }
#endif // LLVM_TRANSFORMS_SCALAR_ADCE_H #endif // LLVM_TRANSFORMS_SCALAR_ADCE_H

include/llvm/Transforms/Scalar/AlignmentFromAssumptions.h

Show All 21 Lines
#include "llvm/IR/Function.h" #include "llvm/IR/Function.h"
#include "llvm/IR/IntrinsicInst.h" #include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
struct AlignmentFromAssumptionsPass struct AlignmentFromAssumptionsPass
: public PassInfoMixin<AlignmentFromAssumptionsPass> { : public PassInfoMixin<AlignmentFromAssumptionsPass> {
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
// Glue for old PM. // Glue for old PM.
bool runImpl(Function &F, AssumptionCache &AC, ScalarEvolution *SE_, bool runImpl(Function &F, AssumptionCache &AC, ScalarEvolution *SE_,
DominatorTree *DT_); DominatorTree *DT_);
// For memory transfers, we need a common alignment for both the source and // For memory transfers, we need a common alignment for both the source and
// destination. If we have a new alignment for only one operand of a transfer // destination. If we have a new alignment for only one operand of a transfer
// instruction, save it in these maps. If we reach the other operand through // instruction, save it in these maps. If we reach the other operand through
Show All 13 Lines

include/llvm/Transforms/Scalar/BDCE.h

Show All 18 Lines
#include "llvm/IR/Function.h" #include "llvm/IR/Function.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
// The Bit-Tracking Dead Code Elimination pass. // The Bit-Tracking Dead Code Elimination pass.
struct BDCEPass : PassInfoMixin<BDCEPass> { struct BDCEPass : PassInfoMixin<BDCEPass> {
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
} }
#endif // LLVM_TRANSFORMS_SCALAR_BDCE_H #endif // LLVM_TRANSFORMS_SCALAR_BDCE_H

include/llvm/Transforms/Scalar/ConstantHoisting.h

Show First 20 Lines • Show All 88 Lines • ▼ Show 20 Lines
struct ConstantInfo { struct ConstantInfo {
ConstantInt *BaseConstant; ConstantInt *BaseConstant;
RebasedConstantListType RebasedConstants; RebasedConstantListType RebasedConstants;
}; };
} }
class ConstantHoistingPass : public PassInfoMixin<ConstantHoistingPass> { class ConstantHoistingPass : public PassInfoMixin<ConstantHoistingPass> {
public: public:
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
// Glue for old PM. // Glue for old PM.
bool runImpl(Function &F, TargetTransformInfo &TTI, DominatorTree &DT, bool runImpl(Function &F, TargetTransformInfo &TTI, DominatorTree &DT,
BasicBlock &Entry); BasicBlock &Entry);
void releaseMemory() { void releaseMemory() {
ConstantVec.clear(); ConstantVec.clear();
ClonedCastMap.clear(); ClonedCastMap.clear();
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

include/llvm/Transforms/Scalar/CorrelatedValuePropagation.h

Show All 11 Lines
#include "llvm/IR/Function.h" #include "llvm/IR/Function.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
struct CorrelatedValuePropagationPass struct CorrelatedValuePropagationPass
: PassInfoMixin<CorrelatedValuePropagationPass> { : PassInfoMixin<CorrelatedValuePropagationPass> {
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
} }
#endif // LLVM_TRANSFORMS_SCALAR_CORRELATEDVALUEPROPAGATION_H #endif // LLVM_TRANSFORMS_SCALAR_CORRELATEDVALUEPROPAGATION_H

include/llvm/Transforms/Scalar/DCE.h

Show All 16 Lines
#include "llvm/IR/Function.h" #include "llvm/IR/Function.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
/// Basic Dead Code Elimination pass. /// Basic Dead Code Elimination pass.
class DCEPass : public PassInfoMixin<DCEPass> { class DCEPass : public PassInfoMixin<DCEPass> {
public: public:
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
} }
#endif // LLVM_TRANSFORMS_SCALAR_DCE_H #endif // LLVM_TRANSFORMS_SCALAR_DCE_H

include/llvm/Transforms/Scalar/DeadStoreElimination.h

Show All 21 Lines
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
/// This class implements a trivial dead store elimination. We consider /// This class implements a trivial dead store elimination. We consider
/// only the redundant stores that are local to a single Basic Block. /// only the redundant stores that are local to a single Basic Block.
class DSEPass : public PassInfoMixin<DSEPass> { class DSEPass : public PassInfoMixin<DSEPass> {
public: public:
PreservedAnalyses run(Function &F, AnalysisManager<Function> &FAM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
} }
#endif // LLVM_TRANSFORMS_SCALAR_DSE_H #endif // LLVM_TRANSFORMS_SCALAR_DSE_H

include/llvm/Transforms/Scalar/EarlyCSE.h

Show All 22 Lines
/// ///
/// This pass does a simple depth-first walk over the dominator tree, /// This pass does a simple depth-first walk over the dominator tree,
/// eliminating trivially redundant instructions and using instsimplify to /// eliminating trivially redundant instructions and using instsimplify to
/// canonicalize things as it goes. It is intended to be fast and catch obvious /// canonicalize things as it goes. It is intended to be fast and catch obvious
/// cases so that instcombine and other passes are more effective. It is /// cases so that instcombine and other passes are more effective. It is
/// expected that a later pass of GVN will catch the interesting/hard cases. /// expected that a later pass of GVN will catch the interesting/hard cases.
struct EarlyCSEPass : PassInfoMixin<EarlyCSEPass> { struct EarlyCSEPass : PassInfoMixin<EarlyCSEPass> {
/// \brief Run the pass over the function. /// \brief Run the pass over the function.
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
} }
#endif #endif

include/llvm/Transforms/Scalar/Float2Int.h

Show All 18 Lines
#include "llvm/ADT/MapVector.h" #include "llvm/ADT/MapVector.h"
#include "llvm/IR/ConstantRange.h" #include "llvm/IR/ConstantRange.h"
#include "llvm/IR/Function.h" #include "llvm/IR/Function.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
class Float2IntPass : public PassInfoMixin<Float2IntPass> { class Float2IntPass : public PassInfoMixin<Float2IntPass> {
public: public:
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
// Glue for old PM. // Glue for old PM.
bool runImpl(Function &F); bool runImpl(Function &F);
private: private:
void findRoots(Function &F, SmallPtrSet<Instruction *, 8> &Roots); void findRoots(Function &F, SmallPtrSet<Instruction *, 8> &Roots);
ConstantRange seen(Instruction *I, ConstantRange R); ConstantRange seen(Instruction *I, ConstantRange R);
ConstantRange badRange(); ConstantRange badRange();
Show All 16 Lines

include/llvm/Transforms/Scalar/GVN.h

Show All 39 Lines
/// The core GVN pass object. /// The core GVN pass object.
/// ///
/// FIXME: We should have a good summary of the GVN algorithm implemented by /// FIXME: We should have a good summary of the GVN algorithm implemented by
/// this particular pass here. /// this particular pass here.
class GVN : public PassInfoMixin<GVN> { class GVN : public PassInfoMixin<GVN> {
public: public:
/// \brief Run the pass over the function. /// \brief Run the pass over the function.
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
/// This removes the specified instruction from /// This removes the specified instruction from
/// our various maps and marks it for deletion. /// our various maps and marks it for deletion.
void markInstructionForDeletion(Instruction *I) { void markInstructionForDeletion(Instruction *I) {
VN.erase(I); VN.erase(I);
InstrsToErase.push_back(I); InstrsToErase.push_back(I);
} }
▲ Show 20 Lines • Show All 170 Lines • ▼ Show 20 Lines
/// Create a legacy GVN pass. This also allows parameterizing whether or not /// Create a legacy GVN pass. This also allows parameterizing whether or not
/// loads are eliminated by the pass. /// loads are eliminated by the pass.
FunctionPass *createGVNPass(bool NoLoads = false); FunctionPass *createGVNPass(bool NoLoads = false);
/// \brief A simple and fast domtree-based GVN pass to hoist common expressions /// \brief A simple and fast domtree-based GVN pass to hoist common expressions
/// from sibling branches. /// from sibling branches.
struct GVNHoistPass : PassInfoMixin<GVNHoistPass> { struct GVNHoistPass : PassInfoMixin<GVNHoistPass> {
/// \brief Run the pass over the function. /// \brief Run the pass over the function.
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
} }
#endif #endif

include/llvm/Transforms/Scalar/GuardWidening.h

Show All 18 Lines
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
class Function; class Function;
struct GuardWideningPass : public PassInfoMixin<GuardWideningPass> { struct GuardWideningPass : public PassInfoMixin<GuardWideningPass> {
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
} }
#endif // LLVM_TRANSFORMS_SCALAR_GUARD_WIDENING_H #endif // LLVM_TRANSFORMS_SCALAR_GUARD_WIDENING_H

include/llvm/Transforms/Scalar/IndVarSimplify.h

Show All 16 Lines
#include "llvm/Analysis/LoopInfo.h" #include "llvm/Analysis/LoopInfo.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
class IndVarSimplifyPass : public PassInfoMixin<IndVarSimplifyPass> { class IndVarSimplifyPass : public PassInfoMixin<IndVarSimplifyPass> {
public: public:
PreservedAnalyses run(Loop &L, AnalysisManager<Loop> &AM); PreservedAnalyses run(Loop &L, AnalysisManager &AM);
}; };
} }
#endif // LLVM_TRANSFORMS_SCALAR_INDVARSIMPLIFY_H #endif // LLVM_TRANSFORMS_SCALAR_INDVARSIMPLIFY_H

include/llvm/Transforms/Scalar/JumpThreading.h

Show First 20 Lines • Show All 92 Lines • ▼ Show 20 Lines JumpThreadingPass(JumpThreadingPass &&Other)
RecursionSet(std::move(Other.RecursionSet)), RecursionSet(std::move(Other.RecursionSet)),
BBDupThreshold(Other.BBDupThreshold) {} BBDupThreshold(Other.BBDupThreshold) {}
// Glue for old PM. // Glue for old PM.
bool runImpl(Function &F, TargetLibraryInfo *TLI_, LazyValueInfo *LVI_, bool runImpl(Function &F, TargetLibraryInfo *TLI_, LazyValueInfo *LVI_,
bool HasProfileData_, std::unique_ptr<BlockFrequencyInfo> BFI_, bool HasProfileData_, std::unique_ptr<BlockFrequencyInfo> BFI_,
std::unique_ptr<BranchProbabilityInfo> BPI_); std::unique_ptr<BranchProbabilityInfo> BPI_);
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
void releaseMemory() { void releaseMemory() {
BFI.reset(); BFI.reset();
BPI.reset(); BPI.reset();
} }
void FindLoopHeaders(Function &F); void FindLoopHeaders(Function &F);
bool ProcessBlock(BasicBlock *BB); bool ProcessBlock(BasicBlock *BB);
Show All 32 Lines

include/llvm/Transforms/Scalar/LICM.h

Show All 35 Lines
#include "llvm/Analysis/LoopInfo.h" #include "llvm/Analysis/LoopInfo.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
/// Performs Loop Invariant Code Motion Pass. /// Performs Loop Invariant Code Motion Pass.
class LICMPass : public PassInfoMixin<LICMPass> { class LICMPass : public PassInfoMixin<LICMPass> {
public: public:
PreservedAnalyses run(Loop &L, AnalysisManager<Loop> &AM); PreservedAnalyses run(Loop &L, AnalysisManager &AM);
}; };
} // end namespace llvm } // end namespace llvm
#endif // LLVM_TRANSFORMS_SCALAR_LICM_H #endif // LLVM_TRANSFORMS_SCALAR_LICM_H

include/llvm/Transforms/Scalar/LoopDeletion.h

Show All 17 Lines
#include "llvm/Analysis/ScalarEvolution.h" #include "llvm/Analysis/ScalarEvolution.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
class LoopDeletionPass : public PassInfoMixin<LoopDeletionPass> { class LoopDeletionPass : public PassInfoMixin<LoopDeletionPass> {
public: public:
LoopDeletionPass() {} LoopDeletionPass() {}
PreservedAnalyses run(Loop &L, AnalysisManager<Loop> &AM); PreservedAnalyses run(Loop &L, AnalysisManager &AM);
bool runImpl(Loop *L, DominatorTree &DT, ScalarEvolution &SE, bool runImpl(Loop *L, DominatorTree &DT, ScalarEvolution &SE,
LoopInfo &loopInfo); LoopInfo &loopInfo);
private: private:
bool isLoopDead(Loop *L, ScalarEvolution &SE, bool isLoopDead(Loop *L, ScalarEvolution &SE,
SmallVectorImpl<BasicBlock *> &exitingBlocks, SmallVectorImpl<BasicBlock *> &exitingBlocks,
SmallVectorImpl<BasicBlock *> &exitBlocks, bool &Changed, SmallVectorImpl<BasicBlock *> &exitBlocks, bool &Changed,
BasicBlock *Preheader); BasicBlock *Preheader);
}; };
} }
#endif // LLVM_TRANSFORMS_SCALAR_LOOPDELETION_H #endif // LLVM_TRANSFORMS_SCALAR_LOOPDELETION_H

include/llvm/Transforms/Scalar/LoopDistribute.h

Show All 17 Lines
#define LLVM_TRANSFORMS_SCALAR_LOOPDISTRIBUTE_H #define LLVM_TRANSFORMS_SCALAR_LOOPDISTRIBUTE_H
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
class LoopDistributePass : public PassInfoMixin<LoopDistributePass> { class LoopDistributePass : public PassInfoMixin<LoopDistributePass> {
public: public:
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
} // end namespace llvm } // end namespace llvm
#endif // LLVM_TRANSFORMS_SCALAR_LOOPDISTRIBUTE_H #endif // LLVM_TRANSFORMS_SCALAR_LOOPDISTRIBUTE_H

include/llvm/Transforms/Scalar/LoopIdiomRecognize.h

Show All 18 Lines
#include "llvm/Analysis/LoopInfo.h" #include "llvm/Analysis/LoopInfo.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
/// Performs Loop Idiom Recognize Pass. /// Performs Loop Idiom Recognize Pass.
class LoopIdiomRecognizePass : public PassInfoMixin<LoopIdiomRecognizePass> { class LoopIdiomRecognizePass : public PassInfoMixin<LoopIdiomRecognizePass> {
public: public:
PreservedAnalyses run(Loop &L, AnalysisManager<Loop> &AM); PreservedAnalyses run(Loop &L, AnalysisManager &AM);
}; };
} // end namespace llvm } // end namespace llvm
#endif // LLVM_TRANSFORMS_SCALAR_LOOPIDIOMRECOGNIZE_H #endif // LLVM_TRANSFORMS_SCALAR_LOOPIDIOMRECOGNIZE_H

include/llvm/Transforms/Scalar/LoopInstSimplify.h

Show All 16 Lines
#include "llvm/Analysis/LoopInfo.h" #include "llvm/Analysis/LoopInfo.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
/// Performs Loop Inst Simplify Pass. /// Performs Loop Inst Simplify Pass.
class LoopInstSimplifyPass : public PassInfoMixin<LoopInstSimplifyPass> { class LoopInstSimplifyPass : public PassInfoMixin<LoopInstSimplifyPass> {
public: public:
PreservedAnalyses run(Loop &L, AnalysisManager<Loop> &AM); PreservedAnalyses run(Loop &L, AnalysisManager &AM);
}; };
} // end namespace llvm } // end namespace llvm
#endif // LLVM_TRANSFORMS_SCALAR_LOOPINSTSIMPLIFY_H #endif // LLVM_TRANSFORMS_SCALAR_LOOPINSTSIMPLIFY_H

include/llvm/Transforms/Scalar/LoopRotation.h

Show All 17 Lines
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
/// A simple loop rotation transformation. /// A simple loop rotation transformation.
class LoopRotatePass : public PassInfoMixin<LoopRotatePass> { class LoopRotatePass : public PassInfoMixin<LoopRotatePass> {
public: public:
LoopRotatePass(); LoopRotatePass();
PreservedAnalyses run(Loop &L, AnalysisManager<Loop> &AM); PreservedAnalyses run(Loop &L, AnalysisManager &AM);
}; };
} }
#endif // LLVM_TRANSFORMS_SCALAR_LOOPROTATION_H #endif // LLVM_TRANSFORMS_SCALAR_LOOPROTATION_H

include/llvm/Transforms/Scalar/LoopSimplifyCFG.h

Show All 19 Lines
#include "llvm/Analysis/LoopInfo.h" #include "llvm/Analysis/LoopInfo.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
/// Performs basic CFG simplifications to assist other loop passes. /// Performs basic CFG simplifications to assist other loop passes.
class LoopSimplifyCFGPass : public PassInfoMixin<LoopSimplifyCFGPass> { class LoopSimplifyCFGPass : public PassInfoMixin<LoopSimplifyCFGPass> {
public: public:
PreservedAnalyses run(Loop &L, AnalysisManager<Loop> &AM); PreservedAnalyses run(Loop &L, AnalysisManager &AM);
}; };
} // end namespace llvm } // end namespace llvm
#endif // LLVM_TRANSFORMS_SCALAR_LOOPSIMPLIFYCFG_H #endif // LLVM_TRANSFORMS_SCALAR_LOOPSIMPLIFYCFG_H

include/llvm/Transforms/Scalar/LoopStrengthReduce.h

Show All 24 Lines
#include "llvm/Analysis/LoopInfo.h" #include "llvm/Analysis/LoopInfo.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
/// Performs Loop Strength Reduce Pass. /// Performs Loop Strength Reduce Pass.
class LoopStrengthReducePass : public PassInfoMixin<LoopStrengthReducePass> { class LoopStrengthReducePass : public PassInfoMixin<LoopStrengthReducePass> {
public: public:
PreservedAnalyses run(Loop &L, AnalysisManager<Loop> &AM); PreservedAnalyses run(Loop &L, AnalysisManager &AM);
}; };
} // end namespace llvm } // end namespace llvm
#endif // LLVM_TRANSFORMS_SCALAR_LOOPSTRENGTHREDUCE_H #endif // LLVM_TRANSFORMS_SCALAR_LOOPSTRENGTHREDUCE_H

include/llvm/Transforms/Scalar/LoopUnrollPass.h

Show All 15 Lines
namespace llvm { namespace llvm {
struct LoopUnrollPass : public PassInfoMixin<LoopUnrollPass> { struct LoopUnrollPass : public PassInfoMixin<LoopUnrollPass> {
Optional<unsigned> ProvidedCount; Optional<unsigned> ProvidedCount;
Optional<unsigned> ProvidedThreshold; Optional<unsigned> ProvidedThreshold;
Optional<bool> ProvidedAllowPartial; Optional<bool> ProvidedAllowPartial;
Optional<bool> ProvidedRuntime; Optional<bool> ProvidedRuntime;
PreservedAnalyses run(Loop &L, AnalysisManager<Loop> &AM); PreservedAnalyses run(Loop &L, AnalysisManager &AM);
}; };
} // end namespace llvm } // end namespace llvm
#endif // LLVM_TRANSFORMS_SCALAR_LOOPUNROLLPASS_H #endif // LLVM_TRANSFORMS_SCALAR_LOOPUNROLLPASS_H

include/llvm/Transforms/Scalar/LowerAtomic.h

Show All 16 Lines
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
/// A pass that lowers atomic intrinsic into non-atomic intrinsics. /// A pass that lowers atomic intrinsic into non-atomic intrinsics.
class LowerAtomicPass : public PassInfoMixin<LowerAtomicPass> { class LowerAtomicPass : public PassInfoMixin<LowerAtomicPass> {
public: public:
PreservedAnalyses run(Function &F, FunctionAnalysisManager &); PreservedAnalyses run(Function &F, AnalysisManager &);
}; };
} }
#endif // LLVM_TRANSFORMS_SCALAR_LOWERATOMIC_H #endif // LLVM_TRANSFORMS_SCALAR_LOWERATOMIC_H

include/llvm/Transforms/Scalar/LowerExpectIntrinsic.h

Show All 23 Lines
struct LowerExpectIntrinsicPass : PassInfoMixin<LowerExpectIntrinsicPass> { struct LowerExpectIntrinsicPass : PassInfoMixin<LowerExpectIntrinsicPass> {
/// \brief Run the pass over the function. /// \brief Run the pass over the function.
/// ///
/// This will lower all of th expect intrinsic calls in this function into /// This will lower all of th expect intrinsic calls in this function into
/// branch weight metadata. That metadata will subsequently feed the analysis /// branch weight metadata. That metadata will subsequently feed the analysis
/// of the probabilities and frequencies of the CFG. After running this pass, /// of the probabilities and frequencies of the CFG. After running this pass,
/// no more expect intrinsics remain, allowing the rest of the optimizer to /// no more expect intrinsics remain, allowing the rest of the optimizer to
/// ignore them. /// ignore them.
PreservedAnalyses run(Function &F, FunctionAnalysisManager &); PreservedAnalyses run(Function &F, AnalysisManager &);
}; };
} }
#endif #endif

include/llvm/Transforms/Scalar/LowerGuardIntrinsic.h

Show All 14 Lines
#ifndef LLVM_TRANSFORMS_SCALAR_LOWERGUARDINTRINSIC_H #ifndef LLVM_TRANSFORMS_SCALAR_LOWERGUARDINTRINSIC_H
#define LLVM_TRANSFORMS_SCALAR_LOWERGUARDINTRINSIC_H #define LLVM_TRANSFORMS_SCALAR_LOWERGUARDINTRINSIC_H
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
struct LowerGuardIntrinsicPass : PassInfoMixin<LowerGuardIntrinsicPass> { struct LowerGuardIntrinsicPass : PassInfoMixin<LowerGuardIntrinsicPass> {
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
} }
#endif //LLVM_TRANSFORMS_SCALAR_LOWERGUARDINTRINSIC_H #endif //LLVM_TRANSFORMS_SCALAR_LOWERGUARDINTRINSIC_H

include/llvm/Transforms/Scalar/MemCpyOptimizer.h

Show All 32 Linesclass MemCpyOptPass : public PassInfoMixin<MemCpyOptPass> {
MemoryDependenceResults *MD = nullptr; MemoryDependenceResults *MD = nullptr;
TargetLibraryInfo *TLI = nullptr; TargetLibraryInfo *TLI = nullptr;
std::function<AliasAnalysis &()> LookupAliasAnalysis; std::function<AliasAnalysis &()> LookupAliasAnalysis;
std::function<AssumptionCache &()> LookupAssumptionCache; std::function<AssumptionCache &()> LookupAssumptionCache;
std::function<DominatorTree &()> LookupDomTree; std::function<DominatorTree &()> LookupDomTree;
public: public:
MemCpyOptPass() {} MemCpyOptPass() {}
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
// Glue for the old PM. // Glue for the old PM.
bool runImpl(Function &F, MemoryDependenceResults *MD_, bool runImpl(Function &F, MemoryDependenceResults *MD_,
TargetLibraryInfo *TLI_, TargetLibraryInfo *TLI_,
std::function<AliasAnalysis &()> LookupAliasAnalysis_, std::function<AliasAnalysis &()> LookupAliasAnalysis_,
std::function<AssumptionCache &()> LookupAssumptionCache_, std::function<AssumptionCache &()> LookupAssumptionCache_,
std::function<DominatorTree &()> LookupDomTree_); std::function<DominatorTree &()> LookupDomTree_);
private: private:
Show All 19 Lines

include/llvm/Transforms/Scalar/MergedLoadStoreMotion.h

Show All 25 Lines
#include "llvm/IR/Module.h" #include "llvm/IR/Module.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
class MergedLoadStoreMotionPass class MergedLoadStoreMotionPass
: public PassInfoMixin<MergedLoadStoreMotionPass> { : public PassInfoMixin<MergedLoadStoreMotionPass> {
public: public:
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
} }
#endif // LLVM_TRANSFORMS_SCALAR_MERGEDLOADSTOREMOTION_H #endif // LLVM_TRANSFORMS_SCALAR_MERGEDLOADSTOREMOTION_H

include/llvm/Transforms/Scalar/NaryReassociate.h

Show First 20 Lines • Show All 86 Lines • ▼ Show 20 Lines
#include "llvm/Analysis/TargetTransformInfo.h" #include "llvm/Analysis/TargetTransformInfo.h"
#include "llvm/IR/Dominators.h" #include "llvm/IR/Dominators.h"
#include "llvm/IR/Function.h" #include "llvm/IR/Function.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
class NaryReassociatePass : public PassInfoMixin<NaryReassociatePass> { class NaryReassociatePass : public PassInfoMixin<NaryReassociatePass> {
public: public:
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
// Glue for old PM. // Glue for old PM.
bool runImpl(Function &F, AssumptionCache *AC_, DominatorTree *DT_, bool runImpl(Function &F, AssumptionCache *AC_, DominatorTree *DT_,
ScalarEvolution *SE_, TargetLibraryInfo *TLI_, ScalarEvolution *SE_, TargetLibraryInfo *TLI_,
TargetTransformInfo *TTI_); TargetTransformInfo *TTI_);
private: private:
// Runs only one iteration of the dominator-based algorithm. See the header // Runs only one iteration of the dominator-based algorithm. See the header
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

include/llvm/Transforms/Scalar/PartiallyInlineLibCalls.h

Show All 17 Lines
#include "llvm/IR/Module.h" #include "llvm/IR/Module.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
class PartiallyInlineLibCallsPass class PartiallyInlineLibCallsPass
: public PassInfoMixin<PartiallyInlineLibCallsPass> { : public PassInfoMixin<PartiallyInlineLibCallsPass> {
public: public:
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
} }
#endif // LLVM_TRANSFORMS_SCALAR_PARTIALLYINLINELIBCALLS_H #endif // LLVM_TRANSFORMS_SCALAR_PARTIALLYINLINELIBCALLS_H

include/llvm/Transforms/Scalar/Reassociate.h

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines
/// Reassociate commutative expressions. /// Reassociate commutative expressions.
class ReassociatePass : public PassInfoMixin<ReassociatePass> { class ReassociatePass : public PassInfoMixin<ReassociatePass> {
DenseMap<BasicBlock *, unsigned> RankMap; DenseMap<BasicBlock *, unsigned> RankMap;
DenseMap<AssertingVH<Value>, unsigned> ValueRankMap; DenseMap<AssertingVH<Value>, unsigned> ValueRankMap;
SetVector<AssertingVH<Instruction>> RedoInsts; SetVector<AssertingVH<Instruction>> RedoInsts;
bool MadeChange; bool MadeChange;
public: public:
PreservedAnalyses run(Function &F, FunctionAnalysisManager &); PreservedAnalyses run(Function &F, AnalysisManager &);
private: private:
void BuildRankMap(Function &F, ReversePostOrderTraversal<Function *> &RPOT); void BuildRankMap(Function &F, ReversePostOrderTraversal<Function *> &RPOT);
unsigned getRank(Value *V); unsigned getRank(Value *V);
void canonicalizeOperands(Instruction *I); void canonicalizeOperands(Instruction *I);
void ReassociateExpression(BinaryOperator *I); void ReassociateExpression(BinaryOperator *I);
void RewriteExprTree(BinaryOperator *I, void RewriteExprTree(BinaryOperator *I,
SmallVectorImpl<reassociate::ValueEntry> &Ops); SmallVectorImpl<reassociate::ValueEntry> &Ops);
Show All 27 Lines

include/llvm/Transforms/Scalar/SCCP.h

Show All 23 Lines
#include "llvm/IR/Function.h" #include "llvm/IR/Function.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
/// This pass performs function-level constant propagation and merging. /// This pass performs function-level constant propagation and merging.
class SCCPPass : public PassInfoMixin<SCCPPass> { class SCCPPass : public PassInfoMixin<SCCPPass> {
public: public:
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
} }
#endif // LLVM_TRANSFORMS_SCALAR_SCCP_H #endif // LLVM_TRANSFORMS_SCALAR_SCCP_H

include/llvm/Transforms/Scalar/SROA.h

Show First 20 Lines • Show All 96 Lines • ▼ Show 20 Linesclass SROA : public PassInfoMixin<SROA> {
/// speculation and by being speculated will allow promoting allocas /// speculation and by being speculated will allow promoting allocas
/// currently in the promotable queue. /// currently in the promotable queue.
SetVector<SelectInst *, SmallVector<SelectInst *, 2>> SpeculatableSelects; SetVector<SelectInst *, SmallVector<SelectInst *, 2>> SpeculatableSelects;
public: public:
SROA() : C(nullptr), DT(nullptr), AC(nullptr) {} SROA() : C(nullptr), DT(nullptr), AC(nullptr) {}
/// \brief Run the pass over the function. /// \brief Run the pass over the function.
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
private: private:
friend class sroa::AllocaSliceRewriter; friend class sroa::AllocaSliceRewriter;
friend class sroa::SROALegacyPass; friend class sroa::SROALegacyPass;
/// Helper used by both the public run method and by the legacy pass. /// Helper used by both the public run method and by the legacy pass.
PreservedAnalyses runImpl(Function &F, DominatorTree &RunDT, PreservedAnalyses runImpl(Function &F, DominatorTree &RunDT,
AssumptionCache &RunAC); AssumptionCache &RunAC);
Show All 14 Lines

include/llvm/Transforms/Scalar/SimplifyCFG.h

Show All 30 Lines
public: public:
/// \brief Construct a pass with the default thresholds. /// \brief Construct a pass with the default thresholds.
SimplifyCFGPass(); SimplifyCFGPass();
/// \brief Construct a pass with a specific bonus threshold. /// \brief Construct a pass with a specific bonus threshold.
SimplifyCFGPass(int BonusInstThreshold); SimplifyCFGPass(int BonusInstThreshold);
/// \brief Run the pass over the function. /// \brief Run the pass over the function.
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
} }
#endif #endif

include/llvm/Transforms/Scalar/Sink.h

Show All 17 Lines
#include "llvm/IR/Function.h" #include "llvm/IR/Function.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
/// Move instructions into successor blocks when possible. /// Move instructions into successor blocks when possible.
class SinkingPass : public PassInfoMixin<SinkingPass> { class SinkingPass : public PassInfoMixin<SinkingPass> {
public: public:
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
} }
#endif // LLVM_TRANSFORMS_SCALAR_SINK_H #endif // LLVM_TRANSFORMS_SCALAR_SINK_H

include/llvm/Transforms/Scalar/SpeculativeExecution.h

Show First 20 Lines • Show All 66 Lines • ▼ Show 20 Lines
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
class SpeculativeExecutionPass class SpeculativeExecutionPass
: public PassInfoMixin<SpeculativeExecutionPass> { : public PassInfoMixin<SpeculativeExecutionPass> {
public: public:
SpeculativeExecutionPass(bool OnlyIfDivergentTarget = false); SpeculativeExecutionPass(bool OnlyIfDivergentTarget = false);
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
// Glue for old PM // Glue for old PM
bool runImpl(Function &F, TargetTransformInfo *TTI); bool runImpl(Function &F, TargetTransformInfo *TTI);
private: private:
bool runOnBasicBlock(BasicBlock &B); bool runOnBasicBlock(BasicBlock &B);
bool considerHoistingFromTo(BasicBlock &FromBlock, BasicBlock &ToBlock); bool considerHoistingFromTo(BasicBlock &FromBlock, BasicBlock &ToBlock);
Show All 9 Lines

include/llvm/Transforms/Scalar/TailRecursionElimination.h

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
#define LLVM_TRANSFORMS_SCALAR_TAILRECURSIONELIMINATION_H #define LLVM_TRANSFORMS_SCALAR_TAILRECURSIONELIMINATION_H
#include "llvm/IR/Function.h" #include "llvm/IR/Function.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
struct TailCallElimPass : PassInfoMixin<TailCallElimPass> { struct TailCallElimPass : PassInfoMixin<TailCallElimPass> {
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
} }
#endif // LLVM_TRANSFORMS_SCALAR_TAILRECURSIONELIMINATION_H #endif // LLVM_TRANSFORMS_SCALAR_TAILRECURSIONELIMINATION_H

include/llvm/Transforms/Utils/AddDiscriminators.h

Show All 16 Lines
#define LLVM_TRANSFORMS_UTILS_ADDDISCRIMINATORS_H #define LLVM_TRANSFORMS_UTILS_ADDDISCRIMINATORS_H
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
class AddDiscriminatorsPass : public PassInfoMixin<AddDiscriminatorsPass> { class AddDiscriminatorsPass : public PassInfoMixin<AddDiscriminatorsPass> {
public: public:
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
} // end namespace llvm } // end namespace llvm
#endif // LLVM_TRANSFORMS_UTILS_ADDDISCRIMINATORS_H #endif // LLVM_TRANSFORMS_UTILS_ADDDISCRIMINATORS_H

include/llvm/Transforms/Utils/BreakCriticalEdges.h

Show All 17 Lines
#ifndef LLVM_TRANSFORMS_UTILS_BREAKCRITICALEDGES_H #ifndef LLVM_TRANSFORMS_UTILS_BREAKCRITICALEDGES_H
#define LLVM_TRANSFORMS_UTILS_BREAKCRITICALEDGES_H #define LLVM_TRANSFORMS_UTILS_BREAKCRITICALEDGES_H
#include "llvm/IR/Function.h" #include "llvm/IR/Function.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
struct BreakCriticalEdgesPass : public PassInfoMixin<BreakCriticalEdgesPass> { struct BreakCriticalEdgesPass : public PassInfoMixin<BreakCriticalEdgesPass> {
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
} // namespace llvm } // namespace llvm
#endif // LLVM_TRANSFORMS_UTILS_BREAKCRITICALEDGES_H #endif // LLVM_TRANSFORMS_UTILS_BREAKCRITICALEDGES_H

include/llvm/Transforms/Utils/LCSSA.h

Show All 31 Lines
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
/// Converts loops into loop-closed SSA form. /// Converts loops into loop-closed SSA form.
class LCSSAPass : public PassInfoMixin<LCSSAPass> { class LCSSAPass : public PassInfoMixin<LCSSAPass> {
public: public:
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
} // end namespace llvm } // end namespace llvm
#endif // LLVM_TRANSFORMS_UTILS_LCSSA_H #endif // LLVM_TRANSFORMS_UTILS_LCSSA_H

include/llvm/Transforms/Utils/LoopSimplify.h

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
#include "llvm/IR/Dominators.h" #include "llvm/IR/Dominators.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
/// This pass is responsible for loop canonicalization. /// This pass is responsible for loop canonicalization.
class LoopSimplifyPass : public PassInfoMixin<LoopSimplifyPass> { class LoopSimplifyPass : public PassInfoMixin<LoopSimplifyPass> {
public: public:
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
/// \brief Simplify each loop in a loop nest recursively. /// \brief Simplify each loop in a loop nest recursively.
/// ///
/// This takes a potentially un-simplified loop L (and its children) and turns /// This takes a potentially un-simplified loop L (and its children) and turns
/// it into a simplified loop nest with preheaders and single backedges. It will /// it into a simplified loop nest with preheaders and single backedges. It will
/// update \c AliasAnalysis and \c ScalarEvolution analyses if they're non-null. /// update \c AliasAnalysis and \c ScalarEvolution analyses if they're non-null.
bool simplifyLoop(Loop *L, DominatorTree *DT, LoopInfo *LI, ScalarEvolution *SE, bool simplifyLoop(Loop *L, DominatorTree *DT, LoopInfo *LI, ScalarEvolution *SE,
AssumptionCache *AC, bool PreserveLCSSA); AssumptionCache *AC, bool PreserveLCSSA);
} // end namespace llvm } // end namespace llvm
#endif // LLVM_TRANSFORMS_UTILS_LOOPSIMPLIFY_H #endif // LLVM_TRANSFORMS_UTILS_LOOPSIMPLIFY_H

include/llvm/Transforms/Utils/Mem2Reg.h

Show All 15 Lines
#define LLVM_TRANSFORMS_UTILS_MEM2REG_H #define LLVM_TRANSFORMS_UTILS_MEM2REG_H
#include "llvm/IR/Function.h" #include "llvm/IR/Function.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
class PromotePass : public PassInfoMixin<PromotePass> { class PromotePass : public PassInfoMixin<PromotePass> {
public: public:
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
} }
#endif // LLVM_TRANSFORMS_UTILS_MEM2REG_H #endif // LLVM_TRANSFORMS_UTILS_MEM2REG_H
No newline at end of file

include/llvm/Transforms/Utils/MemorySSA.h

Show First 20 Lines • Show All 672 Lines • ▼ Show 20 Lines
/// ///
class MemorySSAAnalysis : public AnalysisInfoMixin<MemorySSAAnalysis> { class MemorySSAAnalysis : public AnalysisInfoMixin<MemorySSAAnalysis> {
friend AnalysisInfoMixin<MemorySSAAnalysis>; friend AnalysisInfoMixin<MemorySSAAnalysis>;
static char PassID; static char PassID;
public: public:
typedef MemorySSA Result; typedef MemorySSA Result;
MemorySSA run(Function &F, AnalysisManager<Function> &AM); MemorySSA run(Function &F, AnalysisManager &AM);
}; };
/// \brief Printer pass for \c MemorySSA. /// \brief Printer pass for \c MemorySSA.
class MemorySSAPrinterPass : public PassInfoMixin<MemorySSAPrinterPass> { class MemorySSAPrinterPass : public PassInfoMixin<MemorySSAPrinterPass> {
raw_ostream &OS; raw_ostream &OS;
public: public:
explicit MemorySSAPrinterPass(raw_ostream &OS) : OS(OS) {} explicit MemorySSAPrinterPass(raw_ostream &OS) : OS(OS) {}
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
/// \brief Verifier pass for \c MemorySSA. /// \brief Verifier pass for \c MemorySSA.
struct MemorySSAVerifierPass : PassInfoMixin<MemorySSAVerifierPass> { struct MemorySSAVerifierPass : PassInfoMixin<MemorySSAVerifierPass> {
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
/// \brief Legacy analysis pass which computes \c MemorySSA. /// \brief Legacy analysis pass which computes \c MemorySSA.
class MemorySSAWrapperPass : public FunctionPass { class MemorySSAWrapperPass : public FunctionPass {
public: public:
MemorySSAWrapperPass(); MemorySSAWrapperPass();
static char ID; static char ID;
▲ Show 20 Lines • Show All 289 Lines • Show Last 20 Lines

include/llvm/Transforms/Utils/SimplifyInstructions.h

Show All 18 Lines
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
/// This pass removes redundant instructions. /// This pass removes redundant instructions.
class InstSimplifierPass : public PassInfoMixin<InstSimplifierPass> { class InstSimplifierPass : public PassInfoMixin<InstSimplifierPass> {
public: public:
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
}; };
} // end namespace llvm } // end namespace llvm
#endif // LLVM_TRANSFORMS_UTILS_SIMPLIFYINSTRUCTIONS_H #endif // LLVM_TRANSFORMS_UTILS_SIMPLIFYINSTRUCTIONS_H

include/llvm/Transforms/Utils/SymbolRewriter.h

Show First 20 Lines • Show All 117 Lines • ▼ Show 20 Linespublic:
RewriteSymbolPass() { loadAndParseMapFiles(); } RewriteSymbolPass() { loadAndParseMapFiles(); }
RewriteSymbolPass(SymbolRewriter::RewriteDescriptorList &DL) { RewriteSymbolPass(SymbolRewriter::RewriteDescriptorList &DL) {
Descriptors.splice(Descriptors.begin(), DL); Descriptors.splice(Descriptors.begin(), DL);
} }
RewriteSymbolPass(RewriteSymbolPass &&Other) RewriteSymbolPass(RewriteSymbolPass &&Other)
: Descriptors(std::move(Other.Descriptors)) {} : Descriptors(std::move(Other.Descriptors)) {}
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM); PreservedAnalyses run(Module &M, AnalysisManager &AM);
// Glue for old PM // Glue for old PM
bool runImpl(Module &M); bool runImpl(Module &M);
private: private:
void loadAndParseMapFiles(); void loadAndParseMapFiles();
SymbolRewriter::RewriteDescriptorList Descriptors; SymbolRewriter::RewriteDescriptorList Descriptors;
}; };
} }
#endif //LLVM_TRANSFORMS_UTILS_SYMBOLREWRITER_H #endif //LLVM_TRANSFORMS_UTILS_SYMBOLREWRITER_H

include/llvm/Transforms/Vectorize/LoopVectorize.h

Show First 20 Lines • Show All 83 Lines • ▼ Show 20 Linesstruct LoopVectorizePass : public PassInfoMixin<LoopVectorizePass> {
DemandedBits *DB; DemandedBits *DB;
AliasAnalysis *AA; AliasAnalysis *AA;
AssumptionCache *AC; AssumptionCache *AC;
std::function<const LoopAccessInfo &(Loop &)> *GetLAA; std::function<const LoopAccessInfo &(Loop &)> *GetLAA;
OptimizationRemarkEmitter *ORE; OptimizationRemarkEmitter *ORE;
BlockFrequency ColdEntryFreq; BlockFrequency ColdEntryFreq;
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
// Shim for old PM. // Shim for old PM.
bool runImpl(Function &F, ScalarEvolution &SE_, LoopInfo &LI_, bool runImpl(Function &F, ScalarEvolution &SE_, LoopInfo &LI_,
TargetTransformInfo &TTI_, DominatorTree &DT_, TargetTransformInfo &TTI_, DominatorTree &DT_,
BlockFrequencyInfo &BFI_, TargetLibraryInfo *TLI_, BlockFrequencyInfo &BFI_, TargetLibraryInfo *TLI_,
DemandedBits &DB_, AliasAnalysis &AA_, AssumptionCache &AC_, DemandedBits &DB_, AliasAnalysis &AA_, AssumptionCache &AC_,
std::function<const LoopAccessInfo &(Loop &)> &GetLAA_, std::function<const LoopAccessInfo &(Loop &)> &GetLAA_,
OptimizationRemarkEmitter &ORE); OptimizationRemarkEmitter &ORE);
bool processLoop(Loop *L); bool processLoop(Loop *L);
}; };
} }
#endif // LLVM_TRANSFORMS_VECTORIZE_LOOPVECTORIZE_H #endif // LLVM_TRANSFORMS_VECTORIZE_LOOPVECTORIZE_H

include/llvm/Transforms/Vectorize/SLPVectorizer.h

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Linesstruct SLPVectorizerPass : public PassInfoMixin<SLPVectorizerPass> {
AliasAnalysis *AA = nullptr; AliasAnalysis *AA = nullptr;
LoopInfo *LI = nullptr; LoopInfo *LI = nullptr;
DominatorTree *DT = nullptr; DominatorTree *DT = nullptr;
AssumptionCache *AC = nullptr; AssumptionCache *AC = nullptr;
DemandedBits *DB = nullptr; DemandedBits *DB = nullptr;
const DataLayout *DL = nullptr; const DataLayout *DL = nullptr;
public: public:
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); PreservedAnalyses run(Function &F, AnalysisManager &AM);
// Glue for old PM. // Glue for old PM.
bool runImpl(Function &F, ScalarEvolution *SE_, TargetTransformInfo *TTI_, bool runImpl(Function &F, ScalarEvolution *SE_, TargetTransformInfo *TTI_,
TargetLibraryInfo *TLI_, AliasAnalysis *AA_, LoopInfo *LI_, TargetLibraryInfo *TLI_, AliasAnalysis *AA_, LoopInfo *LI_,
DominatorTree *DT_, AssumptionCache *AC_, DemandedBits *DB_); DominatorTree *DT_, AssumptionCache *AC_, DemandedBits *DB_);
private: private:
/// \brief Collect store and getelementptr instructions and organize them /// \brief Collect store and getelementptr instructions and organize them
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

lib/Analysis/AliasAnalysisEvaluator.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 LinesPrintLoadStoreResults(const char *Msg, bool P, const Value *V1,
} }
} }
static inline bool isInterestingPointer(Value *V) { static inline bool isInterestingPointer(Value *V) {
return V->getType()->isPointerTy() return V->getType()->isPointerTy()
&& !isa<ConstantPointerNull>(V); && !isa<ConstantPointerNull>(V);
} }
PreservedAnalyses AAEvaluator::run(Function &F, AnalysisManager<Function> &AM) { PreservedAnalyses AAEvaluator::run(Function &F, AnalysisManager &AM) {
runInternal(F, AM.getResult<AAManager>(F)); runInternal(F, AM.getResult<AAManager>(F));
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
void AAEvaluator::runInternal(Function &F, AAResults &AA) { void AAEvaluator::runInternal(Function &F, AAResults &AA) {
const DataLayout &DL = F.getParent()->getDataLayout(); const DataLayout &DL = F.getParent()->getDataLayout();
++FunctionCount; ++FunctionCount;
▲ Show 20 Lines • Show All 290 Lines • Show Last 20 Lines

lib/Analysis/AssumptionCache.cpp

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Lines for (auto &VH : AssumeHandles) {
assert(AssumptionSet.insert(VH).second && assert(AssumptionSet.insert(VH).second &&
"Cache contains multiple copies of a call!"); "Cache contains multiple copies of a call!");
} }
#endif #endif
} }
char AssumptionAnalysis::PassID; char AssumptionAnalysis::PassID;
PreservedAnalyses AssumptionPrinterPass::run(Function &F, PreservedAnalyses AssumptionPrinterPass::run(Function &F, AnalysisManager &AM) {
AnalysisManager<Function> &AM) {
AssumptionCache &AC = AM.getResult<AssumptionAnalysis>(F); AssumptionCache &AC = AM.getResult<AssumptionAnalysis>(F);
OS << "Cached assumptions for function: " << F.getName() << "\n"; OS << "Cached assumptions for function: " << F.getName() << "\n";
for (auto &VH : AC.assumptions()) for (auto &VH : AC.assumptions())
if (VH) if (VH)
OS << " " << *cast<CallInst>(VH)->getArgOperand(0) << "\n"; OS << " " << *cast<CallInst>(VH)->getArgOperand(0) << "\n";
return PreservedAnalyses::all(); return PreservedAnalyses::all();
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

lib/Analysis/BasicAliasAnalysis.cpp

Show First 20 Lines • Show All 1,663 Lines • ▼ Show 20 Lines
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// BasicAliasAnalysis Pass // BasicAliasAnalysis Pass
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
char BasicAA::PassID; char BasicAA::PassID;
BasicAAResult BasicAA::run(Function &F, AnalysisManager<Function> &AM) { BasicAAResult BasicAA::run(Function &F, AnalysisManager &AM) {
return BasicAAResult(F.getParent()->getDataLayout(), return BasicAAResult(F.getParent()->getDataLayout(),
AM.getResult<TargetLibraryAnalysis>(F), AM.getResult<TargetLibraryAnalysis>(F),
AM.getResult<AssumptionAnalysis>(F), AM.getResult<AssumptionAnalysis>(F),
&AM.getResult<DominatorTreeAnalysis>(F), &AM.getResult<DominatorTreeAnalysis>(F),
AM.getCachedResult<LoopAnalysis>(F)); AM.getCachedResult<LoopAnalysis>(F));
} }
BasicAAWrapperPass::BasicAAWrapperPass() : FunctionPass(ID) { BasicAAWrapperPass::BasicAAWrapperPass() : FunctionPass(ID) {
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

lib/Analysis/BlockFrequencyInfo.cpp

Show First 20 Lines • Show All 251 Lines • ▼ Show 20 Lines BranchProbabilityInfo &BPI =
getAnalysis<BranchProbabilityInfoWrapperPass>().getBPI(); getAnalysis<BranchProbabilityInfoWrapperPass>().getBPI();
LoopInfo &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo(); LoopInfo &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
BFI.calculate(F, BPI, LI); BFI.calculate(F, BPI, LI);
return false; return false;
} }
char BlockFrequencyAnalysis::PassID; char BlockFrequencyAnalysis::PassID;
BlockFrequencyInfo BlockFrequencyAnalysis::run(Function &F, BlockFrequencyInfo BlockFrequencyAnalysis::run(Function &F,
AnalysisManager<Function> &AM) { AnalysisManager &AM) {
BlockFrequencyInfo BFI; BlockFrequencyInfo BFI;
BFI.calculate(F, AM.getResult<BranchProbabilityAnalysis>(F), BFI.calculate(F, AM.getResult<BranchProbabilityAnalysis>(F),
AM.getResult<LoopAnalysis>(F)); AM.getResult<LoopAnalysis>(F));
return BFI; return BFI;
} }
PreservedAnalyses PreservedAnalyses BlockFrequencyPrinterPass::run(Function &F,
BlockFrequencyPrinterPass::run(Function &F, AnalysisManager<Function> &AM) { AnalysisManager &AM) {
OS << "Printing analysis results of BFI for function " OS << "Printing analysis results of BFI for function "
<< "'" << F.getName() << "':" << "'" << F.getName() << "':"
<< "\n"; << "\n";
AM.getResult<BlockFrequencyAnalysis>(F).print(OS); AM.getResult<BlockFrequencyAnalysis>(F).print(OS);
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }

lib/Analysis/BranchProbabilityInfo.cpp

Show First 20 Lines • Show All 697 Lines • ▼ Show 20 Lines
void BranchProbabilityInfoWrapperPass::print(raw_ostream &OS, void BranchProbabilityInfoWrapperPass::print(raw_ostream &OS,
const Module *) const { const Module *) const {
BPI.print(OS); BPI.print(OS);
} }
char BranchProbabilityAnalysis::PassID; char BranchProbabilityAnalysis::PassID;
BranchProbabilityInfo BranchProbabilityInfo
BranchProbabilityAnalysis::run(Function &F, AnalysisManager<Function> &AM) { BranchProbabilityAnalysis::run(Function &F, AnalysisManager &AM) {
BranchProbabilityInfo BPI; BranchProbabilityInfo BPI;
BPI.calculate(F, AM.getResult<LoopAnalysis>(F)); BPI.calculate(F, AM.getResult<LoopAnalysis>(F));
return BPI; return BPI;
} }
PreservedAnalyses PreservedAnalyses
BranchProbabilityPrinterPass::run(Function &F, AnalysisManager<Function> &AM) { BranchProbabilityPrinterPass::run(Function &F, AnalysisManager &AM) {
OS << "Printing analysis results of BPI for function " OS << "Printing analysis results of BPI for function "
<< "'" << F.getName() << "':" << "'" << F.getName() << "':"
<< "\n"; << "\n";
AM.getResult<BranchProbabilityAnalysis>(F).print(OS); AM.getResult<BranchProbabilityAnalysis>(F).print(OS);
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }

lib/Analysis/CFLAndersAliasAnalysis.cpp

Show First 20 Lines • Show All 863 Lines • ▼ Show 20 LinesAliasResult CFLAndersAAResult::alias(const MemoryLocation &LocA,
if (QueryResult == MayAlias) if (QueryResult == MayAlias)
return AAResultBase::alias(LocA, LocB); return AAResultBase::alias(LocA, LocB);
return QueryResult; return QueryResult;
} }
char CFLAndersAA::PassID; char CFLAndersAA::PassID;
CFLAndersAAResult CFLAndersAA::run(Function &F, AnalysisManager<Function> &AM) { CFLAndersAAResult CFLAndersAA::run(Function &F, AnalysisManager &AM) {
return CFLAndersAAResult(AM.getResult<TargetLibraryAnalysis>(F)); return CFLAndersAAResult(AM.getResult<TargetLibraryAnalysis>(F));
} }
char CFLAndersAAWrapperPass::ID = 0; char CFLAndersAAWrapperPass::ID = 0;
INITIALIZE_PASS(CFLAndersAAWrapperPass, "cfl-anders-aa", INITIALIZE_PASS(CFLAndersAAWrapperPass, "cfl-anders-aa",
"Inclusion-Based CFL Alias Analysis", false, true) "Inclusion-Based CFL Alias Analysis", false, true)
ImmutablePass *llvm::createCFLAndersAAWrapperPass() { ImmutablePass *llvm::createCFLAndersAAWrapperPass() {
Show All 16 Lines

lib/Analysis/CFLSteensAliasAnalysis.cpp

Show First 20 Lines • Show All 337 Lines • ▼ Show 20 Lines if (hasUnknownOrCallerAttr(AttrsA) || hasUnknownOrCallerAttr(AttrsB))
return MayAlias; return MayAlias;
if (isGlobalOrArgAttr(AttrsA) && isGlobalOrArgAttr(AttrsB)) if (isGlobalOrArgAttr(AttrsA) && isGlobalOrArgAttr(AttrsB))
return MayAlias; return MayAlias;
return NoAlias; return NoAlias;
} }
char CFLSteensAA::PassID; char CFLSteensAA::PassID;
CFLSteensAAResult CFLSteensAA::run(Function &F, AnalysisManager<Function> &AM) { CFLSteensAAResult CFLSteensAA::run(Function &F, AnalysisManager &AM) {
return CFLSteensAAResult(AM.getResult<TargetLibraryAnalysis>(F)); return CFLSteensAAResult(AM.getResult<TargetLibraryAnalysis>(F));
} }
char CFLSteensAAWrapperPass::ID = 0; char CFLSteensAAWrapperPass::ID = 0;
INITIALIZE_PASS(CFLSteensAAWrapperPass, "cfl-steens-aa", INITIALIZE_PASS(CFLSteensAAWrapperPass, "cfl-steens-aa",
"Unification-Based CFL Alias Analysis", false, true) "Unification-Based CFL Alias Analysis", false, true)
ImmutablePass *llvm::createCFLSteensAAWrapperPass() { ImmutablePass *llvm::createCFLSteensAAWrapperPass() {
Show All 16 Lines

lib/Analysis/CGSCCPassManager.cpp

//===- CGSCCPassManager.cpp - Managing & running CGSCC passes -------------===// //===- CGSCCPassManager.cpp - Managing & running CGSCC passes -------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "llvm/Analysis/CGSCCPassManager.h" #include "llvm/Analysis/CGSCCPassManager.h"
using namespace llvm; using namespace llvm;
// Explicit instantiations for the core proxy templates. // Explicit instantiations for the pass manager.
namespace llvm { namespace llvm {
template class PassManager<LazyCallGraph::SCC>; template class PassManager<LazyCallGraph::SCC>;
template class AnalysisManager<LazyCallGraph::SCC>; template struct ParentIRUnitTrackingAnalysis<LazyCallGraph::SCC>;
template class InnerAnalysisManagerProxy<CGSCCAnalysisManager, Module>; template <> char ParentIRUnitTrackingAnalysis<LazyCallGraph::SCC>::PassID = 0;
template class OuterAnalysisManagerProxy<ModuleAnalysisManager,
LazyCallGraph::SCC>;
template class InnerAnalysisManagerProxy<FunctionAnalysisManager,
LazyCallGraph::SCC>;
template class OuterAnalysisManagerProxy<CGSCCAnalysisManager, Function>;
} }

lib/Analysis/CallGraph.cpp

Show First 20 Lines • Show All 254 Lines • ▼ Show 20 Lines if (I->first == CS.getInstruction()) {
return; return;
} }
} }
} }
// Provide an explicit template instantiation for the static ID. // Provide an explicit template instantiation for the static ID.
char CallGraphAnalysis::PassID; char CallGraphAnalysis::PassID;
PreservedAnalyses CallGraphPrinterPass::run(Module &M, PreservedAnalyses CallGraphPrinterPass::run(Module &M, AnalysisManager &AM) {
AnalysisManager<Module> &AM) {
AM.getResult<CallGraphAnalysis>(M).print(OS); AM.getResult<CallGraphAnalysis>(M).print(OS);
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Out-of-line definitions of CallGraphAnalysis class members. // Out-of-line definitions of CallGraphAnalysis class members.
// //
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

lib/Analysis/DemandedBits.cpp

Show First 20 Lines • Show All 382 Lines • ▼ Show 20 Lines
} }
FunctionPass *llvm::createDemandedBitsWrapperPass() { FunctionPass *llvm::createDemandedBitsWrapperPass() {
return new DemandedBitsWrapperPass(); return new DemandedBitsWrapperPass();
} }
char DemandedBitsAnalysis::PassID; char DemandedBitsAnalysis::PassID;
DemandedBits DemandedBitsAnalysis::run(Function &F, DemandedBits DemandedBitsAnalysis::run(Function &F, AnalysisManager &AM) {
AnalysisManager<Function> &AM) {
auto &AC = AM.getResult<AssumptionAnalysis>(F); auto &AC = AM.getResult<AssumptionAnalysis>(F);
auto &DT = AM.getResult<DominatorTreeAnalysis>(F); auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
return DemandedBits(F, AC, DT); return DemandedBits(F, AC, DT);
} }
PreservedAnalyses DemandedBitsPrinterPass::run(Function &F, PreservedAnalyses DemandedBitsPrinterPass::run(Function &F,
FunctionAnalysisManager &AM) { AnalysisManager &AM) {
AM.getResult<DemandedBitsAnalysis>(F).print(OS); AM.getResult<DemandedBitsAnalysis>(F).print(OS);
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }

lib/Analysis/DependenceAnalysis.cpp

Show First 20 Lines • Show All 108 Lines • ▼ Show 20 Lines
static cl::opt<bool> static cl::opt<bool>
Delinearize("da-delinearize", cl::init(false), cl::Hidden, cl::ZeroOrMore, Delinearize("da-delinearize", cl::init(false), cl::Hidden, cl::ZeroOrMore,
cl::desc("Try to delinearize array references.")); cl::desc("Try to delinearize array references."));
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// basics // basics
DependenceAnalysis::Result DependenceAnalysis::Result DependenceAnalysis::run(Function &F,
DependenceAnalysis::run(Function &F, FunctionAnalysisManager &FAM) { AnalysisManager &AM) {
auto &AA = FAM.getResult<AAManager>(F); auto &AA = AM.getResult<AAManager>(F);
auto &SE = FAM.getResult<ScalarEvolutionAnalysis>(F); auto &SE = AM.getResult<ScalarEvolutionAnalysis>(F);
auto &LI = FAM.getResult<LoopAnalysis>(F); auto &LI = AM.getResult<LoopAnalysis>(F);
return DependenceInfo(&F, &AA, &SE, &LI); return DependenceInfo(&F, &AA, &SE, &LI);
} }
char DependenceAnalysis::PassID; char DependenceAnalysis::PassID;
INITIALIZE_PASS_BEGIN(DependenceAnalysisWrapperPass, "da", INITIALIZE_PASS_BEGIN(DependenceAnalysisWrapperPass, "da",
"Dependence Analysis", true, true) "Dependence Analysis", true, true)
INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass) INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
▲ Show 20 Lines • Show All 3,817 Lines • Show Last 20 Lines

lib/Analysis/DominanceFrontier.cpp

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
LLVM_DUMP_METHOD void DominanceFrontierWrapperPass::dump() const { LLVM_DUMP_METHOD void DominanceFrontierWrapperPass::dump() const {
print(dbgs()); print(dbgs());
} }
#endif #endif
char DominanceFrontierAnalysis::PassID; char DominanceFrontierAnalysis::PassID;
DominanceFrontier DominanceFrontierAnalysis::run(Function &F, DominanceFrontier DominanceFrontierAnalysis::run(Function &F,
FunctionAnalysisManager &AM) { AnalysisManager &AM) {
DominanceFrontier DF; DominanceFrontier DF;
DF.analyze(AM.getResult<DominatorTreeAnalysis>(F)); DF.analyze(AM.getResult<DominatorTreeAnalysis>(F));
return DF; return DF;
} }
DominanceFrontierPrinterPass::DominanceFrontierPrinterPass(raw_ostream &OS) DominanceFrontierPrinterPass::DominanceFrontierPrinterPass(raw_ostream &OS)
: OS(OS) {} : OS(OS) {}
PreservedAnalyses PreservedAnalyses
DominanceFrontierPrinterPass::run(Function &F, FunctionAnalysisManager &AM) { DominanceFrontierPrinterPass::run(Function &F, AnalysisManager &AM) {
OS << "DominanceFrontier for function: " << F.getName() << "\n"; OS << "DominanceFrontier for function: " << F.getName() << "\n";
AM.getResult<DominanceFrontierAnalysis>(F).print(OS); AM.getResult<DominanceFrontierAnalysis>(F).print(OS);
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }

lib/Analysis/GlobalsModRef.cpp

Show First 20 Lines • Show All 933 Lines • ▼ Show 20 LinesGlobalsAAResult::analyzeModule(Module &M, const TargetLibraryInfo &TLI,
// Propagate on CG. // Propagate on CG.
Result.AnalyzeCallGraph(CG, M); Result.AnalyzeCallGraph(CG, M);
return Result; return Result;
} }
char GlobalsAA::PassID; char GlobalsAA::PassID;
GlobalsAAResult GlobalsAA::run(Module &M, AnalysisManager<Module> &AM) { GlobalsAAResult GlobalsAA::run(Module &M, AnalysisManager &AM) {
return GlobalsAAResult::analyzeModule(M, return GlobalsAAResult::analyzeModule(M,
AM.getResult<TargetLibraryAnalysis>(M), AM.getResult<TargetLibraryAnalysis>(M),
AM.getResult<CallGraphAnalysis>(M)); AM.getResult<CallGraphAnalysis>(M));
} }
char GlobalsAAWrapperPass::ID = 0; char GlobalsAAWrapperPass::ID = 0;
INITIALIZE_PASS_BEGIN(GlobalsAAWrapperPass, "globals-aa", INITIALIZE_PASS_BEGIN(GlobalsAAWrapperPass, "globals-aa",
"Globals Alias Analysis", false, true) "Globals Alias Analysis", false, true)
Show All 30 Lines

lib/Analysis/IVUsers.cpp

Show All 30 Lines
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
#include <algorithm> #include <algorithm>
using namespace llvm; using namespace llvm;
#define DEBUG_TYPE "iv-users" #define DEBUG_TYPE "iv-users"
char IVUsersAnalysis::PassID; char IVUsersAnalysis::PassID;
IVUsers IVUsersAnalysis::run(Loop &L, AnalysisManager<Loop> &AM) { IVUsers IVUsersAnalysis::run(Loop &L, AnalysisManager &AM) {
const auto &FAM =
AM.getResult<FunctionAnalysisManagerLoopProxy>(L).getManager();
Function *F = L.getHeader()->getParent(); Function *F = L.getHeader()->getParent();
return IVUsers(&L, FAM.getCachedResult<AssumptionAnalysis>(*F), return IVUsers(&L, AM.getCachedResult<AssumptionAnalysis>(*F),
FAM.getCachedResult<LoopAnalysis>(*F), AM.getCachedResult<LoopAnalysis>(*F),
FAM.getCachedResult<DominatorTreeAnalysis>(*F), AM.getCachedResult<DominatorTreeAnalysis>(*F),
FAM.getCachedResult<ScalarEvolutionAnalysis>(*F)); AM.getCachedResult<ScalarEvolutionAnalysis>(*F));
} }
PreservedAnalyses IVUsersPrinterPass::run(Loop &L, AnalysisManager<Loop> &AM) { PreservedAnalyses IVUsersPrinterPass::run(Loop &L, AnalysisManager &AM) {
AM.getResult<IVUsersAnalysis>(L).print(OS); AM.getResult<IVUsersAnalysis>(L).print(OS);
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
char IVUsersWrapperPass::ID = 0; char IVUsersWrapperPass::ID = 0;
INITIALIZE_PASS_BEGIN(IVUsersWrapperPass, "iv-users", INITIALIZE_PASS_BEGIN(IVUsersWrapperPass, "iv-users",
"Induction Variable Users", false, true) "Induction Variable Users", false, true)
INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker) INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
▲ Show 20 Lines • Show All 334 Lines • Show Last 20 Lines

lib/Analysis/LazyCallGraph.cpp

Show First 20 Lines • Show All 1,537 Lines • ▼ Show 20 Linesstatic void printRefSCC(raw_ostream &OS, LazyCallGraph::RefSCC &C) {
for (LazyCallGraph::SCC &InnerC : C) for (LazyCallGraph::SCC &InnerC : C)
printSCC(OS, InnerC); printSCC(OS, InnerC);
OS << "\n"; OS << "\n";
} }
PreservedAnalyses LazyCallGraphPrinterPass::run(Module &M, PreservedAnalyses LazyCallGraphPrinterPass::run(Module &M,
ModuleAnalysisManager &AM) { AnalysisManager &AM) {
LazyCallGraph &G = AM.getResult<LazyCallGraphAnalysis>(M); LazyCallGraph &G = AM.getResult<LazyCallGraphAnalysis>(M);
OS << "Printing the call graph for module: " << M.getModuleIdentifier() OS << "Printing the call graph for module: " << M.getModuleIdentifier()
<< "\n\n"; << "\n\n";
for (Function &F : M) for (Function &F : M)
printNode(OS, G.get(F)); printNode(OS, G.get(F));
Show All 16 Lines if (!E.isCall()) // It is a ref edge.
OS << " [style=dashed,label=\"ref\"]"; OS << " [style=dashed,label=\"ref\"]";
OS << ";\n"; OS << ";\n";
} }
OS << "\n"; OS << "\n";
} }
PreservedAnalyses LazyCallGraphDOTPrinterPass::run(Module &M, PreservedAnalyses LazyCallGraphDOTPrinterPass::run(Module &M,
ModuleAnalysisManager &AM) { AnalysisManager &AM) {
LazyCallGraph &G = AM.getResult<LazyCallGraphAnalysis>(M); LazyCallGraph &G = AM.getResult<LazyCallGraphAnalysis>(M);
OS << "digraph \"" << DOT::EscapeString(M.getModuleIdentifier()) << "\" {\n"; OS << "digraph \"" << DOT::EscapeString(M.getModuleIdentifier()) << "\" {\n";
for (Function &F : M) for (Function &F : M)
printNodeDOT(OS, G.get(F)); printNodeDOT(OS, G.get(F));
OS << "}\n"; OS << "}\n";
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }

lib/Analysis/LazyValueInfo.cpp

Show First 20 Lines • Show All 1,479 Lines • ▼ Show 20 Linesvoid LazyValueInfo::releaseMemory() {
if (PImpl) { if (PImpl) {
delete &getCache(PImpl, AC, nullptr); delete &getCache(PImpl, AC, nullptr);
PImpl = nullptr; PImpl = nullptr;
} }
} }
void LazyValueInfoWrapperPass::releaseMemory() { Info.releaseMemory(); } void LazyValueInfoWrapperPass::releaseMemory() { Info.releaseMemory(); }
LazyValueInfo LazyValueAnalysis::run(Function &F, FunctionAnalysisManager &FAM) { LazyValueInfo LazyValueAnalysis::run(Function &F, AnalysisManager &AM) {
auto &AC = FAM.getResult<AssumptionAnalysis>(F); auto &AC = AM.getResult<AssumptionAnalysis>(F);
auto &TLI = FAM.getResult<TargetLibraryAnalysis>(F); auto &TLI = AM.getResult<TargetLibraryAnalysis>(F);
auto *DT = FAM.getCachedResult<DominatorTreeAnalysis>(F); auto *DT = AM.getCachedResult<DominatorTreeAnalysis>(F);
return LazyValueInfo(&AC, &TLI, DT); return LazyValueInfo(&AC, &TLI, DT);
} }
Constant *LazyValueInfo::getConstant(Value *V, BasicBlock *BB, Constant *LazyValueInfo::getConstant(Value *V, BasicBlock *BB,
Instruction *CxtI) { Instruction *CxtI) {
const DataLayout &DL = BB->getModule()->getDataLayout(); const DataLayout &DL = BB->getModule()->getDataLayout();
LVILatticeVal Result = LVILatticeVal Result =
▲ Show 20 Lines • Show All 231 Lines • Show Last 20 Lines

lib/Analysis/LoopAccessAnalysis.cpp

Show First 20 Lines • Show All 2,024 Lines • ▼ Show 20 Lines
INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass) INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass)
INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass) INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass)
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass) INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass) INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
INITIALIZE_PASS_END(LoopAccessLegacyAnalysis, LAA_NAME, laa_name, false, true) INITIALIZE_PASS_END(LoopAccessLegacyAnalysis, LAA_NAME, laa_name, false, true)
char LoopAccessAnalysis::PassID; char LoopAccessAnalysis::PassID;
LoopAccessInfo LoopAccessAnalysis::run(Loop &L, AnalysisManager<Loop> &AM) { LoopAccessInfo LoopAccessAnalysis::run(Loop &L, AnalysisManager &AM) {
const AnalysisManager<Function> &FAM =
AM.getResult<FunctionAnalysisManagerLoopProxy>(L).getManager();
Function &F = *L.getHeader()->getParent(); Function &F = *L.getHeader()->getParent();
auto *SE = FAM.getCachedResult<ScalarEvolutionAnalysis>(F); auto *SE = AM.getCachedResult<ScalarEvolutionAnalysis>(F);
auto *TLI = FAM.getCachedResult<TargetLibraryAnalysis>(F); auto *TLI = AM.getCachedResult<TargetLibraryAnalysis>(F);
auto *AA = FAM.getCachedResult<AAManager>(F); auto *AA = AM.getCachedResult<AAManager>(F);
auto *DT = FAM.getCachedResult<DominatorTreeAnalysis>(F); auto *DT = AM.getCachedResult<DominatorTreeAnalysis>(F);
auto *LI = FAM.getCachedResult<LoopAnalysis>(F); auto *LI = AM.getCachedResult<LoopAnalysis>(F);
if (!SE) if (!SE)
report_fatal_error( report_fatal_error(
"ScalarEvolution must have been cached at a higher level"); "ScalarEvolution must have been cached at a higher level");
if (!AA) if (!AA)
report_fatal_error("AliasAnalysis must have been cached at a higher level"); report_fatal_error("AliasAnalysis must have been cached at a higher level");
if (!DT) if (!DT)
report_fatal_error("DominatorTree must have been cached at a higher level"); report_fatal_error("DominatorTree must have been cached at a higher level");
if (!LI) if (!LI)
report_fatal_error("LoopInfo must have been cached at a higher level"); report_fatal_error("LoopInfo must have been cached at a higher level");
return LoopAccessInfo(&L, SE, TLI, AA, DT, LI); return LoopAccessInfo(&L, SE, TLI, AA, DT, LI);
} }
PreservedAnalyses LoopAccessInfoPrinterPass::run(Loop &L, PreservedAnalyses LoopAccessInfoPrinterPass::run(Loop &L, AnalysisManager &AM) {
AnalysisManager<Loop> &AM) {
Function &F = *L.getHeader()->getParent(); Function &F = *L.getHeader()->getParent();
auto &LAI = AM.getResult<LoopAccessAnalysis>(L); auto &LAI = AM.getResult<LoopAccessAnalysis>(L);
OS << "Loop access info in function '" << F.getName() << "':\n"; OS << "Loop access info in function '" << F.getName() << "':\n";
OS.indent(2) << L.getHeader()->getName() << ":\n"; OS.indent(2) << L.getHeader()->getName() << ":\n";
LAI.print(OS, 4); LAI.print(OS, 4);
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
namespace llvm { namespace llvm {
Pass *createLAAPass() { Pass *createLAAPass() {
return new LoopAccessLegacyAnalysis(); return new LoopAccessLegacyAnalysis();
} }
} }

lib/Analysis/LoopInfo.cpp

Show First 20 Lines • Show All 645 Lines • ▼ Show 20 Lines if (*I == Unloop) {
ParentLoop->removeChildLoop(I); ParentLoop->removeChildLoop(I);
break; break;
} }
} }
} }
char LoopAnalysis::PassID; char LoopAnalysis::PassID;
LoopInfo LoopAnalysis::run(Function &F, AnalysisManager<Function> &AM) { LoopInfo LoopAnalysis::run(Function &F, AnalysisManager &AM) {
// FIXME: Currently we create a LoopInfo from scratch for every function. // FIXME: Currently we create a LoopInfo from scratch for every function.
// This may prove to be too wasteful due to deallocating and re-allocating // This may prove to be too wasteful due to deallocating and re-allocating
// memory each time for the underlying map and vector datastructures. At some // memory each time for the underlying map and vector datastructures. At some
// point it may prove worthwhile to use a freelist and recycle LoopInfo // point it may prove worthwhile to use a freelist and recycle LoopInfo
// objects. I don't want to add that kind of complexity until the scope of // objects. I don't want to add that kind of complexity until the scope of
// the problem is better understood. // the problem is better understood.
LoopInfo LI; LoopInfo LI;
LI.analyze(AM.getResult<DominatorTreeAnalysis>(F)); LI.analyze(AM.getResult<DominatorTreeAnalysis>(F));
return LI; return LI;
} }
PreservedAnalyses LoopPrinterPass::run(Function &F, PreservedAnalyses LoopPrinterPass::run(Function &F,
AnalysisManager<Function> &AM) { AnalysisManager &AM) {
AM.getResult<LoopAnalysis>(F).print(OS); AM.getResult<LoopAnalysis>(F).print(OS);
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
PrintLoopPass::PrintLoopPass() : OS(dbgs()) {} PrintLoopPass::PrintLoopPass() : OS(dbgs()) {}
PrintLoopPass::PrintLoopPass(raw_ostream &OS, const std::string &Banner) PrintLoopPass::PrintLoopPass(raw_ostream &OS, const std::string &Banner)
: OS(OS), Banner(Banner) {} : OS(OS), Banner(Banner) {}
PreservedAnalyses PrintLoopPass::run(Loop &L, AnalysisManager<Loop> &) { PreservedAnalyses PrintLoopPass::run(Loop &L, AnalysisManager &) {
OS << Banner; OS << Banner;
for (auto *Block : L.blocks()) for (auto *Block : L.blocks())
if (Block) if (Block)
Block->print(OS); Block->print(OS);
else else
OS << "Printing <null> block"; OS << "Printing <null> block";
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
Show All 30 Linesvoid LoopInfoWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequired<DominatorTreeWrapperPass>(); AU.addRequired<DominatorTreeWrapperPass>();
} }
void LoopInfoWrapperPass::print(raw_ostream &OS, const Module *) const { void LoopInfoWrapperPass::print(raw_ostream &OS, const Module *) const {
LI.print(OS); LI.print(OS);
} }
PreservedAnalyses LoopVerifierPass::run(Function &F, PreservedAnalyses LoopVerifierPass::run(Function &F,
AnalysisManager<Function> &AM) { AnalysisManager &AM) {
LoopInfo &LI = AM.getResult<LoopAnalysis>(F); LoopInfo &LI = AM.getResult<LoopAnalysis>(F);
LI.verify(); LI.verify();
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// LoopBlocksDFS implementation // LoopBlocksDFS implementation
// //
Show All 9 Lines

lib/Analysis/LoopPass.cpp

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.setPreservesAll(); AU.setPreservesAll();
} }
bool runOnLoop(Loop *L, LPPassManager &) override { bool runOnLoop(Loop *L, LPPassManager &) override {
auto BBI = find_if(L->blocks().begin(), L->blocks().end(), auto BBI = find_if(L->blocks().begin(), L->blocks().end(),
[](BasicBlock *BB) { return BB; }); [](BasicBlock *BB) { return BB; });
if (BBI != L->blocks().end() && if (BBI != L->blocks().end() &&
isFunctionInPrintList((*BBI)->getParent()->getName())) { isFunctionInPrintList((*BBI)->getParent()->getName())) {
AnalysisManager<Loop> DummyLAM; AnalysisManager DummyAM;
P.run(*L, DummyLAM); P.run(*L, DummyAM);
} }
return false; return false;
} }
}; };
char PrintLoopPassWrapper::ID = 0; char PrintLoopPassWrapper::ID = 0;
} }
▲ Show 20 Lines • Show All 295 Lines • Show Last 20 Lines

lib/Analysis/LoopPassManager.cpp

Show All 14 Lines
#include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h" #include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h"
#include "llvm/IR/Dominators.h" #include "llvm/IR/Dominators.h"
using namespace llvm; using namespace llvm;
// Explicit instantiations for core typedef'ed templates. // Explicit instantiations for core typedef'ed templates.
namespace llvm { namespace llvm {
template class PassManager<Loop>; template class PassManager<Loop>;
template class AnalysisManager<Loop>; template struct ParentIRUnitTrackingAnalysis<Loop>;
template class InnerAnalysisManagerProxy<LoopAnalysisManager, Function>; template <> char ParentIRUnitTrackingAnalysis<Loop>::PassID = 0;
template class OuterAnalysisManagerProxy<FunctionAnalysisManager, Loop>;
} }
PreservedAnalyses llvm::getLoopPassPreservedAnalyses() { PreservedAnalyses llvm::getLoopPassPreservedAnalyses() {
PreservedAnalyses PA; PreservedAnalyses PA;
PA.preserve<DominatorTreeAnalysis>(); PA.preserve<DominatorTreeAnalysis>();
PA.preserve<LoopAnalysis>(); PA.preserve<LoopAnalysis>();
PA.preserve<ScalarEvolutionAnalysis>(); PA.preserve<ScalarEvolutionAnalysis>();
// TODO: What we really want to do here is preserve an AA category, but that // TODO: What we really want to do here is preserve an AA category, but that
// concept doesn't exist yet. // concept doesn't exist yet.
PA.preserve<BasicAA>(); PA.preserve<BasicAA>();
PA.preserve<GlobalsAA>(); PA.preserve<GlobalsAA>();
PA.preserve<SCEVAA>(); PA.preserve<SCEVAA>();
return PA; return PA;
} }

lib/Analysis/MemoryDependenceAnalysis.cpp

Show First 20 Lines • Show All 1,655 Lines • ▼ Show 20 Lines for (ValueIsLoadPair P : DepKV.second)
assert(P != ValueIsLoadPair(D, false) && P != ValueIsLoadPair(D, true) && assert(P != ValueIsLoadPair(D, false) && P != ValueIsLoadPair(D, true) &&
"Inst occurs in ReverseNonLocalPtrDeps map"); "Inst occurs in ReverseNonLocalPtrDeps map");
} }
#endif #endif
} }
char MemoryDependenceAnalysis::PassID; char MemoryDependenceAnalysis::PassID;
MemoryDependenceResults MemoryDependenceResults MemoryDependenceAnalysis::run(Function &F,
MemoryDependenceAnalysis::run(Function &F, AnalysisManager<Function> &AM) { AnalysisManager &AM) {
auto &AA = AM.getResult<AAManager>(F); auto &AA = AM.getResult<AAManager>(F);
auto &AC = AM.getResult<AssumptionAnalysis>(F); auto &AC = AM.getResult<AssumptionAnalysis>(F);
auto &TLI = AM.getResult<TargetLibraryAnalysis>(F); auto &TLI = AM.getResult<TargetLibraryAnalysis>(F);
auto &DT = AM.getResult<DominatorTreeAnalysis>(F); auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
return MemoryDependenceResults(AA, AC, TLI, DT); return MemoryDependenceResults(AA, AC, TLI, DT);
} }
char MemoryDependenceWrapperPass::ID = 0; char MemoryDependenceWrapperPass::ID = 0;
Show All 35 Lines

lib/Analysis/ObjCARCAliasAnalysis.cpp

Show First 20 Lines • Show All 125 Lines • ▼ Show 20 Lines case ARCInstKind::FusedRetainAutoreleaseRV:
return MRI_NoModRef; return MRI_NoModRef;
default: default:
break; break;
} }
return AAResultBase::getModRefInfo(CS, Loc); return AAResultBase::getModRefInfo(CS, Loc);
} }
ObjCARCAAResult ObjCARCAA::run(Function &F, AnalysisManager<Function> &AM) { ObjCARCAAResult ObjCARCAA::run(Function &F, AnalysisManager &AM) {
return ObjCARCAAResult(F.getParent()->getDataLayout()); return ObjCARCAAResult(F.getParent()->getDataLayout());
} }
char ObjCARCAAWrapperPass::ID = 0; char ObjCARCAAWrapperPass::ID = 0;
INITIALIZE_PASS(ObjCARCAAWrapperPass, "objc-arc-aa", INITIALIZE_PASS(ObjCARCAAWrapperPass, "objc-arc-aa",
"ObjC-ARC-Based Alias Analysis", false, true) "ObjC-ARC-Based Alias Analysis", false, true)
ImmutablePass *llvm::createObjCARCAAWrapperPass() { ImmutablePass *llvm::createObjCARCAAWrapperPass() {
Show All 20 Lines

lib/Analysis/OptimizationDiagnosticInfo.cpp

Show First 20 Lines • Show All 113 Lines • ▼ Show 20 Linesvoid OptimizationRemarkEmitterWrapperPass::getAnalysisUsage(
LazyBlockFrequencyInfoPass::getLazyBFIAnalysisUsage(AU); LazyBlockFrequencyInfoPass::getLazyBFIAnalysisUsage(AU);
AU.setPreservesAll(); AU.setPreservesAll();
} }
char OptimizationRemarkEmitterAnalysis::PassID; char OptimizationRemarkEmitterAnalysis::PassID;
OptimizationRemarkEmitter OptimizationRemarkEmitter
OptimizationRemarkEmitterAnalysis::run(Function &F, OptimizationRemarkEmitterAnalysis::run(Function &F,
AnalysisManager<Function> &AM) { AnalysisManager &AM) {
BlockFrequencyInfo *BFI; BlockFrequencyInfo *BFI;
if (F.getContext().getDiagnosticHotnessRequested()) if (F.getContext().getDiagnosticHotnessRequested())
BFI = &AM.getResult<BlockFrequencyAnalysis>(F); BFI = &AM.getResult<BlockFrequencyAnalysis>(F);
else else
BFI = nullptr; BFI = nullptr;
return OptimizationRemarkEmitter(&F, BFI); return OptimizationRemarkEmitter(&F, BFI);
Show All 11 Lines

lib/Analysis/PostDominators.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
FunctionPass* llvm::createPostDomTree() { FunctionPass* llvm::createPostDomTree() {
return new PostDominatorTreeWrapperPass(); return new PostDominatorTreeWrapperPass();
} }
char PostDominatorTreeAnalysis::PassID; char PostDominatorTreeAnalysis::PassID;
PostDominatorTree PostDominatorTreeAnalysis::run(Function &F, PostDominatorTree PostDominatorTreeAnalysis::run(Function &F,
FunctionAnalysisManager &) { AnalysisManager &) {
PostDominatorTree PDT; PostDominatorTree PDT;
PDT.recalculate(F); PDT.recalculate(F);
return PDT; return PDT;
} }
PostDominatorTreePrinterPass::PostDominatorTreePrinterPass(raw_ostream &OS) PostDominatorTreePrinterPass::PostDominatorTreePrinterPass(raw_ostream &OS)
: OS(OS) {} : OS(OS) {}
PreservedAnalyses PreservedAnalyses PostDominatorTreePrinterPass::run(Function &F,
PostDominatorTreePrinterPass::run(Function &F, FunctionAnalysisManager &AM) { AnalysisManager &AM) {
OS << "PostDominatorTree for function: " << F.getName() << "\n"; OS << "PostDominatorTree for function: " << F.getName() << "\n";
AM.getResult<PostDominatorTreeAnalysis>(F).print(OS); AM.getResult<PostDominatorTreeAnalysis>(F).print(OS);
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }

lib/Analysis/ProfileSummaryInfo.cpp

Show First 20 Lines • Show All 134 Lines • ▼ Show 20 LinesINITIALIZE_PASS(ProfileSummaryInfoWrapperPass, "profile-summary-info",
"Profile summary info", false, true) "Profile summary info", false, true)
ProfileSummaryInfoWrapperPass::ProfileSummaryInfoWrapperPass() ProfileSummaryInfoWrapperPass::ProfileSummaryInfoWrapperPass()
: ImmutablePass(ID) { : ImmutablePass(ID) {
initializeProfileSummaryInfoWrapperPassPass(*PassRegistry::getPassRegistry()); initializeProfileSummaryInfoWrapperPassPass(*PassRegistry::getPassRegistry());
} }
char ProfileSummaryAnalysis::PassID; char ProfileSummaryAnalysis::PassID;
ProfileSummaryInfo ProfileSummaryAnalysis::run(Module &M, ProfileSummaryInfo ProfileSummaryAnalysis::run(Module &M, AnalysisManager &) {
ModuleAnalysisManager &) {
return ProfileSummaryInfo(M); return ProfileSummaryInfo(M);
} }
// FIXME: This only tests isHotFunction and isColdFunction and not the // FIXME: This only tests isHotFunction and isColdFunction and not the
// isHotCount and isColdCount calls. // isHotCount and isColdCount calls.
PreservedAnalyses ProfileSummaryPrinterPass::run(Module &M, PreservedAnalyses ProfileSummaryPrinterPass::run(Module &M,
AnalysisManager<Module> &AM) { AnalysisManager &AM) {
ProfileSummaryInfo &PSI = AM.getResult<ProfileSummaryAnalysis>(M); ProfileSummaryInfo &PSI = AM.getResult<ProfileSummaryAnalysis>(M);
OS << "Functions in " << M.getName() << " with hot/cold annotations: \n"; OS << "Functions in " << M.getName() << " with hot/cold annotations: \n";
for (auto &F : M) { for (auto &F : M) {
OS << F.getName(); OS << F.getName();
if (PSI.isHotFunction(&F)) if (PSI.isHotFunction(&F))
OS << " :hot "; OS << " :hot ";
else if (PSI.isColdFunction(&F)) else if (PSI.isColdFunction(&F))
OS << " :cold "; OS << " :cold ";
OS << "\n"; OS << "\n";
} }
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
char ProfileSummaryInfoWrapperPass::ID = 0; char ProfileSummaryInfoWrapperPass::ID = 0;

lib/Analysis/RegionInfo.cpp

Show First 20 Lines • Show All 178 Lines • ▼ Show 20 Lines
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// RegionInfoAnalysis implementation // RegionInfoAnalysis implementation
// //
char RegionInfoAnalysis::PassID; char RegionInfoAnalysis::PassID;
RegionInfo RegionInfoAnalysis::run(Function &F, AnalysisManager<Function> &AM) { RegionInfo RegionInfoAnalysis::run(Function &F, AnalysisManager &AM) {
RegionInfo RI; RegionInfo RI;
auto *DT = &AM.getResult<DominatorTreeAnalysis>(F); auto *DT = &AM.getResult<DominatorTreeAnalysis>(F);
auto *PDT = &AM.getResult<PostDominatorTreeAnalysis>(F); auto *PDT = &AM.getResult<PostDominatorTreeAnalysis>(F);
auto *DF = &AM.getResult<DominanceFrontierAnalysis>(F); auto *DF = &AM.getResult<DominanceFrontierAnalysis>(F);
RI.recalculate(F, DT, PDT, DF); RI.recalculate(F, DT, PDT, DF);
return RI; return RI;
} }
RegionInfoPrinterPass::RegionInfoPrinterPass(raw_ostream &OS) RegionInfoPrinterPass::RegionInfoPrinterPass(raw_ostream &OS)
: OS(OS) {} : OS(OS) {}
PreservedAnalyses RegionInfoPrinterPass::run(Function &F, PreservedAnalyses RegionInfoPrinterPass::run(Function &F, AnalysisManager &AM) {
FunctionAnalysisManager &AM) {
OS << "Region Tree for function: " << F.getName() << "\n"; OS << "Region Tree for function: " << F.getName() << "\n";
AM.getResult<RegionInfoAnalysis>(F).print(OS); AM.getResult<RegionInfoAnalysis>(F).print(OS);
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
PreservedAnalyses RegionInfoVerifierPass::run(Function &F, PreservedAnalyses RegionInfoVerifierPass::run(Function &F,
AnalysisManager<Function> &AM) { AnalysisManager &AM) {
AM.getResult<RegionInfoAnalysis>(F).verifyAnalysis(); AM.getResult<RegionInfoAnalysis>(F).verifyAnalysis();
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }

lib/Analysis/ScalarEvolution.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 9,992 Lines • ▼ Show 20 Lines for (VerifyMap::iterator OldI = BackedgeDumpsOld.begin(),
} }
} }
// TODO: Verify more things. // TODO: Verify more things.
} }
char ScalarEvolutionAnalysis::PassID; char ScalarEvolutionAnalysis::PassID;
ScalarEvolution ScalarEvolutionAnalysis::run(Function &F, ScalarEvolution ScalarEvolutionAnalysis::run(Function &F, AnalysisManager &AM) {
AnalysisManager<Function> &AM) {
return ScalarEvolution(F, AM.getResult<TargetLibraryAnalysis>(F), return ScalarEvolution(F, AM.getResult<TargetLibraryAnalysis>(F),
AM.getResult<AssumptionAnalysis>(F), AM.getResult<AssumptionAnalysis>(F),
AM.getResult<DominatorTreeAnalysis>(F), AM.getResult<DominatorTreeAnalysis>(F),
AM.getResult<LoopAnalysis>(F)); AM.getResult<LoopAnalysis>(F));
} }
PreservedAnalyses PreservedAnalyses
ScalarEvolutionPrinterPass::run(Function &F, AnalysisManager<Function> &AM) { ScalarEvolutionPrinterPass::run(Function &F, AnalysisManager &AM) {
AM.getResult<ScalarEvolutionAnalysis>(F).print(OS); AM.getResult<ScalarEvolutionAnalysis>(F).print(OS);
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
INITIALIZE_PASS_BEGIN(ScalarEvolutionWrapperPass, "scalar-evolution", INITIALIZE_PASS_BEGIN(ScalarEvolutionWrapperPass, "scalar-evolution",
"Scalar Evolution Analysis", false, true) "Scalar Evolution Analysis", false, true)
INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker) INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass) INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
▲ Show 20 Lines • Show All 437 Lines • Show Last 20 Lines

lib/Analysis/ScalarEvolutionAliasAnalysis.cpp

Show First 20 Lines • Show All 106 Lines • ▼ Show 20 Lines if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(S)) {
return U->getValue(); return U->getValue();
} }
// No Identified object found. // No Identified object found.
return nullptr; return nullptr;
} }
char SCEVAA::PassID; char SCEVAA::PassID;
SCEVAAResult SCEVAA::run(Function &F, AnalysisManager<Function> &AM) { SCEVAAResult SCEVAA::run(Function &F, AnalysisManager &AM) {
return SCEVAAResult(AM.getResult<ScalarEvolutionAnalysis>(F)); return SCEVAAResult(AM.getResult<ScalarEvolutionAnalysis>(F));
} }
char SCEVAAWrapperPass::ID = 0; char SCEVAAWrapperPass::ID = 0;
INITIALIZE_PASS_BEGIN(SCEVAAWrapperPass, "scev-aa", INITIALIZE_PASS_BEGIN(SCEVAAWrapperPass, "scev-aa",
"ScalarEvolution-based Alias Analysis", false, true) "ScalarEvolution-based Alias Analysis", false, true)
INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass) INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass)
INITIALIZE_PASS_END(SCEVAAWrapperPass, "scev-aa", INITIALIZE_PASS_END(SCEVAAWrapperPass, "scev-aa",
Show All 20 Lines

lib/Analysis/ScopedNoAliasAA.cpp

Show First 20 Lines • Show All 169 Lines • ▼ Show 20 Linesbool ScopedNoAliasAAResult::mayAliasInScopes(const MDNode *Scopes,
} }
return true; return true;
} }
char ScopedNoAliasAA::PassID; char ScopedNoAliasAA::PassID;
ScopedNoAliasAAResult ScopedNoAliasAA::run(Function &F, ScopedNoAliasAAResult ScopedNoAliasAA::run(Function &F,
AnalysisManager<Function> &AM) { AnalysisManager &AM) {
return ScopedNoAliasAAResult(); return ScopedNoAliasAAResult();
} }
char ScopedNoAliasAAWrapperPass::ID = 0; char ScopedNoAliasAAWrapperPass::ID = 0;
INITIALIZE_PASS(ScopedNoAliasAAWrapperPass, "scoped-noalias", INITIALIZE_PASS(ScopedNoAliasAAWrapperPass, "scoped-noalias",
"Scoped NoAlias Alias Analysis", false, true) "Scoped NoAlias Alias Analysis", false, true)
ImmutablePass *llvm::createScopedNoAliasAAWrapperPass() { ImmutablePass *llvm::createScopedNoAliasAAWrapperPass() {
Show All 20 Lines

lib/Analysis/TargetLibraryInfo.cpp

Show First 20 Lines • Show All 1,185 Lines • ▼ Show 20 LinesStringRef TargetLibraryInfoImpl::getScalarizedFunction(StringRef F,
std::vector<VecDesc>::const_iterator I = std::lower_bound( std::vector<VecDesc>::const_iterator I = std::lower_bound(
ScalarDescs.begin(), ScalarDescs.end(), F, compareWithVectorFnName); ScalarDescs.begin(), ScalarDescs.end(), F, compareWithVectorFnName);
if (I == VectorDescs.end() || StringRef(I->VectorFnName) != F) if (I == VectorDescs.end() || StringRef(I->VectorFnName) != F)
return StringRef(); return StringRef();
VF = I->VectorizationFactor; VF = I->VectorizationFactor;
return I->ScalarFnName; return I->ScalarFnName;
} }
TargetLibraryInfo TargetLibraryAnalysis::run(Module &M, TargetLibraryInfo TargetLibraryAnalysis::run(Module &M, AnalysisManager &) {
ModuleAnalysisManager &) {
if (PresetInfoImpl) if (PresetInfoImpl)
return TargetLibraryInfo(*PresetInfoImpl); return TargetLibraryInfo(*PresetInfoImpl);
return TargetLibraryInfo(lookupInfoImpl(Triple(M.getTargetTriple()))); return TargetLibraryInfo(lookupInfoImpl(Triple(M.getTargetTriple())));
} }
TargetLibraryInfo TargetLibraryAnalysis::run(Function &F, TargetLibraryInfo TargetLibraryAnalysis::run(Function &F, AnalysisManager &) {
FunctionAnalysisManager &) {
if (PresetInfoImpl) if (PresetInfoImpl)
return TargetLibraryInfo(*PresetInfoImpl); return TargetLibraryInfo(*PresetInfoImpl);
return TargetLibraryInfo( return TargetLibraryInfo(
lookupInfoImpl(Triple(F.getParent()->getTargetTriple()))); lookupInfoImpl(Triple(F.getParent()->getTargetTriple())));
} }
TargetLibraryInfoImpl &TargetLibraryAnalysis::lookupInfoImpl(const Triple &T) { TargetLibraryInfoImpl &TargetLibraryAnalysis::lookupInfoImpl(const Triple &T) {
Show All 33 Lines

lib/Analysis/TargetTransformInfo.cpp

Show First 20 Lines • Show All 421 Lines • ▼ Show 20 Lines
TargetIRAnalysis::TargetIRAnalysis() : TTICallback(&getDefaultTTI) {} TargetIRAnalysis::TargetIRAnalysis() : TTICallback(&getDefaultTTI) {}
TargetIRAnalysis::TargetIRAnalysis( TargetIRAnalysis::TargetIRAnalysis(
std::function<Result(const Function &)> TTICallback) std::function<Result(const Function &)> TTICallback)
: TTICallback(std::move(TTICallback)) {} : TTICallback(std::move(TTICallback)) {}
TargetIRAnalysis::Result TargetIRAnalysis::run(const Function &F, TargetIRAnalysis::Result TargetIRAnalysis::run(const Function &F,
AnalysisManager<Function> &) { AnalysisManager &) {
return TTICallback(F); return TTICallback(F);
} }
char TargetIRAnalysis::PassID; char TargetIRAnalysis::PassID;
TargetIRAnalysis::Result TargetIRAnalysis::getDefaultTTI(const Function &F) { TargetIRAnalysis::Result TargetIRAnalysis::getDefaultTTI(const Function &F) {
return Result(F.getParent()->getDataLayout()); return Result(F.getParent()->getDataLayout());
} }
Show All 14 Lines
TargetTransformInfoWrapperPass::TargetTransformInfoWrapperPass( TargetTransformInfoWrapperPass::TargetTransformInfoWrapperPass(
TargetIRAnalysis TIRA) TargetIRAnalysis TIRA)
: ImmutablePass(ID), TIRA(std::move(TIRA)) { : ImmutablePass(ID), TIRA(std::move(TIRA)) {
initializeTargetTransformInfoWrapperPassPass( initializeTargetTransformInfoWrapperPassPass(
*PassRegistry::getPassRegistry()); *PassRegistry::getPassRegistry());
} }
TargetTransformInfo &TargetTransformInfoWrapperPass::getTTI(const Function &F) { TargetTransformInfo &TargetTransformInfoWrapperPass::getTTI(const Function &F) {
AnalysisManager<Function> DummyFAM; AnalysisManager DummyAM;
TTI = TIRA.run(F, DummyFAM); TTI = TIRA.run(F, DummyAM);
return *TTI; return *TTI;
} }
ImmutablePass * ImmutablePass *
llvm::createTargetTransformInfoWrapperPass(TargetIRAnalysis TIRA) { llvm::createTargetTransformInfoWrapperPass(TargetIRAnalysis TIRA) {
return new TargetTransformInfoWrapperPass(std::move(TIRA)); return new TargetTransformInfoWrapperPass(std::move(TIRA));
} }

lib/Analysis/TypeBasedAliasAnalysis.cpp

Show First 20 Lines • Show All 579 Lines • ▼ Show 20 Lines if (RootA.getNode() != RootB.getNode())
return true; return true;
// If they have the same root, then we've proved there's no alias. // If they have the same root, then we've proved there's no alias.
return false; return false;
} }
char TypeBasedAA::PassID; char TypeBasedAA::PassID;
TypeBasedAAResult TypeBasedAA::run(Function &F, AnalysisManager<Function> &AM) { TypeBasedAAResult TypeBasedAA::run(Function &F, AnalysisManager &AM) {
return TypeBasedAAResult(); return TypeBasedAAResult();
} }
char TypeBasedAAWrapperPass::ID = 0; char TypeBasedAAWrapperPass::ID = 0;
INITIALIZE_PASS(TypeBasedAAWrapperPass, "tbaa", "Type-Based Alias Analysis", INITIALIZE_PASS(TypeBasedAAWrapperPass, "tbaa", "Type-Based Alias Analysis",
false, true) false, true)
ImmutablePass *llvm::createTypeBasedAAWrapperPass() { ImmutablePass *llvm::createTypeBasedAAWrapperPass() {
Show All 20 Lines

lib/Bitcode/Writer/BitcodeWriterPass.cpp

Show All 13 Lines
#include "llvm/Bitcode/BitcodeWriterPass.h" #include "llvm/Bitcode/BitcodeWriterPass.h"
#include "llvm/Analysis/ModuleSummaryAnalysis.h" #include "llvm/Analysis/ModuleSummaryAnalysis.h"
#include "llvm/Bitcode/ReaderWriter.h" #include "llvm/Bitcode/ReaderWriter.h"
#include "llvm/IR/Module.h" #include "llvm/IR/Module.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
#include "llvm/Pass.h" #include "llvm/Pass.h"
using namespace llvm; using namespace llvm;
PreservedAnalyses BitcodeWriterPass::run(Module &M, ModuleAnalysisManager &) { PreservedAnalyses BitcodeWriterPass::run(Module &M, AnalysisManager &) {
std::unique_ptr<ModuleSummaryIndex> Index; std::unique_ptr<ModuleSummaryIndex> Index;
if (EmitSummaryIndex) if (EmitSummaryIndex)
Index = ModuleSummaryIndexBuilder(&M).takeIndex(); Index = ModuleSummaryIndexBuilder(&M).takeIndex();
WriteBitcodeToFile(&M, OS, ShouldPreserveUseListOrder, Index.get(), WriteBitcodeToFile(&M, OS, ShouldPreserveUseListOrder, Index.get(),
EmitModuleHash); EmitModuleHash);
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

lib/CodeGen/PreISelIntrinsicLowering.cpp

Show First 20 Lines • Show All 79 Lines • ▼ Show 20 LinesINITIALIZE_PASS(PreISelIntrinsicLoweringLegacyPass,
false, false) false, false)
namespace llvm { namespace llvm {
ModulePass *createPreISelIntrinsicLoweringPass() { ModulePass *createPreISelIntrinsicLoweringPass() {
return new PreISelIntrinsicLoweringLegacyPass; return new PreISelIntrinsicLoweringLegacyPass;
} }
PreservedAnalyses PreISelIntrinsicLoweringPass::run(Module &M, PreservedAnalyses PreISelIntrinsicLoweringPass::run(Module &M,
ModuleAnalysisManager &AM) { AnalysisManager &AM) {
if (!lowerIntrinsics(M)) if (!lowerIntrinsics(M))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
else else
return PreservedAnalyses::none(); return PreservedAnalyses::none();
} }
} // End llvm namespace } // End llvm namespace

lib/CodeGen/UnreachableBlockElim.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
INITIALIZE_PASS(UnreachableBlockElimLegacyPass, "unreachableblockelim", INITIALIZE_PASS(UnreachableBlockElimLegacyPass, "unreachableblockelim",
"Remove unreachable blocks from the CFG", false, false) "Remove unreachable blocks from the CFG", false, false)
FunctionPass *llvm::createUnreachableBlockEliminationPass() { FunctionPass *llvm::createUnreachableBlockEliminationPass() {
return new UnreachableBlockElimLegacyPass(); return new UnreachableBlockElimLegacyPass();
} }
PreservedAnalyses UnreachableBlockElimPass::run(Function &F, PreservedAnalyses UnreachableBlockElimPass::run(Function &F,
FunctionAnalysisManager &AM) { AnalysisManager &AM) {
bool Changed = eliminateUnreachableBlock(F); bool Changed = eliminateUnreachableBlock(F);
if (!Changed) if (!Changed)
return PreservedAnalyses::all(); return PreservedAnalyses::all();
PreservedAnalyses PA; PreservedAnalyses PA;
PA.preserve<DominatorTreeAnalysis>(); PA.preserve<DominatorTreeAnalysis>();
return PA; return PA;
} }
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

lib/IR/Dominators.cpp

Show First 20 Lines • Show All 295 Lines • ▼ Show 20 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This implements the DominatorTreeAnalysis which is used with the new pass // This implements the DominatorTreeAnalysis which is used with the new pass
// manager. It also implements some methods from utility passes. // manager. It also implements some methods from utility passes.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
DominatorTree DominatorTreeAnalysis::run(Function &F, DominatorTree DominatorTreeAnalysis::run(Function &F,
AnalysisManager<Function> &) { AnalysisManager &) {
DominatorTree DT; DominatorTree DT;
DT.recalculate(F); DT.recalculate(F);
return DT; return DT;
} }
char DominatorTreeAnalysis::PassID; char DominatorTreeAnalysis::PassID;
DominatorTreePrinterPass::DominatorTreePrinterPass(raw_ostream &OS) : OS(OS) {} DominatorTreePrinterPass::DominatorTreePrinterPass(raw_ostream &OS) : OS(OS) {}
PreservedAnalyses DominatorTreePrinterPass::run(Function &F, PreservedAnalyses DominatorTreePrinterPass::run(Function &F,
FunctionAnalysisManager &AM) { AnalysisManager &AM) {
OS << "DominatorTree for function: " << F.getName() << "\n"; OS << "DominatorTree for function: " << F.getName() << "\n";
AM.getResult<DominatorTreeAnalysis>(F).print(OS); AM.getResult<DominatorTreeAnalysis>(F).print(OS);
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
PreservedAnalyses DominatorTreeVerifierPass::run(Function &F, PreservedAnalyses DominatorTreeVerifierPass::run(Function &F,
FunctionAnalysisManager &AM) { AnalysisManager &AM) {
AM.getResult<DominatorTreeAnalysis>(F).verifyDomTree(); AM.getResult<DominatorTreeAnalysis>(F).verifyDomTree();
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// DominatorTreeWrapperPass Implementation // DominatorTreeWrapperPass Implementation
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Show All 24 Lines

lib/IR/IRPrintingPasses.cpp

Show All 20 Lines
using namespace llvm; using namespace llvm;
PrintModulePass::PrintModulePass() : OS(dbgs()) {} PrintModulePass::PrintModulePass() : OS(dbgs()) {}
PrintModulePass::PrintModulePass(raw_ostream &OS, const std::string &Banner, PrintModulePass::PrintModulePass(raw_ostream &OS, const std::string &Banner,
bool ShouldPreserveUseListOrder) bool ShouldPreserveUseListOrder)
: OS(OS), Banner(Banner), : OS(OS), Banner(Banner),
ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {} ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {}
PreservedAnalyses PrintModulePass::run(Module &M, AnalysisManager<Module> &) { PreservedAnalyses PrintModulePass::run(Module &M, AnalysisManager &) {
OS << Banner; OS << Banner;
if (llvm::isFunctionInPrintList("*")) if (llvm::isFunctionInPrintList("*"))
M.print(OS, nullptr, ShouldPreserveUseListOrder); M.print(OS, nullptr, ShouldPreserveUseListOrder);
else { else {
for(const auto &F : M.functions()) for(const auto &F : M.functions())
if (llvm::isFunctionInPrintList(F.getName())) if (llvm::isFunctionInPrintList(F.getName()))
F.print(OS); F.print(OS);
} }
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
PrintFunctionPass::PrintFunctionPass() : OS(dbgs()) {} PrintFunctionPass::PrintFunctionPass() : OS(dbgs()) {}
PrintFunctionPass::PrintFunctionPass(raw_ostream &OS, const std::string &Banner) PrintFunctionPass::PrintFunctionPass(raw_ostream &OS, const std::string &Banner)
: OS(OS), Banner(Banner) {} : OS(OS), Banner(Banner) {}
PreservedAnalyses PrintFunctionPass::run(Function &F, PreservedAnalyses PrintFunctionPass::run(Function &F,
AnalysisManager<Function> &) { AnalysisManager &) {
if (isFunctionInPrintList(F.getName())) if (isFunctionInPrintList(F.getName()))
OS << Banner << static_cast<Value &>(F); OS << Banner << static_cast<Value &>(F);
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
namespace { namespace {
class PrintModulePassWrapper : public ModulePass { class PrintModulePassWrapper : public ModulePass {
PrintModulePass P; PrintModulePass P;
public: public:
static char ID; static char ID;
PrintModulePassWrapper() : ModulePass(ID) {} PrintModulePassWrapper() : ModulePass(ID) {}
PrintModulePassWrapper(raw_ostream &OS, const std::string &Banner, PrintModulePassWrapper(raw_ostream &OS, const std::string &Banner,
bool ShouldPreserveUseListOrder) bool ShouldPreserveUseListOrder)
: ModulePass(ID), P(OS, Banner, ShouldPreserveUseListOrder) {} : ModulePass(ID), P(OS, Banner, ShouldPreserveUseListOrder) {}
bool runOnModule(Module &M) override { bool runOnModule(Module &M) override {
ModuleAnalysisManager DummyMAM; AnalysisManager DummyAM;
P.run(M, DummyMAM); P.run(M, DummyAM);
return false; return false;
} }
void getAnalysisUsage(AnalysisUsage &AU) const override { void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.setPreservesAll(); AU.setPreservesAll();
} }
}; };
class PrintFunctionPassWrapper : public FunctionPass { class PrintFunctionPassWrapper : public FunctionPass {
PrintFunctionPass P; PrintFunctionPass P;
public: public:
static char ID; static char ID;
PrintFunctionPassWrapper() : FunctionPass(ID) {} PrintFunctionPassWrapper() : FunctionPass(ID) {}
PrintFunctionPassWrapper(raw_ostream &OS, const std::string &Banner) PrintFunctionPassWrapper(raw_ostream &OS, const std::string &Banner)
: FunctionPass(ID), P(OS, Banner) {} : FunctionPass(ID), P(OS, Banner) {}
// This pass just prints a banner followed by the function as it's processed. // This pass just prints a banner followed by the function as it's processed.
bool runOnFunction(Function &F) override { bool runOnFunction(Function &F) override {
FunctionAnalysisManager DummyFAM; AnalysisManager DummyAM;
P.run(F, DummyFAM); P.run(F, DummyAM);
return false; return false;
} }
void getAnalysisUsage(AnalysisUsage &AU) const override { void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.setPreservesAll(); AU.setPreservesAll();
} }
}; };
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

lib/IR/PassManager.cpp

Show All 11 Lines
#include "llvm/IR/LLVMContext.h" #include "llvm/IR/LLVMContext.h"
using namespace llvm; using namespace llvm;
// Explicit template instantiations for core template typedefs. // Explicit template instantiations for core template typedefs.
namespace llvm { namespace llvm {
template class PassManager<Module>; template class PassManager<Module>;
template class PassManager<Function>; template class PassManager<Function>;
template class AnalysisManager<Module>;
template class AnalysisManager<Function>; template struct ParentIRUnitTrackingAnalysis<Module>;
template class InnerAnalysisManagerProxy<FunctionAnalysisManager, Module>; template <> char ParentIRUnitTrackingAnalysis<Module>::PassID = 0;
template class OuterAnalysisManagerProxy<ModuleAnalysisManager, Function>; template struct ParentIRUnitTrackingAnalysis<Function>;
template <> char ParentIRUnitTrackingAnalysis<Function>::PassID = 0;
} }

lib/IR/Verifier.cpp

Show First 20 Lines • Show All 4,416 Lines • ▼ Show 20 Lines
INITIALIZE_PASS(VerifierLegacyPass, "verify", "Module Verifier", false, false) INITIALIZE_PASS(VerifierLegacyPass, "verify", "Module Verifier", false, false)
FunctionPass *llvm::createVerifierPass(bool FatalErrors) { FunctionPass *llvm::createVerifierPass(bool FatalErrors) {
return new VerifierLegacyPass(FatalErrors); return new VerifierLegacyPass(FatalErrors);
} }
char VerifierAnalysis::PassID; char VerifierAnalysis::PassID;
VerifierAnalysis::Result VerifierAnalysis::run(Module &M, VerifierAnalysis::Result VerifierAnalysis::run(Module &M,
ModuleAnalysisManager &) { AnalysisManager &) {
Result Res; Result Res;
Res.IRBroken = llvm::verifyModule(M, &dbgs(), &Res.DebugInfoBroken); Res.IRBroken = llvm::verifyModule(M, &dbgs(), &Res.DebugInfoBroken);
return Res; return Res;
} }
VerifierAnalysis::Result VerifierAnalysis::run(Function &F, VerifierAnalysis::Result VerifierAnalysis::run(Function &F,
FunctionAnalysisManager &) { AnalysisManager &) {
return { llvm::verifyFunction(F, &dbgs()), false }; return { llvm::verifyFunction(F, &dbgs()), false };
} }
PreservedAnalyses VerifierPass::run(Module &M, ModuleAnalysisManager &AM) { PreservedAnalyses VerifierPass::run(Module &M, AnalysisManager &AM) {
auto Res = AM.getResult<VerifierAnalysis>(M); auto Res = AM.getResult<VerifierAnalysis>(M);
if (FatalErrors) { if (FatalErrors) {
if (Res.IRBroken) if (Res.IRBroken)
report_fatal_error("Broken module found, compilation aborted!"); report_fatal_error("Broken module found, compilation aborted!");
assert(!Res.DebugInfoBroken && "Module contains invalid debug info"); assert(!Res.DebugInfoBroken && "Module contains invalid debug info");
} }
// Strip broken debug info. // Strip broken debug info.
if (Res.DebugInfoBroken) { if (Res.DebugInfoBroken) {
DiagnosticInfoIgnoringInvalidDebugMetadata DiagInvalid(M); DiagnosticInfoIgnoringInvalidDebugMetadata DiagInvalid(M);
M.getContext().diagnose(DiagInvalid); M.getContext().diagnose(DiagInvalid);
if (!StripDebugInfo(M)) if (!StripDebugInfo(M))
report_fatal_error("Failed to strip malformed debug info"); report_fatal_error("Failed to strip malformed debug info");
} }
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
PreservedAnalyses VerifierPass::run(Function &F, FunctionAnalysisManager &AM) { PreservedAnalyses VerifierPass::run(Function &F, AnalysisManager &AM) {
auto res = AM.getResult<VerifierAnalysis>(F); auto res = AM.getResult<VerifierAnalysis>(F);
if (res.IRBroken && FatalErrors) if (res.IRBroken && FatalErrors)
report_fatal_error("Broken function found, compilation aborted!"); report_fatal_error("Broken function found, compilation aborted!");
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }

lib/Passes/PassBuilder.cpp

Show First 20 Lines • Show All 129 Lines • ▼ Show 20 Lines
using namespace llvm; using namespace llvm;
static Regex DefaultAliasRegex("^(default|lto-pre-link|lto)<(O[0123sz])>$"); static Regex DefaultAliasRegex("^(default|lto-pre-link|lto)<(O[0123sz])>$");
namespace { namespace {
/// \brief No-op module pass which does nothing. /// \brief No-op module pass which does nothing.
struct NoOpModulePass { struct NoOpModulePass {
PreservedAnalyses run(Module &M, AnalysisManager<Module> &) { PreservedAnalyses run(Module &M, AnalysisManager &) {
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
static StringRef name() { return "NoOpModulePass"; } static StringRef name() { return "NoOpModulePass"; }
}; };
/// \brief No-op module analysis. /// \brief No-op module analysis.
class NoOpModuleAnalysis : public AnalysisInfoMixin<NoOpModuleAnalysis> { class NoOpModuleAnalysis : public AnalysisInfoMixin<NoOpModuleAnalysis> {
friend AnalysisInfoMixin<NoOpModuleAnalysis>; friend AnalysisInfoMixin<NoOpModuleAnalysis>;
static char PassID; static char PassID;
public: public:
struct Result {}; struct Result {};
Result run(Module &, AnalysisManager<Module> &) { return Result(); } Result run(Module &, AnalysisManager &) { return Result(); }
static StringRef name() { return "NoOpModuleAnalysis"; } static StringRef name() { return "NoOpModuleAnalysis"; }
}; };
/// \brief No-op CGSCC pass which does nothing. /// \brief No-op CGSCC pass which does nothing.
struct NoOpCGSCCPass { struct NoOpCGSCCPass {
PreservedAnalyses run(LazyCallGraph::SCC &C, PreservedAnalyses run(LazyCallGraph::SCC &C,
AnalysisManager<LazyCallGraph::SCC> &) { AnalysisManager &) {
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
static StringRef name() { return "NoOpCGSCCPass"; } static StringRef name() { return "NoOpCGSCCPass"; }
}; };
/// \brief No-op CGSCC analysis. /// \brief No-op CGSCC analysis.
class NoOpCGSCCAnalysis : public AnalysisInfoMixin<NoOpCGSCCAnalysis> { class NoOpCGSCCAnalysis : public AnalysisInfoMixin<NoOpCGSCCAnalysis> {
friend AnalysisInfoMixin<NoOpCGSCCAnalysis>; friend AnalysisInfoMixin<NoOpCGSCCAnalysis>;
static char PassID; static char PassID;
public: public:
struct Result {}; struct Result {};
Result run(LazyCallGraph::SCC &, AnalysisManager<LazyCallGraph::SCC> &) { Result run(LazyCallGraph::SCC &, AnalysisManager &) {
return Result(); return Result();
} }
static StringRef name() { return "NoOpCGSCCAnalysis"; } static StringRef name() { return "NoOpCGSCCAnalysis"; }
}; };
/// \brief No-op function pass which does nothing. /// \brief No-op function pass which does nothing.
struct NoOpFunctionPass { struct NoOpFunctionPass {
PreservedAnalyses run(Function &F, AnalysisManager<Function> &) { PreservedAnalyses run(Function &F, AnalysisManager &) {
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
static StringRef name() { return "NoOpFunctionPass"; } static StringRef name() { return "NoOpFunctionPass"; }
}; };
/// \brief No-op function analysis. /// \brief No-op function analysis.
class NoOpFunctionAnalysis : public AnalysisInfoMixin<NoOpFunctionAnalysis> { class NoOpFunctionAnalysis : public AnalysisInfoMixin<NoOpFunctionAnalysis> {
friend AnalysisInfoMixin<NoOpFunctionAnalysis>; friend AnalysisInfoMixin<NoOpFunctionAnalysis>;
static char PassID; static char PassID;
public: public:
struct Result {}; struct Result {};
Result run(Function &, AnalysisManager<Function> &) { return Result(); } Result run(Function &, AnalysisManager &) { return Result(); }
static StringRef name() { return "NoOpFunctionAnalysis"; } static StringRef name() { return "NoOpFunctionAnalysis"; }
}; };
/// \brief No-op loop pass which does nothing. /// \brief No-op loop pass which does nothing.
struct NoOpLoopPass { struct NoOpLoopPass {
PreservedAnalyses run(Loop &L, AnalysisManager<Loop> &) { PreservedAnalyses run(Loop &L, AnalysisManager &) {
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
static StringRef name() { return "NoOpLoopPass"; } static StringRef name() { return "NoOpLoopPass"; }
}; };
/// \brief No-op loop analysis. /// \brief No-op loop analysis.
class NoOpLoopAnalysis : public AnalysisInfoMixin<NoOpLoopAnalysis> { class NoOpLoopAnalysis : public AnalysisInfoMixin<NoOpLoopAnalysis> {
friend AnalysisInfoMixin<NoOpLoopAnalysis>; friend AnalysisInfoMixin<NoOpLoopAnalysis>;
static char PassID; static char PassID;
public: public:
struct Result {}; struct Result {};
Result run(Loop &, AnalysisManager<Loop> &) { return Result(); } Result run(Loop &, AnalysisManager &) { return Result(); }
static StringRef name() { return "NoOpLoopAnalysis"; } static StringRef name() { return "NoOpLoopAnalysis"; }
}; };
char NoOpModuleAnalysis::PassID; char NoOpModuleAnalysis::PassID;
char NoOpCGSCCAnalysis::PassID; char NoOpCGSCCAnalysis::PassID;
char NoOpFunctionAnalysis::PassID; char NoOpFunctionAnalysis::PassID;
char NoOpLoopAnalysis::PassID; char NoOpLoopAnalysis::PassID;
} // End anonymous namespace. } // End anonymous namespace.
void PassBuilder::registerModuleAnalyses(ModuleAnalysisManager &MAM) { void PassBuilder::registerModuleAnalyses(AnalysisManager &AM) {
#define MODULE_ANALYSIS(NAME, CREATE_PASS) \ #define MODULE_ANALYSIS(NAME, CREATE_PASS) \
MAM.registerPass([&] { return CREATE_PASS; }); AM.registerPass<Module>([&] { return CREATE_PASS; });
#include "PassRegistry.def" #include "PassRegistry.def"
} }
void PassBuilder::registerCGSCCAnalyses(CGSCCAnalysisManager &CGAM) { void PassBuilder::registerCGSCCAnalyses(AnalysisManager &AM) {
#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \ #define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
CGAM.registerPass([&] { return CREATE_PASS; }); AM.registerPass<LazyCallGraph::SCC>([&] { return CREATE_PASS; });
#include "PassRegistry.def" #include "PassRegistry.def"
} }
void PassBuilder::registerFunctionAnalyses(FunctionAnalysisManager &FAM) { void PassBuilder::registerFunctionAnalyses(AnalysisManager &AM) {
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \ #define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
FAM.registerPass([&] { return CREATE_PASS; }); AM.registerPass<Function>([&] { return CREATE_PASS; });
#include "PassRegistry.def" #include "PassRegistry.def"
} }
void PassBuilder::registerLoopAnalyses(LoopAnalysisManager &LAM) { void PassBuilder::registerLoopAnalyses(AnalysisManager &AM) {
#define LOOP_ANALYSIS(NAME, CREATE_PASS) \ #define LOOP_ANALYSIS(NAME, CREATE_PASS) \
LAM.registerPass([&] { return CREATE_PASS; }); AM.registerPass<Loop>([&] { return CREATE_PASS; });
#include "PassRegistry.def" #include "PassRegistry.def"
} }
void PassBuilder::addPerModuleDefaultPipeline(ModulePassManager &MPM, void PassBuilder::addPerModuleDefaultPipeline(ModulePassManager &MPM,
OptimizationLevel Level, OptimizationLevel Level,
bool DebugLogging) { bool DebugLogging) {
// FIXME: Finish fleshing this out to match the legacy pipelines. // FIXME: Finish fleshing this out to match the legacy pipelines.
FunctionPassManager EarlyFPM(DebugLogging); FunctionPassManager EarlyFPM(DebugLogging);
▲ Show 20 Lines • Show All 495 Lines • ▼ Show 20 Linesbool PassBuilder::parseCGSCCPassPipeline(CGSCCPassManager &CGPM,
for (const auto &Element : Pipeline) { for (const auto &Element : Pipeline) {
if (!parseCGSCCPass(CGPM, Element, VerifyEachPass, DebugLogging)) if (!parseCGSCCPass(CGPM, Element, VerifyEachPass, DebugLogging))
return false; return false;
// FIXME: No verifier support for CGSCC passes! // FIXME: No verifier support for CGSCC passes!
} }
return true; return true;
} }
void PassBuilder::crossRegisterProxies(LoopAnalysisManager &LAM,
FunctionAnalysisManager &FAM,
CGSCCAnalysisManager &CGAM,
ModuleAnalysisManager &MAM) {
MAM.registerPass([&] { return FunctionAnalysisManagerModuleProxy(FAM); });
MAM.registerPass([&] { return CGSCCAnalysisManagerModuleProxy(CGAM); });
CGAM.registerPass([&] { return FunctionAnalysisManagerCGSCCProxy(FAM); });
CGAM.registerPass([&] { return ModuleAnalysisManagerCGSCCProxy(MAM); });
FAM.registerPass([&] { return CGSCCAnalysisManagerFunctionProxy(CGAM); });
FAM.registerPass([&] { return ModuleAnalysisManagerFunctionProxy(MAM); });
FAM.registerPass([&] { return LoopAnalysisManagerFunctionProxy(LAM); });
LAM.registerPass([&] { return FunctionAnalysisManagerLoopProxy(FAM); });
}
bool PassBuilder::parseModulePassPipeline(ModulePassManager &MPM, bool PassBuilder::parseModulePassPipeline(ModulePassManager &MPM,
ArrayRef<PipelineElement> Pipeline, ArrayRef<PipelineElement> Pipeline,
bool VerifyEachPass, bool VerifyEachPass,
bool DebugLogging) { bool DebugLogging) {
for (const auto &Element : Pipeline) { for (const auto &Element : Pipeline) {
if (!parseModulePass(MPM, Element, VerifyEachPass, DebugLogging)) if (!parseModulePass(MPM, Element, VerifyEachPass, DebugLogging))
return false; return false;
if (VerifyEachPass) if (VerifyEachPass)
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

lib/Passes/PassRegistry.def

Show All 18 Lines
#ifndef MODULE_ANALYSIS #ifndef MODULE_ANALYSIS
#define MODULE_ANALYSIS(NAME, CREATE_PASS) #define MODULE_ANALYSIS(NAME, CREATE_PASS)
#endif #endif
MODULE_ANALYSIS("callgraph", CallGraphAnalysis()) MODULE_ANALYSIS("callgraph", CallGraphAnalysis())
MODULE_ANALYSIS("lcg", LazyCallGraphAnalysis()) MODULE_ANALYSIS("lcg", LazyCallGraphAnalysis())
MODULE_ANALYSIS("no-op-module", NoOpModuleAnalysis()) MODULE_ANALYSIS("no-op-module", NoOpModuleAnalysis())
MODULE_ANALYSIS("profile-summary", ProfileSummaryAnalysis()) MODULE_ANALYSIS("profile-summary", ProfileSummaryAnalysis())
MODULE_ANALYSIS("targetlibinfo", TargetLibraryAnalysis()) MODULE_ANALYSIS("targetlibinfo", TargetLibraryAnalysis())
MODULE_ANALYSIS("parent-irunit-tracking",
ParentIRUnitTrackingAnalysis<Module>())
MODULE_ANALYSIS("verify", VerifierAnalysis()) MODULE_ANALYSIS("verify", VerifierAnalysis())
#ifndef MODULE_ALIAS_ANALYSIS #ifndef MODULE_ALIAS_ANALYSIS
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) \ #define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
MODULE_ANALYSIS(NAME, CREATE_PASS) MODULE_ANALYSIS(NAME, CREATE_PASS)
#endif #endif
MODULE_ALIAS_ANALYSIS("globals-aa", GlobalsAA()) MODULE_ALIAS_ANALYSIS("globals-aa", GlobalsAA())
#undef MODULE_ALIAS_ANALYSIS #undef MODULE_ALIAS_ANALYSIS
Show All 35 Lines
MODULE_PASS("wholeprogramdevirt", WholeProgramDevirtPass()) MODULE_PASS("wholeprogramdevirt", WholeProgramDevirtPass())
MODULE_PASS("verify", VerifierPass()) MODULE_PASS("verify", VerifierPass())
#undef MODULE_PASS #undef MODULE_PASS
#ifndef CGSCC_ANALYSIS #ifndef CGSCC_ANALYSIS
#define CGSCC_ANALYSIS(NAME, CREATE_PASS) #define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#endif #endif
CGSCC_ANALYSIS("no-op-cgscc", NoOpCGSCCAnalysis()) CGSCC_ANALYSIS("no-op-cgscc", NoOpCGSCCAnalysis())
CGSCC_ANALYSIS("parent-irunit-tracking",
ParentIRUnitTrackingAnalysis<LazyCallGraph::SCC>())
#undef CGSCC_ANALYSIS #undef CGSCC_ANALYSIS
#ifndef CGSCC_PASS #ifndef CGSCC_PASS
#define CGSCC_PASS(NAME, CREATE_PASS) #define CGSCC_PASS(NAME, CREATE_PASS)
#endif #endif
CGSCC_PASS("invalidate<all>", InvalidateAllAnalysesPass()) CGSCC_PASS("invalidate<all>", InvalidateAllAnalysesPass())
CGSCC_PASS("function-attrs", PostOrderFunctionAttrsPass()) CGSCC_PASS("function-attrs", PostOrderFunctionAttrsPass())
CGSCC_PASS("no-op-cgscc", NoOpCGSCCPass()) CGSCC_PASS("no-op-cgscc", NoOpCGSCCPass())
Show All 18 Lines
FUNCTION_ANALYSIS("regions", RegionInfoAnalysis()) FUNCTION_ANALYSIS("regions", RegionInfoAnalysis())
FUNCTION_ANALYSIS("no-op-function", NoOpFunctionAnalysis()) FUNCTION_ANALYSIS("no-op-function", NoOpFunctionAnalysis())
FUNCTION_ANALYSIS("opt-remark-emit", OptimizationRemarkEmitterAnalysis()) FUNCTION_ANALYSIS("opt-remark-emit", OptimizationRemarkEmitterAnalysis())
FUNCTION_ANALYSIS("scalar-evolution", ScalarEvolutionAnalysis()) FUNCTION_ANALYSIS("scalar-evolution", ScalarEvolutionAnalysis())
FUNCTION_ANALYSIS("targetlibinfo", TargetLibraryAnalysis()) FUNCTION_ANALYSIS("targetlibinfo", TargetLibraryAnalysis())
FUNCTION_ANALYSIS("targetir", FUNCTION_ANALYSIS("targetir",
TM ? TM->getTargetIRAnalysis() : TargetIRAnalysis()) TM ? TM->getTargetIRAnalysis() : TargetIRAnalysis())
FUNCTION_ANALYSIS("verify", VerifierAnalysis()) FUNCTION_ANALYSIS("verify", VerifierAnalysis())
FUNCTION_ANALYSIS("parent-irunit-tracking",
ParentIRUnitTrackingAnalysis<Function>())
#ifndef FUNCTION_ALIAS_ANALYSIS #ifndef FUNCTION_ALIAS_ANALYSIS
#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \ #define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
FUNCTION_ANALYSIS(NAME, CREATE_PASS) FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#endif #endif
FUNCTION_ALIAS_ANALYSIS("basic-aa", BasicAA()) FUNCTION_ALIAS_ANALYSIS("basic-aa", BasicAA())
FUNCTION_ALIAS_ANALYSIS("cfl-anders-aa", CFLAndersAA()) FUNCTION_ALIAS_ANALYSIS("cfl-anders-aa", CFLAndersAA())
FUNCTION_ALIAS_ANALYSIS("cfl-steens-aa", CFLSteensAA()) FUNCTION_ALIAS_ANALYSIS("cfl-steens-aa", CFLSteensAA())
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Lines
#undef FUNCTION_PASS #undef FUNCTION_PASS
#ifndef LOOP_ANALYSIS #ifndef LOOP_ANALYSIS
#define LOOP_ANALYSIS(NAME, CREATE_PASS) #define LOOP_ANALYSIS(NAME, CREATE_PASS)
#endif #endif
LOOP_ANALYSIS("no-op-loop", NoOpLoopAnalysis()) LOOP_ANALYSIS("no-op-loop", NoOpLoopAnalysis())
LOOP_ANALYSIS("access-info", LoopAccessAnalysis()) LOOP_ANALYSIS("access-info", LoopAccessAnalysis())
LOOP_ANALYSIS("ivusers", IVUsersAnalysis()) LOOP_ANALYSIS("ivusers", IVUsersAnalysis())
LOOP_ANALYSIS("parent-irunit-tracking", ParentIRUnitTrackingAnalysis<Loop>())
#undef LOOP_ANALYSIS #undef LOOP_ANALYSIS
#ifndef LOOP_PASS #ifndef LOOP_PASS
#define LOOP_PASS(NAME, CREATE_PASS) #define LOOP_PASS(NAME, CREATE_PASS)
#endif #endif
LOOP_PASS("invalidate<all>", InvalidateAllAnalysesPass()) LOOP_PASS("invalidate<all>", InvalidateAllAnalysesPass())
LOOP_PASS("licm", LICMPass()) LOOP_PASS("licm", LICMPass())
LOOP_PASS("loop-idiom", LoopIdiomRecognizePass()) LOOP_PASS("loop-idiom", LoopIdiomRecognizePass())
Show All 12 Lines

lib/Transforms/IPO/ConstantMerge.cpp

Show First 20 Lines • Show All 186 Lines • ▼ Show 20 Lines for (unsigned i = 0, e = Replacements.size(); i != e; ++i) {
Replacements[i].first->eraseFromParent(); Replacements[i].first->eraseFromParent();
} }
NumMerged += Replacements.size(); NumMerged += Replacements.size();
Replacements.clear(); Replacements.clear();
} }
} }
PreservedAnalyses ConstantMergePass::run(Module &M, ModuleAnalysisManager &) { PreservedAnalyses ConstantMergePass::run(Module &M, AnalysisManager &) {
if (!mergeConstants(M)) if (!mergeConstants(M))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
return PreservedAnalyses::none(); return PreservedAnalyses::none();
} }
namespace { namespace {
struct ConstantMergeLegacyPass : public ModulePass { struct ConstantMergeLegacyPass : public ModulePass {
static char ID; // Pass identification, replacement for typeid static char ID; // Pass identification, replacement for typeid
Show All 21 Lines

lib/Transforms/IPO/CrossDSOCFI.cpp

Show First 20 Lines • Show All 149 Lines • ▼ Show 20 Linesbool CrossDSOCFI::runOnModule(Module &M) {
VeryLikelyWeights = VeryLikelyWeights =
MDBuilder(M.getContext()).createBranchWeights((1U << 20) - 1, 1); MDBuilder(M.getContext()).createBranchWeights((1U << 20) - 1, 1);
if (M.getModuleFlag("Cross-DSO CFI") == nullptr) if (M.getModuleFlag("Cross-DSO CFI") == nullptr)
return false; return false;
buildCFICheck(M); buildCFICheck(M);
return true; return true;
} }
PreservedAnalyses CrossDSOCFIPass::run(Module &M, AnalysisManager<Module> &AM) { PreservedAnalyses CrossDSOCFIPass::run(Module &M, AnalysisManager &AM) {
CrossDSOCFI Impl; CrossDSOCFI Impl;
bool Changed = Impl.runOnModule(M); bool Changed = Impl.runOnModule(M);
if (!Changed) if (!Changed)
return PreservedAnalyses::all(); return PreservedAnalyses::all();
return PreservedAnalyses::none(); return PreservedAnalyses::none();
} }

lib/Transforms/IPO/DeadArgumentElimination.cpp

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines public:
DAE() : ModulePass(ID) { DAE() : ModulePass(ID) {
initializeDAEPass(*PassRegistry::getPassRegistry()); initializeDAEPass(*PassRegistry::getPassRegistry());
} }
bool runOnModule(Module &M) override { bool runOnModule(Module &M) override {
if (skipModule(M)) if (skipModule(M))
return false; return false;
DeadArgumentEliminationPass DAEP(ShouldHackArguments()); DeadArgumentEliminationPass DAEP(ShouldHackArguments());
ModuleAnalysisManager DummyMAM; AnalysisManager DummyAM;
PreservedAnalyses PA = DAEP.run(M, DummyMAM); PreservedAnalyses PA = DAEP.run(M, DummyAM);
return !PA.areAllPreserved(); return !PA.areAllPreserved();
} }
virtual bool ShouldHackArguments() const { return false; } virtual bool ShouldHackArguments() const { return false; }
}; };
} }
▲ Show 20 Lines • Show All 948 Lines • ▼ Show 20 Linesbool DeadArgumentEliminationPass::RemoveDeadStuffFromFunction(Function *F) {
// Now that the old function is dead, delete it. // Now that the old function is dead, delete it.
F->eraseFromParent(); F->eraseFromParent();
return true; return true;
} }
PreservedAnalyses DeadArgumentEliminationPass::run(Module &M, PreservedAnalyses DeadArgumentEliminationPass::run(Module &M,
ModuleAnalysisManager &) { AnalysisManager &) {
bool Changed = false; bool Changed = false;
// First pass: Do a simple check to see if any functions can have their "..." // First pass: Do a simple check to see if any functions can have their "..."
// removed. We can do this if they never call va_start. This loop cannot be // removed. We can do this if they never call va_start. This loop cannot be
// fused with the next loop, because deleting a function invalidates // fused with the next loop, because deleting a function invalidates
// information computed while surveying other functions. // information computed while surveying other functions.
DEBUG(dbgs() << "DeadArgumentEliminationPass - Deleting dead varargs\n"); DEBUG(dbgs() << "DeadArgumentEliminationPass - Deleting dead varargs\n");
for (Module::iterator I = M.begin(), E = M.end(); I != E; ) { for (Module::iterator I = M.begin(), E = M.end(); I != E; ) {
Show All 31 Lines

lib/Transforms/IPO/ElimAvailExtern.cpp

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines for (Function &F : M) {
NumFunctions++; NumFunctions++;
Changed = true; Changed = true;
} }
return Changed; return Changed;
} }
PreservedAnalyses PreservedAnalyses
EliminateAvailableExternallyPass::run(Module &M, ModuleAnalysisManager &) { EliminateAvailableExternallyPass::run(Module &M, AnalysisManager &) {
if (!eliminateAvailableExternally(M)) if (!eliminateAvailableExternally(M))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
return PreservedAnalyses::none(); return PreservedAnalyses::none();
} }
namespace { namespace {
struct EliminateAvailableExternallyLegacyPass : public ModulePass { struct EliminateAvailableExternallyLegacyPass : public ModulePass {
static char ID; // Pass identification, replacement for typeid static char ID; // Pass identification, replacement for typeid
Show All 23 Lines

lib/Transforms/IPO/ForceFunctionAttrs.cpp

Show First 20 Lines • Show All 75 Lines • ▼ Show 20 Lines for (auto &S : ForceAttributes) {
} }
if (F.hasFnAttribute(Kind)) if (F.hasFnAttribute(Kind))
continue; continue;
F.addFnAttr(Kind); F.addFnAttr(Kind);
} }
} }
PreservedAnalyses ForceFunctionAttrsPass::run(Module &M, PreservedAnalyses ForceFunctionAttrsPass::run(Module &M,
ModuleAnalysisManager &) { AnalysisManager &) {
if (ForceAttributes.empty()) if (ForceAttributes.empty())
return PreservedAnalyses::all(); return PreservedAnalyses::all();
for (Function &F : M.functions()) for (Function &F : M.functions())
addForcedAttributes(F); addForcedAttributes(F);
// Just conservatively invalidate analyses, this isn't likely to be important. // Just conservatively invalidate analyses, this isn't likely to be important.
return PreservedAnalyses::none(); return PreservedAnalyses::none();
Show All 30 Lines

lib/Transforms/IPO/FunctionAttrs.cpp

Show First 20 Lines • Show All 1,029 Lines • ▼ Show 20 Linesstatic bool addNoRecurseAttrs(const SCCNodeSet &SCCNodes) {
// Every call was to a non-recursive function other than this function, and // Every call was to a non-recursive function other than this function, and
// we have no indirect recursion as the SCC size is one. This function cannot // we have no indirect recursion as the SCC size is one. This function cannot
// recurse. // recurse.
return setDoesNotRecurse(*F); return setDoesNotRecurse(*F);
} }
PreservedAnalyses PostOrderFunctionAttrsPass::run(LazyCallGraph::SCC &C, PreservedAnalyses PostOrderFunctionAttrsPass::run(LazyCallGraph::SCC &C,
CGSCCAnalysisManager &AM) { AnalysisManager &AM) {
FunctionAnalysisManager &FAM =
AM.getResult<FunctionAnalysisManagerCGSCCProxy>(C).getManager();
// We pass a lambda into functions to wire them up to the analysis manager // We pass a lambda into functions to wire them up to the analysis manager
// for getting function analyses. // for getting function analyses.
auto AARGetter = [&](Function &F) -> AAResults & { auto AARGetter = [&](Function &F) -> AAResults & {
return FAM.getResult<AAManager>(F); return AM.getResult<AAManager>(F);
}; };
// Fill SCCNodes with the elements of the SCC. Also track whether there are // Fill SCCNodes with the elements of the SCC. Also track whether there are
// any external or opt-none nodes that will prevent us from optimizing any // any external or opt-none nodes that will prevent us from optimizing any
// part of the SCC. // part of the SCC.
SCCNodeSet SCCNodes; SCCNodeSet SCCNodes;
bool HasUnknownCall = false; bool HasUnknownCall = false;
for (LazyCallGraph::Node &N : C) { for (LazyCallGraph::Node &N : C) {
▲ Show 20 Lines • Show All 208 Lines • ▼ Show 20 Lines if (skipModule(M))
return false; return false;
auto &CG = getAnalysis<CallGraphWrapperPass>().getCallGraph(); auto &CG = getAnalysis<CallGraphWrapperPass>().getCallGraph();
return deduceFunctionAttributeInRPO(M, CG); return deduceFunctionAttributeInRPO(M, CG);
} }
PreservedAnalyses PreservedAnalyses
ReversePostOrderFunctionAttrsPass::run(Module &M, AnalysisManager<Module> &AM) { ReversePostOrderFunctionAttrsPass::run(Module &M, AnalysisManager &AM) {
auto &CG = AM.getResult<CallGraphAnalysis>(M); auto &CG = AM.getResult<CallGraphAnalysis>(M);
bool Changed = deduceFunctionAttributeInRPO(M, CG); bool Changed = deduceFunctionAttributeInRPO(M, CG);
// CallGraphAnalysis holds AssertingVH and must be invalidated eagerly so // CallGraphAnalysis holds AssertingVH and must be invalidated eagerly so
// that other passes don't delete stuff from under it. // that other passes don't delete stuff from under it.
AM.invalidate<CallGraphAnalysis>(M); AM.invalidate<CallGraphAnalysis>(M);
if (!Changed) if (!Changed)
return PreservedAnalyses::all(); return PreservedAnalyses::all();
PreservedAnalyses PA; PreservedAnalyses PA;
PA.preserve<CallGraphAnalysis>(); PA.preserve<CallGraphAnalysis>();
return PA; return PA;
} }

lib/Transforms/IPO/FunctionImport.cpp

Show First 20 Lines • Show All 779 Lines • ▼ Show 20 Lines if (skipModule(M))
return false; return false;
return doImportingForModule(M, Index); return doImportingForModule(M, Index);
} }
}; };
} // anonymous namespace } // anonymous namespace
PreservedAnalyses FunctionImportPass::run(Module &M, PreservedAnalyses FunctionImportPass::run(Module &M,
AnalysisManager<Module> &AM) { AnalysisManager &AM) {
if (!doImportingForModule(M, Index)) if (!doImportingForModule(M, Index))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
return PreservedAnalyses::none(); return PreservedAnalyses::none();
} }
char FunctionImportLegacyPass::ID = 0; char FunctionImportLegacyPass::ID = 0;
INITIALIZE_PASS(FunctionImportLegacyPass, "function-import", INITIALIZE_PASS(FunctionImportLegacyPass, "function-import",
"Summary Based Function Import", false, false) "Summary Based Function Import", false, false)
namespace llvm { namespace llvm {
Pass *createFunctionImportPass(const ModuleSummaryIndex *Index = nullptr) { Pass *createFunctionImportPass(const ModuleSummaryIndex *Index = nullptr) {
return new FunctionImportLegacyPass(Index); return new FunctionImportLegacyPass(Index);
} }
} }

lib/Transforms/IPO/GlobalDCE.cpp

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines public:
// run - Do the GlobalDCE pass on the specified module, optionally updating // run - Do the GlobalDCE pass on the specified module, optionally updating
// the specified callgraph to reflect the changes. // the specified callgraph to reflect the changes.
// //
bool runOnModule(Module &M) override { bool runOnModule(Module &M) override {
if (skipModule(M)) if (skipModule(M))
return false; return false;
ModuleAnalysisManager DummyMAM; AnalysisManager DummyAM;
auto PA = Impl.run(M, DummyMAM); auto PA = Impl.run(M, DummyAM);
return !PA.areAllPreserved(); return !PA.areAllPreserved();
} }
private: private:
GlobalDCEPass Impl; GlobalDCEPass Impl;
}; };
} }
Show All 10 Lines
static bool isEmptyFunction(Function *F) { static bool isEmptyFunction(Function *F) {
BasicBlock &Entry = F->getEntryBlock(); BasicBlock &Entry = F->getEntryBlock();
if (Entry.size() != 1 || !isa<ReturnInst>(Entry.front())) if (Entry.size() != 1 || !isa<ReturnInst>(Entry.front()))
return false; return false;
ReturnInst &RI = cast<ReturnInst>(Entry.front()); ReturnInst &RI = cast<ReturnInst>(Entry.front());
return RI.getReturnValue() == nullptr; return RI.getReturnValue() == nullptr;
} }
PreservedAnalyses GlobalDCEPass::run(Module &M, ModuleAnalysisManager &) { PreservedAnalyses GlobalDCEPass::run(Module &M, AnalysisManager &) {
bool Changed = false; bool Changed = false;
// Remove empty functions from the global ctors list. // Remove empty functions from the global ctors list.
Changed |= optimizeGlobalCtorsList(M, isEmptyFunction); Changed |= optimizeGlobalCtorsList(M, isEmptyFunction);
// Collect the set of members for each comdat. // Collect the set of members for each comdat.
for (Function &F : M) for (Function &F : M)
if (Comdat *C = F.getComdat()) if (Comdat *C = F.getComdat())
▲ Show 20 Lines • Show All 191 Lines • Show Last 20 Lines

lib/Transforms/IPO/GlobalOpt.cpp

Show First 20 Lines • Show All 2,559 Lines • ▼ Show 20 Linesstatic bool optimizeGlobalsInModule(
} }
// TODO: Move all global ctors functions to the end of the module for code // TODO: Move all global ctors functions to the end of the module for code
// layout. // layout.
return Changed; return Changed;
} }
PreservedAnalyses GlobalOptPass::run(Module &M, AnalysisManager<Module> &AM) { PreservedAnalyses GlobalOptPass::run(Module &M, AnalysisManager &AM) {
auto &DL = M.getDataLayout(); auto &DL = M.getDataLayout();
auto &TLI = AM.getResult<TargetLibraryAnalysis>(M); auto &TLI = AM.getResult<TargetLibraryAnalysis>(M);
auto &FAM = auto LookupDomTree = [&AM](Function &F) -> DominatorTree & {
AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager(); return AM.getResult<DominatorTreeAnalysis>(F);
auto LookupDomTree = [&FAM](Function &F) -> DominatorTree &{
return FAM.getResult<DominatorTreeAnalysis>(F);
}; };
if (!optimizeGlobalsInModule(M, DL, &TLI, LookupDomTree)) if (!optimizeGlobalsInModule(M, DL, &TLI, LookupDomTree))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
return PreservedAnalyses::none(); return PreservedAnalyses::none();
} }
namespace { namespace {
struct GlobalOptLegacyPass : public ModulePass { struct GlobalOptLegacyPass : public ModulePass {
Show All 35 Lines

lib/Transforms/IPO/InferFunctionAttrs.cpp

Show All 28 Lines for (Function &F : M.functions())
// definitions. // definitions.
if (F.isDeclaration() && !F.hasFnAttribute((Attribute::OptimizeNone))) if (F.isDeclaration() && !F.hasFnAttribute((Attribute::OptimizeNone)))
Changed |= inferLibFuncAttributes(F, TLI); Changed |= inferLibFuncAttributes(F, TLI);
return Changed; return Changed;
} }
PreservedAnalyses InferFunctionAttrsPass::run(Module &M, PreservedAnalyses InferFunctionAttrsPass::run(Module &M,
AnalysisManager<Module> &AM) { AnalysisManager &AM) {
auto &TLI = AM.getResult<TargetLibraryAnalysis>(M); auto &TLI = AM.getResult<TargetLibraryAnalysis>(M);
if (!inferAllPrototypeAttributes(M, TLI)) if (!inferAllPrototypeAttributes(M, TLI))
// If we didn't infer anything, preserve all analyses. // If we didn't infer anything, preserve all analyses.
return PreservedAnalyses::all(); return PreservedAnalyses::all();
// Otherwise, we may have changed fundamental function attributes, so clear // Otherwise, we may have changed fundamental function attributes, so clear
// out all the passes. // out all the passes.
Show All 35 Lines

lib/Transforms/IPO/Internalize.cpp

Show First 20 Lines • Show All 233 Lines • ▼ Show 20 Lines for (auto &GA : M.aliases()) {
DEBUG(dbgs() << "Internalized alias " << GA.getName() << "\n"); DEBUG(dbgs() << "Internalized alias " << GA.getName() << "\n");
} }
return Changed; return Changed;
} }
InternalizePass::InternalizePass() : MustPreserveGV(PreserveAPIList()) {} InternalizePass::InternalizePass() : MustPreserveGV(PreserveAPIList()) {}
PreservedAnalyses InternalizePass::run(Module &M, AnalysisManager<Module> &AM) { PreservedAnalyses InternalizePass::run(Module &M, AnalysisManager &AM) {
if (!internalizeModule(M, AM.getCachedResult<CallGraphAnalysis>(M))) if (!internalizeModule(M, AM.getCachedResult<CallGraphAnalysis>(M)))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
PreservedAnalyses PA; PreservedAnalyses PA;
PA.preserve<CallGraphAnalysis>(); PA.preserve<CallGraphAnalysis>();
return PA; return PA;
} }
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

lib/Transforms/IPO/LowerTypeTests.cpp

Show First 20 Lines • Show All 1,054 Lines • ▼ Show 20 Lines
bool LowerTypeTests::runOnModule(Module &M) { bool LowerTypeTests::runOnModule(Module &M) {
if (skipModule(M)) if (skipModule(M))
return false; return false;
init(this, M); init(this, M);
return lower(); return lower();
} }
PreservedAnalyses LowerTypeTestsPass::run(Module &M, PreservedAnalyses LowerTypeTestsPass::run(Module &M,
AnalysisManager<Module> &AM) { AnalysisManager &AM) {
LowerTypeTests Impl; LowerTypeTests Impl;
init(&Impl, M); init(&Impl, M);
bool Changed = Impl.lower(); bool Changed = Impl.lower();
if (!Changed) if (!Changed)
return PreservedAnalyses::all(); return PreservedAnalyses::all();
return PreservedAnalyses::none(); return PreservedAnalyses::none();
} }

lib/Transforms/IPO/PartialInlining.cpp

Show First 20 Lines • Show All 204 Lines • ▼ Show 20 Lines
INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker) INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
INITIALIZE_PASS_END(PartialInlinerLegacyPass, "partial-inliner", INITIALIZE_PASS_END(PartialInlinerLegacyPass, "partial-inliner",
"Partial Inliner", false, false) "Partial Inliner", false, false)
ModulePass *llvm::createPartialInliningPass() { ModulePass *llvm::createPartialInliningPass() {
return new PartialInlinerLegacyPass(); return new PartialInlinerLegacyPass();
} }
PreservedAnalyses PartialInlinerPass::run(Module &M, PreservedAnalyses PartialInlinerPass::run(Module &M, AnalysisManager &AM) {
ModuleAnalysisManager &AM) {
auto &FAM = AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
std::function<AssumptionCache &(Function &)> GetAssumptionCache = std::function<AssumptionCache &(Function &)> GetAssumptionCache =
[&FAM](Function &F) -> AssumptionCache & { [&](Function &F) -> AssumptionCache & {
return FAM.getResult<AssumptionAnalysis>(F); return AM.getResult<AssumptionAnalysis>(F);
}; };
InlineFunctionInfo IFI(nullptr, &GetAssumptionCache); InlineFunctionInfo IFI(nullptr, &GetAssumptionCache);
if (PartialInlinerImpl(IFI).run(M)) if (PartialInlinerImpl(IFI).run(M))
return PreservedAnalyses::none(); return PreservedAnalyses::none();
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }

lib/Transforms/IPO/SampleProfile.cpp

Show First 20 Lines • Show All 1,247 Lines • ▼ Show 20 Linesbool SampleProfileLoader::runOnFunction(Function &F) {
F.setEntryCount(0); F.setEntryCount(0);
Samples = Reader->getSamplesFor(F); Samples = Reader->getSamplesFor(F);
if (!Samples->empty()) if (!Samples->empty())
return emitAnnotations(F); return emitAnnotations(F);
return false; return false;
} }
PreservedAnalyses SampleProfileLoaderPass::run(Module &M, PreservedAnalyses SampleProfileLoaderPass::run(Module &M,
AnalysisManager<Module> &AM) { AnalysisManager &AM) {
SampleProfileLoader SampleLoader(SampleProfileFile); SampleProfileLoader SampleLoader(SampleProfileFile);
SampleLoader.doInitialization(M); SampleLoader.doInitialization(M);
if (!SampleLoader.runOnModule(M)) if (!SampleLoader.runOnModule(M))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
return PreservedAnalyses::none(); return PreservedAnalyses::none();
} }

lib/Transforms/IPO/StripDeadPrototypes.cpp

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines if (GV->isDeclaration() && GV->use_empty())
GV->eraseFromParent(); GV->eraseFromParent();
} }
// Return an indication of whether we changed anything or not. // Return an indication of whether we changed anything or not.
return MadeChange; return MadeChange;
} }
PreservedAnalyses StripDeadPrototypesPass::run(Module &M, PreservedAnalyses StripDeadPrototypesPass::run(Module &M,
ModuleAnalysisManager &) { AnalysisManager &) {
if (stripDeadPrototypes(M)) if (stripDeadPrototypes(M))
return PreservedAnalyses::none(); return PreservedAnalyses::none();
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
namespace { namespace {
class StripDeadPrototypesLegacyPass : public ModulePass { class StripDeadPrototypesLegacyPass : public ModulePass {
Show All 23 Lines

lib/Transforms/IPO/WholeProgramDevirt.cpp

Show First 20 Lines • Show All 308 Lines • ▼ Show 20 LinesINITIALIZE_PASS(WholeProgramDevirt, "wholeprogramdevirt",
"Whole program devirtualization", false, false) "Whole program devirtualization", false, false)
char WholeProgramDevirt::ID = 0; char WholeProgramDevirt::ID = 0;
ModulePass *llvm::createWholeProgramDevirtPass() { ModulePass *llvm::createWholeProgramDevirtPass() {
return new WholeProgramDevirt; return new WholeProgramDevirt;
} }
PreservedAnalyses WholeProgramDevirtPass::run(Module &M, PreservedAnalyses WholeProgramDevirtPass::run(Module &M,
ModuleAnalysisManager &) { AnalysisManager &) {
if (!DevirtModule(M).run()) if (!DevirtModule(M).run())
return PreservedAnalyses::all(); return PreservedAnalyses::all();
return PreservedAnalyses::none(); return PreservedAnalyses::none();
} }
void DevirtModule::buildTypeIdentifierMap( void DevirtModule::buildTypeIdentifierMap(
std::vector<VTableBits> &Bits, std::vector<VTableBits> &Bits,
DenseMap<Metadata *, std::set<TypeMemberInfo>> &TypeIdMap) { DenseMap<Metadata *, std::set<TypeMemberInfo>> &TypeIdMap) {
▲ Show 20 Lines • Show All 534 Lines • Show Last 20 Lines

lib/Transforms/InstCombine/InstructionCombining.cpp

Show First 20 Lines • Show All 3,169 Lines • ▼ Show 20 Lines for (;;) {
if (!Changed) if (!Changed)
break; break;
} }
return DbgDeclaresChanged || Iteration > 1; return DbgDeclaresChanged || Iteration > 1;
} }
PreservedAnalyses InstCombinePass::run(Function &F, PreservedAnalyses InstCombinePass::run(Function &F,
AnalysisManager<Function> &AM) { AnalysisManager &AM) {
auto &AC = AM.getResult<AssumptionAnalysis>(F); auto &AC = AM.getResult<AssumptionAnalysis>(F);
auto &DT = AM.getResult<DominatorTreeAnalysis>(F); auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
auto &TLI = AM.getResult<TargetLibraryAnalysis>(F); auto &TLI = AM.getResult<TargetLibraryAnalysis>(F);
auto *LI = AM.getCachedResult<LoopAnalysis>(F); auto *LI = AM.getCachedResult<LoopAnalysis>(F);
// FIXME: The AliasAnalysis is not yet supported in the new pass manager // FIXME: The AliasAnalysis is not yet supported in the new pass manager
if (!combineInstructionsOverFunction(F, Worklist, nullptr, AC, TLI, DT, if (!combineInstructionsOverFunction(F, Worklist, nullptr, AC, TLI, DT,
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

lib/Transforms/Instrumentation/GCOVProfiling.cpp

Show First 20 Lines • Show All 447 Lines • ▼ Show 20 Linesbool GCOVProfiler::runOnModule(Module &M) {
Ctx = &M.getContext(); Ctx = &M.getContext();
if (Options.EmitNotes) emitProfileNotes(); if (Options.EmitNotes) emitProfileNotes();
if (Options.EmitData) return emitProfileArcs(); if (Options.EmitData) return emitProfileArcs();
return false; return false;
} }
PreservedAnalyses GCOVProfilerPass::run(Module &M, PreservedAnalyses GCOVProfilerPass::run(Module &M,
AnalysisManager<Module> &AM) { AnalysisManager &AM) {
GCOVProfiler Profiler(GCOVOpts); GCOVProfiler Profiler(GCOVOpts);
if (!Profiler.runOnModule(M)) if (!Profiler.runOnModule(M))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
return PreservedAnalyses::none(); return PreservedAnalyses::none();
} }
▲ Show 20 Lines • Show All 513 Lines • Show Last 20 Lines

lib/Transforms/Instrumentation/IndirectCallPromotion.cpp

Show First 20 Lines • Show All 647 Lines • ▼ Show 20 Linesstatic bool promoteIndirectCalls(Module &M, bool InLTO) {
return Changed; return Changed;
} }
bool PGOIndirectCallPromotionLegacyPass::runOnModule(Module &M) { bool PGOIndirectCallPromotionLegacyPass::runOnModule(Module &M) {
// Command-line option has the priority for InLTO. // Command-line option has the priority for InLTO.
return promoteIndirectCalls(M, InLTO | ICPLTOMode); return promoteIndirectCalls(M, InLTO | ICPLTOMode);
} }
PreservedAnalyses PGOIndirectCallPromotion::run(Module &M, AnalysisManager<Module> &AM) { PreservedAnalyses PGOIndirectCallPromotion::run(Module &M, AnalysisManager &AM) {
if (!promoteIndirectCalls(M, InLTO | ICPLTOMode)) if (!promoteIndirectCalls(M, InLTO | ICPLTOMode))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
return PreservedAnalyses::none(); return PreservedAnalyses::none();
} }

lib/Transforms/Instrumentation/InstrProfiling.cpp

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Linespublic:
void getAnalysisUsage(AnalysisUsage &AU) const override { void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.setPreservesCFG(); AU.setPreservesCFG();
} }
}; };
} // anonymous namespace } // anonymous namespace
PreservedAnalyses InstrProfiling::run(Module &M, AnalysisManager<Module> &AM) { PreservedAnalyses InstrProfiling::run(Module &M, AnalysisManager &AM) {
if (!run(M)) if (!run(M))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
return PreservedAnalyses::none(); return PreservedAnalyses::none();
} }
char InstrProfilingLegacyPass::ID = 0; char InstrProfilingLegacyPass::ID = 0;
INITIALIZE_PASS(InstrProfilingLegacyPass, "instrprof", INITIALIZE_PASS(InstrProfilingLegacyPass, "instrprof",
▲ Show 20 Lines • Show All 537 Lines • Show Last 20 Lines

lib/Transforms/Instrumentation/PGOInstrumentation.cpp

Show First 20 Lines • Show All 958 Lines • ▼ Show 20 Linesbool PGOInstrumentationGenLegacyPass::runOnModule(Module &M) {
}; };
auto LookupBFI = [this](Function &F) { auto LookupBFI = [this](Function &F) {
return &this->getAnalysis<BlockFrequencyInfoWrapperPass>(F).getBFI(); return &this->getAnalysis<BlockFrequencyInfoWrapperPass>(F).getBFI();
}; };
return InstrumentAllFunctions(M, LookupBPI, LookupBFI); return InstrumentAllFunctions(M, LookupBPI, LookupBFI);
} }
PreservedAnalyses PGOInstrumentationGen::run(Module &M, PreservedAnalyses PGOInstrumentationGen::run(Module &M,
AnalysisManager<Module> &AM) { AnalysisManager &AM) {
auto LookupBPI = [&AM](Function &F) {
auto &FAM = AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager(); return &AM.getResult<BranchProbabilityAnalysis>(F);
auto LookupBPI = [&FAM](Function &F) {
return &FAM.getResult<BranchProbabilityAnalysis>(F);
}; };
auto LookupBFI = [&FAM](Function &F) { auto LookupBFI = [&AM](Function &F) {
return &FAM.getResult<BlockFrequencyAnalysis>(F); return &AM.getResult<BlockFrequencyAnalysis>(F);
}; };
if (!InstrumentAllFunctions(M, LookupBPI, LookupBFI)) if (!InstrumentAllFunctions(M, LookupBPI, LookupBFI))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
return PreservedAnalyses::none(); return PreservedAnalyses::none();
} }
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Lines
PGOInstrumentationUse::PGOInstrumentationUse(std::string Filename) PGOInstrumentationUse::PGOInstrumentationUse(std::string Filename)
: ProfileFileName(std::move(Filename)) { : ProfileFileName(std::move(Filename)) {
if (!PGOTestProfileFile.empty()) if (!PGOTestProfileFile.empty())
ProfileFileName = PGOTestProfileFile; ProfileFileName = PGOTestProfileFile;
} }
PreservedAnalyses PGOInstrumentationUse::run(Module &M, PreservedAnalyses PGOInstrumentationUse::run(Module &M,
AnalysisManager<Module> &AM) { AnalysisManager &AM) {
auto LookupBPI = [&AM](Function &F) {
auto &FAM = AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager(); return &AM.getResult<BranchProbabilityAnalysis>(F);
auto LookupBPI = [&FAM](Function &F) {
return &FAM.getResult<BranchProbabilityAnalysis>(F);
}; };
auto LookupBFI = [&FAM](Function &F) { auto LookupBFI = [&AM](Function &F) {
return &FAM.getResult<BlockFrequencyAnalysis>(F); return &AM.getResult<BlockFrequencyAnalysis>(F);
}; };
if (!annotateAllFunctions(M, ProfileFileName, LookupBPI, LookupBFI)) if (!annotateAllFunctions(M, ProfileFileName, LookupBPI, LookupBFI))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
return PreservedAnalyses::none(); return PreservedAnalyses::none();
} }
Show All 13 Lines

lib/Transforms/Scalar/ADCE.cpp

Show First 20 Lines • Show All 194 Lines • ▼ Show 20 Linesbool AggressiveDeadCodeElimination::removeDeadInstructions() {
for (Instruction *&I : Worklist) { for (Instruction *&I : Worklist) {
++NumRemoved; ++NumRemoved;
I->eraseFromParent(); I->eraseFromParent();
} }
return !Worklist.empty(); return !Worklist.empty();
} }
PreservedAnalyses ADCEPass::run(Function &F, FunctionAnalysisManager &) { PreservedAnalyses ADCEPass::run(Function &F, AnalysisManager &) {
if (!AggressiveDeadCodeElimination(F).performDeadCodeElimination()) if (!AggressiveDeadCodeElimination(F).performDeadCodeElimination())
return PreservedAnalyses::all(); return PreservedAnalyses::all();
// FIXME: This should also 'preserve the CFG'. // FIXME: This should also 'preserve the CFG'.
auto PA = PreservedAnalyses(); auto PA = PreservedAnalyses();
PA.preserve<GlobalsAA>(); PA.preserve<GlobalsAA>();
return PA; return PA;
} }
Show All 26 Lines

lib/Transforms/Scalar/AlignmentFromAssumptions.cpp

Show First 20 Lines • Show All 422 Lines • ▼ Show 20 Linesbool AlignmentFromAssumptionsPass::runImpl(Function &F, AssumptionCache &AC,
for (auto &AssumeVH : AC.assumptions()) for (auto &AssumeVH : AC.assumptions())
if (AssumeVH) if (AssumeVH)
Changed |= processAssumption(cast<CallInst>(AssumeVH)); Changed |= processAssumption(cast<CallInst>(AssumeVH));
return Changed; return Changed;
} }
PreservedAnalyses PreservedAnalyses
AlignmentFromAssumptionsPass::run(Function &F, FunctionAnalysisManager &AM) { AlignmentFromAssumptionsPass::run(Function &F, AnalysisManager &AM) {
AssumptionCache &AC = AM.getResult<AssumptionAnalysis>(F); AssumptionCache &AC = AM.getResult<AssumptionAnalysis>(F);
ScalarEvolution &SE = AM.getResult<ScalarEvolutionAnalysis>(F); ScalarEvolution &SE = AM.getResult<ScalarEvolutionAnalysis>(F);
DominatorTree &DT = AM.getResult<DominatorTreeAnalysis>(F); DominatorTree &DT = AM.getResult<DominatorTreeAnalysis>(F);
bool Changed = runImpl(F, AC, &SE, &DT); bool Changed = runImpl(F, AC, &SE, &DT);
AM.invalidate<ScalarEvolutionAnalysis>(F); AM.invalidate<ScalarEvolutionAnalysis>(F);
if (!Changed) if (!Changed)
return PreservedAnalyses::all(); return PreservedAnalyses::all();
PreservedAnalyses PA; PreservedAnalyses PA;
PA.preserve<AAManager>(); PA.preserve<AAManager>();
PA.preserve<ScalarEvolutionAnalysis>(); PA.preserve<ScalarEvolutionAnalysis>();
PA.preserve<GlobalsAA>(); PA.preserve<GlobalsAA>();
PA.preserve<LoopAnalysis>(); PA.preserve<LoopAnalysis>();
PA.preserve<DominatorTreeAnalysis>(); PA.preserve<DominatorTreeAnalysis>();
return PA; return PA;
} }

lib/Transforms/Scalar/BDCE.cpp

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Linesstatic bool bitTrackingDCE(Function &F, DemandedBits &DB) {
for (Instruction *&I : Worklist) { for (Instruction *&I : Worklist) {
++NumRemoved; ++NumRemoved;
I->eraseFromParent(); I->eraseFromParent();
} }
return Changed; return Changed;
} }
PreservedAnalyses BDCEPass::run(Function &F, FunctionAnalysisManager &AM) { PreservedAnalyses BDCEPass::run(Function &F, AnalysisManager &AM) {
auto &DB = AM.getResult<DemandedBitsAnalysis>(F); auto &DB = AM.getResult<DemandedBitsAnalysis>(F);
if (!bitTrackingDCE(F, DB)) if (!bitTrackingDCE(F, DB))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
// FIXME: This should also 'preserve the CFG'. // FIXME: This should also 'preserve the CFG'.
auto PA = PreservedAnalyses(); auto PA = PreservedAnalyses();
PA.preserve<GlobalsAA>(); PA.preserve<GlobalsAA>();
return PA; return PA;
Show All 32 Lines

lib/Transforms/Scalar/ConstantHoisting.cpp

Show First 20 Lines • Show All 611 Lines • ▼ Show 20 Linesbool ConstantHoistingPass::runImpl(Function &Fn, TargetTransformInfo &TTI,
// Cleanup dead instructions. // Cleanup dead instructions.
deleteDeadCastInst(); deleteDeadCastInst();
return MadeChange; return MadeChange;
} }
PreservedAnalyses ConstantHoistingPass::run(Function &F, PreservedAnalyses ConstantHoistingPass::run(Function &F,
FunctionAnalysisManager &AM) { AnalysisManager &AM) {
auto &DT = AM.getResult<DominatorTreeAnalysis>(F); auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
auto &TTI = AM.getResult<TargetIRAnalysis>(F); auto &TTI = AM.getResult<TargetIRAnalysis>(F);
if (!runImpl(F, TTI, DT, F.getEntryBlock())) if (!runImpl(F, TTI, DT, F.getEntryBlock()))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
// FIXME: This should also 'preserve the CFG'. // FIXME: This should also 'preserve the CFG'.
return PreservedAnalyses::none(); return PreservedAnalyses::none();
} }

lib/Transforms/Scalar/CorrelatedValuePropagation.cpp

Show First 20 Lines • Show All 469 Lines • ▼ Show 20 Linesbool CorrelatedValuePropagation::runOnFunction(Function &F) {
if (skipFunction(F)) if (skipFunction(F))
return false; return false;
LazyValueInfo *LVI = &getAnalysis<LazyValueInfoWrapperPass>().getLVI(); LazyValueInfo *LVI = &getAnalysis<LazyValueInfoWrapperPass>().getLVI();
return runImpl(F, LVI); return runImpl(F, LVI);
} }
PreservedAnalyses PreservedAnalyses
CorrelatedValuePropagationPass::run(Function &F, FunctionAnalysisManager &AM) { CorrelatedValuePropagationPass::run(Function &F, AnalysisManager &AM) {
LazyValueInfo *LVI = &AM.getResult<LazyValueAnalysis>(F); LazyValueInfo *LVI = &AM.getResult<LazyValueAnalysis>(F);
bool Changed = runImpl(F, LVI); bool Changed = runImpl(F, LVI);
// FIXME: We need to invalidate LVI to avoid PR28400. Is there a better // FIXME: We need to invalidate LVI to avoid PR28400. Is there a better
// solution? // solution?
AM.invalidate<LazyValueAnalysis>(F); AM.invalidate<LazyValueAnalysis>(F);
if (!Changed) if (!Changed)
return PreservedAnalyses::all(); return PreservedAnalyses::all();
PreservedAnalyses PA; PreservedAnalyses PA;
PA.preserve<GlobalsAA>(); PA.preserve<GlobalsAA>();
return PA; return PA;
} }

lib/Transforms/Scalar/DCE.cpp

Show First 20 Lines • Show All 117 Lines • ▼ Show 20 Linesstatic bool eliminateDeadCode(Function &F, TargetLibraryInfo *TLI) {
while (!WorkList.empty()) { while (!WorkList.empty()) {
Instruction *I = WorkList.pop_back_val(); Instruction *I = WorkList.pop_back_val();
MadeChange |= DCEInstruction(I, WorkList, TLI); MadeChange |= DCEInstruction(I, WorkList, TLI);
} }
return MadeChange; return MadeChange;
} }
PreservedAnalyses DCEPass::run(Function &F, AnalysisManager<Function> &AM) { PreservedAnalyses DCEPass::run(Function &F, AnalysisManager &AM) {
if (eliminateDeadCode(F, AM.getCachedResult<TargetLibraryAnalysis>(F))) if (eliminateDeadCode(F, AM.getCachedResult<TargetLibraryAnalysis>(F)))
return PreservedAnalyses::none(); return PreservedAnalyses::none();
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
namespace { namespace {
struct DCELegacyPass : public FunctionPass { struct DCELegacyPass : public FunctionPass {
static char ID; // Pass identification, replacement for typeid static char ID; // Pass identification, replacement for typeid
Show All 26 Lines

lib/Transforms/Scalar/DeadStoreElimination.cpp

Show First 20 Lines • Show All 1,123 Lines • ▼ Show 20 Lines for (BasicBlock &BB : F)
if (DT->isReachableFromEntry(&BB)) if (DT->isReachableFromEntry(&BB))
MadeChange |= eliminateDeadStores(BB, AA, MD, DT, TLI); MadeChange |= eliminateDeadStores(BB, AA, MD, DT, TLI);
return MadeChange; return MadeChange;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// DSE Pass // DSE Pass
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
PreservedAnalyses DSEPass::run(Function &F, FunctionAnalysisManager &AM) { PreservedAnalyses DSEPass::run(Function &F, AnalysisManager &AM) {
AliasAnalysis *AA = &AM.getResult<AAManager>(F); AliasAnalysis *AA = &AM.getResult<AAManager>(F);
DominatorTree *DT = &AM.getResult<DominatorTreeAnalysis>(F); DominatorTree *DT = &AM.getResult<DominatorTreeAnalysis>(F);
MemoryDependenceResults *MD = &AM.getResult<MemoryDependenceAnalysis>(F); MemoryDependenceResults *MD = &AM.getResult<MemoryDependenceAnalysis>(F);
const TargetLibraryInfo *TLI = &AM.getResult<TargetLibraryAnalysis>(F); const TargetLibraryInfo *TLI = &AM.getResult<TargetLibraryAnalysis>(F);
if (!eliminateDeadStores(F, AA, MD, DT, TLI)) if (!eliminateDeadStores(F, AA, MD, DT, TLI))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
PreservedAnalyses PA; PreservedAnalyses PA;
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

lib/Transforms/Scalar/EarlyCSE.cpp

Show First 20 Lines • Show All 841 Lines • ▼ Show 20 Linesbool EarlyCSE::run() {
// Reset the current generation. // Reset the current generation.
CurrentGeneration = LiveOutGeneration; CurrentGeneration = LiveOutGeneration;
return Changed; return Changed;
} }
PreservedAnalyses EarlyCSEPass::run(Function &F, PreservedAnalyses EarlyCSEPass::run(Function &F,
AnalysisManager<Function> &AM) { AnalysisManager &AM) {
auto &TLI = AM.getResult<TargetLibraryAnalysis>(F); auto &TLI = AM.getResult<TargetLibraryAnalysis>(F);
auto &TTI = AM.getResult<TargetIRAnalysis>(F); auto &TTI = AM.getResult<TargetIRAnalysis>(F);
auto &DT = AM.getResult<DominatorTreeAnalysis>(F); auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
auto &AC = AM.getResult<AssumptionAnalysis>(F); auto &AC = AM.getResult<AssumptionAnalysis>(F);
EarlyCSE CSE(TLI, TTI, DT, AC); EarlyCSE CSE(TLI, TTI, DT, AC);
if (!CSE.run()) if (!CSE.run())
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

lib/Transforms/Scalar/Float2Int.cpp

Show First 20 Lines • Show All 522 Lines • ▼ Show 20 Linesbool Float2IntPass::runImpl(Function &F) {
if (Modified) if (Modified)
cleanup(); cleanup();
return Modified; return Modified;
} }
namespace llvm { namespace llvm {
FunctionPass *createFloat2IntPass() { return new Float2IntLegacyPass(); } FunctionPass *createFloat2IntPass() { return new Float2IntLegacyPass(); }
PreservedAnalyses Float2IntPass::run(Function &F, FunctionAnalysisManager &) { PreservedAnalyses Float2IntPass::run(Function &F, AnalysisManager &) {
if (!runImpl(F)) if (!runImpl(F))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
else { else {
// FIXME: This should also 'preserve the CFG'. // FIXME: This should also 'preserve the CFG'.
PreservedAnalyses PA; PreservedAnalyses PA;
PA.preserve<GlobalsAA>(); PA.preserve<GlobalsAA>();
return PA; return PA;
} }
} }
} // End namespace llvm } // End namespace llvm

lib/Transforms/Scalar/GVN.cpp

Show First 20 Lines • Show All 577 Lines • ▼ Show 20 Lines for (DenseMap<Value*, uint32_t>::const_iterator
assert(I->first != V && "Inst still occurs in value numbering map!"); assert(I->first != V && "Inst still occurs in value numbering map!");
} }
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// GVN Pass // GVN Pass
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
PreservedAnalyses GVN::run(Function &F, AnalysisManager<Function> &AM) { PreservedAnalyses GVN::run(Function &F, AnalysisManager &AM) {
// FIXME: The order of evaluation of these 'getResult' calls is very // FIXME: The order of evaluation of these 'getResult' calls is very
// significant! Re-ordering these variables will cause GVN when run alone to // significant! Re-ordering these variables will cause GVN when run alone to
// be less effective! We should fix memdep and basic-aa to not exhibit this // be less effective! We should fix memdep and basic-aa to not exhibit this
// behavior, but until then don't change the order here. // behavior, but until then don't change the order here.
auto &AC = AM.getResult<AssumptionAnalysis>(F); auto &AC = AM.getResult<AssumptionAnalysis>(F);
auto &DT = AM.getResult<DominatorTreeAnalysis>(F); auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
auto &TLI = AM.getResult<TargetLibraryAnalysis>(F); auto &TLI = AM.getResult<TargetLibraryAnalysis>(F);
auto &AA = AM.getResult<AAManager>(F); auto &AA = AM.getResult<AAManager>(F);
▲ Show 20 Lines • Show All 2,163 Lines • Show Last 20 Lines

lib/Transforms/Scalar/GVNHoist.cpp

Show First 20 Lines • Show All 934 Lines • ▼ Show 20 Lines void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.addRequired<AAResultsWrapperPass>(); AU.addRequired<AAResultsWrapperPass>();
AU.addRequired<MemoryDependenceWrapperPass>(); AU.addRequired<MemoryDependenceWrapperPass>();
AU.addPreserved<DominatorTreeWrapperPass>(); AU.addPreserved<DominatorTreeWrapperPass>();
} }
}; };
} // namespace } // namespace
PreservedAnalyses GVNHoistPass::run(Function &F, PreservedAnalyses GVNHoistPass::run(Function &F,
AnalysisManager<Function> &AM) { AnalysisManager &AM) {
DominatorTree &DT = AM.getResult<DominatorTreeAnalysis>(F); DominatorTree &DT = AM.getResult<DominatorTreeAnalysis>(F);
AliasAnalysis &AA = AM.getResult<AAManager>(F); AliasAnalysis &AA = AM.getResult<AAManager>(F);
MemoryDependenceResults &MD = AM.getResult<MemoryDependenceAnalysis>(F); MemoryDependenceResults &MD = AM.getResult<MemoryDependenceAnalysis>(F);
GVNHoist G(&DT, &AA, &MD, F.optForMinSize()); GVNHoist G(&DT, &AA, &MD, F.optForMinSize());
if (!G.run(F)) if (!G.run(F))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
Show All 15 Lines

lib/Transforms/Scalar/GuardWidening.cpp

Show First 20 Lines • Show All 647 Lines • ▼ Show 20 Lines while (!Checks.empty()) {
RangeChecksOut.emplace_back(CurrentChecks.back()); RangeChecksOut.emplace_back(CurrentChecks.back());
} }
assert(RangeChecksOut.size() <= OldCount && "We pessimized!"); assert(RangeChecksOut.size() <= OldCount && "We pessimized!");
return RangeChecksOut.size() != OldCount; return RangeChecksOut.size() != OldCount;
} }
PreservedAnalyses GuardWideningPass::run(Function &F, PreservedAnalyses GuardWideningPass::run(Function &F,
AnalysisManager<Function> &AM) { AnalysisManager &AM) {
auto &DT = AM.getResult<DominatorTreeAnalysis>(F); auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
auto &LI = AM.getResult<LoopAnalysis>(F); auto &LI = AM.getResult<LoopAnalysis>(F);
auto &PDT = AM.getResult<PostDominatorTreeAnalysis>(F); auto &PDT = AM.getResult<PostDominatorTreeAnalysis>(F);
bool Changed = GuardWideningImpl(DT, PDT, LI).run(); bool Changed = GuardWideningImpl(DT, PDT, LI).run();
return Changed ? PreservedAnalyses::none() : PreservedAnalyses::all(); return Changed ? PreservedAnalyses::none() : PreservedAnalyses::all();
} }
StringRef GuardWideningImpl::scoreTypeToString(WideningScore WS) { StringRef GuardWideningImpl::scoreTypeToString(WideningScore WS) {
Show All 27 Lines

lib/Transforms/Scalar/IndVarSimplify.cpp

Show First 20 Lines • Show All 2,207 Lines • ▼ Show 20 Lines else
NewBECount->getType()); NewBECount->getType());
assert(BackedgeTakenCount == NewBECount && "indvars must preserve SCEV"); assert(BackedgeTakenCount == NewBECount && "indvars must preserve SCEV");
} }
#endif #endif
return Changed; return Changed;
} }
PreservedAnalyses IndVarSimplifyPass::run(Loop &L, AnalysisManager<Loop> &AM) { PreservedAnalyses IndVarSimplifyPass::run(Loop &L, AnalysisManager &AM) {
auto &FAM = AM.getResult<FunctionAnalysisManagerLoopProxy>(L).getManager();
Function *F = L.getHeader()->getParent(); Function *F = L.getHeader()->getParent();
const DataLayout &DL = F->getParent()->getDataLayout(); const DataLayout &DL = F->getParent()->getDataLayout();
auto *LI = FAM.getCachedResult<LoopAnalysis>(*F); auto *LI = AM.getCachedResult<LoopAnalysis>(*F);
auto *SE = FAM.getCachedResult<ScalarEvolutionAnalysis>(*F); auto *SE = AM.getCachedResult<ScalarEvolutionAnalysis>(*F);
auto *DT = FAM.getCachedResult<DominatorTreeAnalysis>(*F); auto *DT = AM.getCachedResult<DominatorTreeAnalysis>(*F);
assert((LI && SE && DT) && assert((LI && SE && DT) &&
"Analyses required for indvarsimplify not available!"); "Analyses required for indvarsimplify not available!");
// Optional analyses. // Optional analyses.
auto *TTI = FAM.getCachedResult<TargetIRAnalysis>(*F); auto *TTI = AM.getCachedResult<TargetIRAnalysis>(*F);
auto *TLI = FAM.getCachedResult<TargetLibraryAnalysis>(*F); auto *TLI = AM.getCachedResult<TargetLibraryAnalysis>(*F);
IndVarSimplify IVS(LI, SE, DT, DL, TLI, TTI); IndVarSimplify IVS(LI, SE, DT, DL, TLI, TTI);
if (!IVS.run(&L)) if (!IVS.run(&L))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
// FIXME: This should also 'preserve the CFG'. // FIXME: This should also 'preserve the CFG'.
return getLoopPassPreservedAnalyses(); return getLoopPassPreservedAnalyses();
} }
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

lib/Transforms/Scalar/JumpThreading.cpp

Show First 20 Lines • Show All 128 Lines • ▼ Show 20 Lines if (HasProfileData) {
BPI.reset(new BranchProbabilityInfo(F, LI)); BPI.reset(new BranchProbabilityInfo(F, LI));
BFI.reset(new BlockFrequencyInfo(F, *BPI, LI)); BFI.reset(new BlockFrequencyInfo(F, *BPI, LI));
} }
return Impl.runImpl(F, TLI, LVI, HasProfileData, std::move(BFI), return Impl.runImpl(F, TLI, LVI, HasProfileData, std::move(BFI),
std::move(BPI)); std::move(BPI));
} }
PreservedAnalyses JumpThreadingPass::run(Function &F, PreservedAnalyses JumpThreadingPass::run(Function &F,
AnalysisManager<Function> &AM) { AnalysisManager &AM) {
auto &TLI = AM.getResult<TargetLibraryAnalysis>(F); auto &TLI = AM.getResult<TargetLibraryAnalysis>(F);
auto &LVI = AM.getResult<LazyValueAnalysis>(F); auto &LVI = AM.getResult<LazyValueAnalysis>(F);
std::unique_ptr<BlockFrequencyInfo> BFI; std::unique_ptr<BlockFrequencyInfo> BFI;
std::unique_ptr<BranchProbabilityInfo> BPI; std::unique_ptr<BranchProbabilityInfo> BPI;
bool HasProfileData = F.getEntryCount().hasValue(); bool HasProfileData = F.getEntryCount().hasValue();
if (HasProfileData) { if (HasProfileData) {
LoopInfo LI{DominatorTree(F)}; LoopInfo LI{DominatorTree(F)};
▲ Show 20 Lines • Show All 1,824 Lines • Show Last 20 Lines

lib/Transforms/Scalar/LICM.cpp

Show First 20 Lines • Show All 167 Lines • ▼ Show 20 Linesprivate:
/// set. /// set.
void deleteAnalysisValue(Value *V, Loop *L) override; void deleteAnalysisValue(Value *V, Loop *L) override;
/// Simple Analysis hook. Delete loop L from alias set map. /// Simple Analysis hook. Delete loop L from alias set map.
void deleteAnalysisLoop(Loop *L) override; void deleteAnalysisLoop(Loop *L) override;
}; };
} }
PreservedAnalyses LICMPass::run(Loop &L, AnalysisManager<Loop> &AM) { PreservedAnalyses LICMPass::run(Loop &L, AnalysisManager &AM) {
const auto &FAM =
AM.getResult<FunctionAnalysisManagerLoopProxy>(L).getManager();
Function *F = L.getHeader()->getParent(); Function *F = L.getHeader()->getParent();
auto *AA = FAM.getCachedResult<AAManager>(*F); auto *AA = AM.getCachedResult<AAManager>(*F);
auto *LI = FAM.getCachedResult<LoopAnalysis>(*F); auto *LI = AM.getCachedResult<LoopAnalysis>(*F);
auto *DT = FAM.getCachedResult<DominatorTreeAnalysis>(*F); auto *DT = AM.getCachedResult<DominatorTreeAnalysis>(*F);
auto *TLI = FAM.getCachedResult<TargetLibraryAnalysis>(*F); auto *TLI = AM.getCachedResult<TargetLibraryAnalysis>(*F);
auto *SE = FAM.getCachedResult<ScalarEvolutionAnalysis>(*F); auto *SE = AM.getCachedResult<ScalarEvolutionAnalysis>(*F);
assert((AA && LI && DT && TLI && SE) && "Analyses for LICM not available"); assert((AA && LI && DT && TLI && SE) && "Analyses for LICM not available");
LoopInvariantCodeMotion LICM; LoopInvariantCodeMotion LICM;
if (!LICM.runOnLoop(&L, AA, LI, DT, TLI, SE, true)) if (!LICM.runOnLoop(&L, AA, LI, DT, TLI, SE, true))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
// FIXME: There is no setPreservesCFG in the new PM. When that becomes // FIXME: There is no setPreservesCFG in the new PM. When that becomes
▲ Show 20 Lines • Show All 983 Lines • Show Last 20 Lines

lib/Transforms/Scalar/LoopDeletion.cpp

Show First 20 Lines • Show All 209 Lines • ▼ Show 20 Linesbool LoopDeletionPass::runImpl(Loop *L, DominatorTree &DT, ScalarEvolution &SE,
loopInfo.markAsRemoved(L); loopInfo.markAsRemoved(L);
Changed = true; Changed = true;
++NumDeleted; ++NumDeleted;
return Changed; return Changed;
} }
PreservedAnalyses LoopDeletionPass::run(Loop &L, AnalysisManager<Loop> &AM) { PreservedAnalyses LoopDeletionPass::run(Loop &L, AnalysisManager &AM) {
auto &FAM = AM.getResult<FunctionAnalysisManagerLoopProxy>(L).getManager();
Function *F = L.getHeader()->getParent(); Function *F = L.getHeader()->getParent();
auto &DT = *FAM.getCachedResult<DominatorTreeAnalysis>(*F); auto &DT = *AM.getCachedResult<DominatorTreeAnalysis>(*F);
auto &SE = *FAM.getCachedResult<ScalarEvolutionAnalysis>(*F); auto &SE = *AM.getCachedResult<ScalarEvolutionAnalysis>(*F);
auto &LI = *FAM.getCachedResult<LoopAnalysis>(*F); auto &LI = *AM.getCachedResult<LoopAnalysis>(*F);
bool Changed = runImpl(&L, DT, SE, LI); bool Changed = runImpl(&L, DT, SE, LI);
if (!Changed) if (!Changed)
return PreservedAnalyses::all(); return PreservedAnalyses::all();
return getLoopPassPreservedAnalyses(); return getLoopPassPreservedAnalyses();
} }
Show All 37 Lines

lib/Transforms/Scalar/LoopDistribute.cpp

Show First 20 Lines • Show All 936 Lines • ▼ Show 20 Lines
private: private:
/// \brief Whether distribution should be on in this function. The per-loop /// \brief Whether distribution should be on in this function. The per-loop
/// pragma can override this. /// pragma can override this.
bool ProcessAllLoops; bool ProcessAllLoops;
}; };
} // anonymous namespace } // anonymous namespace
PreservedAnalyses LoopDistributePass::run(Function &F, PreservedAnalyses LoopDistributePass::run(Function &F,
FunctionAnalysisManager &AM) { AnalysisManager &AM) {
// FIXME: This does not currently match the behavior from the old PM. // FIXME: This does not currently match the behavior from the old PM.
// ProcessAllLoops with the old PM defaults to true when invoked from opt and // ProcessAllLoops with the old PM defaults to true when invoked from opt and
// false when invoked from the optimization pipeline. // false when invoked from the optimization pipeline.
bool ProcessAllLoops = false; bool ProcessAllLoops = false;
if (EnableLoopDistribute.getNumOccurrences() > 0) if (EnableLoopDistribute.getNumOccurrences() > 0)
ProcessAllLoops = EnableLoopDistribute; ProcessAllLoops = EnableLoopDistribute;
auto &LI = AM.getResult<LoopAnalysis>(F); auto &LI = AM.getResult<LoopAnalysis>(F);
auto &DT = AM.getResult<DominatorTreeAnalysis>(F); auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
auto &SE = AM.getResult<ScalarEvolutionAnalysis>(F); auto &SE = AM.getResult<ScalarEvolutionAnalysis>(F);
auto &ORE = AM.getResult<OptimizationRemarkEmitterAnalysis>(F); auto &ORE = AM.getResult<OptimizationRemarkEmitterAnalysis>(F);
auto &LAM = AM.getResult<LoopAnalysisManagerFunctionProxy>(F).getManager();
std::function<const LoopAccessInfo &(Loop &)> GetLAA = std::function<const LoopAccessInfo &(Loop &)> GetLAA =
[&](Loop &L) -> const LoopAccessInfo & { [&](Loop &L) -> const LoopAccessInfo & {
return LAM.getResult<LoopAccessAnalysis>(L); return AM.getResult<LoopAccessAnalysis>(L);
}; };
bool Changed = runImpl(F, &LI, &DT, &SE, &ORE, GetLAA, ProcessAllLoops); bool Changed = runImpl(F, &LI, &DT, &SE, &ORE, GetLAA, ProcessAllLoops);
if (!Changed) if (!Changed)
return PreservedAnalyses::all(); return PreservedAnalyses::all();
PreservedAnalyses PA; PreservedAnalyses PA;
PA.preserve<LoopAnalysis>(); PA.preserve<LoopAnalysis>();
PA.preserve<DominatorTreeAnalysis>(); PA.preserve<DominatorTreeAnalysis>();
Show All 20 Lines

lib/Transforms/Scalar/LoopIdiomRecognize.cpp

Show First 20 Lines • Show All 166 Lines • ▼ Show 20 Lines void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.addRequired<TargetLibraryInfoWrapperPass>(); AU.addRequired<TargetLibraryInfoWrapperPass>();
AU.addRequired<TargetTransformInfoWrapperPass>(); AU.addRequired<TargetTransformInfoWrapperPass>();
getLoopAnalysisUsage(AU); getLoopAnalysisUsage(AU);
} }
}; };
} // End anonymous namespace. } // End anonymous namespace.
PreservedAnalyses LoopIdiomRecognizePass::run(Loop &L, PreservedAnalyses LoopIdiomRecognizePass::run(Loop &L,
AnalysisManager<Loop> &AM) { AnalysisManager &AM) {
const auto &FAM =
AM.getResult<FunctionAnalysisManagerLoopProxy>(L).getManager();
Function *F = L.getHeader()->getParent(); Function *F = L.getHeader()->getParent();
// Use getCachedResult because Loop pass cannot trigger a function analysis. // Use getCachedResult because Loop pass cannot trigger a function analysis.
auto *AA = FAM.getCachedResult<AAManager>(*F); auto *AA = AM.getCachedResult<AAManager>(*F);
auto *DT = FAM.getCachedResult<DominatorTreeAnalysis>(*F); auto *DT = AM.getCachedResult<DominatorTreeAnalysis>(*F);
auto *LI = FAM.getCachedResult<LoopAnalysis>(*F); auto *LI = AM.getCachedResult<LoopAnalysis>(*F);
auto *SE = FAM.getCachedResult<ScalarEvolutionAnalysis>(*F); auto *SE = AM.getCachedResult<ScalarEvolutionAnalysis>(*F);
auto *TLI = FAM.getCachedResult<TargetLibraryAnalysis>(*F); auto *TLI = AM.getCachedResult<TargetLibraryAnalysis>(*F);
const auto *TTI = FAM.getCachedResult<TargetIRAnalysis>(*F); const auto *TTI = AM.getCachedResult<TargetIRAnalysis>(*F);
const auto *DL = &L.getHeader()->getModule()->getDataLayout(); const auto *DL = &L.getHeader()->getModule()->getDataLayout();
assert((AA && DT && LI && SE && TLI && TTI && DL) && assert((AA && DT && LI && SE && TLI && TTI && DL) &&
"Analyses for Loop Idiom Recognition not available"); "Analyses for Loop Idiom Recognition not available");
LoopIdiomRecognize LIR(AA, DT, LI, SE, TLI, TTI, DL); LoopIdiomRecognize LIR(AA, DT, LI, SE, TLI, TTI, DL);
if (!LIR.runOnLoop(&L)) if (!LIR.runOnLoop(&L))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
▲ Show 20 Lines • Show All 1,092 Lines • Show Last 20 Lines

lib/Transforms/Scalar/LoopInstSimplify.cpp

Show First 20 Lines • Show All 178 Lines • ▼ Show 20 Lines void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.addRequired<TargetLibraryInfoWrapperPass>(); AU.addRequired<TargetLibraryInfoWrapperPass>();
AU.setPreservesCFG(); AU.setPreservesCFG();
getLoopAnalysisUsage(AU); getLoopAnalysisUsage(AU);
} }
}; };
} }
PreservedAnalyses LoopInstSimplifyPass::run(Loop &L, PreservedAnalyses LoopInstSimplifyPass::run(Loop &L,
AnalysisManager<Loop> &AM) { AnalysisManager &AM) {
const auto &FAM =
AM.getResult<FunctionAnalysisManagerLoopProxy>(L).getManager();
Function *F = L.getHeader()->getParent(); Function *F = L.getHeader()->getParent();
// Use getCachedResult because Loop pass cannot trigger a function analysis. // Use getCachedResult because Loop pass cannot trigger a function analysis.
auto *DT = FAM.getCachedResult<DominatorTreeAnalysis>(*F); auto *DT = AM.getCachedResult<DominatorTreeAnalysis>(*F);
auto *LI = FAM.getCachedResult<LoopAnalysis>(*F); auto *LI = AM.getCachedResult<LoopAnalysis>(*F);
auto *AC = FAM.getCachedResult<AssumptionAnalysis>(*F); auto *AC = AM.getCachedResult<AssumptionAnalysis>(*F);
const auto *TLI = FAM.getCachedResult<TargetLibraryAnalysis>(*F); const auto *TLI = AM.getCachedResult<TargetLibraryAnalysis>(*F);
assert((LI && AC && TLI) && "Analyses for Loop Inst Simplify not available"); assert((LI && AC && TLI) && "Analyses for Loop Inst Simplify not available");
if (!SimplifyLoopInst(&L, DT, LI, AC, TLI)) if (!SimplifyLoopInst(&L, DT, LI, AC, TLI))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
return getLoopPassPreservedAnalyses(); return getLoopPassPreservedAnalyses();
} }
Show All 12 Lines

lib/Transforms/Scalar/LoopRotation.cpp

Show First 20 Lines • Show All 613 Lines • ▼ Show 20 Linesbool LoopRotate::processLoop(Loop *L) {
if ((MadeChange || SimplifiedLatch) && LoopMD) if ((MadeChange || SimplifiedLatch) && LoopMD)
L->setLoopID(LoopMD); L->setLoopID(LoopMD);
return MadeChange; return MadeChange;
} }
LoopRotatePass::LoopRotatePass() {} LoopRotatePass::LoopRotatePass() {}
PreservedAnalyses LoopRotatePass::run(Loop &L, AnalysisManager<Loop> &AM) { PreservedAnalyses LoopRotatePass::run(Loop &L, AnalysisManager &AM) {
auto &FAM = AM.getResult<FunctionAnalysisManagerLoopProxy>(L).getManager();
Function *F = L.getHeader()->getParent(); Function *F = L.getHeader()->getParent();
auto *LI = FAM.getCachedResult<LoopAnalysis>(*F); auto *LI = AM.getCachedResult<LoopAnalysis>(*F);
const auto *TTI = FAM.getCachedResult<TargetIRAnalysis>(*F); const auto *TTI = AM.getCachedResult<TargetIRAnalysis>(*F);
auto *AC = FAM.getCachedResult<AssumptionAnalysis>(*F); auto *AC = AM.getCachedResult<AssumptionAnalysis>(*F);
assert((LI && TTI && AC) && "Analyses for loop rotation not available"); assert((LI && TTI && AC) && "Analyses for loop rotation not available");
// Optional analyses. // Optional analyses.
auto *DT = FAM.getCachedResult<DominatorTreeAnalysis>(*F); auto *DT = AM.getCachedResult<DominatorTreeAnalysis>(*F);
auto *SE = FAM.getCachedResult<ScalarEvolutionAnalysis>(*F); auto *SE = AM.getCachedResult<ScalarEvolutionAnalysis>(*F);
LoopRotate LR(DefaultRotationThreshold, LI, TTI, AC, DT, SE); LoopRotate LR(DefaultRotationThreshold, LI, TTI, AC, DT, SE);
bool Changed = LR.processLoop(&L); bool Changed = LR.processLoop(&L);
if (!Changed) if (!Changed)
return PreservedAnalyses::all(); return PreservedAnalyses::all();
return getLoopPassPreservedAnalyses(); return getLoopPassPreservedAnalyses();
} }
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

lib/Transforms/Scalar/LoopSimplifyCFG.cpp

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines for (auto &Block : Blocks) {
LI.removeBlock(Pred); LI.removeBlock(Pred);
MergeBasicBlockIntoOnlyPred(Succ, &DT); MergeBasicBlockIntoOnlyPred(Succ, &DT);
Changed = true; Changed = true;
} }
return Changed; return Changed;
} }
PreservedAnalyses LoopSimplifyCFGPass::run(Loop &L, AnalysisManager<Loop> &AM) { PreservedAnalyses LoopSimplifyCFGPass::run(Loop &L, AnalysisManager &AM) {
const auto &FAM =
AM.getResult<FunctionAnalysisManagerLoopProxy>(L).getManager();
Function *F = L.getHeader()->getParent(); Function *F = L.getHeader()->getParent();
auto *LI = FAM.getCachedResult<LoopAnalysis>(*F); auto *LI = AM.getCachedResult<LoopAnalysis>(*F);
auto *DT = FAM.getCachedResult<DominatorTreeAnalysis>(*F); auto *DT = AM.getCachedResult<DominatorTreeAnalysis>(*F);
assert((LI && DT) && "Analyses for LoopSimplifyCFG not available"); assert((LI && DT) && "Analyses for LoopSimplifyCFG not available");
if (!simplifyLoopCFG(L, *DT, *LI)) if (!simplifyLoopCFG(L, *DT, *LI))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
return getLoopPassPreservedAnalyses(); return getLoopPassPreservedAnalyses();
} }
namespace { namespace {
Show All 33 Lines

lib/Transforms/Scalar/LoopStrengthReduce.cpp

Show First 20 Lines • Show All 5,017 Lines • ▼ Show 20 Linesbool LoopStrengthReduce::runOnLoop(Loop *L, LPPassManager & /*LPM*/) {
auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree(); auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
auto &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo(); auto &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
const auto &TTI = getAnalysis<TargetTransformInfoWrapperPass>().getTTI( const auto &TTI = getAnalysis<TargetTransformInfoWrapperPass>().getTTI(
*L->getHeader()->getParent()); *L->getHeader()->getParent());
return ReduceLoopStrength(L, IU, SE, DT, LI, TTI); return ReduceLoopStrength(L, IU, SE, DT, LI, TTI);
} }
PreservedAnalyses LoopStrengthReducePass::run(Loop &L, PreservedAnalyses LoopStrengthReducePass::run(Loop &L,
AnalysisManager<Loop> &AM) { AnalysisManager &AM) {
const auto &FAM =
AM.getResult<FunctionAnalysisManagerLoopProxy>(L).getManager();
Function *F = L.getHeader()->getParent(); Function *F = L.getHeader()->getParent();
auto &IU = AM.getResult<IVUsersAnalysis>(L); auto &IU = AM.getResult<IVUsersAnalysis>(L);
auto *SE = FAM.getCachedResult<ScalarEvolutionAnalysis>(*F); auto *SE = AM.getCachedResult<ScalarEvolutionAnalysis>(*F);
auto *DT = FAM.getCachedResult<DominatorTreeAnalysis>(*F); auto *DT = AM.getCachedResult<DominatorTreeAnalysis>(*F);
auto *LI = FAM.getCachedResult<LoopAnalysis>(*F); auto *LI = AM.getCachedResult<LoopAnalysis>(*F);
auto *TTI = FAM.getCachedResult<TargetIRAnalysis>(*F); auto *TTI = AM.getCachedResult<TargetIRAnalysis>(*F);
assert((SE && DT && LI && TTI) && assert((SE && DT && LI && TTI) &&
"Analyses for Loop Strength Reduce not available"); "Analyses for Loop Strength Reduce not available");
if (!ReduceLoopStrength(&L, IU, *SE, *DT, *LI, *TTI)) if (!ReduceLoopStrength(&L, IU, *SE, *DT, *LI, *TTI))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
return getLoopPassPreservedAnalyses(); return getLoopPassPreservedAnalyses();
} }

lib/Transforms/Scalar/LoopUnrollPass.cpp

Show First 20 Lines • Show All 1,052 Lines • ▼ Show 20 Lines return new LoopUnroll(Threshold == -1 ? None : Optional<unsigned>(Threshold),
: Optional<bool>(AllowPartial), : Optional<bool>(AllowPartial),
Runtime == -1 ? None : Optional<bool>(Runtime)); Runtime == -1 ? None : Optional<bool>(Runtime));
} }
Pass *llvm::createSimpleLoopUnrollPass() { Pass *llvm::createSimpleLoopUnrollPass() {
return llvm::createLoopUnrollPass(-1, -1, 0, 0); return llvm::createLoopUnrollPass(-1, -1, 0, 0);
} }
PreservedAnalyses LoopUnrollPass::run(Loop &L, AnalysisManager<Loop> &AM) { PreservedAnalyses LoopUnrollPass::run(Loop &L, AnalysisManager &AM) {
const auto &FAM =
AM.getResult<FunctionAnalysisManagerLoopProxy>(L).getManager();
Function *F = L.getHeader()->getParent(); Function *F = L.getHeader()->getParent();
DominatorTree *DT = FAM.getCachedResult<DominatorTreeAnalysis>(*F); DominatorTree *DT = AM.getCachedResult<DominatorTreeAnalysis>(*F);
LoopInfo *LI = FAM.getCachedResult<LoopAnalysis>(*F); LoopInfo *LI = AM.getCachedResult<LoopAnalysis>(*F);
ScalarEvolution *SE = FAM.getCachedResult<ScalarEvolutionAnalysis>(*F); ScalarEvolution *SE = AM.getCachedResult<ScalarEvolutionAnalysis>(*F);
auto *TTI = FAM.getCachedResult<TargetIRAnalysis>(*F); auto *TTI = AM.getCachedResult<TargetIRAnalysis>(*F);
auto *AC = FAM.getCachedResult<AssumptionAnalysis>(*F); auto *AC = AM.getCachedResult<AssumptionAnalysis>(*F);
auto *ORE = FAM.getCachedResult<OptimizationRemarkEmitterAnalysis>(*F); auto *ORE = AM.getCachedResult<OptimizationRemarkEmitterAnalysis>(*F);
if (!DT) if (!DT)
report_fatal_error("LoopUnrollPass: DominatorTreeAnalysis not cached at a higher level"); report_fatal_error("LoopUnrollPass: DominatorTreeAnalysis not cached at a higher level");
if (!LI) if (!LI)
report_fatal_error("LoopUnrollPass: LoopAnalysis not cached at a higher level"); report_fatal_error("LoopUnrollPass: LoopAnalysis not cached at a higher level");
if (!SE) if (!SE)
report_fatal_error("LoopUnrollPass: ScalarEvolutionAnalysis not cached at a higher level"); report_fatal_error("LoopUnrollPass: ScalarEvolutionAnalysis not cached at a higher level");
if (!TTI) if (!TTI)
report_fatal_error("LoopUnrollPass: TargetIRAnalysis not cached at a higher level"); report_fatal_error("LoopUnrollPass: TargetIRAnalysis not cached at a higher level");
Show All 14 Lines

lib/Transforms/Scalar/LowerAtomic.cpp

Show First 20 Lines • Show All 133 Lines • ▼ Show 20 Lines
static bool lowerAtomics(Function &F) { static bool lowerAtomics(Function &F) {
bool Changed = false; bool Changed = false;
for (BasicBlock &BB : F) { for (BasicBlock &BB : F) {
Changed |= runOnBasicBlock(BB); Changed |= runOnBasicBlock(BB);
} }
return Changed; return Changed;
} }
PreservedAnalyses LowerAtomicPass::run(Function &F, FunctionAnalysisManager &) { PreservedAnalyses LowerAtomicPass::run(Function &F, AnalysisManager &) {
if (lowerAtomics(F)) if (lowerAtomics(F))
return PreservedAnalyses::none(); return PreservedAnalyses::none();
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
namespace { namespace {
class LowerAtomicLegacyPass : public FunctionPass { class LowerAtomicLegacyPass : public FunctionPass {
public: public:
static char ID; static char ID;
LowerAtomicLegacyPass() : FunctionPass(ID) { LowerAtomicLegacyPass() : FunctionPass(ID) {
initializeLowerAtomicLegacyPassPass(*PassRegistry::getPassRegistry()); initializeLowerAtomicLegacyPassPass(*PassRegistry::getPassRegistry());
} }
bool runOnFunction(Function &F) override { bool runOnFunction(Function &F) override {
if (skipFunction(F)) if (skipFunction(F))
return false; return false;
FunctionAnalysisManager DummyFAM; AnalysisManager DummyAM;
auto PA = Impl.run(F, DummyFAM); auto PA = Impl.run(F, DummyAM);
return !PA.areAllPreserved(); return !PA.areAllPreserved();
} }
private: private:
LowerAtomicPass Impl; LowerAtomicPass Impl;
}; };
} }
char LowerAtomicLegacyPass::ID = 0; char LowerAtomicLegacyPass::ID = 0;
INITIALIZE_PASS(LowerAtomicLegacyPass, "loweratomic", INITIALIZE_PASS(LowerAtomicLegacyPass, "loweratomic",
"Lower atomic intrinsics to non-atomic form", false, false) "Lower atomic intrinsics to non-atomic form", false, false)
Pass *llvm::createLowerAtomicPass() { return new LowerAtomicLegacyPass(); } Pass *llvm::createLowerAtomicPass() { return new LowerAtomicLegacyPass(); }

lib/Transforms/Scalar/LowerExpectIntrinsic.cpp

Show First 20 Lines • Show All 165 Lines • ▼ Show 20 Lines for (BasicBlock::iterator BI = BB.begin(), BE = BB.end(); BI != BE;) {
} }
} }
} }
return Changed; return Changed;
} }
PreservedAnalyses LowerExpectIntrinsicPass::run(Function &F, PreservedAnalyses LowerExpectIntrinsicPass::run(Function &F,
FunctionAnalysisManager &) { AnalysisManager &) {
if (lowerExpectIntrinsic(F)) if (lowerExpectIntrinsic(F))
return PreservedAnalyses::none(); return PreservedAnalyses::none();
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
namespace { namespace {
/// \brief Legacy pass for lowering expect intrinsics out of the IR. /// \brief Legacy pass for lowering expect intrinsics out of the IR.
Show All 23 Lines

lib/Transforms/Scalar/LowerGuardIntrinsic.cpp

Show First 20 Lines • Show All 123 Lines • ▼ Show 20 LinesINITIALIZE_PASS(LowerGuardIntrinsicLegacyPass, "lower-guard-intrinsic",
"Lower the guard intrinsic to normal control flow", false, "Lower the guard intrinsic to normal control flow", false,
false) false)
Pass *llvm::createLowerGuardIntrinsicPass() { Pass *llvm::createLowerGuardIntrinsicPass() {
return new LowerGuardIntrinsicLegacyPass(); return new LowerGuardIntrinsicLegacyPass();
} }
PreservedAnalyses LowerGuardIntrinsicPass::run(Function &F, PreservedAnalyses LowerGuardIntrinsicPass::run(Function &F,
FunctionAnalysisManager &AM) { AnalysisManager &AM) {
if (lowerGuardIntrinsic(F)) if (lowerGuardIntrinsic(F))
return PreservedAnalyses::none(); return PreservedAnalyses::none();
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }

lib/Transforms/Scalar/MemCpyOptimizer.cpp

Show First 20 Lines • Show All 1,361 Lines • ▼ Show 20 Lines for (BasicBlock::iterator BI = BB.begin(), BE = BB.end(); BI != BE;) {
MadeChange = true; MadeChange = true;
} }
} }
} }
return MadeChange; return MadeChange;
} }
PreservedAnalyses MemCpyOptPass::run(Function &F, FunctionAnalysisManager &AM) { PreservedAnalyses MemCpyOptPass::run(Function &F, AnalysisManager &AM) {
auto &MD = AM.getResult<MemoryDependenceAnalysis>(F); auto &MD = AM.getResult<MemoryDependenceAnalysis>(F);
auto &TLI = AM.getResult<TargetLibraryAnalysis>(F); auto &TLI = AM.getResult<TargetLibraryAnalysis>(F);
auto LookupAliasAnalysis = [&]() -> AliasAnalysis & { auto LookupAliasAnalysis = [&]() -> AliasAnalysis & {
return AM.getResult<AAManager>(F); return AM.getResult<AAManager>(F);
}; };
auto LookupAssumptionCache = [&]() -> AssumptionCache & { auto LookupAssumptionCache = [&]() -> AssumptionCache & {
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

lib/Transforms/Scalar/MergedLoadStoreMotion.cpp

Show First 20 Lines • Show All 583 Lines • ▼ Show 20 Lines
INITIALIZE_PASS_BEGIN(MergedLoadStoreMotionLegacyPass, "mldst-motion", INITIALIZE_PASS_BEGIN(MergedLoadStoreMotionLegacyPass, "mldst-motion",
"MergedLoadStoreMotion", false, false) "MergedLoadStoreMotion", false, false)
INITIALIZE_PASS_DEPENDENCY(MemoryDependenceWrapperPass) INITIALIZE_PASS_DEPENDENCY(MemoryDependenceWrapperPass)
INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass) INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass)
INITIALIZE_PASS_END(MergedLoadStoreMotionLegacyPass, "mldst-motion", INITIALIZE_PASS_END(MergedLoadStoreMotionLegacyPass, "mldst-motion",
"MergedLoadStoreMotion", false, false) "MergedLoadStoreMotion", false, false)
PreservedAnalyses PreservedAnalyses
MergedLoadStoreMotionPass::run(Function &F, AnalysisManager<Function> &AM) { MergedLoadStoreMotionPass::run(Function &F, AnalysisManager &AM) {
MergedLoadStoreMotion Impl; MergedLoadStoreMotion Impl;
auto *MD = AM.getCachedResult<MemoryDependenceAnalysis>(F); auto *MD = AM.getCachedResult<MemoryDependenceAnalysis>(F);
auto &AA = AM.getResult<AAManager>(F); auto &AA = AM.getResult<AAManager>(F);
if (!Impl.run(F, MD, AA)) if (!Impl.run(F, MD, AA))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
// FIXME: This should also 'preserve the CFG'. // FIXME: This should also 'preserve the CFG'.
PreservedAnalyses PA; PreservedAnalyses PA;
PA.preserve<GlobalsAA>(); PA.preserve<GlobalsAA>();
PA.preserve<MemoryDependenceAnalysis>(); PA.preserve<MemoryDependenceAnalysis>();
return PA; return PA;
} }

lib/Transforms/Scalar/NaryReassociate.cpp

Show First 20 Lines • Show All 143 Lines • ▼ Show 20 Linesbool NaryReassociateLegacyPass::runOnFunction(Function &F) {
auto *SE = &getAnalysis<ScalarEvolutionWrapperPass>().getSE(); auto *SE = &getAnalysis<ScalarEvolutionWrapperPass>().getSE();
auto *TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(); auto *TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
auto *TTI = &getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F); auto *TTI = &getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
return Impl.runImpl(F, AC, DT, SE, TLI, TTI); return Impl.runImpl(F, AC, DT, SE, TLI, TTI);
} }
PreservedAnalyses NaryReassociatePass::run(Function &F, PreservedAnalyses NaryReassociatePass::run(Function &F,
FunctionAnalysisManager &AM) { AnalysisManager &AM) {
auto *AC = &AM.getResult<AssumptionAnalysis>(F); auto *AC = &AM.getResult<AssumptionAnalysis>(F);
auto *DT = &AM.getResult<DominatorTreeAnalysis>(F); auto *DT = &AM.getResult<DominatorTreeAnalysis>(F);
auto *SE = &AM.getResult<ScalarEvolutionAnalysis>(F); auto *SE = &AM.getResult<ScalarEvolutionAnalysis>(F);
auto *TLI = &AM.getResult<TargetLibraryAnalysis>(F); auto *TLI = &AM.getResult<TargetLibraryAnalysis>(F);
auto *TTI = &AM.getResult<TargetIRAnalysis>(F); auto *TTI = &AM.getResult<TargetIRAnalysis>(F);
bool Changed = runImpl(F, AC, DT, SE, TLI, TTI); bool Changed = runImpl(F, AC, DT, SE, TLI, TTI);
AM.invalidate<ScalarEvolutionAnalysis>(F); AM.invalidate<ScalarEvolutionAnalysis>(F);
▲ Show 20 Lines • Show All 351 Lines • Show Last 20 Lines

lib/Transforms/Scalar/PartiallyInlineLibCalls.cpp

Show First 20 Lines • Show All 117 Lines • ▼ Show 20 Lines for (BasicBlock::iterator II = CurrBB->begin(), IE = CurrBB->end();
break; break;
} }
} }
return Changed; return Changed;
} }
PreservedAnalyses PreservedAnalyses
PartiallyInlineLibCallsPass::run(Function &F, AnalysisManager<Function> &AM) { PartiallyInlineLibCallsPass::run(Function &F, AnalysisManager &AM) {
auto &TLI = AM.getResult<TargetLibraryAnalysis>(F); auto &TLI = AM.getResult<TargetLibraryAnalysis>(F);
auto &TTI = AM.getResult<TargetIRAnalysis>(F); auto &TTI = AM.getResult<TargetIRAnalysis>(F);
if (!runPartiallyInlineLibCalls(F, &TLI, &TTI)) if (!runPartiallyInlineLibCalls(F, &TLI, &TTI))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
return PreservedAnalyses::none(); return PreservedAnalyses::none();
} }
namespace { namespace {
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

lib/Transforms/Scalar/Reassociate.cpp

Show First 20 Lines • Show All 2,165 Lines • ▼ Show 20 Lines if (Ops.size() == 1) {
return; return;
} }
// Now that we ordered and optimized the expressions, splat them back into // Now that we ordered and optimized the expressions, splat them back into
// the expression tree, removing any unneeded nodes. // the expression tree, removing any unneeded nodes.
RewriteExprTree(I, Ops); RewriteExprTree(I, Ops);
} }
PreservedAnalyses ReassociatePass::run(Function &F, FunctionAnalysisManager &) { PreservedAnalyses ReassociatePass::run(Function &F, AnalysisManager &) {
// Reassociate needs for each instruction to have its operands already // Reassociate needs for each instruction to have its operands already
// processed, so we first perform a RPOT of the basic blocks so that // processed, so we first perform a RPOT of the basic blocks so that
// when we process a basic block, all its dominators have been processed // when we process a basic block, all its dominators have been processed
// before. // before.
ReversePostOrderTraversal<Function *> RPOT(&F); ReversePostOrderTraversal<Function *> RPOT(&F);
BuildRankMap(F, RPOT); BuildRankMap(F, RPOT);
MadeChange = false; MadeChange = false;
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines public:
ReassociateLegacyPass() : FunctionPass(ID) { ReassociateLegacyPass() : FunctionPass(ID) {
initializeReassociateLegacyPassPass(*PassRegistry::getPassRegistry()); initializeReassociateLegacyPassPass(*PassRegistry::getPassRegistry());
} }
bool runOnFunction(Function &F) override { bool runOnFunction(Function &F) override {
if (skipFunction(F)) if (skipFunction(F))
return false; return false;
FunctionAnalysisManager DummyFAM; AnalysisManager DummyAM;
auto PA = Impl.run(F, DummyFAM); auto PA = Impl.run(F, DummyAM);
return !PA.areAllPreserved(); return !PA.areAllPreserved();
} }
void getAnalysisUsage(AnalysisUsage &AU) const override { void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.setPreservesCFG(); AU.setPreservesCFG();
AU.addPreserved<GlobalsAAWrapperPass>(); AU.addPreserved<GlobalsAAWrapperPass>();
} }
}; };
Show All 10 Lines

lib/Transforms/Scalar/SCCP.cpp

Show First 20 Lines • Show All 1,625 Lines • ▼ Show 20 Lines for (BasicBlock::iterator BI = BB.begin(), E = BB.end(); BI != E;) {
++NumInstRemoved; ++NumInstRemoved;
} }
} }
} }
return MadeChanges; return MadeChanges;
} }
PreservedAnalyses SCCPPass::run(Function &F, AnalysisManager<Function> &AM) { PreservedAnalyses SCCPPass::run(Function &F, AnalysisManager &AM) {
const DataLayout &DL = F.getParent()->getDataLayout(); const DataLayout &DL = F.getParent()->getDataLayout();
auto &TLI = AM.getResult<TargetLibraryAnalysis>(F); auto &TLI = AM.getResult<TargetLibraryAnalysis>(F);
if (!runSCCP(F, DL, &TLI)) if (!runSCCP(F, DL, &TLI))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
auto PA = PreservedAnalyses(); auto PA = PreservedAnalyses();
PA.preserve<GlobalsAA>(); PA.preserve<GlobalsAA>();
return PA; return PA;
▲ Show 20 Lines • Show All 293 Lines • ▼ Show 20 Lines for (DenseMap<GlobalVariable*, LatticeVal>::const_iterator I = TG.begin(),
} }
M.getGlobalList().erase(GV); M.getGlobalList().erase(GV);
++IPNumGlobalConst; ++IPNumGlobalConst;
} }
return MadeChanges; return MadeChanges;
} }
PreservedAnalyses IPSCCPPass::run(Module &M, AnalysisManager<Module> &AM) { PreservedAnalyses IPSCCPPass::run(Module &M, AnalysisManager &AM) {
const DataLayout &DL = M.getDataLayout(); const DataLayout &DL = M.getDataLayout();
auto &TLI = AM.getResult<TargetLibraryAnalysis>(M); auto &TLI = AM.getResult<TargetLibraryAnalysis>(M);
if (!runIPSCCP(M, DL, &TLI)) if (!runIPSCCP(M, DL, &TLI))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
return PreservedAnalyses::none(); return PreservedAnalyses::none();
} }
namespace { namespace {
Show All 39 Lines

lib/Transforms/Scalar/SROA.cpp

Show First 20 Lines • Show All 4,247 Lines • ▼ Show 20 LinesPreservedAnalyses SROA::runImpl(Function &F, DominatorTree &RunDT,
// FIXME: Even when promoting allocas we should preserve some abstract set of // FIXME: Even when promoting allocas we should preserve some abstract set of
// CFG-specific analyses. // CFG-specific analyses.
PreservedAnalyses PA; PreservedAnalyses PA;
PA.preserve<GlobalsAA>(); PA.preserve<GlobalsAA>();
return PA; return PA;
} }
PreservedAnalyses SROA::run(Function &F, AnalysisManager<Function> &AM) { PreservedAnalyses SROA::run(Function &F, AnalysisManager &AM) {
return runImpl(F, AM.getResult<DominatorTreeAnalysis>(F), return runImpl(F, AM.getResult<DominatorTreeAnalysis>(F),
AM.getResult<AssumptionAnalysis>(F)); AM.getResult<AssumptionAnalysis>(F));
} }
/// A legacy pass for the legacy pass manager that wraps the \c SROA pass. /// A legacy pass for the legacy pass manager that wraps the \c SROA pass.
/// ///
/// This is in the llvm namespace purely to allow it to be a friend of the \c /// This is in the llvm namespace purely to allow it to be a friend of the \c
/// SROA pass. /// SROA pass.
Show All 38 Lines

lib/Transforms/Scalar/SimplifyCFGPass.cpp

Show First 20 Lines • Show All 181 Lines • ▼ Show 20 Lines
SimplifyCFGPass::SimplifyCFGPass() SimplifyCFGPass::SimplifyCFGPass()
: BonusInstThreshold(UserBonusInstThreshold) {} : BonusInstThreshold(UserBonusInstThreshold) {}
SimplifyCFGPass::SimplifyCFGPass(int BonusInstThreshold) SimplifyCFGPass::SimplifyCFGPass(int BonusInstThreshold)
: BonusInstThreshold(BonusInstThreshold) {} : BonusInstThreshold(BonusInstThreshold) {}
PreservedAnalyses SimplifyCFGPass::run(Function &F, PreservedAnalyses SimplifyCFGPass::run(Function &F,
AnalysisManager<Function> &AM) { AnalysisManager &AM) {
auto &TTI = AM.getResult<TargetIRAnalysis>(F); auto &TTI = AM.getResult<TargetIRAnalysis>(F);
auto &AC = AM.getResult<AssumptionAnalysis>(F); auto &AC = AM.getResult<AssumptionAnalysis>(F);
if (!simplifyFunctionCFG(F, TTI, &AC, BonusInstThreshold)) if (!simplifyFunctionCFG(F, TTI, &AC, BonusInstThreshold))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
PreservedAnalyses PA; PreservedAnalyses PA;
PA.preserve<GlobalsAA>(); PA.preserve<GlobalsAA>();
return PA; return PA;
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

lib/Transforms/Scalar/Sink.cpp

Show First 20 Lines • Show All 248 Lines • ▼ Show 20 Lines for (BasicBlock &I : F)
MadeChange |= ProcessBlock(I, DT, LI, AA); MadeChange |= ProcessBlock(I, DT, LI, AA);
EverMadeChange |= MadeChange; EverMadeChange |= MadeChange;
NumSinkIter++; NumSinkIter++;
} while (MadeChange); } while (MadeChange);
return EverMadeChange; return EverMadeChange;
} }
PreservedAnalyses SinkingPass::run(Function &F, AnalysisManager<Function> &AM) { PreservedAnalyses SinkingPass::run(Function &F, AnalysisManager &AM) {
auto &DT = AM.getResult<DominatorTreeAnalysis>(F); auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
auto &LI = AM.getResult<LoopAnalysis>(F); auto &LI = AM.getResult<LoopAnalysis>(F);
auto &AA = AM.getResult<AAManager>(F); auto &AA = AM.getResult<AAManager>(F);
if (!iterativelySinkInstructions(F, DT, LI, AA)) if (!iterativelySinkInstructions(F, DT, LI, AA))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
auto PA = PreservedAnalyses(); auto PA = PreservedAnalyses();
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

lib/Transforms/Scalar/SpeculativeExecution.cpp

Show First 20 Lines • Show All 281 Lines • ▼ Show 20 LinesFunctionPass *createSpeculativeExecutionIfHasBranchDivergencePass() {
return new SpeculativeExecutionLegacyPass(/* OnlyIfDivergentTarget = */ true); return new SpeculativeExecutionLegacyPass(/* OnlyIfDivergentTarget = */ true);
} }
SpeculativeExecutionPass::SpeculativeExecutionPass(bool OnlyIfDivergentTarget) SpeculativeExecutionPass::SpeculativeExecutionPass(bool OnlyIfDivergentTarget)
: OnlyIfDivergentTarget(OnlyIfDivergentTarget || : OnlyIfDivergentTarget(OnlyIfDivergentTarget ||
SpecExecOnlyIfDivergentTarget) {} SpecExecOnlyIfDivergentTarget) {}
PreservedAnalyses SpeculativeExecutionPass::run(Function &F, PreservedAnalyses SpeculativeExecutionPass::run(Function &F,
FunctionAnalysisManager &AM) { AnalysisManager &AM) {
auto *TTI = &AM.getResult<TargetIRAnalysis>(F); auto *TTI = &AM.getResult<TargetIRAnalysis>(F);
bool Changed = runImpl(F, TTI); bool Changed = runImpl(F, TTI);
if (!Changed) if (!Changed)
return PreservedAnalyses::all(); return PreservedAnalyses::all();
PreservedAnalyses PA; PreservedAnalyses PA;
PA.preserve<GlobalsAA>(); PA.preserve<GlobalsAA>();
return PA; return PA;
} }
} // namespace llvm } // namespace llvm

lib/Transforms/Scalar/TailRecursionElimination.cpp

Show First 20 Lines • Show All 820 Lines • ▼ Show 20 LinesINITIALIZE_PASS_END(TailCallElim, "tailcallelim", "Tail Call Elimination",
false, false) false, false)
// Public interface to the TailCallElimination pass // Public interface to the TailCallElimination pass
FunctionPass *llvm::createTailCallEliminationPass() { FunctionPass *llvm::createTailCallEliminationPass() {
return new TailCallElim(); return new TailCallElim();
} }
PreservedAnalyses TailCallElimPass::run(Function &F, PreservedAnalyses TailCallElimPass::run(Function &F,
FunctionAnalysisManager &AM) { AnalysisManager &AM) {
TargetTransformInfo &TTI = AM.getResult<TargetIRAnalysis>(F); TargetTransformInfo &TTI = AM.getResult<TargetIRAnalysis>(F);
bool Changed = eliminateTailRecursion(F, &TTI); bool Changed = eliminateTailRecursion(F, &TTI);
if (!Changed) if (!Changed)
return PreservedAnalyses::all(); return PreservedAnalyses::all();
PreservedAnalyses PA; PreservedAnalyses PA;
PA.preserve<GlobalsAA>(); PA.preserve<GlobalsAA>();
return PA; return PA;
} }

lib/Transforms/Utils/AddDiscriminators.cpp

Show First 20 Lines • Show All 243 Lines • ▼ Show 20 Linesstatic bool addDiscriminators(Function &F) {
} }
return Changed; return Changed;
} }
bool AddDiscriminatorsLegacyPass::runOnFunction(Function &F) { bool AddDiscriminatorsLegacyPass::runOnFunction(Function &F) {
return addDiscriminators(F); return addDiscriminators(F);
} }
PreservedAnalyses AddDiscriminatorsPass::run(Function &F, PreservedAnalyses AddDiscriminatorsPass::run(Function &F,
AnalysisManager<Function> &AM) { AnalysisManager &AM) {
if (!addDiscriminators(F)) if (!addDiscriminators(F))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
// FIXME: should be all() // FIXME: should be all()
return PreservedAnalyses::none(); return PreservedAnalyses::none();
} }

lib/Transforms/Utils/BreakCriticalEdges.cpp

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Lines
// Publicly exposed interface to pass... // Publicly exposed interface to pass...
char &llvm::BreakCriticalEdgesID = BreakCriticalEdges::ID; char &llvm::BreakCriticalEdgesID = BreakCriticalEdges::ID;
FunctionPass *llvm::createBreakCriticalEdgesPass() { FunctionPass *llvm::createBreakCriticalEdgesPass() {
return new BreakCriticalEdges(); return new BreakCriticalEdges();
} }
PreservedAnalyses BreakCriticalEdgesPass::run(Function &F, PreservedAnalyses BreakCriticalEdgesPass::run(Function &F,
FunctionAnalysisManager &AM) { AnalysisManager &AM) {
auto *DT = AM.getCachedResult<DominatorTreeAnalysis>(F); auto *DT = AM.getCachedResult<DominatorTreeAnalysis>(F);
auto *LI = AM.getCachedResult<LoopAnalysis>(F); auto *LI = AM.getCachedResult<LoopAnalysis>(F);
unsigned N = SplitAllCriticalEdges(F, CriticalEdgeSplittingOptions(DT, LI)); unsigned N = SplitAllCriticalEdges(F, CriticalEdgeSplittingOptions(DT, LI));
NumBroken += N; NumBroken += N;
if (N == 0) if (N == 0)
return PreservedAnalyses::all(); return PreservedAnalyses::all();
PreservedAnalyses PA; PreservedAnalyses PA;
PA.preserve<DominatorTreeAnalysis>(); PA.preserve<DominatorTreeAnalysis>();
▲ Show 20 Lines • Show All 244 Lines • Show Last 20 Lines

lib/Transforms/Utils/LCSSA.cpp

Show First 20 Lines • Show All 354 Lines • ▼ Show 20 Linesbool LCSSAWrapperPass::runOnFunction(Function &F) {
LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo(); LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree(); DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
auto *SEWP = getAnalysisIfAvailable<ScalarEvolutionWrapperPass>(); auto *SEWP = getAnalysisIfAvailable<ScalarEvolutionWrapperPass>();
SE = SEWP ? &SEWP->getSE() : nullptr; SE = SEWP ? &SEWP->getSE() : nullptr;
return formLCSSAOnAllLoops(LI, *DT, SE); return formLCSSAOnAllLoops(LI, *DT, SE);
} }
PreservedAnalyses LCSSAPass::run(Function &F, AnalysisManager<Function> &AM) { PreservedAnalyses LCSSAPass::run(Function &F, AnalysisManager &AM) {
auto &LI = AM.getResult<LoopAnalysis>(F); auto &LI = AM.getResult<LoopAnalysis>(F);
auto &DT = AM.getResult<DominatorTreeAnalysis>(F); auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
auto *SE = AM.getCachedResult<ScalarEvolutionAnalysis>(F); auto *SE = AM.getCachedResult<ScalarEvolutionAnalysis>(F);
if (!formLCSSAOnAllLoops(&LI, DT, SE)) if (!formLCSSAOnAllLoops(&LI, DT, SE))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
// FIXME: This should also 'preserve the CFG'. // FIXME: This should also 'preserve the CFG'.
PreservedAnalyses PA; PreservedAnalyses PA;
PA.preserve<BasicAA>(); PA.preserve<BasicAA>();
PA.preserve<GlobalsAA>(); PA.preserve<GlobalsAA>();
PA.preserve<SCEVAA>(); PA.preserve<SCEVAA>();
PA.preserve<ScalarEvolutionAnalysis>(); PA.preserve<ScalarEvolutionAnalysis>();
return PA; return PA;
} }

lib/Transforms/Utils/LoopSimplify.cpp

Show First 20 Lines • Show All 851 Lines • ▼ Show 20 Lines bool InLCSSA =
all_of(*LI, [&](Loop *L) { return L->isRecursivelyLCSSAForm(*DT); }); all_of(*LI, [&](Loop *L) { return L->isRecursivelyLCSSAForm(*DT); });
assert(InLCSSA && "LCSSA is broken after loop-simplify."); assert(InLCSSA && "LCSSA is broken after loop-simplify.");
} }
#endif #endif
return Changed; return Changed;
} }
PreservedAnalyses LoopSimplifyPass::run(Function &F, PreservedAnalyses LoopSimplifyPass::run(Function &F,
AnalysisManager<Function> &AM) { AnalysisManager &AM) {
bool Changed = false; bool Changed = false;
LoopInfo *LI = &AM.getResult<LoopAnalysis>(F); LoopInfo *LI = &AM.getResult<LoopAnalysis>(F);
DominatorTree *DT = &AM.getResult<DominatorTreeAnalysis>(F); DominatorTree *DT = &AM.getResult<DominatorTreeAnalysis>(F);
ScalarEvolution *SE = AM.getCachedResult<ScalarEvolutionAnalysis>(F); ScalarEvolution *SE = AM.getCachedResult<ScalarEvolutionAnalysis>(F);
AssumptionCache *AC = &AM.getResult<AssumptionAnalysis>(F); AssumptionCache *AC = &AM.getResult<AssumptionAnalysis>(F);
// FIXME: This pass should verify that the loops on which it's operating // FIXME: This pass should verify that the loops on which it's operating
// are in canonical SSA form, and that the pass itself preserves this form. // are in canonical SSA form, and that the pass itself preserves this form.
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

lib/Transforms/Utils/Mem2Reg.cpp

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines while (1) {
PromoteMemToReg(Allocas, DT, nullptr, &AC); PromoteMemToReg(Allocas, DT, nullptr, &AC);
NumPromoted += Allocas.size(); NumPromoted += Allocas.size();
Changed = true; Changed = true;
} }
return Changed; return Changed;
} }
PreservedAnalyses PromotePass::run(Function &F, AnalysisManager<Function> &AM) { PreservedAnalyses PromotePass::run(Function &F, AnalysisManager &AM) {
auto &DT = AM.getResult<DominatorTreeAnalysis>(F); auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
auto &AC = AM.getResult<AssumptionAnalysis>(F); auto &AC = AM.getResult<AssumptionAnalysis>(F);
if (!promoteMemoryToRegister(F, DT, AC)) if (!promoteMemoryToRegister(F, DT, AC))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
// FIXME: This should also 'preserve the CFG'. // FIXME: This should also 'preserve the CFG'.
return PreservedAnalyses::none(); return PreservedAnalyses::none();
} }
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

lib/Transforms/Utils/MemorySSA.cpp

Show First 20 Lines • Show All 2,077 Lines • ▼ Show 20 Linesbool MemorySSAPrinterLegacyPass::runOnFunction(Function &F) {
MSSA.print(dbgs()); MSSA.print(dbgs());
if (VerifyMemorySSA) if (VerifyMemorySSA)
MSSA.verifyMemorySSA(); MSSA.verifyMemorySSA();
return false; return false;
} }
char MemorySSAAnalysis::PassID; char MemorySSAAnalysis::PassID;
MemorySSA MemorySSAAnalysis::run(Function &F, AnalysisManager<Function> &AM) { MemorySSA MemorySSAAnalysis::run(Function &F, AnalysisManager &AM) {
auto &DT = AM.getResult<DominatorTreeAnalysis>(F); auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
auto &AA = AM.getResult<AAManager>(F); auto &AA = AM.getResult<AAManager>(F);
return MemorySSA(F, &AA, &DT); return MemorySSA(F, &AA, &DT);
} }
PreservedAnalyses MemorySSAPrinterPass::run(Function &F, PreservedAnalyses MemorySSAPrinterPass::run(Function &F,
FunctionAnalysisManager &AM) { AnalysisManager &AM) {
OS << "MemorySSA for function: " << F.getName() << "\n"; OS << "MemorySSA for function: " << F.getName() << "\n";
AM.getResult<MemorySSAAnalysis>(F).print(OS); AM.getResult<MemorySSAAnalysis>(F).print(OS);
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
PreservedAnalyses MemorySSAVerifierPass::run(Function &F, PreservedAnalyses MemorySSAVerifierPass::run(Function &F,
FunctionAnalysisManager &AM) { AnalysisManager &AM) {
AM.getResult<MemorySSAAnalysis>(F).verifyMemorySSA(); AM.getResult<MemorySSAAnalysis>(F).verifyMemorySSA();
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
char MemorySSAWrapperPass::ID = 0; char MemorySSAWrapperPass::ID = 0;
MemorySSAWrapperPass::MemorySSAWrapperPass() : FunctionPass(ID) { MemorySSAWrapperPass::MemorySSAWrapperPass() : FunctionPass(ID) {
▲ Show 20 Lines • Show All 174 Lines • Show Last 20 Lines

lib/Transforms/Utils/SimplifyInstructions.cpp

Show First 20 Lines • Show All 120 Lines • ▼ Show 20 Lines
char &llvm::InstructionSimplifierID = InstSimplifier::ID; char &llvm::InstructionSimplifierID = InstSimplifier::ID;
// Public interface to the simplify instructions pass. // Public interface to the simplify instructions pass.
FunctionPass *llvm::createInstructionSimplifierPass() { FunctionPass *llvm::createInstructionSimplifierPass() {
return new InstSimplifier(); return new InstSimplifier();
} }
PreservedAnalyses InstSimplifierPass::run(Function &F, PreservedAnalyses InstSimplifierPass::run(Function &F,
AnalysisManager<Function> &AM) { AnalysisManager &AM) {
auto *DT = AM.getCachedResult<DominatorTreeAnalysis>(F); auto *DT = AM.getCachedResult<DominatorTreeAnalysis>(F);
auto &TLI = AM.getResult<TargetLibraryAnalysis>(F); auto &TLI = AM.getResult<TargetLibraryAnalysis>(F);
auto &AC = AM.getResult<AssumptionAnalysis>(F); auto &AC = AM.getResult<AssumptionAnalysis>(F);
bool Changed = runImpl(F, DT, &TLI, &AC); bool Changed = runImpl(F, DT, &TLI, &AC);
if (!Changed) if (!Changed)
return PreservedAnalyses::all(); return PreservedAnalyses::all();
// FIXME: This should also 'preserve the CFG'. // FIXME: This should also 'preserve the CFG'.
return PreservedAnalyses::none(); return PreservedAnalyses::none();
} }

lib/Transforms/Utils/SymbolRewriter.cpp

Show First 20 Lines • Show All 520 Lines • ▼ Show 20 LinesRewriteSymbolsLegacyPass::RewriteSymbolsLegacyPass(
: ModulePass(ID), Impl(DL) {} : ModulePass(ID), Impl(DL) {}
bool RewriteSymbolsLegacyPass::runOnModule(Module &M) { bool RewriteSymbolsLegacyPass::runOnModule(Module &M) {
return Impl.runImpl(M); return Impl.runImpl(M);
} }
} }
namespace llvm { namespace llvm {
PreservedAnalyses RewriteSymbolPass::run(Module &M, ModuleAnalysisManager &AM) { PreservedAnalyses RewriteSymbolPass::run(Module &M, AnalysisManager &AM) {
if (!runImpl(M)) if (!runImpl(M))
return PreservedAnalyses::all(); return PreservedAnalyses::all();
return PreservedAnalyses::none(); return PreservedAnalyses::none();
} }
bool RewriteSymbolPass::runImpl(Module &M) { bool RewriteSymbolPass::runImpl(Module &M) {
bool Changed; bool Changed;
Show All 28 Lines

lib/Transforms/Vectorize/LoopVectorize.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 6,811 Lines • ▼ Show 20 Linesbool LoopVectorizePass::runImpl(
// Process each loop nest in the function. // Process each loop nest in the function.
return Changed; return Changed;
} }
PreservedAnalyses LoopVectorizePass::run(Function &F, PreservedAnalyses LoopVectorizePass::run(Function &F,
FunctionAnalysisManager &AM) { AnalysisManager &AM) {
auto &SE = AM.getResult<ScalarEvolutionAnalysis>(F); auto &SE = AM.getResult<ScalarEvolutionAnalysis>(F);
auto &LI = AM.getResult<LoopAnalysis>(F); auto &LI = AM.getResult<LoopAnalysis>(F);
auto &TTI = AM.getResult<TargetIRAnalysis>(F); auto &TTI = AM.getResult<TargetIRAnalysis>(F);
auto &DT = AM.getResult<DominatorTreeAnalysis>(F); auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
auto &BFI = AM.getResult<BlockFrequencyAnalysis>(F); auto &BFI = AM.getResult<BlockFrequencyAnalysis>(F);
auto *TLI = AM.getCachedResult<TargetLibraryAnalysis>(F); auto *TLI = AM.getCachedResult<TargetLibraryAnalysis>(F);
auto &AA = AM.getResult<AAManager>(F); auto &AA = AM.getResult<AAManager>(F);
auto &AC = AM.getResult<AssumptionAnalysis>(F); auto &AC = AM.getResult<AssumptionAnalysis>(F);
auto &DB = AM.getResult<DemandedBitsAnalysis>(F); auto &DB = AM.getResult<DemandedBitsAnalysis>(F);
auto &ORE = AM.getResult<OptimizationRemarkEmitterAnalysis>(F); auto &ORE = AM.getResult<OptimizationRemarkEmitterAnalysis>(F);
auto &LAM = AM.getResult<LoopAnalysisManagerFunctionProxy>(F).getManager();
std::function<const LoopAccessInfo &(Loop &)> GetLAA = std::function<const LoopAccessInfo &(Loop &)> GetLAA =
[&](Loop &L) -> const LoopAccessInfo & { [&](Loop &L) -> const LoopAccessInfo & {
return LAM.getResult<LoopAccessAnalysis>(L); return AM.getResult<LoopAccessAnalysis>(L);
}; };
bool Changed = bool Changed =
runImpl(F, SE, LI, TTI, DT, BFI, TLI, DB, AA, AC, GetLAA, ORE); runImpl(F, SE, LI, TTI, DT, BFI, TLI, DB, AA, AC, GetLAA, ORE);
if (!Changed) if (!Changed)
return PreservedAnalyses::all(); return PreservedAnalyses::all();
PreservedAnalyses PA; PreservedAnalyses PA;
PA.preserve<LoopAnalysis>(); PA.preserve<LoopAnalysis>();
PA.preserve<DominatorTreeAnalysis>(); PA.preserve<DominatorTreeAnalysis>();
PA.preserve<BasicAA>(); PA.preserve<BasicAA>();
PA.preserve<GlobalsAA>(); PA.preserve<GlobalsAA>();
return PA; return PA;
} }

lib/Transforms/Vectorize/SLPVectorizer.cpp

Show First 20 Lines • Show All 3,501 Lines • ▼ Show 20 Lines void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.addPreserved<DominatorTreeWrapperPass>(); AU.addPreserved<DominatorTreeWrapperPass>();
AU.addPreserved<AAResultsWrapperPass>(); AU.addPreserved<AAResultsWrapperPass>();
AU.addPreserved<GlobalsAAWrapperPass>(); AU.addPreserved<GlobalsAAWrapperPass>();
AU.setPreservesCFG(); AU.setPreservesCFG();
} }
}; };
} // end anonymous namespace } // end anonymous namespace
PreservedAnalyses SLPVectorizerPass::run(Function &F, FunctionAnalysisManager &AM) { PreservedAnalyses SLPVectorizerPass::run(Function &F, AnalysisManager &AM) {
auto *SE = &AM.getResult<ScalarEvolutionAnalysis>(F); auto *SE = &AM.getResult<ScalarEvolutionAnalysis>(F);
auto *TTI = &AM.getResult<TargetIRAnalysis>(F); auto *TTI = &AM.getResult<TargetIRAnalysis>(F);
auto *TLI = AM.getCachedResult<TargetLibraryAnalysis>(F); auto *TLI = AM.getCachedResult<TargetLibraryAnalysis>(F);
auto *AA = &AM.getResult<AAManager>(F); auto *AA = &AM.getResult<AAManager>(F);
auto *LI = &AM.getResult<LoopAnalysis>(F); auto *LI = &AM.getResult<LoopAnalysis>(F);
auto *DT = &AM.getResult<DominatorTreeAnalysis>(F); auto *DT = &AM.getResult<DominatorTreeAnalysis>(F);
auto *AC = &AM.getResult<AssumptionAnalysis>(F); auto *AC = &AM.getResult<AssumptionAnalysis>(F);
auto *DB = &AM.getResult<DemandedBitsAnalysis>(F); auto *DB = &AM.getResult<DemandedBitsAnalysis>(F);
▲ Show 20 Lines • Show All 1,170 Lines • Show Last 20 Lines

test/Other/analysis-manager/transitive-invalidation.ll

  • This file was added.
; RUN: opt '-passes=require<aa>,invalidate<basic-aa>' -aa-pipeline=basic-aa \
; RUN: -debug-pass-manager -disable-output < %s 2>&1 | FileCheck %s
; CHECK: Running pass: InvalidateAnalysisPass<llvm::BasicAA>
; CHECK-NEXT: Invalidating analysis: BasicAA
; CHECK-NEXT: Invalidating analysis: AAManager
; CHECK: Running pass: InvalidateAnalysisPass<llvm::BasicAA>
; CHECK-NEXT: Invalidating analysis: BasicAA
; CHECK-NEXT: Invalidating analysis: AAManager
; RUN: opt '-passes=require<globals-aa>,function(require<aa>),invalidate<globals-aa>' -aa-pipeline=globals-aa \
; RUN: -debug-pass-manager -disable-output < %s 2>&1 | FileCheck %s --check-prefix=GLOBALS-AA
; GLOBALS-AA: Running pass: InvalidateAnalysisPass<llvm::GlobalsAA>
; GLOBALS-AA-NEXT: Invalidating analysis: GlobalsAA
; GLOBALS-AA-NEXT: Invalidating analysis: AAManager
; GLOBALS-AA-NEXT: Invalidating analysis: AAManager
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
define void @foo() {
entry:
ret void
}
define void @bar() {
entry:
ret void
}

test/Other/new-pass-manager.ll

Show All 14 Lines
; RUN: opt -disable-output -disable-verify -debug-pass-manager \ ; RUN: opt -disable-output -disable-verify -debug-pass-manager \
; RUN: -passes=no-op-cgscc %s 2>&1 \ ; RUN: -passes=no-op-cgscc %s 2>&1 \
; RUN: | FileCheck %s --check-prefix=CHECK-CGSCC-PASS ; RUN: | FileCheck %s --check-prefix=CHECK-CGSCC-PASS
; RUN: opt -disable-output -disable-verify -debug-pass-manager \ ; RUN: opt -disable-output -disable-verify -debug-pass-manager \
; RUN: -passes='cgscc(no-op-cgscc)' %s 2>&1 \ ; RUN: -passes='cgscc(no-op-cgscc)' %s 2>&1 \
; RUN: | FileCheck %s --check-prefix=CHECK-CGSCC-PASS ; RUN: | FileCheck %s --check-prefix=CHECK-CGSCC-PASS
; CHECK-CGSCC-PASS: Starting llvm::Module pass manager run ; CHECK-CGSCC-PASS: Starting llvm::Module pass manager run
; CHECK-CGSCC-PASS-NEXT: Running pass: ModuleToPostOrderCGSCCPassAdaptor ; CHECK-CGSCC-PASS-NEXT: Running pass: ModuleToPostOrderCGSCCPassAdaptor
; CHECK-CGSCC-PASS-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}>
; CHECK-CGSCC-PASS-NEXT: Running analysis: LazyCallGraphAnalysis ; CHECK-CGSCC-PASS-NEXT: Running analysis: LazyCallGraphAnalysis
; CHECK-CGSCC-PASS-NEXT: Running an SCC pass across the RefSCC: [(foo)] ; CHECK-CGSCC-PASS-NEXT: Running an SCC pass across the RefSCC: [(foo)]
; CHECK-CGSCC-PASS-NEXT: Starting llvm::LazyCallGraph::SCC pass manager run ; CHECK-CGSCC-PASS-NEXT: Starting llvm::LazyCallGraph::SCC pass manager run
; CHECK-CGSCC-PASS-NEXT: Running pass: NoOpCGSCCPass ; CHECK-CGSCC-PASS-NEXT: Running pass: NoOpCGSCCPass
; CHECK-CGSCC-PASS-NEXT: Finished llvm::LazyCallGraph::SCC pass manager run ; CHECK-CGSCC-PASS-NEXT: Finished llvm::LazyCallGraph::SCC pass manager run
; CHECK-CGSCC-PASS-NEXT: Finished llvm::Module pass manager run ; CHECK-CGSCC-PASS-NEXT: Finished llvm::Module pass manager run
; RUN: opt -disable-output -disable-verify -debug-pass-manager \ ; RUN: opt -disable-output -disable-verify -debug-pass-manager \
; RUN: -passes=no-op-function %s 2>&1 \ ; RUN: -passes=no-op-function %s 2>&1 \
; RUN: | FileCheck %s --check-prefix=CHECK-FUNCTION-PASS ; RUN: | FileCheck %s --check-prefix=CHECK-FUNCTION-PASS
; RUN: opt -disable-output -disable-verify -debug-pass-manager \ ; RUN: opt -disable-output -disable-verify -debug-pass-manager \
; RUN: -passes='function(no-op-function)' %s 2>&1 \ ; RUN: -passes='function(no-op-function)' %s 2>&1 \
; RUN: | FileCheck %s --check-prefix=CHECK-FUNCTION-PASS ; RUN: | FileCheck %s --check-prefix=CHECK-FUNCTION-PASS
; CHECK-FUNCTION-PASS: Starting llvm::Module pass manager run ; CHECK-FUNCTION-PASS: Starting llvm::Module pass manager run
; CHECK-FUNCTION-PASS-NEXT: Running pass: ModuleToFunctionPassAdaptor ; CHECK-FUNCTION-PASS-NEXT: Running pass: ModuleToFunctionPassAdaptor
; CHECK-FUNCTION-PASS-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}>
; CHECK-FUNCTION-PASS-NEXT: Starting llvm::Function pass manager run ; CHECK-FUNCTION-PASS-NEXT: Starting llvm::Function pass manager run
; CHECK-FUNCTION-PASS-NEXT: Running pass: NoOpFunctionPass ; CHECK-FUNCTION-PASS-NEXT: Running pass: NoOpFunctionPass
; CHECK-FUNCTION-PASS-NEXT: Finished llvm::Function pass manager run ; CHECK-FUNCTION-PASS-NEXT: Finished llvm::Function pass manager run
; CHECK-FUNCTION-PASS-NEXT: Finished llvm::Module pass manager run ; CHECK-FUNCTION-PASS-NEXT: Finished llvm::Module pass manager run
; RUN: opt -disable-output -debug-pass-manager -passes=print %s 2>&1 \ ; RUN: opt -disable-output -debug-pass-manager -passes=print %s 2>&1 \
; RUN: | FileCheck %s --check-prefix=CHECK-MODULE-PRINT ; RUN: | FileCheck %s --check-prefix=CHECK-MODULE-PRINT
; CHECK-MODULE-PRINT: Starting llvm::Module pass manager run ; CHECK-MODULE-PRINT: Starting llvm::Module pass manager run
Show All 13 Lines
; CHECK-MODULE-VERIFY: Running pass: VerifierPass ; CHECK-MODULE-VERIFY: Running pass: VerifierPass
; CHECK-MODULE-VERIFY: Finished llvm::Module pass manager run ; CHECK-MODULE-VERIFY: Finished llvm::Module pass manager run
; RUN: opt -disable-output -debug-pass-manager -passes='function(print)' %s 2>&1 \ ; RUN: opt -disable-output -debug-pass-manager -passes='function(print)' %s 2>&1 \
; RUN: | FileCheck %s --check-prefix=CHECK-FUNCTION-PRINT ; RUN: | FileCheck %s --check-prefix=CHECK-FUNCTION-PRINT
; CHECK-FUNCTION-PRINT: Starting llvm::Module pass manager run ; CHECK-FUNCTION-PRINT: Starting llvm::Module pass manager run
; CHECK-FUNCTION-PRINT: Running pass: VerifierPass ; CHECK-FUNCTION-PRINT: Running pass: VerifierPass
; CHECK-FUNCTION-PRINT: Running pass: ModuleToFunctionPassAdaptor ; CHECK-FUNCTION-PRINT: Running pass: ModuleToFunctionPassAdaptor
; CHECK-FUNCTION-PRINT: Running analysis: InnerAnalysisManagerProxy<{{.*}}>
; CHECK-FUNCTION-PRINT: Starting llvm::Function pass manager run ; CHECK-FUNCTION-PRINT: Starting llvm::Function pass manager run
; CHECK-FUNCTION-PRINT: Running pass: PrintFunctionPass ; CHECK-FUNCTION-PRINT: Running pass: PrintFunctionPass
; CHECK-FUNCTION-PRINT-NOT: ModuleID ; CHECK-FUNCTION-PRINT-NOT: ModuleID
; CHECK-FUNCTION-PRINT: define void @foo(i1 %x) ; CHECK-FUNCTION-PRINT: define void @foo(i1 %x)
; CHECK-FUNCTION-PRINT: Finished llvm::Function pass manager run ; CHECK-FUNCTION-PRINT: Finished llvm::Function pass manager run
; CHECK-FUNCTION-PRINT: Running pass: VerifierPass ; CHECK-FUNCTION-PRINT: Running pass: VerifierPass
; CHECK-FUNCTION-PRINT: Finished llvm::Module pass manager run ; CHECK-FUNCTION-PRINT: Finished llvm::Module pass manager run
▲ Show 20 Lines • Show All 306 Lines • ▼ Show 20 Lines
; CHECK-REPEAT-MODULE-PASS-NEXT: Finished llvm::Module pass manager run ; CHECK-REPEAT-MODULE-PASS-NEXT: Finished llvm::Module pass manager run
; CHECK-REPEAT-MODULE-PASS-NEXT: Finished llvm::Module pass manager run ; CHECK-REPEAT-MODULE-PASS-NEXT: Finished llvm::Module pass manager run
; RUN: opt -disable-output -disable-verify -debug-pass-manager \ ; RUN: opt -disable-output -disable-verify -debug-pass-manager \
; RUN: -passes='cgscc(repeat<3>(no-op-cgscc))' %s 2>&1 \ ; RUN: -passes='cgscc(repeat<3>(no-op-cgscc))' %s 2>&1 \
; RUN: | FileCheck %s --check-prefix=CHECK-REPEAT-CGSCC-PASS ; RUN: | FileCheck %s --check-prefix=CHECK-REPEAT-CGSCC-PASS
; CHECK-REPEAT-CGSCC-PASS: Starting llvm::Module pass manager run ; CHECK-REPEAT-CGSCC-PASS: Starting llvm::Module pass manager run
; CHECK-REPEAT-CGSCC-PASS-NEXT: Running pass: ModuleToPostOrderCGSCCPassAdaptor ; CHECK-REPEAT-CGSCC-PASS-NEXT: Running pass: ModuleToPostOrderCGSCCPassAdaptor
; CHECK-REPEAT-CGSCC-PASS-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}>
; CHECK-REPEAT-CGSCC-PASS-NEXT: Running analysis: LazyCallGraphAnalysis ; CHECK-REPEAT-CGSCC-PASS-NEXT: Running analysis: LazyCallGraphAnalysis
; CHECK-REPEAT-CGSCC-PASS-NEXT: Running an SCC pass across the RefSCC: [(foo)] ; CHECK-REPEAT-CGSCC-PASS-NEXT: Running an SCC pass across the RefSCC: [(foo)]
; CHECK-REPEAT-CGSCC-PASS-NEXT: Starting llvm::LazyCallGraph::SCC pass manager run ; CHECK-REPEAT-CGSCC-PASS-NEXT: Starting llvm::LazyCallGraph::SCC pass manager run
; CHECK-REPEAT-CGSCC-PASS-NEXT: Running pass: RepeatedPass ; CHECK-REPEAT-CGSCC-PASS-NEXT: Running pass: RepeatedPass
; CHECK-REPEAT-CGSCC-PASS-NEXT: Starting llvm::LazyCallGraph::SCC pass manager run ; CHECK-REPEAT-CGSCC-PASS-NEXT: Starting llvm::LazyCallGraph::SCC pass manager run
; CHECK-REPEAT-CGSCC-PASS-NEXT: Running pass: NoOpCGSCCPass ; CHECK-REPEAT-CGSCC-PASS-NEXT: Running pass: NoOpCGSCCPass
; CHECK-REPEAT-CGSCC-PASS-NEXT: Finished llvm::LazyCallGraph::SCC pass manager run ; CHECK-REPEAT-CGSCC-PASS-NEXT: Finished llvm::LazyCallGraph::SCC pass manager run
; CHECK-REPEAT-CGSCC-PASS-NEXT: Starting llvm::LazyCallGraph::SCC pass manager run ; CHECK-REPEAT-CGSCC-PASS-NEXT: Starting llvm::LazyCallGraph::SCC pass manager run
; CHECK-REPEAT-CGSCC-PASS-NEXT: Running pass: NoOpCGSCCPass ; CHECK-REPEAT-CGSCC-PASS-NEXT: Running pass: NoOpCGSCCPass
; CHECK-REPEAT-CGSCC-PASS-NEXT: Finished llvm::LazyCallGraph::SCC pass manager run ; CHECK-REPEAT-CGSCC-PASS-NEXT: Finished llvm::LazyCallGraph::SCC pass manager run
; CHECK-REPEAT-CGSCC-PASS-NEXT: Starting llvm::LazyCallGraph::SCC pass manager run ; CHECK-REPEAT-CGSCC-PASS-NEXT: Starting llvm::LazyCallGraph::SCC pass manager run
; CHECK-REPEAT-CGSCC-PASS-NEXT: Running pass: NoOpCGSCCPass ; CHECK-REPEAT-CGSCC-PASS-NEXT: Running pass: NoOpCGSCCPass
; CHECK-REPEAT-CGSCC-PASS-NEXT: Finished llvm::LazyCallGraph::SCC pass manager run ; CHECK-REPEAT-CGSCC-PASS-NEXT: Finished llvm::LazyCallGraph::SCC pass manager run
; CHECK-REPEAT-CGSCC-PASS-NEXT: Finished llvm::LazyCallGraph::SCC pass manager run ; CHECK-REPEAT-CGSCC-PASS-NEXT: Finished llvm::LazyCallGraph::SCC pass manager run
; CHECK-REPEAT-CGSCC-PASS-NEXT: Finished llvm::Module pass manager run ; CHECK-REPEAT-CGSCC-PASS-NEXT: Finished llvm::Module pass manager run
; RUN: opt -disable-output -disable-verify -debug-pass-manager \ ; RUN: opt -disable-output -disable-verify -debug-pass-manager \
; RUN: -passes='function(repeat<3>(no-op-function))' %s 2>&1 \ ; RUN: -passes='function(repeat<3>(no-op-function))' %s 2>&1 \
; RUN: | FileCheck %s --check-prefix=CHECK-REPEAT-FUNCTION-PASS ; RUN: | FileCheck %s --check-prefix=CHECK-REPEAT-FUNCTION-PASS
; CHECK-REPEAT-FUNCTION-PASS: Starting llvm::Module pass manager run ; CHECK-REPEAT-FUNCTION-PASS: Starting llvm::Module pass manager run
; CHECK-REPEAT-FUNCTION-PASS-NEXT: Running pass: ModuleToFunctionPassAdaptor ; CHECK-REPEAT-FUNCTION-PASS-NEXT: Running pass: ModuleToFunctionPassAdaptor
; CHECK-REPEAT-FUNCTION-PASS-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}>
; CHECK-REPEAT-FUNCTION-PASS-NEXT: Starting llvm::Function pass manager run ; CHECK-REPEAT-FUNCTION-PASS-NEXT: Starting llvm::Function pass manager run
; CHECK-REPEAT-FUNCTION-PASS-NEXT: Running pass: RepeatedPass ; CHECK-REPEAT-FUNCTION-PASS-NEXT: Running pass: RepeatedPass
; CHECK-REPEAT-FUNCTION-PASS-NEXT: Starting llvm::Function pass manager run ; CHECK-REPEAT-FUNCTION-PASS-NEXT: Starting llvm::Function pass manager run
; CHECK-REPEAT-FUNCTION-PASS-NEXT: Running pass: NoOpFunctionPass ; CHECK-REPEAT-FUNCTION-PASS-NEXT: Running pass: NoOpFunctionPass
; CHECK-REPEAT-FUNCTION-PASS-NEXT: Finished llvm::Function pass manager run ; CHECK-REPEAT-FUNCTION-PASS-NEXT: Finished llvm::Function pass manager run
; CHECK-REPEAT-FUNCTION-PASS-NEXT: Starting llvm::Function pass manager run ; CHECK-REPEAT-FUNCTION-PASS-NEXT: Starting llvm::Function pass manager run
; CHECK-REPEAT-FUNCTION-PASS-NEXT: Running pass: NoOpFunctionPass ; CHECK-REPEAT-FUNCTION-PASS-NEXT: Running pass: NoOpFunctionPass
; CHECK-REPEAT-FUNCTION-PASS-NEXT: Finished llvm::Function pass manager run ; CHECK-REPEAT-FUNCTION-PASS-NEXT: Finished llvm::Function pass manager run
; CHECK-REPEAT-FUNCTION-PASS-NEXT: Starting llvm::Function pass manager run ; CHECK-REPEAT-FUNCTION-PASS-NEXT: Starting llvm::Function pass manager run
; CHECK-REPEAT-FUNCTION-PASS-NEXT: Running pass: NoOpFunctionPass ; CHECK-REPEAT-FUNCTION-PASS-NEXT: Running pass: NoOpFunctionPass
; CHECK-REPEAT-FUNCTION-PASS-NEXT: Finished llvm::Function pass manager run ; CHECK-REPEAT-FUNCTION-PASS-NEXT: Finished llvm::Function pass manager run
; CHECK-REPEAT-FUNCTION-PASS-NEXT: Finished llvm::Function pass manager run ; CHECK-REPEAT-FUNCTION-PASS-NEXT: Finished llvm::Function pass manager run
; CHECK-REPEAT-FUNCTION-PASS-NEXT: Finished llvm::Module pass manager run ; CHECK-REPEAT-FUNCTION-PASS-NEXT: Finished llvm::Module pass manager run
; RUN: opt -disable-output -disable-verify -debug-pass-manager \ ; RUN: opt -disable-output -disable-verify -debug-pass-manager \
; RUN: -passes='loop(repeat<3>(no-op-loop))' %s 2>&1 \ ; RUN: -passes='loop(repeat<3>(no-op-loop))' %s 2>&1 \
; RUN: | FileCheck %s --check-prefix=CHECK-REPEAT-LOOP-PASS ; RUN: | FileCheck %s --check-prefix=CHECK-REPEAT-LOOP-PASS
; CHECK-REPEAT-LOOP-PASS: Starting llvm::Module pass manager run ; CHECK-REPEAT-LOOP-PASS: Starting llvm::Module pass manager run
; CHECK-REPEAT-LOOP-PASS-NEXT: Running pass: ModuleToFunctionPassAdaptor ; CHECK-REPEAT-LOOP-PASS-NEXT: Running pass: ModuleToFunctionPassAdaptor
; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}>
; CHECK-REPEAT-LOOP-PASS-NEXT: Starting llvm::Function pass manager run ; CHECK-REPEAT-LOOP-PASS-NEXT: Starting llvm::Function pass manager run
; CHECK-REPEAT-LOOP-PASS-NEXT: Running pass: FunctionToLoopPassAdaptor ; CHECK-REPEAT-LOOP-PASS-NEXT: Running pass: FunctionToLoopPassAdaptor
; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}>
; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: LoopAnalysis ; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: LoopAnalysis
; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: ParentIRUnitTrackingAnalysis<llvm::Module>
; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: DominatorTreeAnalysis ; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: DominatorTreeAnalysis
; CHECK-REPEAT-LOOP-PASS-NEXT: Starting llvm::Loop pass manager run ; CHECK-REPEAT-LOOP-PASS-NEXT: Starting llvm::Loop pass manager run
; CHECK-REPEAT-LOOP-PASS-NEXT: Running pass: RepeatedPass ; CHECK-REPEAT-LOOP-PASS-NEXT: Running pass: RepeatedPass
; CHECK-REPEAT-LOOP-PASS-NEXT: Starting llvm::Loop pass manager run ; CHECK-REPEAT-LOOP-PASS-NEXT: Starting llvm::Loop pass manager run
; CHECK-REPEAT-LOOP-PASS-NEXT: Running pass: NoOpLoopPass ; CHECK-REPEAT-LOOP-PASS-NEXT: Running pass: NoOpLoopPass
; CHECK-REPEAT-LOOP-PASS-NEXT: Finished llvm::Loop pass manager run ; CHECK-REPEAT-LOOP-PASS-NEXT: Finished llvm::Loop pass manager run
; CHECK-REPEAT-LOOP-PASS-NEXT: Starting llvm::Loop pass manager run ; CHECK-REPEAT-LOOP-PASS-NEXT: Starting llvm::Loop pass manager run
; CHECK-REPEAT-LOOP-PASS-NEXT: Running pass: NoOpLoopPass ; CHECK-REPEAT-LOOP-PASS-NEXT: Running pass: NoOpLoopPass
Show All 20 Lines

tools/opt/NewPMDriver.cpp

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Linesbool llvm::runPassPipeline(StringRef Arg0, LLVMContext &Context, Module &M,
// Specially handle the alias analysis manager so that we can register // Specially handle the alias analysis manager so that we can register
// a custom pipeline of AA passes with it. // a custom pipeline of AA passes with it.
AAManager AA; AAManager AA;
if (!PB.parseAAPipeline(AA, AAPipeline)) { if (!PB.parseAAPipeline(AA, AAPipeline)) {
errs() << Arg0 << ": unable to parse AA pipeline description.\n"; errs() << Arg0 << ": unable to parse AA pipeline description.\n";
return false; return false;
} }
LoopAnalysisManager LAM(DebugPM); AnalysisManager AM(DebugPM);
FunctionAnalysisManager FAM(DebugPM);
CGSCCAnalysisManager CGAM(DebugPM);
ModuleAnalysisManager MAM(DebugPM);
// Register the AA manager first so that our version is the one used. // Register the AA manager first so that our version is the one used.
FAM.registerPass([&] { return std::move(AA); }); AM.registerPass<Function>([&] { return std::move(AA); });
// Register all the basic analyses with the managers. // Register all the basic analyses with the managers.
PB.registerModuleAnalyses(MAM); PB.registerModuleAnalyses(AM);
PB.registerCGSCCAnalyses(CGAM); PB.registerCGSCCAnalyses(AM);
PB.registerFunctionAnalyses(FAM); PB.registerFunctionAnalyses(AM);
PB.registerLoopAnalyses(LAM); PB.registerLoopAnalyses(AM);
PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
ModulePassManager MPM(DebugPM); ModulePassManager MPM(DebugPM);
if (VK > VK_NoVerifier) if (VK > VK_NoVerifier)
MPM.addPass(VerifierPass()); MPM.addPass(VerifierPass());
if (!PB.parsePassPipeline(MPM, PassPipeline, VK == VK_VerifyEachPass, if (!PB.parsePassPipeline(MPM, PassPipeline, VK == VK_VerifyEachPass,
DebugPM)) { DebugPM)) {
errs() << Arg0 << ": unable to parse pass pipeline description.\n"; errs() << Arg0 << ": unable to parse pass pipeline description.\n";
Show All 16 Lines MPM.addPass(
BitcodeWriterPass(Out->os(), ShouldPreserveBitcodeUseListOrder)); BitcodeWriterPass(Out->os(), ShouldPreserveBitcodeUseListOrder));
break; break;
} }
// Before executing passes, print the final values of the LLVM options. // Before executing passes, print the final values of the LLVM options.
cl::PrintOptionValues(); cl::PrintOptionValues();
// Now that we have all of the passes ready, run them. // Now that we have all of the passes ready, run them.
MPM.run(M, MAM); MPM.run(M, AM);
// Declare success. // Declare success.
if (OK != OK_NoOutput) if (OK != OK_NoOutput)
Out->keep(); Out->keep();
return true; return true;
} }

unittests/Analysis/CGSCCPassManagerTest.cpp

Show All 28 Lines struct Result {
int FunctionCount; int FunctionCount;
}; };
static void *ID() { return (void *)&PassID; } static void *ID() { return (void *)&PassID; }
static StringRef name() { return "TestModuleAnalysis"; } static StringRef name() { return "TestModuleAnalysis"; }
TestModuleAnalysis(int &Runs) : Runs(Runs) {} TestModuleAnalysis(int &Runs) : Runs(Runs) {}
Result run(Module &M, ModuleAnalysisManager &AM) { Result run(Module &M, AnalysisManager &AM) {
++Runs; ++Runs;
return Result(M.size()); return Result(M.size());
} }
private: private:
static char PassID; static char PassID;
int &Runs; int &Runs;
}; };
char TestModuleAnalysis::PassID; char TestModuleAnalysis::PassID;
class TestSCCAnalysis { class TestSCCAnalysis {
public: public:
struct Result { struct Result {
Result(int Count) : FunctionCount(Count) {} Result(int Count) : FunctionCount(Count) {}
int FunctionCount; int FunctionCount;
}; };
static void *ID() { return (void *)&PassID; } static void *ID() { return (void *)&PassID; }
static StringRef name() { return "TestSCCAnalysis"; } static StringRef name() { return "TestSCCAnalysis"; }
TestSCCAnalysis(int &Runs) : Runs(Runs) {} TestSCCAnalysis(int &Runs) : Runs(Runs) {}
Result run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM) { Result run(LazyCallGraph::SCC &C, AnalysisManager &AM) {
++Runs; ++Runs;
return Result(C.size()); return Result(C.size());
} }
private: private:
static char PassID; static char PassID;
int &Runs; int &Runs;
}; };
char TestSCCAnalysis::PassID; char TestSCCAnalysis::PassID;
class TestFunctionAnalysis { class TestFunctionAnalysis {
public: public:
struct Result { struct Result {
Result(int Count) : InstructionCount(Count) {} Result(int Count) : InstructionCount(Count) {}
int InstructionCount; int InstructionCount;
}; };
static void *ID() { return (void *)&PassID; } static void *ID() { return (void *)&PassID; }
static StringRef name() { return "TestFunctionAnalysis"; } static StringRef name() { return "TestFunctionAnalysis"; }
TestFunctionAnalysis(int &Runs) : Runs(Runs) {} TestFunctionAnalysis(int &Runs) : Runs(Runs) {}
Result run(Function &F, FunctionAnalysisManager &AM) { Result run(Function &F, AnalysisManager &AM) {
++Runs; ++Runs;
int Count = 0; int Count = 0;
for (Instruction &I : instructions(F)) { for (Instruction &I : instructions(F)) {
(void)I; (void)I;
++Count; ++Count;
} }
return Result(Count); return Result(Count);
} }
Show All 12 Lines struct Result {
bool invalidate(Function &, const PreservedAnalyses &) { return false; } bool invalidate(Function &, const PreservedAnalyses &) { return false; }
}; };
static void *ID() { return (void *)&PassID; } static void *ID() { return (void *)&PassID; }
static StringRef name() { return "TestImmutableFunctionAnalysis"; } static StringRef name() { return "TestImmutableFunctionAnalysis"; }
TestImmutableFunctionAnalysis(int &Runs) : Runs(Runs) {} TestImmutableFunctionAnalysis(int &Runs) : Runs(Runs) {}
Result run(Function &F, FunctionAnalysisManager &AM) { Result run(Function &F, AnalysisManager &AM) {
++Runs; ++Runs;
return Result(); return Result();
} }
private: private:
static char PassID; static char PassID;
int &Runs; int &Runs;
}; };
char TestImmutableFunctionAnalysis::PassID; char TestImmutableFunctionAnalysis::PassID;
struct TestModulePass { struct TestModulePass {
TestModulePass(int &RunCount) : RunCount(RunCount) {} TestModulePass(int &RunCount) : RunCount(RunCount) {}
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM) { PreservedAnalyses run(Module &M, AnalysisManager &AM) {
++RunCount; ++RunCount;
(void)AM.getResult<TestModuleAnalysis>(M); (void)AM.getResult<TestModuleAnalysis>(M);
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
static StringRef name() { return "TestModulePass"; } static StringRef name() { return "TestModulePass"; }
int &RunCount; int &RunCount;
}; };
struct TestSCCPass { struct TestSCCPass {
TestSCCPass(int &RunCount, int &AnalyzedInstrCount, TestSCCPass(int &RunCount, int &AnalyzedInstrCount,
int &AnalyzedSCCFunctionCount, int &AnalyzedModuleFunctionCount, int &AnalyzedSCCFunctionCount, int &AnalyzedModuleFunctionCount,
bool OnlyUseCachedResults = false) bool OnlyUseCachedResults = false)
: RunCount(RunCount), AnalyzedInstrCount(AnalyzedInstrCount), : RunCount(RunCount), AnalyzedInstrCount(AnalyzedInstrCount),
AnalyzedSCCFunctionCount(AnalyzedSCCFunctionCount), AnalyzedSCCFunctionCount(AnalyzedSCCFunctionCount),
AnalyzedModuleFunctionCount(AnalyzedModuleFunctionCount), AnalyzedModuleFunctionCount(AnalyzedModuleFunctionCount),
OnlyUseCachedResults(OnlyUseCachedResults) {} OnlyUseCachedResults(OnlyUseCachedResults) {}
PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM) { PreservedAnalyses run(LazyCallGraph::SCC &C, AnalysisManager &AM) {
++RunCount; ++RunCount;
const ModuleAnalysisManager &MAM =
AM.getResult<ModuleAnalysisManagerCGSCCProxy>(C).getManager();
FunctionAnalysisManager &FAM =
AM.getResult<FunctionAnalysisManagerCGSCCProxy>(C).getManager();
if (TestModuleAnalysis::Result *TMA = if (TestModuleAnalysis::Result *TMA =
MAM.getCachedResult<TestModuleAnalysis>( AM.getCachedResult<TestModuleAnalysis>(
*C.begin()->getFunction().getParent())) *C.begin()->getFunction().getParent()))
AnalyzedModuleFunctionCount += TMA->FunctionCount; AnalyzedModuleFunctionCount += TMA->FunctionCount;
if (OnlyUseCachedResults) { if (OnlyUseCachedResults) {
// Hack to force the use of the cached interface. // Hack to force the use of the cached interface.
if (TestSCCAnalysis::Result *AR = AM.getCachedResult<TestSCCAnalysis>(C)) if (TestSCCAnalysis::Result *AR = AM.getCachedResult<TestSCCAnalysis>(C))
AnalyzedSCCFunctionCount += AR->FunctionCount; AnalyzedSCCFunctionCount += AR->FunctionCount;
for (LazyCallGraph::Node &N : C) for (LazyCallGraph::Node &N : C)
if (TestFunctionAnalysis::Result *FAR = if (TestFunctionAnalysis::Result *FAR =
FAM.getCachedResult<TestFunctionAnalysis>(N.getFunction())) AM.getCachedResult<TestFunctionAnalysis>(N.getFunction()))
AnalyzedInstrCount += FAR->InstructionCount; AnalyzedInstrCount += FAR->InstructionCount;
} else { } else {
// Typical path just runs the analysis as needed. // Typical path just runs the analysis as needed.
TestSCCAnalysis::Result &AR = AM.getResult<TestSCCAnalysis>(C); TestSCCAnalysis::Result &AR = AM.getResult<TestSCCAnalysis>(C);
AnalyzedSCCFunctionCount += AR.FunctionCount; AnalyzedSCCFunctionCount += AR.FunctionCount;
for (LazyCallGraph::Node &N : C) { for (LazyCallGraph::Node &N : C) {
TestFunctionAnalysis::Result &FAR = TestFunctionAnalysis::Result &FAR =
FAM.getResult<TestFunctionAnalysis>(N.getFunction()); AM.getResult<TestFunctionAnalysis>(N.getFunction());
AnalyzedInstrCount += FAR.InstructionCount; AnalyzedInstrCount += FAR.InstructionCount;
// Just ensure we get the immutable results. // Just ensure we get the immutable results.
(void)FAM.getResult<TestImmutableFunctionAnalysis>(N.getFunction()); (void)AM.getResult<TestImmutableFunctionAnalysis>(N.getFunction());
} }
} }
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
static StringRef name() { return "TestSCCPass"; } static StringRef name() { return "TestSCCPass"; }
int &RunCount; int &RunCount;
int &AnalyzedInstrCount; int &AnalyzedInstrCount;
int &AnalyzedSCCFunctionCount; int &AnalyzedSCCFunctionCount;
int &AnalyzedModuleFunctionCount; int &AnalyzedModuleFunctionCount;
bool OnlyUseCachedResults; bool OnlyUseCachedResults;
}; };
struct TestFunctionPass { struct TestFunctionPass {
TestFunctionPass(int &RunCount) : RunCount(RunCount) {} TestFunctionPass(int &RunCount) : RunCount(RunCount) {}
PreservedAnalyses run(Function &F, AnalysisManager<Function> &) { PreservedAnalyses run(Function &F, AnalysisManager &) {
++RunCount; ++RunCount;
return PreservedAnalyses::none(); return PreservedAnalyses::none();
} }
static StringRef name() { return "TestFunctionPass"; } static StringRef name() { return "TestFunctionPass"; }
int &RunCount; int &RunCount;
}; };
Show All 35 Lines auto M = parseIR("define void @f() {\n"
"entry:\n" "entry:\n"
" call void @h1()\n" " call void @h1()\n"
" ret void\n" " ret void\n"
"}\n" "}\n"
"define void @x() {\n" "define void @x() {\n"
"entry:\n" "entry:\n"
" ret void\n" " ret void\n"
"}\n"); "}\n");
FunctionAnalysisManager FAM(/*DebugLogging*/ true); AnalysisManager AM(/*DebugLogging*/ true);
AM.registerPass<Module>(
[&] { return ParentIRUnitTrackingAnalysis<Module>(); });
AM.registerPass<LazyCallGraph::SCC>(
[&] { return ParentIRUnitTrackingAnalysis<LazyCallGraph::SCC>(); });
AM.registerPass<Function>(
[&] { return ParentIRUnitTrackingAnalysis<Function>(); });
int FunctionAnalysisRuns = 0; int FunctionAnalysisRuns = 0;
FAM.registerPass([&] { return TestFunctionAnalysis(FunctionAnalysisRuns); }); AM.registerPass<Function>(
[&] { return TestFunctionAnalysis(FunctionAnalysisRuns); });
int ImmutableFunctionAnalysisRuns = 0; int ImmutableFunctionAnalysisRuns = 0;
FAM.registerPass([&] { AM.registerPass<Function>([&] {
return TestImmutableFunctionAnalysis(ImmutableFunctionAnalysisRuns); return TestImmutableFunctionAnalysis(ImmutableFunctionAnalysisRuns);
}); });
CGSCCAnalysisManager CGAM(/*DebugLogging*/ true);
int SCCAnalysisRuns = 0; int SCCAnalysisRuns = 0;
CGAM.registerPass([&] { return TestSCCAnalysis(SCCAnalysisRuns); }); AM.registerPass<LazyCallGraph::SCC>(
[&] { return TestSCCAnalysis(SCCAnalysisRuns); });
ModuleAnalysisManager MAM(/*DebugLogging*/ true);
int ModuleAnalysisRuns = 0; int ModuleAnalysisRuns = 0;
MAM.registerPass([&] { return LazyCallGraphAnalysis(); }); AM.registerPass<Module>([&] { return LazyCallGraphAnalysis(); });
MAM.registerPass([&] { return TestModuleAnalysis(ModuleAnalysisRuns); }); AM.registerPass<Module>(
[&] { return TestModuleAnalysis(ModuleAnalysisRuns); });
MAM.registerPass([&] { return FunctionAnalysisManagerModuleProxy(FAM); });
MAM.registerPass([&] { return CGSCCAnalysisManagerModuleProxy(CGAM); });
CGAM.registerPass([&] { return FunctionAnalysisManagerCGSCCProxy(FAM); });
CGAM.registerPass([&] { return ModuleAnalysisManagerCGSCCProxy(MAM); });
FAM.registerPass([&] { return CGSCCAnalysisManagerFunctionProxy(CGAM); });
FAM.registerPass([&] { return ModuleAnalysisManagerFunctionProxy(MAM); });
ModulePassManager MPM(/*DebugLogging*/ true); ModulePassManager MPM(/*DebugLogging*/ true);
int ModulePassRunCount1 = 0; int ModulePassRunCount1 = 0;
MPM.addPass(TestModulePass(ModulePassRunCount1)); MPM.addPass(TestModulePass(ModulePassRunCount1));
CGSCCPassManager CGPM1(/*DebugLogging*/ true); CGSCCPassManager CGPM1(/*DebugLogging*/ true);
int SCCPassRunCount1 = 0; int SCCPassRunCount1 = 0;
int AnalyzedInstrCount1 = 0; int AnalyzedInstrCount1 = 0;
int AnalyzedSCCFunctionCount1 = 0; int AnalyzedSCCFunctionCount1 = 0;
int AnalyzedModuleFunctionCount1 = 0; int AnalyzedModuleFunctionCount1 = 0;
CGPM1.addPass(TestSCCPass(SCCPassRunCount1, AnalyzedInstrCount1, CGPM1.addPass(TestSCCPass(SCCPassRunCount1, AnalyzedInstrCount1,
AnalyzedSCCFunctionCount1, AnalyzedSCCFunctionCount1,
AnalyzedModuleFunctionCount1)); AnalyzedModuleFunctionCount1));
FunctionPassManager FPM1(/*DebugLogging*/ true); FunctionPassManager FPM1(/*DebugLogging*/ true);
int FunctionPassRunCount1 = 0; int FunctionPassRunCount1 = 0;
FPM1.addPass(TestFunctionPass(FunctionPassRunCount1)); FPM1.addPass(TestFunctionPass(FunctionPassRunCount1));
CGPM1.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM1))); CGPM1.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM1)));
MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM1))); MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM1)));
MPM.run(*M, MAM); MPM.run(*M, AM);
EXPECT_EQ(1, ModulePassRunCount1); EXPECT_EQ(1, ModulePassRunCount1);
EXPECT_EQ(1, ModuleAnalysisRuns); EXPECT_EQ(1, ModuleAnalysisRuns);
EXPECT_EQ(4, SCCAnalysisRuns); EXPECT_EQ(4, SCCAnalysisRuns);
EXPECT_EQ(6, FunctionAnalysisRuns); EXPECT_EQ(6, FunctionAnalysisRuns);
EXPECT_EQ(6, ImmutableFunctionAnalysisRuns); EXPECT_EQ(6, ImmutableFunctionAnalysisRuns);
EXPECT_EQ(4, SCCPassRunCount1); EXPECT_EQ(4, SCCPassRunCount1);
EXPECT_EQ(14, AnalyzedInstrCount1); EXPECT_EQ(14, AnalyzedInstrCount1);
EXPECT_EQ(6, AnalyzedSCCFunctionCount1); EXPECT_EQ(6, AnalyzedSCCFunctionCount1);
EXPECT_EQ(4 * 6, AnalyzedModuleFunctionCount1); EXPECT_EQ(4 * 6, AnalyzedModuleFunctionCount1);
} }
} }

unittests/Analysis/LoopPassManagerTest.cpp

Show All 36 Linespublic:
static void *ID() { return (void *)&PassID; } static void *ID() { return (void *)&PassID; }
/// \brief Returns the name of the analysis. /// \brief Returns the name of the analysis.
static StringRef name() { return "TestLoopAnalysis"; } static StringRef name() { return "TestLoopAnalysis"; }
TestLoopAnalysis(int &Runs) : Runs(Runs) {} TestLoopAnalysis(int &Runs) : Runs(Runs) {}
/// \brief Run the analysis pass over the loop and return a result. /// \brief Run the analysis pass over the loop and return a result.
Result run(Loop &L, AnalysisManager<Loop> &AM) { Result run(Loop &L, AnalysisManager &AM) {
++Runs; ++Runs;
int Count = 0; int Count = 0;
for (auto I = L.block_begin(), E = L.block_end(); I != E; ++I) for (auto I = L.block_begin(), E = L.block_end(); I != E; ++I)
++Count; ++Count;
return Result(Count); return Result(Count);
} }
}; };
char TestLoopAnalysis::PassID; char TestLoopAnalysis::PassID;
class TestLoopPass { class TestLoopPass {
std::vector<StringRef> &VisitedLoops; std::vector<StringRef> &VisitedLoops;
int &AnalyzedBlockCount; int &AnalyzedBlockCount;
bool OnlyUseCachedResults; bool OnlyUseCachedResults;
public: public:
TestLoopPass(std::vector<StringRef> &VisitedLoops, int &AnalyzedBlockCount, TestLoopPass(std::vector<StringRef> &VisitedLoops, int &AnalyzedBlockCount,
bool OnlyUseCachedResults = false) bool OnlyUseCachedResults = false)
: VisitedLoops(VisitedLoops), AnalyzedBlockCount(AnalyzedBlockCount), : VisitedLoops(VisitedLoops), AnalyzedBlockCount(AnalyzedBlockCount),
OnlyUseCachedResults(OnlyUseCachedResults) {} OnlyUseCachedResults(OnlyUseCachedResults) {}
PreservedAnalyses run(Loop &L, AnalysisManager<Loop> &AM) { PreservedAnalyses run(Loop &L, AnalysisManager &AM) {
VisitedLoops.push_back(L.getName()); VisitedLoops.push_back(L.getName());
if (OnlyUseCachedResults) { if (OnlyUseCachedResults) {
// Hack to force the use of the cached interface. // Hack to force the use of the cached interface.
if (auto *AR = AM.getCachedResult<TestLoopAnalysis>(L)) if (auto *AR = AM.getCachedResult<TestLoopAnalysis>(L))
AnalyzedBlockCount += AR->BlockCount; AnalyzedBlockCount += AR->BlockCount;
} else { } else {
// Typical path just runs the analysis as needed. // Typical path just runs the analysis as needed.
Show All 9 Lines
// A test loop pass that invalidates the analysis for loops with the given name. // A test loop pass that invalidates the analysis for loops with the given name.
class TestLoopInvalidatingPass { class TestLoopInvalidatingPass {
StringRef Name; StringRef Name;
public: public:
TestLoopInvalidatingPass(StringRef LoopName) : Name(LoopName) {} TestLoopInvalidatingPass(StringRef LoopName) : Name(LoopName) {}
PreservedAnalyses run(Loop &L, AnalysisManager<Loop> &AM) { PreservedAnalyses run(Loop &L, AnalysisManager &AM) {
return L.getName() == Name ? getLoopPassPreservedAnalyses() return L.getName() == Name ? getLoopPassPreservedAnalyses()
: PreservedAnalyses::all(); : PreservedAnalyses::all();
} }
static StringRef name() { return "TestLoopInvalidatingPass"; } static StringRef name() { return "TestLoopInvalidatingPass"; }
}; };
std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) { std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) {
Show All 36 Lines do { \
EXPECT_EQ(N##UL, ACTUAL.size()); \ EXPECT_EQ(N##UL, ACTUAL.size()); \
for (int I = 0; I < N; ++I) \ for (int I = 0; I < N; ++I) \
EXPECT_TRUE(EXPECTED[I] == ACTUAL[I]) << "Element " << I << " is " \ EXPECT_TRUE(EXPECTED[I] == ACTUAL[I]) << "Element " << I << " is " \
<< ACTUAL[I] << ". Expected " \ << ACTUAL[I] << ". Expected " \
<< EXPECTED[I] << "."; \ << EXPECTED[I] << "."; \
} while (0) } while (0)
TEST_F(LoopPassManagerTest, Basic) { TEST_F(LoopPassManagerTest, Basic) {
LoopAnalysisManager LAM(true); AnalysisManager AM(true);
AM.registerPass<Module>(
[&] { return ParentIRUnitTrackingAnalysis<Module>(); });
AM.registerPass<Function>(
[&] { return ParentIRUnitTrackingAnalysis<Function>(); });
AM.registerPass<Loop>(
[&] { return ParentIRUnitTrackingAnalysis<Loop>(); });
int LoopAnalysisRuns = 0; int LoopAnalysisRuns = 0;
LAM.registerPass([&] { return TestLoopAnalysis(LoopAnalysisRuns); }); AM.registerPass<Loop>([&] { return TestLoopAnalysis(LoopAnalysisRuns); });
FunctionAnalysisManager FAM(true);
// We need DominatorTreeAnalysis for LoopAnalysis. // We need DominatorTreeAnalysis for LoopAnalysis.
FAM.registerPass([&] { return DominatorTreeAnalysis(); }); AM.registerPass<Function>([&] { return DominatorTreeAnalysis(); });
FAM.registerPass([&] { return LoopAnalysis(); }); AM.registerPass<Function>([&] { return LoopAnalysis(); });
FAM.registerPass([&] { return LoopAnalysisManagerFunctionProxy(LAM); });
LAM.registerPass([&] { return FunctionAnalysisManagerLoopProxy(FAM); });
ModuleAnalysisManager MAM(true);
MAM.registerPass([&] { return FunctionAnalysisManagerModuleProxy(FAM); });
FAM.registerPass([&] { return ModuleAnalysisManagerFunctionProxy(MAM); });
ModulePassManager MPM(true); ModulePassManager MPM(true);
FunctionPassManager FPM(true); FunctionPassManager FPM(true);
// Visit all of the loops. // Visit all of the loops.
std::vector<StringRef> VisitedLoops1; std::vector<StringRef> VisitedLoops1;
int AnalyzedBlockCount1 = 0; int AnalyzedBlockCount1 = 0;
{ {
Show All 11 Lines int AnalyzedBlockCount2 = 0;
LPM.addPass(TestLoopInvalidatingPass("loop.g.0")); LPM.addPass(TestLoopInvalidatingPass("loop.g.0"));
LPM.addPass(TestLoopPass(VisitedLoops2, AnalyzedBlockCount2, LPM.addPass(TestLoopPass(VisitedLoops2, AnalyzedBlockCount2,
/*OnlyUseCachedResults=*/true)); /*OnlyUseCachedResults=*/true));
FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM))); FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM)));
} }
MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM))); MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
MPM.run(*M, MAM); MPM.run(*M, AM);
StringRef ExpectedLoops[] = {"loop.0.0", "loop.0.1", "loop.0", "loop.g.0"}; StringRef ExpectedLoops[] = {"loop.0.0", "loop.0.1", "loop.0", "loop.g.0"};
// Validate the counters and order of loops visited. // Validate the counters and order of loops visited.
// loop.0 has 3 blocks whereas loop.0.0, loop.0.1, and loop.g.0 each have 1. // loop.0 has 3 blocks whereas loop.0.0, loop.0.1, and loop.g.0 each have 1.
EXPECT_N_ELEMENTS_EQ(4, ExpectedLoops, VisitedLoops1); EXPECT_N_ELEMENTS_EQ(4, ExpectedLoops, VisitedLoops1);
EXPECT_EQ(6, AnalyzedBlockCount1); EXPECT_EQ(6, AnalyzedBlockCount1);
Show All 9 Lines

unittests/IR/PassManagerTest.cpp

Show All 23 Linespublic:
struct Result { struct Result {
Result(int Count) : InstructionCount(Count) {} Result(int Count) : InstructionCount(Count) {}
int InstructionCount; int InstructionCount;
}; };
TestFunctionAnalysis(int &Runs) : Runs(Runs) {} TestFunctionAnalysis(int &Runs) : Runs(Runs) {}
/// \brief Run the analysis pass over the function and return a result. /// \brief Run the analysis pass over the function and return a result.
Result run(Function &F, FunctionAnalysisManager &AM) { Result run(Function &F, AnalysisManager &AM) {
++Runs; ++Runs;
int Count = 0; int Count = 0;
for (Function::iterator BBI = F.begin(), BBE = F.end(); BBI != BBE; ++BBI) for (Function::iterator BBI = F.begin(), BBE = F.end(); BBI != BBE; ++BBI)
for (BasicBlock::iterator II = BBI->begin(), IE = BBI->end(); II != IE; for (BasicBlock::iterator II = BBI->begin(), IE = BBI->end(); II != IE;
++II) ++II)
++Count; ++Count;
return Result(Count); return Result(Count);
} }
Show All 11 Lines
public: public:
struct Result { struct Result {
Result(int Count) : FunctionCount(Count) {} Result(int Count) : FunctionCount(Count) {}
int FunctionCount; int FunctionCount;
}; };
TestModuleAnalysis(int &Runs) : Runs(Runs) {} TestModuleAnalysis(int &Runs) : Runs(Runs) {}
Result run(Module &M, ModuleAnalysisManager &AM) { Result run(Module &M, AnalysisManager &AM) {
++Runs; ++Runs;
int Count = 0; int Count = 0;
for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
++Count; ++Count;
return Result(Count); return Result(Count);
} }
private: private:
friend AnalysisInfoMixin<TestModuleAnalysis>; friend AnalysisInfoMixin<TestModuleAnalysis>;
static char PassID; static char PassID;
int &Runs; int &Runs;
}; };
char TestModuleAnalysis::PassID; char TestModuleAnalysis::PassID;
struct TestModulePass : PassInfoMixin<TestModulePass> { struct TestModulePass : PassInfoMixin<TestModulePass> {
TestModulePass(int &RunCount) : RunCount(RunCount) {} TestModulePass(int &RunCount) : RunCount(RunCount) {}
PreservedAnalyses run(Module &M, ModuleAnalysisManager &) { PreservedAnalyses run(Module &M, AnalysisManager &) {
++RunCount; ++RunCount;
return PreservedAnalyses::none(); return PreservedAnalyses::none();
} }
int &RunCount; int &RunCount;
}; };
struct TestPreservingModulePass : PassInfoMixin<TestPreservingModulePass> { struct TestPreservingModulePass : PassInfoMixin<TestPreservingModulePass> {
PreservedAnalyses run(Module &M, ModuleAnalysisManager &) { PreservedAnalyses run(Module &M, AnalysisManager &) {
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
}; };
struct TestMinPreservingModulePass struct TestMinPreservingModulePass
: PassInfoMixin<TestMinPreservingModulePass> { : PassInfoMixin<TestMinPreservingModulePass> {
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM) { PreservedAnalyses run(Module &M, AnalysisManager &AM) {
PreservedAnalyses PA; PreservedAnalyses PA;
// Force running an analysis. // Force running an analysis.
(void)AM.getResult<TestModuleAnalysis>(M); (void)AM.getResult<TestModuleAnalysis>(M);
PA.preserve<FunctionAnalysisManagerModuleProxy>(); PA.preserve<ParentIRUnitTrackingAnalysis<Module>>();
return PA; return PA;
} }
}; };
struct TestFunctionPass : PassInfoMixin<TestFunctionPass> { struct TestFunctionPass : PassInfoMixin<TestFunctionPass> {
TestFunctionPass(int &RunCount, int &AnalyzedInstrCount, TestFunctionPass(int &RunCount, int &AnalyzedInstrCount,
int &AnalyzedFunctionCount, int &AnalyzedFunctionCount,
bool OnlyUseCachedResults = false) bool OnlyUseCachedResults = false)
: RunCount(RunCount), AnalyzedInstrCount(AnalyzedInstrCount), : RunCount(RunCount), AnalyzedInstrCount(AnalyzedInstrCount),
AnalyzedFunctionCount(AnalyzedFunctionCount), AnalyzedFunctionCount(AnalyzedFunctionCount),
OnlyUseCachedResults(OnlyUseCachedResults) {} OnlyUseCachedResults(OnlyUseCachedResults) {}
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM) { PreservedAnalyses run(Function &F, AnalysisManager &AM) {
++RunCount; ++RunCount;
const ModuleAnalysisManager &MAM =
AM.getResult<ModuleAnalysisManagerFunctionProxy>(F).getManager();
if (TestModuleAnalysis::Result *TMA = if (TestModuleAnalysis::Result *TMA =
MAM.getCachedResult<TestModuleAnalysis>(*F.getParent())) AM.getCachedResult<TestModuleAnalysis>(*F.getParent()))
AnalyzedFunctionCount += TMA->FunctionCount; AnalyzedFunctionCount += TMA->FunctionCount;
if (OnlyUseCachedResults) { if (OnlyUseCachedResults) {
// Hack to force the use of the cached interface. // Hack to force the use of the cached interface.
if (TestFunctionAnalysis::Result *AR = if (TestFunctionAnalysis::Result *AR =
AM.getCachedResult<TestFunctionAnalysis>(F)) AM.getCachedResult<TestFunctionAnalysis>(F))
AnalyzedInstrCount += AR->InstructionCount; AnalyzedInstrCount += AR->InstructionCount;
} else { } else {
Show All 12 Lines
}; };
// A test function pass that invalidates all function analyses for a function // A test function pass that invalidates all function analyses for a function
// with a specific name. // with a specific name.
struct TestInvalidationFunctionPass struct TestInvalidationFunctionPass
: PassInfoMixin<TestInvalidationFunctionPass> { : PassInfoMixin<TestInvalidationFunctionPass> {
TestInvalidationFunctionPass(StringRef FunctionName) : Name(FunctionName) {} TestInvalidationFunctionPass(StringRef FunctionName) : Name(FunctionName) {}
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM) { PreservedAnalyses run(Function &F, AnalysisManager &AM) {
return F.getName() == Name ? PreservedAnalyses::none() return F.getName() == Name ? PreservedAnalyses::none()
: PreservedAnalyses::all(); : PreservedAnalyses::all();
} }
StringRef Name; StringRef Name;
}; };
std::unique_ptr<Module> parseIR(LLVMContext &Context, const char *IR) { std::unique_ptr<Module> parseIR(LLVMContext &Context, const char *IR) {
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 LinesTEST_F(PassManagerTest, BasicPreservedAnalyses) {
EXPECT_TRUE(PA1.preserved<TestFunctionAnalysis>()); EXPECT_TRUE(PA1.preserved<TestFunctionAnalysis>());
EXPECT_TRUE(PA1.preserved<TestModuleAnalysis>()); EXPECT_TRUE(PA1.preserved<TestModuleAnalysis>());
PA1.intersect(PA4); PA1.intersect(PA4);
EXPECT_TRUE(PA1.preserved<TestFunctionAnalysis>()); EXPECT_TRUE(PA1.preserved<TestFunctionAnalysis>());
EXPECT_FALSE(PA1.preserved<TestModuleAnalysis>()); EXPECT_FALSE(PA1.preserved<TestModuleAnalysis>());
} }
TEST_F(PassManagerTest, Basic) { TEST_F(PassManagerTest, Basic) {
FunctionAnalysisManager FAM; AnalysisManager AM(true);
AM.registerPass<Module>(
[&] { return ParentIRUnitTrackingAnalysis<Module>(); });
int FunctionAnalysisRuns = 0; int FunctionAnalysisRuns = 0;
FAM.registerPass([&] { return TestFunctionAnalysis(FunctionAnalysisRuns); }); AM.registerPass<Function>(
[&] { return TestFunctionAnalysis(FunctionAnalysisRuns); });
ModuleAnalysisManager MAM;
int ModuleAnalysisRuns = 0; int ModuleAnalysisRuns = 0;
MAM.registerPass([&] { return TestModuleAnalysis(ModuleAnalysisRuns); }); AM.registerPass<Module>(
MAM.registerPass([&] { return FunctionAnalysisManagerModuleProxy(FAM); }); [&] { return TestModuleAnalysis(ModuleAnalysisRuns); });
FAM.registerPass([&] { return ModuleAnalysisManagerFunctionProxy(MAM); });
ModulePassManager MPM; ModulePassManager MPM(true);
// Count the runs over a Function. // Count the runs over a Function.
int FunctionPassRunCount1 = 0; int FunctionPassRunCount1 = 0;
int AnalyzedInstrCount1 = 0; int AnalyzedInstrCount1 = 0;
int AnalyzedFunctionCount1 = 0; int AnalyzedFunctionCount1 = 0;
{ {
// Pointless scoped copy to test move assignment. // Pointless scoped copy to test move assignment.
ModulePassManager NestedMPM; ModulePassManager NestedMPM(true);
FunctionPassManager FPM; FunctionPassManager FPM(true);
{ {
// Pointless scope to test move assignment. // Pointless scope to test move assignment.
FunctionPassManager NestedFPM; FunctionPassManager NestedFPM(true);
NestedFPM.addPass(TestFunctionPass( NestedFPM.addPass(TestFunctionPass(
FunctionPassRunCount1, AnalyzedInstrCount1, AnalyzedFunctionCount1)); FunctionPassRunCount1, AnalyzedInstrCount1, AnalyzedFunctionCount1));
FPM = std::move(NestedFPM); FPM = std::move(NestedFPM);
} }
NestedMPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM))); NestedMPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
MPM = std::move(NestedMPM); MPM = std::move(NestedMPM);
} }
// Count the runs over a module. // Count the runs over a module.
int ModulePassRunCount = 0; int ModulePassRunCount = 0;
MPM.addPass(TestModulePass(ModulePassRunCount)); MPM.addPass(TestModulePass(ModulePassRunCount));
// Count the runs over a Function in a separate manager. // Count the runs over a Function in a separate manager.
int FunctionPassRunCount2 = 0; int FunctionPassRunCount2 = 0;
int AnalyzedInstrCount2 = 0; int AnalyzedInstrCount2 = 0;
int AnalyzedFunctionCount2 = 0; int AnalyzedFunctionCount2 = 0;
{ {
FunctionPassManager FPM; FunctionPassManager FPM(true);
FPM.addPass(TestFunctionPass(FunctionPassRunCount2, AnalyzedInstrCount2, FPM.addPass(TestFunctionPass(FunctionPassRunCount2, AnalyzedInstrCount2,
AnalyzedFunctionCount2)); AnalyzedFunctionCount2));
MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM))); MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
} }
// A third function pass manager but with only preserving intervening passes // A third function pass manager but with only preserving intervening passes
// and with a function pass that invalidates exactly one analysis. // and with a function pass that invalidates exactly one analysis.
MPM.addPass(TestPreservingModulePass()); MPM.addPass(TestPreservingModulePass());
int FunctionPassRunCount3 = 0; int FunctionPassRunCount3 = 0;
int AnalyzedInstrCount3 = 0; int AnalyzedInstrCount3 = 0;
int AnalyzedFunctionCount3 = 0; int AnalyzedFunctionCount3 = 0;
{ {
FunctionPassManager FPM; FunctionPassManager FPM(true);
FPM.addPass(TestFunctionPass(FunctionPassRunCount3, AnalyzedInstrCount3, FPM.addPass(TestFunctionPass(FunctionPassRunCount3, AnalyzedInstrCount3,
AnalyzedFunctionCount3)); AnalyzedFunctionCount3));
FPM.addPass(TestInvalidationFunctionPass("f")); FPM.addPass(TestInvalidationFunctionPass("f"));
MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM))); MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
} }
// A fourth function pass manager but with a minimal intervening passes. // A fourth function pass manager but with a minimal intervening passes.
MPM.addPass(TestMinPreservingModulePass()); MPM.addPass(TestMinPreservingModulePass());
int FunctionPassRunCount4 = 0; int FunctionPassRunCount4 = 0;
int AnalyzedInstrCount4 = 0; int AnalyzedInstrCount4 = 0;
int AnalyzedFunctionCount4 = 0; int AnalyzedFunctionCount4 = 0;
{ {
FunctionPassManager FPM; FunctionPassManager FPM(true);
FPM.addPass(TestFunctionPass(FunctionPassRunCount4, AnalyzedInstrCount4, FPM.addPass(TestFunctionPass(FunctionPassRunCount4, AnalyzedInstrCount4,
AnalyzedFunctionCount4)); AnalyzedFunctionCount4));
MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM))); MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
} }
// A fifth function pass manager but which uses only cached results. // A fifth function pass manager but which uses only cached results.
int FunctionPassRunCount5 = 0; int FunctionPassRunCount5 = 0;
int AnalyzedInstrCount5 = 0; int AnalyzedInstrCount5 = 0;
int AnalyzedFunctionCount5 = 0; int AnalyzedFunctionCount5 = 0;
{ {
FunctionPassManager FPM; FunctionPassManager FPM(true);
FPM.addPass(TestInvalidationFunctionPass("f")); FPM.addPass(TestInvalidationFunctionPass("f"));
FPM.addPass(TestFunctionPass(FunctionPassRunCount5, AnalyzedInstrCount5, FPM.addPass(TestFunctionPass(FunctionPassRunCount5, AnalyzedInstrCount5,
AnalyzedFunctionCount5, AnalyzedFunctionCount5,
/*OnlyUseCachedResults=*/true)); /*OnlyUseCachedResults=*/true));
MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM))); MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
} }
MPM.run(*M, MAM); MPM.run(*M, AM);
// Validate module pass counters. // Validate module pass counters.
EXPECT_EQ(1, ModulePassRunCount); EXPECT_EQ(1, ModulePassRunCount);
// Validate all function pass counter sets are the same. // Validate all function pass counter sets are the same.
EXPECT_EQ(3, FunctionPassRunCount1); EXPECT_EQ(3, FunctionPassRunCount1);
EXPECT_EQ(5, AnalyzedInstrCount1); EXPECT_EQ(5, AnalyzedInstrCount1);
EXPECT_EQ(0, AnalyzedFunctionCount1); EXPECT_EQ(0, AnalyzedFunctionCount1);
Show All 23 Lines

unittests/IR/VerifierTest.cpp

Show First 20 Lines • Show All 186 Lines • ▼ Show 20 LinesTEST(VerifierTest, StripInvalidDebugInfo) {
// Now break it. // Now break it.
auto *File = DIB.createFile("not-a-CU.f", "."); auto *File = DIB.createFile("not-a-CU.f", ".");
NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu"); NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu");
NMD->addOperand(File); NMD->addOperand(File);
EXPECT_TRUE(verifyModule(M)); EXPECT_TRUE(verifyModule(M));
ModulePassManager MPM(true); ModulePassManager MPM(true);
MPM.addPass(VerifierPass(false)); MPM.addPass(VerifierPass(false));
ModuleAnalysisManager MAM(true); AnalysisManager AM(true);
MAM.registerPass([&] { return VerifierAnalysis(); }); AM.registerPass<Module>([&] { return VerifierAnalysis(); });
MPM.run(M, MAM); MPM.run(M, AM);
EXPECT_FALSE(verifyModule(M)); EXPECT_FALSE(verifyModule(M));
} }
#endif #endif
TEST(VerifierTest, StripInvalidDebugInfoLegacy) { TEST(VerifierTest, StripInvalidDebugInfoLegacy) {
LLVMContext C; LLVMContext C;
Module M("M", C); Module M("M", C);
DIBuilder DIB(M); DIBuilder DIB(M);
Show All 19 Lines