X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FSupport%2FInstVisitor.h;h=109b3cff85b6dc62d96e6e77ac80b556ad5375ec;hb=55907d1274ce715b92d584e305e0708e333a33c0;hp=e4937e10e6b67c13eb850b0202d60449b21bf089;hpb=0e743b83976dd9b31c8fc7ad19f61c30b743dedf;p=oota-llvm.git diff --git a/include/llvm/Support/InstVisitor.h b/include/llvm/Support/InstVisitor.h index e4937e10e6b..109b3cff85b 100644 --- a/include/llvm/Support/InstVisitor.h +++ b/include/llvm/Support/InstVisitor.h @@ -1,49 +1,25 @@ -//===- llvm/Support/InstVisitor.h - Define instruction visitors --*- C++ -*--=// +//===- llvm/Support/InstVisitor.h - Define instruction visitors -*- C++ -*-===// // -// 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 -// your code that is). The win here is that if instructions are added in the -// future, they will be added to the InstVisitor class, allowing you to -// automatically support them (if you handle on of their superclasses). +// The LLVM Compiler Infrastructure // -// Note that this library is specifically designed as a template to avoid -// virtual function call overhead. Defining and using an InstVisitor is just as -// efficient as having your own switch statement over the instruction opcode. -// -// InstVisitor Usage: -// You define InstVisitors from inheriting from the InstVisitor base class -// and "overriding" functions in your class. I say "overriding" because this -// class is defined in terms of statically resolved overloading, not virtual -// functions. As an example, here is a visitor that counts the number of malloc -// instructions processed: -// -// // Declare the class. Note that we derive from InstVisitor instantiated -// // with _our new subclasses_ type. -// // -// struct CountMallocVisitor : public InstVisitor { -// unsigned Count; -// CountMallocVisitor() : Count(0) {} -// -// void visitMallocInst(MallocInst *MI) { ++Count; } -// }; -// -// And this class would be used like this: -// CountMallocVistor CMV; -// 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!. +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// + #ifndef LLVM_SUPPORT_INSTVISITOR_H #define LLVM_SUPPORT_INSTVISITOR_H -#include "llvm/Instruction.h" +#include "llvm/Function.h" +#include "llvm/Instructions.h" +#include "llvm/Intrinsics.h" +#include "llvm/IntrinsicInst.h" +#include "llvm/Module.h" +#include "llvm/Support/CallSite.h" +#include "llvm/Support/ErrorHandling.h" + +namespace llvm { // We operate on opaque instruction classes, so forward declare all instruction // types now... @@ -51,56 +27,103 @@ #define HANDLE_INST(NUM, OPCODE, CLASS) class CLASS; #include "llvm/Instruction.def" -// Forward declare the intermediate types... -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) + return static_cast(this)-> \ + visit##CLASS_TO_VISIT(static_cast(I)) +/// @brief Base class for instruction visitors +/// +/// Instruction visitors are used when you want to perform different actions +/// for different kinds of instructions without having to use lots of casts +/// and a big switch statement (in your code, that is). +/// +/// To define your own visitor, inherit from this class, specifying your +/// new type for the 'SubClass' template parameter, and "override" visitXXX +/// functions in your class. I say "override" because this class is defined +/// in terms of statically resolved overloading, not virtual functions. +/// +/// For example, here is a visitor that counts the number of malloc +/// instructions processed: +/// +/// /// Declare the class. Note that we derive from InstVisitor instantiated +/// /// with _our new subclasses_ type. +/// /// +/// struct CountAllocaVisitor : public InstVisitor { +/// unsigned Count; +/// CountAllocaVisitor() : Count(0) {} +/// +/// void visitAllocaInst(AllocaInst &AI) { ++Count; } +/// }; +/// +/// And this class would be used like this: +/// CountAllocaVisitor CAV; +/// CAV.visit(function); +/// NumAllocas = CAV.Count; +/// +/// The defined has 'visit' methods for Instruction, and also for BasicBlock, +/// Function, and Module, which recursively process all contained instructions. +/// +/// Note that if you don't implement visitXXX for some instruction type, +/// the visitXXX method for instruction superclass will be invoked. So +/// if instructions are added in the future, they will be automatically +/// supported, if you handle one of their superclasses. +/// +/// The optional second template argument specifies the type that instruction +/// visitation functions should return. If you specify this, you *MUST* provide +/// an implementation of visitInstruction though!. +/// +/// Note that this class is specifically designed as a template to avoid +/// virtual function call overhead. Defining and using an InstVisitor is just +/// as efficient as having your own switch statement over the instruction +/// opcode. template -struct InstVisitor { - virtual ~InstVisitor() {} // We are meant to be derived from - +class InstVisitor { //===--------------------------------------------------------------------===// // Interface code - This is the public interface of the InstVisitor that you // use to visit instructions... // +public: // Generic visit method - Allow visitation to all instructions in a range template void visit(Iterator Start, Iterator End) { while (Start != End) - visit(*Start++); + static_cast(this)->visit(*Start++); } - // Define visitors for modules, functions and basic blocks... + // Define visitors for functions and basic blocks... // - void visit(Module *M) { - ((SubClass*)this)->visitModule(M); - visit(M->begin(), M->end()); + void visit(Module &M) { + static_cast(this)->visitModule(M); + visit(M.begin(), M.end()); } - void visit(Function *F) { - ((SubClass*)this)->visitFunction(F); - visit(F->begin(), F->end()); + void visit(Function &F) { + static_cast(this)->visitFunction(F); + visit(F.begin(), F.end()); } - void visit(BasicBlock *BB) { - ((SubClass*)this)->visitBasicBlock(BB); - visit(BB->begin(), BB->end()); + void visit(BasicBlock &BB) { + static_cast(this)->visitBasicBlock(BB); + 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: llvm_unreachable("Unknown instruction type encountered!"); // Build the switch statement using the Instruction.def file... #define HANDLE_INST(NUM, OPCODE, CLASS) \ - case Instruction::OPCODE:return ((SubClass*)this)->visit##OPCODE((CLASS*)I); + case Instruction::OPCODE: return \ + static_cast(this)-> \ + visit##OPCODE(static_cast(I)); #include "llvm/Instruction.def" - - default: assert(0 && "Unknown instruction type encountered!"); } } @@ -115,76 +138,145 @@ struct InstVisitor { // 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. - // + // These functions can also implement fan-out, when a single opcode and + // instruction have multiple more specific Instruction subclasses. The Call + // instruction currently supports this. We implement that by redirecting that + // instruction to a special delegation helper. #define HANDLE_INST(NUM, OPCODE, CLASS) \ - RetTy visit##OPCODE(CLASS *I) { DELEGATE(CLASS); } -#define HANDLE_OTHER_INST(NUM, OPCODE, CLASS) // Ignore "other" instructions + RetTy visit##OPCODE(CLASS &I) { \ + if (NUM == Instruction::Call) \ + return delegateCallInst(I); \ + else \ + DELEGATE(CLASS); \ + } #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... + // necessary because we use the instruction classes as opaque types... // - 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 + RetTy visitReturnInst(ReturnInst &I) { DELEGATE(TerminatorInst);} + RetTy visitBranchInst(BranchInst &I) { DELEGATE(TerminatorInst);} + RetTy visitSwitchInst(SwitchInst &I) { DELEGATE(TerminatorInst);} + RetTy visitIndirectBrInst(IndirectBrInst &I) { DELEGATE(TerminatorInst);} + RetTy visitResumeInst(ResumeInst &I) { DELEGATE(TerminatorInst);} + RetTy visitUnreachableInst(UnreachableInst &I) { DELEGATE(TerminatorInst);} + RetTy visitICmpInst(ICmpInst &I) { DELEGATE(CmpInst);} + RetTy visitFCmpInst(FCmpInst &I) { DELEGATE(CmpInst);} + RetTy visitAllocaInst(AllocaInst &I) { DELEGATE(UnaryInstruction);} + RetTy visitLoadInst(LoadInst &I) { DELEGATE(UnaryInstruction);} + RetTy visitStoreInst(StoreInst &I) { DELEGATE(Instruction);} + RetTy visitAtomicCmpXchgInst(AtomicCmpXchgInst &I) { DELEGATE(Instruction);} + RetTy visitAtomicRMWInst(AtomicRMWInst &I) { DELEGATE(Instruction);} + RetTy visitFenceInst(FenceInst &I) { DELEGATE(Instruction);} + RetTy visitGetElementPtrInst(GetElementPtrInst &I){ DELEGATE(Instruction);} + RetTy visitPHINode(PHINode &I) { DELEGATE(Instruction);} + RetTy visitTruncInst(TruncInst &I) { DELEGATE(CastInst);} + RetTy visitZExtInst(ZExtInst &I) { DELEGATE(CastInst);} + RetTy visitSExtInst(SExtInst &I) { DELEGATE(CastInst);} + RetTy visitFPTruncInst(FPTruncInst &I) { DELEGATE(CastInst);} + RetTy visitFPExtInst(FPExtInst &I) { DELEGATE(CastInst);} + RetTy visitFPToUIInst(FPToUIInst &I) { DELEGATE(CastInst);} + RetTy visitFPToSIInst(FPToSIInst &I) { DELEGATE(CastInst);} + RetTy visitUIToFPInst(UIToFPInst &I) { DELEGATE(CastInst);} + RetTy visitSIToFPInst(SIToFPInst &I) { DELEGATE(CastInst);} + RetTy visitPtrToIntInst(PtrToIntInst &I) { DELEGATE(CastInst);} + RetTy visitIntToPtrInst(IntToPtrInst &I) { DELEGATE(CastInst);} + RetTy visitBitCastInst(BitCastInst &I) { DELEGATE(CastInst);} + RetTy visitSelectInst(SelectInst &I) { DELEGATE(Instruction);} + RetTy visitVAArgInst(VAArgInst &I) { DELEGATE(UnaryInstruction);} + RetTy visitExtractElementInst(ExtractElementInst &I) { DELEGATE(Instruction);} + RetTy visitInsertElementInst(InsertElementInst &I) { DELEGATE(Instruction);} + RetTy visitShuffleVectorInst(ShuffleVectorInst &I) { DELEGATE(Instruction);} + RetTy visitExtractValueInst(ExtractValueInst &I){ DELEGATE(UnaryInstruction);} + RetTy visitInsertValueInst(InsertValueInst &I) { DELEGATE(Instruction); } + RetTy visitLandingPadInst(LandingPadInst &I) { DELEGATE(Instruction); } + + // Handle the special instrinsic instruction classes. + RetTy visitDbgDeclareInst(DbgDeclareInst &I) { DELEGATE(DbgInfoIntrinsic);} + RetTy visitDbgValueInst(DbgValueInst &I) { DELEGATE(DbgInfoIntrinsic);} + RetTy visitDbgInfoIntrinsic(DbgInfoIntrinsic &I) { DELEGATE(IntrinsicInst); } + RetTy visitMemSetInst(MemSetInst &I) { DELEGATE(MemIntrinsic); } + RetTy visitMemCpyInst(MemCpyInst &I) { DELEGATE(MemTransferInst); } + RetTy visitMemMoveInst(MemMoveInst &I) { DELEGATE(MemTransferInst); } + RetTy visitMemTransferInst(MemTransferInst &I) { DELEGATE(MemIntrinsic); } + RetTy visitMemIntrinsic(MemIntrinsic &I) { DELEGATE(IntrinsicInst); } + RetTy visitIntrinsicInst(IntrinsicInst &I) { DELEGATE(CallInst); } + + // Call and Invoke are slightly different as they delegate first through + // a generic CallSite visitor. + RetTy visitCallInst(CallInst &I) { + return static_cast(this)->visitCallSite(&I); + } + RetTy visitInvokeInst(InvokeInst &I) { + return static_cast(this)->visitCallSite(&I); + } + + // 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) { 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); } + RetTy visitCastInst(CastInst &I) { DELEGATE(UnaryInstruction);} + RetTy visitBinaryOperator(BinaryOperator &I) { DELEGATE(Instruction);} + RetTy visitCmpInst(CmpInst &I) { DELEGATE(Instruction);} + RetTy visitTerminatorInst(TerminatorInst &I) { DELEGATE(Instruction);} + RetTy visitUnaryInstruction(UnaryInstruction &I){ DELEGATE(Instruction);} + + // Provide a special visitor for a 'callsite' that visits both calls and + // invokes. When unimplemented, properly delegates to either the terminator or + // regular instruction visitor. + RetTy visitCallSite(CallSite CS) { + assert(CS); + Instruction &I = *CS.getInstruction(); + if (CS.isCall()) + DELEGATE(Instruction); + + assert(CS.isInvoke()); + DELEGATE(TerminatorInst); + } // 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 + // function. If this function is not overloaded in the user's subclass, then // this instruction just gets ignored. // // 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 + +private: + // Special helper function to delegate to CallInst subclass visitors. + RetTy delegateCallInst(CallInst &I) { + if (const Function *F = I.getCalledFunction()) { + switch ((Intrinsic::ID)F->getIntrinsicID()) { + default: DELEGATE(IntrinsicInst); + case Intrinsic::dbg_declare: DELEGATE(DbgDeclareInst); + case Intrinsic::dbg_value: DELEGATE(DbgValueInst); + case Intrinsic::memcpy: DELEGATE(MemCpyInst); + case Intrinsic::memmove: DELEGATE(MemMoveInst); + case Intrinsic::memset: DELEGATE(MemSetInst); + case Intrinsic::not_intrinsic: break; + } + } + DELEGATE(CallInst); + } + + // An overload that will never actually be called, it is used only from dead + // code in the dispatching from opcodes to instruction subclasses. + RetTy delegateCallInst(Instruction &I) { + llvm_unreachable("delegateCallInst called for non-CallInst"); + } }; #undef DELEGATE +} // End llvm namespace + #endif