tools/opt/Passes.h

   1 //===- Passes.h - Utilities for manipulating all passes ---------*- 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 /// \file
  10 ///
  11 /// Interfaces for registering passes, producing common pass manager
  12 /// configurations, and parsing of pass pipelines.
  13 ///
  14 //===----------------------------------------------------------------------===//
  15
  16 #ifndef LLVM_TOOLS_OPT_PASSES_H
  17 #define LLVM_TOOLS_OPT_PASSES_H
  18
  19 #include "llvm/ADT/StringRef.h"
  20 #include "llvm/Analysis/CGSCCPassManager.h"
  21 #include "llvm/IR/PassManager.h"
  22
  23 namespace llvm {
  24 class TargetMachine;
  25
  26 /// \brief This class provides access to all of LLVM's passes.
  27 ///
  28 /// It's members provide the baseline state available to passes during their
  29 /// construction. The \c PassRegistry.def file specifies how to construct all
  30 /// of the built-in passes, and those may reference these members during
  31 /// construction.
  32 class Passes {
  33   TargetMachine *TM;
  34
  35 public:
  36   explicit Passes(TargetMachine *TM = nullptr) : TM(TM) {}
  37
  38   /// \brief Registers all available module analysis passes.
  39   ///
  40   /// This is an interface that can be used to populate a \c
  41   /// ModuleAnalysisManager with all registered module analyses. Callers can
  42   /// still manually register any additional analyses.
  43   void registerModuleAnalyses(ModuleAnalysisManager &MAM);
  44
  45   /// \brief Registers all available CGSCC analysis passes.
  46   ///
  47   /// This is an interface that can be used to populate a \c CGSCCAnalysisManager
  48   /// with all registered CGSCC analyses. Callers can still manually register any
  49   /// additional analyses.
  50   void registerCGSCCAnalyses(CGSCCAnalysisManager &CGAM);
  51
  52   /// \brief Registers all available function analysis passes.
  53   ///
  54   /// This is an interface that can be used to populate a \c
  55   /// FunctionAnalysisManager with all registered function analyses. Callers can
  56   /// still manually register any additional analyses.
  57   void registerFunctionAnalyses(FunctionAnalysisManager &FAM);
  58
  59   /// \brief Parse a textual pass pipeline description into a \c ModulePassManager.
  60   ///
  61   /// The format of the textual pass pipeline description looks something like:
  62   ///
  63   ///   module(function(instcombine,sroa),dce,cgscc(inliner,function(...)),...)
  64   ///
  65   /// Pass managers have ()s describing the nest structure of passes. All passes
  66   /// are comma separated. As a special shortcut, if the very first pass is not
  67   /// a module pass (as a module pass manager is), this will automatically form
  68   /// the shortest stack of pass managers that allow inserting that first pass.
  69   /// So, assuming function passes 'fpassN', CGSCC passes 'cgpassN', and loop passes
  70   /// 'lpassN', all of these are valid:
  71   ///
  72   ///   fpass1,fpass2,fpass3
  73   ///   cgpass1,cgpass2,cgpass3
  74   ///   lpass1,lpass2,lpass3
  75   ///
  76   /// And they are equivalent to the following (resp.):
  77   ///
  78   ///   module(function(fpass1,fpass2,fpass3))
  79   ///   module(cgscc(cgpass1,cgpass2,cgpass3))
  80   ///   module(function(loop(lpass1,lpass2,lpass3)))
  81   ///
  82   /// This shortcut is especially useful for debugging and testing small pass
  83   /// combinations. Note that these shortcuts don't introduce any other magic. If
  84   /// the sequence of passes aren't all the exact same kind of pass, it will be
  85   /// an error. You cannot mix different levels implicitly, you must explicitly
  86   /// form a pass manager in which to nest passes.
  87   bool parsePassPipeline(ModulePassManager &MPM, StringRef PipelineText,
  88                          bool VerifyEachPass = true, bool DebugLogging = false);
  89
  90 private:
  91   bool parseModulePassName(ModulePassManager &MPM, StringRef Name);
  92   bool parseCGSCCPassName(CGSCCPassManager &CGPM, StringRef Name);
  93   bool parseFunctionPassName(FunctionPassManager &FPM, StringRef Name);
  94   bool parseFunctionPassPipeline(FunctionPassManager &FPM,
  95                                  StringRef &PipelineText, bool VerifyEachPass,
  96                                  bool DebugLogging);
  97   bool parseCGSCCPassPipeline(CGSCCPassManager &CGPM, StringRef &PipelineText,
  98                               bool VerifyEachPass, bool DebugLogging);
  99   bool parseModulePassPipeline(ModulePassManager &MPM, StringRef &PipelineText,
 100                                bool VerifyEachPass, bool DebugLogging);
 101 };
 102
 103 }
 104
 105 #endif