X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=blobdiff_plain;f=include%2Fllvm%2FPassSupport.h;h=09abe93e916dd07b46c6501a479396ca595038de;hp=f9360b7f089f5514fbcf7c25108e9180925c85a0;hb=8be3291f5942e3ae4a5d66c480e7aabe2f771031;hpb=a59cbb2043c08f3cfb8fb379f0d336e21e070be8 diff --git a/include/llvm/PassSupport.h b/include/llvm/PassSupport.h index f9360b7f089..09abe93e916 100644 --- a/include/llvm/PassSupport.h +++ b/include/llvm/PassSupport.h @@ -1,5 +1,12 @@ //===- llvm/PassSupport.h - Pass Support code -------------------*- C++ -*-===// // +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// // This file defines stuff that is used to define and "use" Passes. This file // is automatically #included by Pass.h, so: // @@ -14,233 +21,239 @@ #ifndef LLVM_PASS_SUPPORT_H #define LLVM_PASS_SUPPORT_H -// No need to include Pass.h, we are being included by it! +#include "Pass.h" -#include -class TargetData; +namespace llvm { + +class TargetMachine; //===--------------------------------------------------------------------------- -// 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. -// +/// 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 { - const char *PassName; // Nice name for Pass - const char *PassArgument; // Command Line argument to run this pass - const std::type_info &TypeInfo; // type_info object for this Pass class - unsigned char PassType; // Set of enums values below... - - Pass *(*NormalCtor)(); // No argument ctor - Pass *(*DataCtor)(const TargetData&);// Ctor taking TargetData object... - public: - // PassType - Define symbolic constants that can be used to test to see if - // this pass should be listed by analyze or opt. Passes can use none, one or - // many of these flags or'd together. - // - enum { - Analysis = 1, Optimization = 2 + typedef Pass* (*NormalCtor_t)(); + struct InterfaceInfo { + const PassInfo *interface; + const InterfaceInfo *next; }; - // PassInfo ctor - Do not call this directly, this should only be invoked - // through RegisterPass. - PassInfo(const char *name, const char *arg, const std::type_info &ti, - unsigned pt, Pass *(*normal)(), Pass *(*data)(const TargetData &)) - : PassName(name), PassArgument(arg), TypeInfo(ti), PassType(pt), - NormalCtor(normal), DataCtor(data) { +private: + const char *const PassName; // Nice name for Pass + const char *const PassArgument; // Command Line argument to run this pass + const intptr_t 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. + const InterfaceInfo *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, intptr_t 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) { + 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) + : PassName(name), PassArgument(""), PassID(pi), + IsCFGOnlyPass(false), + IsAnalysis(false), IsAnalysisGroup(true), NormalCtor(0) { } - // getPassName - Return the friendly name for the pass, never returns null + /// 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. - // + /// 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 type_info object for the pass... - const std::type_info &getTypeInfo() const { return TypeInfo; } - - // getPassType - Return the PassType of a pass. Note that this can be several - // different types or'd together. This is _strictly_ for use by opt, analyze - // and llc for deciding which passes to use as command line options. - // - unsigned getPassType() const { return PassType; } + /// getTypeInfo - Return the id object for the pass... + /// TODO : Rename + intptr_t getTypeInfo() const { return PassID; } - // 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. + /// Return true if this PassID implements the specified ID pointer. + bool isPassID(void *IDPtr) const { + return PassID == (intptr_t)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; } - Pass *(*getNormalCtor() const)() { + /// 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; } - - // createPass() - Use this - Pass *createPass() const { - assert(NormalCtor && - "Cannot call createPass on PassInfo without default ctor!"); - return NormalCtor(); + void setNormalCtor(NormalCtor_t Ctor) { + NormalCtor = Ctor; } - // getDataCtor - Return a pointer to a function that creates an instance of - // the pass and returns it. This returns a constructor for a version of the - // pass that takes a TArgetData object as a parameter. - // - Pass *(*getDataCtor() const)(const TargetData &) { - return DataCtor; + /// 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) { + InterfaceInfo *NewInfo = new InterfaceInfo(); + NewInfo->interface = ItfPI; + NewInfo->next = ItfImpl; + ItfImpl = NewInfo; } -}; - -//===--------------------------------------------------------------------------- -// RegisterPass template - This template class is used to notify the system -// that a Pass is available for use, and registers it into the internal database -// maintained by the PassManager. Unless this template is used, opt, for -// example will not be able to see the pass and attempts to create the pass will -// fail. This template is used in the follow manner (at global scope, in your -// .cpp file): -// -// static RegisterPass tmp("passopt", "My Pass Name"); -// -// This statement will cause your pass to be created by calling the default -// constructor exposed by the pass. If you have a different constructor that -// must be called, create a global constructor function (which takes the -// arguments you need and returns a Pass*) and register your pass like this: -// -// Pass *createMyPass(foo &opt) { return new MyPass(opt); } -// static RegisterPass tmp("passopt", "My Name", createMyPass); -// -struct RegisterPassBase { - // getPassInfo - Get the pass info for the registered class... - const PassInfo *getPassInfo() const { return PIObj; } - - ~RegisterPassBase(); // Intentionally non-virtual... - - inline operator PassInfo* () const { return PIObj; } + /// getInterfacesImplemented - Return a list of all of the analysis group + /// interfaces implemented by this pass. + /// + const InterfaceInfo *getInterfacesImplemented() const { + return ItfImpl; + } protected: - PassInfo *PIObj; // The PassInfo object for this pass - void registerPass(PassInfo *); + void registerPass(); + void unregisterPass(); + +private: + void operator=(const PassInfo &); // do not implement + PassInfo(const PassInfo &); // do not implement }; -template -Pass *callDefaultCtor() { return new PassName(); } template -struct RegisterPass : public RegisterPassBase { - - // Register Pass using default constructor... - RegisterPass(const char *PassArg, const char *Name, unsigned PassTy = 0) { - registerPass(new PassInfo(Name, PassArg, typeid(PassName), PassTy, - callDefaultCtor, 0)); - } - - // Register Pass using default constructor explicitly... - RegisterPass(const char *PassArg, const char *Name, unsigned PassTy, - Pass *(*ctor)()) { - registerPass(new PassInfo(Name, PassArg, typeid(PassName), PassTy, ctor,0)); - } +Pass *callDefaultCtor() { return new PassName(); } - // Register Pass using TargetData constructor... - RegisterPass(const char *PassArg, const char *Name, unsigned PassTy, - Pass *(*datactor)(const TargetData &)) { - registerPass(new PassInfo(Name, PassArg, typeid(PassName), PassTy, - 0, datactor)); - } +//===--------------------------------------------------------------------------- +/// RegisterPass template - This template class is used to notify the system +/// that a Pass is available for use, and registers it into the internal +/// database maintained by the PassManager. Unless this template is used, opt, +/// for example will not be able to see the pass and attempts to create the pass +/// will fail. This template is used in the follow manner (at global scope, in +/// your .cpp file): +/// +/// static RegisterPass tmp("passopt", "My Pass Name"); +/// +/// This statement will cause your pass to be created by calling the default +/// constructor exposed by the pass. If you have a different constructor that +/// must be called, create a global constructor function (which takes the +/// arguments you need and returns a Pass*) and register your pass like this: +/// +/// static RegisterPass tmp("passopt", "My Name"); +/// +template +struct RegisterPass : public PassInfo { - // Generic constructor version that has an unknown ctor type... - template - RegisterPass(const char *PassArg, const char *Name, unsigned PassTy, - CtorType *Fn) { - registerPass(new PassInfo(Name, PassArg, typeid(PassName), 0, 0)); + // 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::NormalCtor_t(callDefaultCtor), + CFGOnly, is_analysis) { } }; -// RegisterOpt - Register something that is to show up in Opt, this is just a -// shortcut for specifying RegisterPass... -// -template -struct RegisterOpt : public RegisterPassBase { - RegisterOpt(const char *PassArg, const char *Name) { - registerPass(new PassInfo(Name, PassArg, typeid(PassName), - PassInfo::Optimization, - callDefaultCtor, 0)); - } - // Register Pass using default constructor explicitly... - RegisterOpt(const char *PassArg, const char *Name, Pass *(*ctor)()) { - registerPass(new PassInfo(Name, PassArg, typeid(PassName), - PassInfo::Optimization, ctor, 0)); - } - - // Register Pass using TargetData constructor... - RegisterOpt(const char *PassArg, const char *Name, - Pass *(*datactor)(const TargetData &)) { - registerPass(new PassInfo(Name, PassArg, typeid(PassName), - PassInfo::Optimization, 0, datactor)); - } +/// RegisterAnalysisGroup - Register a Pass as a member of an analysis _group_. +/// Analysis groups are used to define an interface (which need not derive from +/// Pass) that is required by passes to do their job. Analysis Groups differ +/// from normal analyses because any available implementation of the group will +/// be used if it is available. +/// +/// If no analysis implementing the interface is available, a default +/// implementation is created and added. A pass registers itself as the default +/// implementation by specifying 'true' as the second template argument of this +/// class. +/// +/// In addition to registering itself as an analysis group member, a pass must +/// register itself normally as well. Passes may be members of multiple groups +/// and may still be "required" specifically by name. +/// +/// The actual interface may also be registered as well (by not specifying the +/// second template argument). The interface should be registered to associate +/// a nice name with the interface. +/// +class RegisterAGBase : public PassInfo { +protected: + RegisterAGBase(const char *Name, + intptr_t InterfaceID, + intptr_t PassID = 0, + bool isDefault = false); }; -// RegisterAnalysis - Register something that is to show up in Analysis, this is -// just a shortcut for specifying RegisterPass... -// -template -struct RegisterAnalysis : public RegisterPassBase { - RegisterAnalysis(const char *PassArg, const char *Name) { - registerPass(new PassInfo(Name, PassArg, typeid(PassName), - PassInfo::Analysis, - callDefaultCtor, 0)); - } - - // Register Pass using default constructor explicitly... - RegisterAnalysis(const char *PassArg, const char *Name, Pass *(*ctor)()) { - registerPass(new PassInfo(Name, PassArg, typeid(PassName), - PassInfo::Analys, ctor, 0)); +template +struct RegisterAnalysisGroup : public RegisterAGBase { + explicit RegisterAnalysisGroup(PassInfo &RPB) + : RegisterAGBase(RPB.getPassName(), + intptr_t(&Interface::ID), RPB.getTypeInfo(), + Default) { } - // Register Pass using TargetData constructor... - RegisterAnalysis(const char *PassArg, const char *Name, - Pass *(*datactor)(const TargetData &)) { - registerPass(new PassInfo(Name, PassArg, typeid(PassName), - PassInfo::Analysis, 0, datactor)); + explicit RegisterAnalysisGroup(const char *Name) + : RegisterAGBase(Name, intptr_t(&Interface::ID)) { } }; + //===--------------------------------------------------------------------------- -// PassRegistrationListener class - This class is meant to be derived from by -// 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 PassRegistationListener class automatically registers your -// object to receive callbacks indicating when passes are loaded and removed. -// +/// PassRegistrationListener class - This class is meant to be derived from by +/// 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 PassRegistationListener class automatically +/// registers your object to receive callbacks indicating when passes are loaded +/// and removed. +/// struct PassRegistrationListener { - // PassRegistrationListener ctor - Add the current object to the list of - // PassRegistrationListeners... + /// PassRegistrationListener ctor - Add the current object to the list of + /// PassRegistrationListeners... PassRegistrationListener(); - // dtor - Remove object from list of listeners... + /// dtor - Remove object from list of listeners... + /// virtual ~PassRegistrationListener(); - // Callback functions - These functions are invoked whenever a pass is loaded - // or removed from the current executable. - // - virtual void passRegistered(const PassInfo *P) {} - virtual void passUnregistered(const PassInfo *P) {} + /// Callback functions - These functions are invoked whenever a pass is loaded + /// or removed from the current executable. + /// + virtual void passRegistered(const PassInfo *) {} - // enumeratePasses - Iterate over the registered passes, calling the - // passEnumerate callback on each PassInfo object. - // + /// enumeratePasses - Iterate over the registered passes, calling the + /// passEnumerate callback on each PassInfo object. + /// void enumeratePasses(); - // passEnumerate - Callback function invoked when someone calls - // enumeratePasses on this PassRegistrationListener object. - // - virtual void passEnumerate(const PassInfo *P) {} + /// passEnumerate - Callback function invoked when someone calls + /// enumeratePasses on this PassRegistrationListener object. + /// + virtual void passEnumerate(const PassInfo *) {} }; + +} // End llvm namespace + #endif