1 //===- InstVisitor.h - Instruction visitor templates ------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 11 #ifndef LLVM_IR_INSTVISITOR_H 12 #define LLVM_IR_INSTVISITOR_H 13 14 #include "llvm/IR/CallSite.h" 15 #include "llvm/IR/Function.h" 16 #include "llvm/IR/Instructions.h" 17 #include "llvm/IR/IntrinsicInst.h" 18 #include "llvm/IR/Intrinsics.h" 19 #include "llvm/IR/Module.h" 20 #include "llvm/Support/ErrorHandling.h" 21 22 namespace llvm { 23 24 // We operate on opaque instruction classes, so forward declare all instruction 25 // types now... 26 // 27 #define HANDLE_INST(NUM, OPCODE, CLASS) class CLASS; 28 #include "llvm/IR/Instruction.def" 29 30 #define DELEGATE(CLASS_TO_VISIT) \ 31 return static_cast<SubClass*>(this)-> \ 32 visit##CLASS_TO_VISIT(static_cast<CLASS_TO_VISIT&>(I)) 33 34 35 /// @brief Base class for instruction visitors 36 /// 37 /// Instruction visitors are used when you want to perform different actions 38 /// for different kinds of instructions without having to use lots of casts 39 /// and a big switch statement (in your code, that is). 40 /// 41 /// To define your own visitor, inherit from this class, specifying your 42 /// new type for the 'SubClass' template parameter, and "override" visitXXX 43 /// functions in your class. I say "override" because this class is defined 44 /// in terms of statically resolved overloading, not virtual functions. 45 /// 46 /// For example, here is a visitor that counts the number of malloc 47 /// instructions processed: 48 /// 49 /// /// Declare the class. Note that we derive from InstVisitor instantiated 50 /// /// with _our new subclasses_ type. 51 /// /// 52 /// struct CountAllocaVisitor : public InstVisitor<CountAllocaVisitor> { 53 /// unsigned Count; 54 /// CountAllocaVisitor() : Count(0) {} 55 /// 56 /// void visitAllocaInst(AllocaInst &AI) { ++Count; } 57 /// }; 58 /// 59 /// And this class would be used like this: 60 /// CountAllocaVisitor CAV; 61 /// CAV.visit(function); 62 /// NumAllocas = CAV.Count; 63 /// 64 /// The defined has 'visit' methods for Instruction, and also for BasicBlock, 65 /// Function, and Module, which recursively process all contained instructions. 66 /// 67 /// Note that if you don't implement visitXXX for some instruction type, 68 /// the visitXXX method for instruction superclass will be invoked. So 69 /// if instructions are added in the future, they will be automatically 70 /// supported, if you handle one of their superclasses. 71 /// 72 /// The optional second template argument specifies the type that instruction 73 /// visitation functions should return. If you specify this, you *MUST* provide 74 /// an implementation of visitInstruction though!. 75 /// 76 /// Note that this class is specifically designed as a template to avoid 77 /// virtual function call overhead. Defining and using an InstVisitor is just 78 /// as efficient as having your own switch statement over the instruction 79 /// opcode. 80 template<typename SubClass, typename RetTy=void> 81 class InstVisitor { 82 //===--------------------------------------------------------------------===// 83 // Interface code - This is the public interface of the InstVisitor that you 84 // use to visit instructions... 85 // 86 87 public: 88 // Generic visit method - Allow visitation to all instructions in a range 89 template<class Iterator> 90 void visit(Iterator Start, Iterator End) { 91 while (Start != End) 92 static_cast<SubClass*>(this)->visit(*Start++); 93 } 94 95 // Define visitors for functions and basic blocks... 96 // 97 void visit(Module &M) { 98 static_cast<SubClass*>(this)->visitModule(M); 99 visit(M.begin(), M.end()); 100 } 101 void visit(Function &F) { 102 static_cast<SubClass*>(this)->visitFunction(F); 103 visit(F.begin(), F.end()); 104 } 105 void visit(BasicBlock &BB) { 106 static_cast<SubClass*>(this)->visitBasicBlock(BB); 107 visit(BB.begin(), BB.end()); 108 } 109 110 // Forwarding functions so that the user can visit with pointers AND refs. 111 void visit(Module *M) { visit(*M); } 112 void visit(Function *F) { visit(*F); } 113 void visit(BasicBlock *BB) { visit(*BB); } 114 RetTy visit(Instruction *I) { return visit(*I); } 115 116 // visit - Finally, code to visit an instruction... 117 // 118 RetTy visit(Instruction &I) { 119 static_assert(std::is_base_of<InstVisitor, SubClass>::value, 120 "Must pass the derived type to this template!"); 121 122 switch (I.getOpcode()) { 123 default: llvm_unreachable("Unknown instruction type encountered!"); 124 // Build the switch statement using the Instruction.def file... 125 #define HANDLE_INST(NUM, OPCODE, CLASS) \ 126 case Instruction::OPCODE: return \ 127 static_cast<SubClass*>(this)-> \ 128 visit##OPCODE(static_cast<CLASS&>(I)); 129 #include "llvm/IR/Instruction.def" 130 } 131 } 132 133 //===--------------------------------------------------------------------===// 134 // Visitation functions... these functions provide default fallbacks in case 135 // the user does not specify what to do for a particular instruction type. 136 // The default behavior is to generalize the instruction type to its subtype 137 // and try visiting the subtype. All of this should be inlined perfectly, 138 // because there are no virtual functions to get in the way. 139 // 140 141 // When visiting a module, function or basic block directly, these methods get 142 // called to indicate when transitioning into a new unit. 143 // 144 void visitModule (Module &M) {} 145 void visitFunction (Function &F) {} 146 void visitBasicBlock(BasicBlock &BB) {} 147 148 // Define instruction specific visitor functions that can be overridden to 149 // handle SPECIFIC instructions. These functions automatically define 150 // visitMul to proxy to visitBinaryOperator for instance in case the user does 151 // not need this generality. 152 // 153 // These functions can also implement fan-out, when a single opcode and 154 // instruction have multiple more specific Instruction subclasses. The Call 155 // instruction currently supports this. We implement that by redirecting that 156 // instruction to a special delegation helper. 157 #define HANDLE_INST(NUM, OPCODE, CLASS) \ 158 RetTy visit##OPCODE(CLASS &I) { \ 159 if (NUM == Instruction::Call) \ 160 return delegateCallInst(I); \ 161 else \ 162 DELEGATE(CLASS); \ 163 } 164 #include "llvm/IR/Instruction.def" 165 166 // Specific Instruction type classes... note that all of the casts are 167 // necessary because we use the instruction classes as opaque types... 168 // 169 RetTy visitReturnInst(ReturnInst &I) { DELEGATE(TerminatorInst);} 170 RetTy visitBranchInst(BranchInst &I) { DELEGATE(TerminatorInst);} 171 RetTy visitSwitchInst(SwitchInst &I) { DELEGATE(TerminatorInst);} 172 RetTy visitIndirectBrInst(IndirectBrInst &I) { DELEGATE(TerminatorInst);} 173 RetTy visitResumeInst(ResumeInst &I) { DELEGATE(TerminatorInst);} 174 RetTy visitUnreachableInst(UnreachableInst &I) { DELEGATE(TerminatorInst);} 175 RetTy visitCleanupReturnInst(CleanupReturnInst &I) { DELEGATE(TerminatorInst);} 176 RetTy visitCatchReturnInst(CatchReturnInst &I) { DELEGATE(TerminatorInst); } 177 RetTy visitCatchSwitchInst(CatchSwitchInst &I) { DELEGATE(TerminatorInst);} 178 RetTy visitICmpInst(ICmpInst &I) { DELEGATE(CmpInst);} 179 RetTy visitFCmpInst(FCmpInst &I) { DELEGATE(CmpInst);} 180 RetTy visitAllocaInst(AllocaInst &I) { DELEGATE(UnaryInstruction);} 181 RetTy visitLoadInst(LoadInst &I) { DELEGATE(UnaryInstruction);} 182 RetTy visitStoreInst(StoreInst &I) { DELEGATE(Instruction);} 183 RetTy visitAtomicCmpXchgInst(AtomicCmpXchgInst &I) { DELEGATE(Instruction);} 184 RetTy visitAtomicRMWInst(AtomicRMWInst &I) { DELEGATE(Instruction);} 185 RetTy visitFenceInst(FenceInst &I) { DELEGATE(Instruction);} 186 RetTy visitGetElementPtrInst(GetElementPtrInst &I){ DELEGATE(Instruction);} 187 RetTy visitPHINode(PHINode &I) { DELEGATE(Instruction);} 188 RetTy visitTruncInst(TruncInst &I) { DELEGATE(CastInst);} 189 RetTy visitZExtInst(ZExtInst &I) { DELEGATE(CastInst);} 190 RetTy visitSExtInst(SExtInst &I) { DELEGATE(CastInst);} 191 RetTy visitFPTruncInst(FPTruncInst &I) { DELEGATE(CastInst);} 192 RetTy visitFPExtInst(FPExtInst &I) { DELEGATE(CastInst);} 193 RetTy visitFPToUIInst(FPToUIInst &I) { DELEGATE(CastInst);} 194 RetTy visitFPToSIInst(FPToSIInst &I) { DELEGATE(CastInst);} 195 RetTy visitUIToFPInst(UIToFPInst &I) { DELEGATE(CastInst);} 196 RetTy visitSIToFPInst(SIToFPInst &I) { DELEGATE(CastInst);} 197 RetTy visitPtrToIntInst(PtrToIntInst &I) { DELEGATE(CastInst);} 198 RetTy visitIntToPtrInst(IntToPtrInst &I) { DELEGATE(CastInst);} 199 RetTy visitBitCastInst(BitCastInst &I) { DELEGATE(CastInst);} 200 RetTy visitAddrSpaceCastInst(AddrSpaceCastInst &I) { DELEGATE(CastInst);} 201 RetTy visitSelectInst(SelectInst &I) { DELEGATE(Instruction);} 202 RetTy visitVAArgInst(VAArgInst &I) { DELEGATE(UnaryInstruction);} 203 RetTy visitExtractElementInst(ExtractElementInst &I) { DELEGATE(Instruction);} 204 RetTy visitInsertElementInst(InsertElementInst &I) { DELEGATE(Instruction);} 205 RetTy visitShuffleVectorInst(ShuffleVectorInst &I) { DELEGATE(Instruction);} 206 RetTy visitExtractValueInst(ExtractValueInst &I){ DELEGATE(UnaryInstruction);} 207 RetTy visitInsertValueInst(InsertValueInst &I) { DELEGATE(Instruction); } 208 RetTy visitLandingPadInst(LandingPadInst &I) { DELEGATE(Instruction); } 209 RetTy visitFuncletPadInst(FuncletPadInst &I) { DELEGATE(Instruction); } 210 RetTy visitCleanupPadInst(CleanupPadInst &I) { DELEGATE(FuncletPadInst); } 211 RetTy visitCatchPadInst(CatchPadInst &I) { DELEGATE(FuncletPadInst); } 212 213 // Handle the special instrinsic instruction classes. 214 RetTy visitDbgDeclareInst(DbgDeclareInst &I) { DELEGATE(DbgInfoIntrinsic);} 215 RetTy visitDbgValueInst(DbgValueInst &I) { DELEGATE(DbgInfoIntrinsic);} 216 RetTy visitDbgInfoIntrinsic(DbgInfoIntrinsic &I) { DELEGATE(IntrinsicInst); } 217 RetTy visitMemSetInst(MemSetInst &I) { DELEGATE(MemIntrinsic); } 218 RetTy visitMemCpyInst(MemCpyInst &I) { DELEGATE(MemTransferInst); } 219 RetTy visitMemMoveInst(MemMoveInst &I) { DELEGATE(MemTransferInst); } 220 RetTy visitMemTransferInst(MemTransferInst &I) { DELEGATE(MemIntrinsic); } 221 RetTy visitMemIntrinsic(MemIntrinsic &I) { DELEGATE(IntrinsicInst); } 222 RetTy visitVAStartInst(VAStartInst &I) { DELEGATE(IntrinsicInst); } 223 RetTy visitVAEndInst(VAEndInst &I) { DELEGATE(IntrinsicInst); } 224 RetTy visitVACopyInst(VACopyInst &I) { DELEGATE(IntrinsicInst); } 225 RetTy visitIntrinsicInst(IntrinsicInst &I) { DELEGATE(CallInst); } 226 227 // Call and Invoke are slightly different as they delegate first through 228 // a generic CallSite visitor. 229 RetTy visitCallInst(CallInst &I) { 230 return static_cast<SubClass*>(this)->visitCallSite(&I); 231 } 232 RetTy visitInvokeInst(InvokeInst &I) { 233 return static_cast<SubClass*>(this)->visitCallSite(&I); 234 } 235 236 // Next level propagators: If the user does not overload a specific 237 // instruction type, they can overload one of these to get the whole class 238 // of instructions... 239 // 240 RetTy visitCastInst(CastInst &I) { DELEGATE(UnaryInstruction);} 241 RetTy visitBinaryOperator(BinaryOperator &I) { DELEGATE(Instruction);} 242 RetTy visitCmpInst(CmpInst &I) { DELEGATE(Instruction);} 243 RetTy visitTerminatorInst(TerminatorInst &I) { DELEGATE(Instruction);} 244 RetTy visitUnaryInstruction(UnaryInstruction &I){ DELEGATE(Instruction);} 245 246 // Provide a special visitor for a 'callsite' that visits both calls and 247 // invokes. When unimplemented, properly delegates to either the terminator or 248 // regular instruction visitor. 249 RetTy visitCallSite(CallSite CS) { 250 assert(CS); 251 Instruction &I = *CS.getInstruction(); 252 if (CS.isCall()) 253 DELEGATE(Instruction); 254 255 assert(CS.isInvoke()); 256 DELEGATE(TerminatorInst); 257 } 258 259 // If the user wants a 'default' case, they can choose to override this 260 // function. If this function is not overloaded in the user's subclass, then 261 // this instruction just gets ignored. 262 // 263 // Note that you MUST override this function if your return type is not void. 264 // 265 void visitInstruction(Instruction &I) {} // Ignore unhandled instructions 266 267 private: 268 // Special helper function to delegate to CallInst subclass visitors. 269 RetTy delegateCallInst(CallInst &I) { 270 if (const Function *F = I.getCalledFunction()) { 271 switch (F->getIntrinsicID()) { 272 default: DELEGATE(IntrinsicInst); 273 case Intrinsic::dbg_declare: DELEGATE(DbgDeclareInst); 274 case Intrinsic::dbg_value: DELEGATE(DbgValueInst); 275 case Intrinsic::memcpy: DELEGATE(MemCpyInst); 276 case Intrinsic::memmove: DELEGATE(MemMoveInst); 277 case Intrinsic::memset: DELEGATE(MemSetInst); 278 case Intrinsic::vastart: DELEGATE(VAStartInst); 279 case Intrinsic::vaend: DELEGATE(VAEndInst); 280 case Intrinsic::vacopy: DELEGATE(VACopyInst); 281 case Intrinsic::not_intrinsic: break; 282 } 283 } 284 DELEGATE(CallInst); 285 } 286 287 // An overload that will never actually be called, it is used only from dead 288 // code in the dispatching from opcodes to instruction subclasses. 289 RetTy delegateCallInst(Instruction &I) { 290 llvm_unreachable("delegateCallInst called for non-CallInst"); 291 } 292 }; 293 294 #undef DELEGATE 295 296 } // End llvm namespace 297 298 #endif 299
