LCOV - code coverage report
Current view: top level - include/llvm/Transforms/IPO - PassManagerBuilder.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 3 3 100.0 %
Date: 2017-09-14 15:23:50 Functions: 1 1 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : // llvm/Transforms/IPO/PassManagerBuilder.h - Build Standard Pass -*- C++ -*-=//
       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             : 
      15             : #ifndef LLVM_TRANSFORMS_IPO_PASSMANAGERBUILDER_H
      16             : #define LLVM_TRANSFORMS_IPO_PASSMANAGERBUILDER_H
      17             : 
      18             : #include <functional>
      19             : #include <memory>
      20             : #include <string>
      21             : #include <vector>
      22             : 
      23             : namespace llvm {
      24             : class ModuleSummaryIndex;
      25             : class Pass;
      26             : class TargetLibraryInfoImpl;
      27             : class TargetMachine;
      28             : 
      29             : // The old pass manager infrastructure is hidden in a legacy namespace now.
      30             : namespace legacy {
      31             : class FunctionPassManager;
      32             : class PassManagerBase;
      33             : }
      34             : 
      35             : /// PassManagerBuilder - This class is used to set up a standard optimization
      36             : /// sequence for languages like C and C++, allowing some APIs to customize the
      37             : /// pass sequence in various ways. A simple example of using it would be:
      38             : ///
      39             : ///  PassManagerBuilder Builder;
      40             : ///  Builder.OptLevel = 2;
      41             : ///  Builder.populateFunctionPassManager(FPM);
      42             : ///  Builder.populateModulePassManager(MPM);
      43             : ///
      44             : /// In addition to setting up the basic passes, PassManagerBuilder allows
      45             : /// frontends to vend a plugin API, where plugins are allowed to add extensions
      46             : /// to the default pass manager.  They do this by specifying where in the pass
      47             : /// pipeline they want to be added, along with a callback function that adds
      48             : /// the pass(es).  For example, a plugin that wanted to add a loop optimization
      49             : /// could do something like this:
      50             : ///
      51             : /// static void addMyLoopPass(const PMBuilder &Builder, PassManagerBase &PM) {
      52             : ///   if (Builder.getOptLevel() > 2 && Builder.getOptSizeLevel() == 0)
      53             : ///     PM.add(createMyAwesomePass());
      54             : /// }
      55             : ///   ...
      56             : ///   Builder.addExtension(PassManagerBuilder::EP_LoopOptimizerEnd,
      57             : ///                        addMyLoopPass);
      58             : ///   ...
      59             : class PassManagerBuilder {
      60             : public:
      61             :   /// Extensions are passed the builder itself (so they can see how it is
      62             :   /// configured) as well as the pass manager to add stuff to.
      63             :   typedef std::function<void(const PassManagerBuilder &Builder,
      64             :                              legacy::PassManagerBase &PM)>
      65             :       ExtensionFn;
      66             :   enum ExtensionPointTy {
      67             :     /// EP_EarlyAsPossible - This extension point allows adding passes before
      68             :     /// any other transformations, allowing them to see the code as it is coming
      69             :     /// out of the frontend.
      70             :     EP_EarlyAsPossible,
      71             : 
      72             :     /// EP_ModuleOptimizerEarly - This extension point allows adding passes
      73             :     /// just before the main module-level optimization passes.
      74             :     EP_ModuleOptimizerEarly,
      75             : 
      76             :     /// EP_LoopOptimizerEnd - This extension point allows adding loop passes to
      77             :     /// the end of the loop optimizer.
      78             :     EP_LoopOptimizerEnd,
      79             : 
      80             :     /// EP_ScalarOptimizerLate - This extension point allows adding optimization
      81             :     /// passes after most of the main optimizations, but before the last
      82             :     /// cleanup-ish optimizations.
      83             :     EP_ScalarOptimizerLate,
      84             : 
      85             :     /// EP_OptimizerLast -- This extension point allows adding passes that
      86             :     /// run after everything else.
      87             :     EP_OptimizerLast,
      88             : 
      89             :     /// EP_VectorizerStart - This extension point allows adding optimization
      90             :     /// passes before the vectorizer and other highly target specific
      91             :     /// optimization passes are executed.
      92             :     EP_VectorizerStart,
      93             : 
      94             :     /// EP_EnabledOnOptLevel0 - This extension point allows adding passes that
      95             :     /// should not be disabled by O0 optimization level. The passes will be
      96             :     /// inserted after the inlining pass.
      97             :     EP_EnabledOnOptLevel0,
      98             : 
      99             :     /// EP_Peephole - This extension point allows adding passes that perform
     100             :     /// peephole optimizations similar to the instruction combiner. These passes
     101             :     /// will be inserted after each instance of the instruction combiner pass.
     102             :     EP_Peephole,
     103             : 
     104             :     /// EP_LateLoopOptimizations - This extension point allows adding late loop
     105             :     /// canonicalization and simplification passes. This is the last point in
     106             :     /// the loop optimization pipeline before loop deletion. Each pass added
     107             :     /// here must be an instance of LoopPass.
     108             :     /// This is the place to add passes that can remove loops, such as target-
     109             :     /// specific loop idiom recognition.
     110             :     EP_LateLoopOptimizations,
     111             : 
     112             :     /// EP_CGSCCOptimizerLate - This extension point allows adding CallGraphSCC
     113             :     /// passes at the end of the main CallGraphSCC passes and before any
     114             :     /// function simplification passes run by CGPassManager.
     115             :     EP_CGSCCOptimizerLate,
     116             :   };
     117             : 
     118             :   /// The Optimization Level - Specify the basic optimization level.
     119             :   ///    0 = -O0, 1 = -O1, 2 = -O2, 3 = -O3
     120             :   unsigned OptLevel;
     121             : 
     122             :   /// SizeLevel - How much we're optimizing for size.
     123             :   ///    0 = none, 1 = -Os, 2 = -Oz
     124             :   unsigned SizeLevel;
     125             : 
     126             :   /// LibraryInfo - Specifies information about the runtime library for the
     127             :   /// optimizer.  If this is non-null, it is added to both the function and
     128             :   /// per-module pass pipeline.
     129             :   TargetLibraryInfoImpl *LibraryInfo;
     130             : 
     131             :   /// Inliner - Specifies the inliner to use.  If this is non-null, it is
     132             :   /// added to the per-module passes.
     133             :   Pass *Inliner;
     134             : 
     135             :   /// The module summary index to use for exporting information from the
     136             :   /// regular LTO phase, for example for the CFI and devirtualization type
     137             :   /// tests.
     138             :   ModuleSummaryIndex *ExportSummary = nullptr;
     139             : 
     140             :   /// The module summary index to use for importing information to the
     141             :   /// thin LTO backends, for example for the CFI and devirtualization type
     142             :   /// tests.
     143             :   const ModuleSummaryIndex *ImportSummary = nullptr;
     144             : 
     145             :   bool DisableTailCalls;
     146             :   bool DisableUnitAtATime;
     147             :   bool DisableUnrollLoops;
     148             :   bool SLPVectorize;
     149             :   bool LoopVectorize;
     150             :   bool RerollLoops;
     151             :   bool NewGVN;
     152             :   bool DisableGVNLoadPRE;
     153             :   bool VerifyInput;
     154             :   bool VerifyOutput;
     155             :   bool MergeFunctions;
     156             :   bool PrepareForLTO;
     157             :   bool PrepareForThinLTO;
     158             :   bool PerformThinLTO;
     159             :   bool DivergentTarget;
     160             : 
     161             :   /// Enable profile instrumentation pass.
     162             :   bool EnablePGOInstrGen;
     163             :   /// Profile data file name that the instrumentation will be written to.
     164             :   std::string PGOInstrGen;
     165             :   /// Path of the profile data file.
     166             :   std::string PGOInstrUse;
     167             :   /// Path of the sample Profile data file.
     168             :   std::string PGOSampleUse;
     169             : 
     170             : private:
     171             :   /// ExtensionList - This is list of all of the extensions that are registered.
     172             :   std::vector<std::pair<ExtensionPointTy, ExtensionFn>> Extensions;
     173             : 
     174             : public:
     175             :   PassManagerBuilder();
     176             :   ~PassManagerBuilder();
     177             :   /// Adds an extension that will be used by all PassManagerBuilder instances.
     178             :   /// This is intended to be used by plugins, to register a set of
     179             :   /// optimisations to run automatically.
     180             :   static void addGlobalExtension(ExtensionPointTy Ty, ExtensionFn Fn);
     181             :   void addExtension(ExtensionPointTy Ty, ExtensionFn Fn);
     182             : 
     183             : private:
     184             :   void addExtensionsToPM(ExtensionPointTy ETy,
     185             :                          legacy::PassManagerBase &PM) const;
     186             :   void addInitialAliasAnalysisPasses(legacy::PassManagerBase &PM) const;
     187             :   void addLTOOptimizationPasses(legacy::PassManagerBase &PM);
     188             :   void addLateLTOOptimizationPasses(legacy::PassManagerBase &PM);
     189             :   void addPGOInstrPasses(legacy::PassManagerBase &MPM);
     190             :   void addFunctionSimplificationPasses(legacy::PassManagerBase &MPM);
     191             :   void addInstructionCombiningPass(legacy::PassManagerBase &MPM) const;
     192             : 
     193             : public:
     194             :   /// populateFunctionPassManager - This fills in the function pass manager,
     195             :   /// which is expected to be run on each function immediately as it is
     196             :   /// generated.  The idea is to reduce the size of the IR in memory.
     197             :   void populateFunctionPassManager(legacy::FunctionPassManager &FPM);
     198             : 
     199             :   /// populateModulePassManager - This sets up the primary pass manager.
     200             :   void populateModulePassManager(legacy::PassManagerBase &MPM);
     201             :   void populateLTOPassManager(legacy::PassManagerBase &PM);
     202             :   void populateThinLTOPassManager(legacy::PassManagerBase &PM);
     203             : };
     204             : 
     205             : /// Registers a function for adding a standard set of passes.  This should be
     206             : /// used by optimizer plugins to allow all front ends to transparently use
     207             : /// them.  Create a static instance of this class in your plugin, providing a
     208             : /// private function that the PassManagerBuilder can use to add your passes.
     209             : struct RegisterStandardPasses {
     210       92943 :   RegisterStandardPasses(PassManagerBuilder::ExtensionPointTy Ty,
     211             :                          PassManagerBuilder::ExtensionFn Fn) {
     212      278829 :     PassManagerBuilder::addGlobalExtension(Ty, std::move(Fn));
     213       92943 :   }
     214             : };
     215             : 
     216             : } // end namespace llvm
     217             : #endif

Generated by: LCOV version 1.13