1//===- llvm/Support/InstVisitor.h - Define instruction visitors -*- 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_SUPPORT_INSTVISITOR_H
12#define LLVM_SUPPORT_INSTVISITOR_H
13
14#include "llvm/Function.h"
15#include "llvm/Instructions.h"
16#include "llvm/Intrinsics.h"
17#include "llvm/IntrinsicInst.h"
18#include "llvm/Module.h"
19#include "llvm/Support/CallSite.h"
20#include "llvm/Support/ErrorHandling.h"
21
22namespace 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/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.
80template<typename SubClass, typename RetTy=void>
81class InstVisitor {
82  //===--------------------------------------------------------------------===//
83  // Interface code - This is the public interface of the InstVisitor that you
84  // use to visit instructions...
85  //
86
87public:
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    switch (I.getOpcode()) {
120    default: llvm_unreachable("Unknown instruction type encountered!");
121      // Build the switch statement using the Instruction.def file...
122#define HANDLE_INST(NUM, OPCODE, CLASS) \
123    case Instruction::OPCODE: return \
124           static_cast<SubClass*>(this)-> \
125                      visit##OPCODE(static_cast<CLASS&>(I));
126#include "llvm/Instruction.def"
127    }
128  }
129
130  //===--------------------------------------------------------------------===//
131  // Visitation functions... these functions provide default fallbacks in case
132  // the user does not specify what to do for a particular instruction type.
133  // The default behavior is to generalize the instruction type to its subtype
134  // and try visiting the subtype.  All of this should be inlined perfectly,
135  // because there are no virtual functions to get in the way.
136  //
137
138  // When visiting a module, function or basic block directly, these methods get
139  // called to indicate when transitioning into a new unit.
140  //
141  void visitModule    (Module &M) {}
142  void visitFunction  (Function &F) {}
143  void visitBasicBlock(BasicBlock &BB) {}
144
145  // Define instruction specific visitor functions that can be overridden to
146  // handle SPECIFIC instructions.  These functions automatically define
147  // visitMul to proxy to visitBinaryOperator for instance in case the user does
148  // not need this generality.
149  //
150  // These functions can also implement fan-out, when a single opcode and
151  // instruction have multiple more specific Instruction subclasses. The Call
152  // instruction currently supports this. We implement that by redirecting that
153  // instruction to a special delegation helper.
154#define HANDLE_INST(NUM, OPCODE, CLASS) \
155    RetTy visit##OPCODE(CLASS &I) { \
156      if (NUM == Instruction::Call) \
157        return delegateCallInst(I); \
158      else \
159        DELEGATE(CLASS); \
160    }
161#include "llvm/Instruction.def"
162
163  // Specific Instruction type classes... note that all of the casts are
164  // necessary because we use the instruction classes as opaque types...
165  //
166  RetTy visitReturnInst(ReturnInst &I)            { DELEGATE(TerminatorInst);}
167  RetTy visitBranchInst(BranchInst &I)            { DELEGATE(TerminatorInst);}
168  RetTy visitSwitchInst(SwitchInst &I)            { DELEGATE(TerminatorInst);}
169  RetTy visitIndirectBrInst(IndirectBrInst &I)    { DELEGATE(TerminatorInst);}
170  RetTy visitResumeInst(ResumeInst &I)            { DELEGATE(TerminatorInst);}
171  RetTy visitUnreachableInst(UnreachableInst &I)  { DELEGATE(TerminatorInst);}
172  RetTy visitICmpInst(ICmpInst &I)                { DELEGATE(CmpInst);}
173  RetTy visitFCmpInst(FCmpInst &I)                { DELEGATE(CmpInst);}
174  RetTy visitAllocaInst(AllocaInst &I)            { DELEGATE(UnaryInstruction);}
175  RetTy visitLoadInst(LoadInst     &I)            { DELEGATE(UnaryInstruction);}
176  RetTy visitStoreInst(StoreInst   &I)            { DELEGATE(Instruction);}
177  RetTy visitAtomicCmpXchgInst(AtomicCmpXchgInst &I) { DELEGATE(Instruction);}
178  RetTy visitAtomicRMWInst(AtomicRMWInst &I)      { DELEGATE(Instruction);}
179  RetTy visitFenceInst(FenceInst   &I)            { DELEGATE(Instruction);}
180  RetTy visitGetElementPtrInst(GetElementPtrInst &I){ DELEGATE(Instruction);}
181  RetTy visitPHINode(PHINode       &I)            { DELEGATE(Instruction);}
182  RetTy visitTruncInst(TruncInst &I)              { DELEGATE(CastInst);}
183  RetTy visitZExtInst(ZExtInst &I)                { DELEGATE(CastInst);}
184  RetTy visitSExtInst(SExtInst &I)                { DELEGATE(CastInst);}
185  RetTy visitFPTruncInst(FPTruncInst &I)          { DELEGATE(CastInst);}
186  RetTy visitFPExtInst(FPExtInst &I)              { DELEGATE(CastInst);}
187  RetTy visitFPToUIInst(FPToUIInst &I)            { DELEGATE(CastInst);}
188  RetTy visitFPToSIInst(FPToSIInst &I)            { DELEGATE(CastInst);}
189  RetTy visitUIToFPInst(UIToFPInst &I)            { DELEGATE(CastInst);}
190  RetTy visitSIToFPInst(SIToFPInst &I)            { DELEGATE(CastInst);}
191  RetTy visitPtrToIntInst(PtrToIntInst &I)        { DELEGATE(CastInst);}
192  RetTy visitIntToPtrInst(IntToPtrInst &I)        { DELEGATE(CastInst);}
193  RetTy visitBitCastInst(BitCastInst &I)          { DELEGATE(CastInst);}
194  RetTy visitSelectInst(SelectInst &I)            { DELEGATE(Instruction);}
195  RetTy visitVAArgInst(VAArgInst   &I)            { DELEGATE(UnaryInstruction);}
196  RetTy visitExtractElementInst(ExtractElementInst &I) { DELEGATE(Instruction);}
197  RetTy visitInsertElementInst(InsertElementInst &I) { DELEGATE(Instruction);}
198  RetTy visitShuffleVectorInst(ShuffleVectorInst &I) { DELEGATE(Instruction);}
199  RetTy visitExtractValueInst(ExtractValueInst &I){ DELEGATE(UnaryInstruction);}
200  RetTy visitInsertValueInst(InsertValueInst &I)  { DELEGATE(Instruction); }
201  RetTy visitLandingPadInst(LandingPadInst &I)    { DELEGATE(Instruction); }
202
203  // Handle the special instrinsic instruction classes.
204  RetTy visitDbgDeclareInst(DbgDeclareInst &I)    { DELEGATE(DbgInfoIntrinsic);}
205  RetTy visitDbgValueInst(DbgValueInst &I)        { DELEGATE(DbgInfoIntrinsic);}
206  RetTy visitDbgInfoIntrinsic(DbgInfoIntrinsic &I) { DELEGATE(IntrinsicInst); }
207  RetTy visitMemSetInst(MemSetInst &I)            { DELEGATE(MemIntrinsic); }
208  RetTy visitMemCpyInst(MemCpyInst &I)            { DELEGATE(MemTransferInst); }
209  RetTy visitMemMoveInst(MemMoveInst &I)          { DELEGATE(MemTransferInst); }
210  RetTy visitMemTransferInst(MemTransferInst &I)  { DELEGATE(MemIntrinsic); }
211  RetTy visitMemIntrinsic(MemIntrinsic &I)        { DELEGATE(IntrinsicInst); }
212  RetTy visitIntrinsicInst(IntrinsicInst &I)      { DELEGATE(CallInst); }
213
214  // Call and Invoke are slightly different as they delegate first through
215  // a generic CallSite visitor.
216  RetTy visitCallInst(CallInst &I) {
217    return static_cast<SubClass*>(this)->visitCallSite(&I);
218  }
219  RetTy visitInvokeInst(InvokeInst &I) {
220    return static_cast<SubClass*>(this)->visitCallSite(&I);
221  }
222
223  // Next level propagators: If the user does not overload a specific
224  // instruction type, they can overload one of these to get the whole class
225  // of instructions...
226  //
227  RetTy visitCastInst(CastInst &I)                { DELEGATE(UnaryInstruction);}
228  RetTy visitBinaryOperator(BinaryOperator &I)    { DELEGATE(Instruction);}
229  RetTy visitCmpInst(CmpInst &I)                  { DELEGATE(Instruction);}
230  RetTy visitTerminatorInst(TerminatorInst &I)    { DELEGATE(Instruction);}
231  RetTy visitUnaryInstruction(UnaryInstruction &I){ DELEGATE(Instruction);}
232
233  // Provide a special visitor for a 'callsite' that visits both calls and
234  // invokes. When unimplemented, properly delegates to either the terminator or
235  // regular instruction visitor.
236  RetTy visitCallSite(CallSite CS) {
237    assert(CS);
238    Instruction &I = *CS.getInstruction();
239    if (CS.isCall())
240      DELEGATE(Instruction);
241
242    assert(CS.isInvoke());
243    DELEGATE(TerminatorInst);
244  }
245
246  // If the user wants a 'default' case, they can choose to override this
247  // function.  If this function is not overloaded in the user's subclass, then
248  // this instruction just gets ignored.
249  //
250  // Note that you MUST override this function if your return type is not void.
251  //
252  void visitInstruction(Instruction &I) {}  // Ignore unhandled instructions
253
254private:
255  // Special helper function to delegate to CallInst subclass visitors.
256  RetTy delegateCallInst(CallInst &I) {
257    if (const Function *F = I.getCalledFunction()) {
258      switch ((Intrinsic::ID)F->getIntrinsicID()) {
259      default:                     DELEGATE(IntrinsicInst);
260      case Intrinsic::dbg_declare: DELEGATE(DbgDeclareInst);
261      case Intrinsic::dbg_value:   DELEGATE(DbgValueInst);
262      case Intrinsic::memcpy:      DELEGATE(MemCpyInst);
263      case Intrinsic::memmove:     DELEGATE(MemMoveInst);
264      case Intrinsic::memset:      DELEGATE(MemSetInst);
265      case Intrinsic::not_intrinsic: break;
266      }
267    }
268    DELEGATE(CallInst);
269  }
270
271  // An overload that will never actually be called, it is used only from dead
272  // code in the dispatching from opcodes to instruction subclasses.
273  RetTy delegateCallInst(Instruction &I) {
274    llvm_unreachable("delegateCallInst called for non-CallInst");
275  }
276};
277
278#undef DELEGATE
279
280} // End llvm namespace
281
282#endif
283