blob: 71e479aac553f434e5eae881fcff15448427a2c5 [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"
Easwaran Raman61edc102016-08-11 18:24:08 +000022#include "llvm/Analysis/InlineCost.h"
Chandler Carruth3a040e62015-12-27 08:41:34 +000023#include "llvm/Analysis/Passes.h"
Chandler Carruth42ff4482015-08-14 02:55:50 +000024#include "llvm/Analysis/ScopedNoAliasAA.h"
Chandler Carruth62d42152015-01-15 02:16:27 +000025#include "llvm/Analysis/TargetLibraryInfo.h"
Chandler Carruth1db22822015-08-14 03:33:48 +000026#include "llvm/Analysis/TypeBasedAliasAnalysis.h"
Chandler Carruth3a040e62015-12-27 08:41:34 +000027#include "llvm/IR/DataLayout.h"
Chandler Carruth3a040e62015-12-27 08:41:34 +000028#include "llvm/IR/LegacyPassManager.h"
Teresa Johnson26ab5772016-03-15 00:04:37 +000029#include "llvm/IR/ModuleSummaryIndex.h"
Chandler Carruth3a040e62015-12-27 08:41:34 +000030#include "llvm/IR/Verifier.h"
31#include "llvm/Support/CommandLine.h"
32#include "llvm/Support/ManagedStatic.h"
Rafael Espindola7cebf362014-08-21 20:03:44 +000033#include "llvm/Target/TargetMachine.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000034#include "llvm/Transforms/IPO.h"
Chandler Carruthf49f1a872015-12-27 08:13:45 +000035#include "llvm/Transforms/IPO/ForceFunctionAttrs.h"
Chandler Carruth9c4ed172016-02-18 11:03:11 +000036#include "llvm/Transforms/IPO/FunctionAttrs.h"
Chandler Carruth3a040e62015-12-27 08:41:34 +000037#include "llvm/Transforms/IPO/InferFunctionAttrs.h"
Teresa Johnson26ab5772016-03-15 00:04:37 +000038#include "llvm/Transforms/Instrumentation.h"
Rafael Espindola3ea478b2011-08-02 21:50:27 +000039#include "llvm/Transforms/Scalar.h"
Chandler Carruth89c45a12016-03-11 08:50:55 +000040#include "llvm/Transforms/Scalar/GVN.h"
Hal Finkelc34e5112012-02-01 03:51:43 +000041#include "llvm/Transforms/Vectorize.h"
Rafael Espindola3ea478b2011-08-02 21:50:27 +000042
43using namespace llvm;
44
Hal Finkelc34e5112012-02-01 03:51:43 +000045static cl::opt<bool>
Nadav Rotem7f27e0b2013-10-18 23:38:13 +000046RunLoopVectorization("vectorize-loops", cl::Hidden,
Nadav Rotemd3df6652012-10-30 18:37:43 +000047 cl::desc("Run the Loop vectorization passes"));
Nadav Rotemc59ae202012-10-29 16:36:25 +000048
49static cl::opt<bool>
Nadav Rotem7f27e0b2013-10-18 23:38:13 +000050RunSLPVectorization("vectorize-slp", cl::Hidden,
Nadav Rotemd4dcc002013-04-15 05:39:58 +000051 cl::desc("Run the SLP vectorization passes"));
52
53static cl::opt<bool>
Nadav Rotem7f27e0b2013-10-18 23:38:13 +000054RunBBVectorization("vectorize-slp-aggressive", cl::Hidden,
Nadav Rotemd4dcc002013-04-15 05:39:58 +000055 cl::desc("Run the BB vectorization passes"));
Hal Finkelc34e5112012-02-01 03:51:43 +000056
Hal Finkel204bf532012-04-13 17:15:33 +000057static cl::opt<bool>
58UseGVNAfterVectorization("use-gvn-after-vectorization",
59 cl::init(false), cl::Hidden,
60 cl::desc("Run GVN instead of Early CSE after vectorization passes"));
61
Chandler Carruth7b8297a2014-10-14 00:31:29 +000062static cl::opt<bool> ExtraVectorizerPasses(
63 "extra-vectorizer-passes", cl::init(false), cl::Hidden,
64 cl::desc("Run cleanup optimization passes after vectorization."));
65
Hal Finkelbf45efd2013-11-16 23:59:05 +000066static cl::opt<bool>
67RunLoopRerolling("reroll-loops", cl::Hidden,
68 cl::desc("Run the loop rerolling pass"));
69
James Molloy0cbb2a862015-03-27 10:36:57 +000070static cl::opt<bool>
71RunFloat2Int("float-to-int", cl::Hidden, cl::init(true),
72 cl::desc("Run the float2int (float demotion) pass"));
73
Michael J. Spencer289067c2014-05-29 01:55:07 +000074static cl::opt<bool> RunLoadCombine("combine-loads", cl::init(false),
75 cl::Hidden,
76 cl::desc("Run the load combining pass"));
77
James Molloy568da092014-08-06 12:56:19 +000078static cl::opt<bool>
79RunSLPAfterLoopVectorization("run-slp-after-loop-vectorization",
James Molloy6b95d8e2014-09-04 13:23:08 +000080 cl::init(true), cl::Hidden,
James Molloy568da092014-08-06 12:56:19 +000081 cl::desc("Run the SLP vectorizer (and BB vectorizer) after the Loop "
82 "vectorizer instead of before"));
83
George Burgess IVbfa401e2016-07-06 00:26:41 +000084// Experimental option to use CFL-AA
85enum class CFLAAType { None, Steensgaard, Andersen, Both };
86static cl::opt<CFLAAType>
87 UseCFLAA("use-cfl-aa", cl::init(CFLAAType::None), cl::Hidden,
88 cl::desc("Enable the new, experimental CFL alias analysis"),
89 cl::values(clEnumValN(CFLAAType::None, "none", "Disable CFL-AA"),
90 clEnumValN(CFLAAType::Steensgaard, "steens",
91 "Enable unification-based CFL-AA"),
92 clEnumValN(CFLAAType::Andersen, "anders",
93 "Enable inclusion-based CFL-AA"),
94 clEnumValN(CFLAAType::Both, "both",
George Burgess IVf84bb6fa2016-07-20 23:14:29 +000095 "Enable both variants of CFL-AA"),
George Burgess IVbfa401e2016-07-06 00:26:41 +000096 clEnumValEnd));
James Molloy568da092014-08-06 12:56:19 +000097
Gerolf Hoflehner24815d92014-09-10 19:55:29 +000098static cl::opt<bool>
Gerolf Hoflehner008e5cd2014-09-10 20:24:03 +000099EnableMLSM("mlsm", cl::init(true), cl::Hidden,
100 cl::desc("Enable motion of merged load and store"));
Gerolf Hoflehner24815d92014-09-10 19:55:29 +0000101
Karthik Bhat88db86d2015-03-06 10:11:25 +0000102static cl::opt<bool> EnableLoopInterchange(
103 "enable-loopinterchange", cl::init(false), cl::Hidden,
104 cl::desc("Enable the new, experimental LoopInterchange Pass"));
105
Chandler Carruthe9ea5a62015-07-22 11:57:28 +0000106static cl::opt<bool> EnableNonLTOGlobalsModRef(
James Molloy40159252015-10-13 10:43:57 +0000107 "enable-non-lto-gmr", cl::init(true), cl::Hidden,
Chandler Carruthe9ea5a62015-07-22 11:57:28 +0000108 cl::desc(
109 "Enable the GlobalsModRef AliasAnalysis outside of the LTO pipeline."));
110
Adam Nemete54a4fa2015-11-03 23:50:08 +0000111static cl::opt<bool> EnableLoopLoadElim(
Adam Nemetc979c6e2016-03-15 22:26:12 +0000112 "enable-loop-load-elim", cl::init(true), cl::Hidden,
113 cl::desc("Enable the LoopLoadElimination Pass"));
Adam Nemete54a4fa2015-11-03 23:50:08 +0000114
Xinliang David Li92392452016-07-23 04:28:52 +0000115static cl::opt<bool> RunPGOInstrGen(
116 "profile-generate", cl::init(false), cl::Hidden,
117 cl::desc("Enable PGO instrumentation."));
118
119static cl::opt<std::string>
120 PGOOutputFile("profile-generate-file", cl::init(""), cl::Hidden,
121 cl::desc("Specify the path of profile data file."));
Rong Xu34abbfb2016-01-21 18:28:59 +0000122
123static cl::opt<std::string> RunPGOInstrUse(
124 "profile-use", cl::init(""), cl::Hidden, cl::value_desc("filename"),
125 cl::desc("Enable use phase of PGO instrumentation and specify the path "
126 "of profile data file"));
127
Ashutosh Nemadf6763a2016-02-06 07:47:48 +0000128static cl::opt<bool> UseLoopVersioningLICM(
129 "enable-loop-versioning-licm", cl::init(false), cl::Hidden,
130 cl::desc("Enable the experimental Loop Versioning LICM pass"));
131
Rong Xu96a19d32016-07-15 18:10:49 +0000132static cl::opt<bool>
133 DisablePreInliner("disable-preinline", cl::init(false), cl::Hidden,
134 cl::desc("Disable pre-instrumentation inliner"));
135
136static cl::opt<int> PreInlineThreshold(
137 "preinline-threshold", cl::Hidden, cl::init(75), cl::ZeroOrMore,
138 cl::desc("Control the amount of inlining in pre-instrumentation inliner "
139 "(default = 75)"));
140
Alina Sbirleaba21ffe2016-07-22 22:02:19 +0000141static cl::opt<bool> EnableGVNHoist(
Sebastian Popbfb96c52016-08-08 14:46:15 +0000142 "enable-gvn-hoist", cl::init(true), cl::Hidden,
143 cl::desc("Enable the GVN hoisting pass (default = on)"));
Alina Sbirleaba21ffe2016-07-22 22:02:19 +0000144
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000145PassManagerBuilder::PassManagerBuilder() {
146 OptLevel = 2;
147 SizeLevel = 0;
Craig Topperf40110f2014-04-25 05:29:35 +0000148 LibraryInfo = nullptr;
149 Inliner = nullptr;
Teresa Johnson26ab5772016-03-15 00:04:37 +0000150 ModuleSummary = nullptr;
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000151 DisableUnitAtATime = false;
152 DisableUnrollLoops = false;
Nadav Rotemd4dcc002013-04-15 05:39:58 +0000153 BBVectorize = RunBBVectorization;
Nadav Rotema1e5e442013-04-15 04:54:42 +0000154 SLPVectorize = RunSLPVectorization;
Nadav Rotemc59ae202012-10-29 16:36:25 +0000155 LoopVectorize = RunLoopVectorization;
Hal Finkel29aeb202013-11-17 16:02:50 +0000156 RerollLoops = RunLoopRerolling;
Michael J. Spencer289067c2014-05-29 01:55:07 +0000157 LoadCombine = RunLoadCombine;
Rafael Espindola208bc532014-08-21 13:13:17 +0000158 DisableGVNLoadPRE = false;
Rafael Espindola7cebf362014-08-21 20:03:44 +0000159 VerifyInput = false;
160 VerifyOutput = false;
Nick Lewycky9e6d1842014-09-13 21:46:00 +0000161 MergeFunctions = false;
Teresa Johnsond3a33a12015-07-06 16:22:42 +0000162 PrepareForLTO = false;
Xinliang David Li92392452016-07-23 04:28:52 +0000163 EnablePGOInstrGen = RunPGOInstrGen;
164 PGOInstrGen = PGOOutputFile;
Rong Xu34abbfb2016-01-21 18:28:59 +0000165 PGOInstrUse = RunPGOInstrUse;
Mehdi Amini1db10ac2016-02-16 23:02:29 +0000166 PrepareForThinLTO = false;
167 PerformThinLTO = false;
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000168}
169
170PassManagerBuilder::~PassManagerBuilder() {
171 delete LibraryInfo;
172 delete Inliner;
173}
174
David Chisnall719a72f2011-08-16 13:58:41 +0000175/// Set of global extensions, automatically added as part of the standard set.
176static ManagedStatic<SmallVector<std::pair<PassManagerBuilder::ExtensionPointTy,
177 PassManagerBuilder::ExtensionFn>, 8> > GlobalExtensions;
178
179void PassManagerBuilder::addGlobalExtension(
180 PassManagerBuilder::ExtensionPointTy Ty,
181 PassManagerBuilder::ExtensionFn Fn) {
Justin Lebar2fe13232016-03-30 20:39:29 +0000182 GlobalExtensions->push_back(std::make_pair(Ty, std::move(Fn)));
David Chisnall719a72f2011-08-16 13:58:41 +0000183}
184
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000185void PassManagerBuilder::addExtension(ExtensionPointTy Ty, ExtensionFn Fn) {
Justin Lebar2fe13232016-03-30 20:39:29 +0000186 Extensions.push_back(std::make_pair(Ty, std::move(Fn)));
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000187}
188
189void PassManagerBuilder::addExtensionsToPM(ExtensionPointTy ETy,
Chandler Carruth30d69c22015-02-13 10:01:29 +0000190 legacy::PassManagerBase &PM) const {
David Chisnall719a72f2011-08-16 13:58:41 +0000191 for (unsigned i = 0, e = GlobalExtensions->size(); i != e; ++i)
192 if ((*GlobalExtensions)[i].first == ETy)
193 (*GlobalExtensions)[i].second(*this, PM);
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000194 for (unsigned i = 0, e = Extensions.size(); i != e; ++i)
195 if (Extensions[i].first == ETy)
196 Extensions[i].second(*this, PM);
197}
198
Chandler Carruth30d69c22015-02-13 10:01:29 +0000199void PassManagerBuilder::addInitialAliasAnalysisPasses(
200 legacy::PassManagerBase &PM) const {
George Burgess IVbfa401e2016-07-06 00:26:41 +0000201 switch (UseCFLAA) {
202 case CFLAAType::Steensgaard:
203 PM.add(createCFLSteensAAWrapperPass());
204 break;
205 case CFLAAType::Andersen:
206 PM.add(createCFLAndersAAWrapperPass());
207 break;
208 case CFLAAType::Both:
209 PM.add(createCFLSteensAAWrapperPass());
210 PM.add(createCFLAndersAAWrapperPass());
211 break;
212 default:
213 break;
214 }
215
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000216 // Add TypeBasedAliasAnalysis before BasicAliasAnalysis so that
217 // BasicAliasAnalysis wins if they disagree. This is intended to help
218 // support "obvious" type-punning idioms.
Chandler Carruth7b560d42015-09-09 17:55:00 +0000219 PM.add(createTypeBasedAAWrapperPass());
220 PM.add(createScopedNoAliasAAWrapperPass());
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000221}
222
Matthias Braunc31032d2016-03-09 18:47:11 +0000223void PassManagerBuilder::addInstructionCombiningPass(
224 legacy::PassManagerBase &PM) const {
225 bool ExpensiveCombines = OptLevel > 2;
226 PM.add(createInstructionCombiningPass(ExpensiveCombines));
227}
228
Chandler Carruth30d69c22015-02-13 10:01:29 +0000229void PassManagerBuilder::populateFunctionPassManager(
230 legacy::FunctionPassManager &FPM) {
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000231 addExtensionsToPM(EP_EarlyAsPossible, FPM);
232
233 // Add LibraryInfo if we have some.
Chandler Carruthb98f63d2015-01-15 10:41:28 +0000234 if (LibraryInfo)
235 FPM.add(new TargetLibraryInfoWrapperPass(*LibraryInfo));
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000236
237 if (OptLevel == 0) return;
238
239 addInitialAliasAnalysisPasses(FPM);
240
241 FPM.add(createCFGSimplificationPass());
David Majnemercbf614a2016-06-15 00:19:09 +0000242 FPM.add(createSROAPass());
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000243 FPM.add(createEarlyCSEPass());
Alina Sbirleaba21ffe2016-07-22 22:02:19 +0000244 if(EnableGVNHoist)
245 FPM.add(createGVNHoistPass());
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000246 FPM.add(createLowerExpectIntrinsicPass());
247}
248
Rong Xu34abbfb2016-01-21 18:28:59 +0000249// Do PGO instrumentation generation or use pass as the option specified.
250void PassManagerBuilder::addPGOInstrPasses(legacy::PassManagerBase &MPM) {
Xinliang David Li92392452016-07-23 04:28:52 +0000251 if (!EnablePGOInstrGen && PGOInstrUse.empty())
Rong Xu96a19d32016-07-15 18:10:49 +0000252 return;
253 // Perform the preinline and cleanup passes for O1 and above.
254 // And avoid doing them if optimizing for size.
255 if (OptLevel > 0 && SizeLevel == 0 && !DisablePreInliner) {
Easwaran Raman61edc102016-08-11 18:24:08 +0000256 // Create preinline pass. We construct an InlineParams object and specify
257 // the threshold here to avoid the command line options of the regular
258 // inliner to influence pre-inlining. The only fields of InlineParams we
259 // care about are DefaultThreshold and HintThreshold.
260 InlineParams IP;
261 IP.DefaultThreshold = PreInlineThreshold;
262 // FIXME: The hint threshold has the same value used by the regular inliner.
263 // This should probably be lowered after performance testing.
264 IP.HintThreshold = 325;
265
266 MPM.add(createFunctionInliningPass(IP));
Rong Xu96a19d32016-07-15 18:10:49 +0000267 MPM.add(createSROAPass());
268 MPM.add(createEarlyCSEPass()); // Catch trivial redundancies
269 MPM.add(createCFGSimplificationPass()); // Merge & remove BBs
270 MPM.add(createInstructionCombiningPass()); // Combine silly seq's
271 addExtensionsToPM(EP_Peephole, MPM);
272 }
Xinliang David Li92392452016-07-23 04:28:52 +0000273 if (EnablePGOInstrGen) {
Xinliang David Li8aebf442016-05-06 05:49:19 +0000274 MPM.add(createPGOInstrumentationGenLegacyPass());
Rong Xu34abbfb2016-01-21 18:28:59 +0000275 // Add the profile lowering pass.
276 InstrProfOptions Options;
Xinliang David Li92392452016-07-23 04:28:52 +0000277 if (!PGOInstrGen.empty())
278 Options.InstrProfileOutput = PGOInstrGen;
Xinliang David Lie6b89292016-04-18 17:47:38 +0000279 MPM.add(createInstrProfilingLegacyPass(Options));
Rong Xu34abbfb2016-01-21 18:28:59 +0000280 }
281 if (!PGOInstrUse.empty())
Xinliang David Lid55827f2016-05-07 05:39:12 +0000282 MPM.add(createPGOInstrumentationUseLegacyPass(PGOInstrUse));
Rong Xu34abbfb2016-01-21 18:28:59 +0000283}
Mehdi Aminiec8bee12016-02-16 22:54:27 +0000284void PassManagerBuilder::addFunctionSimplificationPasses(
Mehdi Amini9c1c3ac2016-02-11 22:09:11 +0000285 legacy::PassManagerBase &MPM) {
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000286 // Start of function pass.
287 // Break up aggregate allocas, using SSAUpdater.
David Majnemercbf614a2016-06-15 00:19:09 +0000288 MPM.add(createSROAPass());
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000289 MPM.add(createEarlyCSEPass()); // Catch trivial redundancies
Justin Lebarcf63b642016-04-15 00:32:12 +0000290 // Speculative execution if the target has divergent branches; otherwise nop.
291 MPM.add(createSpeculativeExecutionIfHasBranchDivergencePass());
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000292 MPM.add(createJumpThreadingPass()); // Thread jumps.
293 MPM.add(createCorrelatedValuePropagationPass()); // Propagate conditionals
294 MPM.add(createCFGSimplificationPass()); // Merge & remove BBs
Matthias Braunc31032d2016-03-09 18:47:11 +0000295 // Combine silly seq's
296 addInstructionCombiningPass(MPM);
Peter Collingbourne0a437612014-05-25 10:27:02 +0000297 addExtensionsToPM(EP_Peephole, MPM);
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000298
Akira Hatanakad9699bc2015-06-09 19:07:19 +0000299 MPM.add(createTailCallEliminationPass()); // Eliminate tail calls
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000300 MPM.add(createCFGSimplificationPass()); // Merge & remove BBs
301 MPM.add(createReassociatePass()); // Reassociate expressions
Roman Divackyd2b9a1b2014-11-21 19:53:24 +0000302 // Rotate Loop - disable header duplication at -Oz
303 MPM.add(createLoopRotatePass(SizeLevel == 2 ? 0 : -1));
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000304 MPM.add(createLICMPass()); // Hoist loop invariants
305 MPM.add(createLoopUnswitchPass(SizeLevel || OptLevel < 3));
Michael Zolotukhin74621cc2015-09-24 03:50:17 +0000306 MPM.add(createCFGSimplificationPass());
Matthias Braunc31032d2016-03-09 18:47:11 +0000307 addInstructionCombiningPass(MPM);
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000308 MPM.add(createIndVarSimplifyPass()); // Canonicalize indvars
309 MPM.add(createLoopIdiomPass()); // Recognize idioms like memset.
310 MPM.add(createLoopDeletionPass()); // Delete dead loops
Karthik Bhat8210fdf2015-04-23 04:51:44 +0000311 if (EnableLoopInterchange) {
Karthik Bhat88db86d2015-03-06 10:11:25 +0000312 MPM.add(createLoopInterchangePass()); // Interchange loops
Karthik Bhat8210fdf2015-04-23 04:51:44 +0000313 MPM.add(createCFGSimplificationPass());
314 }
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000315 if (!DisableUnrollLoops)
Hal Finkel86b30642014-03-31 23:23:51 +0000316 MPM.add(createSimpleLoopUnrollPass()); // Unroll small loops
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000317 addExtensionsToPM(EP_LoopOptimizerEnd, MPM);
318
Gerolf Hoflehnerf27ae6c2014-07-18 19:13:09 +0000319 if (OptLevel > 1) {
Gerolf Hoflehner24815d92014-09-10 19:55:29 +0000320 if (EnableMLSM)
321 MPM.add(createMergedLoadStoreMotionPass()); // Merge ld/st in diamonds
Rafael Espindola208bc532014-08-21 13:13:17 +0000322 MPM.add(createGVNPass(DisableGVNLoadPRE)); // Remove redundancies
Gerolf Hoflehnerf27ae6c2014-07-18 19:13:09 +0000323 }
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000324 MPM.add(createMemCpyOptPass()); // Remove memcpy / form memset
325 MPM.add(createSCCPPass()); // Constant prop with SCCP
326
Hal Finkel2bb61ba2015-02-17 01:36:59 +0000327 // Delete dead bit computations (instcombine runs after to fold away the dead
328 // computations, and then ADCE will run later to exploit any new DCE
329 // opportunities that creates).
330 MPM.add(createBitTrackingDCEPass()); // Delete dead bit computations
331
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000332 // Run instcombine after redundancy elimination to exploit opportunities
333 // opened up by them.
Matthias Braunc31032d2016-03-09 18:47:11 +0000334 addInstructionCombiningPass(MPM);
Peter Collingbourne0a437612014-05-25 10:27:02 +0000335 addExtensionsToPM(EP_Peephole, MPM);
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000336 MPM.add(createJumpThreadingPass()); // Thread jumps
337 MPM.add(createCorrelatedValuePropagationPass());
338 MPM.add(createDeadStoreEliminationPass()); // Delete dead stores
James Molloy83570242015-02-16 18:59:54 +0000339 MPM.add(createLICMPass());
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000340
341 addExtensionsToPM(EP_ScalarOptimizerLate, MPM);
342
Hal Finkel29aeb202013-11-17 16:02:50 +0000343 if (RerollLoops)
Hal Finkelbf45efd2013-11-16 23:59:05 +0000344 MPM.add(createLoopRerollPass());
James Molloy568da092014-08-06 12:56:19 +0000345 if (!RunSLPAfterLoopVectorization) {
346 if (SLPVectorize)
347 MPM.add(createSLPVectorizerPass()); // Vectorize parallel scalar chains.
Nadav Rotemd4dcc002013-04-15 05:39:58 +0000348
James Molloy568da092014-08-06 12:56:19 +0000349 if (BBVectorize) {
350 MPM.add(createBBVectorizePass());
Matthias Braunc31032d2016-03-09 18:47:11 +0000351 addInstructionCombiningPass(MPM);
James Molloy568da092014-08-06 12:56:19 +0000352 addExtensionsToPM(EP_Peephole, MPM);
353 if (OptLevel > 1 && UseGVNAfterVectorization)
Rafael Espindola208bc532014-08-21 13:13:17 +0000354 MPM.add(createGVNPass(DisableGVNLoadPRE)); // Remove redundancies
James Molloy568da092014-08-06 12:56:19 +0000355 else
356 MPM.add(createEarlyCSEPass()); // Catch trivial redundancies
Hal Finkelbf4db4f2013-01-29 00:22:49 +0000357
James Molloy568da092014-08-06 12:56:19 +0000358 // BBVectorize may have significantly shortened a loop body; unroll again.
359 if (!DisableUnrollLoops)
360 MPM.add(createLoopUnrollPass());
361 }
Hal Finkelc34e5112012-02-01 03:51:43 +0000362 }
363
Michael J. Spencer289067c2014-05-29 01:55:07 +0000364 if (LoadCombine)
365 MPM.add(createLoadCombinePass());
366
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000367 MPM.add(createAggressiveDCEPass()); // Delete dead instructions
Tom Stellardaa664d92013-08-06 02:43:45 +0000368 MPM.add(createCFGSimplificationPass()); // Merge & remove BBs
Matthias Braunc31032d2016-03-09 18:47:11 +0000369 // Clean up after everything.
370 addInstructionCombiningPass(MPM);
Peter Collingbourne0a437612014-05-25 10:27:02 +0000371 addExtensionsToPM(EP_Peephole, MPM);
Mehdi Aminiec8bee12016-02-16 22:54:27 +0000372}
373
374void PassManagerBuilder::populateModulePassManager(
375 legacy::PassManagerBase &MPM) {
376 // Allow forcing function attributes as a debugging and tuning aid.
377 MPM.add(createForceFunctionAttrsLegacyPass());
378
379 // If all optimizations are disabled, just run the always-inline pass and,
380 // if enabled, the function merging pass.
381 if (OptLevel == 0) {
382 addPGOInstrPasses(MPM);
383 if (Inliner) {
384 MPM.add(Inliner);
385 Inliner = nullptr;
386 }
387
388 // FIXME: The BarrierNoopPass is a HACK! The inliner pass above implicitly
389 // creates a CGSCC pass manager, but we don't want to add extensions into
390 // that pass manager. To prevent this we insert a no-op module pass to reset
391 // the pass manager to get the same behavior as EP_OptimizerLast in non-O0
392 // builds. The function merging pass is
393 if (MergeFunctions)
394 MPM.add(createMergeFunctionsPass());
395 else if (!GlobalExtensions->empty() || !Extensions.empty())
396 MPM.add(createBarrierNoopPass());
397
398 addExtensionsToPM(EP_EnabledOnOptLevel0, MPM);
399 return;
400 }
401
402 // Add LibraryInfo if we have some.
403 if (LibraryInfo)
404 MPM.add(new TargetLibraryInfoWrapperPass(*LibraryInfo));
405
406 addInitialAliasAnalysisPasses(MPM);
407
408 if (!DisableUnitAtATime) {
409 // Infer attributes about declarations if possible.
410 MPM.add(createInferFunctionAttrsLegacyPass());
411
412 addExtensionsToPM(EP_ModuleOptimizerEarly, MPM);
413
414 MPM.add(createIPSCCPPass()); // IP SCCP
415 MPM.add(createGlobalOptimizerPass()); // Optimize out global vars
416 // Promote any localized global vars.
417 MPM.add(createPromoteMemoryToRegisterPass());
418
419 MPM.add(createDeadArgEliminationPass()); // Dead argument elimination
420
Matthias Braunc31032d2016-03-09 18:47:11 +0000421 addInstructionCombiningPass(MPM); // Clean up after IPCP & DAE
Mehdi Aminiec8bee12016-02-16 22:54:27 +0000422 addExtensionsToPM(EP_Peephole, MPM);
423 MPM.add(createCFGSimplificationPass()); // Clean up after IPCP & DAE
424 }
425
Rong Xu6e34c492016-04-27 23:20:27 +0000426 if (!PerformThinLTO) {
Mehdi Amini1db10ac2016-02-16 23:02:29 +0000427 /// PGO instrumentation is added during the compile phase for ThinLTO, do
428 /// not run it a second time
429 addPGOInstrPasses(MPM);
Rong Xu6e34c492016-04-27 23:20:27 +0000430 }
Mehdi Aminiec8bee12016-02-16 22:54:27 +0000431
Teresa Johnsoncd21a642016-07-17 14:47:01 +0000432 // Indirect call promotion that promotes intra-module targets only.
433 MPM.add(createPGOIndirectCallPromotionLegacyPass());
434
Mehdi Aminiec8bee12016-02-16 22:54:27 +0000435 if (EnableNonLTOGlobalsModRef)
436 // We add a module alias analysis pass here. In part due to bugs in the
437 // analysis infrastructure this "works" in that the analysis stays alive
438 // for the entire SCC pass run below.
439 MPM.add(createGlobalsAAWrapperPass());
440
441 // Start of CallGraph SCC passes.
442 if (!DisableUnitAtATime)
443 MPM.add(createPruneEHPass()); // Remove dead EH info
444 if (Inliner) {
445 MPM.add(Inliner);
446 Inliner = nullptr;
447 }
448 if (!DisableUnitAtATime)
Chandler Carruth9c4ed172016-02-18 11:03:11 +0000449 MPM.add(createPostOrderFunctionAttrsLegacyPass());
Mehdi Aminiec8bee12016-02-16 22:54:27 +0000450 if (OptLevel > 2)
451 MPM.add(createArgumentPromotionPass()); // Scalarize uninlined fn args
452
David Majnemer6e9b47b2016-07-28 03:28:43 +0000453 addExtensionsToPM(EP_CGSCCOptimizerLate, MPM);
Mehdi Aminiec8bee12016-02-16 22:54:27 +0000454 addFunctionSimplificationPasses(MPM);
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000455
Mehdi Amini45c7b3e2016-05-02 16:53:16 +0000456 // FIXME: This is a HACK! The inliner pass above implicitly creates a CGSCC
457 // pass manager that we are specifically trying to avoid. To prevent this
458 // we must insert a no-op module pass to reset the pass manager.
459 MPM.add(createBarrierNoopPass());
460
Mehdi Amini7f7d8be2016-05-03 15:46:00 +0000461 if (!DisableUnitAtATime && OptLevel > 1 && !PrepareForLTO &&
462 !PrepareForThinLTO)
463 // Remove avail extern fns and globals definitions if we aren't
464 // compiling an object file for later LTO. For LTO we want to preserve
465 // these so they are eligible for inlining at link-time. Note if they
466 // are unreferenced they will be removed by GlobalDCE later, so
467 // this only impacts referenced available externally globals.
468 // Eventually they will be suppressed during codegen, but eliminating
469 // here enables more opportunity for GlobalDCE as it may make
470 // globals referenced by available external functions dead
471 // and saves running remaining passes on the eliminated functions.
472 MPM.add(createEliminateAvailableExternallyPass());
473
Mehdi Amini45c7b3e2016-05-02 16:53:16 +0000474 if (!DisableUnitAtATime)
475 MPM.add(createReversePostOrderFunctionAttrsPass());
476
Mehdi Amini1db10ac2016-02-16 23:02:29 +0000477 // If we are planning to perform ThinLTO later, let's not bloat the code with
478 // unrolling/vectorization/... now. We'll first run the inliner + CGSCC passes
479 // during ThinLTO and perform the rest of the optimizations afterward.
Mehdi Aminif72ca86b2016-04-25 08:47:37 +0000480 if (PrepareForThinLTO) {
Mehdi Aminibf4513b2016-04-25 08:47:49 +0000481 // Reduce the size of the IR as much as possible.
482 MPM.add(createGlobalOptimizerPass());
Mehdi Aminif72ca86b2016-04-25 08:47:37 +0000483 // Rename anon function to be able to export them in the summary.
484 MPM.add(createNameAnonFunctionPass());
Mehdi Amini1db10ac2016-02-16 23:02:29 +0000485 return;
Mehdi Aminif72ca86b2016-04-25 08:47:37 +0000486 }
Mehdi Amini1db10ac2016-02-16 23:02:29 +0000487
Mehdi Amini31407ba2016-05-06 18:17:03 +0000488 if (PerformThinLTO)
489 // Optimize globals now when performing ThinLTO, this enables more
490 // optimizations later.
491 MPM.add(createGlobalOptimizerPass());
492
Ashutosh Nema2260a3a2016-02-11 09:23:53 +0000493 // Scheduling LoopVersioningLICM when inlining is over, because after that
Ashutosh Nemadf6763a2016-02-06 07:47:48 +0000494 // we may see more accurate aliasing. Reason to run this late is that too
495 // early versioning may prevent further inlining due to increase of code
Mehdi Amini31407ba2016-05-06 18:17:03 +0000496 // size. By placing it just after inlining other optimizations which runs
497 // later might get benefit of no-alias assumption in clone loop.
Ashutosh Nemadf6763a2016-02-06 07:47:48 +0000498 if (UseLoopVersioningLICM) {
499 MPM.add(createLoopVersioningLICMPass()); // Do LoopVersioningLICM
500 MPM.add(createLICMPass()); // Hoist loop invariants
501 }
502
Chandler Carruth08eebe22015-07-23 09:34:01 +0000503 if (EnableNonLTOGlobalsModRef)
504 // We add a fresh GlobalsModRef run at this point. This is particularly
505 // useful as the above will have inlined, DCE'ed, and function-attr
506 // propagated everything. We should at this point have a reasonably minimal
507 // and richly annotated call graph. By computing aliasing and mod/ref
508 // information for all local globals here, the late loop passes and notably
509 // the vectorizer will be able to use them to help recognize vectorizable
510 // memory operations.
511 //
512 // Note that this relies on a bug in the pass manager which preserves
513 // a module analysis into a function pass pipeline (and throughout it) so
514 // long as the first function pass doesn't invalidate the module analysis.
515 // Thus both Float2Int and LoopRotate have to preserve AliasAnalysis for
516 // this to work. Fortunately, it is trivial to preserve AliasAnalysis
517 // (doing nothing preserves it as it is required to be conservatively
518 // correct in the face of IR changes).
Chandler Carruth7b560d42015-09-09 17:55:00 +0000519 MPM.add(createGlobalsAAWrapperPass());
Chandler Carruth08eebe22015-07-23 09:34:01 +0000520
James Molloy0cbb2a862015-03-27 10:36:57 +0000521 if (RunFloat2Int)
522 MPM.add(createFloat2IntPass());
523
Tobias Grosser39a7bd12015-07-16 08:20:37 +0000524 addExtensionsToPM(EP_VectorizerStart, MPM);
525
Chandler Carruth7b8297a2014-10-14 00:31:29 +0000526 // Re-rotate loops in all our loop nests. These may have fallout out of
527 // rotated form due to GVN or other transformations, and the vectorizer relies
Alexey Bataevda33d802015-07-10 10:37:09 +0000528 // on the rotated form. Disable header duplication at -Oz.
529 MPM.add(createLoopRotatePass(SizeLevel == 2 ? 0 : -1));
Chandler Carruth7b8297a2014-10-14 00:31:29 +0000530
Adam Nemet938d3d62015-05-14 12:05:18 +0000531 // Distribute loops to allow partial vectorization. I.e. isolate dependences
Adam Nemetd2fa4142016-04-27 05:28:18 +0000532 // into separate loop that would otherwise inhibit vectorization. This is
533 // currently only performed for loops marked with the metadata
534 // llvm.loop.distribute=true or when -enable-loop-distribute is specified.
535 MPM.add(createLoopDistributePass(/*ProcessAllLoopsByDefault=*/false));
Adam Nemet938d3d62015-05-14 12:05:18 +0000536
Renato Golin729a3ae2013-12-05 21:20:02 +0000537 MPM.add(createLoopVectorizePass(DisableUnrollLoops, LoopVectorize));
Adam Nemete54a4fa2015-11-03 23:50:08 +0000538
539 // Eliminate loads by forwarding stores from the previous iteration to loads
540 // of the current iteration.
541 if (EnableLoopLoadElim)
542 MPM.add(createLoopLoadEliminationPass());
543
Renato Golin729a3ae2013-12-05 21:20:02 +0000544 // FIXME: Because of #pragma vectorize enable, the passes below are always
545 // inserted in the pipeline, even when the vectorizer doesn't run (ex. when
546 // on -O1 and no #pragma is found). Would be good to have these two passes
547 // as function calls, so that we can only pass them when the vectorizer
548 // changed the code.
Matthias Braunc31032d2016-03-09 18:47:11 +0000549 addInstructionCombiningPass(MPM);
Chandler Carruth7b8297a2014-10-14 00:31:29 +0000550 if (OptLevel > 1 && ExtraVectorizerPasses) {
551 // At higher optimization levels, try to clean up any runtime overlap and
552 // alignment checks inserted by the vectorizer. We want to track correllated
553 // runtime checks for two inner loops in the same outer loop, fold any
554 // common computations, hoist loop-invariant aspects out of any outer loop,
555 // and unswitch the runtime checks if possible. Once hoisted, we may have
556 // dead (or speculatable) control flows or more combining opportunities.
557 MPM.add(createEarlyCSEPass());
558 MPM.add(createCorrelatedValuePropagationPass());
Matthias Braunc31032d2016-03-09 18:47:11 +0000559 addInstructionCombiningPass(MPM);
Chandler Carruth7b8297a2014-10-14 00:31:29 +0000560 MPM.add(createLICMPass());
561 MPM.add(createLoopUnswitchPass(SizeLevel || OptLevel < 3));
562 MPM.add(createCFGSimplificationPass());
Matthias Braunc31032d2016-03-09 18:47:11 +0000563 addInstructionCombiningPass(MPM);
Chandler Carruth7b8297a2014-10-14 00:31:29 +0000564 }
James Molloy568da092014-08-06 12:56:19 +0000565
566 if (RunSLPAfterLoopVectorization) {
Chandler Carruth7b8297a2014-10-14 00:31:29 +0000567 if (SLPVectorize) {
James Molloy568da092014-08-06 12:56:19 +0000568 MPM.add(createSLPVectorizerPass()); // Vectorize parallel scalar chains.
Chandler Carruth7b8297a2014-10-14 00:31:29 +0000569 if (OptLevel > 1 && ExtraVectorizerPasses) {
570 MPM.add(createEarlyCSEPass());
571 }
572 }
James Molloy568da092014-08-06 12:56:19 +0000573
574 if (BBVectorize) {
575 MPM.add(createBBVectorizePass());
Matthias Braunc31032d2016-03-09 18:47:11 +0000576 addInstructionCombiningPass(MPM);
James Molloy568da092014-08-06 12:56:19 +0000577 addExtensionsToPM(EP_Peephole, MPM);
578 if (OptLevel > 1 && UseGVNAfterVectorization)
Rafael Espindola208bc532014-08-21 13:13:17 +0000579 MPM.add(createGVNPass(DisableGVNLoadPRE)); // Remove redundancies
James Molloy568da092014-08-06 12:56:19 +0000580 else
581 MPM.add(createEarlyCSEPass()); // Catch trivial redundancies
582
583 // BBVectorize may have significantly shortened a loop body; unroll again.
584 if (!DisableUnrollLoops)
585 MPM.add(createLoopUnrollPass());
586 }
587 }
588
Peter Collingbourne0a437612014-05-25 10:27:02 +0000589 addExtensionsToPM(EP_Peephole, MPM);
Renato Golin729a3ae2013-12-05 21:20:02 +0000590 MPM.add(createCFGSimplificationPass());
Matthias Braunc31032d2016-03-09 18:47:11 +0000591 addInstructionCombiningPass(MPM);
Chandler Carruth08e1b872013-06-24 07:21:47 +0000592
Kevin Qin49bc7642015-03-12 05:36:01 +0000593 if (!DisableUnrollLoops) {
Hal Finkel86b30642014-03-31 23:23:51 +0000594 MPM.add(createLoopUnrollPass()); // Unroll small loops
595
Wei Mibf727ba2015-05-14 22:02:54 +0000596 // LoopUnroll may generate some redundency to cleanup.
Matthias Braunc31032d2016-03-09 18:47:11 +0000597 addInstructionCombiningPass(MPM);
Wei Mibf727ba2015-05-14 22:02:54 +0000598
Kevin Qin49bc7642015-03-12 05:36:01 +0000599 // Runtime unrolling will introduce runtime check in loop prologue. If the
600 // unrolled loop is a inner loop, then the prologue will be inside the
601 // outer loop. LICM pass can help to promote the runtime check out if the
602 // checked value is loop invariant.
603 MPM.add(createLICMPass());
Manuel Jacoba4859842016-06-02 22:14:26 +0000604
605 // Get rid of LCSSA nodes.
606 MPM.add(createInstructionSimplifierPass());
Kevin Qin49bc7642015-03-12 05:36:01 +0000607 }
608
Hal Finkeld67e4632014-09-07 20:05:11 +0000609 // After vectorization and unrolling, assume intrinsics may tell us more
610 // about pointer alignments.
611 MPM.add(createAlignmentFromAssumptionsPass());
612
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000613 if (!DisableUnitAtATime) {
614 // FIXME: We shouldn't bother with this anymore.
615 MPM.add(createStripDeadPrototypesPass()); // Get rid of dead prototypes
616
Evan Cheng8c6b06d2012-09-28 21:23:26 +0000617 // GlobalOpt already deletes dead functions and globals, at -O2 try a
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000618 // late pass of GlobalDCE. It is capable of deleting dead cycles.
Evan Cheng8c6b06d2012-09-28 21:23:26 +0000619 if (OptLevel > 1) {
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000620 MPM.add(createGlobalDCEPass()); // Remove dead fns and globals.
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000621 MPM.add(createConstantMergePass()); // Merge dup global constants
Evan Cheng8c6b06d2012-09-28 21:23:26 +0000622 }
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000623 }
Nick Lewycky9e6d1842014-09-13 21:46:00 +0000624
625 if (MergeFunctions)
626 MPM.add(createMergeFunctionsPass());
627
Kostya Serebryanye505a5a2012-03-23 23:22:59 +0000628 addExtensionsToPM(EP_OptimizerLast, MPM);
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000629}
630
Chandler Carruth30d69c22015-02-13 10:01:29 +0000631void PassManagerBuilder::addLTOOptimizationPasses(legacy::PassManagerBase &PM) {
Peter Collingbournefad596a2016-05-25 21:26:14 +0000632 // Remove unused virtual tables to improve the quality of code generated by
633 // whole-program devirtualization and bitset lowering.
634 PM.add(createGlobalDCEPass());
635
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000636 // Provide AliasAnalysis services for optimizations.
637 addInitialAliasAnalysisPasses(PM);
638
Teresa Johnson26ab5772016-03-15 00:04:37 +0000639 if (ModuleSummary)
640 PM.add(createFunctionImportPass(ModuleSummary));
Teresa Johnson5fcbdb72015-12-07 19:21:11 +0000641
Chandler Carruthf49f1a872015-12-27 08:13:45 +0000642 // Allow forcing function attributes as a debugging and tuning aid.
643 PM.add(createForceFunctionAttrsLegacyPass());
644
Chandler Carruth3a040e62015-12-27 08:41:34 +0000645 // Infer attributes about declarations if possible.
646 PM.add(createInferFunctionAttrsLegacyPass());
647
Peter Collingbournefad596a2016-05-25 21:26:14 +0000648 if (OptLevel > 1) {
649 // Indirect call promotion. This should promote all the targets that are
650 // left by the earlier promotion pass that promotes intra-module targets.
651 // This two-step promotion is to save the compile time. For LTO, it should
652 // produce the same result as if we only do promotion here.
653 PM.add(createPGOIndirectCallPromotionLegacyPass(true));
Rong Xu6e34c492016-04-27 23:20:27 +0000654
Peter Collingbournefad596a2016-05-25 21:26:14 +0000655 // Propagate constants at call sites into the functions they call. This
656 // opens opportunities for globalopt (and inlining) by substituting function
657 // pointers passed as arguments to direct uses of functions.
658 PM.add(createIPSCCPPass());
659 }
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000660
Peter Collingbournefad596a2016-05-25 21:26:14 +0000661 // Infer attributes about definitions. The readnone attribute in particular is
662 // required for virtual constant propagation.
Chandler Carruth9c4ed172016-02-18 11:03:11 +0000663 PM.add(createPostOrderFunctionAttrsLegacyPass());
Chandler Carruth1926b702016-01-08 10:55:52 +0000664 PM.add(createReversePostOrderFunctionAttrsPass());
Peter Collingbournefad596a2016-05-25 21:26:14 +0000665
666 // Apply whole-program devirtualization and virtual constant propagation.
667 PM.add(createWholeProgramDevirtPass());
668
669 // That's all we need at opt level 1.
670 if (OptLevel == 1)
671 return;
672
673 // Now that we internalized some globals, see if we can hack on them!
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000674 PM.add(createGlobalOptimizerPass());
James Molloy6045cc82015-12-15 09:24:01 +0000675 // Promote any localized global vars.
676 PM.add(createPromoteMemoryToRegisterPass());
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000677
678 // Linking modules together can lead to duplicated global constants, only
679 // keep one copy of each constant.
680 PM.add(createConstantMergePass());
681
682 // Remove unused arguments from functions.
683 PM.add(createDeadArgEliminationPass());
684
685 // Reduce the code after globalopt and ipsccp. Both can open up significant
686 // simplification opportunities, and both can propagate functions through
687 // function pointers. When this happens, we often have to resolve varargs
688 // calls, etc, so let instcombine do this.
Matthias Braunc31032d2016-03-09 18:47:11 +0000689 addInstructionCombiningPass(PM);
Peter Collingbourne0a437612014-05-25 10:27:02 +0000690 addExtensionsToPM(EP_Peephole, PM);
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000691
692 // Inline small functions
Rafael Espindolae07caad2014-08-21 13:35:30 +0000693 bool RunInliner = Inliner;
694 if (RunInliner) {
695 PM.add(Inliner);
696 Inliner = nullptr;
697 }
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000698
699 PM.add(createPruneEHPass()); // Remove dead EH info.
700
701 // Optimize globals again if we ran the inliner.
702 if (RunInliner)
703 PM.add(createGlobalOptimizerPass());
704 PM.add(createGlobalDCEPass()); // Remove dead functions.
705
706 // If we didn't decide to inline a function, check to see if we can
707 // transform it to pass arguments by value instead of by reference.
708 PM.add(createArgumentPromotionPass());
709
710 // The IPO passes may leave cruft around. Clean up after them.
Matthias Braunc31032d2016-03-09 18:47:11 +0000711 addInstructionCombiningPass(PM);
Peter Collingbourne0a437612014-05-25 10:27:02 +0000712 addExtensionsToPM(EP_Peephole, PM);
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000713 PM.add(createJumpThreadingPass());
Bill Wendling4c0d9ad2013-08-30 00:48:37 +0000714
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000715 // Break up allocas
David Majnemercbf614a2016-06-15 00:19:09 +0000716 PM.add(createSROAPass());
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000717
718 // Run a few AA driven optimizations here and now, to cleanup the code.
Chandler Carruth9c4ed172016-02-18 11:03:11 +0000719 PM.add(createPostOrderFunctionAttrsLegacyPass()); // Add nocapture.
Chandler Carruth7b560d42015-09-09 17:55:00 +0000720 PM.add(createGlobalsAAWrapperPass()); // IP alias analysis.
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000721
Bill Wendling932b9922012-04-02 22:16:50 +0000722 PM.add(createLICMPass()); // Hoist loop invariants.
Gerolf Hoflehner24815d92014-09-10 19:55:29 +0000723 if (EnableMLSM)
724 PM.add(createMergedLoadStoreMotionPass()); // Merge ld/st in diamonds.
Bill Wendling932b9922012-04-02 22:16:50 +0000725 PM.add(createGVNPass(DisableGVNLoadPRE)); // Remove redundancies.
726 PM.add(createMemCpyOptPass()); // Remove dead memcpys.
Bill Wendling4c0d9ad2013-08-30 00:48:37 +0000727
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000728 // Nuke dead stores.
729 PM.add(createDeadStoreEliminationPass());
730
Duncan P. N. Exon Smith2b691892014-04-15 17:48:15 +0000731 // More loops are countable; try to optimize them.
732 PM.add(createIndVarSimplifyPass());
733 PM.add(createLoopDeletionPass());
Karthik Bhat88db86d2015-03-06 10:11:25 +0000734 if (EnableLoopInterchange)
735 PM.add(createLoopInterchangePass());
736
James Molloy31f3ddd2016-01-14 15:00:09 +0000737 if (!DisableUnrollLoops)
738 PM.add(createSimpleLoopUnrollPass()); // Unroll small loops
Arnold Schwaighofereb1a38f2014-10-26 21:50:58 +0000739 PM.add(createLoopVectorizePass(true, LoopVectorize));
James Molloy31f3ddd2016-01-14 15:00:09 +0000740 // The vectorizer may have significantly shortened a loop body; unroll again.
741 if (!DisableUnrollLoops)
742 PM.add(createLoopUnrollPass());
Arnold Schwaighofer6ccda922014-02-24 18:19:31 +0000743
James Molloy6045cc82015-12-15 09:24:01 +0000744 // Now that we've optimized loops (in particular loop induction variables),
745 // we may have exposed more scalar opportunities. Run parts of the scalar
746 // optimizer again at this point.
Matthias Braunc31032d2016-03-09 18:47:11 +0000747 addInstructionCombiningPass(PM); // Initial cleanup
James Molloy6045cc82015-12-15 09:24:01 +0000748 PM.add(createCFGSimplificationPass()); // if-convert
749 PM.add(createSCCPPass()); // Propagate exposed constants
Matthias Braunc31032d2016-03-09 18:47:11 +0000750 addInstructionCombiningPass(PM); // Clean up again
James Molloy6045cc82015-12-15 09:24:01 +0000751 PM.add(createBitTrackingDCEPass());
752
Yi Jiang79eb0aa2014-05-05 23:14:46 +0000753 // More scalar chains could be vectorized due to more alias information
JF Bastienf42a6ea2014-10-21 23:18:21 +0000754 if (RunSLPAfterLoopVectorization)
755 if (SLPVectorize)
756 PM.add(createSLPVectorizerPass()); // Vectorize parallel scalar chains.
Yi Jiang79eb0aa2014-05-05 23:14:46 +0000757
Hal Finkeld67e4632014-09-07 20:05:11 +0000758 // After vectorization, assume intrinsics may tell us more about pointer
759 // alignments.
760 PM.add(createAlignmentFromAssumptionsPass());
761
Michael J. Spencer289067c2014-05-29 01:55:07 +0000762 if (LoadCombine)
763 PM.add(createLoadCombinePass());
764
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000765 // Cleanup and simplify the code after the scalar optimizations.
Matthias Braunc31032d2016-03-09 18:47:11 +0000766 addInstructionCombiningPass(PM);
Peter Collingbourne0a437612014-05-25 10:27:02 +0000767 addExtensionsToPM(EP_Peephole, PM);
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000768
769 PM.add(createJumpThreadingPass());
Peter Collingbourne070843d2015-03-19 22:01:00 +0000770}
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000771
Peter Collingbourne070843d2015-03-19 22:01:00 +0000772void PassManagerBuilder::addLateLTOOptimizationPasses(
773 legacy::PassManagerBase &PM) {
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000774 // Delete basic blocks, which optimization passes may have killed.
Tom Stellardaa664d92013-08-06 02:43:45 +0000775 PM.add(createCFGSimplificationPass());
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000776
Teresa Johnsonc4279a72015-08-11 16:26:41 +0000777 // Drop bodies of available externally objects to improve GlobalDCE.
778 PM.add(createEliminateAvailableExternallyPass());
779
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000780 // Now that we have optimized the program, discard unreachable functions.
781 PM.add(createGlobalDCEPass());
Nick Lewycky9e6d1842014-09-13 21:46:00 +0000782
783 // FIXME: this is profitable (for compiler time) to do at -O0 too, but
784 // currently it damages debug info.
785 if (MergeFunctions)
786 PM.add(createMergeFunctionsPass());
Rafael Espindola3ea478b2011-08-02 21:50:27 +0000787}
Rafael Espindola07f609152011-08-09 22:17:34 +0000788
Mehdi Amini1db10ac2016-02-16 23:02:29 +0000789void PassManagerBuilder::populateThinLTOPassManager(
790 legacy::PassManagerBase &PM) {
791 PerformThinLTO = true;
792
793 if (VerifyInput)
794 PM.add(createVerifierPass());
795
Teresa Johnson26ab5772016-03-15 00:04:37 +0000796 if (ModuleSummary)
797 PM.add(createFunctionImportPass(ModuleSummary));
Mehdi Amini1db10ac2016-02-16 23:02:29 +0000798
799 populateModulePassManager(PM);
800
801 if (VerifyOutput)
802 PM.add(createVerifierPass());
803 PerformThinLTO = false;
804}
805
Chandler Carruth30d69c22015-02-13 10:01:29 +0000806void PassManagerBuilder::populateLTOPassManager(legacy::PassManagerBase &PM) {
Rafael Espindola7cebf362014-08-21 20:03:44 +0000807 if (LibraryInfo)
Chandler Carruthb98f63d2015-01-15 10:41:28 +0000808 PM.add(new TargetLibraryInfoWrapperPass(*LibraryInfo));
Rafael Espindola7cebf362014-08-21 20:03:44 +0000809
Duncan P. N. Exon Smithab58a562015-03-19 22:24:17 +0000810 if (VerifyInput)
Rafael Espindola7cebf362014-08-21 20:03:44 +0000811 PM.add(createVerifierPass());
Rafael Espindola7cebf362014-08-21 20:03:44 +0000812
Peter Collingbournedf49d1b2016-02-09 22:50:34 +0000813 if (OptLevel != 0)
Rafael Espindola7cebf362014-08-21 20:03:44 +0000814 addLTOOptimizationPasses(PM);
815
Evgeniy Stepanov67849d52015-12-15 23:00:08 +0000816 // Create a function that performs CFI checks for cross-DSO calls with targets
817 // in the current module.
818 PM.add(createCrossDSOCFIPass());
819
Peter Collingbourne7efd7502016-06-24 21:21:32 +0000820 // Lower type metadata and the type.test intrinsic. This pass supports Clang's
821 // control flow integrity mechanisms (-fsanitize=cfi*) and needs to run at
822 // link time if CFI is enabled. The pass does nothing if CFI is disabled.
823 PM.add(createLowerTypeTestsPass());
Peter Collingbourne070843d2015-03-19 22:01:00 +0000824
825 if (OptLevel != 0)
826 addLateLTOOptimizationPasses(PM);
827
Duncan P. N. Exon Smithab58a562015-03-19 22:24:17 +0000828 if (VerifyOutput)
Rafael Espindola7cebf362014-08-21 20:03:44 +0000829 PM.add(createVerifierPass());
Rafael Espindola7cebf362014-08-21 20:03:44 +0000830}
831
Eric Christopher04d4e932013-04-22 22:47:22 +0000832inline PassManagerBuilder *unwrap(LLVMPassManagerBuilderRef P) {
833 return reinterpret_cast<PassManagerBuilder*>(P);
834}
835
836inline LLVMPassManagerBuilderRef wrap(PassManagerBuilder *P) {
837 return reinterpret_cast<LLVMPassManagerBuilderRef>(P);
838}
839
Dmitri Gribenko0011bbf2012-11-15 16:51:49 +0000840LLVMPassManagerBuilderRef LLVMPassManagerBuilderCreate() {
Rafael Espindola07f609152011-08-09 22:17:34 +0000841 PassManagerBuilder *PMB = new PassManagerBuilder();
842 return wrap(PMB);
843}
844
845void LLVMPassManagerBuilderDispose(LLVMPassManagerBuilderRef PMB) {
846 PassManagerBuilder *Builder = unwrap(PMB);
847 delete Builder;
848}
849
850void
851LLVMPassManagerBuilderSetOptLevel(LLVMPassManagerBuilderRef PMB,
852 unsigned OptLevel) {
853 PassManagerBuilder *Builder = unwrap(PMB);
854 Builder->OptLevel = OptLevel;
855}
856
857void
858LLVMPassManagerBuilderSetSizeLevel(LLVMPassManagerBuilderRef PMB,
859 unsigned SizeLevel) {
860 PassManagerBuilder *Builder = unwrap(PMB);
861 Builder->SizeLevel = SizeLevel;
862}
863
864void
865LLVMPassManagerBuilderSetDisableUnitAtATime(LLVMPassManagerBuilderRef PMB,
866 LLVMBool Value) {
867 PassManagerBuilder *Builder = unwrap(PMB);
868 Builder->DisableUnitAtATime = Value;
869}
870
871void
872LLVMPassManagerBuilderSetDisableUnrollLoops(LLVMPassManagerBuilderRef PMB,
873 LLVMBool Value) {
874 PassManagerBuilder *Builder = unwrap(PMB);
875 Builder->DisableUnrollLoops = Value;
876}
877
878void
879LLVMPassManagerBuilderSetDisableSimplifyLibCalls(LLVMPassManagerBuilderRef PMB,
880 LLVMBool Value) {
Meador Ingedfb08a22013-06-20 19:48:07 +0000881 // NOTE: The simplify-libcalls pass has been removed.
Rafael Espindola07f609152011-08-09 22:17:34 +0000882}
883
884void
885LLVMPassManagerBuilderUseInlinerWithThreshold(LLVMPassManagerBuilderRef PMB,
886 unsigned Threshold) {
887 PassManagerBuilder *Builder = unwrap(PMB);
888 Builder->Inliner = createFunctionInliningPass(Threshold);
889}
890
891void
892LLVMPassManagerBuilderPopulateFunctionPassManager(LLVMPassManagerBuilderRef PMB,
893 LLVMPassManagerRef PM) {
894 PassManagerBuilder *Builder = unwrap(PMB);
Chandler Carruth30d69c22015-02-13 10:01:29 +0000895 legacy::FunctionPassManager *FPM = unwrap<legacy::FunctionPassManager>(PM);
Rafael Espindola07f609152011-08-09 22:17:34 +0000896 Builder->populateFunctionPassManager(*FPM);
897}
898
899void
900LLVMPassManagerBuilderPopulateModulePassManager(LLVMPassManagerBuilderRef PMB,
901 LLVMPassManagerRef PM) {
902 PassManagerBuilder *Builder = unwrap(PMB);
Chandler Carruth30d69c22015-02-13 10:01:29 +0000903 legacy::PassManagerBase *MPM = unwrap(PM);
Rafael Espindola07f609152011-08-09 22:17:34 +0000904 Builder->populateModulePassManager(*MPM);
905}
906
907void LLVMPassManagerBuilderPopulateLTOPassManager(LLVMPassManagerBuilderRef PMB,
908 LLVMPassManagerRef PM,
Nick Lewycky5f508542013-03-10 21:58:22 +0000909 LLVMBool Internalize,
910 LLVMBool RunInliner) {
Rafael Espindola07f609152011-08-09 22:17:34 +0000911 PassManagerBuilder *Builder = unwrap(PMB);
Chandler Carruth30d69c22015-02-13 10:01:29 +0000912 legacy::PassManagerBase *LPM = unwrap(PM);
Rafael Espindolae07caad2014-08-21 13:35:30 +0000913
914 // A small backwards compatibility hack. populateLTOPassManager used to take
915 // an RunInliner option.
916 if (RunInliner && !Builder->Inliner)
917 Builder->Inliner = createFunctionInliningPass();
918
919 Builder->populateLTOPassManager(*LPM);
Rafael Espindola07f609152011-08-09 22:17:34 +0000920}