#include "Pass.h"
#include "llvm/InitializePasses.h"
+#include "llvm/PassInfo.h"
#include "llvm/PassRegistry.h"
#include "llvm/Support/Atomic.h"
#include "llvm/Support/Valgrind.h"
namespace llvm {
class TargetMachine;
-class LLVMContext;
-//===---------------------------------------------------------------------------
-/// PassInfo class - An instance of this class exists for every pass known by
-/// the system, and can be obtained from a live Pass by calling its
-/// getPassInfo() method. These objects are set up by the RegisterPass<>
-/// template, defined below.
-///
-class PassInfo {
-public:
- typedef Pass* (*NormalCtor_t)();
- typedef Pass *(*TargetMachineCtor_t)(TargetMachine *);
-
-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;
- TargetMachineCtor_t TargetMachineCtor;
-
-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, bool isCFGOnly, bool is_analysis,
- TargetMachineCtor_t machine = nullptr)
- : PassName(name), PassArgument(arg), PassID(pi),
- IsCFGOnlyPass(isCFGOnly),
- IsAnalysis(is_analysis), IsAnalysisGroup(false), NormalCtor(normal),
- TargetMachineCtor(machine) {}
- /// 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(nullptr),
- TargetMachineCtor(nullptr) {}
-
- /// getPassName - Return the friendly name for the pass, never returns null
- ///
- const char *getPassName() const { return PassName; }
-
- /// getPassArgument - Return the command line option that may be passed to
- /// 'opt' that will cause this pass to be run. This will return null if there
- /// is no argument.
- ///
- const char *getPassArgument() const { return PassArgument; }
-
- /// getTypeInfo - Return the id object for the pass...
- /// TODO : Rename
- const void *getTypeInfo() const { return PassID; }
-
- /// Return true if this PassID implements the specified ID pointer.
- bool isPassID(const void *IDPtr) const {
- return PassID == IDPtr;
- }
-
- /// isAnalysisGroup - Return true if this is an analysis group, not a normal
- /// pass.
- ///
- bool isAnalysisGroup() const { return IsAnalysisGroup; }
- bool isAnalysis() const { return IsAnalysis; }
-
- /// 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_t getNormalCtor() const {
- return NormalCtor;
- }
- void setNormalCtor(NormalCtor_t Ctor) {
- NormalCtor = Ctor;
- }
-
- /// getTargetMachineCtor - Return a pointer to a function, that when called
- /// with a TargetMachine, creates an instance of the pass and returns it.
- /// This pointer may be null if there is no constructor with a TargetMachine
- /// for the pass.
- ///
- TargetMachineCtor_t getTargetMachineCtor() const { return TargetMachineCtor; }
- void setTargetMachineCtor(TargetMachineCtor_t Ctor) {
- TargetMachineCtor = 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 PassInfo *ItfPI) {
- ItfImpl.push_back(ItfPI);
- }
-
- /// getInterfacesImplemented - Return a list of all of the analysis group
- /// interfaces implemented by this pass.
- ///
- const std::vector<const PassInfo*> &getInterfacesImplemented() const {
- return ItfImpl;
- }
-
-private:
- void operator=(const PassInfo &) LLVM_DELETED_FUNCTION;
- PassInfo(const PassInfo &) LLVM_DELETED_FUNCTION;
-};
#define CALL_ONCE_INITIALIZATION(function) \
static volatile sys::cas_flag initialized = 0; \
CALL_ONCE_INITIALIZATION(initialize##passName##PassOnce) \
}
+#define INITIALIZE_PASS_WITH_OPTIONS(PassName, Arg, Name, Cfg, Analysis) \
+ INITIALIZE_PASS_BEGIN(PassName, Arg, Name, Cfg, Analysis) \
+ PassName::registerOptions(); \
+ INITIALIZE_PASS_END(PassName, Arg, Name, Cfg, Analysis)
+
+#define INITIALIZE_PASS_WITH_OPTIONS_BEGIN(PassName, Arg, Name, Cfg, Analysis) \
+ INITIALIZE_PASS_BEGIN(PassName, Arg, Name, Cfg, Analysis) \
+ PassName::registerOptions(); \
+
template<typename PassName>
Pass *callDefaultCtor() { return new PassName(); }
/// clients that are interested in which passes get registered and unregistered
/// at runtime (which can be because of the RegisterPass constructors being run
/// as the program starts up, or may be because a shared object just got
-/// loaded). Deriving from the PassRegistrationListener class automatically
-/// registers your object to receive callbacks indicating when passes are loaded
-/// and removed.
+/// loaded).
///
struct PassRegistrationListener {
- /// PassRegistrationListener ctor - Add the current object to the list of
- /// PassRegistrationListeners...
- PassRegistrationListener();
-
- /// dtor - Remove object from list of listeners...
- ///
- virtual ~PassRegistrationListener();
+ PassRegistrationListener() {}
+ virtual ~PassRegistrationListener() {}
/// Callback functions - These functions are invoked whenever a pass is loaded
/// or removed from the current executable.
virtual void passEnumerate(const PassInfo *) {}
};
-//===---------------------------------------------------------------------------
-/// PassRunListener class - This class is meant to be derived from by
-/// clients that are interested in which and when passes are run at runtime.
-struct PassRunListener {
- /// PassRunListener ctor - Add the current object to the list of
- /// PassRunListeners...
- PassRunListener(LLVMContext *);
-
- virtual ~PassRunListener();
-
- /// Callback function - This functions is invoked whenever a pass has run.
- virtual void passRun(LLVMContext *, Pass *, Module *, Function *,
- BasicBlock *) {}
-};
-
} // End llvm namespace