//
//===----------------------------------------------------------------------===//
-#ifndef LLVM_PASS_SUPPORT_H
-#define LLVM_PASS_SUPPORT_H
+#ifndef LLVM_PASSSUPPORT_H
+#define LLVM_PASSSUPPORT_H
#include "Pass.h"
-#include "llvm/PassRegistry.h"
#include "llvm/InitializePasses.h"
+#include "llvm/PassInfo.h"
+#include "llvm/PassRegistry.h"
#include "llvm/Support/Atomic.h"
+#include "llvm/Support/Compiler.h"
#include <vector>
namespace llvm {
- class PassManagerBase;
-
-//===---------------------------------------------------------------------------
-/// 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)();
-
-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, bool isCFGOnly, bool is_analysis)
- : PassName(name), PassArgument(arg), PassID(pi),
- IsCFGOnlyPass(isCFGOnly),
- IsAnalysis(is_analysis), IsAnalysisGroup(false), NormalCtor(normal) { }
- /// 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; }
-
- /// 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;
- }
-
- /// 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 &); // do not implement
- PassInfo(const PassInfo &); // do not implement
-};
+class TargetMachine;
#define CALL_ONCE_INITIALIZATION(function) \
static volatile sys::cas_flag initialized = 0; \
if (old_val == 0) { \
function(Registry); \
sys::MemoryFence(); \
+ TsanIgnoreWritesBegin(); \
+ TsanHappensBefore(&initialized); \
initialized = 2; \
+ TsanIgnoreWritesEnd(); \
} else { \
sys::cas_flag tmp = initialized; \
sys::MemoryFence(); \
tmp = initialized; \
sys::MemoryFence(); \
} \
- }
+ } \
+ TsanHappensAfter(&initialized);
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis) \
static void* initialize##passName##PassOnce(PassRegistry &Registry) { \
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(); }
+template <typename PassName> Pass *callTargetMachineCtor(TargetMachine *TM) {
+ return new PassName(TM);
+}
+
//===---------------------------------------------------------------------------
/// RegisterPass<t> template - This template class is used to notify the system
/// that a Pass is available for use, and registers it into the internal
}
};
- /// Unique identifiers for the default standard passes. The addresses of
- /// these symbols are used to uniquely identify passes from the default list.
- namespace DefaultStandardPasses {
- extern unsigned char AggressiveDCEID;
- extern unsigned char ArgumentPromotionID;
- extern unsigned char BasicAliasAnalysisID;
- extern unsigned char CFGSimplificationID;
- extern unsigned char ConstantMergeID;
- extern unsigned char CorrelatedValuePropagationID;
- extern unsigned char DeadArgEliminationID;
- extern unsigned char DeadStoreEliminationID;
- extern unsigned char DeadTypeEliminationID;
- extern unsigned char EarlyCSEID;
- extern unsigned char FunctionAttrsID;
- extern unsigned char FunctionInliningID;
- extern unsigned char GVNID;
- extern unsigned char GlobalDCEID;
- extern unsigned char GlobalOptimizerID;
- extern unsigned char GlobalsModRefID;
- extern unsigned char IPSCCPID;
- extern unsigned char IndVarSimplifyID;
- extern unsigned char InlinerPlaceholderID;
- extern unsigned char InstructionCombiningID;
- extern unsigned char JumpThreadingID;
- extern unsigned char LICMID;
- extern unsigned char LoopDeletionID;
- extern unsigned char LoopIdiomID;
- extern unsigned char LoopRotateID;
- extern unsigned char LoopUnrollID;
- extern unsigned char LoopUnswitchID;
- extern unsigned char MemCpyOptID;
- extern unsigned char PruneEHID;
- extern unsigned char ReassociateID;
- extern unsigned char SCCPID;
- extern unsigned char ScalarReplAggregatesID;
- extern unsigned char SimplifyLibCallsID;
- extern unsigned char StripDeadPrototypesID;
- extern unsigned char TailCallEliminationID;
- extern unsigned char TypeBasedAliasAnalysisID;
- }
-
-
-class RegisterStandardPass;
-/// RegisterStandardPass - Registers a pass as a member of a standard set.
-class StandardPass {
- friend class RegisterStandardPassLists;
- public:
- /// Predefined standard sets of passes
- enum StandardSet {
- AliasAnalysis,
- Function,
- Module,
- LTO
- };
- /// Flags to specify whether a pass should be enabled. Passes registered
- /// with the standard sets may specify a minimum optimization level and one
- /// or more flags that must be set when constructing the set for the pass to
- /// be used.
- enum OptimizationFlags {
- /// Optimize for size was requested.
- OptimizeSize = 1<<0,
- /// Allow passes which may make global module changes.
- UnitAtATime = 1<<1,
- /// UnrollLoops - Allow loop unrolling.
- UnrollLoops = 1<<2,
- /// Allow library calls to be simplified.
- SimplifyLibCalls = 1<<3,
- /// Whether the module may have code using exceptions.
- HaveExceptions = 1<<4,
- // Run an inliner pass as part of this set.
- RunInliner = 1<<5
- };
- enum OptimizationFlagComponents {
- /// The low bits are used to store the optimization level. When requesting
- /// passes, this should store the requested optimisation level. When
- /// setting passes, this should set the minimum optimization level at which
- /// the pass will run.
- OptimizationLevelMask = 0xf,
- /// The maximum optimisation level at which the pass is run.
- MaxOptimizationLevelMask = 0xf0,
- // Flags that must be set
- RequiredFlagMask = 0xff00,
- // Flags that may not be set.
- DisallowedFlagMask = 0xff0000,
- MaxOptimizationLevelShift = 4,
- RequiredFlagShift = 8,
- DisallowedFlagShift = 16
- };
- /// Returns the optimisation level from a set of flags.
- static unsigned OptimizationLevel(unsigned flags) {
- return flags & OptimizationLevelMask;
- }
- /// Returns the maximum optimization level for this set of flags
- static unsigned MaxOptimizationLevel(unsigned flags) {
- return (flags & MaxOptimizationLevelMask) >> 4;
- }
- /// Constructs a set of flags from the specified minimum and maximum
- /// optimisation level
- static unsigned OptimizationFlags(unsigned minLevel=0, unsigned maxLevel=0xf,
- unsigned requiredFlags=0,
- unsigned disallowedFlags=0) {
- return ((minLevel & OptimizationLevelMask) |
- ((maxLevel<<MaxOptimizationLevelShift) & MaxOptimizationLevelMask)
- | ((requiredFlags<<RequiredFlagShift) & RequiredFlagMask)
- | ((disallowedFlags<<DisallowedFlagShift) & DisallowedFlagMask));
- }
- /// Returns the flags that must be set for this to match
- static unsigned RequiredFlags(unsigned flags) {
- return (flags & RequiredFlagMask) >> RequiredFlagShift;
- }
- /// Returns the flags that must not be set for this to match
- static unsigned DisallowedFlags(unsigned flags) {
- return (flags & DisallowedFlagMask) >> RequiredFlagShift;
- }
- /// Register a standard pass in the specified set. If flags is non-zero,
- /// then the pass will only be returned when the specified flags are set.
- template<typename passName>
- class RegisterStandardPass {
- RegisterStandardPass(StandardSet set, unsigned char *runBefore=0,
- unsigned flags=0, unsigned char *ID=0) {
- // Use the pass's ID if one is not specified
- RegisterDefaultPass(PassInfo::NormalCtor_t(callDefaultCtor<passName>),
- ID ? ID : &passName::ID, runBefore, set, flags);
- };
- };
- /// Adds the passes from the specified set to a pass manager.
- static void AddPassesFromSet(PassManagerBase *PM,
- StandardSet Set,
- unsigned Flags=0,
- bool VerifyEach=false,
- Pass *Inliner=0);
- private:
- /// Registers the default passes. This is set by RegisterStandardPassLists
- /// and is called lazily.
- static void (*RegisterDefaultPasses)(void);
- /// Registers the pass
- static void RegisterDefaultPass(PassInfo::NormalCtor_t constructor,
- unsigned char *newPass,
- unsigned char *oldPass,
- StandardSet set,
- unsigned flags=0);
-};
-
/// RegisterAnalysisGroup - Register a Pass as a member of an analysis _group_.
/// Analysis groups are used to define an interface (which need not derive from
public:
RegisterAGBase(const char *Name,
const void *InterfaceID,
- const void *PassID = 0,
+ const void *PassID = nullptr,
bool isDefault = false);
};
/// 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.
+/// 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.
projects / oota-llvm.git / blobdiff