Home | History | Annotate | Download | only in llvm
      1 //===- llvm/PassAnalysisSupport.h - Analysis Pass Support code --*- 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 stuff that is used to define and "use" Analysis Passes.
     11 // This file is automatically #included by Pass.h, so:
     12 //
     13 //           NO .CPP FILES SHOULD INCLUDE THIS FILE DIRECTLY
     14 //
     15 // Instead, #include Pass.h
     16 //
     17 //===----------------------------------------------------------------------===//
     18 
     19 #ifndef LLVM_PASS_ANALYSIS_SUPPORT_H
     20 #define LLVM_PASS_ANALYSIS_SUPPORT_H
     21 
     22 #include "llvm/Pass.h"
     23 #include "llvm/ADT/SmallVector.h"
     24 #include "llvm/ADT/StringRef.h"
     25 #include <vector>
     26 
     27 namespace llvm {
     28 
     29 //===----------------------------------------------------------------------===//
     30 // AnalysisUsage - Represent the analysis usage information of a pass.  This
     31 // tracks analyses that the pass REQUIRES (must be available when the pass
     32 // runs), REQUIRES TRANSITIVE (must be available throughout the lifetime of the
     33 // pass), and analyses that the pass PRESERVES (the pass does not invalidate the
     34 // results of these analyses).  This information is provided by a pass to the
     35 // Pass infrastructure through the getAnalysisUsage virtual function.
     36 //
     37 class AnalysisUsage {
     38 public:
     39   typedef SmallVector<AnalysisID, 32> VectorType;
     40 
     41 private:
     42   // Sets of analyses required and preserved by a pass
     43   VectorType Required, RequiredTransitive, Preserved;
     44   bool PreservesAll;
     45 
     46 public:
     47   AnalysisUsage() : PreservesAll(false) {}
     48 
     49   // addRequired - Add the specified ID to the required set of the usage info
     50   // for a pass.
     51   //
     52   AnalysisUsage &addRequiredID(const void *ID);
     53   AnalysisUsage &addRequiredID(char &ID);
     54   template<class PassClass>
     55   AnalysisUsage &addRequired() {
     56     return addRequiredID(PassClass::ID);
     57   }
     58 
     59   AnalysisUsage &addRequiredTransitiveID(char &ID);
     60   template<class PassClass>
     61   AnalysisUsage &addRequiredTransitive() {
     62     return addRequiredTransitiveID(PassClass::ID);
     63   }
     64 
     65   // addPreserved - Add the specified ID to the set of analyses preserved by
     66   // this pass
     67   //
     68   AnalysisUsage &addPreservedID(const void *ID) {
     69     Preserved.push_back(ID);
     70     return *this;
     71   }
     72   AnalysisUsage &addPreservedID(char &ID) {
     73     Preserved.push_back(&ID);
     74     return *this;
     75   }
     76 
     77   // addPreserved - Add the specified Pass class to the set of analyses
     78   // preserved by this pass.
     79   //
     80   template<class PassClass>
     81   AnalysisUsage &addPreserved() {
     82     Preserved.push_back(&PassClass::ID);
     83     return *this;
     84   }
     85 
     86   // addPreserved - Add the Pass with the specified argument string to the set
     87   // of analyses preserved by this pass. If no such Pass exists, do nothing.
     88   // This can be useful when a pass is trivially preserved, but may not be
     89   // linked in. Be careful about spelling!
     90   //
     91   AnalysisUsage &addPreserved(StringRef Arg);
     92 
     93   // setPreservesAll - Set by analyses that do not transform their input at all
     94   void setPreservesAll() { PreservesAll = true; }
     95   bool getPreservesAll() const { return PreservesAll; }
     96 
     97   /// setPreservesCFG - This function should be called by the pass, iff they do
     98   /// not:
     99   ///
    100   ///  1. Add or remove basic blocks from the function
    101   ///  2. Modify terminator instructions in any way.
    102   ///
    103   /// This function annotates the AnalysisUsage info object to say that analyses
    104   /// that only depend on the CFG are preserved by this pass.
    105   ///
    106   void setPreservesCFG();
    107 
    108   const VectorType &getRequiredSet() const { return Required; }
    109   const VectorType &getRequiredTransitiveSet() const {
    110     return RequiredTransitive;
    111   }
    112   const VectorType &getPreservedSet() const { return Preserved; }
    113 };
    114 
    115 //===----------------------------------------------------------------------===//
    116 // AnalysisResolver - Simple interface used by Pass objects to pull all
    117 // analysis information out of pass manager that is responsible to manage
    118 // the pass.
    119 //
    120 class PMDataManager;
    121 class AnalysisResolver {
    122 private:
    123   AnalysisResolver();  // DO NOT IMPLEMENT
    124 
    125 public:
    126   explicit AnalysisResolver(PMDataManager &P) : PM(P) { }
    127 
    128   inline PMDataManager &getPMDataManager() { return PM; }
    129 
    130   // Find pass that is implementing PI.
    131   Pass *findImplPass(AnalysisID PI) {
    132     Pass *ResultPass = 0;
    133     for (unsigned i = 0; i < AnalysisImpls.size() ; ++i) {
    134       if (AnalysisImpls[i].first == PI) {
    135         ResultPass = AnalysisImpls[i].second;
    136         break;
    137       }
    138     }
    139     return ResultPass;
    140   }
    141 
    142   // Find pass that is implementing PI. Initialize pass for Function F.
    143   Pass *findImplPass(Pass *P, AnalysisID PI, Function &F);
    144 
    145   void addAnalysisImplsPair(AnalysisID PI, Pass *P) {
    146     if (findImplPass(PI) == P)
    147       return;
    148     std::pair<AnalysisID, Pass*> pir = std::make_pair(PI,P);
    149     AnalysisImpls.push_back(pir);
    150   }
    151 
    152   /// clearAnalysisImpls - Clear cache that is used to connect a pass to the
    153   /// the analysis (PassInfo).
    154   void clearAnalysisImpls() {
    155     AnalysisImpls.clear();
    156   }
    157 
    158   // getAnalysisIfAvailable - Return analysis result or null if it doesn't exist
    159   Pass *getAnalysisIfAvailable(AnalysisID ID, bool Direction) const;
    160 
    161 private:
    162   // AnalysisImpls - This keeps track of which passes implements the interfaces
    163   // that are required by the current pass (to implement getAnalysis()).
    164   std::vector<std::pair<AnalysisID, Pass*> > AnalysisImpls;
    165 
    166   // PassManager that is used to resolve analysis info
    167   PMDataManager &PM;
    168 };
    169 
    170 /// getAnalysisIfAvailable<AnalysisType>() - Subclasses use this function to
    171 /// get analysis information that might be around, for example to update it.
    172 /// This is different than getAnalysis in that it can fail (if the analysis
    173 /// results haven't been computed), so should only be used if you can handle
    174 /// the case when the analysis is not available.  This method is often used by
    175 /// transformation APIs to update analysis results for a pass automatically as
    176 /// the transform is performed.
    177 ///
    178 template<typename AnalysisType>
    179 AnalysisType *Pass::getAnalysisIfAvailable() const {
    180   assert(Resolver && "Pass not resident in a PassManager object!");
    181 
    182   const void *PI = &AnalysisType::ID;
    183 
    184   Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
    185   if (ResultPass == 0) return 0;
    186 
    187   // Because the AnalysisType may not be a subclass of pass (for
    188   // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
    189   // adjust the return pointer (because the class may multiply inherit, once
    190   // from pass, once from AnalysisType).
    191   return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
    192 }
    193 
    194 /// getAnalysis<AnalysisType>() - This function is used by subclasses to get
    195 /// to the analysis information that they claim to use by overriding the
    196 /// getAnalysisUsage function.
    197 ///
    198 template<typename AnalysisType>
    199 AnalysisType &Pass::getAnalysis() const {
    200   assert(Resolver && "Pass has not been inserted into a PassManager object!");
    201   return getAnalysisID<AnalysisType>(&AnalysisType::ID);
    202 }
    203 
    204 template<typename AnalysisType>
    205 AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
    206   assert(PI && "getAnalysis for unregistered pass!");
    207   assert(Resolver&&"Pass has not been inserted into a PassManager object!");
    208   // PI *must* appear in AnalysisImpls.  Because the number of passes used
    209   // should be a small number, we just do a linear search over a (dense)
    210   // vector.
    211   Pass *ResultPass = Resolver->findImplPass(PI);
    212   assert (ResultPass &&
    213           "getAnalysis*() called on an analysis that was not "
    214           "'required' by pass!");
    215 
    216   // Because the AnalysisType may not be a subclass of pass (for
    217   // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
    218   // adjust the return pointer (because the class may multiply inherit, once
    219   // from pass, once from AnalysisType).
    220   return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
    221 }
    222 
    223 /// getAnalysis<AnalysisType>() - This function is used by subclasses to get
    224 /// to the analysis information that they claim to use by overriding the
    225 /// getAnalysisUsage function.
    226 ///
    227 template<typename AnalysisType>
    228 AnalysisType &Pass::getAnalysis(Function &F) {
    229   assert(Resolver &&"Pass has not been inserted into a PassManager object!");
    230 
    231   return getAnalysisID<AnalysisType>(&AnalysisType::ID, F);
    232 }
    233 
    234 template<typename AnalysisType>
    235 AnalysisType &Pass::getAnalysisID(AnalysisID PI, Function &F) {
    236   assert(PI && "getAnalysis for unregistered pass!");
    237   assert(Resolver && "Pass has not been inserted into a PassManager object!");
    238   // PI *must* appear in AnalysisImpls.  Because the number of passes used
    239   // should be a small number, we just do a linear search over a (dense)
    240   // vector.
    241   Pass *ResultPass = Resolver->findImplPass(this, PI, F);
    242   assert(ResultPass && "Unable to find requested analysis info");
    243 
    244   // Because the AnalysisType may not be a subclass of pass (for
    245   // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
    246   // adjust the return pointer (because the class may multiply inherit, once
    247   // from pass, once from AnalysisType).
    248   return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
    249 }
    250 
    251 } // End llvm namespace
    252 
    253 #endif
    254