//
//===----------------------------------------------------------------------===//
-#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/PassRegistry.h"
#include "llvm/Support/Atomic.h"
+#include "llvm/Support/Valgrind.h"
#include <vector>
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
class PassInfo {
public:
typedef Pass* (*NormalCtor_t)();
+ typedef Pass *(*TargetMachineCtor_t)(TargetMachine *);
private:
const char *const PassName; // Nice name for Pass
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)
+ 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) { }
+ 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(0) { }
+ IsAnalysis(false), IsAnalysisGroup(true), NormalCtor(nullptr),
+ TargetMachineCtor(nullptr) {}
/// getPassName - Return the friendly name for the pass, never returns null
///
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;
}
private:
- void operator=(const PassInfo &); // do not implement
- PassInfo(const PassInfo &); // do not implement
+ void operator=(const PassInfo &) LLVM_DELETED_FUNCTION;
+ PassInfo(const PassInfo &) LLVM_DELETED_FUNCTION;
};
#define CALL_ONCE_INITIALIZATION(function) \
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) { \
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
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
+/// loaded). Deriving from the PassRegistrationListener class automatically
/// registers your object to receive callbacks indicating when passes are loaded
/// and removed.
///