From: Chris Lattner Date: Thu, 18 Apr 2002 16:16:16 +0000 (+0000) Subject: * Add a comment to the header giving a breif overview of how to return a X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=0e743b83976dd9b31c8fc7ad19f61c30b743dedf;p=oota-llvm.git * Add a comment to the header giving a breif overview of how to return a value from a visit function * Define a (file local) DELEGATE macro to make the code easier to read/maintain * Define per-opcode delegation functions so that users can override specific instances of BinaryOperator for example. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2290 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/llvm/Support/InstVisitor.h b/include/llvm/Support/InstVisitor.h index f75ae4b17b6..e4937e10e6b 100644 --- a/include/llvm/Support/InstVisitor.h +++ b/include/llvm/Support/InstVisitor.h @@ -32,6 +32,12 @@ // 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 @@ -49,6 +55,11 @@ class TerminatorInst; class UnaryOperator; class BinaryOperator; class AllocationInst; class MemAccessInst; + +#define DELEGATE(CLASS_TO_VISIT) \ + return ((SubClass*)this)->visit##CLASS_TO_VISIT((CLASS_TO_VISIT*)I) + + template struct InstVisitor { virtual ~InstVisitor() {} // We are meant to be derived from @@ -86,7 +97,7 @@ struct InstVisitor { switch (I->getOpcode()) { // 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!"); @@ -107,37 +118,63 @@ struct InstVisitor { 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 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); } + 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 visitGenericUnaryInst(GenericUnaryInst *I) { DELEGATE(UnaryOperator); } + RetTy visitGenericBinaryInst(GenericBinaryInst *I){ DELEGATE(BinaryOperator);} + 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(MemAccessInst); } + RetTy visitStoreInst(StoreInst *I) { DELEGATE(MemAccessInst); } + RetTy visitGetElementPtrInst(GetElementPtrInst *I){ DELEGATE(MemAccessInst); } + RetTy visitPHINode(PHINode *I) { DELEGATE(Instruction); } + RetTy visitCastInst(CastInst *I) { DELEGATE(Instruction); } + RetTy visitCallInst(CallInst *I) { DELEGATE(Instruction); } + RetTy visitShiftInst(ShiftInst *I) { DELEGATE(Instruction); } // Next level propogators... 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 visitUnaryOperator (UnaryOperator *I) { DELEGATE(Instruction); } + RetTy visitBinaryOperator(BinaryOperator *I) { DELEGATE(Instruction); } + RetTy visitAllocationInst(AllocationInst *I) { DELEGATE(Instruction); } + RetTy visitMemAccessInst (MemAccessInst *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 @@ -148,4 +185,6 @@ struct InstVisitor { void visitInstruction(Instruction *I) {} // Ignore unhandled instructions }; +#undef DELEGATE + #endif