contrib/llvm-project/llvm/include/llvm/Passes/PassBuilder.h

   1 //===- Parsing, selection, and construction of pass pipelines --*- C++ -*--===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 /// \file
   9 ///
  10 /// Interfaces for registering analysis passes, producing common pass manager
  11 /// configurations, and parsing of pass pipelines.
  12 ///
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_PASSES_PASSBUILDER_H
  16 #define LLVM_PASSES_PASSBUILDER_H
  17
  18 #include "llvm/ADT/Optional.h"
  19 #include "llvm/Analysis/CGSCCPassManager.h"
  20 #include "llvm/IR/PassManager.h"
  21 #include "llvm/Support/Error.h"
  22 #include "llvm/Transforms/Instrumentation.h"
  23 #include "llvm/Transforms/Scalar/LoopPassManager.h"
  24 #include <vector>
  25
  26 namespace llvm {
  27 class StringRef;
  28 class AAManager;
  29 class TargetMachine;
  30 class ModuleSummaryIndex;
  31
  32 /// A struct capturing PGO tunables.
  33 struct PGOOptions {
  34   enum PGOAction { NoAction, IRInstr, IRUse, SampleUse };
  35   enum CSPGOAction { NoCSAction, CSIRInstr, CSIRUse };
  36   PGOOptions(std::string ProfileFile = "", std::string CSProfileGenFile = "",
  37              std::string ProfileRemappingFile = "", PGOAction Action = NoAction,
  38              CSPGOAction CSAction = NoCSAction, bool SamplePGOSupport = false)
  39       : ProfileFile(ProfileFile), CSProfileGenFile(CSProfileGenFile),
  40         ProfileRemappingFile(ProfileRemappingFile), Action(Action),
  41         CSAction(CSAction),
  42         SamplePGOSupport(SamplePGOSupport || Action == SampleUse) {
  43     // Note, we do allow ProfileFile.empty() for Action=IRUse LTO can
  44     // callback with IRUse action without ProfileFile.
  45
  46     // If there is a CSAction, PGOAction cannot be IRInstr or SampleUse.
  47     assert(this->CSAction == NoCSAction ||
  48            (this->Action != IRInstr && this->Action != SampleUse));
  49
  50     // For CSIRInstr, CSProfileGenFile also needs to be nonempty.
  51     assert(this->CSAction != CSIRInstr || !this->CSProfileGenFile.empty());
  52
  53     // If CSAction is CSIRUse, PGOAction needs to be IRUse as they share
  54     // a profile.
  55     assert(this->CSAction != CSIRUse || this->Action == IRUse);
  56
  57     // If neither Action nor CSAction, SamplePGOSupport needs to be true.
  58     assert(this->Action != NoAction || this->CSAction != NoCSAction ||
  59            this->SamplePGOSupport);
  60   }
  61   std::string ProfileFile;
  62   std::string CSProfileGenFile;
  63   std::string ProfileRemappingFile;
  64   PGOAction Action;
  65   CSPGOAction CSAction;
  66   bool SamplePGOSupport;
  67 };
  68
  69 /// Tunable parameters for passes in the default pipelines.
  70 class PipelineTuningOptions {
  71 public:
  72   /// Constructor sets pipeline tuning defaults based on cl::opts. Each option
  73   /// can be set in the PassBuilder when using a LLVM as a library.
  74   PipelineTuningOptions();
  75
  76   /// Tuning option to set loop interleaving on/off. Its default value is that
  77   /// of the flag: `-interleave-loops`.
  78   bool LoopInterleaving;
  79
  80   /// Tuning option to enable/disable loop vectorization. Its default value is
  81   /// that of the flag: `-vectorize-loops`.
  82   bool LoopVectorization;
  83
  84   /// Tuning option to enable/disable slp loop vectorization. Its default value
  85   /// is that of the flag: `vectorize-slp`.
  86   bool SLPVectorization;
  87
  88   /// Tuning option to enable/disable loop unrolling. Its default value is true.
  89   bool LoopUnrolling;
  90
  91   /// Tuning option to forget all SCEV loops in LoopUnroll. Its default value
  92   /// is that of the flag: `-forget-scev-loop-unroll`.
  93   bool ForgetAllSCEVInLoopUnroll;
  94
  95   /// Tuning option to cap the number of calls to retrive clobbering accesses in
  96   /// MemorySSA, in LICM.
  97   unsigned LicmMssaOptCap;
  98
  99   /// Tuning option to disable promotion to scalars in LICM with MemorySSA, if
 100   /// the number of access is too large.
 101   unsigned LicmMssaNoAccForPromotionCap;
 102 };
 103
 104 /// This class provides access to building LLVM's passes.
 105 ///
 106 /// Its members provide the baseline state available to passes during their
 107 /// construction. The \c PassRegistry.def file specifies how to construct all
 108 /// of the built-in passes, and those may reference these members during
 109 /// construction.
 110 class PassBuilder {
 111   TargetMachine *TM;
 112   PipelineTuningOptions PTO;
 113   Optional<PGOOptions> PGOOpt;
 114   PassInstrumentationCallbacks *PIC;
 115
 116 public:
 117   /// A struct to capture parsed pass pipeline names.
 118   ///
 119   /// A pipeline is defined as a series of names, each of which may in itself
 120   /// recursively contain a nested pipeline. A name is either the name of a pass
 121   /// (e.g. "instcombine") or the name of a pipeline type (e.g. "cgscc"). If the
 122   /// name is the name of a pass, the InnerPipeline is empty, since passes
 123   /// cannot contain inner pipelines. See parsePassPipeline() for a more
 124   /// detailed description of the textual pipeline format.
 125   struct PipelineElement {
 126     StringRef Name;
 127     std::vector<PipelineElement> InnerPipeline;
 128   };
 129
 130   /// ThinLTO phase.
 131   ///
 132   /// This enumerates the LLVM ThinLTO optimization phases.
 133   enum class ThinLTOPhase {
 134     /// No ThinLTO behavior needed.
 135     None,
 136     /// ThinLTO prelink (summary) phase.
 137     PreLink,
 138     /// ThinLTO postlink (backend compile) phase.
 139     PostLink
 140   };
 141
 142   /// LLVM-provided high-level optimization levels.
 143   ///
 144   /// This enumerates the LLVM-provided high-level optimization levels. Each
 145   /// level has a specific goal and rationale.
 146   enum OptimizationLevel {
 147     /// Disable as many optimizations as possible. This doesn't completely
 148     /// disable the optimizer in all cases, for example always_inline functions
 149     /// can be required to be inlined for correctness.
 150     O0,
 151
 152     /// Optimize quickly without destroying debuggability.
 153     ///
 154     /// This level is tuned to produce a result from the optimizer as quickly
 155     /// as possible and to avoid destroying debuggability. This tends to result
 156     /// in a very good development mode where the compiled code will be
 157     /// immediately executed as part of testing. As a consequence, where
 158     /// possible, we would like to produce efficient-to-execute code, but not
 159     /// if it significantly slows down compilation or would prevent even basic
 160     /// debugging of the resulting binary.
 161     ///
 162     /// As an example, complex loop transformations such as versioning,
 163     /// vectorization, or fusion don't make sense here due to the degree to
 164     /// which the executed code differs from the source code, and the compile time
 165     /// cost.
 166     O1,
 167
 168     /// Optimize for fast execution as much as possible without triggering
 169     /// significant incremental compile time or code size growth.
 170     ///
 171     /// The key idea is that optimizations at this level should "pay for
 172     /// themselves". So if an optimization increases compile time by 5% or
 173     /// increases code size by 5% for a particular benchmark, that benchmark
 174     /// should also be one which sees a 5% runtime improvement. If the compile
 175     /// time or code size penalties happen on average across a diverse range of
 176     /// LLVM users' benchmarks, then the improvements should as well.
 177     ///
 178     /// And no matter what, the compile time needs to not grow superlinearly
 179     /// with the size of input to LLVM so that users can control the runtime of
 180     /// the optimizer in this mode.
 181     ///
 182     /// This is expected to be a good default optimization level for the vast
 183     /// majority of users.
 184     O2,
 185
 186     /// Optimize for fast execution as much as possible.
 187     ///
 188     /// This mode is significantly more aggressive in trading off compile time
 189     /// and code size to get execution time improvements. The core idea is that
 190     /// this mode should include any optimization that helps execution time on
 191     /// balance across a diverse collection of benchmarks, even if it increases
 192     /// code size or compile time for some benchmarks without corresponding
 193     /// improvements to execution time.
 194     ///
 195     /// Despite being willing to trade more compile time off to get improved
 196     /// execution time, this mode still tries to avoid superlinear growth in
 197     /// order to make even significantly slower compile times at least scale
 198     /// reasonably. This does not preclude very substantial constant factor
 199     /// costs though.
 200     O3,
 201
 202     /// Similar to \c O2 but tries to optimize for small code size instead of
 203     /// fast execution without triggering significant incremental execution
 204     /// time slowdowns.
 205     ///
 206     /// The logic here is exactly the same as \c O2, but with code size and
 207     /// execution time metrics swapped.
 208     ///
 209     /// A consequence of the different core goal is that this should in general
 210     /// produce substantially smaller executables that still run in
 211     /// a reasonable amount of time.
 212     Os,
 213
 214     /// A very specialized mode that will optimize for code size at any and all
 215     /// costs.
 216     ///
 217     /// This is useful primarily when there are absolute size limitations and
 218     /// any effort taken to reduce the size is worth it regardless of the
 219     /// execution time impact. You should expect this level to produce rather
 220     /// slow, but very small, code.
 221     Oz
 222   };
 223
 224   explicit PassBuilder(TargetMachine *TM = nullptr,
 225                        PipelineTuningOptions PTO = PipelineTuningOptions(),
 226                        Optional<PGOOptions> PGOOpt = None,
 227                        PassInstrumentationCallbacks *PIC = nullptr)
 228       : TM(TM), PTO(PTO), PGOOpt(PGOOpt), PIC(PIC) {}
 229
 230   /// Cross register the analysis managers through their proxies.
 231   ///
 232   /// This is an interface that can be used to cross register each
 233   /// AnalysisManager with all the others analysis managers.
 234   void crossRegisterProxies(LoopAnalysisManager &LAM,
 235                             FunctionAnalysisManager &FAM,
 236                             CGSCCAnalysisManager &CGAM,
 237                             ModuleAnalysisManager &MAM);
 238
 239   /// Registers all available module analysis passes.
 240   ///
 241   /// This is an interface that can be used to populate a \c
 242   /// ModuleAnalysisManager with all registered module analyses. Callers can
 243   /// still manually register any additional analyses. Callers can also
 244   /// pre-register analyses and this will not override those.
 245   void registerModuleAnalyses(ModuleAnalysisManager &MAM);
 246
 247   /// Registers all available CGSCC analysis passes.
 248   ///
 249   /// This is an interface that can be used to populate a \c CGSCCAnalysisManager
 250   /// with all registered CGSCC analyses. Callers can still manually register any
 251   /// additional analyses. Callers can also pre-register analyses and this will
 252   /// not override those.
 253   void registerCGSCCAnalyses(CGSCCAnalysisManager &CGAM);
 254
 255   /// Registers all available function analysis passes.
 256   ///
 257   /// This is an interface that can be used to populate a \c
 258   /// FunctionAnalysisManager with all registered function analyses. Callers can
 259   /// still manually register any additional analyses. Callers can also
 260   /// pre-register analyses and this will not override those.
 261   void registerFunctionAnalyses(FunctionAnalysisManager &FAM);
 262
 263   /// Registers all available loop analysis passes.
 264   ///
 265   /// This is an interface that can be used to populate a \c LoopAnalysisManager
 266   /// with all registered loop analyses. Callers can still manually register any
 267   /// additional analyses.
 268   void registerLoopAnalyses(LoopAnalysisManager &LAM);
 269
 270   /// Construct the core LLVM function canonicalization and simplification
 271   /// pipeline.
 272   ///
 273   /// This is a long pipeline and uses most of the per-function optimization
 274   /// passes in LLVM to canonicalize and simplify the IR. It is suitable to run
 275   /// repeatedly over the IR and is not expected to destroy important
 276   /// information about the semantics of the IR.
 277   ///
 278   /// Note that \p Level cannot be `O0` here. The pipelines produced are
 279   /// only intended for use when attempting to optimize code. If frontends
 280   /// require some transformations for semantic reasons, they should explicitly
 281   /// build them.
 282   ///
 283   /// \p Phase indicates the current ThinLTO phase.
 284   FunctionPassManager
 285   buildFunctionSimplificationPipeline(OptimizationLevel Level,
 286                                       ThinLTOPhase Phase,
 287                                       bool DebugLogging = false);
 288
 289   /// Construct the core LLVM module canonicalization and simplification
 290   /// pipeline.
 291   ///
 292   /// This pipeline focuses on canonicalizing and simplifying the entire module
 293   /// of IR. Much like the function simplification pipeline above, it is
 294   /// suitable to run repeatedly over the IR and is not expected to destroy
 295   /// important information. It does, however, perform inlining and other
 296   /// heuristic based simplifications that are not strictly reversible.
 297   ///
 298   /// Note that \p Level cannot be `O0` here. The pipelines produced are
 299   /// only intended for use when attempting to optimize code. If frontends
 300   /// require some transformations for semantic reasons, they should explicitly
 301   /// build them.
 302   ///
 303   /// \p Phase indicates the current ThinLTO phase.
 304   ModulePassManager
 305   buildModuleSimplificationPipeline(OptimizationLevel Level,
 306                                     ThinLTOPhase Phase,
 307                                     bool DebugLogging = false);
 308
 309   /// Construct the core LLVM module optimization pipeline.
 310   ///
 311   /// This pipeline focuses on optimizing the execution speed of the IR. It
 312   /// uses cost modeling and thresholds to balance code growth against runtime
 313   /// improvements. It includes vectorization and other information destroying
 314   /// transformations. It also cannot generally be run repeatedly on a module
 315   /// without potentially seriously regressing either runtime performance of
 316   /// the code or serious code size growth.
 317   ///
 318   /// Note that \p Level cannot be `O0` here. The pipelines produced are
 319   /// only intended for use when attempting to optimize code. If frontends
 320   /// require some transformations for semantic reasons, they should explicitly
 321   /// build them.
 322   ModulePassManager buildModuleOptimizationPipeline(OptimizationLevel Level,
 323                                                     bool DebugLogging = false,
 324                                                     bool LTOPreLink = false);
 325
 326   /// Build a per-module default optimization pipeline.
 327   ///
 328   /// This provides a good default optimization pipeline for per-module
 329   /// optimization and code generation without any link-time optimization. It
 330   /// typically correspond to frontend "-O[123]" options for optimization
 331   /// levels \c O1, \c O2 and \c O3 resp.
 332   ///
 333   /// Note that \p Level cannot be `O0` here. The pipelines produced are
 334   /// only intended for use when attempting to optimize code. If frontends
 335   /// require some transformations for semantic reasons, they should explicitly
 336   /// build them.
 337   ModulePassManager buildPerModuleDefaultPipeline(OptimizationLevel Level,
 338                                                   bool DebugLogging = false,
 339                                                   bool LTOPreLink = false);
 340
 341   /// Build a pre-link, ThinLTO-targeting default optimization pipeline to
 342   /// a pass manager.
 343   ///
 344   /// This adds the pre-link optimizations tuned to prepare a module for
 345   /// a ThinLTO run. It works to minimize the IR which needs to be analyzed
 346   /// without making irreversible decisions which could be made better during
 347   /// the LTO run.
 348   ///
 349   /// Note that \p Level cannot be `O0` here. The pipelines produced are
 350   /// only intended for use when attempting to optimize code. If frontends
 351   /// require some transformations for semantic reasons, they should explicitly
 352   /// build them.
 353   ModulePassManager
 354   buildThinLTOPreLinkDefaultPipeline(OptimizationLevel Level,
 355                                      bool DebugLogging = false);
 356
 357   /// Build an ThinLTO default optimization pipeline to a pass manager.
 358   ///
 359   /// This provides a good default optimization pipeline for link-time
 360   /// optimization and code generation. It is particularly tuned to fit well
 361   /// when IR coming into the LTO phase was first run through \c
 362   /// addPreLinkLTODefaultPipeline, and the two coordinate closely.
 363   ///
 364   /// Note that \p Level cannot be `O0` here. The pipelines produced are
 365   /// only intended for use when attempting to optimize code. If frontends
 366   /// require some transformations for semantic reasons, they should explicitly
 367   /// build them.
 368   ModulePassManager
 369   buildThinLTODefaultPipeline(OptimizationLevel Level, bool DebugLogging,
 370                               const ModuleSummaryIndex *ImportSummary);
 371
 372   /// Build a pre-link, LTO-targeting default optimization pipeline to a pass
 373   /// manager.
 374   ///
 375   /// This adds the pre-link optimizations tuned to work well with a later LTO
 376   /// run. It works to minimize the IR which needs to be analyzed without
 377   /// making irreversible decisions which could be made better during the LTO
 378   /// run.
 379   ///
 380   /// Note that \p Level cannot be `O0` here. The pipelines produced are
 381   /// only intended for use when attempting to optimize code. If frontends
 382   /// require some transformations for semantic reasons, they should explicitly
 383   /// build them.
 384   ModulePassManager buildLTOPreLinkDefaultPipeline(OptimizationLevel Level,
 385                                                    bool DebugLogging = false);
 386
 387   /// Build an LTO default optimization pipeline to a pass manager.
 388   ///
 389   /// This provides a good default optimization pipeline for link-time
 390   /// optimization and code generation. It is particularly tuned to fit well
 391   /// when IR coming into the LTO phase was first run through \c
 392   /// addPreLinkLTODefaultPipeline, and the two coordinate closely.
 393   ///
 394   /// Note that \p Level cannot be `O0` here. The pipelines produced are
 395   /// only intended for use when attempting to optimize code. If frontends
 396   /// require some transformations for semantic reasons, they should explicitly
 397   /// build them.
 398   ModulePassManager buildLTODefaultPipeline(OptimizationLevel Level,
 399                                             bool DebugLogging,
 400                                             ModuleSummaryIndex *ExportSummary);
 401
 402   /// Build the default `AAManager` with the default alias analysis pipeline
 403   /// registered.
 404   AAManager buildDefaultAAPipeline();
 405
 406   /// Parse a textual pass pipeline description into a \c
 407   /// ModulePassManager.
 408   ///
 409   /// The format of the textual pass pipeline description looks something like:
 410   ///
 411   ///   module(function(instcombine,sroa),dce,cgscc(inliner,function(...)),...)
 412   ///
 413   /// Pass managers have ()s describing the nest structure of passes. All passes
 414   /// are comma separated. As a special shortcut, if the very first pass is not
 415   /// a module pass (as a module pass manager is), this will automatically form
 416   /// the shortest stack of pass managers that allow inserting that first pass.
 417   /// So, assuming function passes 'fpassN', CGSCC passes 'cgpassN', and loop
 418   /// passes 'lpassN', all of these are valid:
 419   ///
 420   ///   fpass1,fpass2,fpass3
 421   ///   cgpass1,cgpass2,cgpass3
 422   ///   lpass1,lpass2,lpass3
 423   ///
 424   /// And they are equivalent to the following (resp.):
 425   ///
 426   ///   module(function(fpass1,fpass2,fpass3))
 427   ///   module(cgscc(cgpass1,cgpass2,cgpass3))
 428   ///   module(function(loop(lpass1,lpass2,lpass3)))
 429   ///
 430   /// This shortcut is especially useful for debugging and testing small pass
 431   /// combinations. Note that these shortcuts don't introduce any other magic.
 432   /// If the sequence of passes aren't all the exact same kind of pass, it will
 433   /// be an error. You cannot mix different levels implicitly, you must
 434   /// explicitly form a pass manager in which to nest passes.
 435   Error parsePassPipeline(ModulePassManager &MPM, StringRef PipelineText,
 436                           bool VerifyEachPass = true,
 437                           bool DebugLogging = false);
 438
 439   /// {{@ Parse a textual pass pipeline description into a specific PassManager
 440   ///
 441   /// Automatic deduction of an appropriate pass manager stack is not supported.
 442   /// For example, to insert a loop pass 'lpass' into a FunctionPassManager,
 443   /// this is the valid pipeline text:
 444   ///
 445   ///   function(lpass)
 446   Error parsePassPipeline(CGSCCPassManager &CGPM, StringRef PipelineText,
 447                           bool VerifyEachPass = true,
 448                           bool DebugLogging = false);
 449   Error parsePassPipeline(FunctionPassManager &FPM, StringRef PipelineText,
 450                           bool VerifyEachPass = true,
 451                           bool DebugLogging = false);
 452   Error parsePassPipeline(LoopPassManager &LPM, StringRef PipelineText,
 453                           bool VerifyEachPass = true,
 454                           bool DebugLogging = false);
 455   /// @}}
 456
 457   /// Parse a textual alias analysis pipeline into the provided AA manager.
 458   ///
 459   /// The format of the textual AA pipeline is a comma separated list of AA
 460   /// pass names:
 461   ///
 462   ///   basic-aa,globals-aa,...
 463   ///
 464   /// The AA manager is set up such that the provided alias analyses are tried
 465   /// in the order specified. See the \c AAManaager documentation for details
 466   /// about the logic used. This routine just provides the textual mapping
 467   /// between AA names and the analyses to register with the manager.
 468   ///
 469   /// Returns false if the text cannot be parsed cleanly. The specific state of
 470   /// the \p AA manager is unspecified if such an error is encountered and this
 471   /// returns false.
 472   Error parseAAPipeline(AAManager &AA, StringRef PipelineText);
 473
 474   /// Register a callback for a default optimizer pipeline extension
 475   /// point
 476   ///
 477   /// This extension point allows adding passes that perform peephole
 478   /// optimizations similar to the instruction combiner. These passes will be
 479   /// inserted after each instance of the instruction combiner pass.
 480   void registerPeepholeEPCallback(
 481       const std::function<void(FunctionPassManager &, OptimizationLevel)> &C) {
 482     PeepholeEPCallbacks.push_back(C);
 483   }
 484
 485   /// Register a callback for a default optimizer pipeline extension
 486   /// point
 487   ///
 488   /// This extension point allows adding late loop canonicalization and
 489   /// simplification passes. This is the last point in the loop optimization
 490   /// pipeline before loop deletion. Each pass added
 491   /// here must be an instance of LoopPass.
 492   /// This is the place to add passes that can remove loops, such as target-
 493   /// specific loop idiom recognition.
 494   void registerLateLoopOptimizationsEPCallback(
 495       const std::function<void(LoopPassManager &, OptimizationLevel)> &C) {
 496     LateLoopOptimizationsEPCallbacks.push_back(C);
 497   }
 498
 499   /// Register a callback for a default optimizer pipeline extension
 500   /// point
 501   ///
 502   /// This extension point allows adding loop passes to the end of the loop
 503   /// optimizer.
 504   void registerLoopOptimizerEndEPCallback(
 505       const std::function<void(LoopPassManager &, OptimizationLevel)> &C) {
 506     LoopOptimizerEndEPCallbacks.push_back(C);
 507   }
 508
 509   /// Register a callback for a default optimizer pipeline extension
 510   /// point
 511   ///
 512   /// This extension point allows adding optimization passes after most of the
 513   /// main optimizations, but before the last cleanup-ish optimizations.
 514   void registerScalarOptimizerLateEPCallback(
 515       const std::function<void(FunctionPassManager &, OptimizationLevel)> &C) {
 516     ScalarOptimizerLateEPCallbacks.push_back(C);
 517   }
 518
 519   /// Register a callback for a default optimizer pipeline extension
 520   /// point
 521   ///
 522   /// This extension point allows adding CallGraphSCC passes at the end of the
 523   /// main CallGraphSCC passes and before any function simplification passes run
 524   /// by CGPassManager.
 525   void registerCGSCCOptimizerLateEPCallback(
 526       const std::function<void(CGSCCPassManager &, OptimizationLevel)> &C) {
 527     CGSCCOptimizerLateEPCallbacks.push_back(C);
 528   }
 529
 530   /// Register a callback for a default optimizer pipeline extension
 531   /// point
 532   ///
 533   /// This extension point allows adding optimization passes before the
 534   /// vectorizer and other highly target specific optimization passes are
 535   /// executed.
 536   void registerVectorizerStartEPCallback(
 537       const std::function<void(FunctionPassManager &, OptimizationLevel)> &C) {
 538     VectorizerStartEPCallbacks.push_back(C);
 539   }
 540
 541   /// Register a callback for a default optimizer pipeline extension point.
 542   ///
 543   /// This extension point allows adding optimization once at the start of the
 544   /// pipeline. This does not apply to 'backend' compiles (LTO and ThinLTO
 545   /// link-time pipelines).
 546   void registerPipelineStartEPCallback(
 547       const std::function<void(ModulePassManager &)> &C) {
 548     PipelineStartEPCallbacks.push_back(C);
 549   }
 550
 551   /// Register a callback for a default optimizer pipeline extension point
 552   ///
 553   /// This extension point allows adding optimizations at the very end of the
 554   /// function optimization pipeline. A key difference between this and the
 555   /// legacy PassManager's OptimizerLast callback is that this extension point
 556   /// is not triggered at O0. Extensions to the O0 pipeline should append their
 557   /// passes to the end of the overall pipeline.
 558   void registerOptimizerLastEPCallback(
 559       const std::function<void(FunctionPassManager &, OptimizationLevel)> &C) {
 560     OptimizerLastEPCallbacks.push_back(C);
 561   }
 562
 563   /// Register a callback for parsing an AliasAnalysis Name to populate
 564   /// the given AAManager \p AA
 565   void registerParseAACallback(
 566       const std::function<bool(StringRef Name, AAManager &AA)> &C) {
 567     AAParsingCallbacks.push_back(C);
 568   }
 569
 570   /// {{@ Register callbacks for analysis registration with this PassBuilder
 571   /// instance.
 572   /// Callees register their analyses with the given AnalysisManager objects.
 573   void registerAnalysisRegistrationCallback(
 574       const std::function<void(CGSCCAnalysisManager &)> &C) {
 575     CGSCCAnalysisRegistrationCallbacks.push_back(C);
 576   }
 577   void registerAnalysisRegistrationCallback(
 578       const std::function<void(FunctionAnalysisManager &)> &C) {
 579     FunctionAnalysisRegistrationCallbacks.push_back(C);
 580   }
 581   void registerAnalysisRegistrationCallback(
 582       const std::function<void(LoopAnalysisManager &)> &C) {
 583     LoopAnalysisRegistrationCallbacks.push_back(C);
 584   }
 585   void registerAnalysisRegistrationCallback(
 586       const std::function<void(ModuleAnalysisManager &)> &C) {
 587     ModuleAnalysisRegistrationCallbacks.push_back(C);
 588   }
 589   /// @}}
 590
 591   /// {{@ Register pipeline parsing callbacks with this pass builder instance.
 592   /// Using these callbacks, callers can parse both a single pass name, as well
 593   /// as entire sub-pipelines, and populate the PassManager instance
 594   /// accordingly.
 595   void registerPipelineParsingCallback(
 596       const std::function<bool(StringRef Name, CGSCCPassManager &,
 597                                ArrayRef<PipelineElement>)> &C) {
 598     CGSCCPipelineParsingCallbacks.push_back(C);
 599   }
 600   void registerPipelineParsingCallback(
 601       const std::function<bool(StringRef Name, FunctionPassManager &,
 602                                ArrayRef<PipelineElement>)> &C) {
 603     FunctionPipelineParsingCallbacks.push_back(C);
 604   }
 605   void registerPipelineParsingCallback(
 606       const std::function<bool(StringRef Name, LoopPassManager &,
 607                                ArrayRef<PipelineElement>)> &C) {
 608     LoopPipelineParsingCallbacks.push_back(C);
 609   }
 610   void registerPipelineParsingCallback(
 611       const std::function<bool(StringRef Name, ModulePassManager &,
 612                                ArrayRef<PipelineElement>)> &C) {
 613     ModulePipelineParsingCallbacks.push_back(C);
 614   }
 615   /// @}}
 616
 617   /// Register a callback for a top-level pipeline entry.
 618   ///
 619   /// If the PassManager type is not given at the top level of the pipeline
 620   /// text, this Callback should be used to determine the appropriate stack of
 621   /// PassManagers and populate the passed ModulePassManager.
 622   void registerParseTopLevelPipelineCallback(
 623       const std::function<bool(ModulePassManager &, ArrayRef<PipelineElement>,
 624                                bool VerifyEachPass, bool DebugLogging)> &C) {
 625     TopLevelPipelineParsingCallbacks.push_back(C);
 626   }
 627
 628   /// Add PGOInstrumenation passes for O0 only.
 629   void addPGOInstrPassesForO0(ModulePassManager &MPM, bool DebugLogging,
 630                               bool RunProfileGen, bool IsCS,
 631                               std::string ProfileFile,
 632                               std::string ProfileRemappingFile);
 633
 634
 635   /// Returns PIC. External libraries can use this to register pass
 636   /// instrumentation callbacks.
 637   PassInstrumentationCallbacks *getPassInstrumentationCallbacks() const {
 638     return PIC;
 639   }
 640
 641 private:
 642   static Optional<std::vector<PipelineElement>>
 643   parsePipelineText(StringRef Text);
 644
 645   Error parseModulePass(ModulePassManager &MPM, const PipelineElement &E,
 646                         bool VerifyEachPass, bool DebugLogging);
 647   Error parseCGSCCPass(CGSCCPassManager &CGPM, const PipelineElement &E,
 648                        bool VerifyEachPass, bool DebugLogging);
 649   Error parseFunctionPass(FunctionPassManager &FPM, const PipelineElement &E,
 650                           bool VerifyEachPass, bool DebugLogging);
 651   Error parseLoopPass(LoopPassManager &LPM, const PipelineElement &E,
 652                       bool VerifyEachPass, bool DebugLogging);
 653   bool parseAAPassName(AAManager &AA, StringRef Name);
 654
 655   Error parseLoopPassPipeline(LoopPassManager &LPM,
 656                               ArrayRef<PipelineElement> Pipeline,
 657                               bool VerifyEachPass, bool DebugLogging);
 658   Error parseFunctionPassPipeline(FunctionPassManager &FPM,
 659                                   ArrayRef<PipelineElement> Pipeline,
 660                                   bool VerifyEachPass, bool DebugLogging);
 661   Error parseCGSCCPassPipeline(CGSCCPassManager &CGPM,
 662                                ArrayRef<PipelineElement> Pipeline,
 663                                bool VerifyEachPass, bool DebugLogging);
 664   Error parseModulePassPipeline(ModulePassManager &MPM,
 665                                 ArrayRef<PipelineElement> Pipeline,
 666                                 bool VerifyEachPass, bool DebugLogging);
 667
 668   void addPGOInstrPasses(ModulePassManager &MPM, bool DebugLogging,
 669                          OptimizationLevel Level, bool RunProfileGen, bool IsCS,
 670                          std::string ProfileFile,
 671                          std::string ProfileRemappingFile);
 672   void invokePeepholeEPCallbacks(FunctionPassManager &, OptimizationLevel);
 673
 674   // Extension Point callbacks
 675   SmallVector<std::function<void(FunctionPassManager &, OptimizationLevel)>, 2>
 676       PeepholeEPCallbacks;
 677   SmallVector<std::function<void(LoopPassManager &, OptimizationLevel)>, 2>
 678       LateLoopOptimizationsEPCallbacks;
 679   SmallVector<std::function<void(LoopPassManager &, OptimizationLevel)>, 2>
 680       LoopOptimizerEndEPCallbacks;
 681   SmallVector<std::function<void(FunctionPassManager &, OptimizationLevel)>, 2>
 682       ScalarOptimizerLateEPCallbacks;
 683   SmallVector<std::function<void(CGSCCPassManager &, OptimizationLevel)>, 2>
 684       CGSCCOptimizerLateEPCallbacks;
 685   SmallVector<std::function<void(FunctionPassManager &, OptimizationLevel)>, 2>
 686       VectorizerStartEPCallbacks;
 687   SmallVector<std::function<void(FunctionPassManager &, OptimizationLevel)>, 2>
 688       OptimizerLastEPCallbacks;
 689   // Module callbacks
 690   SmallVector<std::function<void(ModulePassManager &)>, 2>
 691       PipelineStartEPCallbacks;
 692   SmallVector<std::function<void(ModuleAnalysisManager &)>, 2>
 693       ModuleAnalysisRegistrationCallbacks;
 694   SmallVector<std::function<bool(StringRef, ModulePassManager &,
 695                                  ArrayRef<PipelineElement>)>,
 696               2>
 697       ModulePipelineParsingCallbacks;
 698   SmallVector<std::function<bool(ModulePassManager &, ArrayRef<PipelineElement>,
 699                                  bool VerifyEachPass, bool DebugLogging)>,
 700               2>
 701       TopLevelPipelineParsingCallbacks;
 702   // CGSCC callbacks
 703   SmallVector<std::function<void(CGSCCAnalysisManager &)>, 2>
 704       CGSCCAnalysisRegistrationCallbacks;
 705   SmallVector<std::function<bool(StringRef, CGSCCPassManager &,
 706                                  ArrayRef<PipelineElement>)>,
 707               2>
 708       CGSCCPipelineParsingCallbacks;
 709   // Function callbacks
 710   SmallVector<std::function<void(FunctionAnalysisManager &)>, 2>
 711       FunctionAnalysisRegistrationCallbacks;
 712   SmallVector<std::function<bool(StringRef, FunctionPassManager &,
 713                                  ArrayRef<PipelineElement>)>,
 714               2>
 715       FunctionPipelineParsingCallbacks;
 716   // Loop callbacks
 717   SmallVector<std::function<void(LoopAnalysisManager &)>, 2>
 718       LoopAnalysisRegistrationCallbacks;
 719   SmallVector<std::function<bool(StringRef, LoopPassManager &,
 720                                  ArrayRef<PipelineElement>)>,
 721               2>
 722       LoopPipelineParsingCallbacks;
 723   // AA callbacks
 724   SmallVector<std::function<bool(StringRef Name, AAManager &AA)>, 2>
 725       AAParsingCallbacks;
 726 };
 727
 728 /// This utility template takes care of adding require<> and invalidate<>
 729 /// passes for an analysis to a given \c PassManager. It is intended to be used
 730 /// during parsing of a pass pipeline when parsing a single PipelineName.
 731 /// When registering a new function analysis FancyAnalysis with the pass
 732 /// pipeline name "fancy-analysis", a matching ParsePipelineCallback could look
 733 /// like this:
 734 ///
 735 /// static bool parseFunctionPipeline(StringRef Name, FunctionPassManager &FPM,
 736 ///                                   ArrayRef<PipelineElement> P) {
 737 ///   if (parseAnalysisUtilityPasses<FancyAnalysis>("fancy-analysis", Name,
 738 ///                                                 FPM))
 739 ///     return true;
 740 ///   return false;
 741 /// }
 742 template <typename AnalysisT, typename IRUnitT, typename AnalysisManagerT,
 743           typename... ExtraArgTs>
 744 bool parseAnalysisUtilityPasses(
 745     StringRef AnalysisName, StringRef PipelineName,
 746     PassManager<IRUnitT, AnalysisManagerT, ExtraArgTs...> &PM) {
 747   if (!PipelineName.endswith(">"))
 748     return false;
 749   // See if this is an invalidate<> pass name
 750   if (PipelineName.startswith("invalidate<")) {
 751     PipelineName = PipelineName.substr(11, PipelineName.size() - 12);
 752     if (PipelineName != AnalysisName)
 753       return false;
 754     PM.addPass(InvalidateAnalysisPass<AnalysisT>());
 755     return true;
 756   }
 757
 758   // See if this is a require<> pass name
 759   if (PipelineName.startswith("require<")) {
 760     PipelineName = PipelineName.substr(8, PipelineName.size() - 9);
 761     if (PipelineName != AnalysisName)
 762       return false;
 763     PM.addPass(RequireAnalysisPass<AnalysisT, IRUnitT, AnalysisManagerT,
 764                                    ExtraArgTs...>());
 765     return true;
 766   }
 767
 768   return false;
 769 }
 770 }
 771
 772 #endif