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