LLVM  10.0.0svn
IPO.h
Go to the documentation of this file.
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 ///
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.
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.
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 ///
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 ///
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 ///
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 ///
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.
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.
244  const ModuleSummaryIndex *ImportSummary);
245 
246 /// This pass export CFI checks for use by external modules.
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 *
261  const ModuleSummaryIndex *ImportSummary);
262 
263 /// This pass splits globals into pieces for the benefit of whole-program
264 /// devirtualization and control-flow integrity.
266 
267 //===----------------------------------------------------------------------===//
268 // SampleProfilePass - Loads sample profile data from disk and generates
269 // IR metadata to reflect the profile.
272 
273 /// Write ThinLTO-ready bitcode to Str.
275  raw_ostream *ThinLinkOS = nullptr);
276 
277 } // End llvm namespace
278 
279 #endif
ModulePass * createWriteThinLTOBitcodePass(raw_ostream &Str, raw_ostream *ThinLinkOS=nullptr)
Write ThinLTO-ready bitcode to Str.
ModulePass * createIPConstantPropagationPass()
createIPConstantPropagationPass - This pass propagates constants from call sites into the bodies of f...
ModulePass * createStripDeadPrototypesPass()
createStripDeadPrototypesPass - This pass removes any function declarations (prototypes) that are not...
This class represents lattice values for constants.
Definition: AllocatorList.h:23
PassSummaryAction
What to do with the summary when running passes that operate on it.
Definition: IPO.h:227
Various leaf nodes.
Definition: ISDOpcodes.h:59
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
ModulePass * createMergeFunctionsPass()
createMergeFunctionsPass - This pass discovers identical functions and collapses them.
ModulePass * createGVExtractionPass(std::vector< GlobalValue *> &GVs, bool deleteFn=false)
createGVExtractionPass - If deleteFn is true, this pass deletes the specified global values...
Definition: ExtractGV.cpp:158
ModulePass * createIPSCCPPass()
createIPSCCPPass - This pass propagates constants from call sites into the bodies of functions...
Definition: SCCP.cpp:92
Pass * createSingleLoopExtractorPass()
createSingleLoopExtractorPass - This pass extracts one natural loop from the program into a function ...
ModulePass * createEliminateAvailableExternallyPass()
This transform is designed to eliminate available external globals (functions or global variables) ...
ModulePass * createStripNonDebugSymbolsPass()
Export information to summary.
ModulePass * createBlockExtractorPass()
createBlockExtractorPass - This pass extracts all the specified blocks from the functions in the modu...
ModulePass * createStripDeadDebugInfoPass()
ModulePass * createPartialInliningPass()
createPartialInliningPass - This pass inlines parts of functions.
ModulePass * createDeadArgHackingPass()
DeadArgHacking pass - Same as DAE, but delete arguments of external functions as well.
ModulePass * createCrossDSOCFIPass()
This pass export CFI checks for use by external modules.
Pass * createArgumentPromotionPass(unsigned maxElements=3)
createArgumentPromotionPass - This pass promotes "by reference" arguments to be passed by value if th...
ModulePass * createCalledValuePropagationPass()
createCalledValuePropagationPass - Attach metadata to indirct call sites indicating the set of functi...
ModulePass * createSampleProfileLoaderPass()
Class to hold module path string table and global value map, and encapsulate methods for operating on...
ModulePass * createGlobalDCEPass()
createGlobalDCEPass - This transform is designed to eliminate unreachable internal globals (functions...
Import information from summary.
Pass * createFunctionImportPass()
This pass performs iterative function importing from other modules.
ModulePass * createDeadArgEliminationPass()
createDeadArgEliminationPass - This pass removes arguments from functions which are not used by the b...
ModulePass * createLowerTypeTestsPass(ModuleSummaryIndex *ExportSummary, const ModuleSummaryIndex *ImportSummary)
This pass lowers type metadata and the llvm.type.test intrinsic to bitsets.
ModulePass * createBarrierNoopPass()
createBarrierNoopPass - This pass is purely a module pass barrier in a pass manager.
ModulePass * createConstantMergePass()
createConstantMergePass - This function returns a new pass that merges duplicate global constants tog...
ModulePass * createGlobalOptimizerPass()
createGlobalOptimizerPass - This function returns a new pass that optimizes non-address taken interna...
Definition: GlobalOpt.cpp:3044
Pass * createReversePostOrderFunctionAttrsPass()
createReversePostOrderFunctionAttrsPass - This pass walks SCCs of the call graph in RPO to deduce and...
ModulePass * createStripDebugDeclarePass()
ModulePass * createGlobalSplitPass()
This pass splits globals into pieces for the benefit of whole-program devirtualization and control-fl...
print lazy value Lazy Value Info Printer Pass
ModulePass * createInternalizePass(std::function< bool(const GlobalValue &)> MustPreserveGV)
createInternalizePass - This pass loops over all of the functions in the input module, internalizing all globals (functions and variables) it can.
Pass * createLoopExtractorPass()
createLoopExtractorPass - This pass extracts all natural loops from the program into a function if it...
static cl::opt< unsigned > Threshold("loop-unswitch-threshold", cl::desc("Max loop size to unswitch"), cl::init(100), cl::Hidden)
ModulePass * createWholeProgramDevirtPass(ModuleSummaryIndex *ExportSummary, const ModuleSummaryIndex *ImportSummary)
This pass implements whole-program devirtualization using type metadata.
ModulePass * createHotColdSplittingPass()
createHotColdSplittingPass - This pass outlines cold blocks into a separate function(s).
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition: Pass.h:224
Pass * createFunctionInliningPass()
createFunctionInliningPass - Return a new pass object that uses a heuristic to inline direct function...
Pass * createPruneEHPass()
createPruneEHPass - Return a new pass object which transforms invoke instructions into calls...
Definition: PruneEH.cpp:60
ModulePass * createStripSymbolsPass(bool OnlyDebugInfo=false)
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
print Print MemDeps of function
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48