-//===- llvm/Support/InstVisitor.h - Define instruction visitors --*- C++ -*--=//
+//===- llvm/Support/InstVisitor.h - Define instruction visitors -*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
//
// This template class is used to define instruction visitors in a typesafe
// manner without having to use lots of casts and a big switch statement (in
// 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
#define LLVM_SUPPORT_INSTVISITOR_H
-#include "llvm/Instruction.h"
+#include "llvm/Function.h"
+#include "llvm/Module.h"
+
+namespace llvm {
// 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 {
- virtual ~InstVisitor() {} // We are meant to be derived from
-
//===--------------------------------------------------------------------===//
// Interface code - This is the public interface of the InstVisitor that you
// use to visit instructions...
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...
+ // Define visitors for 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); }
+#include "llvm/Instruction.def"
+
// Specific Instruction type classes... note that all of the casts are
- // neccesary because we use the instruction classes as opaque types...
+ // necessary 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 visitUnwindInst(UnwindInst &I) { DELEGATE(TerminatorInst);}
+ RetTy visitUnreachableInst(UnreachableInst &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 visitSelectInst(SelectInst &I) { DELEGATE(Instruction); }
+ RetTy visitCallInst(CallInst &I) { DELEGATE(Instruction); }
+ RetTy visitShiftInst(ShiftInst &I) { DELEGATE(Instruction); }
+ RetTy visitVANextInst(VANextInst &I) { DELEGATE(Instruction); }
+ RetTy visitVAArgInst(VAArgInst &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
+
+} // End llvm namespace
+
#endif