LLVM  6.0.0svn
PassManagerBuilder.cpp
Go to the documentation of this file.
1 //===- 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 
17 #include "llvm/ADT/SmallVector.h"
23 #include "llvm/Analysis/Passes.h"
27 #include "llvm/IR/DataLayout.h"
30 #include "llvm/IR/Verifier.h"
34 #include "llvm/Transforms/IPO.h"
39 #include "llvm/Transforms/Scalar.h"
43 
44 using namespace llvm;
45 
46 static cl::opt<bool>
47  RunPartialInlining("enable-partial-inlining", cl::init(false), cl::Hidden,
48  cl::ZeroOrMore, cl::desc("Run Partial inlinining pass"));
49 
50 static cl::opt<bool>
51  RunLoopVectorization("vectorize-loops", cl::Hidden,
52  cl::desc("Run the Loop vectorization passes"));
53 
54 static cl::opt<bool>
55 RunSLPVectorization("vectorize-slp", cl::Hidden,
56  cl::desc("Run the SLP vectorization passes"));
57 
58 static cl::opt<bool>
59 UseGVNAfterVectorization("use-gvn-after-vectorization",
60  cl::init(false), cl::Hidden,
61  cl::desc("Run GVN instead of Early CSE after vectorization passes"));
62 
64  "extra-vectorizer-passes", cl::init(false), cl::Hidden,
65  cl::desc("Run cleanup optimization passes after vectorization."));
66 
67 static cl::opt<bool>
68 RunLoopRerolling("reroll-loops", cl::Hidden,
69  cl::desc("Run the loop rerolling pass"));
70 
71 static cl::opt<bool> RunNewGVN("enable-newgvn", cl::init(false), cl::Hidden,
72  cl::desc("Run the NewGVN pass"));
73 
74 static cl::opt<bool>
75 RunSLPAfterLoopVectorization("run-slp-after-loop-vectorization",
76  cl::init(true), cl::Hidden,
77  cl::desc("Run the SLP vectorizer (and BB vectorizer) after the Loop "
78  "vectorizer instead of before"));
79 
80 // Experimental option to use CFL-AA
82 static cl::opt<CFLAAType>
84  cl::desc("Enable the new, experimental CFL alias analysis"),
85  cl::values(clEnumValN(CFLAAType::None, "none", "Disable CFL-AA"),
87  "Enable unification-based CFL-AA"),
89  "Enable inclusion-based CFL-AA"),
91  "Enable both variants of CFL-AA")));
92 
94  "enable-loopinterchange", cl::init(false), cl::Hidden,
95  cl::desc("Enable the new, experimental LoopInterchange Pass"));
96 
98  "enable-non-lto-gmr", cl::init(true), cl::Hidden,
99  cl::desc(
100  "Enable the GlobalsModRef AliasAnalysis outside of the LTO pipeline."));
101 
103  "enable-loop-load-elim", cl::init(true), cl::Hidden,
104  cl::desc("Enable the LoopLoadElimination Pass"));
105 
106 static cl::opt<bool>
107  EnablePrepareForThinLTO("prepare-for-thinlto", cl::init(false), cl::Hidden,
108  cl::desc("Enable preparation for ThinLTO."));
109 
111  "profile-generate", cl::init(false), cl::Hidden,
112  cl::desc("Enable PGO instrumentation."));
113 
115  PGOOutputFile("profile-generate-file", cl::init(""), cl::Hidden,
116  cl::desc("Specify the path of profile data file."));
117 
119  "profile-use", cl::init(""), cl::Hidden, cl::value_desc("filename"),
120  cl::desc("Enable use phase of PGO instrumentation and specify the path "
121  "of profile data file"));
122 
124  "enable-loop-versioning-licm", cl::init(false), cl::Hidden,
125  cl::desc("Enable the experimental Loop Versioning LICM pass"));
126 
127 static cl::opt<bool>
128  DisablePreInliner("disable-preinline", cl::init(false), cl::Hidden,
129  cl::desc("Disable pre-instrumentation inliner"));
130 
132  "preinline-threshold", cl::Hidden, cl::init(75), cl::ZeroOrMore,
133  cl::desc("Control the amount of inlining in pre-instrumentation inliner "
134  "(default = 75)"));
135 
137  "enable-earlycse-memssa", cl::init(true), cl::Hidden,
138  cl::desc("Enable the EarlyCSE w/ MemorySSA pass (default = on)"));
139 
141  "enable-gvn-hoist", cl::init(false), cl::Hidden,
142  cl::desc("Enable the GVN hoisting pass (default = off)"));
143 
144 static cl::opt<bool>
145  DisableLibCallsShrinkWrap("disable-libcalls-shrinkwrap", cl::init(false),
146  cl::Hidden,
147  cl::desc("Disable shrink-wrap library calls"));
148 
149 static cl::opt<bool>
150  EnableSimpleLoopUnswitch("enable-simple-loop-unswitch", cl::init(false),
151  cl::Hidden,
152  cl::desc("Enable the simple loop unswitch pass."));
153 
155  "enable-gvn-sink", cl::init(false), cl::Hidden,
156  cl::desc("Enable the GVN sinking pass (default = off)"));
157 
159  OptLevel = 2;
160  SizeLevel = 0;
161  LibraryInfo = nullptr;
162  Inliner = nullptr;
163  DisableUnitAtATime = false;
164  DisableUnrollLoops = false;
165  SLPVectorize = RunSLPVectorization;
166  LoopVectorize = RunLoopVectorization;
167  RerollLoops = RunLoopRerolling;
168  NewGVN = RunNewGVN;
169  DisableGVNLoadPRE = false;
170  VerifyInput = false;
171  VerifyOutput = false;
172  MergeFunctions = false;
173  PrepareForLTO = false;
174  EnablePGOInstrGen = RunPGOInstrGen;
175  PGOInstrGen = PGOOutputFile;
176  PGOInstrUse = RunPGOInstrUse;
177  PrepareForThinLTO = EnablePrepareForThinLTO;
178  PerformThinLTO = false;
179  DivergentTarget = false;
180 }
181 
183  delete LibraryInfo;
184  delete Inliner;
185 }
186 
187 /// Set of global extensions, automatically added as part of the standard set.
190 
191 /// Check if GlobalExtensions is constructed and not empty.
192 /// Since GlobalExtensions is a managed static, calling 'empty()' will trigger
193 /// the construction of the object.
195  return GlobalExtensions.isConstructed() && !GlobalExtensions->empty();
196 }
197 
199  PassManagerBuilder::ExtensionPointTy Ty,
201  GlobalExtensions->push_back(std::make_pair(Ty, std::move(Fn)));
202 }
203 
205  Extensions.push_back(std::make_pair(Ty, std::move(Fn)));
206 }
207 
208 void PassManagerBuilder::addExtensionsToPM(ExtensionPointTy ETy,
209  legacy::PassManagerBase &PM) const {
210  if (GlobalExtensionsNotEmpty()) {
211  for (auto &Ext : *GlobalExtensions) {
212  if (Ext.first == ETy)
213  Ext.second(*this, PM);
214  }
215  }
216  for (unsigned i = 0, e = Extensions.size(); i != e; ++i)
217  if (Extensions[i].first == ETy)
218  Extensions[i].second(*this, PM);
219 }
220 
221 void PassManagerBuilder::addInitialAliasAnalysisPasses(
222  legacy::PassManagerBase &PM) const {
223  switch (UseCFLAA) {
226  break;
227  case CFLAAType::Andersen:
229  break;
230  case CFLAAType::Both:
233  break;
234  default:
235  break;
236  }
237 
238  // Add TypeBasedAliasAnalysis before BasicAliasAnalysis so that
239  // BasicAliasAnalysis wins if they disagree. This is intended to help
240  // support "obvious" type-punning idioms.
243 }
244 
245 void PassManagerBuilder::addInstructionCombiningPass(
246  legacy::PassManagerBase &PM) const {
247  bool ExpensiveCombines = OptLevel > 2;
248  PM.add(createInstructionCombiningPass(ExpensiveCombines));
249 }
250 
253  addExtensionsToPM(EP_EarlyAsPossible, FPM);
254 
255  // Add LibraryInfo if we have some.
256  if (LibraryInfo)
257  FPM.add(new TargetLibraryInfoWrapperPass(*LibraryInfo));
258 
259  if (OptLevel == 0) return;
260 
261  addInitialAliasAnalysisPasses(FPM);
262 
264  FPM.add(createSROAPass());
265  FPM.add(createEarlyCSEPass());
267 }
268 
269 // Do PGO instrumentation generation or use pass as the option specified.
270 void PassManagerBuilder::addPGOInstrPasses(legacy::PassManagerBase &MPM) {
271  if (!EnablePGOInstrGen && PGOInstrUse.empty() && PGOSampleUse.empty())
272  return;
273  // Perform the preinline and cleanup passes for O1 and above.
274  // And avoid doing them if optimizing for size.
275  if (OptLevel > 0 && SizeLevel == 0 && !DisablePreInliner &&
276  PGOSampleUse.empty()) {
277  // Create preinline pass. We construct an InlineParams object and specify
278  // the threshold here to avoid the command line options of the regular
279  // inliner to influence pre-inlining. The only fields of InlineParams we
280  // care about are DefaultThreshold and HintThreshold.
281  InlineParams IP;
283  // FIXME: The hint threshold has the same value used by the regular inliner.
284  // This should probably be lowered after performance testing.
285  IP.HintThreshold = 325;
286 
288  MPM.add(createSROAPass());
289  MPM.add(createEarlyCSEPass()); // Catch trivial redundancies
290  MPM.add(createCFGSimplificationPass()); // Merge & remove BBs
291  MPM.add(createInstructionCombiningPass()); // Combine silly seq's
292  addExtensionsToPM(EP_Peephole, MPM);
293  }
294  if (EnablePGOInstrGen) {
296  // Add the profile lowering pass.
297  InstrProfOptions Options;
298  if (!PGOInstrGen.empty())
299  Options.InstrProfileOutput = PGOInstrGen;
300  Options.DoCounterPromotion = true;
301  MPM.add(createLoopRotatePass());
302  MPM.add(createInstrProfilingLegacyPass(Options));
303  }
304  if (!PGOInstrUse.empty())
305  MPM.add(createPGOInstrumentationUseLegacyPass(PGOInstrUse));
306  // Indirect call promotion that promotes intra-module targets only.
307  // For ThinLTO this is done earlier due to interactions with globalopt
308  // for imported functions. We don't run this at -O0.
309  if (OptLevel > 0)
310  MPM.add(
311  createPGOIndirectCallPromotionLegacyPass(false, !PGOSampleUse.empty()));
312 }
313 void PassManagerBuilder::addFunctionSimplificationPasses(
315  // Start of function pass.
316  // Break up aggregate allocas, using SSAUpdater.
317  MPM.add(createSROAPass());
318  MPM.add(createEarlyCSEPass(EnableEarlyCSEMemSSA)); // Catch trivial redundancies
319  if (EnableGVNHoist)
320  MPM.add(createGVNHoistPass());
321  if (EnableGVNSink) {
322  MPM.add(createGVNSinkPass());
324  }
325 
326  // Speculative execution if the target has divergent branches; otherwise nop.
328  MPM.add(createJumpThreadingPass()); // Thread jumps.
329  MPM.add(createCorrelatedValuePropagationPass()); // Propagate conditionals
330  MPM.add(createCFGSimplificationPass()); // Merge & remove BBs
331  // Combine silly seq's
332  addInstructionCombiningPass(MPM);
333  if (SizeLevel == 0 && !DisableLibCallsShrinkWrap)
335  addExtensionsToPM(EP_Peephole, MPM);
336 
337  // Optimize memory intrinsic calls based on the profiled size information.
338  if (SizeLevel == 0)
340 
341  MPM.add(createTailCallEliminationPass()); // Eliminate tail calls
342  MPM.add(createCFGSimplificationPass()); // Merge & remove BBs
343  MPM.add(createReassociatePass()); // Reassociate expressions
344  // Rotate Loop - disable header duplication at -Oz
345  MPM.add(createLoopRotatePass(SizeLevel == 2 ? 0 : -1));
346  MPM.add(createLICMPass()); // Hoist loop invariants
347  if (EnableSimpleLoopUnswitch)
349  else
350  MPM.add(createLoopUnswitchPass(SizeLevel || OptLevel < 3, DivergentTarget));
352  addInstructionCombiningPass(MPM);
353  MPM.add(createIndVarSimplifyPass()); // Canonicalize indvars
354  MPM.add(createLoopIdiomPass()); // Recognize idioms like memset.
355  addExtensionsToPM(EP_LateLoopOptimizations, MPM);
356  MPM.add(createLoopDeletionPass()); // Delete dead loops
357 
358  if (EnableLoopInterchange) {
359  MPM.add(createLoopInterchangePass()); // Interchange loops
361  }
362  if (!DisableUnrollLoops)
363  MPM.add(createSimpleLoopUnrollPass(OptLevel)); // Unroll small loops
364  addExtensionsToPM(EP_LoopOptimizerEnd, MPM);
365 
366  if (OptLevel > 1) {
367  MPM.add(createMergedLoadStoreMotionPass()); // Merge ld/st in diamonds
368  MPM.add(NewGVN ? createNewGVNPass()
369  : createGVNPass(DisableGVNLoadPRE)); // Remove redundancies
370  }
371  MPM.add(createMemCpyOptPass()); // Remove memcpy / form memset
372  MPM.add(createSCCPPass()); // Constant prop with SCCP
373 
374  // Delete dead bit computations (instcombine runs after to fold away the dead
375  // computations, and then ADCE will run later to exploit any new DCE
376  // opportunities that creates).
377  MPM.add(createBitTrackingDCEPass()); // Delete dead bit computations
378 
379  // Run instcombine after redundancy elimination to exploit opportunities
380  // opened up by them.
381  addInstructionCombiningPass(MPM);
382  addExtensionsToPM(EP_Peephole, MPM);
383  MPM.add(createJumpThreadingPass()); // Thread jumps
385  MPM.add(createDeadStoreEliminationPass()); // Delete dead stores
386  MPM.add(createLICMPass());
387 
388  addExtensionsToPM(EP_ScalarOptimizerLate, MPM);
389 
390  if (RerollLoops)
391  MPM.add(createLoopRerollPass());
392  if (!RunSLPAfterLoopVectorization && SLPVectorize)
393  MPM.add(createSLPVectorizerPass()); // Vectorize parallel scalar chains.
394 
395  MPM.add(createAggressiveDCEPass()); // Delete dead instructions
396  MPM.add(createCFGSimplificationPass()); // Merge & remove BBs
397  // Clean up after everything.
398  addInstructionCombiningPass(MPM);
399  addExtensionsToPM(EP_Peephole, MPM);
400 }
401 
404  if (!PGOSampleUse.empty()) {
405  MPM.add(createPruneEHPass());
406  MPM.add(createSampleProfileLoaderPass(PGOSampleUse));
407  }
408 
409  // Allow forcing function attributes as a debugging and tuning aid.
411 
412  // If all optimizations are disabled, just run the always-inline pass and,
413  // if enabled, the function merging pass.
414  if (OptLevel == 0) {
415  addPGOInstrPasses(MPM);
416  if (Inliner) {
417  MPM.add(Inliner);
418  Inliner = nullptr;
419  }
420 
421  // FIXME: The BarrierNoopPass is a HACK! The inliner pass above implicitly
422  // creates a CGSCC pass manager, but we don't want to add extensions into
423  // that pass manager. To prevent this we insert a no-op module pass to reset
424  // the pass manager to get the same behavior as EP_OptimizerLast in non-O0
425  // builds. The function merging pass is
426  if (MergeFunctions)
428  else if (GlobalExtensionsNotEmpty() || !Extensions.empty())
429  MPM.add(createBarrierNoopPass());
430 
431  addExtensionsToPM(EP_EnabledOnOptLevel0, MPM);
432 
433  // Rename anon globals to be able to export them in the summary.
434  // This has to be done after we add the extensions to the pass manager
435  // as there could be passes (e.g. Adddress sanitizer) which introduce
436  // new unnamed globals.
437  if (PrepareForThinLTO)
439  return;
440  }
441 
442  // Add LibraryInfo if we have some.
443  if (LibraryInfo)
444  MPM.add(new TargetLibraryInfoWrapperPass(*LibraryInfo));
445 
446  addInitialAliasAnalysisPasses(MPM);
447 
448  // For ThinLTO there are two passes of indirect call promotion. The
449  // first is during the compile phase when PerformThinLTO=false and
450  // intra-module indirect call targets are promoted. The second is during
451  // the ThinLTO backend when PerformThinLTO=true, when we promote imported
452  // inter-module indirect calls. For that we perform indirect call promotion
453  // earlier in the pass pipeline, here before globalopt. Otherwise imported
454  // available_externally functions look unreferenced and are removed.
455  if (PerformThinLTO)
456  MPM.add(createPGOIndirectCallPromotionLegacyPass(/*InLTO = */ true,
457  !PGOSampleUse.empty()));
458 
459  // For SamplePGO in ThinLTO compile phase, we do not want to unroll loops
460  // as it will change the CFG too much to make the 2nd profile annotation
461  // in backend more difficult.
462  bool PrepareForThinLTOUsingPGOSampleProfile =
463  PrepareForThinLTO && !PGOSampleUse.empty();
464  if (PrepareForThinLTOUsingPGOSampleProfile)
465  DisableUnrollLoops = true;
466 
467  if (!DisableUnitAtATime) {
468  // Infer attributes about declarations if possible.
470 
471  addExtensionsToPM(EP_ModuleOptimizerEarly, MPM);
472 
473  MPM.add(createIPSCCPPass()); // IP SCCP
474  MPM.add(createGlobalOptimizerPass()); // Optimize out global vars
475  // Promote any localized global vars.
477 
478  MPM.add(createDeadArgEliminationPass()); // Dead argument elimination
479 
480  addInstructionCombiningPass(MPM); // Clean up after IPCP & DAE
481  addExtensionsToPM(EP_Peephole, MPM);
482  MPM.add(createCFGSimplificationPass()); // Clean up after IPCP & DAE
483  }
484 
485  // For SamplePGO in ThinLTO compile phase, we do not want to do indirect
486  // call promotion as it will change the CFG too much to make the 2nd
487  // profile annotation in backend more difficult.
488  // PGO instrumentation is added during the compile phase for ThinLTO, do
489  // not run it a second time
490  if (!PerformThinLTO && !PrepareForThinLTOUsingPGOSampleProfile)
491  addPGOInstrPasses(MPM);
492 
493  if (EnableNonLTOGlobalsModRef)
494  // We add a module alias analysis pass here. In part due to bugs in the
495  // analysis infrastructure this "works" in that the analysis stays alive
496  // for the entire SCC pass run below.
498 
499  // Start of CallGraph SCC passes.
500  if (!DisableUnitAtATime)
501  MPM.add(createPruneEHPass()); // Remove dead EH info
502  if (Inliner) {
503  MPM.add(Inliner);
504  Inliner = nullptr;
505  }
506  if (!DisableUnitAtATime)
508  if (OptLevel > 2)
509  MPM.add(createArgumentPromotionPass()); // Scalarize uninlined fn args
510 
511  addExtensionsToPM(EP_CGSCCOptimizerLate, MPM);
512  addFunctionSimplificationPasses(MPM);
513 
514  // FIXME: This is a HACK! The inliner pass above implicitly creates a CGSCC
515  // pass manager that we are specifically trying to avoid. To prevent this
516  // we must insert a no-op module pass to reset the pass manager.
517  MPM.add(createBarrierNoopPass());
518  if (RunPartialInlining)
520 
521  if (!DisableUnitAtATime && OptLevel > 1 && !PrepareForLTO &&
522  !PrepareForThinLTO)
523  // Remove avail extern fns and globals definitions if we aren't
524  // compiling an object file for later LTO. For LTO we want to preserve
525  // these so they are eligible for inlining at link-time. Note if they
526  // are unreferenced they will be removed by GlobalDCE later, so
527  // this only impacts referenced available externally globals.
528  // Eventually they will be suppressed during codegen, but eliminating
529  // here enables more opportunity for GlobalDCE as it may make
530  // globals referenced by available external functions dead
531  // and saves running remaining passes on the eliminated functions.
533 
534  if (!DisableUnitAtATime)
536 
537  // If we are planning to perform ThinLTO later, let's not bloat the code with
538  // unrolling/vectorization/... now. We'll first run the inliner + CGSCC passes
539  // during ThinLTO and perform the rest of the optimizations afterward.
540  if (PrepareForThinLTO) {
541  // Reduce the size of the IR as much as possible.
543  // Rename anon globals to be able to export them in the summary.
545  return;
546  }
547 
548  if (PerformThinLTO)
549  // Optimize globals now when performing ThinLTO, this enables more
550  // optimizations later.
552 
553  // Scheduling LoopVersioningLICM when inlining is over, because after that
554  // we may see more accurate aliasing. Reason to run this late is that too
555  // early versioning may prevent further inlining due to increase of code
556  // size. By placing it just after inlining other optimizations which runs
557  // later might get benefit of no-alias assumption in clone loop.
558  if (UseLoopVersioningLICM) {
559  MPM.add(createLoopVersioningLICMPass()); // Do LoopVersioningLICM
560  MPM.add(createLICMPass()); // Hoist loop invariants
561  }
562 
563  if (EnableNonLTOGlobalsModRef)
564  // We add a fresh GlobalsModRef run at this point. This is particularly
565  // useful as the above will have inlined, DCE'ed, and function-attr
566  // propagated everything. We should at this point have a reasonably minimal
567  // and richly annotated call graph. By computing aliasing and mod/ref
568  // information for all local globals here, the late loop passes and notably
569  // the vectorizer will be able to use them to help recognize vectorizable
570  // memory operations.
571  //
572  // Note that this relies on a bug in the pass manager which preserves
573  // a module analysis into a function pass pipeline (and throughout it) so
574  // long as the first function pass doesn't invalidate the module analysis.
575  // Thus both Float2Int and LoopRotate have to preserve AliasAnalysis for
576  // this to work. Fortunately, it is trivial to preserve AliasAnalysis
577  // (doing nothing preserves it as it is required to be conservatively
578  // correct in the face of IR changes).
580 
581  MPM.add(createFloat2IntPass());
582 
583  addExtensionsToPM(EP_VectorizerStart, MPM);
584 
585  // Re-rotate loops in all our loop nests. These may have fallout out of
586  // rotated form due to GVN or other transformations, and the vectorizer relies
587  // on the rotated form. Disable header duplication at -Oz.
588  MPM.add(createLoopRotatePass(SizeLevel == 2 ? 0 : -1));
589 
590  // Distribute loops to allow partial vectorization. I.e. isolate dependences
591  // into separate loop that would otherwise inhibit vectorization. This is
592  // currently only performed for loops marked with the metadata
593  // llvm.loop.distribute=true or when -enable-loop-distribute is specified.
595 
596  MPM.add(createLoopVectorizePass(DisableUnrollLoops, LoopVectorize));
597 
598  // Eliminate loads by forwarding stores from the previous iteration to loads
599  // of the current iteration.
600  if (EnableLoopLoadElim)
602 
603  // FIXME: Because of #pragma vectorize enable, the passes below are always
604  // inserted in the pipeline, even when the vectorizer doesn't run (ex. when
605  // on -O1 and no #pragma is found). Would be good to have these two passes
606  // as function calls, so that we can only pass them when the vectorizer
607  // changed the code.
608  addInstructionCombiningPass(MPM);
609  if (OptLevel > 1 && ExtraVectorizerPasses) {
610  // At higher optimization levels, try to clean up any runtime overlap and
611  // alignment checks inserted by the vectorizer. We want to track correllated
612  // runtime checks for two inner loops in the same outer loop, fold any
613  // common computations, hoist loop-invariant aspects out of any outer loop,
614  // and unswitch the runtime checks if possible. Once hoisted, we may have
615  // dead (or speculatable) control flows or more combining opportunities.
616  MPM.add(createEarlyCSEPass());
618  addInstructionCombiningPass(MPM);
619  MPM.add(createLICMPass());
620  MPM.add(createLoopUnswitchPass(SizeLevel || OptLevel < 3, DivergentTarget));
622  addInstructionCombiningPass(MPM);
623  }
624 
625  if (RunSLPAfterLoopVectorization && SLPVectorize) {
626  MPM.add(createSLPVectorizerPass()); // Vectorize parallel scalar chains.
627  if (OptLevel > 1 && ExtraVectorizerPasses) {
628  MPM.add(createEarlyCSEPass());
629  }
630  }
631 
632  addExtensionsToPM(EP_Peephole, MPM);
633  MPM.add(createLateCFGSimplificationPass()); // Switches to lookup tables
634  addInstructionCombiningPass(MPM);
635 
636  if (!DisableUnrollLoops) {
637  MPM.add(createLoopUnrollPass(OptLevel)); // Unroll small loops
638 
639  // LoopUnroll may generate some redundency to cleanup.
640  addInstructionCombiningPass(MPM);
641 
642  // Runtime unrolling will introduce runtime check in loop prologue. If the
643  // unrolled loop is a inner loop, then the prologue will be inside the
644  // outer loop. LICM pass can help to promote the runtime check out if the
645  // checked value is loop invariant.
646  MPM.add(createLICMPass());
647  }
648 
649  // After vectorization and unrolling, assume intrinsics may tell us more
650  // about pointer alignments.
652 
653  if (!DisableUnitAtATime) {
654  // FIXME: We shouldn't bother with this anymore.
655  MPM.add(createStripDeadPrototypesPass()); // Get rid of dead prototypes
656 
657  // GlobalOpt already deletes dead functions and globals, at -O2 try a
658  // late pass of GlobalDCE. It is capable of deleting dead cycles.
659  if (OptLevel > 1) {
660  MPM.add(createGlobalDCEPass()); // Remove dead fns and globals.
661  MPM.add(createConstantMergePass()); // Merge dup global constants
662  }
663  }
664 
665  if (MergeFunctions)
667 
668  // LoopSink pass sinks instructions hoisted by LICM, which serves as a
669  // canonicalization pass that enables other optimizations. As a result,
670  // LoopSink pass needs to be a very late IR pass to avoid undoing LICM
671  // result too early.
672  MPM.add(createLoopSinkPass());
673  // Get rid of LCSSA nodes.
675 
676  // LoopSink (and other loop passes since the last simplifyCFG) might have
677  // resulted in single-entry-single-exit or empty blocks. Clean up the CFG.
679 
680  addExtensionsToPM(EP_OptimizerLast, MPM);
681 }
682 
683 void PassManagerBuilder::addLTOOptimizationPasses(legacy::PassManagerBase &PM) {
684  // Remove unused virtual tables to improve the quality of code generated by
685  // whole-program devirtualization and bitset lowering.
686  PM.add(createGlobalDCEPass());
687 
688  // Provide AliasAnalysis services for optimizations.
689  addInitialAliasAnalysisPasses(PM);
690 
691  // Allow forcing function attributes as a debugging and tuning aid.
693 
694  // Infer attributes about declarations if possible.
696 
697  if (OptLevel > 1) {
698  // Indirect call promotion. This should promote all the targets that are
699  // left by the earlier promotion pass that promotes intra-module targets.
700  // This two-step promotion is to save the compile time. For LTO, it should
701  // produce the same result as if we only do promotion here.
702  PM.add(
703  createPGOIndirectCallPromotionLegacyPass(true, !PGOSampleUse.empty()));
704 
705  // Propagate constants at call sites into the functions they call. This
706  // opens opportunities for globalopt (and inlining) by substituting function
707  // pointers passed as arguments to direct uses of functions.
708  PM.add(createIPSCCPPass());
709  }
710 
711  // Infer attributes about definitions. The readnone attribute in particular is
712  // required for virtual constant propagation.
715 
716  // Split globals using inrange annotations on GEP indices. This can help
717  // improve the quality of generated code when virtual constant propagation or
718  // control flow integrity are enabled.
720 
721  // Apply whole-program devirtualization and virtual constant propagation.
722  PM.add(createWholeProgramDevirtPass(ExportSummary, nullptr));
723 
724  // That's all we need at opt level 1.
725  if (OptLevel == 1)
726  return;
727 
728  // Now that we internalized some globals, see if we can hack on them!
730  // Promote any localized global vars.
732 
733  // Linking modules together can lead to duplicated global constants, only
734  // keep one copy of each constant.
736 
737  // Remove unused arguments from functions.
739 
740  // Reduce the code after globalopt and ipsccp. Both can open up significant
741  // simplification opportunities, and both can propagate functions through
742  // function pointers. When this happens, we often have to resolve varargs
743  // calls, etc, so let instcombine do this.
744  addInstructionCombiningPass(PM);
745  addExtensionsToPM(EP_Peephole, PM);
746 
747  // Inline small functions
748  bool RunInliner = Inliner;
749  if (RunInliner) {
750  PM.add(Inliner);
751  Inliner = nullptr;
752  }
753 
754  PM.add(createPruneEHPass()); // Remove dead EH info.
755 
756  // Optimize globals again if we ran the inliner.
757  if (RunInliner)
759  PM.add(createGlobalDCEPass()); // Remove dead functions.
760 
761  // If we didn't decide to inline a function, check to see if we can
762  // transform it to pass arguments by value instead of by reference.
764 
765  // The IPO passes may leave cruft around. Clean up after them.
766  addInstructionCombiningPass(PM);
767  addExtensionsToPM(EP_Peephole, PM);
769 
770  // Break up allocas
771  PM.add(createSROAPass());
772 
773  // Run a few AA driven optimizations here and now, to cleanup the code.
774  PM.add(createPostOrderFunctionAttrsLegacyPass()); // Add nocapture.
775  PM.add(createGlobalsAAWrapperPass()); // IP alias analysis.
776 
777  PM.add(createLICMPass()); // Hoist loop invariants.
778  PM.add(createMergedLoadStoreMotionPass()); // Merge ld/st in diamonds.
779  PM.add(NewGVN ? createNewGVNPass()
780  : createGVNPass(DisableGVNLoadPRE)); // Remove redundancies.
781  PM.add(createMemCpyOptPass()); // Remove dead memcpys.
782 
783  // Nuke dead stores.
785 
786  // More loops are countable; try to optimize them.
789  if (EnableLoopInterchange)
791 
792  if (!DisableUnrollLoops)
793  PM.add(createSimpleLoopUnrollPass(OptLevel)); // Unroll small loops
794  PM.add(createLoopVectorizePass(true, LoopVectorize));
795  // The vectorizer may have significantly shortened a loop body; unroll again.
796  if (!DisableUnrollLoops)
797  PM.add(createLoopUnrollPass(OptLevel));
798 
799  // Now that we've optimized loops (in particular loop induction variables),
800  // we may have exposed more scalar opportunities. Run parts of the scalar
801  // optimizer again at this point.
802  addInstructionCombiningPass(PM); // Initial cleanup
803  PM.add(createCFGSimplificationPass()); // if-convert
804  PM.add(createSCCPPass()); // Propagate exposed constants
805  addInstructionCombiningPass(PM); // Clean up again
807 
808  // More scalar chains could be vectorized due to more alias information
810  if (SLPVectorize)
811  PM.add(createSLPVectorizerPass()); // Vectorize parallel scalar chains.
812 
813  // After vectorization, assume intrinsics may tell us more about pointer
814  // alignments.
816 
817  // Cleanup and simplify the code after the scalar optimizations.
818  addInstructionCombiningPass(PM);
819  addExtensionsToPM(EP_Peephole, PM);
820 
822 }
823 
824 void PassManagerBuilder::addLateLTOOptimizationPasses(
826  // Delete basic blocks, which optimization passes may have killed.
828 
829  // Drop bodies of available externally objects to improve GlobalDCE.
831 
832  // Now that we have optimized the program, discard unreachable functions.
833  PM.add(createGlobalDCEPass());
834 
835  // FIXME: this is profitable (for compiler time) to do at -O0 too, but
836  // currently it damages debug info.
837  if (MergeFunctions)
839 }
840 
843  PerformThinLTO = true;
844 
845  if (VerifyInput)
846  PM.add(createVerifierPass());
847 
848  if (ImportSummary) {
849  // These passes import type identifier resolutions for whole-program
850  // devirtualization and CFI. They must run early because other passes may
851  // disturb the specific instruction patterns that these passes look for,
852  // creating dependencies on resolutions that may not appear in the summary.
853  //
854  // For example, GVN may transform the pattern assume(type.test) appearing in
855  // two basic blocks into assume(phi(type.test, type.test)), which would
856  // transform a dependency on a WPD resolution into a dependency on a type
857  // identifier resolution for CFI.
858  //
859  // Also, WPD has access to more precise information than ICP and can
860  // devirtualize more effectively, so it should operate on the IR first.
861  PM.add(createWholeProgramDevirtPass(nullptr, ImportSummary));
862  PM.add(createLowerTypeTestsPass(nullptr, ImportSummary));
863  }
864 
865  populateModulePassManager(PM);
866 
867  if (VerifyOutput)
868  PM.add(createVerifierPass());
869  PerformThinLTO = false;
870 }
871 
873  if (LibraryInfo)
874  PM.add(new TargetLibraryInfoWrapperPass(*LibraryInfo));
875 
876  if (VerifyInput)
877  PM.add(createVerifierPass());
878 
879  if (OptLevel != 0)
880  addLTOOptimizationPasses(PM);
881  else {
882  // The whole-program-devirt pass needs to run at -O0 because only it knows
883  // about the llvm.type.checked.load intrinsic: it needs to both lower the
884  // intrinsic itself and handle it in the summary.
885  PM.add(createWholeProgramDevirtPass(ExportSummary, nullptr));
886  }
887 
888  // Create a function that performs CFI checks for cross-DSO calls with targets
889  // in the current module.
891 
892  // Lower type metadata and the type.test intrinsic. This pass supports Clang's
893  // control flow integrity mechanisms (-fsanitize=cfi*) and needs to run at
894  // link time if CFI is enabled. The pass does nothing if CFI is disabled.
895  PM.add(createLowerTypeTestsPass(ExportSummary, nullptr));
896 
897  if (OptLevel != 0)
898  addLateLTOOptimizationPasses(PM);
899 
900  if (VerifyOutput)
901  PM.add(createVerifierPass());
902 }
903 
905  return reinterpret_cast<PassManagerBuilder*>(P);
906 }
907 
909  return reinterpret_cast<LLVMPassManagerBuilderRef>(P);
910 }
911 
914  return wrap(PMB);
915 }
916 
918  PassManagerBuilder *Builder = unwrap(PMB);
919  delete Builder;
920 }
921 
922 void
924  unsigned OptLevel) {
925  PassManagerBuilder *Builder = unwrap(PMB);
926  Builder->OptLevel = OptLevel;
927 }
928 
929 void
931  unsigned SizeLevel) {
932  PassManagerBuilder *Builder = unwrap(PMB);
933  Builder->SizeLevel = SizeLevel;
934 }
935 
936 void
938  LLVMBool Value) {
939  PassManagerBuilder *Builder = unwrap(PMB);
940  Builder->DisableUnitAtATime = Value;
941 }
942 
943 void
945  LLVMBool Value) {
946  PassManagerBuilder *Builder = unwrap(PMB);
947  Builder->DisableUnrollLoops = Value;
948 }
949 
950 void
952  LLVMBool Value) {
953  // NOTE: The simplify-libcalls pass has been removed.
954 }
955 
956 void
958  unsigned Threshold) {
959  PassManagerBuilder *Builder = unwrap(PMB);
960  Builder->Inliner = createFunctionInliningPass(Threshold);
961 }
962 
963 void
965  LLVMPassManagerRef PM) {
966  PassManagerBuilder *Builder = unwrap(PMB);
967  legacy::FunctionPassManager *FPM = unwrap<legacy::FunctionPassManager>(PM);
968  Builder->populateFunctionPassManager(*FPM);
969 }
970 
971 void
973  LLVMPassManagerRef PM) {
974  PassManagerBuilder *Builder = unwrap(PMB);
975  legacy::PassManagerBase *MPM = unwrap(PM);
976  Builder->populateModulePassManager(*MPM);
977 }
978 
981  LLVMBool Internalize,
982  LLVMBool RunInliner) {
983  PassManagerBuilder *Builder = unwrap(PMB);
984  legacy::PassManagerBase *LPM = unwrap(PM);
985 
986  // A small backwards compatibility hack. populateLTOPassManager used to take
987  // an RunInliner option.
988  if (RunInliner && !Builder->Inliner)
989  Builder->Inliner = createFunctionInliningPass();
990 
991  Builder->populateLTOPassManager(*LPM);
992 }
Super simple passes to force specific function attrs from the commandline into the IR for debugging p...
ModulePass * createNameAnonGlobalPass()
===------------------------------------------------------------------—===//
FunctionPass * createGVNPass(bool NoLoads=false)
Create a legacy GVN pass.
Definition: GVN.cpp:2364
Pass * createLoopRerollPass()
Thresholds to tune inline cost analysis.
Definition: InlineCost.h:123
static const struct @339 Extensions[]
void LLVMPassManagerBuilderSetOptLevel(LLVMPassManagerBuilderRef PMB, unsigned OptLevel)
See llvm::PassManagerBuilder::OptLevel.
ModulePass * createStripDeadPrototypesPass()
createStripDeadPrototypesPass - This pass removes any function declarations (prototypes) that are not...
ModulePass * createPGOInstrumentationGenLegacyPass()
static cl::opt< bool > UseLoopVersioningLICM("enable-loop-versioning-licm", cl::init(false), cl::Hidden, cl::desc("Enable the experimental Loop Versioning LICM pass"))
PassManagerBuilder - This class is used to set up a standard optimization sequence for languages like...
partial Partial Inliner
This is the interface for LLVM&#39;s inclusion-based alias analysis implemented with CFL graph reachabili...
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
This is the interface for a simple mod/ref and alias analysis over globals.
static cl::opt< bool > EnableEarlyCSEMemSSA("enable-earlycse-memssa", cl::init(true), cl::Hidden, cl::desc("Enable the EarlyCSE w/ MemorySSA pass (default = on)"))
FunctionPass * createPGOMemOPSizeOptLegacyPass()
ModulePass * createMergeFunctionsPass()
createMergeFunctionsPass - This pass discovers identical functions and collapses them.
void populateThinLTOPassManager(legacy::PassManagerBase &PM)
static cl::opt< bool > EnableGVNHoist("enable-gvn-hoist", cl::init(false), cl::Hidden, cl::desc("Enable the GVN hoisting pass (default = off)"))
void LLVMPassManagerBuilderSetDisableSimplifyLibCalls(LLVMPassManagerBuilderRef PMB, LLVMBool Value)
See llvm::PassManagerBuilder::DisableSimplifyLibCalls.
This is the interface for a metadata-based scoped no-alias analysis.
static cl::opt< std::string > RunPGOInstrUse("profile-use", cl::init(""), cl::Hidden, cl::value_desc("filename"), cl::desc("Enable use phase of PGO instrumentation and specify the path " "of profile data file"))
FunctionPass * createVerifierPass(bool FatalErrors=true)
Definition: Verifier.cpp:4974
ModulePass * createIPSCCPPass()
createIPSCCPPass - This pass propagates constants from call sites into the bodies of functions...
Definition: SCCP.cpp:1983
FunctionPass * createFloat2IntPass()
Definition: Float2Int.cpp:514
virtual void add(Pass *P)=0
Add a pass to the queue of passes to run.
void LLVMPassManagerBuilderSetDisableUnrollLoops(LLVMPassManagerBuilderRef PMB, LLVMBool Value)
See llvm::PassManagerBuilder::DisableUnrollLoops.
static cl::opt< std::string > PGOOutputFile("profile-generate-file", cl::init(""), cl::Hidden, cl::desc("Specify the path of profile data file."))
ModulePass * createEliminateAvailableExternallyPass()
This transform is designed to eliminate available external globals (functions or global variables) ...
FunctionPass * createGVNHoistPass()
Definition: GVNHoist.cpp:1045
static cl::opt< bool > RunPGOInstrGen("profile-generate", cl::init(false), cl::Hidden, cl::desc("Enable PGO instrumentation."))
ModulePass * createInstrProfilingLegacyPass(const InstrProfOptions &Options=InstrProfOptions())
Insert frontend instrumentation based profiling.
ImmutablePass * createScopedNoAliasAAWrapperPass()
FunctionPass * createAlignmentFromAssumptionsPass()
void LLVMPassManagerBuilderPopulateLTOPassManager(LLVMPassManagerBuilderRef PMB, LLVMPassManagerRef PM, LLVMBool Internalize, LLVMBool RunInliner)
See llvm::PassManagerBuilder::populateLTOPassManager.
Pass * Inliner
Inliner - Specifies the inliner to use.
FunctionPass * createJumpThreadingPass(int Threshold=-1)
static cl::opt< bool > RunLoopVectorization("vectorize-loops", cl::Hidden, cl::desc("Run the Loop vectorization passes"))
ModulePass * createPartialInliningPass()
createPartialInliningPass - This pass inlines parts of functions.
Attribute unwrap(LLVMAttributeRef Attr)
Definition: Attributes.h:195
static void addGlobalExtension(ExtensionPointTy Ty, ExtensionFn Fn)
Adds an extension that will be used by all PassManagerBuilder instances.
Optional< int > HintThreshold
Threshold to use for callees with inline hint.
Definition: InlineCost.h:128
static cl::opt< bool > EnableNonLTOGlobalsModRef("enable-non-lto-gmr", cl::init(true), cl::Hidden, cl::desc("Enable the GlobalsModRef AliasAnalysis outside of the LTO pipeline."))
void populateLTOPassManager(legacy::PassManagerBase &PM)
ModulePass * createCrossDSOCFIPass()
This pass export CFI checks for use by external modules.
static cl::opt< bool > ExtraVectorizerPasses("extra-vectorizer-passes", cl::init(false), cl::Hidden, cl::desc("Run cleanup optimization passes after vectorization."))
FunctionPass * createReassociatePass()
Pass * createSimpleLoopUnrollPass(int OptLevel=2)
Pass * createArgumentPromotionPass(unsigned maxElements=3)
createArgumentPromotionPass - This pass promotes "by reference" arguments to be passed by value if th...
static cl::opt< bool > EnableSimpleLoopUnswitch("enable-simple-loop-unswitch", cl::init(false), cl::Hidden, cl::desc("Enable the simple loop unswitch pass."))
static cl::opt< bool > EnablePrepareForThinLTO("prepare-for-thinlto", cl::init(false), cl::Hidden, cl::desc("Enable preparation for ThinLTO."))
FunctionPass * createSCCPPass()
Definition: SCCP.cpp:1700
FunctionPass * createCFGSimplificationPass(int Threshold=-1, std::function< bool(const Function &)> Ftor=nullptr)
std::function< void(const PassManagerBuilder &Builder, legacy::PassManagerBase &PM)> ExtensionFn
Extensions are passed the builder itself (so they can see how it is configured) as well as the pass m...
unsigned OptLevel
The Optimization Level - Specify the basic optimization level.
static cl::opt< bool > UseGVNAfterVectorization("use-gvn-after-vectorization", cl::init(false), cl::Hidden, cl::desc("Run GVN instead of Early CSE after vectorization passes"))
Pass * createLoopVectorizePass(bool NoUnrolling=false, bool AlwaysVectorize=true)
void populateModulePassManager(legacy::PassManagerBase &MPM)
populateModulePassManager - This sets up the primary pass manager.
static cl::opt< bool > DisablePreInliner("disable-preinline", cl::init(false), cl::Hidden, cl::desc("Disable pre-instrumentation inliner"))
void add(Pass *P) override
Add a pass to the queue of passes to run.
static ManagedStatic< SmallVector< std::pair< PassManagerBuilder::ExtensionPointTy, PassManagerBuilder::ExtensionFn >, 8 > > GlobalExtensions
Set of global extensions, automatically added as part of the standard set.
static cl::opt< bool > RunSLPVectorization("vectorize-slp", cl::Hidden, cl::desc("Run the SLP vectorization passes"))
void LLVMPassManagerBuilderSetSizeLevel(LLVMPassManagerBuilderRef PMB, unsigned SizeLevel)
See llvm::PassManagerBuilder::SizeLevel.
FunctionPass * createNewGVNPass()
Definition: NewGVN.cpp:3921
ModulePass * createSampleProfileLoaderPass()
FunctionPass * createInstructionCombiningPass(bool ExpensiveCombines=true)
ModulePass * createGlobalDCEPass()
createGlobalDCEPass - This transform is designed to eliminate unreachable internal globals (functions...
Pass * createCorrelatedValuePropagationPass()
struct LLVMOpaquePassManagerBuilder * LLVMPassManagerBuilderRef
#define P(N)
This is the interface for LLVM&#39;s unification-based alias analysis implemented with CFL graph reachabi...
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:404
This is the interface for a metadata-based TBAA.
FunctionPass * createTailCallEliminationPass()
This file provides the interface for LLVM&#39;s Global Value Numbering pass which eliminates fully redund...
ValuesClass values(OptsTy... Options)
Helper to build a ValuesClass by forwarding a variable number of arguments as an initializer list to ...
Definition: CommandLine.h:624
FunctionPass * createPromoteMemoryToRegisterPass()
Definition: Mem2Reg.cpp:106
ModulePass * createDeadArgEliminationPass()
createDeadArgEliminationPass - This pass removes arguments from functions which are not used by the b...
void LLVMPassManagerBuilderDispose(LLVMPassManagerBuilderRef PMB)
Pass * createLICMPass()
Definition: LICM.cpp:223
FunctionPass * createDeadStoreEliminationPass()
ModulePass * createLowerTypeTestsPass(ModuleSummaryIndex *ExportSummary, const ModuleSummaryIndex *ImportSummary)
This pass lowers type metadata and the llvm.type.test intrinsic to bitsets.
ModulePass * createPGOInstrumentationUseLegacyPass(StringRef Filename=StringRef(""))
ModulePass * createBarrierNoopPass()
createBarrierNoopPass - This pass is purely a module pass barrier in a pass manager.
FunctionPass * createMemCpyOptPass()
The public interface to this file...
FunctionPass * createBitTrackingDCEPass()
Definition: BDCE.cpp:118
ModulePass * createConstantMergePass()
createConstantMergePass - This function returns a new pass that merges duplicate global constants tog...
Pass * createLoopSinkPass()
ModulePass * createGlobalOptimizerPass()
createGlobalOptimizerPass - This function returns a new pass that optimizes non-address taken interna...
Definition: GlobalOpt.cpp:2616
Pass * createReversePostOrderFunctionAttrsPass()
createReversePostOrderFunctionAttrsPass - This pass walks SCCs of the call graph in RPO to deduce and...
FunctionPass * createLateCFGSimplificationPass(int Threshold=-1, std::function< bool(const Function &)> Ftor=nullptr)
void populateFunctionPassManager(legacy::FunctionPassManager &FPM)
populateFunctionPassManager - This fills in the function pass manager, which is expected to be run on...
FunctionPassManager manages FunctionPasses and BasicBlockPassManagers.
int LLVMBool
Definition: Types.h:29
Pass * createPostOrderFunctionAttrsLegacyPass()
Create a legacy pass manager instance of a pass to compute function attrs in post-order.
std::string InstrProfileOutput
Pass * createLoopVersioningLICMPass()
ModulePass * createGlobalSplitPass()
This pass splits globals into pieces for the benefit of whole-program devirtualization and control-fl...
static cl::opt< bool > EnableLoopInterchange("enable-loopinterchange", cl::init(false), cl::Hidden, cl::desc("Enable the new, experimental LoopInterchange Pass"))
unsigned first
static cl::opt< bool > EnableLoopLoadElim("enable-loop-load-elim", cl::init(true), cl::Hidden, cl::desc("Enable the LoopLoadElimination Pass"))
Pass * createLoopInterchangePass()
PassManagerBase - An abstract interface to allow code to add passes to a pass manager without having ...
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:864
FunctionPass * createLoopLoadEliminationPass()
static cl::opt< bool > RunSLPAfterLoopVectorization("run-slp-after-loop-vectorization", cl::init(true), cl::Hidden, cl::desc("Run the SLP vectorizer (and BB vectorizer) after the Loop " "vectorizer instead of before"))
Pass * createSimpleLoopUnswitchLegacyPass()
Create the legacy pass object for the simple loop unswitcher.
static cl::opt< CFLAAType > UseCFLAA("use-cfl-aa", cl::init(CFLAAType::None), cl::Hidden, cl::desc("Enable the new, experimental CFL alias analysis"), cl::values(clEnumValN(CFLAAType::None, "none", "Disable CFL-AA"), clEnumValN(CFLAAType::Steensgaard, "steens", "Enable unification-based CFL-AA"), clEnumValN(CFLAAType::Andersen, "anders", "Enable inclusion-based CFL-AA"), clEnumValN(CFLAAType::Both, "both", "Enable both variants of CFL-AA")))
FunctionPass * createSpeculativeExecutionIfHasBranchDivergencePass()
Pass * createLoopUnrollPass(int OptLevel=2, int Threshold=-1, int Count=-1, int AllowPartial=-1, int Runtime=-1, int UpperBound=-1)
FunctionPass * createMergedLoadStoreMotionPass()
createMergedLoadStoreMotionPass - The public interface to this file.
FunctionPass * createLibCallsShrinkWrapPass()
struct LLVMOpaquePassManager * LLVMPassManagerRef
Definition: Types.h:114
Pass * createLoopDeletionPass()
Pass * createLoopUnswitchPass(bool OptimizeForSize=false, bool hasBranchDivergence=false)
Options for the frontend instrumentation based profiling pass.
static cl::opt< bool > EnableGVNSink("enable-gvn-sink", cl::init(false), cl::Hidden, cl::desc("Enable the GVN sinking pass (default = off)"))
Pass * createLoopIdiomPass()
#define clEnumValN(ENUMVAL, FLAGNAME, DESC)
Definition: CommandLine.h:599
ModulePass * createWholeProgramDevirtPass(ModuleSummaryIndex *ExportSummary, const ModuleSummaryIndex *ImportSummary)
This pass implements whole-program devirtualization using type metadata.
Interfaces for passes which infer implicit function attributes from the name and signature of functio...
LLVMPassManagerBuilderRef LLVMPassManagerBuilderCreate()
See llvm::PassManagerBuilder.
void LLVMPassManagerBuilderPopulateModulePassManager(LLVMPassManagerBuilderRef PMB, LLVMPassManagerRef PM)
See llvm::PassManagerBuilder::populateModulePassManager.
LLVMAttributeRef wrap(Attribute Attr)
Definition: Attributes.h:190
unsigned SizeLevel
SizeLevel - How much we&#39;re optimizing for size.
static cl::opt< bool > DisableLibCallsShrinkWrap("disable-libcalls-shrinkwrap", cl::init(false), cl::Hidden, cl::desc("Disable shrink-wrap library calls"))
FunctionPass * createGVNSinkPass()
Definition: GVNSink.cpp:883
ModulePass * createGlobalsAAWrapperPass()
FunctionPass * createSROAPass()
Definition: SROA.cpp:4312
Pass * createInferFunctionAttrsLegacyPass()
Create a legacy pass manager instance of a pass to infer function attributes.
static bool GlobalExtensionsNotEmpty()
Check if GlobalExtensions is constructed and not empty.
Provides passes for computing function attributes based on interprocedural analyses.
ImmutablePass * createCFLSteensAAWrapperPass()
ImmutablePass * createTypeBasedAAWrapperPass()
Pass * createSLPVectorizerPass()
static int const Threshold
TODO: Write a new FunctionPass AliasAnalysis so that it can keep a cache.
ModuleSummaryIndex.h This file contains the declarations the classes that hold the module index and s...
void LLVMPassManagerBuilderSetDisableUnitAtATime(LLVMPassManagerBuilderRef PMB, LLVMBool Value)
See llvm::PassManagerBuilder::DisableUnitAtATime.
Pass * createFunctionInliningPass()
createFunctionInliningPass - Return a new pass object that uses a heuristic to inline direct function...
Pass * createPruneEHPass()
createPruneEHPass - Return a new pass object which transforms invoke instructions into calls...
Definition: PruneEH.cpp:62
LLVM Value Representation.
Definition: Value.h:73
FunctionPass * createEarlyCSEPass(bool UseMemorySSA=false)
Definition: EarlyCSE.cpp:1086
static cl::opt< int > PreInlineThreshold("preinline-threshold", cl::Hidden, cl::init(75), cl::ZeroOrMore, cl::desc("Control the amount of inlining in pre-instrumentation inliner " "(default = 75)"))
This is the interface for LLVM&#39;s primary stateless and local alias analysis.
static cl::opt< bool > RunPartialInlining("enable-partial-inlining", cl::init(false), cl::Hidden, cl::ZeroOrMore, cl::desc("Run Partial inlinining pass"))
ManagedStatic - This transparently changes the behavior of global statics to be lazily constructed on...
Definition: ManagedStatic.h:61
void LLVMPassManagerBuilderPopulateFunctionPassManager(LLVMPassManagerBuilderRef PMB, LLVMPassManagerRef PM)
See llvm::PassManagerBuilder::populateFunctionPassManager.
ImmutablePass * createCFLAndersAAWrapperPass()
void addExtension(ExtensionPointTy Ty, ExtensionFn Fn)
FunctionPass * createInstructionSimplifierPass()
Pass * createForceFunctionAttrsLegacyPass()
Create a legacy pass manager instance of a pass to force function attrs.
Pass * createLoopRotatePass(int MaxHeaderSize=-1)
Pass * createIndVarSimplifyPass()
FunctionPass * createAggressiveDCEPass()
Definition: ADCE.cpp:664
int DefaultThreshold
The default threshold to start with for a callee.
Definition: InlineCost.h:125
FunctionPass * createLoopDistributePass()
FunctionPass * createLowerExpectIntrinsicPass()
static cl::opt< bool > RunLoopRerolling("reroll-loops", cl::Hidden, cl::desc("Run the loop rerolling pass"))
static cl::opt< bool > RunNewGVN("enable-newgvn", cl::init(false), cl::Hidden, cl::desc("Run the NewGVN pass"))
void LLVMPassManagerBuilderUseInlinerWithThreshold(LLVMPassManagerBuilderRef PMB, unsigned Threshold)
See llvm::PassManagerBuilder::Inliner.
ModulePass * createPGOIndirectCallPromotionLegacyPass(bool InLTO=false, bool SamplePGO=false)