/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/Transforms/IPO/Inliner.h
Line | Count | Source |
1 | | //===- Inliner.h - Inliner pass and infrastructure --------------*- C++ -*-===// |
2 | | // |
3 | | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | | // See https://llvm.org/LICENSE.txt for license information. |
5 | | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | | // |
7 | | //===----------------------------------------------------------------------===// |
8 | | |
9 | | #ifndef LLVM_TRANSFORMS_IPO_INLINER_H |
10 | | #define LLVM_TRANSFORMS_IPO_INLINER_H |
11 | | |
12 | | #include "llvm/Analysis/CGSCCPassManager.h" |
13 | | #include "llvm/Analysis/CallGraphSCCPass.h" |
14 | | #include "llvm/Analysis/InlineCost.h" |
15 | | #include "llvm/Analysis/LazyCallGraph.h" |
16 | | #include "llvm/IR/CallSite.h" |
17 | | #include "llvm/IR/PassManager.h" |
18 | | #include "llvm/Transforms/Utils/ImportedFunctionsInliningStatistics.h" |
19 | | #include <utility> |
20 | | |
21 | | namespace llvm { |
22 | | |
23 | | class AssumptionCacheTracker; |
24 | | class CallGraph; |
25 | | class ProfileSummaryInfo; |
26 | | |
27 | | /// This class contains all of the helper code which is used to perform the |
28 | | /// inlining operations that do not depend on the policy. It contains the core |
29 | | /// bottom-up inlining infrastructure that specific inliner passes use. |
30 | | struct LegacyInlinerBase : public CallGraphSCCPass { |
31 | | explicit LegacyInlinerBase(char &ID); |
32 | | explicit LegacyInlinerBase(char &ID, bool InsertLifetime); |
33 | | |
34 | | /// For this class, we declare that we require and preserve the call graph. |
35 | | /// If the derived class implements this method, it should always explicitly |
36 | | /// call the implementation here. |
37 | | void getAnalysisUsage(AnalysisUsage &Info) const override; |
38 | | |
39 | | bool doInitialization(CallGraph &CG) override; |
40 | | |
41 | | /// Main run interface method, this implements the interface required by the |
42 | | /// Pass class. |
43 | | bool runOnSCC(CallGraphSCC &SCC) override; |
44 | | |
45 | | using llvm::Pass::doFinalization; |
46 | | |
47 | | /// Remove now-dead linkonce functions at the end of processing to avoid |
48 | | /// breaking the SCC traversal. |
49 | | bool doFinalization(CallGraph &CG) override; |
50 | | |
51 | | /// This method must be implemented by the subclass to determine the cost of |
52 | | /// inlining the specified call site. If the cost returned is greater than |
53 | | /// the current inline threshold, the call site is not inlined. |
54 | | virtual InlineCost getInlineCost(CallSite CS) = 0; |
55 | | |
56 | | /// Remove dead functions. |
57 | | /// |
58 | | /// This also includes a hack in the form of the 'AlwaysInlineOnly' flag |
59 | | /// which restricts it to deleting functions with an 'AlwaysInline' |
60 | | /// attribute. This is useful for the InlineAlways pass that only wants to |
61 | | /// deal with that subset of the functions. |
62 | | bool removeDeadFunctions(CallGraph &CG, bool AlwaysInlineOnly = false); |
63 | | |
64 | | /// This function performs the main work of the pass. The default of |
65 | | /// Inlinter::runOnSCC() calls skipSCC() before calling this method, but |
66 | | /// derived classes which cannot be skipped can override that method and call |
67 | | /// this function unconditionally. |
68 | | bool inlineCalls(CallGraphSCC &SCC); |
69 | | |
70 | | private: |
71 | | // Insert @llvm.lifetime intrinsics. |
72 | | bool InsertLifetime = true; |
73 | | |
74 | | protected: |
75 | | AssumptionCacheTracker *ACT; |
76 | | ProfileSummaryInfo *PSI; |
77 | | ImportedFunctionsInliningStatistics ImportedFunctionsStats; |
78 | | }; |
79 | | |
80 | | /// The inliner pass for the new pass manager. |
81 | | /// |
82 | | /// This pass wires together the inlining utilities and the inline cost |
83 | | /// analysis into a CGSCC pass. It considers every call in every function in |
84 | | /// the SCC and tries to inline if profitable. It can be tuned with a number of |
85 | | /// parameters to control what cost model is used and what tradeoffs are made |
86 | | /// when making the decision. |
87 | | /// |
88 | | /// It should be noted that the legacy inliners do considerably more than this |
89 | | /// inliner pass does. They provide logic for manually merging allocas, and |
90 | | /// doing considerable DCE including the DCE of dead functions. This pass makes |
91 | | /// every attempt to be simpler. DCE of functions requires complex reasoning |
92 | | /// about comdat groups, etc. Instead, it is expected that other more focused |
93 | | /// passes be composed to achieve the same end result. |
94 | | class InlinerPass : public PassInfoMixin<InlinerPass> { |
95 | | public: |
96 | | InlinerPass(InlineParams Params = getInlineParams()) |
97 | 316 | : Params(std::move(Params)) {} |
98 | | ~InlinerPass(); |
99 | | InlinerPass(InlinerPass &&Arg) |
100 | | : Params(std::move(Arg.Params)), |
101 | 674 | ImportedFunctionsStats(std::move(Arg.ImportedFunctionsStats)) {} |
102 | | |
103 | | PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM, |
104 | | LazyCallGraph &CG, CGSCCUpdateResult &UR); |
105 | | |
106 | | private: |
107 | | InlineParams Params; |
108 | | std::unique_ptr<ImportedFunctionsInliningStatistics> ImportedFunctionsStats; |
109 | | }; |
110 | | |
111 | | } // end namespace llvm |
112 | | |
113 | | #endif // LLVM_TRANSFORMS_IPO_INLINER_H |