RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2025-02-01 18:04:59 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[PM] Make the AnalysisManager parameter to run methods a reference.

Browse Source 
This was originally a pointer to support pass managers which didn't use
AnalysisManagers. However, that doesn't realistically come up much and
the complexity of supporting it doesn't really make sense.

In fact, *many* parts of the pass manager were just assuming the pointer
was never null already. This at least makes it much more explicit and
clear.

llvm-svn: 263219
This commit is contained in:
Chandler Carruth 2016-03-11 11:05:24 +00:00
parent 0c3020180a
commit 6150530377
59 changed files with 186 additions and 199 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/llvm/Analysis/AliasAnalysis.h
View File

@ -866,10 +866,10 @@ public:
ResultGetters.push_back(&getModuleAAResultImpl<AnalysisT>);
}
Result run(Function &F, AnalysisManager<Function> *AM) {
Result R(AM->getResult<TargetLibraryAnalysis>(F));
Result run(Function &F, AnalysisManager<Function> &AM) {
Result R(AM.getResult<TargetLibraryAnalysis>(F));
for (auto &Getter : ResultGetters)
(*Getter)(F, *AM, R);
(*Getter)(F, AM, R);
return R;
}

2
include/llvm/Analysis/AliasAnalysisEvaluator.h
View File

@ -55,7 +55,7 @@ public:
static StringRef name() { return "AAEvaluator"; }
/// \brief Run the pass over the function.
PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM);
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM);
private:
// Allow the legacy pass to run this using an internal API.

2
include/llvm/Analysis/AssumptionCache.h
View File

@ -115,7 +115,7 @@ class AssumptionPrinterPass : public PassInfoMixin<AssumptionPrinterPass> {
public:
explicit AssumptionPrinterPass(raw_ostream &OS) : OS(OS) {}
PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM);
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM);
static StringRef name() { return "AssumptionPrinterPass"; }
};

2
include/llvm/Analysis/BasicAliasAnalysis.h
View File

@ -187,7 +187,7 @@ class BasicAA : public AnalysisInfoMixin<BasicAA> {
public:
typedef BasicAAResult Result;
BasicAAResult run(Function &F, AnalysisManager<Function> *AM);
BasicAAResult run(Function &F, AnalysisManager<Function> &AM);
};
/// Legacy wrapper pass to provide the BasicAAResult object.

2
include/llvm/Analysis/CFLAliasAnalysis.h
View File

@ -116,7 +116,7 @@ class CFLAA : public AnalysisInfoMixin<CFLAA> {
public:
typedef CFLAAResult Result;
CFLAAResult run(Function &F, AnalysisManager<Function> *AM);
CFLAAResult run(Function &F, AnalysisManager<Function> &AM);
};
/// Legacy wrapper pass to provide the CFLAAResult object.

22
include/llvm/Analysis/CGSCCPassManager.h
View File

@ -88,20 +88,18 @@ public:
}
/// \brief Runs the CGSCC pass across every SCC in the module.
PreservedAnalyses run(Module &M, ModuleAnalysisManager *AM) {
assert(AM && "We need analyses to compute the call graph!");
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM) {
// Setup the CGSCC analysis manager from its proxy.
CGSCCAnalysisManager &CGAM =
AM->getResult<CGSCCAnalysisManagerModuleProxy>(M).getManager();
AM.getResult<CGSCCAnalysisManagerModuleProxy>(M).getManager();
// Get the call graph for this module.
LazyCallGraph &CG = AM->getResult<LazyCallGraphAnalysis>(M);
LazyCallGraph &CG = AM.getResult<LazyCallGraphAnalysis>(M);
PreservedAnalyses PA = PreservedAnalyses::all();
for (LazyCallGraph::RefSCC &OuterC : CG.postorder_ref_sccs())
for (LazyCallGraph::SCC &C : OuterC) {
PreservedAnalyses PassPA = Pass.run(C, &CGAM);
PreservedAnalyses PassPA = Pass.run(C, CGAM);
// We know that the CGSCC pass couldn't have invalidated any other
// SCC's analyses (that's the contract of a CGSCC pass), so
@ -180,11 +178,10 @@ public:
}
/// \brief Runs the function pass across every function in the module.
PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager *AM) {
FunctionAnalysisManager *FAM = nullptr;
if (AM)
// Setup the function analysis manager from its proxy.
FAM = &AM->getResult<FunctionAnalysisManagerCGSCCProxy>(C).getManager();
PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM) {
// Setup the function analysis manager from its proxy.
FunctionAnalysisManager &FAM =
AM.getResult<FunctionAnalysisManagerCGSCCProxy>(C).getManager();
PreservedAnalyses PA = PreservedAnalyses::all();
for (LazyCallGraph::Node &N : C) {
@ -195,8 +192,7 @@ public:
// directly handle the function analysis manager's invalidation here.
// Also, update the preserved analyses to reflect that once invalidated
// these can again be preserved.
if (FAM)
PassPA = FAM->invalidate(N.getFunction(), std::move(PassPA));
PassPA = FAM.invalidate(N.getFunction(), std::move(PassPA));
// Then intersect the preserved set so that invalidation of module
// analyses will eventually occur when the module pass completes.

2
include/llvm/Analysis/CallGraph.h
View File

@ -315,7 +315,7 @@ class CallGraphPrinterPass : public PassInfoMixin<CallGraphPrinterPass> {
public:
explicit CallGraphPrinterPass(raw_ostream &OS) : OS(OS) {}
PreservedAnalyses run(Module &M, AnalysisManager<Module> *AM);
PreservedAnalyses run(Module &M, AnalysisManager<Module> &AM);
};
/// \brief The \c ModulePass which wraps up a \c CallGraph and the logic to

4
include/llvm/Analysis/DominanceFrontier.h
View File

@ -178,7 +178,7 @@ public:
typedef DominanceFrontier Result;
/// \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<Function> &AM);
};
/// \brief Printer pass for the \c DominanceFrontier.
@ -188,7 +188,7 @@ class DominanceFrontierPrinterPass
public:
explicit DominanceFrontierPrinterPass(raw_ostream &OS);
PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM);
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM);
};
} // End llvm namespace

2
include/llvm/Analysis/GlobalsModRef.h
View File

@ -125,7 +125,7 @@ class GlobalsAA : public AnalysisInfoMixin<GlobalsAA> {
public:
typedef GlobalsAAResult Result;
GlobalsAAResult run(Module &M, AnalysisManager<Module> *AM);
GlobalsAAResult run(Module &M, AnalysisManager<Module> &AM);
};
/// Legacy wrapper pass to provide the GlobalsAAResult object.

2
include/llvm/Analysis/LazyCallGraph.h
View File

@ -920,7 +920,7 @@ class LazyCallGraphPrinterPass
public:
explicit LazyCallGraphPrinterPass(raw_ostream &OS);
PreservedAnalyses run(Module &M, ModuleAnalysisManager *AM);
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
};
}

4
include/llvm/Analysis/LoopInfo.h
View File

@ -794,7 +794,7 @@ class LoopAnalysis : public AnalysisInfoMixin<LoopAnalysis> {
public:
typedef LoopInfo Result;
LoopInfo run(Function &F, AnalysisManager<Function> *AM);
LoopInfo run(Function &F, AnalysisManager<Function> &AM);
};
/// \brief Printer pass for the \c LoopAnalysis results.
@ -803,7 +803,7 @@ class LoopPrinterPass : public PassInfoMixin<LoopPrinterPass> {
public:
explicit LoopPrinterPass(raw_ostream &OS) : OS(OS) {}
PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM);
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM);
};
/// \brief The legacy pass manager's analysis pass to compute loop information.

12
include/llvm/Analysis/LoopPassManager.h
View File

@ -78,14 +78,12 @@ public:
}
/// \brief Runs the loop passes across every loop in the function.
PreservedAnalyses run(Function &F, FunctionAnalysisManager *AM) {
assert(AM && "We need analyses to compute the loop structure!");
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM) {
// Setup the loop analysis manager from its proxy.
LoopAnalysisManager *LAM =
&AM->getResult<LoopAnalysisManagerFunctionProxy>(F).getManager();
LoopAnalysisManager &LAM =
AM.getResult<LoopAnalysisManagerFunctionProxy>(F).getManager();
// Get the loop structure for this function
LoopInfo &LI = AM->getResult<LoopAnalysis>(F);
LoopInfo &LI = AM.getResult<LoopAnalysis>(F);
PreservedAnalyses PA = PreservedAnalyses::all();
@ -109,7 +107,7 @@ public:
// loop analysis manager's invalidation here. Also, update the
// preserved analyses to reflect that once invalidated these can again
// be preserved.
PassPA = LAM->invalidate(*L, std::move(PassPA));
PassPA = LAM.invalidate(*L, std::move(PassPA));
// Then intersect the preserved set so that invalidation of module
// analyses will eventually occur when the module pass completes.

2
include/llvm/Analysis/MemoryDependenceAnalysis.h
View File

@ -479,7 +479,7 @@ class MemoryDependenceAnalysis
public:
typedef MemoryDependenceResults Result;
MemoryDependenceResults run(Function &F, AnalysisManager<Function> *AM);
MemoryDependenceResults run(Function &F, AnalysisManager<Function> &AM);
};
/// A wrapper analysis pass for the legacy pass manager that exposes a \c

2
include/llvm/Analysis/ObjCARCAliasAnalysis.h
View File

@ -68,7 +68,7 @@ class ObjCARCAA : public AnalysisInfoMixin<ObjCARCAA> {
public:
typedef ObjCARCAAResult Result;
ObjCARCAAResult run(Function &F, AnalysisManager<Function> *AM);
ObjCARCAAResult run(Function &F, AnalysisManager<Function> &AM);
};
/// Legacy wrapper pass to provide the ObjCARCAAResult object.

2
include/llvm/Analysis/PostDominators.h
View File

@ -58,7 +58,7 @@ class PostDominatorTreePrinterPass
public:
explicit PostDominatorTreePrinterPass(raw_ostream &OS);
PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM);
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM);
};
struct PostDominatorTreeWrapperPass : public FunctionPass {

6
include/llvm/Analysis/RegionInfo.h
View File

@ -930,7 +930,7 @@ class RegionInfoAnalysis : public AnalysisInfoMixin<RegionInfoAnalysis> {
public:
typedef RegionInfo Result;
RegionInfo run(Function &F, AnalysisManager<Function> *AM);
RegionInfo run(Function &F, AnalysisManager<Function> &AM);
};
/// \brief Printer pass for the \c RegionInfo.
@ -939,12 +939,12 @@ class RegionInfoPrinterPass : public PassInfoMixin<RegionInfoPrinterPass> {
public:
explicit RegionInfoPrinterPass(raw_ostream &OS);
PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM);
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM);
};
/// \brief Verifier pass for the \c RegionInfo.
struct RegionInfoVerifierPass : PassInfoMixin<RegionInfoVerifierPass> {
PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM);
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM);
};
template <>

4
include/llvm/Analysis/ScalarEvolution.h
View File

@ -1438,7 +1438,7 @@ namespace llvm {
public:
typedef ScalarEvolution Result;
ScalarEvolution run(Function &F, AnalysisManager<Function> *AM);
ScalarEvolution run(Function &F, AnalysisManager<Function> &AM);
};
/// \brief Printer pass for the \c ScalarEvolutionAnalysis results.
@ -1448,7 +1448,7 @@ namespace llvm {
public:
explicit ScalarEvolutionPrinterPass(raw_ostream &OS) : OS(OS) {}
PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM);
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM);
};
class ScalarEvolutionWrapperPass : public FunctionPass {

2
include/llvm/Analysis/ScalarEvolutionAliasAnalysis.h
View File

@ -45,7 +45,7 @@ class SCEVAA : public AnalysisInfoMixin<SCEVAA> {
public:
typedef SCEVAAResult Result;
SCEVAAResult run(Function &F, AnalysisManager<Function> *AM);
SCEVAAResult run(Function &F, AnalysisManager<Function> &AM);
};
/// Legacy wrapper pass to provide the SCEVAAResult object.

2
include/llvm/Analysis/ScopedNoAliasAA.h
View File

@ -54,7 +54,7 @@ class ScopedNoAliasAA : public AnalysisInfoMixin<ScopedNoAliasAA> {
public:
typedef ScopedNoAliasAAResult Result;
ScopedNoAliasAAResult run(Function &F, AnalysisManager<Function> *AM);
ScopedNoAliasAAResult run(Function &F, AnalysisManager<Function> &AM);
};
/// Legacy wrapper pass to provide the ScopedNoAliasAAResult object.

2
include/llvm/Analysis/TypeBasedAliasAnalysis.h
View File

@ -55,7 +55,7 @@ class TypeBasedAA : public AnalysisInfoMixin<TypeBasedAA> {
public:
typedef TypeBasedAAResult Result;
TypeBasedAAResult run(Function &F, AnalysisManager<Function> *AM);
TypeBasedAAResult run(Function &F, AnalysisManager<Function> &AM);
};
/// Legacy wrapper pass to provide the TypeBasedAAResult object.

4
include/llvm/IR/Dominators.h
View File

@ -201,12 +201,12 @@ class DominatorTreePrinterPass
public:
explicit DominatorTreePrinterPass(raw_ostream &OS);
PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM);
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM);
};
/// \brief Verifier pass for the \c DominatorTree.
struct DominatorTreeVerifierPass : PassInfoMixin<DominatorTreeVerifierPass> {
PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM);
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM);
};
/// \brief Legacy analysis pass which computes a \c DominatorTree.

42
include/llvm/IR/PassManager.h
View File

@ -235,7 +235,7 @@ public:
}
/// \brief Run all of the passes in this manager over the IR.
PreservedAnalyses run(IRUnitT &IR, AnalysisManager<IRUnitT> *AM = nullptr) {
PreservedAnalyses run(IRUnitT &IR, AnalysisManager<IRUnitT> &AM) {
PreservedAnalyses PA = PreservedAnalyses::all();
if (DebugLogging)
@ -248,13 +248,11 @@ public:
PreservedAnalyses PassPA = Passes[Idx]->run(IR, AM);
// If we have an active analysis manager at this level we want to ensure
// we update it as each pass runs and potentially invalidates analyses.
// We also update the preserved set of analyses based on what analyses we
// have already handled the invalidation for here and don't need to
// invalidate when finished.
if (AM)
PassPA = AM->invalidate(IR, std::move(PassPA));
// Update the analysis manager as each pass runs and potentially
// invalidates analyses. We also update the preserved set of analyses
// based on what analyses we have already handled the invalidation for
// here and don't need to invalidate when finished.
PassPA = AM.invalidate(IR, std::move(PassPA));
// Finally, we intersect the final preserved analyses to compute the
// aggregate preserved set for this pass manager.
@ -533,7 +531,7 @@ private:
if (DebugLogging)
dbgs() << "Running analysis: " << P.name() << "\n";
AnalysisResultListT &ResultList = AnalysisResultLists[&IR];
ResultList.emplace_back(PassID, P.run(IR, this));
ResultList.emplace_back(PassID, P.run(IR, *this));
// P.run may have inserted elements into AnalysisResults and invalidated
// RI.
@ -885,11 +883,10 @@ public:
}
/// \brief Runs the function pass across every function in the module.
PreservedAnalyses run(Module &M, ModuleAnalysisManager *AM) {
FunctionAnalysisManager *FAM = nullptr;
if (AM)
// Setup the function analysis manager from its proxy.
FAM = &AM->getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM) {
// Setup the function analysis manager from its proxy.
FunctionAnalysisManager &FAM =
AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
PreservedAnalyses PA = PreservedAnalyses::all();
for (Function &F : M) {
@ -903,8 +900,7 @@ public:
// directly handle the function analysis manager's invalidation here and
// update our preserved set to reflect that these have already been
// handled.
if (FAM)
PassPA = FAM->invalidate(F, std::move(PassPA));
PassPA = FAM.invalidate(F, std::move(PassPA));
// Then intersect the preserved set so that invalidation of module
// analyses will eventually occur when the module pass completes.
@ -944,9 +940,8 @@ struct RequireAnalysisPass : PassInfoMixin<RequireAnalysisPass<AnalysisT>> {
/// created, these methods can be instantiated to satisfy whatever the
/// context requires.
template <typename IRUnitT>
PreservedAnalyses run(IRUnitT &Arg, AnalysisManager<IRUnitT> *AM) {
if (AM)
(void)AM->template getResult<AnalysisT>(Arg);
PreservedAnalyses run(IRUnitT &Arg, AnalysisManager<IRUnitT> &AM) {
(void)AM.template getResult<AnalysisT>(Arg);
return PreservedAnalyses::all();
}
@ -967,11 +962,10 @@ struct InvalidateAnalysisPass
/// created, these methods can be instantiated to satisfy whatever the
/// context requires.
template <typename IRUnitT>
PreservedAnalyses run(IRUnitT &Arg, AnalysisManager<IRUnitT> *AM) {
if (AM)
// We have to directly invalidate the analysis result as we can't
// enumerate all other analyses and use the preserved set to control it.
(void)AM->template invalidate<AnalysisT>(Arg);
PreservedAnalyses run(IRUnitT &Arg, AnalysisManager<IRUnitT> &AM) {
// We have to directly invalidate the analysis result as we can't
// enumerate all other analyses and use the preserved set to control it.
AM.template invalidate<AnalysisT>(Arg);
return PreservedAnalyses::all();
}

14
include/llvm/IR/PassManagerInternal.h
View File

@ -40,7 +40,7 @@ template <typename IRUnitT> struct PassConcept {
/// Note that actual pass object can omit the analysis manager argument if
/// desired. Also that the analysis manager may be null if there is no
/// analysis manager in the pass pipeline.
virtual PreservedAnalyses run(IRUnitT &IR, AnalysisManager<IRUnitT> *AM) = 0;
virtual PreservedAnalyses run(IRUnitT &IR, AnalysisManager<IRUnitT> &AM) = 0;
/// \brief Polymorphic method to access the name of a pass.
virtual StringRef name() = 0;
@ -55,7 +55,7 @@ class PassRunAcceptsAnalysisManager {
char a, b;
};
template <typename T, ResultT (T::*)(IRUnitT &, AnalysisManager<IRUnitT> *)>
template <typename T, ResultT (T::*)(IRUnitT &, AnalysisManager<IRUnitT> &)>
struct Checker;
template <typename T> static SmallType f(Checker<T, &T::run> *);
@ -96,7 +96,7 @@ struct PassModel<IRUnitT, PassT, PreservedAnalysesT, true>
return *this;
}
PreservedAnalysesT run(IRUnitT &IR, AnalysisManager<IRUnitT> *AM) override {
PreservedAnalysesT run(IRUnitT &IR, AnalysisManager<IRUnitT> &AM) override {
return Pass.run(IR, AM);
}
StringRef name() override { return PassT::name(); }
@ -122,7 +122,7 @@ struct PassModel<IRUnitT, PassT, PreservedAnalysesT, false>
return *this;
}
PreservedAnalysesT run(IRUnitT &IR, AnalysisManager<IRUnitT> *AM) override {
PreservedAnalysesT run(IRUnitT &IR, AnalysisManager<IRUnitT> &) override {
return Pass.run(IR);
}
StringRef name() override { return PassT::name(); }
@ -252,7 +252,7 @@ template <typename IRUnitT> struct AnalysisPassConcept {
/// \returns A unique_ptr to the analysis result object to be queried by
/// users.
virtual std::unique_ptr<AnalysisResultConcept<IRUnitT>>
run(IRUnitT &IR, AnalysisManager<IRUnitT> *AM) = 0;
run(IRUnitT &IR, AnalysisManager<IRUnitT> &AM) = 0;
/// \brief Polymorphic method to access the name of a pass.
virtual StringRef name() = 0;
@ -294,7 +294,7 @@ struct AnalysisPassModel<IRUnitT, PassT, true> : AnalysisPassConcept<IRUnitT> {
///
/// The return is wrapped in an \c AnalysisResultModel.
std::unique_ptr<AnalysisResultConcept<IRUnitT>>
run(IRUnitT &IR, AnalysisManager<IRUnitT> *AM) override {
run(IRUnitT &IR, AnalysisManager<IRUnitT> &AM) override {
return make_unique<ResultModelT>(Pass.run(IR, AM));
}
@ -332,7 +332,7 @@ struct AnalysisPassModel<IRUnitT, PassT, false> : AnalysisPassConcept<IRUnitT> {
///
/// The return is wrapped in an \c AnalysisResultModel.
std::unique_ptr<AnalysisResultConcept<IRUnitT>>
run(IRUnitT &IR, AnalysisManager<IRUnitT> *) override {
run(IRUnitT &IR, AnalysisManager<IRUnitT> &) override {
return make_unique<ResultModelT>(Pass.run(IR));
}

2
include/llvm/Transforms/IPO/FunctionAttrs.h
View File

@ -30,7 +30,7 @@ namespace llvm {
/// attribute. It also discovers function arguments that are not captured by
/// the function and marks them with the nocapture attribute.
struct PostOrderFunctionAttrsPass : PassInfoMixin<PostOrderFunctionAttrsPass> {
PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager *AM);
PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM);
};
/// Create a legacy pass manager instance of a pass to compute function attrs

2
include/llvm/Transforms/IPO/InferFunctionAttrs.h
View File

@ -24,7 +24,7 @@ namespace llvm {
/// A pass which infers function attributes from the names and signatures of
/// function declarations in a module.
struct InferFunctionAttrsPass : PassInfoMixin<InferFunctionAttrsPass> {
PreservedAnalyses run(Module &M, AnalysisManager<Module> *AM);
PreservedAnalyses run(Module &M, AnalysisManager<Module> &AM);
};
/// Create a legacy pass manager instance of a pass to infer function

2
include/llvm/Transforms/InstCombine/InstCombine.h
View File

@ -43,7 +43,7 @@ public:
return *this;
}
PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM);
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM);
};
/// \brief The legacy pass manager's instcombine pass.

2
include/llvm/Transforms/Scalar/EarlyCSE.h
View File

@ -28,7 +28,7 @@ namespace llvm {
/// expected that a later pass of GVN will catch the interesting/hard cases.
struct EarlyCSEPass : PassInfoMixin<EarlyCSEPass> {
/// \brief Run the pass over the function.
PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM);
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM);
};
}

2
include/llvm/Transforms/Scalar/GVN.h
View File

@ -46,7 +46,7 @@ class GVN : public PassInfoMixin<GVN> {
public:
/// \brief Run the pass over the function.
PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM);
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM);
/// This removes the specified instruction from
/// our various maps and marks it for deletion.

2
include/llvm/Transforms/Scalar/SROA.h
View File

@ -102,7 +102,7 @@ public:
SROA() : C(nullptr), DT(nullptr), AC(nullptr) {}
/// \brief Run the pass over the function.
PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM);
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM);
private:
friend class sroa::AllocaSliceRewriter;

2
include/llvm/Transforms/Scalar/SimplifyCFG.h
View File

@ -36,7 +36,7 @@ public:
SimplifyCFGPass(int BonusInstThreshold);
/// \brief Run the pass over the function.
PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM);
PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM);
};
}

4
lib/Analysis/AliasAnalysisEvaluator.cpp
View File

@ -88,8 +88,8 @@ static inline bool isInterestingPointer(Value *V) {
&& !isa<ConstantPointerNull>(V);
}
PreservedAnalyses AAEvaluator::run(Function &F, AnalysisManager<Function> *AM) {
runInternal(F, AM->getResult<AAManager>(F));
PreservedAnalyses AAEvaluator::run(Function &F, AnalysisManager<Function> &AM) {
runInternal(F, AM.getResult<AAManager>(F));
return PreservedAnalyses::all();
}

4
lib/Analysis/AssumptionCache.cpp
View File

@ -77,8 +77,8 @@ void AssumptionCache::registerAssumption(CallInst *CI) {
char AssumptionAnalysis::PassID;
PreservedAnalyses AssumptionPrinterPass::run(Function &F,
AnalysisManager<Function> *AM) {
AssumptionCache &AC = AM->getResult<AssumptionAnalysis>(F);
AnalysisManager<Function> &AM) {
AssumptionCache &AC = AM.getResult<AssumptionAnalysis>(F);
OS << "Cached assumptions for function: " << F.getName() << "\n";
for (auto &VH : AC.assumptions())

10
lib/Analysis/BasicAliasAnalysis.cpp
View File

@ -1608,12 +1608,12 @@ bool BasicAAResult::constantOffsetHeuristic(
char BasicAA::PassID;
BasicAAResult BasicAA::run(Function &F, AnalysisManager<Function> *AM) {
BasicAAResult BasicAA::run(Function &F, AnalysisManager<Function> &AM) {
return BasicAAResult(F.getParent()->getDataLayout(),
AM->getResult<TargetLibraryAnalysis>(F),
AM->getResult<AssumptionAnalysis>(F),
AM->getCachedResult<DominatorTreeAnalysis>(F),
AM->getCachedResult<LoopAnalysis>(F));
AM.getResult<TargetLibraryAnalysis>(F),
AM.getResult<AssumptionAnalysis>(F),
AM.getCachedResult<DominatorTreeAnalysis>(F),
AM.getCachedResult<LoopAnalysis>(F));
}
BasicAAWrapperPass::BasicAAWrapperPass() : FunctionPass(ID) {

2
lib/Analysis/CFLAliasAnalysis.cpp
View File

@ -1090,7 +1090,7 @@ AliasResult CFLAAResult::query(const MemoryLocation &LocA,
char CFLAA::PassID;
CFLAAResult CFLAA::run(Function &F, AnalysisManager<Function> *AM) {
CFLAAResult CFLAA::run(Function &F, AnalysisManager<Function> &AM) {
return CFLAAResult();
}

4
lib/Analysis/CallGraph.cpp
View File

@ -263,8 +263,8 @@ void CallGraphNode::replaceCallEdge(CallSite CS,
char CallGraphAnalysis::PassID;
PreservedAnalyses CallGraphPrinterPass::run(Module &M,
AnalysisManager<Module> *AM) {
AM->getResult<CallGraphAnalysis>(M).print(OS);
AnalysisManager<Module> &AM) {
AM.getResult<CallGraphAnalysis>(M).print(OS);
return PreservedAnalyses::all();
}

8
lib/Analysis/DominanceFrontier.cpp
View File

@ -59,9 +59,9 @@ LLVM_DUMP_METHOD void DominanceFrontierWrapperPass::dump() const {
char DominanceFrontierAnalysis::PassID;
DominanceFrontier DominanceFrontierAnalysis::run(Function &F,
FunctionAnalysisManager *AM) {
FunctionAnalysisManager &AM) {
DominanceFrontier DF;
DF.analyze(AM->getResult<DominatorTreeAnalysis>(F));
DF.analyze(AM.getResult<DominatorTreeAnalysis>(F));
return DF;
}
@ -69,9 +69,9 @@ DominanceFrontierPrinterPass::DominanceFrontierPrinterPass(raw_ostream &OS)
: OS(OS) {}
PreservedAnalyses
DominanceFrontierPrinterPass::run(Function &F, FunctionAnalysisManager *AM) {
DominanceFrontierPrinterPass::run(Function &F, FunctionAnalysisManager &AM) {
OS << "DominanceFrontier for function: " << F.getName() << "\n";
AM->getResult<DominanceFrontierAnalysis>(F).print(OS);
AM.getResult<DominanceFrontierAnalysis>(F).print(OS);
return PreservedAnalyses::all();
}

6
lib/Analysis/GlobalsModRef.cpp
View File

@ -938,10 +938,10 @@ GlobalsAAResult::analyzeModule(Module &M, const TargetLibraryInfo &TLI,
char GlobalsAA::PassID;
GlobalsAAResult GlobalsAA::run(Module &M, AnalysisManager<Module> *AM) {
GlobalsAAResult GlobalsAA::run(Module &M, AnalysisManager<Module> &AM) {
return GlobalsAAResult::analyzeModule(M,
AM->getResult<TargetLibraryAnalysis>(M),
AM->getResult<CallGraphAnalysis>(M));
AM.getResult<TargetLibraryAnalysis>(M),
AM.getResult<CallGraphAnalysis>(M));
}
char GlobalsAAWrapperPass::ID = 0;

4
lib/Analysis/LazyCallGraph.cpp
View File

@ -1531,8 +1531,8 @@ static void printRefSCC(raw_ostream &OS, LazyCallGraph::RefSCC &C) {
}
PreservedAnalyses LazyCallGraphPrinterPass::run(Module &M,
ModuleAnalysisManager *AM) {
LazyCallGraph &G = AM->getResult<LazyCallGraphAnalysis>(M);
ModuleAnalysisManager &AM) {
LazyCallGraph &G = AM.getResult<LazyCallGraphAnalysis>(M);
OS << "Printing the call graph for module: " << M.getModuleIdentifier()
<< "\n\n";

8
lib/Analysis/LoopInfo.cpp
View File

@ -643,7 +643,7 @@ void LoopInfo::markAsRemoved(Loop *Unloop) {
char LoopAnalysis::PassID;
LoopInfo LoopAnalysis::run(Function &F, AnalysisManager<Function> *AM) {
LoopInfo LoopAnalysis::run(Function &F, AnalysisManager<Function> &AM) {
// FIXME: Currently we create a LoopInfo from scratch for every function.
// 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
@ -651,13 +651,13 @@ LoopInfo LoopAnalysis::run(Function &F, AnalysisManager<Function> *AM) {
// objects. I don't want to add that kind of complexity until the scope of
// the problem is better understood.
LoopInfo LI;
LI.analyze(AM->getResult<DominatorTreeAnalysis>(F));
LI.analyze(AM.getResult<DominatorTreeAnalysis>(F));
return LI;
}
PreservedAnalyses LoopPrinterPass::run(Function &F,
AnalysisManager<Function> *AM) {
AM->getResult<LoopAnalysis>(F).print(OS);
AnalysisManager<Function> &AM) {
AM.getResult<LoopAnalysis>(F).print(OS);
return PreservedAnalyses::all();
}

10
lib/Analysis/MemoryDependenceAnalysis.cpp
View File

@ -1662,11 +1662,11 @@ void MemoryDependenceResults::verifyRemoved(Instruction *D) const {
char MemoryDependenceAnalysis::PassID;
MemoryDependenceResults
MemoryDependenceAnalysis::run(Function &F, AnalysisManager<Function> *AM) {
auto &AA = AM->getResult<AAManager>(F);
auto &AC = AM->getResult<AssumptionAnalysis>(F);
auto &TLI = AM->getResult<TargetLibraryAnalysis>(F);
auto *DT = AM->getCachedResult<DominatorTreeAnalysis>(F);
MemoryDependenceAnalysis::run(Function &F, AnalysisManager<Function> &AM) {
auto &AA = AM.getResult<AAManager>(F);
auto &AC = AM.getResult<AssumptionAnalysis>(F);
auto &TLI = AM.getResult<TargetLibraryAnalysis>(F);
auto *DT = AM.getCachedResult<DominatorTreeAnalysis>(F);
return MemoryDependenceResults(AA, AC, TLI, DT);
}

2
lib/Analysis/ObjCARCAliasAnalysis.cpp
View File

@ -131,7 +131,7 @@ ModRefInfo ObjCARCAAResult::getModRefInfo(ImmutableCallSite CS,
return AAResultBase::getModRefInfo(CS, Loc);
}
ObjCARCAAResult ObjCARCAA::run(Function &F, AnalysisManager<Function> *AM) {
ObjCARCAAResult ObjCARCAA::run(Function &F, AnalysisManager<Function> &AM) {
return ObjCARCAAResult(F.getParent()->getDataLayout());
}

4
lib/Analysis/PostDominators.cpp
View File

@ -56,9 +56,9 @@ PostDominatorTreePrinterPass::PostDominatorTreePrinterPass(raw_ostream &OS)
: OS(OS) {}
PreservedAnalyses
PostDominatorTreePrinterPass::run(Function &F, FunctionAnalysisManager *AM) {
PostDominatorTreePrinterPass::run(Function &F, FunctionAnalysisManager &AM) {
OS << "PostDominatorTree for function: " << F.getName() << "\n";
AM->getResult<PostDominatorTreeAnalysis>(F).print(OS);
AM.getResult<PostDominatorTreeAnalysis>(F).print(OS);
return PreservedAnalyses::all();
}

18
lib/Analysis/RegionInfo.cpp
View File

@ -187,11 +187,11 @@ namespace llvm {
char RegionInfoAnalysis::PassID;
RegionInfo RegionInfoAnalysis::run(Function &F, AnalysisManager<Function> *AM) {
RegionInfo RegionInfoAnalysis::run(Function &F, AnalysisManager<Function> &AM) {
RegionInfo RI;
auto *DT = &AM->getResult<DominatorTreeAnalysis>(F);
auto *PDT = &AM->getResult<PostDominatorTreeAnalysis>(F);
auto *DF = &AM->getResult<DominanceFrontierAnalysis>(F);
auto *DT = &AM.getResult<DominatorTreeAnalysis>(F);
auto *PDT = &AM.getResult<PostDominatorTreeAnalysis>(F);
auto *DF = &AM.getResult<DominanceFrontierAnalysis>(F);
RI.recalculate(F, DT, PDT, DF);
return RI;
@ -200,17 +200,17 @@ RegionInfo RegionInfoAnalysis::run(Function &F, AnalysisManager<Function> *AM) {
RegionInfoPrinterPass::RegionInfoPrinterPass(raw_ostream &OS)
: OS(OS) {}
PreservedAnalyses
RegionInfoPrinterPass::run(Function &F, FunctionAnalysisManager *AM) {
PreservedAnalyses RegionInfoPrinterPass::run(Function &F,
FunctionAnalysisManager &AM) {
OS << "Region Tree for function: " << F.getName() << "\n";
AM->getResult<RegionInfoAnalysis>(F).print(OS);
AM.getResult<RegionInfoAnalysis>(F).print(OS);
return PreservedAnalyses::all();
}
PreservedAnalyses RegionInfoVerifierPass::run(Function &F,
AnalysisManager<Function> *AM) {
AM->getResult<RegionInfoAnalysis>(F).verifyAnalysis();
AnalysisManager<Function> &AM) {
AM.getResult<RegionInfoAnalysis>(F).verifyAnalysis();
return PreservedAnalyses::all();
}

14
lib/Analysis/ScalarEvolution.cpp
View File

@ -9733,16 +9733,16 @@ void ScalarEvolution::verify() const {
char ScalarEvolutionAnalysis::PassID;
ScalarEvolution ScalarEvolutionAnalysis::run(Function &F,
AnalysisManager<Function> *AM) {
return ScalarEvolution(F, AM->getResult<TargetLibraryAnalysis>(F),
AM->getResult<AssumptionAnalysis>(F),
AM->getResult<DominatorTreeAnalysis>(F),
AM->getResult<LoopAnalysis>(F));
AnalysisManager<Function> &AM) {
return ScalarEvolution(F, AM.getResult<TargetLibraryAnalysis>(F),
AM.getResult<AssumptionAnalysis>(F),
AM.getResult<DominatorTreeAnalysis>(F),
AM.getResult<LoopAnalysis>(F));
}
PreservedAnalyses
ScalarEvolutionPrinterPass::run(Function &F, AnalysisManager<Function> *AM) {
AM->getResult<ScalarEvolutionAnalysis>(F).print(OS);
ScalarEvolutionPrinterPass::run(Function &F, AnalysisManager<Function> &AM) {
AM.getResult<ScalarEvolutionAnalysis>(F).print(OS);
return PreservedAnalyses::all();
}

4
lib/Analysis/ScalarEvolutionAliasAnalysis.cpp
View File

@ -112,8 +112,8 @@ Value *SCEVAAResult::GetBaseValue(const SCEV *S) {
char SCEVAA::PassID;
SCEVAAResult SCEVAA::run(Function &F, AnalysisManager<Function> *AM) {
return SCEVAAResult(AM->getResult<ScalarEvolutionAnalysis>(F));
SCEVAAResult SCEVAA::run(Function &F, AnalysisManager<Function> &AM) {
return SCEVAAResult(AM.getResult<ScalarEvolutionAnalysis>(F));
}
char SCEVAAWrapperPass::ID = 0;

2
lib/Analysis/ScopedNoAliasAA.cpp
View File

@ -175,7 +175,7 @@ bool ScopedNoAliasAAResult::mayAliasInScopes(const MDNode *Scopes,
char ScopedNoAliasAA::PassID;
ScopedNoAliasAAResult ScopedNoAliasAA::run(Function &F,
AnalysisManager<Function> *AM) {
AnalysisManager<Function> &AM) {
return ScopedNoAliasAAResult();
}

2
lib/Analysis/TypeBasedAliasAnalysis.cpp
View File

@ -585,7 +585,7 @@ bool TypeBasedAAResult::PathAliases(const MDNode *A, const MDNode *B) const {
char TypeBasedAA::PassID;
TypeBasedAAResult TypeBasedAA::run(Function &F, AnalysisManager<Function> *AM) {
TypeBasedAAResult TypeBasedAA::run(Function &F, AnalysisManager<Function> &AM) {
return TypeBasedAAResult();
}

8
lib/IR/Dominators.cpp
View File

@ -313,16 +313,16 @@ char DominatorTreeAnalysis::PassID;
DominatorTreePrinterPass::DominatorTreePrinterPass(raw_ostream &OS) : OS(OS) {}
PreservedAnalyses DominatorTreePrinterPass::run(Function &F,
FunctionAnalysisManager *AM) {
FunctionAnalysisManager &AM) {
OS << "DominatorTree for function: " << F.getName() << "\n";
AM->getResult<DominatorTreeAnalysis>(F).print(OS);
AM.getResult<DominatorTreeAnalysis>(F).print(OS);
return PreservedAnalyses::all();
}
PreservedAnalyses DominatorTreeVerifierPass::run(Function &F,
FunctionAnalysisManager *AM) {
AM->getResult<DominatorTreeAnalysis>(F).verifyDomTree();
FunctionAnalysisManager &AM) {
AM.getResult<DominatorTreeAnalysis>(F).verifyDomTree();
return PreservedAnalyses::all();
}

8
lib/Transforms/IPO/FunctionAttrs.cpp
View File

@ -987,13 +987,13 @@ static bool addNoRecurseAttrs(const SCCNodeSet &SCCNodes) {
return setDoesNotRecurse(*F);
}
PreservedAnalyses
PostOrderFunctionAttrsPass::run(LazyCallGraph::SCC &C, CGSCCAnalysisManager *AM) {
PreservedAnalyses PostOrderFunctionAttrsPass::run(LazyCallGraph::SCC &C,
CGSCCAnalysisManager &AM) {
Module &M = *C.begin()->getFunction().getParent();
const ModuleAnalysisManager &MAM =
AM->getResult<ModuleAnalysisManagerCGSCCProxy>(C).getManager();
AM.getResult<ModuleAnalysisManagerCGSCCProxy>(C).getManager();
FunctionAnalysisManager &FAM =
AM->getResult<FunctionAnalysisManagerCGSCCProxy>(C).getManager();
AM.getResult<FunctionAnalysisManagerCGSCCProxy>(C).getManager();
// FIXME: Need some way to make it more reasonable to assume that this is
// always cached.

4
lib/Transforms/IPO/InferFunctionAttrs.cpp
View File

@ -945,8 +945,8 @@ static bool inferAllPrototypeAttributes(Module &M,
}
PreservedAnalyses InferFunctionAttrsPass::run(Module &M,
AnalysisManager<Module> *AM) {
auto &TLI = AM->getResult<TargetLibraryAnalysis>(M);
AnalysisManager<Module> &AM) {
auto &TLI = AM.getResult<TargetLibraryAnalysis>(M);
if (!inferAllPrototypeAttributes(M, TLI))
// If we didn't infer anything, preserve all analyses.

10
lib/Transforms/InstCombine/InstructionCombining.cpp
View File

@ -3082,12 +3082,12 @@ combineInstructionsOverFunction(Function &F, InstCombineWorklist &Worklist,
}
PreservedAnalyses InstCombinePass::run(Function &F,
AnalysisManager<Function> *AM) {
auto &AC = AM->getResult<AssumptionAnalysis>(F);
auto &DT = AM->getResult<DominatorTreeAnalysis>(F);
auto &TLI = AM->getResult<TargetLibraryAnalysis>(F);
AnalysisManager<Function> &AM) {
auto &AC = AM.getResult<AssumptionAnalysis>(F);
auto &DT = AM.getResult<DominatorTreeAnalysis>(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
if (!combineInstructionsOverFunction(F, Worklist, nullptr, AC, TLI, DT,

10
lib/Transforms/Scalar/EarlyCSE.cpp
View File

@ -818,11 +818,11 @@ bool EarlyCSE::run() {
}
PreservedAnalyses EarlyCSEPass::run(Function &F,
AnalysisManager<Function> *AM) {
auto &TLI = AM->getResult<TargetLibraryAnalysis>(F);
auto &TTI = AM->getResult<TargetIRAnalysis>(F);
auto &DT = AM->getResult<DominatorTreeAnalysis>(F);
auto &AC = AM->getResult<AssumptionAnalysis>(F);
AnalysisManager<Function> &AM) {
auto &TLI = AM.getResult<TargetLibraryAnalysis>(F);
auto &TTI = AM.getResult<TargetIRAnalysis>(F);
auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
auto &AC = AM.getResult<AssumptionAnalysis>(F);
EarlyCSE CSE(TLI, TTI, DT, AC);

12
lib/Transforms/Scalar/GVN.cpp
View File

@ -584,12 +584,12 @@ void GVN::ValueTable::verifyRemoved(const Value *V) const {
// GVN Pass
//===----------------------------------------------------------------------===//
PreservedAnalyses GVN::run(Function &F, AnalysisManager<Function> *AM) {
bool Changed = runImpl(F, AM->getResult<AssumptionAnalysis>(F),
AM->getResult<DominatorTreeAnalysis>(F),
AM->getResult<TargetLibraryAnalysis>(F),
AM->getResult<AAManager>(F),
&AM->getResult<MemoryDependenceAnalysis>(F));
PreservedAnalyses GVN::run(Function &F, AnalysisManager<Function> &AM) {
bool Changed = runImpl(F, AM.getResult<AssumptionAnalysis>(F),
AM.getResult<DominatorTreeAnalysis>(F),
AM.getResult<TargetLibraryAnalysis>(F),
AM.getResult<AAManager>(F),
&AM.getResult<MemoryDependenceAnalysis>(F));
return Changed ? PreservedAnalyses::none() : PreservedAnalyses::all();
}

6
lib/Transforms/Scalar/SROA.cpp
View File

@ -4241,9 +4241,9 @@ PreservedAnalyses SROA::runImpl(Function &F, DominatorTree &RunDT,
return Changed ? PreservedAnalyses::none() : PreservedAnalyses::all();
}
PreservedAnalyses SROA::run(Function &F, AnalysisManager<Function> *AM) {
return runImpl(F, AM->getResult<DominatorTreeAnalysis>(F),
AM->getResult<AssumptionAnalysis>(F));
PreservedAnalyses SROA::run(Function &F, AnalysisManager<Function> &AM) {
return runImpl(F, AM.getResult<DominatorTreeAnalysis>(F),
AM.getResult<AssumptionAnalysis>(F));
}
/// A legacy pass for the legacy pass manager that wraps the \c SROA pass.

6
lib/Transforms/Scalar/SimplifyCFGPass.cpp
View File

@ -178,9 +178,9 @@ SimplifyCFGPass::SimplifyCFGPass(int BonusInstThreshold)
: BonusInstThreshold(BonusInstThreshold) {}
PreservedAnalyses SimplifyCFGPass::run(Function &F,
AnalysisManager<Function> *AM) {
auto &TTI = AM->getResult<TargetIRAnalysis>(F);
auto &AC = AM->getResult<AssumptionAnalysis>(F);
AnalysisManager<Function> &AM) {
auto &TTI = AM.getResult<TargetIRAnalysis>(F);
auto &AC = AM.getResult<AssumptionAnalysis>(F);
if (simplifyFunctionCFG(F, TTI, &AC, BonusInstThreshold))
return PreservedAnalyses::none();

2
tools/opt/NewPMDriver.cpp
View File

@ -118,7 +118,7 @@ bool llvm::runPassPipeline(StringRef Arg0, LLVMContext &Context, Module &M,
cl::PrintOptionValues();
// Now that we have all of the passes ready, run them.
MPM.run(M, &MAM);
MPM.run(M, MAM);
// Declare success.
if (OK != OK_NoOutput)

25
unittests/Analysis/CGSCCPassManagerTest.cpp
View File

@ -34,7 +34,7 @@ public:
TestModuleAnalysis(int &Runs) : Runs(Runs) {}
Result run(Module &M, ModuleAnalysisManager *AM) {
Result run(Module &M, ModuleAnalysisManager &AM) {
++Runs;
return Result(M.size());
}
@ -59,7 +59,7 @@ public:
TestSCCAnalysis(int &Runs) : Runs(Runs) {}
Result run(LazyCallGraph::SCC &C, CGSCCAnalysisManager *AM) {
Result run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM) {
++Runs;
return Result(C.size());
}
@ -84,7 +84,7 @@ public:
TestFunctionAnalysis(int &Runs) : Runs(Runs) {}
Result run(Function &F, FunctionAnalysisManager *AM) {
Result run(Function &F, FunctionAnalysisManager &AM) {
++Runs;
int Count = 0;
for (Instruction &I : instructions(F)) {
@ -113,7 +113,7 @@ public:
TestImmutableFunctionAnalysis(int &Runs) : Runs(Runs) {}
Result run(Function &F, FunctionAnalysisManager *AM) {
Result run(Function &F, FunctionAnalysisManager &AM) {
++Runs;
return Result();
}
@ -129,9 +129,9 @@ char TestImmutableFunctionAnalysis::PassID;
struct TestModulePass {
TestModulePass(int &RunCount) : RunCount(RunCount) {}
PreservedAnalyses run(Module &M, ModuleAnalysisManager *AM) {
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM) {
++RunCount;
(void)AM->getResult<TestModuleAnalysis>(M);
(void)AM.getResult<TestModuleAnalysis>(M);
return PreservedAnalyses::all();
}
@ -150,13 +150,13 @@ struct TestSCCPass {
AnalyzedModuleFunctionCount(AnalyzedModuleFunctionCount),
OnlyUseCachedResults(OnlyUseCachedResults) {}
PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager *AM) {
PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM) {
++RunCount;
const ModuleAnalysisManager &MAM =
AM->getResult<ModuleAnalysisManagerCGSCCProxy>(C).getManager();
AM.getResult<ModuleAnalysisManagerCGSCCProxy>(C).getManager();
FunctionAnalysisManager &FAM =
AM->getResult<FunctionAnalysisManagerCGSCCProxy>(C).getManager();
AM.getResult<FunctionAnalysisManagerCGSCCProxy>(C).getManager();
if (TestModuleAnalysis::Result *TMA =
MAM.getCachedResult<TestModuleAnalysis>(
*C.begin()->getFunction().getParent()))
@ -164,8 +164,7 @@ struct TestSCCPass {
if (OnlyUseCachedResults) {
// 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;
for (LazyCallGraph::Node &N : C)
if (TestFunctionAnalysis::Result *FAR =
@ -173,7 +172,7 @@ struct TestSCCPass {
AnalyzedInstrCount += FAR->InstructionCount;
} else {
// 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;
for (LazyCallGraph::Node &N : C) {
TestFunctionAnalysis::Result &FAR =
@ -301,7 +300,7 @@ TEST_F(CGSCCPassManagerTest, Basic) {
CGPM1.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM1)));
MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM1)));
MPM.run(*M, &MAM);
MPM.run(*M, MAM);
EXPECT_EQ(1, ModulePassRunCount1);

12
unittests/Analysis/LoopPassManagerTest.cpp
View File

@ -42,7 +42,7 @@ public:
TestLoopAnalysis(int &Runs) : Runs(Runs) {}
/// \brief Run the analysis pass over the loop and return a result.
Result run(Loop &L, AnalysisManager<Loop> *AM) {
Result run(Loop &L, AnalysisManager<Loop> &AM) {
++Runs;
int Count = 0;
@ -65,16 +65,16 @@ public:
: VisitedLoops(VisitedLoops), AnalyzedBlockCount(AnalyzedBlockCount),
OnlyUseCachedResults(OnlyUseCachedResults) {}
PreservedAnalyses run(Loop &L, AnalysisManager<Loop> *AM) {
PreservedAnalyses run(Loop &L, AnalysisManager<Loop> &AM) {
VisitedLoops.push_back(L.getName());
if (OnlyUseCachedResults) {
// 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;
} else {
// Typical path just runs the analysis as needed.
auto &AR = AM->getResult<TestLoopAnalysis>(L);
auto &AR = AM.getResult<TestLoopAnalysis>(L);
AnalyzedBlockCount += AR.BlockCount;
}
@ -91,7 +91,7 @@ class TestLoopInvalidatingPass {
public:
TestLoopInvalidatingPass(StringRef LoopName) : Name(LoopName) {}
PreservedAnalyses run(Loop &L, AnalysisManager<Loop> *AM) {
PreservedAnalyses run(Loop &L, AnalysisManager<Loop> &AM) {
return L.getName() == Name ? PreservedAnalyses::none()
: PreservedAnalyses::all();
}
@ -185,7 +185,7 @@ TEST_F(LoopPassManagerTest, Basic) {
}
MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
MPM.run(*M, &MAM);
MPM.run(*M, MAM);
StringRef ExpectedLoops[] = {"loop.0.0", "loop.0.1", "loop.0", "loop.g.0"};

18
unittests/IR/PassManagerTest.cpp
View File

@ -29,7 +29,7 @@ public:
TestFunctionAnalysis(int &Runs) : Runs(Runs) {}
/// \brief Run the analysis pass over the function and return a result.
Result run(Function &F, FunctionAnalysisManager *AM) {
Result run(Function &F, FunctionAnalysisManager &AM) {
++Runs;
int Count = 0;
for (Function::iterator BBI = F.begin(), BBE = F.end(); BBI != BBE; ++BBI)
@ -57,7 +57,7 @@ public:
TestModuleAnalysis(int &Runs) : Runs(Runs) {}
Result run(Module &M, ModuleAnalysisManager *AM) {
Result run(Module &M, ModuleAnalysisManager &AM) {
++Runs;
int Count = 0;
for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
@ -91,11 +91,11 @@ struct TestPreservingModulePass : PassInfoMixin<TestPreservingModulePass> {
struct TestMinPreservingModulePass
: PassInfoMixin<TestMinPreservingModulePass> {
PreservedAnalyses run(Module &M, ModuleAnalysisManager *AM) {
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM) {
PreservedAnalyses PA;
// Force running an analysis.
(void)AM->getResult<TestModuleAnalysis>(M);
(void)AM.getResult<TestModuleAnalysis>(M);
PA.preserve<FunctionAnalysisManagerModuleProxy>();
return PA;
@ -110,11 +110,11 @@ struct TestFunctionPass : PassInfoMixin<TestFunctionPass> {
AnalyzedFunctionCount(AnalyzedFunctionCount),
OnlyUseCachedResults(OnlyUseCachedResults) {}
PreservedAnalyses run(Function &F, FunctionAnalysisManager *AM) {
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM) {
++RunCount;
const ModuleAnalysisManager &MAM =
AM->getResult<ModuleAnalysisManagerFunctionProxy>(F).getManager();
AM.getResult<ModuleAnalysisManagerFunctionProxy>(F).getManager();
if (TestModuleAnalysis::Result *TMA =
MAM.getCachedResult<TestModuleAnalysis>(*F.getParent()))
AnalyzedFunctionCount += TMA->FunctionCount;
@ -122,11 +122,11 @@ struct TestFunctionPass : PassInfoMixin<TestFunctionPass> {
if (OnlyUseCachedResults) {
// Hack to force the use of the cached interface.
if (TestFunctionAnalysis::Result *AR =
AM->getCachedResult<TestFunctionAnalysis>(F))
AM.getCachedResult<TestFunctionAnalysis>(F))
AnalyzedInstrCount += AR->InstructionCount;
} else {
// Typical path just runs the analysis as needed.
TestFunctionAnalysis::Result &AR = AM->getResult<TestFunctionAnalysis>(F);
TestFunctionAnalysis::Result &AR = AM.getResult<TestFunctionAnalysis>(F);
AnalyzedInstrCount += AR.InstructionCount;
}
@ -298,7 +298,7 @@ TEST_F(PassManagerTest, Basic) {
MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
}
MPM.run(*M, &MAM);
MPM.run(*M, MAM);
// Validate module pass counters.
EXPECT_EQ(1, ModulePassRunCount);