1249259Sdim//===- llvm/InstVisitor.h - Instruction visitor templates -------*- C++ -*-===// 2249259Sdim// 3249259Sdim// The LLVM Compiler Infrastructure 4249259Sdim// 5249259Sdim// This file is distributed under the University of Illinois Open Source 6249259Sdim// License. See LICENSE.TXT for details. 7249259Sdim// 8249259Sdim//===----------------------------------------------------------------------===// 9249259Sdim 10249259Sdim 11249259Sdim#ifndef LLVM_INSTVISITOR_H 12249259Sdim#define LLVM_INSTVISITOR_H 13249259Sdim 14249259Sdim#include "llvm/IR/Function.h" 15249259Sdim#include "llvm/IR/Instructions.h" 16249259Sdim#include "llvm/IR/IntrinsicInst.h" 17249259Sdim#include "llvm/IR/Intrinsics.h" 18249259Sdim#include "llvm/IR/Module.h" 19249259Sdim#include "llvm/Support/CallSite.h" 20249259Sdim#include "llvm/Support/ErrorHandling.h" 21249259Sdim 22249259Sdimnamespace llvm { 23249259Sdim 24249259Sdim// We operate on opaque instruction classes, so forward declare all instruction 25249259Sdim// types now... 26249259Sdim// 27249259Sdim#define HANDLE_INST(NUM, OPCODE, CLASS) class CLASS; 28249259Sdim#include "llvm/IR/Instruction.def" 29249259Sdim 30249259Sdim#define DELEGATE(CLASS_TO_VISIT) \ 31249259Sdim return static_cast<SubClass*>(this)-> \ 32249259Sdim visit##CLASS_TO_VISIT(static_cast<CLASS_TO_VISIT&>(I)) 33249259Sdim 34249259Sdim 35249259Sdim/// @brief Base class for instruction visitors 36249259Sdim/// 37249259Sdim/// Instruction visitors are used when you want to perform different actions 38249259Sdim/// for different kinds of instructions without having to use lots of casts 39249259Sdim/// and a big switch statement (in your code, that is). 40249259Sdim/// 41249259Sdim/// To define your own visitor, inherit from this class, specifying your 42249259Sdim/// new type for the 'SubClass' template parameter, and "override" visitXXX 43249259Sdim/// functions in your class. I say "override" because this class is defined 44249259Sdim/// in terms of statically resolved overloading, not virtual functions. 45249259Sdim/// 46249259Sdim/// For example, here is a visitor that counts the number of malloc 47249259Sdim/// instructions processed: 48249259Sdim/// 49249259Sdim/// /// Declare the class. Note that we derive from InstVisitor instantiated 50249259Sdim/// /// with _our new subclasses_ type. 51249259Sdim/// /// 52249259Sdim/// struct CountAllocaVisitor : public InstVisitor<CountAllocaVisitor> { 53249259Sdim/// unsigned Count; 54249259Sdim/// CountAllocaVisitor() : Count(0) {} 55249259Sdim/// 56249259Sdim/// void visitAllocaInst(AllocaInst &AI) { ++Count; } 57249259Sdim/// }; 58249259Sdim/// 59249259Sdim/// And this class would be used like this: 60249259Sdim/// CountAllocaVisitor CAV; 61249259Sdim/// CAV.visit(function); 62249259Sdim/// NumAllocas = CAV.Count; 63249259Sdim/// 64249259Sdim/// The defined has 'visit' methods for Instruction, and also for BasicBlock, 65249259Sdim/// Function, and Module, which recursively process all contained instructions. 66249259Sdim/// 67249259Sdim/// Note that if you don't implement visitXXX for some instruction type, 68249259Sdim/// the visitXXX method for instruction superclass will be invoked. So 69249259Sdim/// if instructions are added in the future, they will be automatically 70249259Sdim/// supported, if you handle one of their superclasses. 71249259Sdim/// 72249259Sdim/// The optional second template argument specifies the type that instruction 73249259Sdim/// visitation functions should return. If you specify this, you *MUST* provide 74249259Sdim/// an implementation of visitInstruction though!. 75249259Sdim/// 76249259Sdim/// Note that this class is specifically designed as a template to avoid 77249259Sdim/// virtual function call overhead. Defining and using an InstVisitor is just 78249259Sdim/// as efficient as having your own switch statement over the instruction 79249259Sdim/// opcode. 80249259Sdimtemplate<typename SubClass, typename RetTy=void> 81249259Sdimclass InstVisitor { 82249259Sdim //===--------------------------------------------------------------------===// 83249259Sdim // Interface code - This is the public interface of the InstVisitor that you 84249259Sdim // use to visit instructions... 85249259Sdim // 86249259Sdim 87249259Sdimpublic: 88249259Sdim // Generic visit method - Allow visitation to all instructions in a range 89249259Sdim template<class Iterator> 90249259Sdim void visit(Iterator Start, Iterator End) { 91249259Sdim while (Start != End) 92249259Sdim static_cast<SubClass*>(this)->visit(*Start++); 93249259Sdim } 94249259Sdim 95249259Sdim // Define visitors for functions and basic blocks... 96249259Sdim // 97249259Sdim void visit(Module &M) { 98249259Sdim static_cast<SubClass*>(this)->visitModule(M); 99249259Sdim visit(M.begin(), M.end()); 100249259Sdim } 101249259Sdim void visit(Function &F) { 102249259Sdim static_cast<SubClass*>(this)->visitFunction(F); 103249259Sdim visit(F.begin(), F.end()); 104249259Sdim } 105249259Sdim void visit(BasicBlock &BB) { 106249259Sdim static_cast<SubClass*>(this)->visitBasicBlock(BB); 107249259Sdim visit(BB.begin(), BB.end()); 108249259Sdim } 109249259Sdim 110249259Sdim // Forwarding functions so that the user can visit with pointers AND refs. 111249259Sdim void visit(Module *M) { visit(*M); } 112249259Sdim void visit(Function *F) { visit(*F); } 113249259Sdim void visit(BasicBlock *BB) { visit(*BB); } 114249259Sdim RetTy visit(Instruction *I) { return visit(*I); } 115249259Sdim 116249259Sdim // visit - Finally, code to visit an instruction... 117249259Sdim // 118249259Sdim RetTy visit(Instruction &I) { 119249259Sdim switch (I.getOpcode()) { 120249259Sdim default: llvm_unreachable("Unknown instruction type encountered!"); 121249259Sdim // Build the switch statement using the Instruction.def file... 122249259Sdim#define HANDLE_INST(NUM, OPCODE, CLASS) \ 123249259Sdim case Instruction::OPCODE: return \ 124249259Sdim static_cast<SubClass*>(this)-> \ 125249259Sdim visit##OPCODE(static_cast<CLASS&>(I)); 126249259Sdim#include "llvm/IR/Instruction.def" 127249259Sdim } 128249259Sdim } 129249259Sdim 130249259Sdim //===--------------------------------------------------------------------===// 131249259Sdim // Visitation functions... these functions provide default fallbacks in case 132249259Sdim // the user does not specify what to do for a particular instruction type. 133249259Sdim // The default behavior is to generalize the instruction type to its subtype 134249259Sdim // and try visiting the subtype. All of this should be inlined perfectly, 135249259Sdim // because there are no virtual functions to get in the way. 136249259Sdim // 137249259Sdim 138249259Sdim // When visiting a module, function or basic block directly, these methods get 139249259Sdim // called to indicate when transitioning into a new unit. 140249259Sdim // 141249259Sdim void visitModule (Module &M) {} 142249259Sdim void visitFunction (Function &F) {} 143249259Sdim void visitBasicBlock(BasicBlock &BB) {} 144249259Sdim 145249259Sdim // Define instruction specific visitor functions that can be overridden to 146249259Sdim // handle SPECIFIC instructions. These functions automatically define 147249259Sdim // visitMul to proxy to visitBinaryOperator for instance in case the user does 148249259Sdim // not need this generality. 149249259Sdim // 150249259Sdim // These functions can also implement fan-out, when a single opcode and 151249259Sdim // instruction have multiple more specific Instruction subclasses. The Call 152249259Sdim // instruction currently supports this. We implement that by redirecting that 153249259Sdim // instruction to a special delegation helper. 154249259Sdim#define HANDLE_INST(NUM, OPCODE, CLASS) \ 155249259Sdim RetTy visit##OPCODE(CLASS &I) { \ 156249259Sdim if (NUM == Instruction::Call) \ 157249259Sdim return delegateCallInst(I); \ 158249259Sdim else \ 159249259Sdim DELEGATE(CLASS); \ 160249259Sdim } 161249259Sdim#include "llvm/IR/Instruction.def" 162249259Sdim 163249259Sdim // Specific Instruction type classes... note that all of the casts are 164249259Sdim // necessary because we use the instruction classes as opaque types... 165249259Sdim // 166249259Sdim RetTy visitReturnInst(ReturnInst &I) { DELEGATE(TerminatorInst);} 167249259Sdim RetTy visitBranchInst(BranchInst &I) { DELEGATE(TerminatorInst);} 168249259Sdim RetTy visitSwitchInst(SwitchInst &I) { DELEGATE(TerminatorInst);} 169249259Sdim RetTy visitIndirectBrInst(IndirectBrInst &I) { DELEGATE(TerminatorInst);} 170249259Sdim RetTy visitResumeInst(ResumeInst &I) { DELEGATE(TerminatorInst);} 171249259Sdim RetTy visitUnreachableInst(UnreachableInst &I) { DELEGATE(TerminatorInst);} 172249259Sdim RetTy visitICmpInst(ICmpInst &I) { DELEGATE(CmpInst);} 173249259Sdim RetTy visitFCmpInst(FCmpInst &I) { DELEGATE(CmpInst);} 174249259Sdim RetTy visitAllocaInst(AllocaInst &I) { DELEGATE(UnaryInstruction);} 175249259Sdim RetTy visitLoadInst(LoadInst &I) { DELEGATE(UnaryInstruction);} 176249259Sdim RetTy visitStoreInst(StoreInst &I) { DELEGATE(Instruction);} 177249259Sdim RetTy visitAtomicCmpXchgInst(AtomicCmpXchgInst &I) { DELEGATE(Instruction);} 178249259Sdim RetTy visitAtomicRMWInst(AtomicRMWInst &I) { DELEGATE(Instruction);} 179249259Sdim RetTy visitFenceInst(FenceInst &I) { DELEGATE(Instruction);} 180249259Sdim RetTy visitGetElementPtrInst(GetElementPtrInst &I){ DELEGATE(Instruction);} 181249259Sdim RetTy visitPHINode(PHINode &I) { DELEGATE(Instruction);} 182249259Sdim RetTy visitTruncInst(TruncInst &I) { DELEGATE(CastInst);} 183249259Sdim RetTy visitZExtInst(ZExtInst &I) { DELEGATE(CastInst);} 184249259Sdim RetTy visitSExtInst(SExtInst &I) { DELEGATE(CastInst);} 185249259Sdim RetTy visitFPTruncInst(FPTruncInst &I) { DELEGATE(CastInst);} 186249259Sdim RetTy visitFPExtInst(FPExtInst &I) { DELEGATE(CastInst);} 187249259Sdim RetTy visitFPToUIInst(FPToUIInst &I) { DELEGATE(CastInst);} 188249259Sdim RetTy visitFPToSIInst(FPToSIInst &I) { DELEGATE(CastInst);} 189249259Sdim RetTy visitUIToFPInst(UIToFPInst &I) { DELEGATE(CastInst);} 190249259Sdim RetTy visitSIToFPInst(SIToFPInst &I) { DELEGATE(CastInst);} 191249259Sdim RetTy visitPtrToIntInst(PtrToIntInst &I) { DELEGATE(CastInst);} 192249259Sdim RetTy visitIntToPtrInst(IntToPtrInst &I) { DELEGATE(CastInst);} 193249259Sdim RetTy visitBitCastInst(BitCastInst &I) { DELEGATE(CastInst);} 194263508Sdim RetTy visitAddrSpaceCastInst(AddrSpaceCastInst &I) { DELEGATE(CastInst);} 195249259Sdim RetTy visitSelectInst(SelectInst &I) { DELEGATE(Instruction);} 196249259Sdim RetTy visitVAArgInst(VAArgInst &I) { DELEGATE(UnaryInstruction);} 197249259Sdim RetTy visitExtractElementInst(ExtractElementInst &I) { DELEGATE(Instruction);} 198249259Sdim RetTy visitInsertElementInst(InsertElementInst &I) { DELEGATE(Instruction);} 199249259Sdim RetTy visitShuffleVectorInst(ShuffleVectorInst &I) { DELEGATE(Instruction);} 200249259Sdim RetTy visitExtractValueInst(ExtractValueInst &I){ DELEGATE(UnaryInstruction);} 201249259Sdim RetTy visitInsertValueInst(InsertValueInst &I) { DELEGATE(Instruction); } 202249259Sdim RetTy visitLandingPadInst(LandingPadInst &I) { DELEGATE(Instruction); } 203249259Sdim 204249259Sdim // Handle the special instrinsic instruction classes. 205249259Sdim RetTy visitDbgDeclareInst(DbgDeclareInst &I) { DELEGATE(DbgInfoIntrinsic);} 206249259Sdim RetTy visitDbgValueInst(DbgValueInst &I) { DELEGATE(DbgInfoIntrinsic);} 207249259Sdim RetTy visitDbgInfoIntrinsic(DbgInfoIntrinsic &I) { DELEGATE(IntrinsicInst); } 208249259Sdim RetTy visitMemSetInst(MemSetInst &I) { DELEGATE(MemIntrinsic); } 209249259Sdim RetTy visitMemCpyInst(MemCpyInst &I) { DELEGATE(MemTransferInst); } 210249259Sdim RetTy visitMemMoveInst(MemMoveInst &I) { DELEGATE(MemTransferInst); } 211249259Sdim RetTy visitMemTransferInst(MemTransferInst &I) { DELEGATE(MemIntrinsic); } 212249259Sdim RetTy visitMemIntrinsic(MemIntrinsic &I) { DELEGATE(IntrinsicInst); } 213249259Sdim RetTy visitVAStartInst(VAStartInst &I) { DELEGATE(IntrinsicInst); } 214249259Sdim RetTy visitVAEndInst(VAEndInst &I) { DELEGATE(IntrinsicInst); } 215249259Sdim RetTy visitVACopyInst(VACopyInst &I) { DELEGATE(IntrinsicInst); } 216249259Sdim RetTy visitIntrinsicInst(IntrinsicInst &I) { DELEGATE(CallInst); } 217249259Sdim 218249259Sdim // Call and Invoke are slightly different as they delegate first through 219249259Sdim // a generic CallSite visitor. 220249259Sdim RetTy visitCallInst(CallInst &I) { 221249259Sdim return static_cast<SubClass*>(this)->visitCallSite(&I); 222249259Sdim } 223249259Sdim RetTy visitInvokeInst(InvokeInst &I) { 224249259Sdim return static_cast<SubClass*>(this)->visitCallSite(&I); 225249259Sdim } 226249259Sdim 227249259Sdim // Next level propagators: If the user does not overload a specific 228249259Sdim // instruction type, they can overload one of these to get the whole class 229249259Sdim // of instructions... 230249259Sdim // 231249259Sdim RetTy visitCastInst(CastInst &I) { DELEGATE(UnaryInstruction);} 232249259Sdim RetTy visitBinaryOperator(BinaryOperator &I) { DELEGATE(Instruction);} 233249259Sdim RetTy visitCmpInst(CmpInst &I) { DELEGATE(Instruction);} 234249259Sdim RetTy visitTerminatorInst(TerminatorInst &I) { DELEGATE(Instruction);} 235249259Sdim RetTy visitUnaryInstruction(UnaryInstruction &I){ DELEGATE(Instruction);} 236249259Sdim 237249259Sdim // Provide a special visitor for a 'callsite' that visits both calls and 238249259Sdim // invokes. When unimplemented, properly delegates to either the terminator or 239249259Sdim // regular instruction visitor. 240249259Sdim RetTy visitCallSite(CallSite CS) { 241249259Sdim assert(CS); 242249259Sdim Instruction &I = *CS.getInstruction(); 243249259Sdim if (CS.isCall()) 244249259Sdim DELEGATE(Instruction); 245249259Sdim 246249259Sdim assert(CS.isInvoke()); 247249259Sdim DELEGATE(TerminatorInst); 248249259Sdim } 249249259Sdim 250249259Sdim // If the user wants a 'default' case, they can choose to override this 251249259Sdim // function. If this function is not overloaded in the user's subclass, then 252249259Sdim // this instruction just gets ignored. 253249259Sdim // 254249259Sdim // Note that you MUST override this function if your return type is not void. 255249259Sdim // 256249259Sdim void visitInstruction(Instruction &I) {} // Ignore unhandled instructions 257249259Sdim 258249259Sdimprivate: 259249259Sdim // Special helper function to delegate to CallInst subclass visitors. 260249259Sdim RetTy delegateCallInst(CallInst &I) { 261249259Sdim if (const Function *F = I.getCalledFunction()) { 262249259Sdim switch ((Intrinsic::ID)F->getIntrinsicID()) { 263249259Sdim default: DELEGATE(IntrinsicInst); 264249259Sdim case Intrinsic::dbg_declare: DELEGATE(DbgDeclareInst); 265249259Sdim case Intrinsic::dbg_value: DELEGATE(DbgValueInst); 266249259Sdim case Intrinsic::memcpy: DELEGATE(MemCpyInst); 267249259Sdim case Intrinsic::memmove: DELEGATE(MemMoveInst); 268249259Sdim case Intrinsic::memset: DELEGATE(MemSetInst); 269249259Sdim case Intrinsic::vastart: DELEGATE(VAStartInst); 270249259Sdim case Intrinsic::vaend: DELEGATE(VAEndInst); 271249259Sdim case Intrinsic::vacopy: DELEGATE(VACopyInst); 272249259Sdim case Intrinsic::not_intrinsic: break; 273249259Sdim } 274249259Sdim } 275249259Sdim DELEGATE(CallInst); 276249259Sdim } 277249259Sdim 278249259Sdim // An overload that will never actually be called, it is used only from dead 279249259Sdim // code in the dispatching from opcodes to instruction subclasses. 280249259Sdim RetTy delegateCallInst(Instruction &I) { 281249259Sdim llvm_unreachable("delegateCallInst called for non-CallInst"); 282249259Sdim } 283249259Sdim}; 284249259Sdim 285249259Sdim#undef DELEGATE 286249259Sdim 287249259Sdim} // End llvm namespace 288249259Sdim 289249259Sdim#endif 290