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