1 //===- llvm/Support/InstVisitor.h - Define instruction visitors -*- 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_SUPPORT_INSTVISITOR_H
12 #define LLVM_SUPPORT_INSTVISITOR_H
14 #include "llvm/Function.h"
15 #include "llvm/Instructions.h"
16 #include "llvm/Module.h"
17 #include "llvm/Support/CallSite.h"
18 #include "llvm/Support/ErrorHandling.h"
22 // We operate on opaque instruction classes, so forward declare all instruction
25 #define HANDLE_INST(NUM, OPCODE, CLASS) class CLASS;
26 #include "llvm/Instruction.def"
28 #define DELEGATE(CLASS_TO_VISIT) \
29 return static_cast<SubClass*>(this)-> \
30 visit##CLASS_TO_VISIT(static_cast<CLASS_TO_VISIT&>(I))
33 /// @brief Base class for instruction visitors
35 /// Instruction visitors are used when you want to perform different actions
36 /// for different kinds of instructions without having to use lots of casts
37 /// and a big switch statement (in your code, that is).
39 /// To define your own visitor, inherit from this class, specifying your
40 /// new type for the 'SubClass' template parameter, and "override" visitXXX
41 /// functions in your class. I say "override" because this class is defined
42 /// in terms of statically resolved overloading, not virtual functions.
44 /// For example, here is a visitor that counts the number of malloc
45 /// instructions processed:
47 /// /// Declare the class. Note that we derive from InstVisitor instantiated
48 /// /// with _our new subclasses_ type.
50 /// struct CountAllocaVisitor : public InstVisitor<CountAllocaVisitor> {
52 /// CountAllocaVisitor() : Count(0) {}
54 /// void visitAllocaInst(AllocaInst &AI) { ++Count; }
57 /// And this class would be used like this:
58 /// CountAllocaVisitor CAV;
59 /// CAV.visit(function);
60 /// NumAllocas = CAV.Count;
62 /// The defined has 'visit' methods for Instruction, and also for BasicBlock,
63 /// Function, and Module, which recursively process all contained instructions.
65 /// Note that if you don't implement visitXXX for some instruction type,
66 /// the visitXXX method for instruction superclass will be invoked. So
67 /// if instructions are added in the future, they will be automatically
68 /// supported, if you handle one of their superclasses.
70 /// The optional second template argument specifies the type that instruction
71 /// visitation functions should return. If you specify this, you *MUST* provide
72 /// an implementation of visitInstruction though!.
74 /// Note that this class is specifically designed as a template to avoid
75 /// virtual function call overhead. Defining and using an InstVisitor is just
76 /// as efficient as having your own switch statement over the instruction
78 template<typename SubClass, typename RetTy=void>
80 //===--------------------------------------------------------------------===//
81 // Interface code - This is the public interface of the InstVisitor that you
82 // use to visit instructions...
86 // Generic visit method - Allow visitation to all instructions in a range
87 template<class Iterator>
88 void visit(Iterator Start, Iterator End) {
90 static_cast<SubClass*>(this)->visit(*Start++);
93 // Define visitors for functions and basic blocks...
95 void visit(Module &M) {
96 static_cast<SubClass*>(this)->visitModule(M);
97 visit(M.begin(), M.end());
99 void visit(Function &F) {
100 static_cast<SubClass*>(this)->visitFunction(F);
101 visit(F.begin(), F.end());
103 void visit(BasicBlock &BB) {
104 static_cast<SubClass*>(this)->visitBasicBlock(BB);
105 visit(BB.begin(), BB.end());
108 // Forwarding functions so that the user can visit with pointers AND refs.
109 void visit(Module *M) { visit(*M); }
110 void visit(Function *F) { visit(*F); }
111 void visit(BasicBlock *BB) { visit(*BB); }
112 RetTy visit(Instruction *I) { return visit(*I); }
114 // visit - Finally, code to visit an instruction...
116 RetTy visit(Instruction &I) {
117 switch (I.getOpcode()) {
118 default: llvm_unreachable("Unknown instruction type encountered!");
119 // Build the switch statement using the Instruction.def file...
120 #define HANDLE_INST(NUM, OPCODE, CLASS) \
121 case Instruction::OPCODE: return \
122 static_cast<SubClass*>(this)-> \
123 visit##OPCODE(static_cast<CLASS&>(I));
124 #include "llvm/Instruction.def"
128 //===--------------------------------------------------------------------===//
129 // Visitation functions... these functions provide default fallbacks in case
130 // the user does not specify what to do for a particular instruction type.
131 // The default behavior is to generalize the instruction type to its subtype
132 // and try visiting the subtype. All of this should be inlined perfectly,
133 // because there are no virtual functions to get in the way.
136 // When visiting a module, function or basic block directly, these methods get
137 // called to indicate when transitioning into a new unit.
139 void visitModule (Module &M) {}
140 void visitFunction (Function &F) {}
141 void visitBasicBlock(BasicBlock &BB) {}
143 // Define instruction specific visitor functions that can be overridden to
144 // handle SPECIFIC instructions. These functions automatically define
145 // visitMul to proxy to visitBinaryOperator for instance in case the user does
146 // not need this generality.
148 // The one problem case we have to handle here though is that the PHINode
149 // class and opcode name are the exact same. Because of this, we cannot
150 // define visitPHINode (the inst version) to forward to visitPHINode (the
151 // generic version) without multiply defined symbols and recursion. To handle
152 // this, we do not autoexpand "Other" instructions, we do it manually.
154 #define HANDLE_INST(NUM, OPCODE, CLASS) \
155 RetTy visit##OPCODE(CLASS &I) { DELEGATE(CLASS); }
156 #include "llvm/Instruction.def"
158 // Specific Instruction type classes... note that all of the casts are
159 // necessary because we use the instruction classes as opaque types...
161 RetTy visitReturnInst(ReturnInst &I) { DELEGATE(TerminatorInst);}
162 RetTy visitBranchInst(BranchInst &I) { DELEGATE(TerminatorInst);}
163 RetTy visitSwitchInst(SwitchInst &I) { DELEGATE(TerminatorInst);}
164 RetTy visitIndirectBrInst(IndirectBrInst &I) { DELEGATE(TerminatorInst);}
165 RetTy visitResumeInst(ResumeInst &I) { DELEGATE(TerminatorInst);}
166 RetTy visitUnreachableInst(UnreachableInst &I) { DELEGATE(TerminatorInst);}
167 RetTy visitICmpInst(ICmpInst &I) { DELEGATE(CmpInst);}
168 RetTy visitFCmpInst(FCmpInst &I) { DELEGATE(CmpInst);}
169 RetTy visitAllocaInst(AllocaInst &I) { DELEGATE(UnaryInstruction);}
170 RetTy visitLoadInst(LoadInst &I) { DELEGATE(UnaryInstruction);}
171 RetTy visitStoreInst(StoreInst &I) { DELEGATE(Instruction);}
172 RetTy visitAtomicCmpXchgInst(AtomicCmpXchgInst &I) { DELEGATE(Instruction);}
173 RetTy visitAtomicRMWInst(AtomicRMWInst &I) { DELEGATE(Instruction);}
174 RetTy visitFenceInst(FenceInst &I) { DELEGATE(Instruction);}
175 RetTy visitGetElementPtrInst(GetElementPtrInst &I){ DELEGATE(Instruction);}
176 RetTy visitPHINode(PHINode &I) { DELEGATE(Instruction);}
177 RetTy visitTruncInst(TruncInst &I) { DELEGATE(CastInst);}
178 RetTy visitZExtInst(ZExtInst &I) { DELEGATE(CastInst);}
179 RetTy visitSExtInst(SExtInst &I) { DELEGATE(CastInst);}
180 RetTy visitFPTruncInst(FPTruncInst &I) { DELEGATE(CastInst);}
181 RetTy visitFPExtInst(FPExtInst &I) { DELEGATE(CastInst);}
182 RetTy visitFPToUIInst(FPToUIInst &I) { DELEGATE(CastInst);}
183 RetTy visitFPToSIInst(FPToSIInst &I) { DELEGATE(CastInst);}
184 RetTy visitUIToFPInst(UIToFPInst &I) { DELEGATE(CastInst);}
185 RetTy visitSIToFPInst(SIToFPInst &I) { DELEGATE(CastInst);}
186 RetTy visitPtrToIntInst(PtrToIntInst &I) { DELEGATE(CastInst);}
187 RetTy visitIntToPtrInst(IntToPtrInst &I) { DELEGATE(CastInst);}
188 RetTy visitBitCastInst(BitCastInst &I) { DELEGATE(CastInst);}
189 RetTy visitSelectInst(SelectInst &I) { DELEGATE(Instruction);}
190 RetTy visitVAArgInst(VAArgInst &I) { DELEGATE(UnaryInstruction);}
191 RetTy visitExtractElementInst(ExtractElementInst &I) { DELEGATE(Instruction);}
192 RetTy visitInsertElementInst(InsertElementInst &I) { DELEGATE(Instruction);}
193 RetTy visitShuffleVectorInst(ShuffleVectorInst &I) { DELEGATE(Instruction);}
194 RetTy visitExtractValueInst(ExtractValueInst &I){ DELEGATE(UnaryInstruction);}
195 RetTy visitInsertValueInst(InsertValueInst &I) { DELEGATE(Instruction); }
196 RetTy visitLandingPadInst(LandingPadInst &I) { DELEGATE(Instruction); }
198 // Call and Invoke are slightly different as they delegate first through
199 // a generic CallSite visitor.
200 RetTy visitCallInst(CallInst &I) {
201 return static_cast<SubClass*>(this)->visitCallSite(&I);
203 RetTy visitInvokeInst(InvokeInst &I) {
204 return static_cast<SubClass*>(this)->visitCallSite(&I);
207 // Next level propagators: If the user does not overload a specific
208 // instruction type, they can overload one of these to get the whole class
209 // of instructions...
211 RetTy visitCastInst(CastInst &I) { DELEGATE(UnaryInstruction);}
212 RetTy visitBinaryOperator(BinaryOperator &I) { DELEGATE(Instruction);}
213 RetTy visitCmpInst(CmpInst &I) { DELEGATE(Instruction);}
214 RetTy visitTerminatorInst(TerminatorInst &I) { DELEGATE(Instruction);}
215 RetTy visitUnaryInstruction(UnaryInstruction &I){ DELEGATE(Instruction);}
217 // Provide a special visitor for a 'callsite' that visits both calls and
218 // invokes. When unimplemented, properly delegates to either the terminator or
219 // regular instruction visitor.
220 RetTy visitCallSite(CallSite CS) {
222 Instruction &I = *CS.getInstruction();
224 DELEGATE(Instruction);
226 assert(CS.isInvoke());
227 DELEGATE(TerminatorInst);
230 // If the user wants a 'default' case, they can choose to override this
231 // function. If this function is not overloaded in the user's subclass, then
232 // this instruction just gets ignored.
234 // Note that you MUST override this function if your return type is not void.
236 void visitInstruction(Instruction &I) {} // Ignore unhandled instructions
241 } // End llvm namespace