<div class="doc_code"><pre>
static char ID;
- Hello() : FunctionPass((intptr_t)&ID) {}
+ Hello() : FunctionPass(&ID) {}
</pre></div><p>
<p> This declares pass identifier used by LLVM to identify pass. This allows LLVM to
<b>struct Hello</b> : <b>public</b> <a href="#FunctionPass">FunctionPass</a> {
static char ID;
- Hello() : FunctionPass((intptr_t)&ID) {}
+ Hello() : FunctionPass(&ID) {}
<b>virtual bool</b> <a href="#runOnFunction">runOnFunction</a>(Function &F) {
llvm::cerr << "<i>Hello: </i>" << F.getName() << "\n";
public:
static char ID; // Pass identification, replacement for typeid
- LoopInfo() : FunctionPass(intptr_t(&ID)) {
+ LoopInfo() : FunctionPass(&ID) {
LI = new LoopInfoBase<BasicBlock>();
}
public:
static char ID; // Class identification, replacement for typeinfo
- LoopVR() : FunctionPass(intptr_t(&ID)) {}
+ LoopVR() : FunctionPass(&ID) {}
bool runOnFunction(Function &F);
virtual void print(std::ostream &os, const Module *) const;
public:
static char ID; // Pass identification, replacement for typeid
- MachineLoopInfo() : MachineFunctionPass(intptr_t(&ID)) {
+ MachineLoopInfo() : MachineFunctionPass(&ID) {
LI = new LoopInfoBase<MachineBasicBlock>();
}
public:
static char ID;
explicit FPPassManager(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.
///
/// @note This has to exist, because this is a pass, but it should never be
/// used.
- TargetData() : ImmutablePass(intptr_t(&ID)) {
+ TargetData() : ImmutablePass(&ID) {
assert(0 && "ERROR: Bad TargetData ctor used. "
"Tool did not specify a TargetData to use?");
abort();
/// Constructs a TargetData from a specification string. See init().
explicit TargetData(const std::string &TargetDescription)
- : ImmutablePass(intptr_t(&ID)) {
+ : ImmutablePass(&ID) {
init(TargetDescription);
}
explicit TargetData(const Module *M);
TargetData(const TargetData &TD) :
- ImmutablePass(intptr_t(&ID)),
+ ImmutablePass(&ID),
LittleEndian(TD.isLittleEndian()),
PointerMemSize(TD.PointerMemSize),
PointerABIAlign(TD.PointerABIAlign),
}
Printer::Printer(std::ostream &OS)
- : FunctionPass(intptr_t(&ID)), OS(OS) {}
+ : FunctionPass(&ID), OS(OS) {}
const char *Printer::getPassName() const {
return "Print Garbage Collector Information";
return new Deleter();
}
-Deleter::Deleter() : FunctionPass(intptr_t(&ID)) {}
+Deleter::Deleter() : FunctionPass(&ID) {}
const char *Deleter::getPassName() const {
return "Delete Garbage Collector Information";
char MachineCodeAnalysis::ID = 0;
MachineCodeAnalysis::MachineCodeAnalysis()
- : MachineFunctionPass(intptr_t(&ID)) {}
+ : MachineFunctionPass(&ID) {}
const char *MachineCodeAnalysis::getPassName() const {
return "Analyze Machine Code For Garbage Collection";
}
MachineDominatorTree::MachineDominatorTree()
- : MachineFunctionPass(intptr_t(&ID)) {
+ : MachineFunctionPass(&ID) {
DT = new DominatorTreeBase<MachineBasicBlock>(false);
}
//
struct VISIBILITY_HIDDEN DeadInstElimination : public BasicBlockPass {
static char ID; // Pass identification, replacement for typeid
- DeadInstElimination() : BasicBlockPass(intptr_t(&ID)) {}
+ DeadInstElimination() : BasicBlockPass(&ID) {}
virtual bool runOnBasicBlock(BasicBlock &BB) {
bool Changed = false;
for (BasicBlock::iterator DI = BB.begin(); DI != BB.end(); ) {
bool DeleteStream; // Delete the ostream in our dtor?
public:
static char ID;
- PrintModulePass() : ModulePass(intptr_t(&ID)), Out(&errs()),
+ PrintModulePass() : ModulePass(&ID), Out(&errs()),
DeleteStream(false) {}
PrintModulePass(raw_ostream *o, bool DS)
- : ModulePass(intptr_t(&ID)), Out(o), DeleteStream(DS) {}
+ : ModulePass(&ID), Out(o), DeleteStream(DS) {}
~PrintModulePass() {
if (DeleteStream) delete Out;
bool DeleteStream; // Delete the ostream in our dtor?
public:
static char ID;
- PrintFunctionPass() : FunctionPass(intptr_t(&ID)), Banner(""), Out(&errs()),
+ PrintFunctionPass() : FunctionPass(&ID), Banner(""), Out(&errs()),
DeleteStream(false) {}
PrintFunctionPass(const std::string &B, raw_ostream *o, bool DS)
- : FunctionPass(intptr_t(&ID)), Banner(B), Out(o), DeleteStream(DS) {}
+ : FunctionPass(&ID), Banner(B), Out(o), DeleteStream(DS) {}
inline ~PrintFunctionPass() {
if (DeleteStream) delete Out;
class CrashOnCalls : public BasicBlockPass {
public:
static char ID; // Pass ID, replacement for typeid
- CrashOnCalls() : BasicBlockPass((intptr_t)&ID) {}
+ CrashOnCalls() : BasicBlockPass(&ID) {}
private:
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.setPreservesAll();
class DeleteCalls : public BasicBlockPass {
public:
static char ID; // Pass ID, replacement for typeid
- DeleteCalls() : BasicBlockPass((intptr_t)&ID) {}
+ DeleteCalls() : BasicBlockPass(&ID) {}
private:
bool runOnBasicBlock(BasicBlock &BB) {
for (BasicBlock::iterator I = BB.begin(), E = BB.end(); I != E; ++I)
/// or handle in alias analyses.
struct ExternalFunctionsPassedConstants : public ModulePass {
static char ID; // Pass ID, replacement for typeid
- ExternalFunctionsPassedConstants() : ModulePass((intptr_t)&ID) {}
+ ExternalFunctionsPassedConstants() : ModulePass(&ID) {}
virtual bool runOnModule(Module &M) {
for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
if (I->isDeclaration()) {
struct CallGraphPrinter : public ModulePass {
static char ID; // Pass ID, replacement for typeid
- CallGraphPrinter() : ModulePass((intptr_t)&ID) {}
+ CallGraphPrinter() : ModulePass(&ID) {}
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.setPreservesAll();
namespace {
struct CallGraphPrinter : public ModulePass {
static char ID; // Pass ID, replacement for typeid
- CallGraphPrinter() : ModulePass((intptr_t)&ID) {}
+ CallGraphPrinter() : ModulePass(&ID) {}
virtual bool runOnModule(Module &M) {
WriteGraphToFile(std::cerr, "callgraph", &getAnalysis<CallGraph>());
class DomInfoPrinter : public FunctionPass {
public:
static char ID; // Pass identification, replacement for typeid
- DomInfoPrinter() : FunctionPass((intptr_t)&ID) {}
+ DomInfoPrinter() : FunctionPass(&ID) {}
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.setPreservesAll();
namespace {
struct CFGSCC : public FunctionPass {
static char ID; // Pass identification, replacement for typeid
- CFGSCC() : FunctionPass((intptr_t)&ID) {}
+ CFGSCC() : FunctionPass(&ID) {}
bool runOnFunction(Function& func);
void print(std::ostream &O, const Module* = 0) const { }
struct CallGraphSCC : public ModulePass {
static char ID; // Pass identification, replacement for typeid
- CallGraphSCC() : ModulePass((intptr_t)&ID) {}
+ CallGraphSCC() : ModulePass(&ID) {}
// run - Print out SCCs in the call graph for the specified module.
bool runOnModule(Module &M);
static char ID;
const PassInfo *PassToPrint;
CallGraphSCCPassPrinter(const PassInfo *PI) :
- CallGraphSCCPass((intptr_t)&ID), PassToPrint(PI) {}
+ CallGraphSCCPass(&ID), PassToPrint(PI) {}
virtual bool runOnSCC(const std::vector<CallGraphNode *>&SCC) {
if (!Quiet) {
struct ModulePassPrinter : public ModulePass {
static char ID;
const PassInfo *PassToPrint;
- ModulePassPrinter(const PassInfo *PI) : ModulePass((intptr_t)&ID),
+ ModulePassPrinter(const PassInfo *PI) : ModulePass(&ID),
PassToPrint(PI) {}
virtual bool runOnModule(Module &M) {
struct FunctionPassPrinter : public FunctionPass {
const PassInfo *PassToPrint;
static char ID;
- FunctionPassPrinter(const PassInfo *PI) : FunctionPass((intptr_t)&ID),
+ FunctionPassPrinter(const PassInfo *PI) : FunctionPass(&ID),
PassToPrint(PI) {}
virtual bool runOnFunction(Function &F) {
static char ID;
const PassInfo *PassToPrint;
LoopPassPrinter(const PassInfo *PI) :
- LoopPass((intptr_t)&ID), PassToPrint(PI) {}
+ LoopPass(&ID), PassToPrint(PI) {}
virtual bool runOnLoop(Loop *L, LPPassManager &LPM) {
if (!Quiet) {
const PassInfo *PassToPrint;
static char ID;
BasicBlockPassPrinter(const PassInfo *PI)
- : BasicBlockPass((intptr_t)&ID), PassToPrint(PI) {}
+ : BasicBlockPass(&ID), PassToPrint(PI) {}
virtual bool runOnBasicBlock(BasicBlock &BB) {
if (!Quiet) {