LLVM  4.0.0
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"
42 
43 using namespace llvm;
44 
45 static cl::opt<bool>
46 RunLoopVectorization("vectorize-loops", cl::Hidden,
47  cl::desc("Run the Loop vectorization passes"));
48 
49 static cl::opt<bool>
50 RunSLPVectorization("vectorize-slp", cl::Hidden,
51  cl::desc("Run the SLP vectorization passes"));
52 
53 static cl::opt<bool>
54 RunBBVectorization("vectorize-slp-aggressive", cl::Hidden,
55  cl::desc("Run the BB vectorization passes"));
56 
57 static cl::opt<bool>
58 UseGVNAfterVectorization("use-gvn-after-vectorization",
59  cl::init(false), cl::Hidden,
60  cl::desc("Run GVN instead of Early CSE after vectorization passes"));
61 
63  "extra-vectorizer-passes", cl::init(false), cl::Hidden,
64  cl::desc("Run cleanup optimization passes after vectorization."));
65 
66 static cl::opt<bool>
67 RunLoopRerolling("reroll-loops", cl::Hidden,
68  cl::desc("Run the loop rerolling pass"));
69 
70 static cl::opt<bool> RunLoadCombine("combine-loads", cl::init(false),
71  cl::Hidden,
72  cl::desc("Run the load combining pass"));
73 
74 static cl::opt<bool> RunNewGVN("enable-newgvn", cl::init(false), cl::Hidden,
75  cl::desc("Run the NewGVN pass"));
76 
77 static cl::opt<bool>
78 RunSLPAfterLoopVectorization("run-slp-after-loop-vectorization",
79  cl::init(true), cl::Hidden,
80  cl::desc("Run the SLP vectorizer (and BB vectorizer) after the Loop "
81  "vectorizer instead of before"));
82 
83 // Experimental option to use CFL-AA
85 static cl::opt<CFLAAType>
87  cl::desc("Enable the new, experimental CFL alias analysis"),
88  cl::values(clEnumValN(CFLAAType::None, "none", "Disable CFL-AA"),
90  "Enable unification-based CFL-AA"),
92  "Enable inclusion-based CFL-AA"),
94  "Enable both variants of CFL-AA")));
95 
96 static cl::opt<bool>
97 EnableMLSM("mlsm", cl::init(true), cl::Hidden,
98  cl::desc("Enable motion of merged load and store"));
99 
101  "enable-loopinterchange", cl::init(false), cl::Hidden,
102  cl::desc("Enable the new, experimental LoopInterchange Pass"));
103 
105  "enable-non-lto-gmr", cl::init(true), cl::Hidden,
106  cl::desc(
107  "Enable the GlobalsModRef AliasAnalysis outside of the LTO pipeline."));
108 
110  "enable-loop-load-elim", cl::init(true), cl::Hidden,
111  cl::desc("Enable the LoopLoadElimination Pass"));
112 
113 static cl::opt<bool>
114  EnablePrepareForThinLTO("prepare-for-thinlto", cl::init(false), cl::Hidden,
115  cl::desc("Enable preparation for ThinLTO."));
116 
118  "profile-generate", cl::init(false), cl::Hidden,
119  cl::desc("Enable PGO instrumentation."));
120 
122  PGOOutputFile("profile-generate-file", cl::init(""), cl::Hidden,
123  cl::desc("Specify the path of profile data file."));
124 
126  "profile-use", cl::init(""), cl::Hidden, cl::value_desc("filename"),
127  cl::desc("Enable use phase of PGO instrumentation and specify the path "
128  "of profile data file"));
129 
131  "enable-loop-versioning-licm", cl::init(false), cl::Hidden,
132  cl::desc("Enable the experimental Loop Versioning LICM pass"));
133 
134 static cl::opt<bool>
135  DisablePreInliner("disable-preinline", cl::init(false), cl::Hidden,
136  cl::desc("Disable pre-instrumentation inliner"));
137 
139  "preinline-threshold", cl::Hidden, cl::init(75), cl::ZeroOrMore,
140  cl::desc("Control the amount of inlining in pre-instrumentation inliner "
141  "(default = 75)"));
142 
144  "enable-gvn-hoist", cl::init(false), cl::Hidden,
145  cl::desc("Enable the GVN hoisting pass"));
146 
147 static cl::opt<bool>
148  DisableLibCallsShrinkWrap("disable-libcalls-shrinkwrap", cl::init(false),
149  cl::Hidden,
150  cl::desc("Disable shrink-wrap library calls"));
151 
153  OptLevel = 2;
154  SizeLevel = 0;
155  LibraryInfo = nullptr;
156  Inliner = nullptr;
157  DisableUnitAtATime = false;
158  DisableUnrollLoops = false;
164  NewGVN = RunNewGVN;
165  DisableGVNLoadPRE = false;
166  VerifyInput = false;
167  VerifyOutput = false;
168  MergeFunctions = false;
169  PrepareForLTO = false;
174  PerformThinLTO = false;
175 }
176 
178  delete LibraryInfo;
179  delete Inliner;
180 }
181 
182 /// Set of global extensions, automatically added as part of the standard set.
185 
189  GlobalExtensions->push_back(std::make_pair(Ty, std::move(Fn)));
190 }
191 
193  Extensions.push_back(std::make_pair(Ty, std::move(Fn)));
194 }
195 
196 void PassManagerBuilder::addExtensionsToPM(ExtensionPointTy ETy,
197  legacy::PassManagerBase &PM) const {
198  for (unsigned i = 0, e = GlobalExtensions->size(); i != e; ++i)
199  if ((*GlobalExtensions)[i].first == ETy)
200  (*GlobalExtensions)[i].second(*this, PM);
201  for (unsigned i = 0, e = Extensions.size(); i != e; ++i)
202  if (Extensions[i].first == ETy)
203  Extensions[i].second(*this, PM);
204 }
205 
206 void PassManagerBuilder::addInitialAliasAnalysisPasses(
207  legacy::PassManagerBase &PM) const {
208  switch (UseCFLAA) {
211  break;
212  case CFLAAType::Andersen:
214  break;
215  case CFLAAType::Both:
218  break;
219  default:
220  break;
221  }
222 
223  // Add TypeBasedAliasAnalysis before BasicAliasAnalysis so that
224  // BasicAliasAnalysis wins if they disagree. This is intended to help
225  // support "obvious" type-punning idioms.
228 }
229 
230 void PassManagerBuilder::addInstructionCombiningPass(
231  legacy::PassManagerBase &PM) const {
232  bool ExpensiveCombines = OptLevel > 2;
233  PM.add(createInstructionCombiningPass(ExpensiveCombines));
234 }
235 
238  addExtensionsToPM(EP_EarlyAsPossible, FPM);
239 
240  // Add LibraryInfo if we have some.
241  if (LibraryInfo)
243 
244  if (OptLevel == 0) return;
245 
246  addInitialAliasAnalysisPasses(FPM);
247 
249  FPM.add(createSROAPass());
250  FPM.add(createEarlyCSEPass());
251  if(EnableGVNHoist)
252  FPM.add(createGVNHoistPass());
254 }
255 
256 // Do PGO instrumentation generation or use pass as the option specified.
257 void PassManagerBuilder::addPGOInstrPasses(legacy::PassManagerBase &MPM) {
258  if (!EnablePGOInstrGen && PGOInstrUse.empty())
259  return;
260  // Perform the preinline and cleanup passes for O1 and above.
261  // And avoid doing them if optimizing for size.
262  if (OptLevel > 0 && SizeLevel == 0 && !DisablePreInliner) {
263  // Create preinline pass. We construct an InlineParams object and specify
264  // the threshold here to avoid the command line options of the regular
265  // inliner to influence pre-inlining. The only fields of InlineParams we
266  // care about are DefaultThreshold and HintThreshold.
267  InlineParams IP;
269  // FIXME: The hint threshold has the same value used by the regular inliner.
270  // This should probably be lowered after performance testing.
271  IP.HintThreshold = 325;
272 
274  MPM.add(createSROAPass());
275  MPM.add(createEarlyCSEPass()); // Catch trivial redundancies
276  MPM.add(createCFGSimplificationPass()); // Merge & remove BBs
277  MPM.add(createInstructionCombiningPass()); // Combine silly seq's
278  addExtensionsToPM(EP_Peephole, MPM);
279  }
280  if (EnablePGOInstrGen) {
282  // Add the profile lowering pass.
283  InstrProfOptions Options;
284  if (!PGOInstrGen.empty())
286  MPM.add(createInstrProfilingLegacyPass(Options));
287  }
288  if (!PGOInstrUse.empty())
290 }
291 void PassManagerBuilder::addFunctionSimplificationPasses(
293  // Start of function pass.
294  // Break up aggregate allocas, using SSAUpdater.
295  MPM.add(createSROAPass());
296  MPM.add(createEarlyCSEPass()); // Catch trivial redundancies
297  // Speculative execution if the target has divergent branches; otherwise nop.
299  MPM.add(createJumpThreadingPass()); // Thread jumps.
300  MPM.add(createCorrelatedValuePropagationPass()); // Propagate conditionals
301  MPM.add(createCFGSimplificationPass()); // Merge & remove BBs
302  // Combine silly seq's
303  addInstructionCombiningPass(MPM);
306  addExtensionsToPM(EP_Peephole, MPM);
307 
308  MPM.add(createTailCallEliminationPass()); // Eliminate tail calls
309  MPM.add(createCFGSimplificationPass()); // Merge & remove BBs
310  MPM.add(createReassociatePass()); // Reassociate expressions
311  // Rotate Loop - disable header duplication at -Oz
312  MPM.add(createLoopRotatePass(SizeLevel == 2 ? 0 : -1));
313  MPM.add(createLICMPass()); // Hoist loop invariants
316  addInstructionCombiningPass(MPM);
317  MPM.add(createIndVarSimplifyPass()); // Canonicalize indvars
318  MPM.add(createLoopIdiomPass()); // Recognize idioms like memset.
319  MPM.add(createLoopDeletionPass()); // Delete dead loops
320  if (EnableLoopInterchange) {
321  MPM.add(createLoopInterchangePass()); // Interchange loops
323  }
324  if (!DisableUnrollLoops)
325  MPM.add(createSimpleLoopUnrollPass()); // Unroll small loops
326  addExtensionsToPM(EP_LoopOptimizerEnd, MPM);
327 
328  if (OptLevel > 1) {
329  if (EnableMLSM)
330  MPM.add(createMergedLoadStoreMotionPass()); // Merge ld/st in diamonds
331  MPM.add(NewGVN ? createNewGVNPass()
332  : createGVNPass(DisableGVNLoadPRE)); // Remove redundancies
333  }
334  MPM.add(createMemCpyOptPass()); // Remove memcpy / form memset
335  MPM.add(createSCCPPass()); // Constant prop with SCCP
336 
337  // Delete dead bit computations (instcombine runs after to fold away the dead
338  // computations, and then ADCE will run later to exploit any new DCE
339  // opportunities that creates).
340  MPM.add(createBitTrackingDCEPass()); // Delete dead bit computations
341 
342  // Run instcombine after redundancy elimination to exploit opportunities
343  // opened up by them.
344  addInstructionCombiningPass(MPM);
345  addExtensionsToPM(EP_Peephole, MPM);
346  MPM.add(createJumpThreadingPass()); // Thread jumps
348  MPM.add(createDeadStoreEliminationPass()); // Delete dead stores
349  MPM.add(createLICMPass());
350 
351  addExtensionsToPM(EP_ScalarOptimizerLate, MPM);
352 
353  if (RerollLoops)
354  MPM.add(createLoopRerollPass());
356  if (SLPVectorize)
357  MPM.add(createSLPVectorizerPass()); // Vectorize parallel scalar chains.
358 
359  if (BBVectorize) {
360  MPM.add(createBBVectorizePass());
361  addInstructionCombiningPass(MPM);
362  addExtensionsToPM(EP_Peephole, MPM);
364  MPM.add(NewGVN
365  ? createNewGVNPass()
366  : createGVNPass(DisableGVNLoadPRE)); // Remove redundancies
367  else
368  MPM.add(createEarlyCSEPass()); // Catch trivial redundancies
369 
370  // BBVectorize may have significantly shortened a loop body; unroll again.
371  if (!DisableUnrollLoops)
372  MPM.add(createLoopUnrollPass());
373  }
374  }
375 
376  if (LoadCombine)
377  MPM.add(createLoadCombinePass());
378 
379  MPM.add(createAggressiveDCEPass()); // Delete dead instructions
380  MPM.add(createCFGSimplificationPass()); // Merge & remove BBs
381  // Clean up after everything.
382  addInstructionCombiningPass(MPM);
383  addExtensionsToPM(EP_Peephole, MPM);
384 }
385 
388  if (!PGOSampleUse.empty()) {
389  MPM.add(createPruneEHPass());
391  }
392 
393  // Allow forcing function attributes as a debugging and tuning aid.
395 
396  // If all optimizations are disabled, just run the always-inline pass and,
397  // if enabled, the function merging pass.
398  if (OptLevel == 0) {
399  addPGOInstrPasses(MPM);
400  if (Inliner) {
401  MPM.add(Inliner);
402  Inliner = nullptr;
403  }
404 
405  // FIXME: The BarrierNoopPass is a HACK! The inliner pass above implicitly
406  // creates a CGSCC pass manager, but we don't want to add extensions into
407  // that pass manager. To prevent this we insert a no-op module pass to reset
408  // the pass manager to get the same behavior as EP_OptimizerLast in non-O0
409  // builds. The function merging pass is
410  if (MergeFunctions)
412  else if (!GlobalExtensions->empty() || !Extensions.empty())
413  MPM.add(createBarrierNoopPass());
414 
415  if (PrepareForThinLTO)
416  // Rename anon globals to be able to export them in the summary.
418 
419  addExtensionsToPM(EP_EnabledOnOptLevel0, MPM);
420  return;
421  }
422 
423  // Add LibraryInfo if we have some.
424  if (LibraryInfo)
426 
427  addInitialAliasAnalysisPasses(MPM);
428 
429  // For ThinLTO there are two passes of indirect call promotion. The
430  // first is during the compile phase when PerformThinLTO=false and
431  // intra-module indirect call targets are promoted. The second is during
432  // the ThinLTO backend when PerformThinLTO=true, when we promote imported
433  // inter-module indirect calls. For that we perform indirect call promotion
434  // earlier in the pass pipeline, here before globalopt. Otherwise imported
435  // available_externally functions look unreferenced and are removed.
436  if (PerformThinLTO)
437  MPM.add(createPGOIndirectCallPromotionLegacyPass(/*InLTO = */ true));
438 
439  if (!DisableUnitAtATime) {
440  // Infer attributes about declarations if possible.
442 
443  addExtensionsToPM(EP_ModuleOptimizerEarly, MPM);
444 
445  MPM.add(createIPSCCPPass()); // IP SCCP
446  MPM.add(createGlobalOptimizerPass()); // Optimize out global vars
447  // Promote any localized global vars.
449 
450  MPM.add(createDeadArgEliminationPass()); // Dead argument elimination
451 
452  addInstructionCombiningPass(MPM); // Clean up after IPCP & DAE
453  addExtensionsToPM(EP_Peephole, MPM);
454  MPM.add(createCFGSimplificationPass()); // Clean up after IPCP & DAE
455  }
456 
457  if (!PerformThinLTO) {
458  /// PGO instrumentation is added during the compile phase for ThinLTO, do
459  /// not run it a second time
460  addPGOInstrPasses(MPM);
461  // Indirect call promotion that promotes intra-module targets only.
462  // For ThinLTO this is done earlier due to interactions with globalopt
463  // for imported functions.
465  }
466 
468  // We add a module alias analysis pass here. In part due to bugs in the
469  // analysis infrastructure this "works" in that the analysis stays alive
470  // for the entire SCC pass run below.
472 
473  // Start of CallGraph SCC passes.
474  if (!DisableUnitAtATime)
475  MPM.add(createPruneEHPass()); // Remove dead EH info
476  if (Inliner) {
477  MPM.add(Inliner);
478  Inliner = nullptr;
479  }
480  if (!DisableUnitAtATime)
482  if (OptLevel > 2)
483  MPM.add(createArgumentPromotionPass()); // Scalarize uninlined fn args
484 
485  addExtensionsToPM(EP_CGSCCOptimizerLate, MPM);
486  addFunctionSimplificationPasses(MPM);
487 
488  // FIXME: This is a HACK! The inliner pass above implicitly creates a CGSCC
489  // pass manager that we are specifically trying to avoid. To prevent this
490  // we must insert a no-op module pass to reset the pass manager.
491  MPM.add(createBarrierNoopPass());
492 
493  if (!DisableUnitAtATime && OptLevel > 1 && !PrepareForLTO &&
495  // Remove avail extern fns and globals definitions if we aren't
496  // compiling an object file for later LTO. For LTO we want to preserve
497  // these so they are eligible for inlining at link-time. Note if they
498  // are unreferenced they will be removed by GlobalDCE later, so
499  // this only impacts referenced available externally globals.
500  // Eventually they will be suppressed during codegen, but eliminating
501  // here enables more opportunity for GlobalDCE as it may make
502  // globals referenced by available external functions dead
503  // and saves running remaining passes on the eliminated functions.
505 
506  if (!DisableUnitAtATime)
508 
509  // If we are planning to perform ThinLTO later, let's not bloat the code with
510  // unrolling/vectorization/... now. We'll first run the inliner + CGSCC passes
511  // during ThinLTO and perform the rest of the optimizations afterward.
512  if (PrepareForThinLTO) {
513  // Reduce the size of the IR as much as possible.
515  // Rename anon globals to be able to export them in the summary.
517  return;
518  }
519 
520  if (PerformThinLTO)
521  // Optimize globals now when performing ThinLTO, this enables more
522  // optimizations later.
524 
525  // Scheduling LoopVersioningLICM when inlining is over, because after that
526  // we may see more accurate aliasing. Reason to run this late is that too
527  // early versioning may prevent further inlining due to increase of code
528  // size. By placing it just after inlining other optimizations which runs
529  // later might get benefit of no-alias assumption in clone loop.
530  if (UseLoopVersioningLICM) {
531  MPM.add(createLoopVersioningLICMPass()); // Do LoopVersioningLICM
532  MPM.add(createLICMPass()); // Hoist loop invariants
533  }
534 
536  // We add a fresh GlobalsModRef run at this point. This is particularly
537  // useful as the above will have inlined, DCE'ed, and function-attr
538  // propagated everything. We should at this point have a reasonably minimal
539  // and richly annotated call graph. By computing aliasing and mod/ref
540  // information for all local globals here, the late loop passes and notably
541  // the vectorizer will be able to use them to help recognize vectorizable
542  // memory operations.
543  //
544  // Note that this relies on a bug in the pass manager which preserves
545  // a module analysis into a function pass pipeline (and throughout it) so
546  // long as the first function pass doesn't invalidate the module analysis.
547  // Thus both Float2Int and LoopRotate have to preserve AliasAnalysis for
548  // this to work. Fortunately, it is trivial to preserve AliasAnalysis
549  // (doing nothing preserves it as it is required to be conservatively
550  // correct in the face of IR changes).
552 
553  MPM.add(createFloat2IntPass());
554 
555  addExtensionsToPM(EP_VectorizerStart, MPM);
556 
557  // Re-rotate loops in all our loop nests. These may have fallout out of
558  // rotated form due to GVN or other transformations, and the vectorizer relies
559  // on the rotated form. Disable header duplication at -Oz.
560  MPM.add(createLoopRotatePass(SizeLevel == 2 ? 0 : -1));
561 
562  // Distribute loops to allow partial vectorization. I.e. isolate dependences
563  // into separate loop that would otherwise inhibit vectorization. This is
564  // currently only performed for loops marked with the metadata
565  // llvm.loop.distribute=true or when -enable-loop-distribute is specified.
567 
569 
570  // Eliminate loads by forwarding stores from the previous iteration to loads
571  // of the current iteration.
572  if (EnableLoopLoadElim)
574 
575  // FIXME: Because of #pragma vectorize enable, the passes below are always
576  // inserted in the pipeline, even when the vectorizer doesn't run (ex. when
577  // on -O1 and no #pragma is found). Would be good to have these two passes
578  // as function calls, so that we can only pass them when the vectorizer
579  // changed the code.
580  addInstructionCombiningPass(MPM);
581  if (OptLevel > 1 && ExtraVectorizerPasses) {
582  // At higher optimization levels, try to clean up any runtime overlap and
583  // alignment checks inserted by the vectorizer. We want to track correllated
584  // runtime checks for two inner loops in the same outer loop, fold any
585  // common computations, hoist loop-invariant aspects out of any outer loop,
586  // and unswitch the runtime checks if possible. Once hoisted, we may have
587  // dead (or speculatable) control flows or more combining opportunities.
588  MPM.add(createEarlyCSEPass());
590  addInstructionCombiningPass(MPM);
591  MPM.add(createLICMPass());
594  addInstructionCombiningPass(MPM);
595  }
596 
598  if (SLPVectorize) {
599  MPM.add(createSLPVectorizerPass()); // Vectorize parallel scalar chains.
600  if (OptLevel > 1 && ExtraVectorizerPasses) {
601  MPM.add(createEarlyCSEPass());
602  }
603  }
604 
605  if (BBVectorize) {
606  MPM.add(createBBVectorizePass());
607  addInstructionCombiningPass(MPM);
608  addExtensionsToPM(EP_Peephole, MPM);
610  MPM.add(NewGVN
611  ? createNewGVNPass()
612  : createGVNPass(DisableGVNLoadPRE)); // Remove redundancies
613  else
614  MPM.add(createEarlyCSEPass()); // Catch trivial redundancies
615 
616  // BBVectorize may have significantly shortened a loop body; unroll again.
617  if (!DisableUnrollLoops)
618  MPM.add(createLoopUnrollPass());
619  }
620  }
621 
622  addExtensionsToPM(EP_Peephole, MPM);
624  addInstructionCombiningPass(MPM);
625 
626  if (!DisableUnrollLoops) {
627  MPM.add(createLoopUnrollPass()); // Unroll small loops
628 
629  // LoopUnroll may generate some redundency to cleanup.
630  addInstructionCombiningPass(MPM);
631 
632  // Runtime unrolling will introduce runtime check in loop prologue. If the
633  // unrolled loop is a inner loop, then the prologue will be inside the
634  // outer loop. LICM pass can help to promote the runtime check out if the
635  // checked value is loop invariant.
636  MPM.add(createLICMPass());
637  }
638 
639  // After vectorization and unrolling, assume intrinsics may tell us more
640  // about pointer alignments.
642 
643  if (!DisableUnitAtATime) {
644  // FIXME: We shouldn't bother with this anymore.
645  MPM.add(createStripDeadPrototypesPass()); // Get rid of dead prototypes
646 
647  // GlobalOpt already deletes dead functions and globals, at -O2 try a
648  // late pass of GlobalDCE. It is capable of deleting dead cycles.
649  if (OptLevel > 1) {
650  MPM.add(createGlobalDCEPass()); // Remove dead fns and globals.
651  MPM.add(createConstantMergePass()); // Merge dup global constants
652  }
653  }
654 
655  if (MergeFunctions)
657 
658  // LoopSink pass sinks instructions hoisted by LICM, which serves as a
659  // canonicalization pass that enables other optimizations. As a result,
660  // LoopSink pass needs to be a very late IR pass to avoid undoing LICM
661  // result too early.
662  MPM.add(createLoopSinkPass());
663  // Get rid of LCSSA nodes.
665  addExtensionsToPM(EP_OptimizerLast, MPM);
666 }
667 
668 void PassManagerBuilder::addLTOOptimizationPasses(legacy::PassManagerBase &PM) {
669  // Remove unused virtual tables to improve the quality of code generated by
670  // whole-program devirtualization and bitset lowering.
671  PM.add(createGlobalDCEPass());
672 
673  // Provide AliasAnalysis services for optimizations.
674  addInitialAliasAnalysisPasses(PM);
675 
676  // Allow forcing function attributes as a debugging and tuning aid.
678 
679  // Infer attributes about declarations if possible.
681 
682  if (OptLevel > 1) {
683  // Indirect call promotion. This should promote all the targets that are
684  // left by the earlier promotion pass that promotes intra-module targets.
685  // This two-step promotion is to save the compile time. For LTO, it should
686  // produce the same result as if we only do promotion here.
688 
689  // Propagate constants at call sites into the functions they call. This
690  // opens opportunities for globalopt (and inlining) by substituting function
691  // pointers passed as arguments to direct uses of functions.
692  PM.add(createIPSCCPPass());
693  }
694 
695  // Infer attributes about definitions. The readnone attribute in particular is
696  // required for virtual constant propagation.
699 
700  // Split globals using inrange annotations on GEP indices. This can help
701  // improve the quality of generated code when virtual constant propagation or
702  // control flow integrity are enabled.
704 
705  // Apply whole-program devirtualization and virtual constant propagation.
707 
708  // That's all we need at opt level 1.
709  if (OptLevel == 1)
710  return;
711 
712  // Now that we internalized some globals, see if we can hack on them!
714  // Promote any localized global vars.
716 
717  // Linking modules together can lead to duplicated global constants, only
718  // keep one copy of each constant.
720 
721  // Remove unused arguments from functions.
723 
724  // Reduce the code after globalopt and ipsccp. Both can open up significant
725  // simplification opportunities, and both can propagate functions through
726  // function pointers. When this happens, we often have to resolve varargs
727  // calls, etc, so let instcombine do this.
728  addInstructionCombiningPass(PM);
729  addExtensionsToPM(EP_Peephole, PM);
730 
731  // Inline small functions
732  bool RunInliner = Inliner;
733  if (RunInliner) {
734  PM.add(Inliner);
735  Inliner = nullptr;
736  }
737 
738  PM.add(createPruneEHPass()); // Remove dead EH info.
739 
740  // Optimize globals again if we ran the inliner.
741  if (RunInliner)
743  PM.add(createGlobalDCEPass()); // Remove dead functions.
744 
745  // If we didn't decide to inline a function, check to see if we can
746  // transform it to pass arguments by value instead of by reference.
748 
749  // The IPO passes may leave cruft around. Clean up after them.
750  addInstructionCombiningPass(PM);
751  addExtensionsToPM(EP_Peephole, PM);
753 
754  // Break up allocas
755  PM.add(createSROAPass());
756 
757  // Run a few AA driven optimizations here and now, to cleanup the code.
758  PM.add(createPostOrderFunctionAttrsLegacyPass()); // Add nocapture.
759  PM.add(createGlobalsAAWrapperPass()); // IP alias analysis.
760 
761  PM.add(createLICMPass()); // Hoist loop invariants.
762  if (EnableMLSM)
763  PM.add(createMergedLoadStoreMotionPass()); // Merge ld/st in diamonds.
765  : createGVNPass(DisableGVNLoadPRE)); // Remove redundancies.
766  PM.add(createMemCpyOptPass()); // Remove dead memcpys.
767 
768  // Nuke dead stores.
770 
771  // More loops are countable; try to optimize them.
776 
777  if (!DisableUnrollLoops)
778  PM.add(createSimpleLoopUnrollPass()); // Unroll small loops
780  // The vectorizer may have significantly shortened a loop body; unroll again.
781  if (!DisableUnrollLoops)
783 
784  // Now that we've optimized loops (in particular loop induction variables),
785  // we may have exposed more scalar opportunities. Run parts of the scalar
786  // optimizer again at this point.
787  addInstructionCombiningPass(PM); // Initial cleanup
788  PM.add(createCFGSimplificationPass()); // if-convert
789  PM.add(createSCCPPass()); // Propagate exposed constants
790  addInstructionCombiningPass(PM); // Clean up again
792 
793  // More scalar chains could be vectorized due to more alias information
795  if (SLPVectorize)
796  PM.add(createSLPVectorizerPass()); // Vectorize parallel scalar chains.
797 
798  // After vectorization, assume intrinsics may tell us more about pointer
799  // alignments.
801 
802  if (LoadCombine)
804 
805  // Cleanup and simplify the code after the scalar optimizations.
806  addInstructionCombiningPass(PM);
807  addExtensionsToPM(EP_Peephole, PM);
808 
810 }
811 
812 void PassManagerBuilder::addLateLTOOptimizationPasses(
814  // Delete basic blocks, which optimization passes may have killed.
816 
817  // Drop bodies of available externally objects to improve GlobalDCE.
819 
820  // Now that we have optimized the program, discard unreachable functions.
821  PM.add(createGlobalDCEPass());
822 
823  // FIXME: this is profitable (for compiler time) to do at -O0 too, but
824  // currently it damages debug info.
825  if (MergeFunctions)
827 }
828 
831  PerformThinLTO = true;
832 
833  if (VerifyInput)
834  PM.add(createVerifierPass());
835 
837 
838  if (VerifyOutput)
839  PM.add(createVerifierPass());
840  PerformThinLTO = false;
841 }
842 
844  if (LibraryInfo)
846 
847  if (VerifyInput)
848  PM.add(createVerifierPass());
849 
850  if (OptLevel != 0)
851  addLTOOptimizationPasses(PM);
852 
853  // Create a function that performs CFI checks for cross-DSO calls with targets
854  // in the current module.
856 
857  // Lower type metadata and the type.test intrinsic. This pass supports Clang's
858  // control flow integrity mechanisms (-fsanitize=cfi*) and needs to run at
859  // link time if CFI is enabled. The pass does nothing if CFI is disabled.
861  /*Summary=*/nullptr));
862 
863  if (OptLevel != 0)
864  addLateLTOOptimizationPasses(PM);
865 
866  if (VerifyOutput)
867  PM.add(createVerifierPass());
868 }
869 
871  return reinterpret_cast<PassManagerBuilder*>(P);
872 }
873 
875  return reinterpret_cast<LLVMPassManagerBuilderRef>(P);
876 }
877 
880  return wrap(PMB);
881 }
882 
884  PassManagerBuilder *Builder = unwrap(PMB);
885  delete Builder;
886 }
887 
888 void
890  unsigned OptLevel) {
891  PassManagerBuilder *Builder = unwrap(PMB);
892  Builder->OptLevel = OptLevel;
893 }
894 
895 void
897  unsigned SizeLevel) {
898  PassManagerBuilder *Builder = unwrap(PMB);
899  Builder->SizeLevel = SizeLevel;
900 }
901 
902 void
904  LLVMBool Value) {
905  PassManagerBuilder *Builder = unwrap(PMB);
906  Builder->DisableUnitAtATime = Value;
907 }
908 
909 void
911  LLVMBool Value) {
912  PassManagerBuilder *Builder = unwrap(PMB);
913  Builder->DisableUnrollLoops = Value;
914 }
915 
916 void
918  LLVMBool Value) {
919  // NOTE: The simplify-libcalls pass has been removed.
920 }
921 
922 void
924  unsigned Threshold) {
925  PassManagerBuilder *Builder = unwrap(PMB);
926  Builder->Inliner = createFunctionInliningPass(Threshold);
927 }
928 
929 void
931  LLVMPassManagerRef PM) {
932  PassManagerBuilder *Builder = unwrap(PMB);
933  legacy::FunctionPassManager *FPM = unwrap<legacy::FunctionPassManager>(PM);
934  Builder->populateFunctionPassManager(*FPM);
935 }
936 
937 void
939  LLVMPassManagerRef PM) {
940  PassManagerBuilder *Builder = unwrap(PMB);
941  legacy::PassManagerBase *MPM = unwrap(PM);
942  Builder->populateModulePassManager(*MPM);
943 }
944 
947  LLVMBool Internalize,
948  LLVMBool RunInliner) {
949  PassManagerBuilder *Builder = unwrap(PMB);
950  legacy::PassManagerBase *LPM = unwrap(PM);
951 
952  // A small backwards compatibility hack. populateLTOPassManager used to take
953  // an RunInliner option.
954  if (RunInliner && !Builder->Inliner)
955  Builder->Inliner = createFunctionInliningPass();
956 
957  Builder->populateLTOPassManager(*LPM);
958 }
Super simple passes to force specific function attrs from the commandline into the IR for debugging p...
static cl::opt< bool > RunLoadCombine("combine-loads", cl::init(false), cl::Hidden, cl::desc("Run the load combining pass"))
ModulePass * createNameAnonGlobalPass()
===------------------------------------------------------------------—===//
FunctionPass * createGVNPass(bool NoLoads=false)
Create a legacy GVN pass.
Definition: GVN.cpp:2797
Pass * createLoopRerollPass()
Thresholds to tune inline cost analysis.
Definition: InlineCost.h:122
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...
bool EnablePGOInstrGen
Enable profile instrumentation pass.
static cl::opt< bool > RunBBVectorization("vectorize-slp-aggressive", cl::Hidden, cl::desc("Run the BB vectorization passes"))
This is the interface for LLVM's inclusion-based alias analysis implemented with CFL graph reachabili...
size_t i
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"))
This is the interface for a simple mod/ref and alias analysis over globals.
ModulePass * createMergeFunctionsPass()
createMergeFunctionsPass - This pass discovers identical functions and collapses them.
void populateThinLTOPassManager(legacy::PassManagerBase &PM)
void LLVMPassManagerBuilderSetDisableSimplifyLibCalls(LLVMPassManagerBuilderRef PMB, LLVMBool Value)
See llvm::PassManagerBuilder::DisableSimplifyLibCalls.
This is the interface for a metadata-based scoped no-alias analysis.
EP_ScalarOptimizerLate - This extension point allows adding optimization passes after most of the mai...
FunctionPass * createVerifierPass(bool FatalErrors=true)
Definition: Verifier.cpp:4791
ModulePass * createIPSCCPPass()
createIPSCCPPass - This pass propagates constants from call sites into the bodies of functions...
Definition: SCCP.cpp:1955
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:1001
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.
std::string PGOSampleUse
Path of the sample Profile data file.
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"))
Attribute unwrap(LLVMAttributeRef Attr)
Definition: Attributes.h:191
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:127
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 * createArgumentPromotionPass(unsigned maxElements=3)
createArgumentPromotionPass - This pass promotes "by reference" arguments to be passed by value if th...
static cl::opt< bool > EnablePrepareForThinLTO("prepare-for-thinlto", cl::init(false), cl::Hidden, cl::desc("Enable preparation for ThinLTO."))
EP_ModuleOptimizerEarly - This extension point allows adding passes just before the main module-level...
FunctionPass * createSCCPPass()
Definition: SCCP.cpp:1646
EP_EnabledOnOptLevel0 - This extension point allows adding passes that should not be disabled by O0 o...
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.
Pass * createLoopUnswitchPass(bool OptimizeForSize=false)
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"))
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.
ModulePass * createWholeProgramDevirtPass()
This pass implements whole-program devirtualization using type metadata.
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:372
ModulePass * createSampleProfileLoaderPass()
FunctionPass * createInstructionCombiningPass(bool ExpensiveCombines=true)
ModulePass * createGlobalDCEPass()
createGlobalDCEPass - This transform is designed to eliminate unreachable internal globals (functions...
std::string PGOInstrUse
Path of the profile data file.
ValuesClass values(OptsTy...Options)
Helper to build a ValuesClass by forwarding a variable number of arguments as an initializer list to ...
Definition: CommandLine.h:615
Pass * createCorrelatedValuePropagationPass()
struct LLVMOpaquePassManagerBuilder * LLVMPassManagerBuilderRef
#define P(N)
This is the interface for LLVM's unification-based alias analysis implemented with CFL graph reachabi...
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:395
static cl::opt< bool > EnableMLSM("mlsm", cl::init(true), cl::Hidden, cl::desc("Enable motion of merged load and store"))
This is the interface for a metadata-based TBAA.
FunctionPass * createTailCallEliminationPass()
This file provides the interface for LLVM's Global Value Numbering pass which eliminates fully redund...
FunctionPass * createPromoteMemoryToRegisterPass()
Definition: Mem2Reg.cpp:105
TargetLibraryInfoImpl * LibraryInfo
LibraryInfo - Specifies information about the runtime library for the optimizer.
ModulePass * createDeadArgEliminationPass()
createDeadArgEliminationPass - This pass removes arguments from functions which are not used by the b...
void LLVMPassManagerBuilderDispose(LLVMPassManagerBuilderRef PMB)
FunctionPass * createCFGSimplificationPass(int Threshold=-1, std::function< bool(const Function &)> Ftor=nullptr)
Pass * createLICMPass()
Definition: LICM.cpp:217
FunctionPass * createDeadStoreEliminationPass()
ModulePass * createPGOInstrumentationUseLegacyPass(StringRef Filename=StringRef(""))
ModulePass * createPGOIndirectCallPromotionLegacyPass(bool InLTO=false)
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:2599
Pass * createReversePostOrderFunctionAttrsPass()
createReversePostOrderFunctionAttrsPass - This pass walks SCCs of the call graph in RPO to deduce and...
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: c/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...
EP_OptimizerLast – This extension point allows adding passes that run after everything else...
EP_EarlyAsPossible - This extension point allows adding passes before any other transformations, allowing them to see the code as it is coming out of the frontend.
static cl::opt< bool > EnableLoopInterchange("enable-loopinterchange", cl::init(false), cl::Hidden, cl::desc("Enable the new, experimental LoopInterchange Pass"))
EP_CGSCCOptimizerLate - This extension point allows adding CallGraphSCC passes at the end of the main...
EP_VectorizerStart - This extension point allows adding optimization passes before the vectorizer and...
static cl::opt< bool > EnableLoopLoadElim("enable-loop-load-elim", cl::init(true), cl::Hidden, cl::desc("Enable the LoopLoadElimination Pass"))
BasicBlockPass * createLoadCombinePass()
Pass * createLoopInterchangePass()
PassManagerBase - An abstract interface to allow code to add passes to a pass manager without having ...
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:843
FunctionPass * createLoopLoadEliminationPass()
Pass * createLoopUnrollPass(int Threshold=-1, int Count=-1, int AllowPartial=-1, int Runtime=-1, int UpperBound=-1)
FunctionPass * createSpeculativeExecutionIfHasBranchDivergencePass()
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)"))
FunctionPass * createMergedLoadStoreMotionPass()
createMergedLoadStoreMotionPass - The public interface to this file.
FunctionPass * createLibCallsShrinkWrapPass()
struct LLVMOpaquePassManager * LLVMPassManagerRef
Definition: c/Types.h:100
Pass * createLoopDeletionPass()
Options for the frontend instrumentation based profiling pass.
BasicBlockPass * createBBVectorizePass(const VectorizeConfig &C=VectorizeConfig())
EP_Peephole - This extension point allows adding passes that perform peephole optimizations similar t...
Pass * createLoopIdiomPass()
#define clEnumValN(ENUMVAL, FLAGNAME, DESC)
Definition: CommandLine.h:590
Interfaces for passes which infer implicit function attributes from the name and signature of functio...
LLVMPassManagerBuilderRef LLVMPassManagerBuilderCreate()
See llvm::PassManagerBuilder.
std::string PGOInstrGen
Profile data file name that the instrumentation will be written to.
ModulePass * createLowerTypeTestsPass(LowerTypeTestsSummaryAction Action, ModuleSummaryIndex *Index)
This pass lowers type metadata and the llvm.type.test intrinsic to bitsets.
void LLVMPassManagerBuilderPopulateModulePassManager(LLVMPassManagerBuilderRef PMB, LLVMPassManagerRef PM)
See llvm::PassManagerBuilder::populateModulePassManager.
LLVMAttributeRef wrap(Attribute Attr)
Definition: Attributes.h:186
unsigned SizeLevel
SizeLevel - How much we're optimizing for size.
static cl::opt< bool > DisableLibCallsShrinkWrap("disable-libcalls-shrinkwrap", cl::init(false), cl::Hidden, cl::desc("Disable shrink-wrap library calls"))
ModulePass * createGlobalsAAWrapperPass()
FunctionPass * createSROAPass()
Definition: SROA.cpp:4283
Pass * createInferFunctionAttrsLegacyPass()
Create a legacy pass manager instance of a pass to infer function attributes.
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."))
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.
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")))
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:71
Pass * createSimpleLoopUnrollPass()
FunctionPass * createEarlyCSEPass(bool UseMemorySSA=false)
Definition: EarlyCSE.cpp:1050
This is the interface for LLVM's primary stateless and local alias analysis.
ManagedStatic - This transparently changes the behavior of global statics to be lazily constructed on...
Definition: ManagedStatic.h:63
void LLVMPassManagerBuilderPopulateFunctionPassManager(LLVMPassManagerBuilderRef PMB, LLVMPassManagerRef PM)
See llvm::PassManagerBuilder::populateFunctionPassManager.
ImmutablePass * createCFLAndersAAWrapperPass()
void addExtension(ExtensionPointTy Ty, ExtensionFn Fn)
FunctionPass * createInstructionSimplifierPass()
static cl::opt< bool > EnableGVNHoist("enable-gvn-hoist", cl::init(false), cl::Hidden, cl::desc("Enable the GVN hoisting pass"))
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:683
int DefaultThreshold
The default threshold to start with for a callee.
Definition: InlineCost.h:124
FunctionPass * createLoopDistributePass()
FunctionPass * createLowerExpectIntrinsicPass()
EP_LoopOptimizerEnd - This extension point allows adding loop passes to the end of the loop optimizer...
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.