1 #include "llvm/Transforms/IPO/SCCP.h"
2 #include "llvm/Analysis/AssumptionCache.h"
3 #include "llvm/Analysis/PostDominators.h"
4 #include "llvm/Analysis/TargetLibraryInfo.h"
5 #include "llvm/InitializePasses.h"
6 #include "llvm/Transforms/IPO.h"
7 #include "llvm/Transforms/Scalar/SCCP.h"
8
9 using namespace llvm;
10
run(Module & M,ModuleAnalysisManager & AM)11 PreservedAnalyses IPSCCPPass::run(Module &M, ModuleAnalysisManager &AM) {
12 const DataLayout &DL = M.getDataLayout();
13 auto &FAM = AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
14 auto GetTLI = [&FAM](Function &F) -> const TargetLibraryInfo & {
15 return FAM.getResult<TargetLibraryAnalysis>(F);
16 };
17 auto getAnalysis = [&FAM](Function &F) -> AnalysisResultsForFn {
18 DominatorTree &DT = FAM.getResult<DominatorTreeAnalysis>(F);
19 return {
20 std::make_unique<PredicateInfo>(F, DT, FAM.getResult<AssumptionAnalysis>(F)),
21 &DT, FAM.getCachedResult<PostDominatorTreeAnalysis>(F)};
22 };
23
24 if (!runIPSCCP(M, DL, GetTLI, getAnalysis))
25 return PreservedAnalyses::all();
26
27 PreservedAnalyses PA;
28 PA.preserve<DominatorTreeAnalysis>();
29 PA.preserve<PostDominatorTreeAnalysis>();
30 PA.preserve<FunctionAnalysisManagerModuleProxy>();
31 return PA;
32 }
33
34 namespace {
35
36 //===--------------------------------------------------------------------===//
37 //
38 /// IPSCCP Class - This class implements interprocedural Sparse Conditional
39 /// Constant Propagation.
40 ///
41 class IPSCCPLegacyPass : public ModulePass {
42 public:
43 static char ID;
44
IPSCCPLegacyPass()45 IPSCCPLegacyPass() : ModulePass(ID) {
46 initializeIPSCCPLegacyPassPass(*PassRegistry::getPassRegistry());
47 }
48
runOnModule(Module & M)49 bool runOnModule(Module &M) override {
50 if (skipModule(M))
51 return false;
52 const DataLayout &DL = M.getDataLayout();
53 auto GetTLI = [this](Function &F) -> const TargetLibraryInfo & {
54 return this->getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F);
55 };
56 auto getAnalysis = [this](Function &F) -> AnalysisResultsForFn {
57 DominatorTree &DT =
58 this->getAnalysis<DominatorTreeWrapperPass>(F).getDomTree();
59 return {
60 std::make_unique<PredicateInfo>(
61 F, DT,
62 this->getAnalysis<AssumptionCacheTracker>().getAssumptionCache(
63 F)),
64 nullptr, // We cannot preserve the DT or PDT with the legacy pass
65 nullptr}; // manager, so set them to nullptr.
66 };
67
68 return runIPSCCP(M, DL, GetTLI, getAnalysis);
69 }
70
getAnalysisUsage(AnalysisUsage & AU) const71 void getAnalysisUsage(AnalysisUsage &AU) const override {
72 AU.addRequired<AssumptionCacheTracker>();
73 AU.addRequired<DominatorTreeWrapperPass>();
74 AU.addRequired<TargetLibraryInfoWrapperPass>();
75 }
76 };
77
78 } // end anonymous namespace
79
80 char IPSCCPLegacyPass::ID = 0;
81
82 INITIALIZE_PASS_BEGIN(IPSCCPLegacyPass, "ipsccp",
83 "Interprocedural Sparse Conditional Constant Propagation",
84 false, false)
INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)85 INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
86 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
87 INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
88 INITIALIZE_PASS_END(IPSCCPLegacyPass, "ipsccp",
89 "Interprocedural Sparse Conditional Constant Propagation",
90 false, false)
91
92 // createIPSCCPPass - This is the public interface to this file.
93 ModulePass *llvm::createIPSCCPPass() { return new IPSCCPLegacyPass(); }
94