Coverage Report

Created: 2019-07-24 05:18

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