LLVM  15.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"
14 #include "llvm/IR/Instructions.h"
15 #include "llvm/IR/IntrinsicInst.h"
16 #include "llvm/IR/Intrinsics.h"
17 #include "llvm/IR/Module.h"
18 
19 namespace 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.
77 template<typename SubClass, typename RetTy=void>
78 class InstVisitor {
79  //===--------------------------------------------------------------------===//
80  // Interface code - This is the public interface of the InstVisitor that you
81  // use to visit instructions...
82  //
83 
84 public:
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  //
115  RetTy visit(Instruction &I) {
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.
213  }
224 
225  // While terminators don't have a distinct type modeling them, we support
226  // intercepting them with dedicated a visitor callback.
228  return static_cast<SubClass *>(this)->visitTerminator(I);
229  }
231  return static_cast<SubClass *>(this)->visitTerminator(I);
232  }
234  return static_cast<SubClass *>(this)->visitTerminator(I);
235  }
237  return static_cast<SubClass *>(this)->visitTerminator(I);
238  }
240  return static_cast<SubClass *>(this)->visitTerminator(I);
241  }
243  return static_cast<SubClass *>(this)->visitTerminator(I);
244  }
246  return static_cast<SubClass *>(this)->visitTerminator(I);
247  }
249  return static_cast<SubClass *>(this)->visitTerminator(I);
250  }
252  return static_cast<SubClass *>(this)->visitTerminator(I);
253  }
255 
256  // Next level propagators: If the user does not overload a specific
257  // instruction type, they can overload one of these to get the whole class
258  // of instructions...
259  //
265 
266  // The next level delegation for `CallBase` is slightly more complex in order
267  // to support visiting cases where the call is also a terminator.
269  if (isa<InvokeInst>(I) || isa<CallBrInst>(I))
270  return static_cast<SubClass *>(this)->visitTerminator(I);
271 
273  }
274 
275  // If the user wants a 'default' case, they can choose to override this
276  // function. If this function is not overloaded in the user's subclass, then
277  // this instruction just gets ignored.
278  //
279  // Note that you MUST override this function if your return type is not void.
280  //
281  void visitInstruction(Instruction &I) {} // Ignore unhandled instructions
282 
283 private:
284  // Special helper function to delegate to CallInst subclass visitors.
285  RetTy delegateCallInst(CallInst &I) {
286  if (const Function *F = I.getCalledFunction()) {
287  switch (F->getIntrinsicID()) {
288  default: DELEGATE(IntrinsicInst);
289  case Intrinsic::dbg_declare: DELEGATE(DbgDeclareInst);
290  case Intrinsic::dbg_value: DELEGATE(DbgValueInst);
291  case Intrinsic::dbg_label: DELEGATE(DbgLabelInst);
293  case Intrinsic::memmove: DELEGATE(MemMoveInst);
294  case Intrinsic::memset: DELEGATE(MemSetInst);
295  case Intrinsic::vastart: DELEGATE(VAStartInst);
296  case Intrinsic::vaend: DELEGATE(VAEndInst);
297  case Intrinsic::vacopy: DELEGATE(VACopyInst);
298  case Intrinsic::not_intrinsic: break;
299  }
300  }
301  DELEGATE(CallInst);
302  }
303 
304  // An overload that will never actually be called, it is used only from dead
305  // code in the dispatching from opcodes to instruction subclasses.
306  RetTy delegateCallInst(Instruction &I) {
307  llvm_unreachable("delegateCallInst called for non-CallInst");
308  }
309 };
310 
311 #undef DELEGATE
312 
313 } // End llvm namespace
314 
315 #endif
llvm::InstVisitor::visitInstruction
void visitInstruction(Instruction &I)
Definition: InstVisitor.h:281
llvm::InstVisitor::visitCastInst
RetTy visitCastInst(CastInst &I)
Definition: InstVisitor.h:260
llvm::InstVisitor::visitPtrToIntInst
RetTy visitPtrToIntInst(PtrToIntInst &I)
Definition: InstVisitor.h:185
llvm::InstVisitor::visitBranchInst
RetTy visitBranchInst(BranchInst &I)
Definition: InstVisitor.h:230
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
llvm::InstVisitor::visitCleanupPadInst
RetTy visitCleanupPadInst(CleanupPadInst &I)
Definition: InstVisitor.h:198
llvm::InstVisitor::visitDbgLabelInst
RetTy visitDbgLabelInst(DbgLabelInst &I)
Definition: InstVisitor.h:207
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::InstVisitor::visitInsertValueInst
RetTy visitInsertValueInst(InsertValueInst &I)
Definition: InstVisitor.h:195
llvm::ReturnInst
Return a value (possibly void), from a function.
Definition: Instructions.h:3004
llvm::VAArgInst
This class represents the va_arg llvm instruction, which returns an argument of the specified type gi...
Definition: Instructions.h:1819
llvm::InstVisitor::visit
void visit(Function &F)
Definition: InstVisitor.h:98
llvm::InstVisitor::visitVAStartInst
RetTy visitVAStartInst(VAStartInst &I)
Definition: InstVisitor.h:217
IntrinsicInst.h
llvm::InstVisitor::visitDbgValueInst
RetTy visitDbgValueInst(DbgValueInst &I)
Definition: InstVisitor.h:204
llvm::ExtractElementInst
This instruction extracts a single (scalar) element from a VectorType value.
Definition: Instructions.h:1859
llvm::MemTransferInst
This class wraps the llvm.memcpy/memmove intrinsics.
Definition: IntrinsicInst.h:1022
llvm::Function
Definition: Function.h:60
llvm::InstVisitor::visitDbgVariableIntrinsic
RetTy visitDbgVariableIntrinsic(DbgVariableIntrinsic &I)
Definition: InstVisitor.h:205
llvm::InstVisitor::visitTruncInst
RetTy visitTruncInst(TruncInst &I)
Definition: InstVisitor.h:176
llvm::MemMoveInst
This class wraps the llvm.memmove intrinsic.
Definition: IntrinsicInst.h:1054
llvm::BitCastInst
This class represents a no-op cast from one type to another.
Definition: Instructions.h:5212
llvm::LandingPadInst
The landingpad instruction holds all of the information necessary to generate correct exception handl...
Definition: Instructions.h:2903
llvm::InstVisitor::visitCatchSwitchInst
RetTy visitCatchSwitchInst(CatchSwitchInst &I)
Definition: InstVisitor.h:251
llvm::InstVisitor::visitVACopyInst
RetTy visitVACopyInst(VACopyInst &I)
Definition: InstVisitor.h:219
llvm::InstVisitor::visitIntrinsicInst
RetTy visitIntrinsicInst(IntrinsicInst &I)
Definition: InstVisitor.h:220
llvm::InstVisitor::visitUnaryOperator
RetTy visitUnaryOperator(UnaryOperator &I)
Definition: InstVisitor.h:261
llvm::InstVisitor::visitCallBase
RetTy visitCallBase(CallBase &I)
Definition: InstVisitor.h:268
llvm::InstVisitor::visitFuncletPadInst
RetTy visitFuncletPadInst(FuncletPadInst &I)
Definition: InstVisitor.h:197
llvm::InstVisitor::visitVAArgInst
RetTy visitVAArgInst(VAArgInst &I)
Definition: InstVisitor.h:190
llvm::InstVisitor::visitBitCastInst
RetTy visitBitCastInst(BitCastInst &I)
Definition: InstVisitor.h:187
Module.h
llvm::InstVisitor::visitTerminator
RetTy visitTerminator(Instruction &I)
Definition: InstVisitor.h:254
llvm::MemIntrinsic
This is the common base class for memset/memcpy/memmove.
Definition: IntrinsicInst.h:957
llvm::InstVisitor::visitDbgDeclareInst
RetTy visitDbgDeclareInst(DbgDeclareInst &I)
Definition: InstVisitor.h:203
llvm::FenceInst
An instruction for ordering other memory operations.
Definition: Instructions.h:432
llvm::InstVisitor::visitLandingPadInst
RetTy visitLandingPadInst(LandingPadInst &I)
Definition: InstVisitor.h:196
llvm::Intrinsic::not_intrinsic
@ not_intrinsic
Definition: Intrinsics.h:45
llvm::UnaryOperator
Definition: InstrTypes.h:101
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::InstVisitor::visitFPTruncInst
RetTy visitFPTruncInst(FPTruncInst &I)
Definition: InstVisitor.h:179
llvm::InstVisitor::visitInsertElementInst
RetTy visitInsertElementInst(InsertElementInst &I)
Definition: InstVisitor.h:192
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:55
llvm::VAStartInst
This represents the llvm.va_start intrinsic.
Definition: IntrinsicInst.h:1195
llvm::InstVisitor::visitZExtInst
RetTy visitZExtInst(ZExtInst &I)
Definition: InstVisitor.h:177
llvm::InstVisitor::visitShuffleVectorInst
RetTy visitShuffleVectorInst(ShuffleVectorInst &I)
Definition: InstVisitor.h:193
llvm::AddrSpaceCastInst
This class represents a conversion between pointers from one address space to another.
Definition: Instructions.h:5252
llvm::InstVisitor::visitMemCpyInst
RetTy visitMemCpyInst(MemCpyInst &I)
Definition: InstVisitor.h:210
llvm::DbgValueInst
This represents the llvm.dbg.value instruction.
Definition: IntrinsicInst.h:348
llvm::InstVisitor::visitICmpInst
RetTy visitICmpInst(ICmpInst &I)
Definition: InstVisitor.h:166
llvm::InstVisitor::visitMemIntrinsic
RetTy visitMemIntrinsic(MemIntrinsic &I)
Definition: InstVisitor.h:216
Intrinsics.h
llvm::InstVisitor::visitCatchPadInst
RetTy visitCatchPadInst(CatchPadInst &I)
Definition: InstVisitor.h:199
llvm::InstVisitor::visitIndirectBrInst
RetTy visitIndirectBrInst(IndirectBrInst &I)
Definition: InstVisitor.h:236
llvm::FCmpInst
This instruction compares its operands according to the predicate given to the constructor.
Definition: Instructions.h:1347
llvm::InstVisitor::visitGetElementPtrInst
RetTy visitGetElementPtrInst(GetElementPtrInst &I)
Definition: InstVisitor.h:174
llvm::MemCpyInlineInst
This class wraps the llvm.memcpy.inline intrinsic.
Definition: IntrinsicInst.h:1066
llvm::InstVisitor::visitAtomicCmpXchgInst
RetTy visitAtomicCmpXchgInst(AtomicCmpXchgInst &I)
Definition: InstVisitor.h:171
llvm::InsertElementInst
This instruction inserts a single (scalar) element into a VectorType value.
Definition: Instructions.h:1923
llvm::Instruction
Definition: Instruction.h:42
llvm::InstVisitor::visitFPToSIInst
RetTy visitFPToSIInst(FPToSIInst &I)
Definition: InstVisitor.h:182
llvm::InstVisitor::visitLoadInst
RetTy visitLoadInst(LoadInst &I)
Definition: InstVisitor.h:169
llvm::InstVisitor::visitFPExtInst
RetTy visitFPExtInst(FPExtInst &I)
Definition: InstVisitor.h:180
llvm::InstVisitor::visitPHINode
RetTy visitPHINode(PHINode &I)
Definition: InstVisitor.h:175
llvm::DbgInfoIntrinsic
This is the common base class for debug info intrinsics.
Definition: IntrinsicInst.h:135
llvm::MemSetInst
This class wraps the llvm.memset and llvm.memset.inline intrinsics.
Definition: IntrinsicInst.h:989
llvm::UnaryInstruction
Definition: InstrTypes.h:56
llvm::InvokeInst
Invoke instruction.
Definition: Instructions.h:3763
llvm::CmpInst
This class is the base class for the comparison instructions.
Definition: InstrTypes.h:709
llvm::InstVisitor::visitCleanupReturnInst
RetTy visitCleanupReturnInst(CleanupReturnInst &I)
Definition: InstVisitor.h:245
llvm::InstVisitor::visitUnaryInstruction
RetTy visitUnaryInstruction(UnaryInstruction &I)
Definition: InstVisitor.h:264
llvm::DbgVariableIntrinsic
This is the common base class for debug info intrinsics for variables.
Definition: IntrinsicInst.h:149
llvm::CleanupPadInst
Definition: Instructions.h:4446
llvm::InstVisitor::visitSelectInst
RetTy visitSelectInst(SelectInst &I)
Definition: InstVisitor.h:189
llvm::StoreInst
An instruction for storing to memory.
Definition: Instructions.h:297
llvm::ICmpInst
This instruction compares its operands according to the predicate given to the constructor.
Definition: Instructions.h:1173
llvm::InstVisitor::visitSExtInst
RetTy visitSExtInst(SExtInst &I)
Definition: InstVisitor.h:178
llvm::FPToSIInst
This class represents a cast from floating point to signed integer.
Definition: Instructions.h:5079
llvm::CatchReturnInst
Definition: Instructions.h:4538
llvm::DbgDeclareInst
This represents the llvm.dbg.declare instruction.
Definition: IntrinsicInst.h:309
llvm::DbgLabelInst
This represents the llvm.dbg.label instruction.
Definition: IntrinsicInst.h:371
llvm::TruncInst
This class represents a truncation of integer types.
Definition: Instructions.h:4767
llvm::CallBrInst
CallBr instruction, tracking function calls that may not return control but instead transfer it to a ...
Definition: Instructions.h:3972
I
#define I(x, y, z)
Definition: MD5.cpp:58
llvm::InstVisitor::visit
void visit(Module *M)
Definition: InstVisitor.h:108
llvm::GetElementPtrInst
an instruction for type-safe pointer arithmetic to access elements of arrays and structs
Definition: Instructions.h:916
llvm::InstVisitor::visitFreezeInst
RetTy visitFreezeInst(FreezeInst &I)
Definition: InstVisitor.h:200
llvm::InstVisitor::visit
void visit(Iterator Start, Iterator End)
Definition: InstVisitor.h:87
llvm::InstVisitor::visitUIToFPInst
RetTy visitUIToFPInst(UIToFPInst &I)
Definition: InstVisitor.h:183
llvm::InstVisitor::visitFPToUIInst
RetTy visitFPToUIInst(FPToUIInst &I)
Definition: InstVisitor.h:181
llvm::InstVisitor::visit
void visit(BasicBlock &BB)
Definition: InstVisitor.h:102
memcpy
<%struct.s * > cast struct s *S to sbyte *< sbyte * > sbyte uint cast struct s *agg result to sbyte *< sbyte * > sbyte uint cast struct s *memtmp to sbyte *< sbyte * > sbyte uint ret void llc ends up issuing two memcpy or custom lower memcpy(of small size) to be ldmia/stmia. I think option 2 is better but the current register allocator cannot allocate a chunk of registers at a time. A feasible temporary solution is to use specific physical registers at the lowering time for small(<
llvm::InstVisitor::visitMemCpyInlineInst
RetTy visitMemCpyInlineInst(MemCpyInlineInst &I)
Definition: InstVisitor.h:211
llvm::InstVisitor::visitAddrSpaceCastInst
RetTy visitAddrSpaceCastInst(AddrSpaceCastInst &I)
Definition: InstVisitor.h:188
llvm::InstVisitor::visitFenceInst
RetTy visitFenceInst(FenceInst &I)
Definition: InstVisitor.h:173
llvm::SelectInst
This class represents the LLVM 'select' instruction.
Definition: Instructions.h:1724
llvm::FPToUIInst
This class represents a cast from floating point to unsigned integer.
Definition: Instructions.h:5040
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
llvm::InstVisitor::visitFCmpInst
RetTy visitFCmpInst(FCmpInst &I)
Definition: InstVisitor.h:167
llvm::InstVisitor::visitStoreInst
RetTy visitStoreInst(StoreInst &I)
Definition: InstVisitor.h:170
llvm::ZExtInst
This class represents zero extension of integer types.
Definition: Instructions.h:4806
llvm::InstVisitor::visitModule
void visitModule(Module &M)
Definition: InstVisitor.h:141
llvm::InstVisitor::visitReturnInst
RetTy visitReturnInst(ReturnInst &I)
Definition: InstVisitor.h:227
llvm::VAEndInst
This represents the llvm.va_end intrinsic.
Definition: IntrinsicInst.h:1208
llvm::BinaryOperator
Definition: InstrTypes.h:188
llvm::InstVisitor::visitAtomicRMWInst
RetTy visitAtomicRMWInst(AtomicRMWInst &I)
Definition: InstVisitor.h:172
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:143
llvm::PtrToIntInst
This class represents a cast from a pointer to an integer.
Definition: Instructions.h:5161
llvm::InstVisitor
Base class for instruction visitors.
Definition: InstVisitor.h:78
llvm::FPExtInst
This class represents an extension of floating point types.
Definition: Instructions.h:4923
llvm::CastInst
This is the base class for all instructions that perform data casts.
Definition: InstrTypes.h:429
llvm::InstVisitor::visit
void visit(BasicBlock *BB)
Definition: InstVisitor.h:110
llvm::SExtInst
This class represents a sign extension of integer types.
Definition: Instructions.h:4845
llvm::LoadInst
An instruction for reading from memory.
Definition: Instructions.h:173
llvm::InstVisitor::visitAllocaInst
RetTy visitAllocaInst(AllocaInst &I)
Definition: InstVisitor.h:168
llvm::AtomicRMWInst
an instruction that atomically reads a memory location, combines it with another value,...
Definition: Instructions.h:714
llvm::InstVisitor::visitBinaryOperator
RetTy visitBinaryOperator(BinaryOperator &I)
Definition: InstVisitor.h:262
llvm::InstVisitor::visitFunction
void visitFunction(Function &F)
Definition: InstVisitor.h:142
llvm::ResumeInst
Resume the propagation of an exception.
Definition: Instructions.h:4211
llvm::InstVisitor::visitInvokeInst
RetTy visitInvokeInst(InvokeInst &I)
Definition: InstVisitor.h:222
llvm::InstVisitor::visitBasicBlock
void visitBasicBlock(BasicBlock &BB)
Definition: InstVisitor.h:143
DELEGATE
#define DELEGATE(CLASS_TO_VISIT)
Definition: InstVisitor.h:27
llvm::InstVisitor::visitMemSetInst
RetTy visitMemSetInst(MemSetInst &I)
Definition: InstVisitor.h:209
llvm::VACopyInst
This represents the llvm.va_copy intrinsic.
Definition: IntrinsicInst.h:1221
llvm::InstVisitor::visitResumeInst
RetTy visitResumeInst(ResumeInst &I)
Definition: InstVisitor.h:239
llvm::ExtractValueInst
This instruction extracts a struct member or array element value from an aggregate value.
Definition: Instructions.h:2398
llvm::InstVisitor::visit
void visit(Module &M)
Definition: InstVisitor.h:94
llvm::InstVisitor::visitCallBrInst
RetTy visitCallBrInst(CallBrInst &I)
Definition: InstVisitor.h:223
Function.h
llvm::InstVisitor::visit
void visit(Function *F)
Definition: InstVisitor.h:109
llvm::InstVisitor::visitUnreachableInst
RetTy visitUnreachableInst(UnreachableInst &I)
Definition: InstVisitor.h:242
llvm::UIToFPInst
This class represents a cast unsigned integer to floating point.
Definition: Instructions.h:4962
llvm::CleanupReturnInst
Definition: Instructions.h:4619
llvm::IntToPtrInst
This class represents a cast from an integer to a pointer.
Definition: Instructions.h:5118
llvm::IndirectBrInst
Indirect Branch Instruction.
Definition: Instructions.h:3628
llvm::IntrinsicInst
A wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:46
llvm::InstVisitor::visit
RetTy visit(Instruction *I)
Definition: InstVisitor.h:111
llvm::InstVisitor::visitCmpInst
RetTy visitCmpInst(CmpInst &I)
Definition: InstVisitor.h:263
llvm::CatchPadInst
Definition: Instructions.h:4487
llvm::ShuffleVectorInst
This instruction constructs a fixed permutation of two input vectors.
Definition: Instructions.h:1995
Instructions.h
llvm::MemCpyInst
This class wraps the llvm.memcpy intrinsic.
Definition: IntrinsicInst.h:1041
llvm::FuncletPadInst
Definition: InstrTypes.h:2369
llvm::SIToFPInst
This class represents a cast from signed integer to floating point.
Definition: Instructions.h:5001
llvm::FreezeInst
This class represents a freeze function that returns random concrete value if an operand is either a ...
Definition: Instructions.h:5394
llvm::FPTruncInst
This class represents a truncation of floating point types.
Definition: Instructions.h:4884
llvm::InstVisitor::visitCallInst
RetTy visitCallInst(CallInst &I)
Definition: InstVisitor.h:221
llvm::InstVisitor::visitSwitchInst
RetTy visitSwitchInst(SwitchInst &I)
Definition: InstVisitor.h:233
llvm::PHINode
Definition: Instructions.h:2651
llvm::InstVisitor::visitExtractValueInst
RetTy visitExtractValueInst(ExtractValueInst &I)
Definition: InstVisitor.h:194
llvm::CallBase
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1174
llvm::CallInst
This class represents a function call, abstracting a target machine's calling convention.
Definition: Instructions.h:1461
BB
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM BB
Definition: README.txt:39
llvm::UnreachableInst
This function has undefined behavior.
Definition: Instructions.h:4727
llvm::InstVisitor::visitMemTransferInst
RetTy visitMemTransferInst(MemTransferInst &I)
Definition: InstVisitor.h:215
llvm::SwitchInst
Multiway switch.
Definition: Instructions.h:3230
llvm::AllocaInst
an instruction to allocate memory on the stack
Definition: Instructions.h:58
llvm::InstVisitor::visitDbgInfoIntrinsic
RetTy visitDbgInfoIntrinsic(DbgInfoIntrinsic &I)
Definition: InstVisitor.h:208
llvm::BranchInst
Conditional or Unconditional Branch instruction.
Definition: Instructions.h:3086
llvm::InstVisitor::visitSIToFPInst
RetTy visitSIToFPInst(SIToFPInst &I)
Definition: InstVisitor.h:184
llvm::InsertValueInst
This instruction inserts a struct field of array element value into an aggregate value.
Definition: Instructions.h:2509
llvm::CatchSwitchInst
Definition: Instructions.h:4268
llvm::InstVisitor::visit
RetTy visit(Instruction &I)
Definition: InstVisitor.h:115
llvm::InstVisitor::visitVAEndInst
RetTy visitVAEndInst(VAEndInst &I)
Definition: InstVisitor.h:218
llvm::AtomicCmpXchgInst
An instruction that atomically checks whether a specified value is in a memory location,...
Definition: Instructions.h:509
llvm::InstVisitor::visitExtractElementInst
RetTy visitExtractElementInst(ExtractElementInst &I)
Definition: InstVisitor.h:191
llvm::InstVisitor::visitCatchReturnInst
RetTy visitCatchReturnInst(CatchReturnInst &I)
Definition: InstVisitor.h:248
llvm::InstVisitor::visitIntToPtrInst
RetTy visitIntToPtrInst(IntToPtrInst &I)
Definition: InstVisitor.h:186
llvm::InstVisitor::visitMemMoveInst
RetTy visitMemMoveInst(MemMoveInst &I)
Definition: InstVisitor.h:214