1 | //===- llvm/Transforms/IPO.h - Interprocedural Transformations --*- 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 | // This header file defines prototypes for accessor functions that expose passes |
10 | // in the IPO transformations library. |
11 | // |
12 | //===----------------------------------------------------------------------===// |
13 | |
14 | #ifndef LLVM_TRANSFORMS_IPO_H |
15 | #define LLVM_TRANSFORMS_IPO_H |
16 | |
17 | #include "llvm/ADT/SmallVector.h" |
18 | #include <functional> |
19 | #include <vector> |
20 | |
21 | namespace llvm { |
22 | |
23 | struct InlineParams; |
24 | class StringRef; |
25 | class ModuleSummaryIndex; |
26 | class ModulePass; |
27 | class Pass; |
28 | class BasicBlock; |
29 | class GlobalValue; |
30 | class raw_ostream; |
31 | |
32 | //===----------------------------------------------------------------------===// |
33 | // |
34 | // This pass adds !annotation metadata to entries in the |
35 | // @llvm.global.annotations global constant. |
36 | // |
37 | ModulePass *createAnnotation2MetadataLegacyPass(); |
38 | |
39 | //===----------------------------------------------------------------------===// |
40 | // |
41 | // These functions removes symbols from functions and modules. If OnlyDebugInfo |
42 | // is true, only debugging information is removed from the module. |
43 | // |
44 | ModulePass *createStripSymbolsPass(bool OnlyDebugInfo = false); |
45 | |
46 | //===----------------------------------------------------------------------===// |
47 | // |
48 | // These functions strips symbols from functions and modules. |
49 | // Only debugging information is not stripped. |
50 | // |
51 | ModulePass *createStripNonDebugSymbolsPass(); |
52 | |
53 | //===----------------------------------------------------------------------===// |
54 | // |
55 | // This pass removes llvm.dbg.declare intrinsics. |
56 | ModulePass *createStripDebugDeclarePass(); |
57 | |
58 | //===----------------------------------------------------------------------===// |
59 | // |
60 | // This pass removes unused symbols' debug info. |
61 | ModulePass *createStripDeadDebugInfoPass(); |
62 | |
63 | //===----------------------------------------------------------------------===// |
64 | /// createConstantMergePass - This function returns a new pass that merges |
65 | /// duplicate global constants together into a single constant that is shared. |
66 | /// This is useful because some passes (ie TraceValues) insert a lot of string |
67 | /// constants into the program, regardless of whether or not they duplicate an |
68 | /// existing string. |
69 | /// |
70 | ModulePass *createConstantMergePass(); |
71 | |
72 | //===----------------------------------------------------------------------===// |
73 | /// createGlobalOptimizerPass - This function returns a new pass that optimizes |
74 | /// non-address taken internal globals. |
75 | /// |
76 | ModulePass *createGlobalOptimizerPass(); |
77 | |
78 | //===----------------------------------------------------------------------===// |
79 | /// createGlobalDCEPass - This transform is designed to eliminate unreachable |
80 | /// internal globals (functions or global variables) |
81 | /// |
82 | ModulePass *createGlobalDCEPass(); |
83 | |
84 | //===----------------------------------------------------------------------===// |
85 | /// This transform is designed to eliminate available external globals |
86 | /// (functions or global variables) |
87 | /// |
88 | ModulePass *createEliminateAvailableExternallyPass(); |
89 | |
90 | //===----------------------------------------------------------------------===// |
91 | /// createGVExtractionPass - If deleteFn is true, this pass deletes |
92 | /// the specified global values. Otherwise, it deletes as much of the module as |
93 | /// possible, except for the global values specified. If keepConstInit is true, |
94 | /// the initializers of global constants are not deleted even if they are |
95 | /// unused. |
96 | /// |
97 | ModulePass *(std::vector<GlobalValue*>& GVs, bool |
98 | deleteFn = false, bool keepConstInit = false); |
99 | |
100 | //===----------------------------------------------------------------------===// |
101 | /// This pass performs iterative function importing from other modules. |
102 | Pass *createFunctionImportPass(); |
103 | |
104 | //===----------------------------------------------------------------------===// |
105 | /// createFunctionInliningPass - Return a new pass object that uses a heuristic |
106 | /// to inline direct function calls to small functions. |
107 | /// |
108 | /// The Threshold can be passed directly, or asked to be computed from the |
109 | /// given optimization and size optimization arguments. |
110 | /// |
111 | /// The -inline-threshold command line option takes precedence over the |
112 | /// threshold given here. |
113 | Pass *createFunctionInliningPass(); |
114 | Pass *createFunctionInliningPass(int Threshold); |
115 | Pass *createFunctionInliningPass(unsigned OptLevel, unsigned SizeOptLevel, |
116 | bool DisableInlineHotCallSite); |
117 | Pass *createFunctionInliningPass(InlineParams &Params); |
118 | |
119 | //===----------------------------------------------------------------------===// |
120 | /// createPruneEHPass - Return a new pass object which transforms invoke |
121 | /// instructions into calls, if the callee can _not_ unwind the stack. |
122 | /// |
123 | Pass *createPruneEHPass(); |
124 | |
125 | //===----------------------------------------------------------------------===// |
126 | /// createInternalizePass - This pass loops over all of the functions in the |
127 | /// input module, internalizing all globals (functions and variables) it can. |
128 | //// |
129 | /// Before internalizing a symbol, the callback \p MustPreserveGV is invoked and |
130 | /// gives to the client the ability to prevent internalizing specific symbols. |
131 | /// |
132 | /// The symbol in DSOList are internalized if it is safe to drop them from |
133 | /// the symbol table. |
134 | /// |
135 | /// Note that commandline options that are used with the above function are not |
136 | /// used now! |
137 | ModulePass * |
138 | createInternalizePass(std::function<bool(const GlobalValue &)> MustPreserveGV); |
139 | |
140 | /// createInternalizePass - Same as above, but with an empty exportList. |
141 | ModulePass *createInternalizePass(); |
142 | |
143 | //===----------------------------------------------------------------------===// |
144 | /// createDeadArgEliminationPass - This pass removes arguments from functions |
145 | /// which are not used by the body of the function. |
146 | /// |
147 | ModulePass *createDeadArgEliminationPass(); |
148 | |
149 | /// DeadArgHacking pass - Same as DAE, but delete arguments of external |
150 | /// functions as well. This is definitely not safe, and should only be used by |
151 | /// bugpoint. |
152 | ModulePass *createDeadArgHackingPass(); |
153 | |
154 | //===----------------------------------------------------------------------===// |
155 | /// createArgumentPromotionPass - This pass promotes "by reference" arguments to |
156 | /// be passed by value if the number of elements passed is smaller or |
157 | /// equal to maxElements (maxElements == 0 means always promote). |
158 | /// |
159 | Pass *createArgumentPromotionPass(unsigned maxElements = 3); |
160 | |
161 | //===----------------------------------------------------------------------===// |
162 | /// createOpenMPOptLegacyPass - OpenMP specific optimizations. |
163 | Pass *createOpenMPOptCGSCCLegacyPass(); |
164 | |
165 | //===----------------------------------------------------------------------===// |
166 | /// createIPSCCPPass - This pass propagates constants from call sites into the |
167 | /// bodies of functions, and keeps track of whether basic blocks are executable |
168 | /// in the process. |
169 | /// |
170 | ModulePass *createIPSCCPPass(); |
171 | |
172 | //===----------------------------------------------------------------------===// |
173 | /// createFunctionSpecializationPass - This pass propagates constants from call |
174 | /// sites to the specialized version of the callee function. |
175 | ModulePass *createFunctionSpecializationPass(); |
176 | |
177 | //===----------------------------------------------------------------------===// |
178 | // |
179 | /// createLoopExtractorPass - This pass extracts all natural loops from the |
180 | /// program into a function if it can. |
181 | /// |
182 | Pass *(); |
183 | |
184 | /// createSingleLoopExtractorPass - This pass extracts one natural loop from the |
185 | /// program into a function if it can. This is used by bugpoint. |
186 | /// |
187 | Pass *(); |
188 | |
189 | /// createBlockExtractorPass - This pass extracts all the specified blocks |
190 | /// from the functions in the module. |
191 | /// |
192 | ModulePass *(); |
193 | ModulePass * |
194 | (const SmallVectorImpl<BasicBlock *> &, |
195 | bool EraseFunctions); |
196 | ModulePass * |
197 | (const SmallVectorImpl<SmallVector<BasicBlock *, 16>> |
198 | &, |
199 | bool EraseFunctions); |
200 | |
201 | /// createStripDeadPrototypesPass - This pass removes any function declarations |
202 | /// (prototypes) that are not used. |
203 | ModulePass *createStripDeadPrototypesPass(); |
204 | |
205 | //===----------------------------------------------------------------------===// |
206 | /// createReversePostOrderFunctionAttrsPass - This pass walks SCCs of the call |
207 | /// graph in RPO to deduce and propagate function attributes. Currently it |
208 | /// only handles synthesizing norecurse attributes. |
209 | /// |
210 | Pass *createReversePostOrderFunctionAttrsPass(); |
211 | |
212 | //===----------------------------------------------------------------------===// |
213 | /// createMergeFunctionsPass - This pass discovers identical functions and |
214 | /// collapses them. |
215 | /// |
216 | ModulePass *createMergeFunctionsPass(); |
217 | |
218 | //===----------------------------------------------------------------------===// |
219 | /// createHotColdSplittingPass - This pass outlines cold blocks into a separate |
220 | /// function(s). |
221 | ModulePass *createHotColdSplittingPass(); |
222 | |
223 | //===----------------------------------------------------------------------===// |
224 | /// createIROutlinerPass - This pass finds similar code regions and factors |
225 | /// those regions out into functions. |
226 | ModulePass *createIROutlinerPass(); |
227 | |
228 | //===----------------------------------------------------------------------===// |
229 | /// createPartialInliningPass - This pass inlines parts of functions. |
230 | /// |
231 | ModulePass *createPartialInliningPass(); |
232 | |
233 | //===----------------------------------------------------------------------===// |
234 | /// createBarrierNoopPass - This pass is purely a module pass barrier in a pass |
235 | /// manager. |
236 | ModulePass *createBarrierNoopPass(); |
237 | |
238 | /// createCalledValuePropagationPass - Attach metadata to indirct call sites |
239 | /// indicating the set of functions they may target at run-time. |
240 | ModulePass *createCalledValuePropagationPass(); |
241 | |
242 | /// What to do with the summary when running passes that operate on it. |
243 | enum class PassSummaryAction { |
244 | None, ///< Do nothing. |
245 | Import, ///< Import information from summary. |
246 | Export, ///< Export information to summary. |
247 | }; |
248 | |
249 | /// This pass lowers type metadata and the llvm.type.test intrinsic to |
250 | /// bitsets. |
251 | /// |
252 | /// The behavior depends on the summary arguments: |
253 | /// - If ExportSummary is non-null, this pass will export type identifiers to |
254 | /// the given summary. |
255 | /// - If ImportSummary is non-null, this pass will import type identifiers from |
256 | /// the given summary. |
257 | /// - Otherwise, if both are null and DropTypeTests is true, all type test |
258 | /// assume sequences will be removed from the IR. |
259 | /// It is invalid for both ExportSummary and ImportSummary to be non-null |
260 | /// unless DropTypeTests is true. |
261 | ModulePass *createLowerTypeTestsPass(ModuleSummaryIndex *ExportSummary, |
262 | const ModuleSummaryIndex *ImportSummary, |
263 | bool DropTypeTests = false); |
264 | |
265 | /// This pass export CFI checks for use by external modules. |
266 | ModulePass *createCrossDSOCFIPass(); |
267 | |
268 | /// This pass implements whole-program devirtualization using type |
269 | /// metadata. |
270 | /// |
271 | /// The behavior depends on the summary arguments: |
272 | /// - If ExportSummary is non-null, this pass will export type identifiers to |
273 | /// the given summary. |
274 | /// - Otherwise, if ImportSummary is non-null, this pass will import type |
275 | /// identifiers from the given summary. |
276 | /// - Otherwise it does neither. |
277 | /// It is invalid for both ExportSummary and ImportSummary to be non-null. |
278 | ModulePass * |
279 | createWholeProgramDevirtPass(ModuleSummaryIndex *ExportSummary, |
280 | const ModuleSummaryIndex *ImportSummary); |
281 | |
282 | /// This pass splits globals into pieces for the benefit of whole-program |
283 | /// devirtualization and control-flow integrity. |
284 | ModulePass *createGlobalSplitPass(); |
285 | |
286 | //===----------------------------------------------------------------------===// |
287 | // SampleProfilePass - Loads sample profile data from disk and generates |
288 | // IR metadata to reflect the profile. |
289 | ModulePass *createSampleProfileLoaderPass(); |
290 | ModulePass *createSampleProfileLoaderPass(StringRef Name); |
291 | |
292 | /// Write ThinLTO-ready bitcode to Str. |
293 | ModulePass *createWriteThinLTOBitcodePass(raw_ostream &Str, |
294 | raw_ostream *ThinLinkOS = nullptr); |
295 | |
296 | } // End llvm namespace |
297 | |
298 | #endif |
299 | |