#define LLVM_PASS_SUPPORT_H
#include "Pass.h"
-#include "llvm/Config/config.h"
+#include "llvm/PassRegistry.h"
namespace llvm {
/// getPassInfo() method. These objects are set up by the RegisterPass<>
/// template, defined below.
///
-
-struct StaticPassInfo {
+class PassInfo {
+public:
typedef Pass* (*NormalCtor_t)();
- struct InterfaceInfo {
- const StaticPassInfo *interface;
- const InterfaceInfo *next;
- };
-
- const char *PassName; // Nice name for Pass
- const char *PassArgument; // Command Line argument to run this pass
- intptr_t PassID;
- bool IsCFGOnlyPass; // Pass only looks at the CFG.
- bool IsAnalysis; // True if an analysis pass.
- bool IsAnalysisGroup; // True if an analysis group.
- InterfaceInfo *ItfImpl;// Interfaces implemented by this pass
+
+private:
+ const char *const PassName; // Nice name for Pass
+ const char *const PassArgument; // Command Line argument to run this pass
+ const void *PassID;
+ const bool IsCFGOnlyPass; // Pass only looks at the CFG.
+ const bool IsAnalysis; // True if an analysis pass.
+ const bool IsAnalysisGroup; // True if an analysis group.
+ std::vector<const PassInfo*> ItfImpl;// Interfaces implemented by this pass
NormalCtor_t NormalCtor;
-
+
+public:
+ /// PassInfo ctor - Do not call this directly, this should only be invoked
+ /// through RegisterPass.
+ PassInfo(const char *name, const char *arg, const void *pi,
+ NormalCtor_t normal = 0,
+ bool isCFGOnly = false, bool is_analysis = false)
+ : PassName(name), PassArgument(arg), PassID(pi),
+ IsCFGOnlyPass(isCFGOnly),
+ IsAnalysis(is_analysis), IsAnalysisGroup(false), NormalCtor(normal) {
+ PassRegistry::getPassRegistry()->registerPass(*this);
+ }
+ /// PassInfo ctor - Do not call this directly, this should only be invoked
+ /// through RegisterPass. This version is for use by analysis groups; it
+ /// does not auto-register the pass.
+ PassInfo(const char *name, const void *pi)
+ : PassName(name), PassArgument(""), PassID(pi),
+ IsCFGOnlyPass(false),
+ IsAnalysis(false), IsAnalysisGroup(true), NormalCtor(0) {
+ }
+
/// getPassName - Return the friendly name for the pass, never returns null
///
const char *getPassName() const { return PassName; }
/// getTypeInfo - Return the id object for the pass...
/// TODO : Rename
- intptr_t getTypeInfo() const { return PassID; }
+ const void *getTypeInfo() const { return PassID; }
/// Return true if this PassID implements the specified ID pointer.
- bool isPassID(void *IDPtr) const {
- return PassID == (intptr_t)IDPtr;
+ bool isPassID(const void *IDPtr) const {
+ return PassID == IDPtr;
}
-
+
/// isAnalysisGroup - Return true if this is an analysis group, not a normal
/// pass.
///
/// isCFGOnlyPass - return true if this pass only looks at the CFG for the
/// function.
bool isCFGOnlyPass() const { return IsCFGOnlyPass; }
-
+
/// getNormalCtor - Return a pointer to a function, that when called, creates
/// an instance of the pass and returns it. This pointer may be null if there
/// is no default constructor for the pass.
NormalCtor = Ctor;
}
+ /// createPass() - Use this method to create an instance of this pass.
+ Pass *createPass() const;
+
/// addInterfaceImplemented - This method is called when this pass is
/// registered as a member of an analysis group with the RegisterAnalysisGroup
/// template.
///
- void addInterfaceImplemented(const StaticPassInfo *ItfPI) {
- InterfaceInfo *NewInfo = new InterfaceInfo();
- NewInfo->interface = ItfPI;
- NewInfo->next = ItfImpl;
- ItfImpl = NewInfo;
+ void addInterfaceImplemented(const PassInfo *ItfPI) {
+ ItfImpl.push_back(ItfPI);
}
/// getInterfacesImplemented - Return a list of all of the analysis group
/// interfaces implemented by this pass.
///
- const InterfaceInfo *getInterfacesImplemented() const {
+ const std::vector<const PassInfo*> &getInterfacesImplemented() const {
return ItfImpl;
}
- /// createPass() - Use this method to create an instance of this pass.
- Pass *createPass() const;
-};
-
-class PassInfo : public StaticPassInfo {
-public:
- /// PassInfo ctor - Do not call this directly, this should only be invoked
- /// through RegisterPass.
- PassInfo(const char *name, const char *arg, intptr_t pi,
- NormalCtor_t normal = 0,
- bool isCFGOnly = false, bool is_analysis = false) {
- this->PassName = name;
- this->PassArgument = arg;
- this->PassID = pi;
- this->IsCFGOnlyPass = isCFGOnly;
- this->IsAnalysis = is_analysis;
- this->IsAnalysisGroup = false;
- this->NormalCtor = normal;
- registerPass();
- }
- /// PassInfo ctor - Do not call this directly, this should only be invoked
- /// through RegisterPass. This version is for use by analysis groups; it
- /// does not auto-register the pass.
- PassInfo(const char *name, intptr_t pi) {
- this->PassName = name;
- this->PassArgument = "";
- this->PassID = pi;
- this->IsCFGOnlyPass = false;
- this->IsAnalysis = false;
- this->IsAnalysisGroup = true;
- this->NormalCtor = 0;
- }
-
-protected:
- void registerPass();
- void unregisterPass();
-
private:
void operator=(const PassInfo &); // do not implement
PassInfo(const PassInfo &); // do not implement
};
+#define INITIALIZE_PASS(passName, arg, name, cfg, analysis) \
+ static RegisterPass<passName> passName ## _info(arg, name, cfg, analysis)
template<typename PassName>
Pass *callDefaultCtor() { return new PassName(); }
// Register Pass using default constructor...
RegisterPass(const char *PassArg, const char *Name, bool CFGOnly = false,
bool is_analysis = false)
- : PassInfo(Name, PassArg, intptr_t(&passName::ID),
+ : PassInfo(Name, PassArg, &passName::ID,
PassInfo::NormalCtor_t(callDefaultCtor<passName>),
CFGOnly, is_analysis) {
+
}
};
class RegisterAGBase : public PassInfo {
protected:
RegisterAGBase(const char *Name,
- intptr_t InterfaceID,
- intptr_t PassID = 0,
+ const void *InterfaceID,
+ const void *PassID = 0,
bool isDefault = false);
};
struct RegisterAnalysisGroup : public RegisterAGBase {
explicit RegisterAnalysisGroup(PassInfo &RPB)
: RegisterAGBase(RPB.getPassName(),
- intptr_t(&Interface::ID), RPB.getTypeInfo(),
+ &Interface::ID, RPB.getTypeInfo(),
Default) {
}
explicit RegisterAnalysisGroup(const char *Name)
- : RegisterAGBase(Name, intptr_t(&Interface::ID)) {
+ : RegisterAGBase(Name, &Interface::ID) {
}
};
-
+#define INITIALIZE_AG_PASS(passName, agName, arg, name, cfg, analysis, def) \
+ static RegisterPass<passName> passName ## _info(arg, name, cfg, analysis); \
+ static RegisterAnalysisGroup<agName, def> passName ## _ag(passName ## _info)
//===---------------------------------------------------------------------------
/// PassRegistrationListener class - This class is meant to be derived from by
/// Callback functions - These functions are invoked whenever a pass is loaded
/// or removed from the current executable.
///
- virtual void passRegistered(const StaticPassInfo *) {}
+ virtual void passRegistered(const PassInfo *) {}
/// enumeratePasses - Iterate over the registered passes, calling the
/// passEnumerate callback on each PassInfo object.
/// passEnumerate - Callback function invoked when someone calls
/// enumeratePasses on this PassRegistrationListener object.
///
- virtual void passEnumerate(const StaticPassInfo *) {}
+ virtual void passEnumerate(const PassInfo *) {}
};
projects / oota-llvm.git / blobdiff