X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FSupport%2FInstVisitor.h;h=e848c9b576164b5e89124740e2df01c6aa7c12eb;hb=a727d5502c8e23c090da658bf14c5ebc1169a070;hp=f8298e313d83d94e891bf555ec560af61a1d0d8f;hpb=99e7ab72c8909469141358552ece13d701d17274;p=oota-llvm.git diff --git a/include/llvm/Support/InstVisitor.h b/include/llvm/Support/InstVisitor.h index f8298e313d8..e848c9b5761 100644 --- a/include/llvm/Support/InstVisitor.h +++ b/include/llvm/Support/InstVisitor.h @@ -1,51 +1,21 @@ //===- 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 was developed by the LLVM research group and 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/Module.h" -class Module; +namespace llvm { // We operate on opaque instruction classes, so forward declare all instruction // types now... @@ -57,35 +27,83 @@ class Module; class TerminatorInst; class BinaryOperator; class AllocationInst; - #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 action for +/// different kinds of instruction without 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 "overriding" 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 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; +/// +/// The defined has 'visit' methods for Instruction, and also for BasicBlock, +/// Function, and Module, which recursively process all conained 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 on 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) - ((SubClass*)this)->visit(*Start++); + static_cast(this)->visit(*Start++); } // Define visitors for functions and basic blocks... // + void visit(Module &M) { + static_cast(this)->visitModule(M); + visit(M.begin(), M.end()); + } void visit(Function &F) { - ((SubClass*)this)->visitFunction(F); + static_cast(this)->visitFunction(F); visit(F.begin(), F.end()); } void visit(BasicBlock &BB) { - ((SubClass*)this)->visitBasicBlock(BB); + static_cast(this)->visitBasicBlock(BB); visit(BB.begin(), BB.end()); } @@ -103,7 +121,9 @@ struct InstVisitor { abort(); // 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" } } @@ -119,10 +139,10 @@ 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) {} - // 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 @@ -136,20 +156,8 @@ struct InstVisitor { // #define HANDLE_INST(NUM, OPCODE, CLASS) \ RetTy visit##OPCODE(CLASS &I) { DELEGATE(CLASS); } -#define HANDLE_OTHER_INST(NUM, OPCODE, CLASS) // Handle "other" insts specially #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 visitVANext(VANextInst &I) { DELEGATE(VANextInst); } - RetTy visitVAArg (VAArgInst &I) { DELEGATE(VAArgInst); } - RetTy visitUserOp1(Instruction &I) { DELEGATE(Instruction); } - RetTy visitUserOp2(Instruction &I) { DELEGATE(Instruction); } - - // Specific Instruction type classes... note that all of the casts are // necessary because we use the instruction classes as opaque types... // @@ -158,7 +166,9 @@ struct InstVisitor { RetTy visitSwitchInst(SwitchInst &I) { DELEGATE(TerminatorInst);} RetTy visitInvokeInst(InvokeInst &I) { DELEGATE(TerminatorInst);} RetTy visitUnwindInst(UnwindInst &I) { DELEGATE(TerminatorInst);} - RetTy visitSetCondInst(SetCondInst &I) { DELEGATE(BinaryOperator);} + RetTy visitUnreachableInst(UnreachableInst &I) { DELEGATE(TerminatorInst);} + RetTy visitICmpInst(ICmpInst &I) { DELEGATE(CmpInst);} + RetTy visitFCmpInst(FCmpInst &I) { DELEGATE(CmpInst);} RetTy visitMallocInst(MallocInst &I) { DELEGATE(AllocationInst);} RetTy visitAllocaInst(AllocaInst &I) { DELEGATE(AllocationInst);} RetTy visitFreeInst(FreeInst &I) { DELEGATE(Instruction); } @@ -166,11 +176,24 @@ struct InstVisitor { 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 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 visitCallInst(CallInst &I) { DELEGATE(Instruction); } - RetTy visitShiftInst(ShiftInst &I) { DELEGATE(Instruction); } - RetTy visitVANextInst(VANextInst &I) { DELEGATE(Instruction); } RetTy visitVAArgInst(VAArgInst &I) { DELEGATE(Instruction); } + RetTy visitExtractElementInst(ExtractElementInst &I) { DELEGATE(Instruction);} + RetTy visitInsertElementInst(InsertElementInst &I) { DELEGATE(Instruction); } + RetTy visitShuffleVectorInst(ShuffleVectorInst &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 @@ -179,6 +202,8 @@ struct InstVisitor { RetTy visitTerminatorInst(TerminatorInst &I) { DELEGATE(Instruction); } RetTy visitBinaryOperator(BinaryOperator &I) { DELEGATE(Instruction); } RetTy visitAllocationInst(AllocationInst &I) { DELEGATE(Instruction); } + RetTy visitCmpInst(CmpInst &I) { DELEGATE(Instruction); } + RetTy visitCastInst(CastInst &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 @@ -191,4 +216,6 @@ struct InstVisitor { #undef DELEGATE +} // End llvm namespace + #endif