// CMV.visit(function);
// NumMallocs = CMV.Count;
//
+// Returning a value from the visitation function:
+// The InstVisitor class takes an optional second template argument that
+// specifies what type the instruction visitation functions should return. If
+// you specify this, you *MUST* provide an implementation of visitInstruction
+// though!.
+//
//===----------------------------------------------------------------------===//
#ifndef LLVM_SUPPORT_INSTVISITOR_H
#include "llvm/Instruction.h"
+class Module;
+
// We operate on opaque instruction classes, so forward declare all instruction
// types now...
//
#include "llvm/Instruction.def"
// Forward declare the intermediate types...
-class TerminatorInst; class UnaryOperator; class BinaryOperator;
-class AllocationInst; class MemAccessInst;
+class TerminatorInst; class BinaryOperator;
+class AllocationInst;
+
+
+#define DELEGATE(CLASS_TO_VISIT) \
+ return ((SubClass*)this)->visit##CLASS_TO_VISIT((CLASS_TO_VISIT&)I)
+
template<typename SubClass, typename RetTy=void>
struct InstVisitor {
template<class Iterator>
void visit(Iterator Start, Iterator End) {
while (Start != End)
- visit(*Start++);
+ ((SubClass*)this)->visit(*Start++);
}
// Define visitors for modules, functions and basic blocks...
//
- void visit(Module *M) {
+ void visit(Module &M) {
((SubClass*)this)->visitModule(M);
- visit(M->begin(), M->end());
+ visit(M.begin(), M.end());
}
- void visit(Function *F) {
+ void visit(Function &F) {
((SubClass*)this)->visitFunction(F);
- visit(F->begin(), F->end());
+ visit(F.begin(), F.end());
}
- void visit(BasicBlock *BB) {
+ void visit(BasicBlock &BB) {
((SubClass*)this)->visitBasicBlock(BB);
- visit(BB->begin(), BB->end());
+ visit(BB.begin(), BB.end());
}
+ // Forwarding functions so that the user can visit with pointers AND refs.
+ void visit(Module *M) { visit(*M); }
+ void visit(Function *F) { visit(*F); }
+ void visit(BasicBlock *BB) { visit(*BB); }
+ RetTy visit(Instruction *I) { return visit(*I); }
+
// visit - Finally, code to visit an instruction...
//
- RetTy visit(Instruction *I) {
- switch (I->getOpcode()) {
+ RetTy visit(Instruction &I) {
+ switch (I.getOpcode()) {
+ default: assert(0 && "Unknown instruction type encountered!");
+ abort();
// Build the switch statement using the Instruction.def file...
#define HANDLE_INST(NUM, OPCODE, CLASS) \
- case Instruction::OPCODE: return ((SubClass*)this)->visit##CLASS((CLASS*)I);
+ case Instruction::OPCODE:return ((SubClass*)this)->visit##OPCODE((CLASS&)I);
#include "llvm/Instruction.def"
-
- default: assert(0 && "Unknown instruction type encountered!");
}
}
// When visiting a module, function or basic block directly, these methods get
// called to indicate when transitioning into a new unit.
//
- void visitModule (Module *M) {}
- void visitFunction (Function *F) {}
- void visitBasicBlock(BasicBlock *BB) {}
+ void visitModule (Module &M) {}
+ void visitFunction (Function &F) {}
+ void visitBasicBlock(BasicBlock &BB) {}
+
+
+ // Define instruction specific visitor functions that can be overridden to
+ // handle SPECIFIC instructions. These functions automatically define
+ // visitMul to proxy to visitBinaryOperator for instance in case the user does
+ // not need this generality.
+ //
+ // The one problem case we have to handle here though is that the PHINode
+ // class and opcode name are the exact same. Because of this, we cannot
+ // define visitPHINode (the inst version) to forward to visitPHINode (the
+ // generic version) without multiply defined symbols and recursion. To handle
+ // this, we do not autoexpand "Other" instructions, we do it manually.
+ //
+#define HANDLE_INST(NUM, OPCODE, CLASS) \
+ RetTy visit##OPCODE(CLASS &I) { DELEGATE(CLASS); }
+#define HANDLE_OTHER_INST(NUM, OPCODE, CLASS) // Ignore "other" instructions
+#include "llvm/Instruction.def"
+
+ // Implement all "other" instructions, except for PHINode
+ RetTy visitCast(CastInst &I) { DELEGATE(CastInst); }
+ RetTy visitCall(CallInst &I) { DELEGATE(CallInst); }
+ RetTy visitShr(ShiftInst &I) { DELEGATE(ShiftInst); }
+ RetTy visitShl(ShiftInst &I) { DELEGATE(ShiftInst); }
+ RetTy visitVarArg(VarArgInst &I) { DELEGATE(VarArgInst); }
+ RetTy visitUserOp1(Instruction &I) { DELEGATE(Instruction); }
+ RetTy visitUserOp2(Instruction &I) { DELEGATE(Instruction); }
+
// Specific Instruction type classes... note that all of the casts are
// neccesary because we use the instruction classes as opaque types...
//
- RetTy visitReturnInst(ReturnInst *I) { return ((SubClass*)this)->visitTerminatorInst((TerminatorInst*)I); }
- RetTy visitBranchInst(BranchInst *I) { return ((SubClass*)this)->visitTerminatorInst((TerminatorInst*)I); }
- RetTy visitSwitchInst(SwitchInst *I) { return ((SubClass*)this)->visitTerminatorInst((TerminatorInst*)I); }
- RetTy visitInvokeInst(InvokeInst *I) { return ((SubClass*)this)->visitTerminatorInst((TerminatorInst*)I); }
- RetTy visitGenericUnaryInst(GenericUnaryInst *I) { return ((SubClass*)this)->visitUnaryOperator((UnaryOperator*)I); }
- RetTy visitGenericBinaryInst(GenericBinaryInst *I) { return ((SubClass*)this)->visitBinaryOperator((BinaryOperator*)I); }
- RetTy visitSetCondInst(SetCondInst *I) { return ((SubClass*)this)->visitBinaryOperator((BinaryOperator *)I); }
- RetTy visitMallocInst(MallocInst *I) { return ((SubClass*)this)->visitAllocationInst((AllocationInst *)I); }
- RetTy visitAllocaInst(AllocaInst *I) { return ((SubClass*)this)->visitAllocationInst((AllocationInst *)I); }
- RetTy visitFreeInst(FreeInst *I) { return ((SubClass*)this)->visitInstruction((Instruction *)I); }
- RetTy visitLoadInst(LoadInst *I) { return ((SubClass*)this)->visitMemAccessInst((MemAccessInst *)I); }
- RetTy visitStoreInst(StoreInst *I) { return ((SubClass*)this)->visitMemAccessInst((MemAccessInst *)I); }
- RetTy visitGetElementPtrInst(GetElementPtrInst *I) { return ((SubClass*)this)->visitMemAccessInst((MemAccessInst *)I); }
- RetTy visitPHINode(PHINode *I) { return ((SubClass*)this)->visitInstruction((Instruction *)I); }
- RetTy visitCastInst(CastInst *I) { return ((SubClass*)this)->visitInstruction((Instruction *)I); }
- RetTy visitCallInst(CallInst *I) { return ((SubClass*)this)->visitInstruction((Instruction *)I); }
- RetTy visitShiftInst(ShiftInst *I) { return ((SubClass*)this)->visitInstruction((Instruction *)I); }
-
- // Next level propogators... if the user does not overload a specific
+ RetTy visitReturnInst(ReturnInst &I) { DELEGATE(TerminatorInst);}
+ RetTy visitBranchInst(BranchInst &I) { DELEGATE(TerminatorInst);}
+ RetTy visitSwitchInst(SwitchInst &I) { DELEGATE(TerminatorInst);}
+ RetTy visitInvokeInst(InvokeInst &I) { DELEGATE(TerminatorInst);}
+ RetTy visitSetCondInst(SetCondInst &I) { DELEGATE(BinaryOperator);}
+ RetTy visitMallocInst(MallocInst &I) { DELEGATE(AllocationInst);}
+ RetTy visitAllocaInst(AllocaInst &I) { DELEGATE(AllocationInst);}
+ RetTy visitFreeInst(FreeInst &I) { DELEGATE(Instruction); }
+ RetTy visitLoadInst(LoadInst &I) { DELEGATE(Instruction); }
+ RetTy visitStoreInst(StoreInst &I) { DELEGATE(Instruction); }
+ RetTy visitGetElementPtrInst(GetElementPtrInst &I){ DELEGATE(Instruction); }
+ RetTy visitPHINode(PHINode &I) { DELEGATE(Instruction); }
+ RetTy visitCastInst(CastInst &I) { DELEGATE(Instruction); }
+ RetTy visitCallInst(CallInst &I) { DELEGATE(Instruction); }
+ RetTy visitShiftInst(ShiftInst &I) { DELEGATE(Instruction); }
+ RetTy visitVarArgInst(VarArgInst &I) { DELEGATE(Instruction); }
+
+ // Next level propagators... if the user does not overload a specific
// instruction type, they can overload one of these to get the whole class
// of instructions...
//
- RetTy visitTerminatorInst(TerminatorInst *I) { return ((SubClass*)this)->visitInstruction((Instruction*)I); }
- RetTy visitUnaryOperator (UnaryOperator *I) { return ((SubClass*)this)->visitInstruction((Instruction*)I); }
- RetTy visitBinaryOperator(BinaryOperator *I) { return ((SubClass*)this)->visitInstruction((Instruction*)I); }
- RetTy visitAllocationInst(AllocationInst *I) { return ((SubClass*)this)->visitInstruction((Instruction*)I); }
- RetTy visitMemAccessInst (MemAccessInst *I) { return ((SubClass*)this)->visitInstruction((Instruction*)I); }
+ RetTy visitTerminatorInst(TerminatorInst &I) { DELEGATE(Instruction); }
+ RetTy visitBinaryOperator(BinaryOperator &I) { DELEGATE(Instruction); }
+ RetTy visitAllocationInst(AllocationInst &I) { DELEGATE(Instruction); }
// If the user wants a 'default' case, they can choose to override this
// function. If this function is not overloaded in the users subclass, then
//
// Note that you MUST override this function if your return type is not void.
//
- void visitInstruction(Instruction *I) {} // Ignore unhandled instructions
+ void visitInstruction(Instruction &I) {} // Ignore unhandled instructions
};
+#undef DELEGATE
+
#endif
projects / oota-llvm.git / blobdiff