1 //===- InstVisitor.h - Instruction visitor templates ------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
11 #ifndef LLVM_IR_INSTVISITOR_H
12 #define LLVM_IR_INSTVISITOR_H
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"
24 // We operate on opaque instruction classes, so forward declare all instruction
27 #define HANDLE_INST(NUM, OPCODE, CLASS) class CLASS;
28 #include "llvm/IR/Instruction.def"
30 #define DELEGATE(CLASS_TO_VISIT) \
31 return static_cast<SubClass*>(this)-> \
32 visit##CLASS_TO_VISIT(static_cast<CLASS_TO_VISIT&>(I))
35 /// @brief Base class for instruction visitors
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).
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.
46 /// For example, here is a visitor that counts the number of malloc
47 /// instructions processed:
49 /// /// Declare the class. Note that we derive from InstVisitor instantiated
50 /// /// with _our new subclasses_ type.
52 /// struct CountAllocaVisitor : public InstVisitor<CountAllocaVisitor> {
54 /// CountAllocaVisitor() : Count(0) {}
56 /// void visitAllocaInst(AllocaInst &AI) { ++Count; }
59 /// And this class would be used like this:
60 /// CountAllocaVisitor CAV;
61 /// CAV.visit(function);
62 /// NumAllocas = CAV.Count;
64 /// The defined has 'visit' methods for Instruction, and also for BasicBlock,
65 /// Function, and Module, which recursively process all contained instructions.
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.
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!.
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
80 template<typename SubClass, typename RetTy=void>
82 //===--------------------------------------------------------------------===//
83 // Interface code - This is the public interface of the InstVisitor that you
84 // use to visit instructions...
88 // Generic visit method - Allow visitation to all instructions in a range
89 template<class Iterator>
90 void visit(Iterator Start, Iterator End) {
92 static_cast<SubClass*>(this)->visit(*Start++);
95 // Define visitors for functions and basic blocks...
97 void visit(Module &M) {
98 static_cast<SubClass*>(this)->visitModule(M);
99 visit(M.begin(), M.end());
101 void visit(Function &F) {
102 static_cast<SubClass*>(this)->visitFunction(F);
103 visit(F.begin(), F.end());
105 void visit(BasicBlock &BB) {
106 static_cast<SubClass*>(this)->visitBasicBlock(BB);
107 visit(BB.begin(), BB.end());
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); }
116 // visit - Finally, code to visit an instruction...
118 RetTy visit(Instruction &I) {
119 static_assert(std::is_base_of<InstVisitor, SubClass>::value,
120 "Must pass the derived type to this template!");
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"
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.
141 // When visiting a module, function or basic block directly, these methods get
142 // called to indicate when transitioning into a new unit.
144 void visitModule (Module &M) {}
145 void visitFunction (Function &F) {}
146 void visitBasicBlock(BasicBlock &BB) {}
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.
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); \
164 #include "llvm/IR/Instruction.def"
166 // Specific Instruction type classes... note that all of the casts are
167 // necessary because we use the instruction classes as opaque types...
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); }
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); }
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);
232 RetTy visitInvokeInst(InvokeInst &I) {
233 return static_cast<SubClass*>(this)->visitCallSite(&I);
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...
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);}
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) {
251 Instruction &I = *CS.getInstruction();
253 DELEGATE(Instruction);
255 assert(CS.isInvoke());
256 DELEGATE(TerminatorInst);
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.
263 // Note that you MUST override this function if your return type is not void.
265 void visitInstruction(Instruction &I) {} // Ignore unhandled instructions
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;
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");
296 } // End llvm namespace