#ifndef LLVM_PASS_H
#define LLVM_PASS_H
-#include "llvm/Support/DataTypes.h"
-#include "llvm/Support/Streams.h"
+#include "llvm/System/DataTypes.h"
#include <cassert>
-#include <iosfwd>
#include <utility>
#include <vector>
namespace llvm {
-class Value;
class BasicBlock;
class Function;
class Module;
class PMStack;
class AnalysisResolver;
class PMDataManager;
+class raw_ostream;
+class StringRef;
// AnalysisID - Use the PassInfo to identify a pass...
typedef const PassInfo* AnalysisID;
class Pass {
AnalysisResolver *Resolver; // Used to resolve analysis
intptr_t PassID;
- // AnalysisImpls - This keeps track of which passes implement the interfaces
- // that are required by the current pass (to implement getAnalysis()).
- //
- std::vector<std::pair<const PassInfo*, Pass*> > AnalysisImpls;
void operator=(const Pass&); // DO NOT IMPLEMENT
Pass(const Pass &); // DO NOT IMPLEMENT
+
public:
explicit Pass(intptr_t pid) : Resolver(0), PassID(pid) {
assert(pid && "pid cannot be 0");
/// provide the Module* in case the analysis doesn't need it it can just be
/// ignored.
///
- virtual void print(std::ostream &O, const Module *M) const;
- void print(std::ostream *O, const Module *M) const { if (O) print(*O, M); }
- void dump() const; // dump - call print(std::cerr, 0);
+ virtual void print(raw_ostream &O, const Module *M) const;
+ void dump() const; // dump - Print to stderr.
/// Each pass is responsible for assigning a pass manager to itself.
/// PMS is the stack of available pass manager.
// or null if it is not known.
static const PassInfo *lookupPassInfo(intptr_t TI);
- /// getAnalysisToUpdate<AnalysisType>() - This function is used by subclasses
- /// to get to the analysis information that might be around that needs to be
- /// updated. This is different than getAnalysis in that it can fail (ie the
- /// analysis results haven't been computed), so should only be used if you
- /// provide the capability to update an analysis that exists. This method is
- /// often used by transformation APIs to update analysis results for a pass
- /// automatically as the transform is performed.
+ // lookupPassInfo - Return the pass info object for the pass with the given
+ // argument string, or null if it is not known.
+ static const PassInfo *lookupPassInfo(const StringRef &Arg);
+
+ /// getAnalysisIfAvailable<AnalysisType>() - Subclasses use this function to
+ /// get analysis information that might be around, for example to update it.
+ /// This is different than getAnalysis in that it can fail (if the analysis
+ /// results haven't been computed), so should only be used if you can handle
+ /// the case when the analysis is not available. This method is often used by
+ /// transformation APIs to update analysis results for a pass automatically as
+ /// the transform is performed.
///
- template<typename AnalysisType>
- AnalysisType *getAnalysisToUpdate() const; // Defined in PassAnalysisSupport.h
+ template<typename AnalysisType> AnalysisType *
+ getAnalysisIfAvailable() const; // Defined in PassAnalysisSupport.h
/// mustPreserveAnalysisID - This method serves the same function as
- /// getAnalysisToUpdate, but works if you just have an AnalysisID. This
+ /// getAnalysisIfAvailable, but works if you just have an AnalysisID. This
/// obviously cannot give you a properly typed instance of the class if you
- /// don't have the class name available (use getAnalysisToUpdate if you do),
- /// but it can tell you if you need to preserve the pass at least.
+ /// don't have the class name available (use getAnalysisIfAvailable if you
+ /// do), but it can tell you if you need to preserve the pass at least.
///
bool mustPreserveAnalysisID(const PassInfo *AnalysisID) const;
AnalysisType &getAnalysis() const; // Defined in PassAnalysisSupport.h
template<typename AnalysisType>
- AnalysisType &getAnalysis(Function &F); // Defined in PassanalysisSupport.h
+ AnalysisType &getAnalysis(Function &F); // Defined in PassAnalysisSupport.h
template<typename AnalysisType>
AnalysisType &getAnalysisID(const PassInfo *PI) const;
AnalysisType &getAnalysisID(const PassInfo *PI, Function &F);
};
-inline std::ostream &operator<<(std::ostream &OS, const Pass &P) {
- P.print(OS, 0); return OS;
-}
//===----------------------------------------------------------------------===//
/// ModulePass class - This class is used to implement unstructured
/// any necessary per-module initialization.
///
virtual bool doInitialization(Module &) { return false; }
-
+
/// runOnFunction - Virtual method overriden by subclasses to do the
/// per-function processing of the pass.
///