static char ID; // Pass ID, replacement for typeid
DominatorTreeBase<BasicBlock>* DT;
- DominatorTree() : FunctionPass(intptr_t(&ID)) {
+ DominatorTree() : FunctionPass(&ID) {
DT = new DominatorTreeBase<BasicBlock>(false);
}
const bool IsPostDominators;
public:
- DominanceFrontierBase(intptr_t ID, bool isPostDom)
+ DominanceFrontierBase(void *ID, bool isPostDom)
: FunctionPass(ID), IsPostDominators(isPostDom) {}
/// getRoots - Return the root blocks of the current CFG. This may include
public:
static char ID; // Pass ID, replacement for typeid
DominanceFrontier() :
- DominanceFrontierBase(intptr_t(&ID), false) {}
+ DominanceFrontierBase(&ID, false) {}
BasicBlock *getRoot() const {
assert(Roots.size() == 1 && "Should always have entry node!");
std::set<const Type *> UsedTypes;
public:
static char ID; // Pass identification, replacement for typeid
- FindUsedTypes() : ModulePass((intptr_t)&ID) {}
+ FindUsedTypes() : ModulePass(&ID) {}
/// getTypes - After the pass has been run, return the set containing all of
/// the types used in the module.
public:
static char ID; // Pass identification, replacement for typeid
- IntervalPartition() : FunctionPass((intptr_t)&ID), RootInterval(0) {}
+ IntervalPartition() : FunctionPass(&ID), RootInterval(0) {}
// run - Calculate the interval partition for this function
virtual bool runOnFunction(Function &F);
public:
explicit LoopPass(intptr_t pid) : Pass(pid) {}
+ explicit LoopPass(void *pid) : Pass(pid) {}
// runOnLoop - This method should be implemented by the subclass to perform
// whatever action is necessary for the specified Loop.
static Instruction* const Dirty;
static char ID; // Class identification, replacement for typeinfo
- MemoryDependenceAnalysis() : FunctionPass((intptr_t)&ID) {}
+ MemoryDependenceAnalysis() : FunctionPass(&ID) {}
/// Pass Implementation stuff. This doesn't do any analysis.
///
static char ID; // Pass identification, replacement for typeid
DominatorTreeBase<BasicBlock>* DT;
- PostDominatorTree() : FunctionPass((intptr_t)&ID) {
+ PostDominatorTree() : FunctionPass(&ID) {
DT = new DominatorTreeBase<BasicBlock>(true);
}
struct PostDominanceFrontier : public DominanceFrontierBase {
static char ID;
PostDominanceFrontier()
- : DominanceFrontierBase((intptr_t) &ID, true) {}
+ : DominanceFrontierBase(&ID, true) {}
virtual bool runOnFunction(Function &) {
Frontiers.clear();
void *Impl; // ScalarEvolution uses the pimpl pattern
public:
static char ID; // Pass identification, replacement for typeid
- ScalarEvolution() : FunctionPass((intptr_t)&ID), Impl(0) {}
+ ScalarEvolution() : FunctionPass(&ID), Impl(0) {}
/// getSCEV - Return a SCEV expression handle for the full generality of the
/// specified expression.
struct CallGraphSCCPass : public Pass {
explicit CallGraphSCCPass(intptr_t pid) : Pass(pid) {}
+ explicit CallGraphSCCPass(void *pid) : Pass(pid) {}
/// doInitialization - This method is called before the SCC's of the program
/// has been processed, allowing the pass to do initialization as necessary.
public:
static char ID; // Pass identification, replacement for typeid
- LiveIntervals() : MachineFunctionPass((intptr_t)&ID) {}
+ LiveIntervals() : MachineFunctionPass(&ID) {}
struct InstrSlots {
enum {
public:
static char ID; // Pass identification, replacement for typeid
- LiveStacks() : MachineFunctionPass((intptr_t)&ID) {}
+ LiveStacks() : MachineFunctionPass(&ID) {}
typedef SS2IntervalMap::iterator iterator;
typedef SS2IntervalMap::const_iterator const_iterator;
class LiveVariables : public MachineFunctionPass {
public:
static char ID; // Pass identification, replacement for typeid
- LiveVariables() : MachineFunctionPass((intptr_t)&ID) {}
+ LiveVariables() : MachineFunctionPass(&ID) {}
/// VarInfo - This represents the regions where a virtual register is live in
/// the program. We represent this with three different pieces of
struct MachineFunctionPass : public FunctionPass {
explicit MachineFunctionPass(intptr_t ID) : FunctionPass(ID) {}
+ explicit MachineFunctionPass(void *ID) : FunctionPass(ID) {}
protected:
/// runOnMachineFunction - This method must be overloaded to perform the
/// perform the inlining operations that does not depend on the policy.
///
struct Inliner : public CallGraphSCCPass {
- explicit Inliner(const void *ID);
- explicit Inliner(const void *ID, int Threshold);
+ explicit Inliner(void *ID);
+ explicit Inliner(void *ID, int Threshold);
/// getAnalysisUsage - For this class, we declare that we require and preserve
/// the call graph. If the derived class implements this method, it should
/// multiple profilers can be support simultaniously.
struct RSProfilers : public ModulePass {
static char ID; // Pass identification, replacement for typeinfo
- RSProfilers() : ModulePass((intptr_t)&ID) {}
+ RSProfilers() : ModulePass(&ID) {}
/// isProfiling - This method returns true if the value passed it was
/// inserted by the profiler.
BasicBlock *ReturnBlock, *UnwindBlock, *UnreachableBlock;
public:
static char ID; // Pass identification, replacement for typeid
- UnifyFunctionExitNodes() : FunctionPass((intptr_t)&ID),
+ UnifyFunctionExitNodes() : FunctionPass(&ID),
ReturnBlock(0), UnwindBlock(0) {}
// We can preserve non-critical-edgeness when we unify function exit nodes
Module *M;
public:
static char ID; // Class identification, replacement for typeinfo
- AliasAnalysisCounter() : ModulePass((intptr_t) &ID) {
+ AliasAnalysisCounter() : ModulePass(&ID) {
No = May = Must = 0;
NoMR = JustRef = JustMod = MR = 0;
}
public:
static char ID; // Pass identification, replacement for typeid
- AAEval() : FunctionPass((intptr_t)&ID) {}
+ AAEval() : FunctionPass(&ID) {}
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequired<AliasAnalysis>();
public:
static char ID; // Class identification, replacement for typeinfo
- AliasDebugger() : ModulePass((intptr_t)&ID) {}
+ AliasDebugger() : ModulePass(&ID) {}
bool runOnModule(Module &M) {
InitializeAliasAnalysis(this); // set up super class
AliasSetTracker *Tracker;
public:
static char ID; // Pass identification, replacement for typeid
- AliasSetPrinter() : FunctionPass((intptr_t)&ID) {}
+ AliasSetPrinter() : FunctionPass(&ID) {}
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.setPreservesAll();
///
struct VISIBILITY_HIDDEN NoAA : public ImmutablePass, public AliasAnalysis {
static char ID; // Class identification, replacement for typeinfo
- NoAA() : ImmutablePass((intptr_t)&ID) {}
- explicit NoAA(intptr_t PID) : ImmutablePass(PID) { }
+ NoAA() : ImmutablePass(&ID) {}
+ explicit NoAA(void *PID) : ImmutablePass(PID) { }
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequired<TargetData>();
/// derives from the NoAA class.
struct VISIBILITY_HIDDEN BasicAliasAnalysis : public NoAA {
static char ID; // Class identification, replacement for typeinfo
- BasicAliasAnalysis() : NoAA((intptr_t)&ID) { }
+ BasicAliasAnalysis() : NoAA(&ID) {}
AliasResult alias(const Value *V1, unsigned V1Size,
const Value *V2, unsigned V2Size);
namespace {
struct VISIBILITY_HIDDEN CFGViewer : public FunctionPass {
static char ID; // Pass identifcation, replacement for typeid
- CFGViewer() : FunctionPass((intptr_t)&ID) {}
+ CFGViewer() : FunctionPass(&ID) {}
virtual bool runOnFunction(Function &F) {
F.viewCFG();
namespace {
struct VISIBILITY_HIDDEN CFGOnlyViewer : public FunctionPass {
static char ID; // Pass identifcation, replacement for typeid
- CFGOnlyViewer() : FunctionPass((intptr_t)&ID) {}
+ CFGOnlyViewer() : FunctionPass(&ID) {}
virtual bool runOnFunction(Function &F) {
CFGOnly = true;
namespace {
struct VISIBILITY_HIDDEN CFGPrinter : public FunctionPass {
static char ID; // Pass identification, replacement for typeid
- CFGPrinter() : FunctionPass((intptr_t)&ID) {}
- explicit CFGPrinter(intptr_t pid) : FunctionPass(pid) {}
+ CFGPrinter() : FunctionPass(&ID) {}
+ explicit CFGPrinter(void *pid) : FunctionPass(pid) {}
virtual bool runOnFunction(Function &F) {
std::string Filename = "cfg." + F.getName() + ".dot";
namespace {
struct VISIBILITY_HIDDEN CFGOnlyPrinter : public CFGPrinter {
static char ID; // Pass identification, replacement for typeid
- CFGOnlyPrinter() : CFGPrinter((intptr_t)&ID) {}
+ CFGOnlyPrinter() : CFGPrinter(&ID) {}
virtual bool runOnFunction(Function &F) {
bool OldCFGOnly = CFGOnly;
CFGOnly = true;
public:
static char ID;
- Andersens() : ModulePass((intptr_t)&ID) {}
+ Andersens() : ModulePass(&ID) {}
bool runOnModule(Module &M) {
InitializeAliasAnalysis(this);
public:
static char ID; // Class identification, replacement for typeinfo
- BasicCallGraph() : ModulePass((intptr_t)&ID), Root(0),
+ BasicCallGraph() : ModulePass(&ID), Root(0),
ExternalCallingNode(0), CallsExternalNode(0) {}
// runOnModule - Compute the call graph for the specified module.
public:
static char ID;
explicit CGPassManager(int Depth)
- : ModulePass((intptr_t)&ID), PMDataManager(Depth) { }
+ : ModulePass(&ID), PMDataManager(Depth) { }
/// run - Execute all of the passes scheduled for execution. Keep track of
/// whether any of the passes modifies the module, and if so, return true.
public:
static char ID;
- GlobalsModRef() : ModulePass((intptr_t)&ID) {}
+ GlobalsModRef() : ModulePass(&ID) {}
bool runOnModule(Module &M) {
InitializeAliasAnalysis(this); // set up super class
}
public:
static char ID; // Pass identification, replacement for typeid
- InstCount() : FunctionPass((intptr_t)&ID) {}
+ InstCount() : FunctionPass(&ID) {}
virtual bool runOnFunction(Function &F);
// distinguish it from a copy constructor. Always pass in false for now.
//
IntervalPartition::IntervalPartition(IntervalPartition &IP, bool)
- : FunctionPass((intptr_t) &ID) {
+ : FunctionPass(&ID) {
assert(IP.getRootInterval() && "Cannot operate on empty IntervalPartitions!");
// Pass false to intervals_begin because we take ownership of it's memory
/// LPPassManager manages FPPassManagers and CalLGraphSCCPasses.
LPPassManager::LPPassManager(int Depth)
- : FunctionPass((intptr_t)&ID), PMDataManager(Depth) {
+ : FunctionPass(&ID), PMDataManager(Depth) {
skipThisLoop = false;
redoThisLoop = false;
LI = NULL;
struct VISIBILITY_HIDDEN NoProfileInfo
: public ImmutablePass, public ProfileInfo {
static char ID; // Class identification, replacement for typeinfo
- NoProfileInfo() : ImmutablePass((intptr_t)&ID) {}
+ NoProfileInfo() : ImmutablePass(&ID) {}
};
} // End of anonymous namespace
public:
static char ID; // Class identification, replacement for typeinfo
explicit LoaderPass(const std::string &filename = "")
- : ModulePass((intptr_t)&ID), Filename(filename) {
+ : ModulePass(&ID), Filename(filename) {
if (filename.empty()) Filename = ProfileInfoFilename;
}
public:
static char ID; // Pass identifcation, replacement for typeid
explicit WriteBitcodePass(std::ostream &o)
- : ModulePass((intptr_t) &ID), Out(o) {}
+ : ModulePass(&ID), Out(o) {}
const char *getPassName() const { return "Bitcode Writer"; }
char AsmPrinter::ID = 0;
AsmPrinter::AsmPrinter(raw_ostream &o, TargetMachine &tm,
const TargetAsmInfo *T)
- : MachineFunctionPass((intptr_t)&ID), FunctionNumber(0), O(o),
+ : MachineFunctionPass(&ID), FunctionNumber(0), O(o),
TM(tm), TAI(T), TRI(tm.getRegisterInfo()),
IsInTextSection(false)
{}
struct VISIBILITY_HIDDEN BranchFolder : public MachineFunctionPass {
static char ID;
explicit BranchFolder(bool defaultEnableTailMerge) :
- MachineFunctionPass((intptr_t)&ID) {
+ MachineFunctionPass(&ID) {
switch (FlagEnableTailMerge) {
case cl::BOU_UNSET: EnableTailMerge = defaultEnableTailMerge; break;
case cl::BOU_TRUE: EnableTailMerge = true; break;
//===----------------------------------------------------------------------===//
ELFWriter::ELFWriter(raw_ostream &o, TargetMachine &tm)
- : MachineFunctionPass((intptr_t)&ID), O(o), TM(tm) {
+ : MachineFunctionPass(&ID), O(o), TM(tm) {
e_flags = 0; // e_flags defaults to 0, no flags.
is64Bit = TM.getTargetData()->getPointerSizeInBits() == 64;
char GCModuleInfo::ID = 0;
GCModuleInfo::GCModuleInfo()
- : ImmutablePass((intptr_t)&ID) {}
+ : ImmutablePass(&ID) {}
GCModuleInfo::~GCModuleInfo() {
clear();
char LowerIntrinsics::ID = 0;
LowerIntrinsics::LowerIntrinsics()
- : FunctionPass((intptr_t)&ID) {}
+ : FunctionPass(&ID) {}
const char *LowerIntrinsics::getPassName() const {
return "Lower Garbage Collection Instructions";
bool MadeChange;
public:
static char ID;
- IfConverter() : MachineFunctionPass((intptr_t)&ID) {}
+ IfConverter() : MachineFunctionPass(&ID) {}
virtual bool runOnMachineFunction(MachineFunction &MF);
virtual const char *getPassName() const { return "If Converter"; }
class LoopAligner : public MachineFunctionPass {
public:
static char ID;
- LoopAligner() : MachineFunctionPass((intptr_t)&ID) {}
+ LoopAligner() : MachineFunctionPass(&ID) {}
virtual bool runOnMachineFunction(MachineFunction &MF);
virtual const char *getPassName() const { return "Loop aligner"; }
struct VISIBILITY_HIDDEN LowerSubregsInstructionPass
: public MachineFunctionPass {
static char ID; // Pass identification, replacement for typeid
- LowerSubregsInstructionPass() : MachineFunctionPass((intptr_t)&ID) {}
+ LowerSubregsInstructionPass() : MachineFunctionPass(&ID) {}
const char *getPassName() const {
return "Subregister lowering instruction pass";
char MachOWriter::ID = 0;
MachOWriter::MachOWriter(raw_ostream &o, TargetMachine &tm)
- : MachineFunctionPass((intptr_t)&ID), O(o), TM(tm) {
+ : MachineFunctionPass(&ID), O(o), TM(tm) {
is64Bit = TM.getTargetData()->getPointerSizeInBits() == 64;
isLittleEndian = TM.getTargetData()->isLittleEndian();
const std::string Banner;
Printer (std::ostream *os, const std::string &banner)
- : MachineFunctionPass((intptr_t)&ID), OS(os), Banner(banner) {}
+ : MachineFunctionPass(&ID), OS(os), Banner(banner) {}
const char *getPassName() const { return "MachineFunction Printer"; }
namespace {
struct VISIBILITY_HIDDEN Deleter : public MachineFunctionPass {
static char ID;
- Deleter() : MachineFunctionPass((intptr_t)&ID) {}
+ Deleter() : MachineFunctionPass(&ID) {}
const char *getPassName() const { return "Machine Code Deleter"; }
MachineLoop *CurLoop; // The current loop we are working on.
public:
static char ID; // Pass identification, replacement for typeid
- MachineLICM() : MachineFunctionPass((intptr_t)&ID) {}
+ MachineLICM() : MachineFunctionPass(&ID) {}
virtual bool runOnMachineFunction(MachineFunction &MF);
//===----------------------------------------------------------------------===//
MachineModuleInfo::MachineModuleInfo()
-: ImmutablePass((intptr_t)&ID)
+: ImmutablePass(&ID)
, DR()
, VR()
, CompileUnits()
struct DebugLabelFolder : public MachineFunctionPass {
static char ID;
- DebugLabelFolder() : MachineFunctionPass((intptr_t)&ID) {}
+ DebugLabelFolder() : MachineFunctionPass(&ID) {}
virtual bool runOnMachineFunction(MachineFunction &MF);
virtual const char *getPassName() const { return "Label Folder"; }
public:
static char ID; // Pass identification
- MachineSinking() : MachineFunctionPass((intptr_t)&ID) {}
+ MachineSinking() : MachineFunctionPass(&ID) {}
virtual bool runOnMachineFunction(MachineFunction &MF);
public:
static char ID; // Pass identification, replacement for typeid
- PNE() : MachineFunctionPass((intptr_t)&ID) {}
+ PNE() : MachineFunctionPass(&ID) {}
virtual bool runOnMachineFunction(MachineFunction &Fn);
class VISIBILITY_HIDDEN SchedulePostRATDList : public MachineFunctionPass {
public:
static char ID;
- SchedulePostRATDList() : MachineFunctionPass((intptr_t)&ID) {}
+ SchedulePostRATDList() : MachineFunctionPass(&ID) {}
private:
MachineFunction *MF;
const TargetMachine *TM;
namespace {
struct VISIBILITY_HIDDEN PEI : public MachineFunctionPass {
static char ID;
- PEI() : MachineFunctionPass((intptr_t)&ID) {}
+ PEI() : MachineFunctionPass(&ID) {}
const char *getPassName() const {
return "Prolog/Epilog Insertion & Frame Finalization";
class VISIBILITY_HIDDEN RABigBlock : public MachineFunctionPass {
public:
static char ID;
- RABigBlock() : MachineFunctionPass((intptr_t)&ID) {}
+ RABigBlock() : MachineFunctionPass(&ID) {}
private:
/// TM - For getting at TargetMachine info
///
namespace {
struct VISIBILITY_HIDDEN RALinScan : public MachineFunctionPass {
static char ID;
- RALinScan() : MachineFunctionPass((intptr_t)&ID) {}
+ RALinScan() : MachineFunctionPass(&ID) {}
typedef std::pair<LiveInterval*, LiveInterval::iterator> IntervalPtr;
typedef SmallVector<IntervalPtr, 32> IntervalPtrs;
class VISIBILITY_HIDDEN RALocal : public MachineFunctionPass {
public:
static char ID;
- RALocal() : MachineFunctionPass((intptr_t)&ID),
- StackSlotForVirtReg(-1) {}
+ RALocal() : MachineFunctionPass(&ID), StackSlotForVirtReg(-1) {}
private:
const TargetMachine *TM;
MachineFunction *MF;
class VISIBILITY_HIDDEN RegAllocSimple : public MachineFunctionPass {
public:
static char ID;
- RegAllocSimple() : MachineFunctionPass((intptr_t)&ID) {}
+ RegAllocSimple() : MachineFunctionPass(&ID) {}
private:
MachineFunction *MF;
const TargetMachine *TM;
//===----------------------------------------------------------------------===//
SelectionDAGISel::SelectionDAGISel(TargetLowering &tli, bool fast) :
- FunctionPass((intptr_t)&ID), TLI(tli),
+ FunctionPass(&ID), TLI(tli),
FuncInfo(new FunctionLoweringInfo(TLI)),
CurDAG(new SelectionDAG(TLI, *FuncInfo)),
SDL(new SelectionDAGLowering(*CurDAG, TLI, *FuncInfo)),
public:
static char ID; // Pass identifcation, replacement for typeid
- SimpleRegisterCoalescing() : MachineFunctionPass((intptr_t)&ID) {}
+ SimpleRegisterCoalescing() : MachineFunctionPass(&ID) {}
struct InstrSlots {
enum {
public:
static char ID; // Pass identification
- StackSlotColoring() : MachineFunctionPass((intptr_t)&ID), NextColor(-1) {}
+ StackSlotColoring() : MachineFunctionPass(&ID), NextColor(-1) {}
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequired<LiveStacks>();
namespace {
struct VISIBILITY_HIDDEN StrongPHIElimination : public MachineFunctionPass {
static char ID; // Pass identification, replacement for typeid
- StrongPHIElimination() : MachineFunctionPass((intptr_t)&ID) {}
+ StrongPHIElimination() : MachineFunctionPass(&ID) {}
// Waiting stores, for each MBB, the set of copies that need to
// be inserted into that MBB
DenseMap<MachineInstr*, unsigned> &DistanceMap);
public:
static char ID; // Pass identification, replacement for typeid
- TwoAddressInstructionPass() : MachineFunctionPass((intptr_t)&ID) {}
+ TwoAddressInstructionPass() : MachineFunctionPass(&ID) {}
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.addPreserved<LiveVariables>();
virtual bool runOnFunction(Function &F);
public:
static char ID; // Pass identification, replacement for typeid
- UnreachableBlockElim() : FunctionPass((intptr_t)&ID) {}
+ UnreachableBlockElim() : FunctionPass(&ID) {}
};
}
char UnreachableBlockElim::ID = 0;
public:
static char ID; // Pass identification, replacement for typeid
- UnreachableMachineBlockElim() : MachineFunctionPass((intptr_t)&ID) {}
+ UnreachableMachineBlockElim() : MachineFunctionPass(&ID) {}
};
}
char UnreachableMachineBlockElim::ID = 0;
public:
static char ID;
explicit ARMCodeEmitter(TargetMachine &tm, MachineCodeEmitter &mce)
- : MachineFunctionPass((intptr_t)&ID), II(0), TD(0), TM(tm),
+ : MachineFunctionPass(&ID), II(0), TD(0), TM(tm),
MCE(mce) {}
ARMCodeEmitter(TargetMachine &tm, MachineCodeEmitter &mce,
const ARMInstrInfo &ii, const TargetData &td)
- : MachineFunctionPass((intptr_t)&ID), II(&ii), TD(&td), TM(tm),
+ : MachineFunctionPass(&ID), II(&ii), TD(&td), TM(tm),
MCE(mce) {}
bool runOnMachineFunction(MachineFunction &MF);
bool isThumb;
public:
static char ID;
- ARMConstantIslands() : MachineFunctionPass((intptr_t)&ID) {}
+ ARMConstantIslands() : MachineFunctionPass(&ID) {}
virtual bool runOnMachineFunction(MachineFunction &Fn);
namespace {
struct VISIBILITY_HIDDEN ARMLoadStoreOpt : public MachineFunctionPass {
static char ID;
- ARMLoadStoreOpt() : MachineFunctionPass((intptr_t)&ID) {}
+ ARMLoadStoreOpt() : MachineFunctionPass(&ID) {}
const TargetInstrInfo *TII;
const TargetRegisterInfo *TRI;
namespace {
struct VISIBILITY_HIDDEN AlphaBSel : public MachineFunctionPass {
static char ID;
- AlphaBSel() : MachineFunctionPass((intptr_t)&ID) {}
+ AlphaBSel() : MachineFunctionPass(&ID) {}
virtual bool runOnMachineFunction(MachineFunction &Fn);
public:
static char ID;
explicit AlphaCodeEmitter(TargetMachine &tm, MachineCodeEmitter &mce)
- : MachineFunctionPass((intptr_t)&ID), II(0), TM(tm), MCE(mce) {}
+ : MachineFunctionPass(&ID), II(0), TM(tm), MCE(mce) {}
AlphaCodeEmitter(TargetMachine &tm, MachineCodeEmitter &mce,
const AlphaInstrInfo& ii)
- : MachineFunctionPass((intptr_t)&ID), II(&ii), TM(tm), MCE(mce) {}
+ : MachineFunctionPass(&ID), II(&ii), TM(tm), MCE(mce) {}
bool runOnMachineFunction(MachineFunction &MF);
static char ID;
AlphaLLRPPass(AlphaTargetMachine &tm)
- : MachineFunctionPass((intptr_t)&ID), TM(tm) { }
+ : MachineFunctionPass(&ID), TM(tm) { }
virtual const char *getPassName() const {
return "Alpha NOP inserter";
public:
static char ID;
CBackendNameAllUsedStructsAndMergeFunctions()
- : ModulePass((intptr_t)&ID) {}
+ : ModulePass(&ID) {}
void getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequired<FindUsedTypes>();
}
public:
static char ID;
explicit CWriter(raw_ostream &o)
- : FunctionPass((intptr_t)&ID), Out(o), IL(0), Mang(0), LI(0),
+ : FunctionPass(&ID), Out(o), IL(0), Mang(0), LI(0),
TheModule(0), TAsm(0), TD(0) {}
virtual const char *getPassName() const { return "C backend"; }
public:
static char ID;
explicit CppWriter(raw_ostream &o) :
- ModulePass((intptr_t)&ID), Out(o), uniqueNum(0), is_inline(false) {}
+ ModulePass(&ID), Out(o), uniqueNum(0), is_inline(false) {}
virtual const char *getPassName() const { return "C++ backend"; }
IA64TargetMachine &TM;
IA64BundlingPass(IA64TargetMachine &tm)
- : MachineFunctionPass((intptr_t)&ID), TM(tm) { }
+ : MachineFunctionPass(&ID), TM(tm) { }
virtual const char *getPassName() const {
return "IA64 (Itanium) Bundling Pass";
static char ID;
MSILModule(const std::set<const Type *>*& _UsedTypes,
const TargetData*& _TD)
- : ModulePass((intptr_t)&ID), UsedTypes(_UsedTypes), TD(_TD) {}
+ : ModulePass(&ID), UsedTypes(_UsedTypes), TD(_TD) {}
void getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequired<FindUsedTypes>();
StaticInitList;
const std::set<const Type *>* UsedTypes;
static char ID;
- MSILWriter(raw_ostream &o) : FunctionPass((intptr_t)&ID), Out(o) {
+ MSILWriter(raw_ostream &o) : FunctionPass(&ID), Out(o) {
UniqID = 0;
}
static char ID;
Filler(TargetMachine &tm)
- : MachineFunctionPass((intptr_t)&ID), TM(tm), TII(tm.getInstrInfo()) { }
+ : MachineFunctionPass(&ID), TM(tm), TII(tm.getInstrInfo()) { }
virtual const char *getPassName() const {
return "Mips Delay Slot Filler";
namespace {
struct VISIBILITY_HIDDEN PPCBSel : public MachineFunctionPass {
static char ID;
- PPCBSel() : MachineFunctionPass((intptr_t)&ID) {}
+ PPCBSel() : MachineFunctionPass(&ID) {}
/// BlockSizes - The sizes of the basic blocks in the function.
std::vector<unsigned> BlockSizes;
public:
static char ID;
PPCCodeEmitter(TargetMachine &T, MachineCodeEmitter &M)
- : MachineFunctionPass((intptr_t)&ID), TM(T), MCE(M) {}
+ : MachineFunctionPass(&ID), TM(T), MCE(M) {}
const char *getPassName() const { return "PowerPC Machine Code Emitter"; }
static char ID;
Filler(TargetMachine &tm)
- : MachineFunctionPass((intptr_t)&ID), TM(tm), TII(tm.getInstrInfo()) { }
+ : MachineFunctionPass(&ID), TM(tm), TII(tm.getInstrInfo()) { }
virtual const char *getPassName() const {
return "SPARC Delay Slot Filler";
static char ID;
FPMover(TargetMachine &tm)
- : MachineFunctionPass((intptr_t)&ID), TM(tm) { }
+ : MachineFunctionPass(&ID), TM(tm) { }
virtual const char *getPassName() const {
return "Sparc Double-FP Move Fixer";
}
TargetData::TargetData(const Module *M)
- : ImmutablePass((intptr_t)&ID) {
+ : ImmutablePass(&ID) {
init(M->getDataLayout());
}
public:
static char ID;
explicit Emitter(X86TargetMachine &tm, MachineCodeEmitter &mce)
- : MachineFunctionPass((intptr_t)&ID), II(0), TD(0), TM(tm),
+ : MachineFunctionPass(&ID), II(0), TD(0), TM(tm),
MCE(mce), PICBaseOffset(0), Is64BitMode(false),
IsPIC(TM.getRelocationModel() == Reloc::PIC_) {}
Emitter(X86TargetMachine &tm, MachineCodeEmitter &mce,
const X86InstrInfo &ii, const TargetData &td, bool is64)
- : MachineFunctionPass((intptr_t)&ID), II(&ii), TD(&td), TM(tm),
+ : MachineFunctionPass(&ID), II(&ii), TD(&td), TM(tm),
MCE(mce), PICBaseOffset(0), Is64BitMode(is64),
IsPIC(TM.getRelocationModel() == Reloc::PIC_) {}
namespace {
struct VISIBILITY_HIDDEN FPS : public MachineFunctionPass {
static char ID;
- FPS() : MachineFunctionPass((intptr_t)&ID) {}
+ FPS() : MachineFunctionPass(&ID) {}
virtual bool runOnMachineFunction(MachineFunction &MF);
namespace {
struct VISIBILITY_HIDDEN MSAC : public MachineFunctionPass {
static char ID;
- MSAC() : MachineFunctionPass((intptr_t)&ID) {}
+ MSAC() : MachineFunctionPass(&ID) {}
virtual bool runOnMachineFunction(MachineFunction &MF) {
MachineFrameInfo *FFI = MF.getFrameInfo();
// Hello - The first implementation, without getAnalysisUsage.
struct Hello : public FunctionPass {
static char ID; // Pass identification, replacement for typeid
- Hello() : FunctionPass((intptr_t)&ID) {}
+ Hello() : FunctionPass(&ID) {}
virtual bool runOnFunction(Function &F) {
HelloCounter++;
// Hello2 - The second implementation with getAnalysisUsage implemented.
struct Hello2 : public FunctionPass {
static char ID; // Pass identification, replacement for typeid
- Hello2() : FunctionPass((intptr_t)&ID) {}
+ Hello2() : FunctionPass(&ID) {}
virtual bool runOnFunction(Function &F) {
HelloCounter++;
virtual bool runOnSCC(const std::vector<CallGraphNode *> &SCC);
static char ID; // Pass identification, replacement for typeid
- ArgPromotion(unsigned maxElements = 3) : CallGraphSCCPass((intptr_t)&ID),
+ ArgPromotion(unsigned maxElements = 3) : CallGraphSCCPass(&ID),
maxElements(maxElements) {}
/// A vector used to hold the indices of a single GEP instruction
namespace {
struct VISIBILITY_HIDDEN ConstantMerge : public ModulePass {
static char ID; // Pass identification, replacement for typeid
- ConstantMerge() : ModulePass((intptr_t)&ID) {}
+ ConstantMerge() : ModulePass(&ID) {}
// run - For this pass, process all of the globals in the module,
// eliminating duplicate constants.
public:
static char ID; // Pass identification, replacement for typeid
- DAE() : ModulePass((intptr_t)&ID) {}
+ DAE() : ModulePass(&ID) {}
bool runOnModule(Module &M);
virtual bool ShouldHackArguments() const { return false; }
namespace {
struct VISIBILITY_HIDDEN DTE : public ModulePass {
static char ID; // Pass identification, replacement for typeid
- DTE() : ModulePass((intptr_t)&ID) {}
+ DTE() : ModulePass(&ID) {}
// doPassInitialization - For this pass, it removes global symbol table
// entries for primitive types. These are never used for linking in GCC and
///
explicit GVExtractorPass(std::vector<GlobalValue*>& GVs, bool deleteS = true,
bool relinkCallees = false)
- : ModulePass((intptr_t)&ID), Named(GVs), deleteStuff(deleteS),
+ : ModulePass(&ID), Named(GVs), deleteStuff(deleteS),
reLink(relinkCallees) {}
bool runOnModule(Module &M) {
namespace {
struct VISIBILITY_HIDDEN GlobalDCE : public ModulePass {
static char ID; // Pass identification, replacement for typeid
- GlobalDCE() : ModulePass((intptr_t)&ID) {}
+ GlobalDCE() : ModulePass(&ID) {}
// run - Do the GlobalDCE pass on the specified module, optionally updating
// the specified callgraph to reflect the changes.
AU.addRequired<TargetData>();
}
static char ID; // Pass identification, replacement for typeid
- GlobalOpt() : ModulePass((intptr_t)&ID) {}
+ GlobalOpt() : ModulePass(&ID) {}
bool runOnModule(Module &M);
///
struct VISIBILITY_HIDDEN IPCP : public ModulePass {
static char ID; // Pass identification, replacement for typeid
- IPCP() : ModulePass((intptr_t)&ID) {}
+ IPCP() : ModulePass(&ID) {}
bool runOnModule(Module &M);
private:
class VISIBILITY_HIDDEN IndMemRemPass : public ModulePass {
public:
static char ID; // Pass identification, replacement for typeid
- IndMemRemPass() : ModulePass((intptr_t)&ID) {}
+ IndMemRemPass() : ModulePass(&ID) {}
virtual bool runOnModule(Module &M);
};
InlineLimit("inline-threshold", cl::Hidden, cl::init(200),
cl::desc("Control the amount of inlining to perform (default = 200)"));
-Inliner::Inliner(const void *ID)
- : CallGraphSCCPass((intptr_t)ID), InlineThreshold(InlineLimit) {}
+Inliner::Inliner(void *ID)
+ : CallGraphSCCPass(ID), InlineThreshold(InlineLimit) {}
-Inliner::Inliner(const void *ID, int Threshold)
- : CallGraphSCCPass((intptr_t)ID), InlineThreshold(Threshold) {}
+Inliner::Inliner(void *ID, int Threshold)
+ : CallGraphSCCPass(ID), InlineThreshold(Threshold) {}
/// getAnalysisUsage - For this class, we declare that we require and preserve
/// the call graph. If the derived class implements this method, it should
X("internalize", "Internalize Global Symbols");
InternalizePass::InternalizePass(bool AllButMain)
- : ModulePass((intptr_t)&ID), AllButMain(AllButMain){
+ : ModulePass(&ID), AllButMain(AllButMain){
if (!APIFile.empty()) // If a filename is specified, use it.
LoadFile(APIFile.c_str());
if (!APIList.empty()) // If a list is specified, use it as well.
}
InternalizePass::InternalizePass(const std::vector<const char *>&exportList)
- : ModulePass((intptr_t)&ID), AllButMain(false){
+ : ModulePass(&ID), AllButMain(false){
for(std::vector<const char *>::const_iterator itr = exportList.begin();
itr != exportList.end(); itr++) {
ExternalNames.insert(*itr);
unsigned NumLoops;
explicit LoopExtractor(unsigned numLoops = ~0)
- : FunctionPass((intptr_t)&ID), NumLoops(numLoops) {}
+ : FunctionPass(&ID), NumLoops(numLoops) {}
virtual bool runOnFunction(Function &F);
public:
static char ID; // Pass identification, replacement for typeid
explicit BlockExtractorPass(const std::vector<BasicBlock*> &B)
- : ModulePass((intptr_t)&ID), BlocksToNotExtract(B) {
+ : ModulePass(&ID), BlocksToNotExtract(B) {
if (!BlockFile.empty())
LoadFile(BlockFile.c_str());
}
- BlockExtractorPass() : ModulePass((intptr_t)&ID) {}
+ BlockExtractorPass() : ModulePass(&ID) {}
bool runOnModule(Module &M);
};
bool IsTransformableFunction(const std::string& Name);
public:
static char ID; // Pass identification, replacement for typeid
- LowerSetJmp() : ModulePass((intptr_t)&ID) {}
+ LowerSetJmp() : ModulePass(&ID) {}
void visitCallInst(CallInst& CI);
void visitInvokeInst(InvokeInst& II);
int scanDistribution(Function&, int, std::map<Constant*, int>&);
public :
static char ID; // Pass identification, replacement for typeid
- PartSpec() : ModulePass((intptr_t)&ID) {}
+ PartSpec() : ModulePass(&ID) {}
bool runOnModule(Module &M);
};
}
namespace {
struct VISIBILITY_HIDDEN PruneEH : public CallGraphSCCPass {
static char ID; // Pass identification, replacement for typeid
- PruneEH() : CallGraphSCCPass((intptr_t)&ID) {}
+ PruneEH() : CallGraphSCCPass(&ID) {}
// runOnSCC - Analyze the SCC, performing the transformation if possible.
bool runOnSCC(const std::vector<CallGraphNode *> &SCC);
public:
static char ID; // Pass identification, replacement for typeid
RaiseAllocations()
- : ModulePass((intptr_t)&ID), MallocFunc(0), FreeFunc(0) {}
+ : ModulePass(&ID), MallocFunc(0), FreeFunc(0) {}
// doPassInitialization - For the raise allocations pass, this finds a
// declaration for malloc and free if they exist.
class VISIBILITY_HIDDEN StripDeadPrototypesPass : public ModulePass {
public:
static char ID; // Pass identification, replacement for typeid
- StripDeadPrototypesPass() : ModulePass((intptr_t)&ID) { }
+ StripDeadPrototypesPass() : ModulePass(&ID) { }
virtual bool runOnModule(Module &M);
};
public:
static char ID; // Pass identification, replacement for typeid
explicit StripSymbols(bool ODI = false)
- : ModulePass((intptr_t)&ID), OnlyDebugInfo(ODI) {}
+ : ModulePass(&ID), OnlyDebugInfo(ODI) {}
virtual bool runOnModule(Module &M);
virtual bool runOnSCC(const std::vector<CallGraphNode *> &SCC);
static char ID; // Pass identification, replacement for typeid
- SRETPromotion() : CallGraphSCCPass((intptr_t)&ID) {}
+ SRETPromotion() : CallGraphSCCPass(&ID) {}
private:
bool PromoteReturn(CallGraphNode *CGN);
bool runOnModule(Module &M);
public:
static char ID; // Pass identification, replacement for typeid
- EdgeProfiler() : ModulePass((intptr_t)&ID) {}
+ EdgeProfiler() : ModulePass(&ID) {}
};
}
/// ProfilerRS - Insert the random sampling framework
struct VISIBILITY_HIDDEN ProfilerRS : public FunctionPass {
static char ID; // Pass identification, replacement for typeid
- ProfilerRS() : FunctionPass((intptr_t)&ID) {}
+ ProfilerRS() : FunctionPass(&ID) {}
std::map<Value*, Value*> TransCache;
std::set<BasicBlock*> ChoicePoints;
namespace {
struct VISIBILITY_HIDDEN ADCE : public FunctionPass {
static char ID; // Pass identification, replacement for typeid
- ADCE() : FunctionPass((intptr_t)&ID) {}
+ ADCE() : FunctionPass(&ID) {}
virtual bool runOnFunction(Function& F);
namespace {
struct VISIBILITY_HIDDEN BlockPlacement : public FunctionPass {
static char ID; // Pass identification, replacement for typeid
- BlockPlacement() : FunctionPass((intptr_t)&ID) {}
+ BlockPlacement() : FunctionPass(&ID) {}
virtual bool runOnFunction(Function &F);
public:
static char ID; // Pass identification, replacement for typeid
explicit CodeGenPrepare(const TargetLowering *tli = 0)
- : FunctionPass((intptr_t)&ID), TLI(tli) {}
+ : FunctionPass(&ID), TLI(tli) {}
bool runOnFunction(Function &F);
private:
namespace {
struct VISIBILITY_HIDDEN CondProp : public FunctionPass {
static char ID; // Pass identification, replacement for typeid
- CondProp() : FunctionPass((intptr_t)&ID) {}
+ CondProp() : FunctionPass(&ID) {}
virtual bool runOnFunction(Function &F);
namespace {
struct VISIBILITY_HIDDEN ConstantPropagation : public FunctionPass {
static char ID; // Pass identification, replacement for typeid
- ConstantPropagation() : FunctionPass((intptr_t)&ID) {}
+ ConstantPropagation() : FunctionPass(&ID) {}
bool runOnFunction(Function &F);
//
struct DCE : public FunctionPass {
static char ID; // Pass identification, replacement for typeid
- DCE() : FunctionPass((intptr_t)&ID) {}
+ DCE() : FunctionPass(&ID) {}
virtual bool runOnFunction(Function &F);
namespace {
struct VISIBILITY_HIDDEN DSE : public FunctionPass {
static char ID; // Pass identification, replacement for typeid
- DSE() : FunctionPass((intptr_t)&ID) {}
+ DSE() : FunctionPass(&ID) {}
virtual bool runOnFunction(Function &F) {
bool Changed = false;
bool runOnFunction(Function &F);
public:
static char ID; // Pass identification, replacement for typeid
- GVN() : FunctionPass((intptr_t)&ID) { }
+ GVN() : FunctionPass(&ID) { }
private:
ValueTable VN;
bool runOnFunction(Function &F);
public:
static char ID; // Pass identification, replacement for typeid
- GVNPRE() : FunctionPass((intptr_t)&ID) { }
+ GVNPRE() : FunctionPass(&ID) {}
private:
ValueTable VN;
public:
static char ID; // Pass identification, replacement for typeid
- IndVarSimplify() : LoopPass((intptr_t)&ID) {}
+ IndVarSimplify() : LoopPass(&ID) {}
bool runOnLoop(Loop *L, LPPassManager &LPM);
bool doInitialization(Loop *L, LPPassManager &LPM);
bool MustPreserveLCSSA;
public:
static char ID; // Pass identification, replacement for typeid
- InstCombiner() : FunctionPass((intptr_t)&ID) {}
+ InstCombiner() : FunctionPass(&ID) {}
/// AddToWorkList - Add the specified instruction to the worklist if it
/// isn't already in it.
class VISIBILITY_HIDDEN JumpThreading : public FunctionPass {
public:
static char ID; // Pass identification
- JumpThreading() : FunctionPass((intptr_t)&ID) {}
+ JumpThreading() : FunctionPass(&ID) {}
bool runOnFunction(Function &F);
bool ThreadBlock(BasicBlock *BB);
namespace {
struct VISIBILITY_HIDDEN LICM : public LoopPass {
static char ID; // Pass identification, replacement for typeid
- LICM() : LoopPass((intptr_t)&ID) {}
+ LICM() : LoopPass(&ID) {}
virtual bool runOnLoop(Loop *L, LPPassManager &LPM);
class VISIBILITY_HIDDEN LoopDeletion : public LoopPass {
public:
static char ID; // Pass ID, replacement for typeid
- LoopDeletion() : LoopPass((intptr_t)&ID) { }
+ LoopDeletion() : LoopPass(&ID) {}
// Possibly eliminate loop L if it is dead.
bool runOnLoop(Loop* L, LPPassManager& LPM);
public:
static char ID; // Pass ID, replacement for typeid
- LoopIndexSplit() : LoopPass((intptr_t)&ID) {}
+ LoopIndexSplit() : LoopPass(&ID) {}
// Index split Loop L. Return true if loop is split.
bool runOnLoop(Loop *L, LPPassManager &LPM);
public:
static char ID; // Pass ID, replacement for typeid
- LoopRotate() : LoopPass((intptr_t)&ID) {}
+ LoopRotate() : LoopPass(&ID) {}
// Rotate Loop L as many times as possible. Return true if
// loop is rotated at least once.
public:
static char ID; // Pass ID, replacement for typeid
explicit LoopStrengthReduce(const TargetLowering *tli = NULL) :
- LoopPass((intptr_t)&ID), TLI(tli) {
+ LoopPass(&ID), TLI(tli) {
}
bool runOnLoop(Loop *L, LPPassManager &LPM);
class VISIBILITY_HIDDEN LoopUnroll : public LoopPass {
public:
static char ID; // Pass ID, replacement for typeid
- LoopUnroll() : LoopPass((intptr_t)&ID) {}
+ LoopUnroll() : LoopPass(&ID) {}
/// A magic value for use with the Threshold parameter to indicate
/// that the loop unroll should be performed regardless of how much
public:
static char ID; // Pass ID, replacement for typeid
explicit LoopUnswitch(bool Os = false) :
- LoopPass((intptr_t)&ID), OptimizeForSize(Os), redoLoop(false),
+ LoopPass(&ID), OptimizeForSize(Os), redoLoop(false),
currentLoop(NULL), DF(NULL), DT(NULL), loopHeader(NULL),
loopPreheader(NULL) {}
namespace {
struct VISIBILITY_HIDDEN MarkModRef : public FunctionPass {
static char ID; // Pass identification, replacement for typeid
- MarkModRef() : FunctionPass((intptr_t)&ID) {}
+ MarkModRef() : FunctionPass(&ID) {}
bool runOnFunction(Function &F);
bool runOnFunction(Function &F);
public:
static char ID; // Pass identification, replacement for typeid
- MemCpyOpt() : FunctionPass((intptr_t)&ID) { }
+ MemCpyOpt() : FunctionPass(&ID) {}
private:
// This transformation requires dominator postdominator info
public:
static char ID; // Pass identification, replacement for typeid
- PredicateSimplifier() : FunctionPass((intptr_t)&ID) {}
+ PredicateSimplifier() : FunctionPass(&ID) {}
bool runOnFunction(Function &F);
bool MadeChange;
public:
static char ID; // Pass identification, replacement for typeid
- Reassociate() : FunctionPass((intptr_t)&ID) {}
+ Reassociate() : FunctionPass(&ID) {}
bool runOnFunction(Function &F);
namespace {
struct VISIBILITY_HIDDEN RegToMem : public FunctionPass {
static char ID; // Pass identification, replacement for typeid
- RegToMem() : FunctionPass((intptr_t)&ID) {}
+ RegToMem() : FunctionPass(&ID) {}
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequiredID(BreakCriticalEdgesID);
///
struct VISIBILITY_HIDDEN SCCP : public FunctionPass {
static char ID; // Pass identification, replacement for typeid
- SCCP() : FunctionPass((intptr_t)&ID) {}
+ SCCP() : FunctionPass(&ID) {}
// runOnFunction - Run the Sparse Conditional Constant Propagation
// algorithm, and return true if the function was modified.
///
struct VISIBILITY_HIDDEN IPSCCP : public ModulePass {
static char ID;
- IPSCCP() : ModulePass((intptr_t)&ID) {}
+ IPSCCP() : ModulePass(&ID) {}
bool runOnModule(Module &M);
};
} // end anonymous namespace
namespace {
struct VISIBILITY_HIDDEN SROA : public FunctionPass {
static char ID; // Pass identification, replacement for typeid
- explicit SROA(signed T = -1) : FunctionPass((intptr_t)&ID) {
+ explicit SROA(signed T = -1) : FunctionPass(&ID) {
if (T == -1)
SRThreshold = 128;
else
namespace {
struct VISIBILITY_HIDDEN CFGSimplifyPass : public FunctionPass {
static char ID; // Pass identification, replacement for typeid
- CFGSimplifyPass() : FunctionPass((intptr_t)&ID) {}
+ CFGSimplifyPass() : FunctionPass(&ID) {}
virtual bool runOnFunction(Function &F);
};
FWriteOpt FWrite; FPutsOpt FPuts; FPrintFOpt FPrintF;
public:
static char ID; // Pass identification
- SimplifyLibCalls() : FunctionPass((intptr_t)&ID) {}
+ SimplifyLibCalls() : FunctionPass(&ID) {}
void InitOptimizations();
bool runOnFunction(Function &F);
bool runOnFunction(Function &F);
public:
static char ID; // Pass identification, replacement for typeid
- TailDup() : FunctionPass((intptr_t)&ID) {}
+ TailDup() : FunctionPass(&ID) {}
private:
inline bool shouldEliminateUnconditionalBranch(TerminatorInst *, unsigned);
namespace {
struct VISIBILITY_HIDDEN TailCallElim : public FunctionPass {
static char ID; // Pass identification, replacement for typeid
- TailCallElim() : FunctionPass((intptr_t)&ID) {}
+ TailCallElim() : FunctionPass(&ID) {}
virtual bool runOnFunction(Function &F);
namespace {
struct VISIBILITY_HIDDEN BreakCriticalEdges : public FunctionPass {
static char ID; // Pass identification, replacement for typeid
- BreakCriticalEdges() : FunctionPass((intptr_t)&ID) {}
+ BreakCriticalEdges() : FunctionPass(&ID) {}
virtual bool runOnFunction(Function &F);
namespace {
struct VISIBILITY_HIDDEN LCSSA : public LoopPass {
static char ID; // Pass identification, replacement for typeid
- LCSSA() : LoopPass((intptr_t)&ID) {}
+ LCSSA() : LoopPass(&ID) {}
// Cached analysis information for the current function.
LoopInfo *LI;
namespace {
struct VISIBILITY_HIDDEN LoopSimplify : public FunctionPass {
static char ID; // Pass identification, replacement for typeid
- LoopSimplify() : FunctionPass((intptr_t)&ID) {}
+ LoopSimplify() : FunctionPass(&ID) {}
// AA - If we have an alias analysis object to update, this is it, otherwise
// this is null.
public:
static char ID; // Pass ID, replacement for typeid
explicit LowerAllocations(bool LowerToInt = false)
- : BasicBlockPass((intptr_t)&ID), MallocFunc(0), FreeFunc(0),
+ : BasicBlockPass(&ID), MallocFunc(0), FreeFunc(0),
LowerMallocArgToInteger(LowerToInt) {}
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
public:
static char ID; // Pass identification, replacement for typeid
explicit LowerInvoke(const TargetLowering *tli = NULL)
- : FunctionPass((intptr_t)&ID), TLI(tli) { }
+ : FunctionPass(&ID), TLI(tli) { }
bool doInitialization(Module &M);
bool runOnFunction(Function &F);
class VISIBILITY_HIDDEN LowerSwitch : public FunctionPass {
public:
static char ID; // Pass identification, replacement for typeid
- LowerSwitch() : FunctionPass((intptr_t) &ID) {}
+ LowerSwitch() : FunctionPass(&ID) {}
virtual bool runOnFunction(Function &F);
namespace {
struct VISIBILITY_HIDDEN PromotePass : public FunctionPass {
static char ID; // Pass identification, replacement for typeid
- PromotePass() : FunctionPass((intptr_t)&ID) {}
+ PromotePass() : FunctionPass(&ID) {}
// runOnFunction - To run this pass, first we calculate the alloca
// instructions that are safe for promotion, then we promote each one.
public:
static char ID;
explicit BBPassManager(int Depth)
- : PMDataManager(Depth), FunctionPass((intptr_t)&ID) {}
+ : PMDataManager(Depth), FunctionPass(&ID) {}
/// Execute all of the passes scheduled for execution. Keep track of
/// whether any of the passes modifies the function, and if so, return true.
public:
static char ID;
explicit FunctionPassManagerImpl(int Depth) :
- Pass((intptr_t)&ID), PMDataManager(Depth),
+ Pass(&ID), PMDataManager(Depth),
PMTopLevelManager(TLM_Function) { }
/// add - Add a pass to the queue of passes to run. This passes ownership of
public:
static char ID;
explicit MPPassManager(int Depth) :
- Pass((intptr_t)&ID), PMDataManager(Depth) { }
+ Pass(&ID), PMDataManager(Depth) { }
// Delete on the fly managers.
virtual ~MPPassManager() {
public:
static char ID;
explicit PassManagerImpl(int Depth) :
- Pass((intptr_t)&ID), PMDataManager(Depth),
- PMTopLevelManager(TLM_Pass) { }
+ Pass(&ID), PMDataManager(Depth), PMTopLevelManager(TLM_Pass) { }
/// add - Add a pass to the queue of passes to run. This passes ownership of
/// the Pass to the PassManager. When the PassManager is destroyed, the pass
struct VISIBILITY_HIDDEN PreVerifier : public FunctionPass {
static char ID; // Pass ID, replacement for typeid
- PreVerifier() : FunctionPass((intptr_t)&ID) { }
+ PreVerifier() : FunctionPass(&ID) { }
// Check that the prerequisites for successful DominatorTree construction
// are satisfied.
SmallPtrSet<Instruction*, 16> InstsInThisBlock;
Verifier()
- : FunctionPass((intptr_t)&ID),
+ : FunctionPass(&ID),
Broken(false), RealPass(true), action(AbortProcessAction),
DT(0), msgs( std::ios::app | std::ios::out ) {}
explicit Verifier(VerifierFailureAction ctn)
- : FunctionPass((intptr_t)&ID),
+ : FunctionPass(&ID),
Broken(false), RealPass(true), action(ctn), DT(0),
msgs( std::ios::app | std::ios::out ) {}
explicit Verifier(bool AB)
- : FunctionPass((intptr_t)&ID),
+ : FunctionPass(&ID),
Broken(false), RealPass(true),
action( AB ? AbortProcessAction : PrintMessageAction), DT(0),
msgs( std::ios::app | std::ios::out ) {}
explicit Verifier(DominatorTree &dt)
- : FunctionPass((intptr_t)&ID),
+ : FunctionPass(&ID),
Broken(false), RealPass(false), action(PrintMessageAction),
DT(&dt), msgs( std::ios::app | std::ios::out ) {}
projects / oota-llvm.git / commitdiff