LLVM  9.0.0svn
InstVisitor.h
Go to the documentation of this file.
1 //===- InstVisitor.h - Instruction visitor templates ------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 
10 #ifndef LLVM_IR_INSTVISITOR_H
11 #define LLVM_IR_INSTVISITOR_H
12 
13 #include "llvm/IR/CallSite.h"
14 #include "llvm/IR/Function.h"
15 #include "llvm/IR/Instructions.h"
16 #include "llvm/IR/IntrinsicInst.h"
17 #include "llvm/IR/Intrinsics.h"
18 #include "llvm/IR/Module.h"
20 
21 namespace llvm {
22 
23 // We operate on opaque instruction classes, so forward declare all instruction
24 // types now...
25 //
26 #define HANDLE_INST(NUM, OPCODE, CLASS) class CLASS;
27 #include "llvm/IR/Instruction.def"
28 
29 #define DELEGATE(CLASS_TO_VISIT) \
30  return static_cast<SubClass*>(this)-> \
31  visit##CLASS_TO_VISIT(static_cast<CLASS_TO_VISIT&>(I))
32 
33 
34 /// Base class for instruction visitors
35 ///
36 /// Instruction visitors are used when you want to perform different actions
37 /// for different kinds of instructions without having to use lots of casts
38 /// and a big switch statement (in your code, that is).
39 ///
40 /// To define your own visitor, inherit from this class, specifying your
41 /// new type for the 'SubClass' template parameter, and "override" visitXXX
42 /// functions in your class. I say "override" because this class is defined
43 /// in terms of statically resolved overloading, not virtual functions.
44 ///
45 /// For example, here is a visitor that counts the number of malloc
46 /// instructions processed:
47 ///
48 /// /// Declare the class. Note that we derive from InstVisitor instantiated
49 /// /// with _our new subclasses_ type.
50 /// ///
51 /// struct CountAllocaVisitor : public InstVisitor<CountAllocaVisitor> {
52 /// unsigned Count;
53 /// CountAllocaVisitor() : Count(0) {}
54 ///
55 /// void visitAllocaInst(AllocaInst &AI) { ++Count; }
56 /// };
57 ///
58 /// And this class would be used like this:
59 /// CountAllocaVisitor CAV;
60 /// CAV.visit(function);
61 /// NumAllocas = CAV.Count;
62 ///
63 /// The defined has 'visit' methods for Instruction, and also for BasicBlock,
64 /// Function, and Module, which recursively process all contained instructions.
65 ///
66 /// Note that if you don't implement visitXXX for some instruction type,
67 /// the visitXXX method for instruction superclass will be invoked. So
68 /// if instructions are added in the future, they will be automatically
69 /// supported, if you handle one of their superclasses.
70 ///
71 /// The optional second template argument specifies the type that instruction
72 /// visitation functions should return. If you specify this, you *MUST* provide
73 /// an implementation of visitInstruction though!.
74 ///
75 /// Note that this class is specifically designed as a template to avoid
76 /// virtual function call overhead. Defining and using an InstVisitor is just
77 /// as efficient as having your own switch statement over the instruction
78 /// opcode.
79 template<typename SubClass, typename RetTy=void>
80 class InstVisitor {
81  //===--------------------------------------------------------------------===//
82  // Interface code - This is the public interface of the InstVisitor that you
83  // use to visit instructions...
84  //
85 
86 public:
87  // Generic visit method - Allow visitation to all instructions in a range
88  template<class Iterator>
89  void visit(Iterator Start, Iterator End) {
90  while (Start != End)
91  static_cast<SubClass*>(this)->visit(*Start++);
92  }
93 
94  // Define visitors for functions and basic blocks...
95  //
96  void visit(Module &M) {
97  static_cast<SubClass*>(this)->visitModule(M);
98  visit(M.begin(), M.end());
99  }
100  void visit(Function &F) {
101  static_cast<SubClass*>(this)->visitFunction(F);
102  visit(F.begin(), F.end());
103  }
104  void visit(BasicBlock &BB) {
105  static_cast<SubClass*>(this)->visitBasicBlock(BB);
106  visit(BB.begin(), BB.end());
107  }
108 
109  // Forwarding functions so that the user can visit with pointers AND refs.
110  void visit(Module *M) { visit(*M); }
111  void visit(Function *F) { visit(*F); }
112  void visit(BasicBlock *BB) { visit(*BB); }
113  RetTy visit(Instruction *I) { return visit(*I); }
114 
115  // visit - Finally, code to visit an instruction...
116  //
117  RetTy visit(Instruction &I) {
118  static_assert(std::is_base_of<InstVisitor, SubClass>::value,
119  "Must pass the derived type to this template!");
120 
121  switch (I.getOpcode()) {
122  default: llvm_unreachable("Unknown instruction type encountered!");
123  // Build the switch statement using the Instruction.def file...
124 #define HANDLE_INST(NUM, OPCODE, CLASS) \
125  case Instruction::OPCODE: return \
126  static_cast<SubClass*>(this)-> \
127  visit##OPCODE(static_cast<CLASS&>(I));
128 #include "llvm/IR/Instruction.def"
129  }
130  }
131 
132  //===--------------------------------------------------------------------===//
133  // Visitation functions... these functions provide default fallbacks in case
134  // the user does not specify what to do for a particular instruction type.
135  // The default behavior is to generalize the instruction type to its subtype
136  // and try visiting the subtype. All of this should be inlined perfectly,
137  // because there are no virtual functions to get in the way.
138  //
139 
140  // When visiting a module, function or basic block directly, these methods get
141  // called to indicate when transitioning into a new unit.
142  //
143  void visitModule (Module &M) {}
146 
147  // Define instruction specific visitor functions that can be overridden to
148  // handle SPECIFIC instructions. These functions automatically define
149  // visitMul to proxy to visitBinaryOperator for instance in case the user does
150  // not need this generality.
151  //
152  // These functions can also implement fan-out, when a single opcode and
153  // instruction have multiple more specific Instruction subclasses. The Call
154  // instruction currently supports this. We implement that by redirecting that
155  // instruction to a special delegation helper.
156 #define HANDLE_INST(NUM, OPCODE, CLASS) \
157  RetTy visit##OPCODE(CLASS &I) { \
158  if (NUM == Instruction::Call) \
159  return delegateCallInst(I); \
160  else \
161  DELEGATE(CLASS); \
162  }
163 #include "llvm/IR/Instruction.def"
164 
165  // Specific Instruction type classes... note that all of the casts are
166  // necessary because we use the instruction classes as opaque types...
167  //
202 
203  // Handle the special instrinsic instruction classes.
219 
220  // Call, Invoke and CallBr are slightly different as they delegate first
221  // through a generic CallSite visitor.
223  return static_cast<SubClass*>(this)->visitCallSite(&I);
224  }
226  return static_cast<SubClass*>(this)->visitCallSite(&I);
227  }
229  return static_cast<SubClass *>(this)->visitCallSite(&I);
230  }
231 
232  // While terminators don't have a distinct type modeling them, we support
233  // intercepting them with dedicated a visitor callback.
235  return static_cast<SubClass *>(this)->visitTerminator(I);
236  }
238  return static_cast<SubClass *>(this)->visitTerminator(I);
239  }
241  return static_cast<SubClass *>(this)->visitTerminator(I);
242  }
244  return static_cast<SubClass *>(this)->visitTerminator(I);
245  }
247  return static_cast<SubClass *>(this)->visitTerminator(I);
248  }
250  return static_cast<SubClass *>(this)->visitTerminator(I);
251  }
253  return static_cast<SubClass *>(this)->visitTerminator(I);
254  }
256  return static_cast<SubClass *>(this)->visitTerminator(I);
257  }
259  return static_cast<SubClass *>(this)->visitTerminator(I);
260  }
262 
263  // Next level propagators: If the user does not overload a specific
264  // instruction type, they can overload one of these to get the whole class
265  // of instructions...
266  //
272 
273  // The next level delegation for `CallBase` is slightly more complex in order
274  // to support visiting cases where the call is also a terminator.
276  if (isa<InvokeInst>(I) || isa<CallBrInst>(I))
277  return static_cast<SubClass *>(this)->visitTerminator(I);
278 
280  }
281 
282  // Provide a legacy visitor for a 'callsite' that visits calls, invokes,
283  // and calbrs.
284  //
285  // Prefer overriding the type system based `CallBase` instead.
287  assert(CS);
288  Instruction &I = *CS.getInstruction();
290  }
291 
292  // If the user wants a 'default' case, they can choose to override this
293  // function. If this function is not overloaded in the user's subclass, then
294  // this instruction just gets ignored.
295  //
296  // Note that you MUST override this function if your return type is not void.
297  //
298  void visitInstruction(Instruction &I) {} // Ignore unhandled instructions
299 
300 private:
301  // Special helper function to delegate to CallInst subclass visitors.
302  RetTy delegateCallInst(CallInst &I) {
303  if (const Function *F = I.getCalledFunction()) {
304  switch (F->getIntrinsicID()) {
305  default: DELEGATE(IntrinsicInst);
306  case Intrinsic::dbg_declare: DELEGATE(DbgDeclareInst);
307  case Intrinsic::dbg_value: DELEGATE(DbgValueInst);
308  case Intrinsic::dbg_label: DELEGATE(DbgLabelInst);
309  case Intrinsic::memcpy: DELEGATE(MemCpyInst);
310  case Intrinsic::memmove: DELEGATE(MemMoveInst);
311  case Intrinsic::memset: DELEGATE(MemSetInst);
312  case Intrinsic::vastart: DELEGATE(VAStartInst);
313  case Intrinsic::vaend: DELEGATE(VAEndInst);
314  case Intrinsic::vacopy: DELEGATE(VACopyInst);
315  case Intrinsic::not_intrinsic: break;
316  }
317  }
319  }
320 
321  // An overload that will never actually be called, it is used only from dead
322  // code in the dispatching from opcodes to instruction subclasses.
323  RetTy delegateCallInst(Instruction &I) {
324  llvm_unreachable("delegateCallInst called for non-CallInst");
325  }
326 };
327 
328 #undef DELEGATE
329 
330 } // End llvm namespace
331 
332 #endif
RetTy visitSelectInst(SelectInst &I)
Definition: InstVisitor.h:191
RetTy visitAtomicRMWInst(AtomicRMWInst &I)
Definition: InstVisitor.h:174
Return a value (possibly void), from a function.
RetTy visitUnaryOperator(UnaryOperator &I)
Definition: InstVisitor.h:268
RetTy visitVAStartInst(VAStartInst &I)
Definition: InstVisitor.h:215
RetTy visitMemSetInst(MemSetInst &I)
Definition: InstVisitor.h:210
This class is the base class for the comparison instructions.
Definition: InstrTypes.h:636
This instruction extracts a struct member or array element value from an aggregate value...
RetTy visitCallSite(CallSite CS)
Definition: InstVisitor.h:286
Base class for instruction visitors.
Definition: InstVisitor.h:80
This represents the llvm.dbg.label instruction.
This class represents lattice values for constants.
Definition: AllocatorList.h:23
RetTy visitDbgDeclareInst(DbgDeclareInst &I)
Definition: InstVisitor.h:204
RetTy visitDbgInfoIntrinsic(DbgInfoIntrinsic &I)
Definition: InstVisitor.h:209
RetTy visitFPExtInst(FPExtInst &I)
Definition: InstVisitor.h:182
This represents the llvm.va_end intrinsic.
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:64
An instruction for ordering other memory operations.
Definition: Instructions.h:454
iterator end()
Definition: Function.h:657
an instruction that atomically checks whether a specified value is in a memory location, and, if it is, stores a new value there.
Definition: Instructions.h:528
RetTy visitCmpInst(CmpInst &I)
Definition: InstVisitor.h:270
RetTy visitTerminator(Instruction &I)
Definition: InstVisitor.h:261
RetTy visitFCmpInst(FCmpInst &I)
Definition: InstVisitor.h:169
This class represents zero extension of integer types.
RetTy visitCastInst(CastInst &I)
Definition: InstVisitor.h:267
This class represents a function call, abstracting a target machine&#39;s calling convention.
RetTy visitBranchInst(BranchInst &I)
Definition: InstVisitor.h:237
RetTy visitLandingPadInst(LandingPadInst &I)
Definition: InstVisitor.h:198
This instruction constructs a fixed permutation of two input vectors.
This class wraps the llvm.memset intrinsic.
void visit(BasicBlock *BB)
Definition: InstVisitor.h:112
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1014
F(f)
This class represents a sign extension of integer types.
An instruction for reading from memory.
Definition: Instructions.h:167
RetTy visitDbgVariableIntrinsic(DbgVariableIntrinsic &I)
Definition: InstVisitor.h:206
RetTy visitPHINode(PHINode &I)
Definition: InstVisitor.h:177
an instruction that atomically reads a memory location, combines it with another value, and then stores the result back.
Definition: Instructions.h:691
RetTy visitICmpInst(ICmpInst &I)
Definition: InstVisitor.h:168
RetTy visitExtractElementInst(ExtractElementInst &I)
Definition: InstVisitor.h:193
RetTy visitVACopyInst(VACopyInst &I)
Definition: InstVisitor.h:217
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:268
RetTy visitSExtInst(SExtInst &I)
Definition: InstVisitor.h:180
void visit(Module *M)
Definition: InstVisitor.h:110
void visitFunction(Function &F)
Definition: InstVisitor.h:144
This class represents a conversion between pointers from one address space to another.
RetTy visitMemCpyInst(MemCpyInst &I)
Definition: InstVisitor.h:211
This class represents the LLVM &#39;select&#39; instruction.
RetTy visitIntrinsicInst(IntrinsicInst &I)
Definition: InstVisitor.h:218
This is the base class for all instructions that perform data casts.
Definition: InstrTypes.h:353
This class wraps the llvm.memmove intrinsic.
RetTy visitUIToFPInst(UIToFPInst &I)
Definition: InstVisitor.h:185
RetTy visitMemMoveInst(MemMoveInst &I)
Definition: InstVisitor.h:212
RetTy visitFPToUIInst(FPToUIInst &I)
Definition: InstVisitor.h:183
RetTy visitInsertValueInst(InsertValueInst &I)
Definition: InstVisitor.h:197
This class represents a cast from a pointer to an integer.
void visit(Iterator Start, Iterator End)
Definition: InstVisitor.h:89
InstrTy * getInstruction() const
Definition: CallSite.h:96
This represents the llvm.va_start intrinsic.
This is the common base class for debug info intrinsics for variables.
Definition: IntrinsicInst.h:87
This instruction compares its operands according to the predicate given to the constructor.
This class represents a no-op cast from one type to another.
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
Definition: Instruction.h:125
An instruction for storing to memory.
Definition: Instructions.h:320
This class represents a cast from floating point to signed integer.
RetTy visitMemTransferInst(MemTransferInst &I)
Definition: InstVisitor.h:213
iterator begin()
Definition: Function.h:655
RetTy visitExtractValueInst(ExtractValueInst &I)
Definition: InstVisitor.h:196
This class represents a truncation of integer types.
RetTy visitVAEndInst(VAEndInst &I)
Definition: InstVisitor.h:216
an instruction for type-safe pointer arithmetic to access elements of arrays and structs ...
Definition: Instructions.h:873
RetTy visitFuncletPadInst(FuncletPadInst &I)
Definition: InstVisitor.h:199
This instruction inserts a single (scalar) element into a VectorType value.
The landingpad instruction holds all of the information necessary to generate correct exception handl...
void visitBasicBlock(BasicBlock &BB)
Definition: InstVisitor.h:145
RetTy visitVAArgInst(VAArgInst &I)
Definition: InstVisitor.h:192
RetTy visitCallBase(CallBase &I)
Definition: InstVisitor.h:275
LLVM Basic Block Representation.
Definition: BasicBlock.h:57
RetTy visitIntToPtrInst(IntToPtrInst &I)
Definition: InstVisitor.h:188
Conditional or Unconditional Branch instruction.
void visit(Function *F)
Definition: InstVisitor.h:111
This function has undefined behavior.
RetTy visitResumeInst(ResumeInst &I)
Definition: InstVisitor.h:246
a unary instruction
Resume the propagation of an exception.
Indirect Branch Instruction.
RetTy visitCatchReturnInst(CatchReturnInst &I)
Definition: InstVisitor.h:255
This instruction compares its operands according to the predicate given to the constructor.
RetTy visitDbgLabelInst(DbgLabelInst &I)
Definition: InstVisitor.h:208
RetTy visitSwitchInst(SwitchInst &I)
Definition: InstVisitor.h:240
RetTy visitFPTruncInst(FPTruncInst &I)
Definition: InstVisitor.h:181
RetTy visitLoadInst(LoadInst &I)
Definition: InstVisitor.h:171
This class represents a cast from an integer to a pointer.
RetTy visitDbgValueInst(DbgValueInst &I)
Definition: InstVisitor.h:205
RetTy visitZExtInst(ZExtInst &I)
Definition: InstVisitor.h:179
This class represents the va_arg llvm instruction, which returns an argument of the specified type gi...
RetTy visitReturnInst(ReturnInst &I)
Definition: InstVisitor.h:234
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
CallBr instruction, tracking function calls that may not return control but instead transfer it to a ...
RetTy visitSIToFPInst(SIToFPInst &I)
Definition: InstVisitor.h:186
RetTy visitInvokeInst(InvokeInst &I)
Definition: InstVisitor.h:225
RetTy visitBinaryOperator(BinaryOperator &I)
Definition: InstVisitor.h:269
RetTy visitCallBrInst(CallBrInst &I)
Definition: InstVisitor.h:228
This is the common base class for memset/memcpy/memmove.
RetTy visitShuffleVectorInst(ShuffleVectorInst &I)
Definition: InstVisitor.h:195
RetTy visitIndirectBrInst(IndirectBrInst &I)
Definition: InstVisitor.h:243
RetTy visitCatchSwitchInst(CatchSwitchInst &I)
Definition: InstVisitor.h:258
RetTy visitAtomicCmpXchgInst(AtomicCmpXchgInst &I)
Definition: InstVisitor.h:173
iterator end()
Definition: BasicBlock.h:270
Module.h This file contains the declarations for the Module class.
RetTy visitFPToSIInst(FPToSIInst &I)
Definition: InstVisitor.h:184
RetTy visitCatchPadInst(CatchPadInst &I)
Definition: InstVisitor.h:201
This is the common base class for debug info intrinsics.
Definition: IntrinsicInst.h:66
This class represents a cast from floating point to unsigned integer.
This class wraps the llvm.memcpy intrinsic.
RetTy visitCleanupPadInst(CleanupPadInst &I)
Definition: InstVisitor.h:200
RetTy visitFenceInst(FenceInst &I)
Definition: InstVisitor.h:175
RetTy visitStoreInst(StoreInst &I)
Definition: InstVisitor.h:172
RetTy visitCallInst(CallInst &I)
Definition: InstVisitor.h:222
This class wraps the llvm.memcpy/memmove intrinsics.
void visitModule(Module &M)
Definition: InstVisitor.h:143
RetTy visitPtrToIntInst(PtrToIntInst &I)
Definition: InstVisitor.h:187
void visit(Function &F)
Definition: InstVisitor.h:100
iterator end()
Definition: Module.h:599
This represents the llvm.dbg.value instruction.
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation.
Definition: InstrTypes.h:1201
#define I(x, y, z)
Definition: MD5.cpp:58
This class represents a cast unsigned integer to floating point.
iterator begin()
Definition: Module.h:597
This instruction extracts a single (scalar) element from a VectorType value.
RetTy visitGetElementPtrInst(GetElementPtrInst &I)
Definition: InstVisitor.h:176
RetTy visitBitCastInst(BitCastInst &I)
Definition: InstVisitor.h:189
RetTy visitAddrSpaceCastInst(AddrSpaceCastInst &I)
Definition: InstVisitor.h:190
RetTy visitAllocaInst(AllocaInst &I)
Definition: InstVisitor.h:170
RetTy visitMemIntrinsic(MemIntrinsic &I)
Definition: InstVisitor.h:214
Multiway switch.
void visit(BasicBlock &BB)
Definition: InstVisitor.h:104
This class represents a cast from signed integer to floating point.
This represents the llvm.va_copy intrinsic.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
RetTy visit(Instruction &I)
Definition: InstVisitor.h:117
RetTy visitUnreachableInst(UnreachableInst &I)
Definition: InstVisitor.h:249
This class represents a truncation of floating point types.
Invoke instruction.
#define DELEGATE(CLASS_TO_VISIT)
Definition: InstVisitor.h:29
RetTy visitInsertElementInst(InsertElementInst &I)
Definition: InstVisitor.h:194
RetTy visit(Instruction *I)
Definition: InstVisitor.h:113
void visit(Module &M)
Definition: InstVisitor.h:96
void visitInstruction(Instruction &I)
Definition: InstVisitor.h:298
This class represents an extension of floating point types.
This represents the llvm.dbg.declare instruction.
RetTy visitCleanupReturnInst(CleanupReturnInst &I)
Definition: InstVisitor.h:252
RetTy visitUnaryInstruction(UnaryInstruction &I)
Definition: InstVisitor.h:271
A wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:43
an instruction to allocate memory on the stack
Definition: Instructions.h:59
This instruction inserts a struct field of array element value into an aggregate value.
RetTy visitTruncInst(TruncInst &I)
Definition: InstVisitor.h:178