LLVM 17.0.0git
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/Function.h"
16#include "llvm/IR/Intrinsics.h"
17#include "llvm/IR/Module.h"
18
19namespace llvm {
20
21// We operate on opaque instruction classes, so forward declare all instruction
22// types now...
23//
24#define HANDLE_INST(NUM, OPCODE, CLASS) class CLASS;
25#include "llvm/IR/Instruction.def"
26
27#define DELEGATE(CLASS_TO_VISIT) \
28 return static_cast<SubClass*>(this)-> \
29 visit##CLASS_TO_VISIT(static_cast<CLASS_TO_VISIT&>(I))
30
31
32/// Base class for instruction visitors
33///
34/// Instruction visitors are used when you want to perform different actions
35/// for different kinds of instructions without having to use lots of casts
36/// and a big switch statement (in your code, that is).
37///
38/// To define your own visitor, inherit from this class, specifying your
39/// new type for the 'SubClass' template parameter, and "override" visitXXX
40/// functions in your class. I say "override" because this class is defined
41/// in terms of statically resolved overloading, not virtual functions.
42///
43/// For example, here is a visitor that counts the number of malloc
44/// instructions processed:
45///
46/// /// Declare the class. Note that we derive from InstVisitor instantiated
47/// /// with _our new subclasses_ type.
48/// ///
49/// struct CountAllocaVisitor : public InstVisitor<CountAllocaVisitor> {
50/// unsigned Count;
51/// CountAllocaVisitor() : Count(0) {}
52///
53/// void visitAllocaInst(AllocaInst &AI) { ++Count; }
54/// };
55///
56/// And this class would be used like this:
57/// CountAllocaVisitor CAV;
58/// CAV.visit(function);
59/// NumAllocas = CAV.Count;
60///
61/// The defined has 'visit' methods for Instruction, and also for BasicBlock,
62/// Function, and Module, which recursively process all contained instructions.
63///
64/// Note that if you don't implement visitXXX for some instruction type,
65/// the visitXXX method for instruction superclass will be invoked. So
66/// if instructions are added in the future, they will be automatically
67/// supported, if you handle one of their superclasses.
68///
69/// The optional second template argument specifies the type that instruction
70/// visitation functions should return. If you specify this, you *MUST* provide
71/// an implementation of visitInstruction though!.
72///
73/// Note that this class is specifically designed as a template to avoid
74/// virtual function call overhead. Defining and using an InstVisitor is just
75/// as efficient as having your own switch statement over the instruction
76/// opcode.
77template<typename SubClass, typename RetTy=void>
79 //===--------------------------------------------------------------------===//
80 // Interface code - This is the public interface of the InstVisitor that you
81 // use to visit instructions...
82 //
83
84public:
85 // Generic visit method - Allow visitation to all instructions in a range
86 template<class Iterator>
87 void visit(Iterator Start, Iterator End) {
88 while (Start != End)
89 static_cast<SubClass*>(this)->visit(*Start++);
90 }
91
92 // Define visitors for functions and basic blocks...
93 //
94 void visit(Module &M) {
95 static_cast<SubClass*>(this)->visitModule(M);
96 visit(M.begin(), M.end());
97 }
98 void visit(Function &F) {
99 static_cast<SubClass*>(this)->visitFunction(F);
100 visit(F.begin(), F.end());
101 }
102 void visit(BasicBlock &BB) {
103 static_cast<SubClass*>(this)->visitBasicBlock(BB);
104 visit(BB.begin(), BB.end());
105 }
106
107 // Forwarding functions so that the user can visit with pointers AND refs.
108 void visit(Module *M) { visit(*M); }
109 void visit(Function *F) { visit(*F); }
110 void visit(BasicBlock *BB) { visit(*BB); }
111 RetTy visit(Instruction *I) { return visit(*I); }
112
113 // visit - Finally, code to visit an instruction...
114 //
116 static_assert(std::is_base_of<InstVisitor, SubClass>::value,
117 "Must pass the derived type to this template!");
118
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/IR/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) {}
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/IR/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 //
201
202 // Handle the special intrinsic instruction classes.
223
224 // While terminators don't have a distinct type modeling them, we support
225 // intercepting them with dedicated a visitor callback.
227 return static_cast<SubClass *>(this)->visitTerminator(I);
228 }
230 return static_cast<SubClass *>(this)->visitTerminator(I);
231 }
233 return static_cast<SubClass *>(this)->visitTerminator(I);
234 }
236 return static_cast<SubClass *>(this)->visitTerminator(I);
237 }
239 return static_cast<SubClass *>(this)->visitTerminator(I);
240 }
242 return static_cast<SubClass *>(this)->visitTerminator(I);
243 }
245 return static_cast<SubClass *>(this)->visitTerminator(I);
246 }
248 return static_cast<SubClass *>(this)->visitTerminator(I);
249 }
251 return static_cast<SubClass *>(this)->visitTerminator(I);
252 }
254
255 // Next level propagators: If the user does not overload a specific
256 // instruction type, they can overload one of these to get the whole class
257 // of instructions...
258 //
264
265 // The next level delegation for `CallBase` is slightly more complex in order
266 // to support visiting cases where the call is also a terminator.
268 if (isa<InvokeInst>(I) || isa<CallBrInst>(I))
269 return static_cast<SubClass *>(this)->visitTerminator(I);
270
272 }
273
274 // If the user wants a 'default' case, they can choose to override this
275 // function. If this function is not overloaded in the user's subclass, then
276 // this instruction just gets ignored.
277 //
278 // Note that you MUST override this function if your return type is not void.
279 //
280 void visitInstruction(Instruction &I) {} // Ignore unhandled instructions
281
282private:
283 // Special helper function to delegate to CallInst subclass visitors.
284 RetTy delegateCallInst(CallInst &I) {
285 if (const Function *F = I.getCalledFunction()) {
286 switch (F->getIntrinsicID()) {
287 default: DELEGATE(IntrinsicInst);
288 case Intrinsic::dbg_declare: DELEGATE(DbgDeclareInst);
289 case Intrinsic::dbg_value: DELEGATE(DbgValueInst);
290 case Intrinsic::dbg_label: DELEGATE(DbgLabelInst);
291 case Intrinsic::memcpy: DELEGATE(MemCpyInst);
292 case Intrinsic::memcpy_inline:
294 case Intrinsic::memmove: DELEGATE(MemMoveInst);
295 case Intrinsic::memset: DELEGATE(MemSetInst);
296 case Intrinsic::memset_inline:
298 case Intrinsic::vastart: DELEGATE(VAStartInst);
299 case Intrinsic::vaend: DELEGATE(VAEndInst);
300 case Intrinsic::vacopy: DELEGATE(VACopyInst);
301 case Intrinsic::not_intrinsic: break;
302 }
303 }
304 DELEGATE(CallInst);
305 }
306
307 // An overload that will never actually be called, it is used only from dead
308 // code in the dispatching from opcodes to instruction subclasses.
309 RetTy delegateCallInst(Instruction &I) {
310 llvm_unreachable("delegateCallInst called for non-CallInst");
311 }
312};
313
314#undef DELEGATE
315
316} // End llvm namespace
317
318#endif
return RetTy
#define DELEGATE(CLASS_TO_VISIT)
Definition: InstVisitor.h:27
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
Module.h This file contains the declarations for the Module class.
This class represents a conversion between pointers from one address space to another.
an instruction to allocate memory on the stack
Definition: Instructions.h:58
An instruction that atomically checks whether a specified value is in a memory location,...
Definition: Instructions.h:513
an instruction that atomically reads a memory location, combines it with another value,...
Definition: Instructions.h:718
LLVM Basic Block Representation.
Definition: BasicBlock.h:56
iterator end()
Definition: BasicBlock.h:316
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:314
This class represents a no-op cast from one type to another.
Conditional or Unconditional Branch instruction.
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1184
CallBr instruction, tracking function calls that may not return control but instead transfer it to a ...
This class represents a function call, abstracting a target machine's calling convention.
This is the base class for all instructions that perform data casts.
Definition: InstrTypes.h:428
This class is the base class for the comparison instructions.
Definition: InstrTypes.h:708
This represents the llvm.dbg.declare instruction.
This is the common base class for debug info intrinsics.
This represents the llvm.dbg.label instruction.
This represents the llvm.dbg.value instruction.
This is the common base class for debug info intrinsics for variables.
This instruction extracts a single (scalar) element from a VectorType value.
This instruction extracts a struct member or array element value from an aggregate value.
This instruction compares its operands according to the predicate given to the constructor.
This class represents an extension of floating point types.
This class represents a cast from floating point to signed integer.
This class represents a cast from floating point to unsigned integer.
This class represents a truncation of floating point types.
An instruction for ordering other memory operations.
Definition: Instructions.h:436
This class represents a freeze function that returns random concrete value if an operand is either a ...
an instruction for type-safe pointer arithmetic to access elements of arrays and structs
Definition: Instructions.h:940
This instruction compares its operands according to the predicate given to the constructor.
Indirect Branch Instruction.
This instruction inserts a single (scalar) element into a VectorType value.
This instruction inserts a struct field of array element value into an aggregate value.
Base class for instruction visitors.
Definition: InstVisitor.h:78
RetTy visitCallBrInst(CallBrInst &I)
Definition: InstVisitor.h:222
RetTy visitIndirectBrInst(IndirectBrInst &I)
Definition: InstVisitor.h:235
RetTy visitFreezeInst(FreezeInst &I)
Definition: InstVisitor.h:200
RetTy visitPtrToIntInst(PtrToIntInst &I)
Definition: InstVisitor.h:185
RetTy visitCmpInst(CmpInst &I)
Definition: InstVisitor.h:262
RetTy visitMemIntrinsic(MemIntrinsic &I)
Definition: InstVisitor.h:215
RetTy visitInvokeInst(InvokeInst &I)
Definition: InstVisitor.h:221
RetTy visitFPToSIInst(FPToSIInst &I)
Definition: InstVisitor.h:182
RetTy visitVACopyInst(VACopyInst &I)
Definition: InstVisitor.h:218
RetTy visitFCmpInst(FCmpInst &I)
Definition: InstVisitor.h:167
RetTy visitDbgInfoIntrinsic(DbgInfoIntrinsic &I)
Definition: InstVisitor.h:208
RetTy visitTerminator(Instruction &I)
Definition: InstVisitor.h:253
RetTy visitExtractElementInst(ExtractElementInst &I)
Definition: InstVisitor.h:191
RetTy visitVAStartInst(VAStartInst &I)
Definition: InstVisitor.h:216
RetTy visitMemCpyInst(MemCpyInst &I)
Definition: InstVisitor.h:211
RetTy visitCallBase(CallBase &I)
Definition: InstVisitor.h:267
RetTy visitTruncInst(TruncInst &I)
Definition: InstVisitor.h:176
void visitFunction(Function &F)
Definition: InstVisitor.h:142
void visit(Module *M)
Definition: InstVisitor.h:108
RetTy visitCleanupReturnInst(CleanupReturnInst &I)
Definition: InstVisitor.h:244
RetTy visitInsertValueInst(InsertValueInst &I)
Definition: InstVisitor.h:195
RetTy visit(Instruction &I)
Definition: InstVisitor.h:115
RetTy visitCatchPadInst(CatchPadInst &I)
Definition: InstVisitor.h:199
RetTy visitIntrinsicInst(IntrinsicInst &I)
Definition: InstVisitor.h:219
RetTy visitShuffleVectorInst(ShuffleVectorInst &I)
Definition: InstVisitor.h:193
RetTy visitLandingPadInst(LandingPadInst &I)
Definition: InstVisitor.h:196
void visitBasicBlock(BasicBlock &BB)
Definition: InstVisitor.h:143
RetTy visitUnreachableInst(UnreachableInst &I)
Definition: InstVisitor.h:241
RetTy visitAtomicCmpXchgInst(AtomicCmpXchgInst &I)
Definition: InstVisitor.h:171
RetTy visitIntToPtrInst(IntToPtrInst &I)
Definition: InstVisitor.h:186
RetTy visitSExtInst(SExtInst &I)
Definition: InstVisitor.h:178
RetTy visitBitCastInst(BitCastInst &I)
Definition: InstVisitor.h:187
RetTy visitSwitchInst(SwitchInst &I)
Definition: InstVisitor.h:232
RetTy visitCleanupPadInst(CleanupPadInst &I)
Definition: InstVisitor.h:198
void visit(Iterator Start, Iterator End)
Definition: InstVisitor.h:87
RetTy visit(Instruction *I)
Definition: InstVisitor.h:111
RetTy visitPHINode(PHINode &I)
Definition: InstVisitor.h:175
RetTy visitReturnInst(ReturnInst &I)
Definition: InstVisitor.h:226
RetTy visitExtractValueInst(ExtractValueInst &I)
Definition: InstVisitor.h:194
RetTy visitVAEndInst(VAEndInst &I)
Definition: InstVisitor.h:217
void visit(Function &F)
Definition: InstVisitor.h:98
RetTy visitFPToUIInst(FPToUIInst &I)
Definition: InstVisitor.h:181
RetTy visitUnaryOperator(UnaryOperator &I)
Definition: InstVisitor.h:260
RetTy visitDbgLabelInst(DbgLabelInst &I)
Definition: InstVisitor.h:207
RetTy visitStoreInst(StoreInst &I)
Definition: InstVisitor.h:170
RetTy visitMemCpyInlineInst(MemCpyInlineInst &I)
Definition: InstVisitor.h:212
RetTy visitFuncletPadInst(FuncletPadInst &I)
Definition: InstVisitor.h:197
RetTy visitInsertElementInst(InsertElementInst &I)
Definition: InstVisitor.h:192
void visit(BasicBlock *BB)
Definition: InstVisitor.h:110
RetTy visitMemMoveInst(MemMoveInst &I)
Definition: InstVisitor.h:213
RetTy visitAtomicRMWInst(AtomicRMWInst &I)
Definition: InstVisitor.h:172
void visit(BasicBlock &BB)
Definition: InstVisitor.h:102
RetTy visitDbgValueInst(DbgValueInst &I)
Definition: InstVisitor.h:204
RetTy visitUnaryInstruction(UnaryInstruction &I)
Definition: InstVisitor.h:263
RetTy visitAddrSpaceCastInst(AddrSpaceCastInst &I)
Definition: InstVisitor.h:188
RetTy visitFPTruncInst(FPTruncInst &I)
Definition: InstVisitor.h:179
RetTy visitAllocaInst(AllocaInst &I)
Definition: InstVisitor.h:168
RetTy visitBinaryOperator(BinaryOperator &I)
Definition: InstVisitor.h:261
RetTy visitMemSetInlineInst(MemSetInlineInst &I)
Definition: InstVisitor.h:210
RetTy visitSIToFPInst(SIToFPInst &I)
Definition: InstVisitor.h:184
RetTy visitResumeInst(ResumeInst &I)
Definition: InstVisitor.h:238
RetTy visitFPExtInst(FPExtInst &I)
Definition: InstVisitor.h:180
RetTy visitICmpInst(ICmpInst &I)
Definition: InstVisitor.h:166
RetTy visitCatchReturnInst(CatchReturnInst &I)
Definition: InstVisitor.h:247
void visit(Module &M)
Definition: InstVisitor.h:94
RetTy visitMemTransferInst(MemTransferInst &I)
Definition: InstVisitor.h:214
RetTy visitMemSetInst(MemSetInst &I)
Definition: InstVisitor.h:209
RetTy visitCallInst(CallInst &I)
Definition: InstVisitor.h:220
void visitModule(Module &M)
Definition: InstVisitor.h:141
RetTy visitCatchSwitchInst(CatchSwitchInst &I)
Definition: InstVisitor.h:250
RetTy visitCastInst(CastInst &I)
Definition: InstVisitor.h:259
RetTy visitDbgVariableIntrinsic(DbgVariableIntrinsic &I)
Definition: InstVisitor.h:205
RetTy visitDbgDeclareInst(DbgDeclareInst &I)
Definition: InstVisitor.h:203
RetTy visitBranchInst(BranchInst &I)
Definition: InstVisitor.h:229
RetTy visitSelectInst(SelectInst &I)
Definition: InstVisitor.h:189
RetTy visitGetElementPtrInst(GetElementPtrInst &I)
Definition: InstVisitor.h:174
RetTy visitUIToFPInst(UIToFPInst &I)
Definition: InstVisitor.h:183
RetTy visitFenceInst(FenceInst &I)
Definition: InstVisitor.h:173
void visitInstruction(Instruction &I)
Definition: InstVisitor.h:280
void visit(Function *F)
Definition: InstVisitor.h:109
RetTy visitLoadInst(LoadInst &I)
Definition: InstVisitor.h:169
RetTy visitVAArgInst(VAArgInst &I)
Definition: InstVisitor.h:190
RetTy visitZExtInst(ZExtInst &I)
Definition: InstVisitor.h:177
This class represents a cast from an integer to a pointer.
A wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:47
Invoke instruction.
The landingpad instruction holds all of the information necessary to generate correct exception handl...
An instruction for reading from memory.
Definition: Instructions.h:177
This class wraps the llvm.memcpy.inline intrinsic.
This class wraps the llvm.memcpy intrinsic.
This is the common base class for memset/memcpy/memmove.
This class wraps the llvm.memmove intrinsic.
This class wraps the llvm.memset.inline intrinsic.
This class wraps the llvm.memset and llvm.memset.inline intrinsics.
This class wraps the llvm.memcpy/memmove intrinsics.
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
This class represents a cast from a pointer to an integer.
Resume the propagation of an exception.
Return a value (possibly void), from a function.
This class represents a sign extension of integer types.
This class represents a cast from signed integer to floating point.
This class represents the LLVM 'select' instruction.
This instruction constructs a fixed permutation of two input vectors.
An instruction for storing to memory.
Definition: Instructions.h:301
Multiway switch.
This class represents a truncation of integer types.
This class represents a cast unsigned integer to floating point.
This function has undefined behavior.
This class represents the va_arg llvm instruction, which returns an argument of the specified type gi...
This represents the llvm.va_copy intrinsic.
This represents the llvm.va_end intrinsic.
This represents the llvm.va_start intrinsic.
This class represents zero extension of integer types.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18