Line data Source code
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 : /// 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 111442 : void visit(Iterator Start, Iterator End) {
91 22783397 : while (Start != End)
92 18732896 : static_cast<SubClass*>(this)->visit(*Start++);
93 111441 : }
94 409 :
95 7108 : // Define visitors for functions and basic blocks...
96 3681 : //
97 409 : void visit(Module &M) {
98 308 : static_cast<SubClass*>(this)->visitModule(M);
99 5593 : visit(M.begin(), M.end());
100 2901 : }
101 1120848 : void visit(Function &F) {
102 1120698 : static_cast<SubClass*>(this)->visitFunction(F);
103 113248 : visit(F.begin(), F.end());
104 1121885 : }
105 1215433 : void visit(BasicBlock &BB) {
106 1215275 : static_cast<SubClass*>(this)->visitBasicBlock(BB);
107 : visit(BB.begin(), BB.end());
108 1215275 : }
109 0 :
110 : // Forwarding functions so that the user can visit with pointers AND refs.
111 : void visit(Module *M) { visit(*M); }
112 0 : void visit(Function *F) { visit(*F); }
113 0 : void visit(BasicBlock *BB) { visit(*BB); }
114 20175015 : RetTy visit(Instruction *I) { return visit(*I); }
115 717 :
116 0 : // visit - Finally, code to visit an instruction...
117 : //
118 71050291 : 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 64345270 : switch (I.getOpcode()) {
123 0 : 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 0 : case Instruction::OPCODE: return \
127 : static_cast<SubClass*>(this)-> \
128 : visit##OPCODE(static_cast<CLASS&>(I));
129 : #include "llvm/IR/Instruction.def"
130 7927 : }
131 0 : }
132 651265 :
133 : //===--------------------------------------------------------------------===//
134 : // Visitation functions... these functions provide default fallbacks in case
135 0 : // the user does not specify what to do for a particular instruction type.
136 651265 : // The default behavior is to generalize the instruction type to its subtype
137 0 : // 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 3681 : void visitModule (Module &M) {}
145 0 : void visitFunction (Function &F) {}
146 2560204 : void visitBasicBlock(BasicBlock &BB) {}
147 :
148 : // Define instruction specific visitor functions that can be overridden to
149 0 : // handle SPECIFIC instructions. These functions automatically define
150 2560204 : // visitMul to proxy to visitBinaryOperator for instance in case the user does
151 0 : // 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 2901 : RetTy visit##OPCODE(CLASS &I) { \
159 : if (NUM == Instruction::Call) \
160 371233 : return delegateCallInst(I); \
161 : else \
162 : DELEGATE(CLASS); \
163 0 : }
164 371233 : #include "llvm/IR/Instruction.def"
165 0 :
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 520694 : RetTy visitICmpInst(ICmpInst &I) { DELEGATE(CmpInst);}
170 2669 : RetTy visitFCmpInst(FCmpInst &I) { DELEGATE(CmpInst);}
171 2598074 : RetTy visitAllocaInst(AllocaInst &I) { DELEGATE(UnaryInstruction);}
172 1345 : RetTy visitLoadInst(LoadInst &I) { DELEGATE(UnaryInstruction);}
173 5268 : RetTy visitStoreInst(StoreInst &I) { DELEGATE(Instruction);}
174 600 : RetTy visitAtomicCmpXchgInst(AtomicCmpXchgInst &I) { DELEGATE(Instruction);}
175 530 : RetTy visitAtomicRMWInst(AtomicRMWInst &I) { DELEGATE(Instruction);}
176 10 : RetTy visitFenceInst(FenceInst &I) { DELEGATE(Instruction);}
177 6974 : RetTy visitGetElementPtrInst(GetElementPtrInst &I){ DELEGATE(Instruction);}
178 9419 : RetTy visitPHINode(PHINode &I) { DELEGATE(Instruction);}
179 15795 : RetTy visitTruncInst(TruncInst &I) { DELEGATE(CastInst);}
180 53309 : RetTy visitZExtInst(ZExtInst &I) { DELEGATE(CastInst);}
181 15953 : RetTy visitSExtInst(SExtInst &I) { DELEGATE(CastInst);}
182 383 : RetTy visitFPTruncInst(FPTruncInst &I) { DELEGATE(CastInst);}
183 505 : RetTy visitFPExtInst(FPExtInst &I) { DELEGATE(CastInst);}
184 62 : RetTy visitFPToUIInst(FPToUIInst &I) { DELEGATE(CastInst);}
185 78 : RetTy visitFPToSIInst(FPToSIInst &I) { DELEGATE(CastInst);}
186 118 : RetTy visitUIToFPInst(UIToFPInst &I) { DELEGATE(CastInst);}
187 197 : RetTy visitSIToFPInst(SIToFPInst &I) { DELEGATE(CastInst);}
188 19209 : RetTy visitPtrToIntInst(PtrToIntInst &I) { DELEGATE(CastInst);}
189 5557 : RetTy visitIntToPtrInst(IntToPtrInst &I) { DELEGATE(CastInst);}
190 260566 : RetTy visitBitCastInst(BitCastInst &I) { DELEGATE(CastInst);}
191 510 : RetTy visitAddrSpaceCastInst(AddrSpaceCastInst &I) { DELEGATE(CastInst);}
192 12024 : RetTy visitSelectInst(SelectInst &I) { DELEGATE(Instruction);}
193 0 : RetTy visitVAArgInst(VAArgInst &I) { DELEGATE(UnaryInstruction);}
194 8 : RetTy visitExtractElementInst(ExtractElementInst &I) { DELEGATE(Instruction);}
195 0 : RetTy visitInsertElementInst(InsertElementInst &I) { DELEGATE(Instruction);}
196 0 : RetTy visitShuffleVectorInst(ShuffleVectorInst &I) { DELEGATE(Instruction);}
197 0 : RetTy visitExtractValueInst(ExtractValueInst &I){ DELEGATE(UnaryInstruction);}
198 0 : RetTy visitInsertValueInst(InsertValueInst &I) { DELEGATE(Instruction); }
199 129269 : RetTy visitLandingPadInst(LandingPadInst &I) { DELEGATE(Instruction); }
200 6 : RetTy visitFuncletPadInst(FuncletPadInst &I) { DELEGATE(Instruction); }
201 0 : RetTy visitCleanupPadInst(CleanupPadInst &I) { DELEGATE(FuncletPadInst); }
202 0 : RetTy visitCatchPadInst(CatchPadInst &I) { DELEGATE(FuncletPadInst); }
203 0 :
204 0 : // Handle the special instrinsic instruction classes.
205 0 : RetTy visitDbgDeclareInst(DbgDeclareInst &I) { DELEGATE(DbgVariableIntrinsic);}
206 0 : RetTy visitDbgValueInst(DbgValueInst &I) { DELEGATE(DbgVariableIntrinsic);}
207 0 : RetTy visitDbgVariableIntrinsic(DbgVariableIntrinsic &I)
208 0 : { DELEGATE(DbgInfoIntrinsic);}
209 0 : RetTy visitDbgLabelInst(DbgLabelInst &I) { DELEGATE(DbgInfoIntrinsic);}
210 47 : RetTy visitDbgInfoIntrinsic(DbgInfoIntrinsic &I){ DELEGATE(IntrinsicInst); }
211 1880 : RetTy visitMemSetInst(MemSetInst &I) { DELEGATE(MemIntrinsic); }
212 0 : RetTy visitMemCpyInst(MemCpyInst &I) { DELEGATE(MemTransferInst); }
213 0 : RetTy visitMemMoveInst(MemMoveInst &I) { DELEGATE(MemTransferInst); }
214 2206 : RetTy visitMemTransferInst(MemTransferInst &I) { DELEGATE(MemIntrinsic); }
215 92 : RetTy visitMemIntrinsic(MemIntrinsic &I) { DELEGATE(IntrinsicInst); }
216 20 : RetTy visitVAStartInst(VAStartInst &I) { DELEGATE(IntrinsicInst); }
217 9 : RetTy visitVAEndInst(VAEndInst &I) { DELEGATE(IntrinsicInst); }
218 0 : RetTy visitVACopyInst(VACopyInst &I) { DELEGATE(IntrinsicInst); }
219 2559827 : RetTy visitIntrinsicInst(IntrinsicInst &I) { DELEGATE(CallInst); }
220 :
221 0 : // Call and Invoke are slightly different as they delegate first through
222 0 : // a generic CallSite visitor.
223 0 : RetTy visitCallInst(CallInst &I) {
224 987688 : return static_cast<SubClass*>(this)->visitCallSite(&I);
225 0 : }
226 0 : RetTy visitInvokeInst(InvokeInst &I) {
227 186769 : return static_cast<SubClass*>(this)->visitCallSite(&I);
228 0 : }
229 0 :
230 0 : // While terminators don't have a distinct type modeling them, we support
231 0 : // intercepting them with dedicated a visitor callback.
232 0 : RetTy visitReturnInst(ReturnInst &I) {
233 0 : return static_cast<SubClass *>(this)->visitTerminator(I);
234 0 : }
235 0 : RetTy visitBranchInst(BranchInst &I) {
236 346590 : return static_cast<SubClass *>(this)->visitTerminator(I);
237 0 : }
238 0 : RetTy visitSwitchInst(SwitchInst &I) {
239 2496 : return static_cast<SubClass *>(this)->visitTerminator(I);
240 1 : }
241 0 : RetTy visitIndirectBrInst(IndirectBrInst &I) {
242 14 : return static_cast<SubClass *>(this)->visitTerminator(I);
243 0 : }
244 0 : RetTy visitResumeInst(ResumeInst &I) {
245 0 : return static_cast<SubClass *>(this)->visitTerminator(I);
246 0 : }
247 581 : RetTy visitUnreachableInst(UnreachableInst &I) {
248 12650 : return static_cast<SubClass *>(this)->visitTerminator(I);
249 0 : }
250 0 : RetTy visitCleanupReturnInst(CleanupReturnInst &I) {
251 34 : return static_cast<SubClass *>(this)->visitTerminator(I);
252 21423 : }
253 0 : RetTy visitCatchReturnInst(CatchReturnInst &I) {
254 8 : return static_cast<SubClass *>(this)->visitTerminator(I);
255 3305 : }
256 0 : RetTy visitCatchSwitchInst(CatchSwitchInst &I) {
257 0 : return static_cast<SubClass *>(this)->visitTerminator(I);
258 9516 : }
259 186033 : RetTy visitTerminator(Instruction &I) { DELEGATE(Instruction);}
260 0 :
261 0 : // Next level propagators: If the user does not overload a specific
262 38 : // instruction type, they can overload one of these to get the whole class
263 0 : // of instructions...
264 2 : //
265 54 : RetTy visitCastInst(CastInst &I) { DELEGATE(UnaryInstruction);}
266 0 : RetTy visitBinaryOperator(BinaryOperator &I) { DELEGATE(Instruction);}
267 600 : RetTy visitCmpInst(CmpInst &I) { DELEGATE(Instruction);}
268 2232 : RetTy visitUnaryInstruction(UnaryInstruction &I){ DELEGATE(Instruction);}
269 23422 :
270 23422 : // Provide a special visitor for a 'callsite' that visits both calls and
271 0 : // invokes. When unimplemented, properly delegates to either the terminator or
272 17 : // regular instruction visitor.
273 1145009 : RetTy visitCallSite(CallSite CS) {
274 0 : assert(CS);
275 0 : Instruction &I = *CS.getInstruction();
276 1145009 : if (CS.isCall())
277 958614 : DELEGATE(Instruction);
278 23422 :
279 23422 : assert(CS.isInvoke());
280 186409 : return static_cast<SubClass *>(this)->visitTerminator(I);
281 28777 : }
282 28879 :
283 : // If the user wants a 'default' case, they can choose to override this
284 28777 : // function. If this function is not overloaded in the user's subclass, then
285 28777 : // this instruction just gets ignored.
286 : //
287 0 : // Note that you MUST override this function if your return type is not void.
288 0 : //
289 0 : void visitInstruction(Instruction &I) {} // Ignore unhandled instructions
290 0 :
291 7 : private:
292 : // Special helper function to delegate to CallInst subclass visitors.
293 5440688 : RetTy delegateCallInst(CallInst &I) {
294 0 : if (const Function *F = I.getCalledFunction()) {
295 5228833 : switch (F->getIntrinsicID()) {
296 1787295 : default: DELEGATE(IntrinsicInst);
297 11743 : case Intrinsic::dbg_declare: DELEGATE(DbgDeclareInst);
298 453692 : case Intrinsic::dbg_value: DELEGATE(DbgValueInst);
299 81 : case Intrinsic::dbg_label: DELEGATE(DbgLabelInst);
300 46525 : case Intrinsic::memcpy: DELEGATE(MemCpyInst);
301 10705 : case Intrinsic::memmove: DELEGATE(MemMoveInst);
302 251630 : case Intrinsic::memset: DELEGATE(MemSetInst);
303 1920 : case Intrinsic::vastart: DELEGATE(VAStartInst);
304 1080 : case Intrinsic::vaend: DELEGATE(VAEndInst);
305 106 : case Intrinsic::vacopy: DELEGATE(VACopyInst);
306 0 : case Intrinsic::not_intrinsic: break;
307 : }
308 0 : }
309 1990446 : DELEGATE(CallInst);
310 : }
311 0 :
312 0 : // An overload that will never actually be called, it is used only from dead
313 : // code in the dispatching from opcodes to instruction subclasses.
314 0 : RetTy delegateCallInst(Instruction &I) {
315 0 : llvm_unreachable("delegateCallInst called for non-CallInst");
316 : }
317 0 : };
318 0 :
319 : #undef DELEGATE
320 0 :
321 21423 : } // End llvm namespace
322 :
323 21423 : #endif
|
