blob: cf5b76dc365be4f81ef879e596a472961589ffd3 [file] [log] [blame]
Rafael Espindola3ea478b2011-08-02 21:50:27 +00001//===- PassManagerBuilder.cpp - Build Standard Pass -----------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file defines the PassManagerBuilder class, which is used to set up a
11// "standard" optimization sequence suitable for languages like C and C++.
12//
13//===----------------------------------------------------------------------===//
14
Rafael Espindola3ea478b2011-08-02 21:50:27 +000015#include "llvm/Transforms/IPO/PassManagerBuilder.h"
Rafael Espindola07f609152011-08-09 22:17:34 +000016#include "llvm-c/Transforms/PassManagerBuilder.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000017#include "llvm/ADT/SmallVector.h"
Chandler Carruth17e0bc32015-08-06 07:33:15 +000018#include "llvm/Analysis/BasicAliasAnalysis.h"
George Burgess IVbfa401e2016-07-06 00:26:41 +000019#include "llvm/Analysis/CFLAndersAliasAnalysis.h"
20#include "llvm/Analysis/CFLSteensAliasAnalysis.h"
Chandler Carruth21dcff72015-08-14 03:48:20 +000021#include "llvm/Analysis/GlobalsModRef.h"
Chandler Carruth3a040e62015-12-27 08:41:34 +000022#include "llvm/Analysis/Passes.h"
Chandler Carruth42ff4482015-08-14 02:55:50 +000023#include "llvm/Analysis/ScopedNoAliasAA.h"
Chandler Carruth62d42152015-01-15 02:16:27 +000024#include "llvm/Analysis/TargetLibraryInfo.h"
Chandler Carruth1db22822015-08-14 03:33:48 +000025#include "llvm/Analysis/TypeBasedAliasAnalysis.h"
Chandler Carruth3a040e62015-12-27 08:41:34 +000026#include "llvm/IR/DataLayout.h"
Chandler Carruth3a040e62015-12-27 08:41:34 +000027#include "llvm/IR/LegacyPassManager.h"
Teresa Johnson26ab5772016-03-15 00:04:37 +000028#include "llvm/IR/ModuleSummaryIndex.h"
Chandler Carruth3a040e62015-12-27 08:41:34 +000029#include "llvm/IR/Verifier.h"
30#include "llvm/Support/CommandLine.h"
31#include "llvm/Support/ManagedStatic.h"
Rafael Espindola7cebf362014-08-21 20:03:44 +000032#include "llvm/Target/TargetMachine.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000033#include "llvm/Transforms/IPO.h"
Chandler Carruthf49f1a872015-12-27 08:13:45 +000034#include "llvm/Transforms/IPO/ForceFunctionAttrs.h"
Chandler Carruth9c4ed172016-02-18 11:03:11 +000035#include "llvm/Transforms/IPO/FunctionAttrs.h"
Chandler Carruth3a040e62015-12-27 08:41:34 +000036#include "llvm/Transforms/IPO/InferFunctionAttrs.h"
Teresa Johnson26ab5772016-03-15 00:04:37 +000037#include "llvm/Transforms/Instrumentation.h"
Rafael Espindola3ea478b2011-08-02 21:50:27 +000038#include "llvm/Transforms/Scalar.h"
Chandler Carruth89c45a12016-03-11 08:50:55 +000039#include "llvm/Transforms/Scalar/GVN.h"
Hal Finkelc34e5112012-02-01 03:51:43 +000040#include "llvm/Transforms/Vectorize.h"
Rafael Espindola3ea478b2011-08-02 21:50:27 +000041
42using namespace llvm;
43
Hal Finkelc34e5112012-02-01 03:51:43 +000044static cl::opt<bool>
Nadav Rotem7f27e0b2013-10-18 23:38:13 +000045RunLoopVectorization("vectorize-loops", cl::Hidden,
Nadav Rotemd3df6652012-10-30 18:37:43 +000046 cl::desc("Run the Loop vectorization passes"));
Nadav Rotemc59ae202012-10-29 16:36:25 +000047
48static cl::opt<bool>
Nadav Rotem7f27e0b2013-10-18 23:38:13 +000049RunSLPVectorization("vectorize-slp", cl::Hidden,
Nadav Rotemd4dcc002013-04-15 05:39:58 +000050 cl::desc("Run the SLP vectorization passes"));
51
52static cl::opt<bool>
Nadav Rotem7f27e0b2013-10-18 23:38:13 +000053RunBBVectorization("vectorize-slp-aggressive", cl::Hidden,
Nadav Rotemd4dcc002013-04-15 05:39:58 +000054 cl::desc("Run the BB vectorization passes"));
Hal Finkelc34e5112012-02-01 03:51:43 +000055
Hal Finkel204bf532012-04-13 17:15:33 +000056static cl::opt<bool>
57UseGVNAfterVectorization("use-gvn-after-vectorization",
58 cl::init(false), cl::Hidden,
59 cl::desc("Run GVN instead of Early CSE after vectorization passes"));
60
Chandler Carruth7b8297a2014-10-14 00:31:29 +000061static cl::opt<bool> ExtraVectorizerPasses(
62 "extra-vectorizer-passes", cl::init(false), cl::Hidden,
63 cl::desc("Run cleanup optimization passes after vectorization."));
64
Hal Finkelbf45efd2013-11-16 23:59:05 +000065static cl::opt<bool>
66RunLoopRerolling("reroll-loops", cl::Hidden,
67 cl::desc("Run the loop rerolling pass"));
68
James Molloy0cbb2a862015-03-27 10:36:57 +000069static cl::opt<bool>
70RunFloat2Int("float-to-int", cl::Hidden, cl::init(true),
71 cl::desc("Run the float2int (float demotion) pass"));
72
Michael J. Spencer289067c2014-05-29 01:55:07 +000073static cl::opt<bool> RunLoadCombine("combine-loads", cl::init(false),
74 cl::Hidden,
75 cl::desc("Run the load combining pass"));
76
James Molloy568da092014-08-06 12:56:19 +000077static cl::opt<bool>
78RunSLPAfterLoopVectorization("run-slp-after-loop-vectorization",
James Molloy6b95d8e2014-09-04 13:23:08 +000079 cl::init(true), cl::Hidden,
James Molloy568da092014-08-06 12:56:19 +000080 cl::desc("Run the SLP vectorizer (and BB vectorizer) after the Loop "
81 "vectorizer instead of before"));
82
George Burgess IVbfa401e2016-07-06 00:26:41 +000083// Experimental option to use CFL-AA
84enum class CFLAAType { None, Steensgaard, Andersen, Both };
85static cl::opt<CFLAAType>
86 UseCFLAA("use-cfl-aa", cl::init(CFLAAType::None), cl::Hidden,
87 cl::desc("Enable the new, experimental CFL alias analysis"),
88 cl::values(clEnumValN(CFLAAType::None, "none", "Disable CFL-AA"),
89 clEnumValN(CFLAAType::Steensgaard, "steens",
90 "Enable unification-based CFL-AA"),
91 clEnumValN(CFLAAType::Andersen, "anders",
92 "Enable inclusion-based CFL-AA"),
93 clEnumValN(CFLAAType::Both, "both",
94 "Enable both variants of CFL-aa"),
95 clEnumValEnd));
James Molloy568da092014-08-06 12:56:19 +000096
Gerolf Hoflehner24815d92014-09-10 19:55:29 +000097static cl::opt<bool>
Gerolf Hoflehner008e5cd2014-09-10 20:24:03 +000098EnableMLSM("mlsm", cl::init(true), cl::Hidden,
99 cl::desc("Enable motion of merged load and store"));
Gerolf Hoflehner24815d92014-09-10 19:55:29 +0000100
Karthik Bhat88db86d2015-03-06 10:11:25 +0000101static cl::opt<bool> EnableLoopInterchange(
102 "enable-loopinterchange", cl::init(false), cl::Hidden,
103 cl::desc("Enable the new, experimental LoopInterchange Pass"));
104
Chandler Carruthe9ea5a62015-07-22 11:57:28 +0000105static cl::opt<bool> EnableNonLTOGlobalsModRef(
James Molloy40159252015-10-13 10:43:57 +0000106 "enable-non-lto-gmr", cl::init(true), cl::Hidden,
Chandler Carruthe9ea5a62015-07-22 11:57:28 +0000107 cl::desc(
108 "Enable the GlobalsModRef AliasAnalysis outside of the LTO pipeline."));
109
Adam Nemete54a4fa2015-11-03 23:50:08 +0000110static cl::opt<bool> EnableLoopLoadElim(
Adam Nemetc979c6e2016-03-15 22:26:12 +0000111 "enable-loop-load-elim", cl::init(true), cl::Hidden,
112 cl::desc("Enable the LoopLoadElimination Pass"));
Adam Nemete54a4fa2015-11-03 23:50:08 +0000113
Rong Xu34abbfb2016-01-21 18:28:59 +0000114static cl::opt<std::string> RunPGOInstrGen(
115 "profile-generate", cl::init(""), cl::Hidden,
116 cl::desc("Enable generation phase of PGO instrumentation and specify the "
117 "path of profile data file"));
118
119static cl::opt<std::string> RunPGOInstrUse(
120 "profile-use", cl::init(""), cl::Hidden, cl::value_desc("filename"),
121 cl::desc("Enable use phase of PGO instrumentation and specify the path "
122 "of profile data file"));
123
Ashutosh Nemadf6763a2016-02-06 07:47:48 +0000124static cl::opt<bool> UseLoopVersioningLICM(
125 "enable-loop-versioning-licm", cl::init(false), cl::Hidden,
126 cl::desc("Enable the experimental Loop Versioning LICM pass"));
127
Rong Xu96a19d32016-07-15 18:10:49 +0000128static cl::opt<bool>
129 DisablePreInliner("disable-preinline", cl::init(false), cl::Hidden,
130 cl::desc("Disable pre-instrumentation inliner"));
131
132static cl::opt<int> PreInlineThreshold(
133 "preinline-threshold", cl::Hidden, cl::init(75), cl::ZeroOrMore,
134 cl::desc("Control the amount of inlining in pre-instrumentation inliner "
135 "(default = 75)"));
136
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000137PassManagerBuilder::PassManagerBuilder() {
138 OptLevel = 2;
139 SizeLevel = 0;
Craig Topperf40110f2014-04-25 05:29:35 +0000140 LibraryInfo = nullptr;
141 Inliner = nullptr;
Teresa Johnson26ab5772016-03-15 00:04:37 +0000142 ModuleSummary = nullptr;
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000143 DisableUnitAtATime = false;
144 DisableUnrollLoops = false;
Nadav Rotemd4dcc002013-04-15 05:39:58 +0000145 BBVectorize = RunBBVectorization;
Nadav Rotema1e5e442013-04-15 04:54:42 +0000146 SLPVectorize = RunSLPVectorization;
Nadav Rotemc59ae202012-10-29 16:36:25 +0000147 LoopVectorize = RunLoopVectorization;
Hal Finkel29aeb202013-11-17 16:02:50 +0000148 RerollLoops = RunLoopRerolling;
Michael J. Spencer289067c2014-05-29 01:55:07 +0000149 LoadCombine = RunLoadCombine;
Rafael Espindola208bc532014-08-21 13:13:17 +0000150 DisableGVNLoadPRE = false;
Rafael Espindola7cebf362014-08-21 20:03:44 +0000151 VerifyInput = false;
152 VerifyOutput = false;
Nick Lewycky9e6d1842014-09-13 21:46:00 +0000153 MergeFunctions = false;
Teresa Johnsond3a33a12015-07-06 16:22:42 +0000154 PrepareForLTO = false;
Rong Xu34abbfb2016-01-21 18:28:59 +0000155 PGOInstrGen = RunPGOInstrGen;
156 PGOInstrUse = RunPGOInstrUse;
Mehdi Amini1db10ac2016-02-16 23:02:29 +0000157 PrepareForThinLTO = false;
158 PerformThinLTO = false;
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000159}
160
161PassManagerBuilder::~PassManagerBuilder() {
162 delete LibraryInfo;
163 delete Inliner;
164}
165
David Chisnall719a72f2011-08-16 13:58:41 +0000166/// Set of global extensions, automatically added as part of the standard set.
167static ManagedStatic<SmallVector<std::pair<PassManagerBuilder::ExtensionPointTy,
168 PassManagerBuilder::ExtensionFn>, 8> > GlobalExtensions;
169
170void PassManagerBuilder::addGlobalExtension(
171 PassManagerBuilder::ExtensionPointTy Ty,
172 PassManagerBuilder::ExtensionFn Fn) {
Justin Lebar2fe13232016-03-30 20:39:29 +0000173 GlobalExtensions->push_back(std::make_pair(Ty, std::move(Fn)));
David Chisnall719a72f2011-08-16 13:58:41 +0000174}
175
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000176void PassManagerBuilder::addExtension(ExtensionPointTy Ty, ExtensionFn Fn) {
Justin Lebar2fe13232016-03-30 20:39:29 +0000177 Extensions.push_back(std::make_pair(Ty, std::move(Fn)));
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000178}
179
180void PassManagerBuilder::addExtensionsToPM(ExtensionPointTy ETy,
Chandler Carruth30d69c22015-02-13 10:01:29 +0000181 legacy::PassManagerBase &PM) const {
David Chisnall719a72f2011-08-16 13:58:41 +0000182 for (unsigned i = 0, e = GlobalExtensions->size(); i != e; ++i)
183 if ((*GlobalExtensions)[i].first == ETy)
184 (*GlobalExtensions)[i].second(*this, PM);
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000185 for (unsigned i = 0, e = Extensions.size(); i != e; ++i)
186 if (Extensions[i].first == ETy)
187 Extensions[i].second(*this, PM);
188}
189
Chandler Carruth30d69c22015-02-13 10:01:29 +0000190void PassManagerBuilder::addInitialAliasAnalysisPasses(
191 legacy::PassManagerBase &PM) const {
George Burgess IVbfa401e2016-07-06 00:26:41 +0000192 switch (UseCFLAA) {
193 case CFLAAType::Steensgaard:
194 PM.add(createCFLSteensAAWrapperPass());
195 break;
196 case CFLAAType::Andersen:
197 PM.add(createCFLAndersAAWrapperPass());
198 break;
199 case CFLAAType::Both:
200 PM.add(createCFLSteensAAWrapperPass());
201 PM.add(createCFLAndersAAWrapperPass());
202 break;
203 default:
204 break;
205 }
206
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000207 // Add TypeBasedAliasAnalysis before BasicAliasAnalysis so that
208 // BasicAliasAnalysis wins if they disagree. This is intended to help
209 // support "obvious" type-punning idioms.
Chandler Carruth7b560d42015-09-09 17:55:00 +0000210 PM.add(createTypeBasedAAWrapperPass());
211 PM.add(createScopedNoAliasAAWrapperPass());
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000212}
213
Matthias Braunc31032d2016-03-09 18:47:11 +0000214void PassManagerBuilder::addInstructionCombiningPass(
215 legacy::PassManagerBase &PM) const {
216 bool ExpensiveCombines = OptLevel > 2;
217 PM.add(createInstructionCombiningPass(ExpensiveCombines));
218}
219
Chandler Carruth30d69c22015-02-13 10:01:29 +0000220void PassManagerBuilder::populateFunctionPassManager(
221 legacy::FunctionPassManager &FPM) {
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000222 addExtensionsToPM(EP_EarlyAsPossible, FPM);
223
224 // Add LibraryInfo if we have some.
Chandler Carruthb98f63d2015-01-15 10:41:28 +0000225 if (LibraryInfo)
226 FPM.add(new TargetLibraryInfoWrapperPass(*LibraryInfo));
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000227
228 if (OptLevel == 0) return;
229
230 addInitialAliasAnalysisPasses(FPM);
231
232 FPM.add(createCFGSimplificationPass());
David Majnemercbf614a2016-06-15 00:19:09 +0000233 FPM.add(createSROAPass());
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000234 FPM.add(createEarlyCSEPass());
Sebastian Pop41774802016-07-15 13:45:20 +0000235 FPM.add(createGVNHoistPass());
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000236 FPM.add(createLowerExpectIntrinsicPass());
237}
238
Rong Xu34abbfb2016-01-21 18:28:59 +0000239// Do PGO instrumentation generation or use pass as the option specified.
240void PassManagerBuilder::addPGOInstrPasses(legacy::PassManagerBase &MPM) {
Rong Xu96a19d32016-07-15 18:10:49 +0000241 if (PGOInstrGen.empty() && PGOInstrUse.empty())
242 return;
243 // Perform the preinline and cleanup passes for O1 and above.
244 // And avoid doing them if optimizing for size.
245 if (OptLevel > 0 && SizeLevel == 0 && !DisablePreInliner) {
246 // Create preinline pass.
247 MPM.add(createFunctionInliningPass(PreInlineThreshold));
248 MPM.add(createSROAPass());
249 MPM.add(createEarlyCSEPass()); // Catch trivial redundancies
250 MPM.add(createCFGSimplificationPass()); // Merge & remove BBs
251 MPM.add(createInstructionCombiningPass()); // Combine silly seq's
252 addExtensionsToPM(EP_Peephole, MPM);
253 }
Rong Xu34abbfb2016-01-21 18:28:59 +0000254 if (!PGOInstrGen.empty()) {
Xinliang David Li8aebf442016-05-06 05:49:19 +0000255 MPM.add(createPGOInstrumentationGenLegacyPass());
Rong Xu34abbfb2016-01-21 18:28:59 +0000256 // Add the profile lowering pass.
257 InstrProfOptions Options;
258 Options.InstrProfileOutput = PGOInstrGen;
Xinliang David Lie6b89292016-04-18 17:47:38 +0000259 MPM.add(createInstrProfilingLegacyPass(Options));
Rong Xu34abbfb2016-01-21 18:28:59 +0000260 }
261 if (!PGOInstrUse.empty())
Xinliang David Lid55827f2016-05-07 05:39:12 +0000262 MPM.add(createPGOInstrumentationUseLegacyPass(PGOInstrUse));
Rong Xu34abbfb2016-01-21 18:28:59 +0000263}
Mehdi Aminiec8bee12016-02-16 22:54:27 +0000264void PassManagerBuilder::addFunctionSimplificationPasses(
Mehdi Amini9c1c3ac2016-02-11 22:09:11 +0000265 legacy::PassManagerBase &MPM) {
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000266 // Start of function pass.
267 // Break up aggregate allocas, using SSAUpdater.
David Majnemercbf614a2016-06-15 00:19:09 +0000268 MPM.add(createSROAPass());
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000269 MPM.add(createEarlyCSEPass()); // Catch trivial redundancies
Justin Lebarcf63b642016-04-15 00:32:12 +0000270 // Speculative execution if the target has divergent branches; otherwise nop.
271 MPM.add(createSpeculativeExecutionIfHasBranchDivergencePass());
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000272 MPM.add(createJumpThreadingPass()); // Thread jumps.
273 MPM.add(createCorrelatedValuePropagationPass()); // Propagate conditionals
274 MPM.add(createCFGSimplificationPass()); // Merge & remove BBs
Matthias Braunc31032d2016-03-09 18:47:11 +0000275 // Combine silly seq's
276 addInstructionCombiningPass(MPM);
Peter Collingbourne0a437612014-05-25 10:27:02 +0000277 addExtensionsToPM(EP_Peephole, MPM);
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000278
Akira Hatanakad9699bc2015-06-09 19:07:19 +0000279 MPM.add(createTailCallEliminationPass()); // Eliminate tail calls
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000280 MPM.add(createCFGSimplificationPass()); // Merge & remove BBs
281 MPM.add(createReassociatePass()); // Reassociate expressions
Roman Divackyd2b9a1b2014-11-21 19:53:24 +0000282 // Rotate Loop - disable header duplication at -Oz
283 MPM.add(createLoopRotatePass(SizeLevel == 2 ? 0 : -1));
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000284 MPM.add(createLICMPass()); // Hoist loop invariants
285 MPM.add(createLoopUnswitchPass(SizeLevel || OptLevel < 3));
Michael Zolotukhin74621cc2015-09-24 03:50:17 +0000286 MPM.add(createCFGSimplificationPass());
Matthias Braunc31032d2016-03-09 18:47:11 +0000287 addInstructionCombiningPass(MPM);
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000288 MPM.add(createIndVarSimplifyPass()); // Canonicalize indvars
289 MPM.add(createLoopIdiomPass()); // Recognize idioms like memset.
290 MPM.add(createLoopDeletionPass()); // Delete dead loops
Karthik Bhat8210fdf2015-04-23 04:51:44 +0000291 if (EnableLoopInterchange) {
Karthik Bhat88db86d2015-03-06 10:11:25 +0000292 MPM.add(createLoopInterchangePass()); // Interchange loops
Karthik Bhat8210fdf2015-04-23 04:51:44 +0000293 MPM.add(createCFGSimplificationPass());
294 }
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000295 if (!DisableUnrollLoops)
Hal Finkel86b30642014-03-31 23:23:51 +0000296 MPM.add(createSimpleLoopUnrollPass()); // Unroll small loops
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000297 addExtensionsToPM(EP_LoopOptimizerEnd, MPM);
298
Gerolf Hoflehnerf27ae6c2014-07-18 19:13:09 +0000299 if (OptLevel > 1) {
Gerolf Hoflehner24815d92014-09-10 19:55:29 +0000300 if (EnableMLSM)
301 MPM.add(createMergedLoadStoreMotionPass()); // Merge ld/st in diamonds
Rafael Espindola208bc532014-08-21 13:13:17 +0000302 MPM.add(createGVNPass(DisableGVNLoadPRE)); // Remove redundancies
Gerolf Hoflehnerf27ae6c2014-07-18 19:13:09 +0000303 }
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000304 MPM.add(createMemCpyOptPass()); // Remove memcpy / form memset
305 MPM.add(createSCCPPass()); // Constant prop with SCCP
306
Hal Finkel2bb61ba2015-02-17 01:36:59 +0000307 // Delete dead bit computations (instcombine runs after to fold away the dead
308 // computations, and then ADCE will run later to exploit any new DCE
309 // opportunities that creates).
310 MPM.add(createBitTrackingDCEPass()); // Delete dead bit computations
311
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000312 // Run instcombine after redundancy elimination to exploit opportunities
313 // opened up by them.
Matthias Braunc31032d2016-03-09 18:47:11 +0000314 addInstructionCombiningPass(MPM);
Peter Collingbourne0a437612014-05-25 10:27:02 +0000315 addExtensionsToPM(EP_Peephole, MPM);
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000316 MPM.add(createJumpThreadingPass()); // Thread jumps
317 MPM.add(createCorrelatedValuePropagationPass());
318 MPM.add(createDeadStoreEliminationPass()); // Delete dead stores
James Molloy83570242015-02-16 18:59:54 +0000319 MPM.add(createLICMPass());
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000320
321 addExtensionsToPM(EP_ScalarOptimizerLate, MPM);
322
Hal Finkel29aeb202013-11-17 16:02:50 +0000323 if (RerollLoops)
Hal Finkelbf45efd2013-11-16 23:59:05 +0000324 MPM.add(createLoopRerollPass());
James Molloy568da092014-08-06 12:56:19 +0000325 if (!RunSLPAfterLoopVectorization) {
326 if (SLPVectorize)
327 MPM.add(createSLPVectorizerPass()); // Vectorize parallel scalar chains.
Nadav Rotemd4dcc002013-04-15 05:39:58 +0000328
James Molloy568da092014-08-06 12:56:19 +0000329 if (BBVectorize) {
330 MPM.add(createBBVectorizePass());
Matthias Braunc31032d2016-03-09 18:47:11 +0000331 addInstructionCombiningPass(MPM);
James Molloy568da092014-08-06 12:56:19 +0000332 addExtensionsToPM(EP_Peephole, MPM);
333 if (OptLevel > 1 && UseGVNAfterVectorization)
Rafael Espindola208bc532014-08-21 13:13:17 +0000334 MPM.add(createGVNPass(DisableGVNLoadPRE)); // Remove redundancies
James Molloy568da092014-08-06 12:56:19 +0000335 else
336 MPM.add(createEarlyCSEPass()); // Catch trivial redundancies
Hal Finkelbf4db4f2013-01-29 00:22:49 +0000337
James Molloy568da092014-08-06 12:56:19 +0000338 // BBVectorize may have significantly shortened a loop body; unroll again.
339 if (!DisableUnrollLoops)
340 MPM.add(createLoopUnrollPass());
341 }
Hal Finkelc34e5112012-02-01 03:51:43 +0000342 }
343
Michael J. Spencer289067c2014-05-29 01:55:07 +0000344 if (LoadCombine)
345 MPM.add(createLoadCombinePass());
346
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000347 MPM.add(createAggressiveDCEPass()); // Delete dead instructions
Tom Stellardaa664d92013-08-06 02:43:45 +0000348 MPM.add(createCFGSimplificationPass()); // Merge & remove BBs
Matthias Braunc31032d2016-03-09 18:47:11 +0000349 // Clean up after everything.
350 addInstructionCombiningPass(MPM);
Peter Collingbourne0a437612014-05-25 10:27:02 +0000351 addExtensionsToPM(EP_Peephole, MPM);
Mehdi Aminiec8bee12016-02-16 22:54:27 +0000352}
353
354void PassManagerBuilder::populateModulePassManager(
355 legacy::PassManagerBase &MPM) {
356 // Allow forcing function attributes as a debugging and tuning aid.
357 MPM.add(createForceFunctionAttrsLegacyPass());
358
359 // If all optimizations are disabled, just run the always-inline pass and,
360 // if enabled, the function merging pass.
361 if (OptLevel == 0) {
362 addPGOInstrPasses(MPM);
363 if (Inliner) {
364 MPM.add(Inliner);
365 Inliner = nullptr;
366 }
367
368 // FIXME: The BarrierNoopPass is a HACK! The inliner pass above implicitly
369 // creates a CGSCC pass manager, but we don't want to add extensions into
370 // that pass manager. To prevent this we insert a no-op module pass to reset
371 // the pass manager to get the same behavior as EP_OptimizerLast in non-O0
372 // builds. The function merging pass is
373 if (MergeFunctions)
374 MPM.add(createMergeFunctionsPass());
375 else if (!GlobalExtensions->empty() || !Extensions.empty())
376 MPM.add(createBarrierNoopPass());
377
378 addExtensionsToPM(EP_EnabledOnOptLevel0, MPM);
379 return;
380 }
381
382 // Add LibraryInfo if we have some.
383 if (LibraryInfo)
384 MPM.add(new TargetLibraryInfoWrapperPass(*LibraryInfo));
385
386 addInitialAliasAnalysisPasses(MPM);
387
388 if (!DisableUnitAtATime) {
389 // Infer attributes about declarations if possible.
390 MPM.add(createInferFunctionAttrsLegacyPass());
391
392 addExtensionsToPM(EP_ModuleOptimizerEarly, MPM);
393
394 MPM.add(createIPSCCPPass()); // IP SCCP
395 MPM.add(createGlobalOptimizerPass()); // Optimize out global vars
396 // Promote any localized global vars.
397 MPM.add(createPromoteMemoryToRegisterPass());
398
399 MPM.add(createDeadArgEliminationPass()); // Dead argument elimination
400
Matthias Braunc31032d2016-03-09 18:47:11 +0000401 addInstructionCombiningPass(MPM); // Clean up after IPCP & DAE
Mehdi Aminiec8bee12016-02-16 22:54:27 +0000402 addExtensionsToPM(EP_Peephole, MPM);
403 MPM.add(createCFGSimplificationPass()); // Clean up after IPCP & DAE
404 }
405
Rong Xu6e34c492016-04-27 23:20:27 +0000406 if (!PerformThinLTO) {
Mehdi Amini1db10ac2016-02-16 23:02:29 +0000407 /// PGO instrumentation is added during the compile phase for ThinLTO, do
408 /// not run it a second time
409 addPGOInstrPasses(MPM);
Rong Xu6e34c492016-04-27 23:20:27 +0000410 }
Mehdi Aminiec8bee12016-02-16 22:54:27 +0000411
Teresa Johnsoncd21a642016-07-17 14:47:01 +0000412 // Indirect call promotion that promotes intra-module targets only.
413 MPM.add(createPGOIndirectCallPromotionLegacyPass());
414
Mehdi Aminiec8bee12016-02-16 22:54:27 +0000415 if (EnableNonLTOGlobalsModRef)
416 // We add a module alias analysis pass here. In part due to bugs in the
417 // analysis infrastructure this "works" in that the analysis stays alive
418 // for the entire SCC pass run below.
419 MPM.add(createGlobalsAAWrapperPass());
420
421 // Start of CallGraph SCC passes.
422 if (!DisableUnitAtATime)
423 MPM.add(createPruneEHPass()); // Remove dead EH info
424 if (Inliner) {
425 MPM.add(Inliner);
426 Inliner = nullptr;
427 }
428 if (!DisableUnitAtATime)
Chandler Carruth9c4ed172016-02-18 11:03:11 +0000429 MPM.add(createPostOrderFunctionAttrsLegacyPass());
Mehdi Aminiec8bee12016-02-16 22:54:27 +0000430 if (OptLevel > 2)
431 MPM.add(createArgumentPromotionPass()); // Scalarize uninlined fn args
432
433 addFunctionSimplificationPasses(MPM);
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000434
Mehdi Amini45c7b3e2016-05-02 16:53:16 +0000435 // FIXME: This is a HACK! The inliner pass above implicitly creates a CGSCC
436 // pass manager that we are specifically trying to avoid. To prevent this
437 // we must insert a no-op module pass to reset the pass manager.
438 MPM.add(createBarrierNoopPass());
439
Mehdi Amini7f7d8be2016-05-03 15:46:00 +0000440 if (!DisableUnitAtATime && OptLevel > 1 && !PrepareForLTO &&
441 !PrepareForThinLTO)
442 // Remove avail extern fns and globals definitions if we aren't
443 // compiling an object file for later LTO. For LTO we want to preserve
444 // these so they are eligible for inlining at link-time. Note if they
445 // are unreferenced they will be removed by GlobalDCE later, so
446 // this only impacts referenced available externally globals.
447 // Eventually they will be suppressed during codegen, but eliminating
448 // here enables more opportunity for GlobalDCE as it may make
449 // globals referenced by available external functions dead
450 // and saves running remaining passes on the eliminated functions.
451 MPM.add(createEliminateAvailableExternallyPass());
452
Mehdi Amini45c7b3e2016-05-02 16:53:16 +0000453 if (!DisableUnitAtATime)
454 MPM.add(createReversePostOrderFunctionAttrsPass());
455
Mehdi Amini1db10ac2016-02-16 23:02:29 +0000456 // If we are planning to perform ThinLTO later, let's not bloat the code with
457 // unrolling/vectorization/... now. We'll first run the inliner + CGSCC passes
458 // during ThinLTO and perform the rest of the optimizations afterward.
Mehdi Aminif72ca86b2016-04-25 08:47:37 +0000459 if (PrepareForThinLTO) {
Mehdi Aminibf4513b2016-04-25 08:47:49 +0000460 // Reduce the size of the IR as much as possible.
461 MPM.add(createGlobalOptimizerPass());
Mehdi Aminif72ca86b2016-04-25 08:47:37 +0000462 // Rename anon function to be able to export them in the summary.
463 MPM.add(createNameAnonFunctionPass());
Mehdi Amini1db10ac2016-02-16 23:02:29 +0000464 return;
Mehdi Aminif72ca86b2016-04-25 08:47:37 +0000465 }
Mehdi Amini1db10ac2016-02-16 23:02:29 +0000466
Mehdi Amini31407ba2016-05-06 18:17:03 +0000467 if (PerformThinLTO)
468 // Optimize globals now when performing ThinLTO, this enables more
469 // optimizations later.
470 MPM.add(createGlobalOptimizerPass());
471
Ashutosh Nema2260a3a2016-02-11 09:23:53 +0000472 // Scheduling LoopVersioningLICM when inlining is over, because after that
Ashutosh Nemadf6763a2016-02-06 07:47:48 +0000473 // we may see more accurate aliasing. Reason to run this late is that too
474 // early versioning may prevent further inlining due to increase of code
Mehdi Amini31407ba2016-05-06 18:17:03 +0000475 // size. By placing it just after inlining other optimizations which runs
476 // later might get benefit of no-alias assumption in clone loop.
Ashutosh Nemadf6763a2016-02-06 07:47:48 +0000477 if (UseLoopVersioningLICM) {
478 MPM.add(createLoopVersioningLICMPass()); // Do LoopVersioningLICM
479 MPM.add(createLICMPass()); // Hoist loop invariants
480 }
481
Chandler Carruth08eebe22015-07-23 09:34:01 +0000482 if (EnableNonLTOGlobalsModRef)
483 // We add a fresh GlobalsModRef run at this point. This is particularly
484 // useful as the above will have inlined, DCE'ed, and function-attr
485 // propagated everything. We should at this point have a reasonably minimal
486 // and richly annotated call graph. By computing aliasing and mod/ref
487 // information for all local globals here, the late loop passes and notably
488 // the vectorizer will be able to use them to help recognize vectorizable
489 // memory operations.
490 //
491 // Note that this relies on a bug in the pass manager which preserves
492 // a module analysis into a function pass pipeline (and throughout it) so
493 // long as the first function pass doesn't invalidate the module analysis.
494 // Thus both Float2Int and LoopRotate have to preserve AliasAnalysis for
495 // this to work. Fortunately, it is trivial to preserve AliasAnalysis
496 // (doing nothing preserves it as it is required to be conservatively
497 // correct in the face of IR changes).
Chandler Carruth7b560d42015-09-09 17:55:00 +0000498 MPM.add(createGlobalsAAWrapperPass());
Chandler Carruth08eebe22015-07-23 09:34:01 +0000499
James Molloy0cbb2a862015-03-27 10:36:57 +0000500 if (RunFloat2Int)
501 MPM.add(createFloat2IntPass());
502
Tobias Grosser39a7bd12015-07-16 08:20:37 +0000503 addExtensionsToPM(EP_VectorizerStart, MPM);
504
Chandler Carruth7b8297a2014-10-14 00:31:29 +0000505 // Re-rotate loops in all our loop nests. These may have fallout out of
506 // rotated form due to GVN or other transformations, and the vectorizer relies
Alexey Bataevda33d802015-07-10 10:37:09 +0000507 // on the rotated form. Disable header duplication at -Oz.
508 MPM.add(createLoopRotatePass(SizeLevel == 2 ? 0 : -1));
Chandler Carruth7b8297a2014-10-14 00:31:29 +0000509
Adam Nemet938d3d62015-05-14 12:05:18 +0000510 // Distribute loops to allow partial vectorization. I.e. isolate dependences
Adam Nemetd2fa4142016-04-27 05:28:18 +0000511 // into separate loop that would otherwise inhibit vectorization. This is
512 // currently only performed for loops marked with the metadata
513 // llvm.loop.distribute=true or when -enable-loop-distribute is specified.
514 MPM.add(createLoopDistributePass(/*ProcessAllLoopsByDefault=*/false));
Adam Nemet938d3d62015-05-14 12:05:18 +0000515
Renato Golin729a3ae2013-12-05 21:20:02 +0000516 MPM.add(createLoopVectorizePass(DisableUnrollLoops, LoopVectorize));
Adam Nemete54a4fa2015-11-03 23:50:08 +0000517
518 // Eliminate loads by forwarding stores from the previous iteration to loads
519 // of the current iteration.
520 if (EnableLoopLoadElim)
521 MPM.add(createLoopLoadEliminationPass());
522
Renato Golin729a3ae2013-12-05 21:20:02 +0000523 // FIXME: Because of #pragma vectorize enable, the passes below are always
524 // inserted in the pipeline, even when the vectorizer doesn't run (ex. when
525 // on -O1 and no #pragma is found). Would be good to have these two passes
526 // as function calls, so that we can only pass them when the vectorizer
527 // changed the code.
Matthias Braunc31032d2016-03-09 18:47:11 +0000528 addInstructionCombiningPass(MPM);
Chandler Carruth7b8297a2014-10-14 00:31:29 +0000529 if (OptLevel > 1 && ExtraVectorizerPasses) {
530 // At higher optimization levels, try to clean up any runtime overlap and
531 // alignment checks inserted by the vectorizer. We want to track correllated
532 // runtime checks for two inner loops in the same outer loop, fold any
533 // common computations, hoist loop-invariant aspects out of any outer loop,
534 // and unswitch the runtime checks if possible. Once hoisted, we may have
535 // dead (or speculatable) control flows or more combining opportunities.
536 MPM.add(createEarlyCSEPass());
537 MPM.add(createCorrelatedValuePropagationPass());
Matthias Braunc31032d2016-03-09 18:47:11 +0000538 addInstructionCombiningPass(MPM);
Chandler Carruth7b8297a2014-10-14 00:31:29 +0000539 MPM.add(createLICMPass());
540 MPM.add(createLoopUnswitchPass(SizeLevel || OptLevel < 3));
541 MPM.add(createCFGSimplificationPass());
Matthias Braunc31032d2016-03-09 18:47:11 +0000542 addInstructionCombiningPass(MPM);
Chandler Carruth7b8297a2014-10-14 00:31:29 +0000543 }
James Molloy568da092014-08-06 12:56:19 +0000544
545 if (RunSLPAfterLoopVectorization) {
Chandler Carruth7b8297a2014-10-14 00:31:29 +0000546 if (SLPVectorize) {
James Molloy568da092014-08-06 12:56:19 +0000547 MPM.add(createSLPVectorizerPass()); // Vectorize parallel scalar chains.
Chandler Carruth7b8297a2014-10-14 00:31:29 +0000548 if (OptLevel > 1 && ExtraVectorizerPasses) {
549 MPM.add(createEarlyCSEPass());
550 }
551 }
James Molloy568da092014-08-06 12:56:19 +0000552
553 if (BBVectorize) {
554 MPM.add(createBBVectorizePass());
Matthias Braunc31032d2016-03-09 18:47:11 +0000555 addInstructionCombiningPass(MPM);
James Molloy568da092014-08-06 12:56:19 +0000556 addExtensionsToPM(EP_Peephole, MPM);
557 if (OptLevel > 1 && UseGVNAfterVectorization)
Rafael Espindola208bc532014-08-21 13:13:17 +0000558 MPM.add(createGVNPass(DisableGVNLoadPRE)); // Remove redundancies
James Molloy568da092014-08-06 12:56:19 +0000559 else
560 MPM.add(createEarlyCSEPass()); // Catch trivial redundancies
561
562 // BBVectorize may have significantly shortened a loop body; unroll again.
563 if (!DisableUnrollLoops)
564 MPM.add(createLoopUnrollPass());
565 }
566 }
567
Peter Collingbourne0a437612014-05-25 10:27:02 +0000568 addExtensionsToPM(EP_Peephole, MPM);
Renato Golin729a3ae2013-12-05 21:20:02 +0000569 MPM.add(createCFGSimplificationPass());
Matthias Braunc31032d2016-03-09 18:47:11 +0000570 addInstructionCombiningPass(MPM);
Chandler Carruth08e1b872013-06-24 07:21:47 +0000571
Kevin Qin49bc7642015-03-12 05:36:01 +0000572 if (!DisableUnrollLoops) {
Hal Finkel86b30642014-03-31 23:23:51 +0000573 MPM.add(createLoopUnrollPass()); // Unroll small loops
574
Wei Mibf727ba2015-05-14 22:02:54 +0000575 // LoopUnroll may generate some redundency to cleanup.
Matthias Braunc31032d2016-03-09 18:47:11 +0000576 addInstructionCombiningPass(MPM);
Wei Mibf727ba2015-05-14 22:02:54 +0000577
Kevin Qin49bc7642015-03-12 05:36:01 +0000578 // Runtime unrolling will introduce runtime check in loop prologue. If the
579 // unrolled loop is a inner loop, then the prologue will be inside the
580 // outer loop. LICM pass can help to promote the runtime check out if the
581 // checked value is loop invariant.
582 MPM.add(createLICMPass());
Manuel Jacoba4859842016-06-02 22:14:26 +0000583
584 // Get rid of LCSSA nodes.
585 MPM.add(createInstructionSimplifierPass());
Kevin Qin49bc7642015-03-12 05:36:01 +0000586 }
587
Hal Finkeld67e4632014-09-07 20:05:11 +0000588 // After vectorization and unrolling, assume intrinsics may tell us more
589 // about pointer alignments.
590 MPM.add(createAlignmentFromAssumptionsPass());
591
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000592 if (!DisableUnitAtATime) {
593 // FIXME: We shouldn't bother with this anymore.
594 MPM.add(createStripDeadPrototypesPass()); // Get rid of dead prototypes
595
Evan Cheng8c6b06d2012-09-28 21:23:26 +0000596 // GlobalOpt already deletes dead functions and globals, at -O2 try a
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000597 // late pass of GlobalDCE. It is capable of deleting dead cycles.
Evan Cheng8c6b06d2012-09-28 21:23:26 +0000598 if (OptLevel > 1) {
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000599 MPM.add(createGlobalDCEPass()); // Remove dead fns and globals.
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000600 MPM.add(createConstantMergePass()); // Merge dup global constants
Evan Cheng8c6b06d2012-09-28 21:23:26 +0000601 }
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000602 }
Nick Lewycky9e6d1842014-09-13 21:46:00 +0000603
604 if (MergeFunctions)
605 MPM.add(createMergeFunctionsPass());
606
Kostya Serebryanye505a5a2012-03-23 23:22:59 +0000607 addExtensionsToPM(EP_OptimizerLast, MPM);
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000608}
609
Chandler Carruth30d69c22015-02-13 10:01:29 +0000610void PassManagerBuilder::addLTOOptimizationPasses(legacy::PassManagerBase &PM) {
Peter Collingbournefad596a2016-05-25 21:26:14 +0000611 // Remove unused virtual tables to improve the quality of code generated by
612 // whole-program devirtualization and bitset lowering.
613 PM.add(createGlobalDCEPass());
614
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000615 // Provide AliasAnalysis services for optimizations.
616 addInitialAliasAnalysisPasses(PM);
617
Teresa Johnson26ab5772016-03-15 00:04:37 +0000618 if (ModuleSummary)
619 PM.add(createFunctionImportPass(ModuleSummary));
Teresa Johnson5fcbdb72015-12-07 19:21:11 +0000620
Chandler Carruthf49f1a872015-12-27 08:13:45 +0000621 // Allow forcing function attributes as a debugging and tuning aid.
622 PM.add(createForceFunctionAttrsLegacyPass());
623
Chandler Carruth3a040e62015-12-27 08:41:34 +0000624 // Infer attributes about declarations if possible.
625 PM.add(createInferFunctionAttrsLegacyPass());
626
Peter Collingbournefad596a2016-05-25 21:26:14 +0000627 if (OptLevel > 1) {
628 // Indirect call promotion. This should promote all the targets that are
629 // left by the earlier promotion pass that promotes intra-module targets.
630 // This two-step promotion is to save the compile time. For LTO, it should
631 // produce the same result as if we only do promotion here.
632 PM.add(createPGOIndirectCallPromotionLegacyPass(true));
Rong Xu6e34c492016-04-27 23:20:27 +0000633
Peter Collingbournefad596a2016-05-25 21:26:14 +0000634 // Propagate constants at call sites into the functions they call. This
635 // opens opportunities for globalopt (and inlining) by substituting function
636 // pointers passed as arguments to direct uses of functions.
637 PM.add(createIPSCCPPass());
638 }
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000639
Peter Collingbournefad596a2016-05-25 21:26:14 +0000640 // Infer attributes about definitions. The readnone attribute in particular is
641 // required for virtual constant propagation.
Chandler Carruth9c4ed172016-02-18 11:03:11 +0000642 PM.add(createPostOrderFunctionAttrsLegacyPass());
Chandler Carruth1926b702016-01-08 10:55:52 +0000643 PM.add(createReversePostOrderFunctionAttrsPass());
Peter Collingbournefad596a2016-05-25 21:26:14 +0000644
645 // Apply whole-program devirtualization and virtual constant propagation.
646 PM.add(createWholeProgramDevirtPass());
647
648 // That's all we need at opt level 1.
649 if (OptLevel == 1)
650 return;
651
652 // Now that we internalized some globals, see if we can hack on them!
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000653 PM.add(createGlobalOptimizerPass());
James Molloy6045cc82015-12-15 09:24:01 +0000654 // Promote any localized global vars.
655 PM.add(createPromoteMemoryToRegisterPass());
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000656
657 // Linking modules together can lead to duplicated global constants, only
658 // keep one copy of each constant.
659 PM.add(createConstantMergePass());
660
661 // Remove unused arguments from functions.
662 PM.add(createDeadArgEliminationPass());
663
664 // Reduce the code after globalopt and ipsccp. Both can open up significant
665 // simplification opportunities, and both can propagate functions through
666 // function pointers. When this happens, we often have to resolve varargs
667 // calls, etc, so let instcombine do this.
Matthias Braunc31032d2016-03-09 18:47:11 +0000668 addInstructionCombiningPass(PM);
Peter Collingbourne0a437612014-05-25 10:27:02 +0000669 addExtensionsToPM(EP_Peephole, PM);
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000670
671 // Inline small functions
Rafael Espindolae07caad2014-08-21 13:35:30 +0000672 bool RunInliner = Inliner;
673 if (RunInliner) {
674 PM.add(Inliner);
675 Inliner = nullptr;
676 }
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000677
678 PM.add(createPruneEHPass()); // Remove dead EH info.
679
680 // Optimize globals again if we ran the inliner.
681 if (RunInliner)
682 PM.add(createGlobalOptimizerPass());
683 PM.add(createGlobalDCEPass()); // Remove dead functions.
684
685 // If we didn't decide to inline a function, check to see if we can
686 // transform it to pass arguments by value instead of by reference.
687 PM.add(createArgumentPromotionPass());
688
689 // The IPO passes may leave cruft around. Clean up after them.
Matthias Braunc31032d2016-03-09 18:47:11 +0000690 addInstructionCombiningPass(PM);
Peter Collingbourne0a437612014-05-25 10:27:02 +0000691 addExtensionsToPM(EP_Peephole, PM);
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000692 PM.add(createJumpThreadingPass());
Bill Wendling4c0d9ad2013-08-30 00:48:37 +0000693
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000694 // Break up allocas
David Majnemercbf614a2016-06-15 00:19:09 +0000695 PM.add(createSROAPass());
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000696
697 // Run a few AA driven optimizations here and now, to cleanup the code.
Chandler Carruth9c4ed172016-02-18 11:03:11 +0000698 PM.add(createPostOrderFunctionAttrsLegacyPass()); // Add nocapture.
Chandler Carruth7b560d42015-09-09 17:55:00 +0000699 PM.add(createGlobalsAAWrapperPass()); // IP alias analysis.
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000700
Bill Wendling932b9922012-04-02 22:16:50 +0000701 PM.add(createLICMPass()); // Hoist loop invariants.
Gerolf Hoflehner24815d92014-09-10 19:55:29 +0000702 if (EnableMLSM)
703 PM.add(createMergedLoadStoreMotionPass()); // Merge ld/st in diamonds.
Bill Wendling932b9922012-04-02 22:16:50 +0000704 PM.add(createGVNPass(DisableGVNLoadPRE)); // Remove redundancies.
705 PM.add(createMemCpyOptPass()); // Remove dead memcpys.
Bill Wendling4c0d9ad2013-08-30 00:48:37 +0000706
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000707 // Nuke dead stores.
708 PM.add(createDeadStoreEliminationPass());
709
Duncan P. N. Exon Smith2b691892014-04-15 17:48:15 +0000710 // More loops are countable; try to optimize them.
711 PM.add(createIndVarSimplifyPass());
712 PM.add(createLoopDeletionPass());
Karthik Bhat88db86d2015-03-06 10:11:25 +0000713 if (EnableLoopInterchange)
714 PM.add(createLoopInterchangePass());
715
James Molloy31f3ddd2016-01-14 15:00:09 +0000716 if (!DisableUnrollLoops)
717 PM.add(createSimpleLoopUnrollPass()); // Unroll small loops
Arnold Schwaighofereb1a38f2014-10-26 21:50:58 +0000718 PM.add(createLoopVectorizePass(true, LoopVectorize));
James Molloy31f3ddd2016-01-14 15:00:09 +0000719 // The vectorizer may have significantly shortened a loop body; unroll again.
720 if (!DisableUnrollLoops)
721 PM.add(createLoopUnrollPass());
Arnold Schwaighofer6ccda922014-02-24 18:19:31 +0000722
James Molloy6045cc82015-12-15 09:24:01 +0000723 // Now that we've optimized loops (in particular loop induction variables),
724 // we may have exposed more scalar opportunities. Run parts of the scalar
725 // optimizer again at this point.
Matthias Braunc31032d2016-03-09 18:47:11 +0000726 addInstructionCombiningPass(PM); // Initial cleanup
James Molloy6045cc82015-12-15 09:24:01 +0000727 PM.add(createCFGSimplificationPass()); // if-convert
728 PM.add(createSCCPPass()); // Propagate exposed constants
Matthias Braunc31032d2016-03-09 18:47:11 +0000729 addInstructionCombiningPass(PM); // Clean up again
James Molloy6045cc82015-12-15 09:24:01 +0000730 PM.add(createBitTrackingDCEPass());
731
Yi Jiang79eb0aa2014-05-05 23:14:46 +0000732 // More scalar chains could be vectorized due to more alias information
JF Bastienf42a6ea2014-10-21 23:18:21 +0000733 if (RunSLPAfterLoopVectorization)
734 if (SLPVectorize)
735 PM.add(createSLPVectorizerPass()); // Vectorize parallel scalar chains.
Yi Jiang79eb0aa2014-05-05 23:14:46 +0000736
Hal Finkeld67e4632014-09-07 20:05:11 +0000737 // After vectorization, assume intrinsics may tell us more about pointer
738 // alignments.
739 PM.add(createAlignmentFromAssumptionsPass());
740
Michael J. Spencer289067c2014-05-29 01:55:07 +0000741 if (LoadCombine)
742 PM.add(createLoadCombinePass());
743
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000744 // Cleanup and simplify the code after the scalar optimizations.
Matthias Braunc31032d2016-03-09 18:47:11 +0000745 addInstructionCombiningPass(PM);
Peter Collingbourne0a437612014-05-25 10:27:02 +0000746 addExtensionsToPM(EP_Peephole, PM);
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000747
748 PM.add(createJumpThreadingPass());
Peter Collingbourne070843d2015-03-19 22:01:00 +0000749}
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000750
Peter Collingbourne070843d2015-03-19 22:01:00 +0000751void PassManagerBuilder::addLateLTOOptimizationPasses(
752 legacy::PassManagerBase &PM) {
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000753 // Delete basic blocks, which optimization passes may have killed.
Tom Stellardaa664d92013-08-06 02:43:45 +0000754 PM.add(createCFGSimplificationPass());
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000755
Teresa Johnsonc4279a72015-08-11 16:26:41 +0000756 // Drop bodies of available externally objects to improve GlobalDCE.
757 PM.add(createEliminateAvailableExternallyPass());
758
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000759 // Now that we have optimized the program, discard unreachable functions.
760 PM.add(createGlobalDCEPass());
Nick Lewycky9e6d1842014-09-13 21:46:00 +0000761
762 // FIXME: this is profitable (for compiler time) to do at -O0 too, but
763 // currently it damages debug info.
764 if (MergeFunctions)
765 PM.add(createMergeFunctionsPass());
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000766}
Rafael Espindola07f609152011-08-09 22:17:34 +0000767
Mehdi Amini1db10ac2016-02-16 23:02:29 +0000768void PassManagerBuilder::populateThinLTOPassManager(
769 legacy::PassManagerBase &PM) {
770 PerformThinLTO = true;
771
772 if (VerifyInput)
773 PM.add(createVerifierPass());
774
Teresa Johnson26ab5772016-03-15 00:04:37 +0000775 if (ModuleSummary)
776 PM.add(createFunctionImportPass(ModuleSummary));
Mehdi Amini1db10ac2016-02-16 23:02:29 +0000777
778 populateModulePassManager(PM);
779
780 if (VerifyOutput)
781 PM.add(createVerifierPass());
782 PerformThinLTO = false;
783}
784
Chandler Carruth30d69c22015-02-13 10:01:29 +0000785void PassManagerBuilder::populateLTOPassManager(legacy::PassManagerBase &PM) {
Rafael Espindola7cebf362014-08-21 20:03:44 +0000786 if (LibraryInfo)
Chandler Carruthb98f63d2015-01-15 10:41:28 +0000787 PM.add(new TargetLibraryInfoWrapperPass(*LibraryInfo));
Rafael Espindola7cebf362014-08-21 20:03:44 +0000788
Duncan P. N. Exon Smithab58a562015-03-19 22:24:17 +0000789 if (VerifyInput)
Rafael Espindola7cebf362014-08-21 20:03:44 +0000790 PM.add(createVerifierPass());
Rafael Espindola7cebf362014-08-21 20:03:44 +0000791
Peter Collingbournedf49d1b2016-02-09 22:50:34 +0000792 if (OptLevel != 0)
Rafael Espindola7cebf362014-08-21 20:03:44 +0000793 addLTOOptimizationPasses(PM);
794
Evgeniy Stepanov67849d52015-12-15 23:00:08 +0000795 // Create a function that performs CFI checks for cross-DSO calls with targets
796 // in the current module.
797 PM.add(createCrossDSOCFIPass());
798
Peter Collingbourne7efd7502016-06-24 21:21:32 +0000799 // Lower type metadata and the type.test intrinsic. This pass supports Clang's
800 // control flow integrity mechanisms (-fsanitize=cfi*) and needs to run at
801 // link time if CFI is enabled. The pass does nothing if CFI is disabled.
802 PM.add(createLowerTypeTestsPass());
Peter Collingbourne070843d2015-03-19 22:01:00 +0000803
804 if (OptLevel != 0)
805 addLateLTOOptimizationPasses(PM);
806
Duncan P. N. Exon Smithab58a562015-03-19 22:24:17 +0000807 if (VerifyOutput)
Rafael Espindola7cebf362014-08-21 20:03:44 +0000808 PM.add(createVerifierPass());
Rafael Espindola7cebf362014-08-21 20:03:44 +0000809}
810
Eric Christopher04d4e932013-04-22 22:47:22 +0000811inline PassManagerBuilder *unwrap(LLVMPassManagerBuilderRef P) {
812 return reinterpret_cast<PassManagerBuilder*>(P);
813}
814
815inline LLVMPassManagerBuilderRef wrap(PassManagerBuilder *P) {
816 return reinterpret_cast<LLVMPassManagerBuilderRef>(P);
817}
818
Dmitri Gribenko0011bbf2012-11-15 16:51:49 +0000819LLVMPassManagerBuilderRef LLVMPassManagerBuilderCreate() {
Rafael Espindola07f609152011-08-09 22:17:34 +0000820 PassManagerBuilder *PMB = new PassManagerBuilder();
821 return wrap(PMB);
822}
823
824void LLVMPassManagerBuilderDispose(LLVMPassManagerBuilderRef PMB) {
825 PassManagerBuilder *Builder = unwrap(PMB);
826 delete Builder;
827}
828
829void
830LLVMPassManagerBuilderSetOptLevel(LLVMPassManagerBuilderRef PMB,
831 unsigned OptLevel) {
832 PassManagerBuilder *Builder = unwrap(PMB);
833 Builder->OptLevel = OptLevel;
834}
835
836void
837LLVMPassManagerBuilderSetSizeLevel(LLVMPassManagerBuilderRef PMB,
838 unsigned SizeLevel) {
839 PassManagerBuilder *Builder = unwrap(PMB);
840 Builder->SizeLevel = SizeLevel;
841}
842
843void
844LLVMPassManagerBuilderSetDisableUnitAtATime(LLVMPassManagerBuilderRef PMB,
845 LLVMBool Value) {
846 PassManagerBuilder *Builder = unwrap(PMB);
847 Builder->DisableUnitAtATime = Value;
848}
849
850void
851LLVMPassManagerBuilderSetDisableUnrollLoops(LLVMPassManagerBuilderRef PMB,
852 LLVMBool Value) {
853 PassManagerBuilder *Builder = unwrap(PMB);
854 Builder->DisableUnrollLoops = Value;
855}
856
857void
858LLVMPassManagerBuilderSetDisableSimplifyLibCalls(LLVMPassManagerBuilderRef PMB,
859 LLVMBool Value) {
Meador Ingedfb08a22013-06-20 19:48:07 +0000860 // NOTE: The simplify-libcalls pass has been removed.
Rafael Espindola07f609152011-08-09 22:17:34 +0000861}
862
863void
864LLVMPassManagerBuilderUseInlinerWithThreshold(LLVMPassManagerBuilderRef PMB,
865 unsigned Threshold) {
866 PassManagerBuilder *Builder = unwrap(PMB);
867 Builder->Inliner = createFunctionInliningPass(Threshold);
868}
869
870void
871LLVMPassManagerBuilderPopulateFunctionPassManager(LLVMPassManagerBuilderRef PMB,
872 LLVMPassManagerRef PM) {
873 PassManagerBuilder *Builder = unwrap(PMB);
Chandler Carruth30d69c22015-02-13 10:01:29 +0000874 legacy::FunctionPassManager *FPM = unwrap<legacy::FunctionPassManager>(PM);
Rafael Espindola07f609152011-08-09 22:17:34 +0000875 Builder->populateFunctionPassManager(*FPM);
876}
877
878void
879LLVMPassManagerBuilderPopulateModulePassManager(LLVMPassManagerBuilderRef PMB,
880 LLVMPassManagerRef PM) {
881 PassManagerBuilder *Builder = unwrap(PMB);
Chandler Carruth30d69c22015-02-13 10:01:29 +0000882 legacy::PassManagerBase *MPM = unwrap(PM);
Rafael Espindola07f609152011-08-09 22:17:34 +0000883 Builder->populateModulePassManager(*MPM);
884}
885
886void LLVMPassManagerBuilderPopulateLTOPassManager(LLVMPassManagerBuilderRef PMB,
887 LLVMPassManagerRef PM,
Nick Lewycky5f508542013-03-10 21:58:22 +0000888 LLVMBool Internalize,
889 LLVMBool RunInliner) {
Rafael Espindola07f609152011-08-09 22:17:34 +0000890 PassManagerBuilder *Builder = unwrap(PMB);
Chandler Carruth30d69c22015-02-13 10:01:29 +0000891 legacy::PassManagerBase *LPM = unwrap(PM);
Rafael Espindolae07caad2014-08-21 13:35:30 +0000892
893 // A small backwards compatibility hack. populateLTOPassManager used to take
894 // an RunInliner option.
895 if (RunInliner && !Builder->Inliner)
896 Builder->Inliner = createFunctionInliningPass();
897
898 Builder->populateLTOPassManager(*LPM);
Rafael Espindola07f609152011-08-09 22:17:34 +0000899}