include/llvm/IR/PassManagerInternal.h

   1 //===- PassManager internal APIs and implementation details -----*- 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 /// This header provides internal APIs and implementation details used by the
  12 /// pass management interfaces exposed in PassManager.h. To understand more
  13 /// context of why these particular interfaces are needed, see that header
  14 /// file. None of these APIs should be used elsewhere.
  15 ///
  16 //===----------------------------------------------------------------------===//
  17
  18 #ifndef LLVM_IR_PASSMANAGERINTERNAL_H
  19 #define LLVM_IR_PASSMANAGERINTERNAL_H
  20
  21 #include "llvm/ADT/StringRef.h"
  22 #include "llvm/ADT/STLExtras.h"
  23
  24 namespace llvm {
  25
  26 template <typename IRUnitT> class AnalysisManager;
  27 class PreservedAnalyses;
  28
  29 /// \brief Implementation details of the pass manager interfaces.
  30 namespace detail {
  31
  32 /// \brief Template for the abstract base class used to dispatch
  33 /// polymorphically over pass objects.
  34 template <typename IRUnitT> struct PassConcept {
  35   // Boiler plate necessary for the container of derived classes.
  36   virtual ~PassConcept() {}
  37
  38   /// \brief The polymorphic API which runs the pass over a given IR entity.
  39   ///
  40   /// Note that actual pass object can omit the analysis manager argument if
  41   /// desired. Also that the analysis manager may be null if there is no
  42   /// analysis manager in the pass pipeline.
  43   virtual PreservedAnalyses run(IRUnitT &IR, AnalysisManager<IRUnitT> *AM) = 0;
  44
  45   /// \brief Polymorphic method to access the name of a pass.
  46   virtual StringRef name() = 0;
  47 };
  48
  49 /// \brief SFINAE metafunction for computing whether \c PassT has a run method
  50 /// accepting an \c AnalysisManager<IRUnitT>.
  51 template <typename IRUnitT, typename PassT, typename ResultT>
  52 class PassRunAcceptsAnalysisManager {
  53   typedef char SmallType;
  54   struct BigType {
  55     char a, b;
  56   };
  57
  58   template <typename T, ResultT (T::*)(IRUnitT &, AnalysisManager<IRUnitT> *)>
  59   struct Checker;
  60
  61   template <typename T> static SmallType f(Checker<T, &T::run> *);
  62   template <typename T> static BigType f(...);
  63
  64 public:
  65   enum { Value = sizeof(f<PassT>(nullptr)) == sizeof(SmallType) };
  66 };
  67
  68 /// \brief A template wrapper used to implement the polymorphic API.
  69 ///
  70 /// Can be instantiated for any object which provides a \c run method accepting
  71 /// an \c IRUnitT. It requires the pass to be a copyable object. When the
  72 /// \c run method also accepts an \c AnalysisManager<IRUnitT>*, we pass it
  73 /// along.
  74 template <typename IRUnitT, typename PassT,
  75           typename PreservedAnalysesT = PreservedAnalyses,
  76           bool AcceptsAnalysisManager = PassRunAcceptsAnalysisManager<
  77               IRUnitT, PassT, PreservedAnalysesT>::Value>
  78 struct PassModel;
  79
  80 /// \brief Specialization of \c PassModel for passes that accept an analyis
  81 /// manager.
  82 template <typename IRUnitT, typename PassT, typename PreservedAnalysesT>
  83 struct PassModel<IRUnitT, PassT, PreservedAnalysesT, true>
  84     : PassConcept<IRUnitT> {
  85   explicit PassModel(PassT Pass) : Pass(std::move(Pass)) {}
  86   // We have to explicitly define all the special member functions because MSVC
  87   // refuses to generate them.
  88   PassModel(const PassModel &Arg) : Pass(Arg.Pass) {}
  89   PassModel(PassModel &&Arg) : Pass(std::move(Arg.Pass)) {}
  90   friend void swap(PassModel &LHS, PassModel &RHS) {
  91     using std::swap;
  92     swap(LHS.Pass, RHS.Pass);
  93   }
  94   PassModel &operator=(PassModel RHS) {
  95     swap(*this, RHS);
  96     return *this;
  97   }
  98
  99   PreservedAnalysesT run(IRUnitT &IR, AnalysisManager<IRUnitT> *AM) override {
 100     return Pass.run(IR, AM);
 101   }
 102   StringRef name() override { return PassT::name(); }
 103   PassT Pass;
 104 };
 105
 106 /// \brief Specialization of \c PassModel for passes that accept an analyis
 107 /// manager.
 108 template <typename IRUnitT, typename PassT, typename PreservedAnalysesT>
 109 struct PassModel<IRUnitT, PassT, PreservedAnalysesT, false>
 110     : PassConcept<IRUnitT> {
 111   explicit PassModel(PassT Pass) : Pass(std::move(Pass)) {}
 112   // We have to explicitly define all the special member functions because MSVC
 113   // refuses to generate them.
 114   PassModel(const PassModel &Arg) : Pass(Arg.Pass) {}
 115   PassModel(PassModel &&Arg) : Pass(std::move(Arg.Pass)) {}
 116   friend void swap(PassModel &LHS, PassModel &RHS) {
 117     using std::swap;
 118     swap(LHS.Pass, RHS.Pass);
 119   }
 120   PassModel &operator=(PassModel RHS) {
 121     swap(*this, RHS);
 122     return *this;
 123   }
 124
 125   PreservedAnalysesT run(IRUnitT &IR, AnalysisManager<IRUnitT> *AM) override {
 126     return Pass.run(IR);
 127   }
 128   StringRef name() override { return PassT::name(); }
 129   PassT Pass;
 130 };
 131
 132 /// \brief Abstract concept of an analysis result.
 133 ///
 134 /// This concept is parameterized over the IR unit that this result pertains
 135 /// to.
 136 template <typename IRUnitT> struct AnalysisResultConcept {
 137   virtual ~AnalysisResultConcept() {}
 138
 139   /// \brief Method to try and mark a result as invalid.
 140   ///
 141   /// When the outer analysis manager detects a change in some underlying
 142   /// unit of the IR, it will call this method on all of the results cached.
 143   ///
 144   /// This method also receives a set of preserved analyses which can be used
 145   /// to avoid invalidation because the pass which changed the underlying IR
 146   /// took care to update or preserve the analysis result in some way.
 147   ///
 148   /// \returns true if the result is indeed invalid (the default).
 149   virtual bool invalidate(IRUnitT &IR, const PreservedAnalyses &PA) = 0;
 150 };
 151
 152 /// \brief SFINAE metafunction for computing whether \c ResultT provides an
 153 /// \c invalidate member function.
 154 template <typename IRUnitT, typename ResultT> class ResultHasInvalidateMethod {
 155   typedef char SmallType;
 156   struct BigType {
 157     char a, b;
 158   };
 159
 160   template <typename T, bool (T::*)(IRUnitT &, const PreservedAnalyses &)>
 161   struct Checker;
 162
 163   template <typename T> static SmallType f(Checker<T, &T::invalidate> *);
 164   template <typename T> static BigType f(...);
 165
 166 public:
 167   enum { Value = sizeof(f<ResultT>(nullptr)) == sizeof(SmallType) };
 168 };
 169
 170 /// \brief Wrapper to model the analysis result concept.
 171 ///
 172 /// By default, this will implement the invalidate method with a trivial
 173 /// implementation so that the actual analysis result doesn't need to provide
 174 /// an invalidation handler. It is only selected when the invalidation handler
 175 /// is not part of the ResultT's interface.
 176 template <typename IRUnitT, typename PassT, typename ResultT,
 177           typename PreservedAnalysesT = PreservedAnalyses,
 178           bool HasInvalidateHandler =
 179               ResultHasInvalidateMethod<IRUnitT, ResultT>::Value>
 180 struct AnalysisResultModel;
 181
 182 /// \brief Specialization of \c AnalysisResultModel which provides the default
 183 /// invalidate functionality.
 184 template <typename IRUnitT, typename PassT, typename ResultT,
 185           typename PreservedAnalysesT>
 186 struct AnalysisResultModel<IRUnitT, PassT, ResultT, PreservedAnalysesT, false>
 187     : AnalysisResultConcept<IRUnitT> {
 188   explicit AnalysisResultModel(ResultT Result) : Result(std::move(Result)) {}
 189   // We have to explicitly define all the special member functions because MSVC
 190   // refuses to generate them.
 191   AnalysisResultModel(const AnalysisResultModel &Arg) : Result(Arg.Result) {}
 192   AnalysisResultModel(AnalysisResultModel &&Arg)
 193       : Result(std::move(Arg.Result)) {}
 194   friend void swap(AnalysisResultModel &LHS, AnalysisResultModel &RHS) {
 195     using std::swap;
 196     swap(LHS.Result, RHS.Result);
 197   }
 198   AnalysisResultModel &operator=(AnalysisResultModel RHS) {
 199     swap(*this, RHS);
 200     return *this;
 201   }
 202
 203   /// \brief The model bases invalidation solely on being in the preserved set.
 204   //
 205   // FIXME: We should actually use two different concepts for analysis results
 206   // rather than two different models, and avoid the indirect function call for
 207   // ones that use the trivial behavior.
 208   bool invalidate(IRUnitT &, const PreservedAnalysesT &PA) override {
 209     return !PA.preserved(PassT::ID());
 210   }
 211
 212   ResultT Result;
 213 };
 214
 215 /// \brief Specialization of \c AnalysisResultModel which delegates invalidate
 216 /// handling to \c ResultT.
 217 template <typename IRUnitT, typename PassT, typename ResultT,
 218           typename PreservedAnalysesT>
 219 struct AnalysisResultModel<IRUnitT, PassT, ResultT, PreservedAnalysesT, true>
 220     : AnalysisResultConcept<IRUnitT> {
 221   explicit AnalysisResultModel(ResultT Result) : Result(std::move(Result)) {}
 222   // We have to explicitly define all the special member functions because MSVC
 223   // refuses to generate them.
 224   AnalysisResultModel(const AnalysisResultModel &Arg) : Result(Arg.Result) {}
 225   AnalysisResultModel(AnalysisResultModel &&Arg)
 226       : Result(std::move(Arg.Result)) {}
 227   friend void swap(AnalysisResultModel &LHS, AnalysisResultModel &RHS) {
 228     using std::swap;
 229     swap(LHS.Result, RHS.Result);
 230   }
 231   AnalysisResultModel &operator=(AnalysisResultModel RHS) {
 232     swap(*this, RHS);
 233     return *this;
 234   }
 235
 236   /// \brief The model delegates to the \c ResultT method.
 237   bool invalidate(IRUnitT &IR, const PreservedAnalysesT &PA) override {
 238     return Result.invalidate(IR, PA);
 239   }
 240
 241   ResultT Result;
 242 };
 243
 244 /// \brief Abstract concept of an analysis pass.
 245 ///
 246 /// This concept is parameterized over the IR unit that it can run over and
 247 /// produce an analysis result.
 248 template <typename IRUnitT> struct AnalysisPassConcept {
 249   virtual ~AnalysisPassConcept() {}
 250
 251   /// \brief Method to run this analysis over a unit of IR.
 252   /// \returns A unique_ptr to the analysis result object to be queried by
 253   /// users.
 254   virtual std::unique_ptr<AnalysisResultConcept<IRUnitT>>
 255   run(IRUnitT &IR, AnalysisManager<IRUnitT> *AM) = 0;
 256
 257   /// \brief Polymorphic method to access the name of a pass.
 258   virtual StringRef name() = 0;
 259 };
 260
 261 /// \brief Wrapper to model the analysis pass concept.
 262 ///
 263 /// Can wrap any type which implements a suitable \c run method. The method
 264 /// must accept the IRUnitT as an argument and produce an object which can be
 265 /// wrapped in a \c AnalysisResultModel.
 266 template <typename IRUnitT, typename PassT,
 267           bool AcceptsAnalysisManager = PassRunAcceptsAnalysisManager<
 268               IRUnitT, PassT, typename PassT::Result>::Value>
 269 struct AnalysisPassModel;
 270
 271 /// \brief Specialization of \c AnalysisPassModel which passes an
 272 /// \c AnalysisManager to PassT's run method.
 273 template <typename IRUnitT, typename PassT>
 274 struct AnalysisPassModel<IRUnitT, PassT, true> : AnalysisPassConcept<IRUnitT> {
 275   explicit AnalysisPassModel(PassT Pass) : Pass(std::move(Pass)) {}
 276   // We have to explicitly define all the special member functions because MSVC
 277   // refuses to generate them.
 278   AnalysisPassModel(const AnalysisPassModel &Arg) : Pass(Arg.Pass) {}
 279   AnalysisPassModel(AnalysisPassModel &&Arg) : Pass(std::move(Arg.Pass)) {}
 280   friend void swap(AnalysisPassModel &LHS, AnalysisPassModel &RHS) {
 281     using std::swap;
 282     swap(LHS.Pass, RHS.Pass);
 283   }
 284   AnalysisPassModel &operator=(AnalysisPassModel RHS) {
 285     swap(*this, RHS);
 286     return *this;
 287   }
 288
 289   // FIXME: Replace PassT::Result with type traits when we use C++11.
 290   typedef AnalysisResultModel<IRUnitT, PassT, typename PassT::Result>
 291       ResultModelT;
 292
 293   /// \brief The model delegates to the \c PassT::run method.
 294   ///
 295   /// The return is wrapped in an \c AnalysisResultModel.
 296   std::unique_ptr<AnalysisResultConcept<IRUnitT>>
 297   run(IRUnitT &IR, AnalysisManager<IRUnitT> *AM) override {
 298     return make_unique<ResultModelT>(Pass.run(IR, AM));
 299   }
 300
 301   /// \brief The model delegates to a static \c PassT::name method.
 302   ///
 303   /// The returned string ref must point to constant immutable data!
 304   StringRef name() override { return PassT::name(); }
 305
 306   PassT Pass;
 307 };
 308
 309 /// \brief Specialization of \c AnalysisPassModel which does not pass an
 310 /// \c AnalysisManager to PassT's run method.
 311 template <typename IRUnitT, typename PassT>
 312 struct AnalysisPassModel<IRUnitT, PassT, false> : AnalysisPassConcept<IRUnitT> {
 313   explicit AnalysisPassModel(PassT Pass) : Pass(std::move(Pass)) {}
 314   // We have to explicitly define all the special member functions because MSVC
 315   // refuses to generate them.
 316   AnalysisPassModel(const AnalysisPassModel &Arg) : Pass(Arg.Pass) {}
 317   AnalysisPassModel(AnalysisPassModel &&Arg) : Pass(std::move(Arg.Pass)) {}
 318   friend void swap(AnalysisPassModel &LHS, AnalysisPassModel &RHS) {
 319     using std::swap;
 320     swap(LHS.Pass, RHS.Pass);
 321   }
 322   AnalysisPassModel &operator=(AnalysisPassModel RHS) {
 323     swap(*this, RHS);
 324     return *this;
 325   }
 326
 327   // FIXME: Replace PassT::Result with type traits when we use C++11.
 328   typedef AnalysisResultModel<IRUnitT, PassT, typename PassT::Result>
 329       ResultModelT;
 330
 331   /// \brief The model delegates to the \c PassT::run method.
 332   ///
 333   /// The return is wrapped in an \c AnalysisResultModel.
 334   std::unique_ptr<AnalysisResultConcept<IRUnitT>>
 335   run(IRUnitT &IR, AnalysisManager<IRUnitT> *) override {
 336     return make_unique<ResultModelT>(Pass.run(IR));
 337   }
 338
 339   /// \brief The model delegates to a static \c PassT::name method.
 340   ///
 341   /// The returned string ref must point to constant immutable data!
 342   StringRef name() override { return PassT::name(); }
 343
 344   PassT Pass;
 345 };
 346
 347 } // End namespace detail
 348 }
 349
 350 #endif