1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
|
//===-- llvm/Instruction.h - Instruction class definition -------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the declaration of the Instruction class, which is the
// base class for all of the LLVM instructions.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_INSTRUCTION_H
#define LLVM_INSTRUCTION_H
#include "llvm/User.h"
namespace llvm {
struct AssemblyAnnotationWriter;
class BinaryOperator;
template<typename SC> struct ilist_traits;
template<typename ValueSubClass, typename ItemParentClass, typename SymTabClass,
typename SubClass> class SymbolTableListTraits;
class Instruction : public User {
BasicBlock *Parent;
Instruction *Prev, *Next; // Next and Prev links for our intrusive linked list
void setNext(Instruction *N) { Next = N; }
void setPrev(Instruction *N) { Prev = N; }
friend class SymbolTableListTraits<Instruction, BasicBlock, Function,
ilist_traits<Instruction> >;
void setParent(BasicBlock *P);
private:
// FIXME: This is a dirty hack. Setcc instructions shouldn't encode the CC
// into the opcode field. When they don't, this will be unneeded.
void setOpcode(unsigned NewOpcode);
friend class BinaryOperator;
protected:
Instruction(const Type *Ty, unsigned iType, Use *Ops, unsigned NumOps,
const std::string &Name = "",
Instruction *InsertBefore = 0);
Instruction(const Type *Ty, unsigned iType, Use *Ops, unsigned NumOps,
const std::string &Name, BasicBlock *InsertAtEnd);
public:
~Instruction() {
assert(Parent == 0 && "Instruction still linked in the program!");
}
/// mayWriteToMemory - Return true if this instruction may modify memory.
///
virtual bool mayWriteToMemory() const { return false; }
/// clone() - Create a copy of 'this' instruction that is identical in all
/// ways except the following:
/// * The instruction has no parent
/// * The instruction has no name
///
virtual Instruction *clone() const = 0;
/// isIdenticalTo - Return true if the specified instruction is exactly
/// identical to the current one. This means that all operands match and any
/// extra information (e.g. load is volatile) agree.
bool isIdenticalTo(Instruction *I) const;
// Accessor methods...
//
inline const BasicBlock *getParent() const { return Parent; }
inline BasicBlock *getParent() { return Parent; }
// getNext/Prev - Return the next or previous instruction in the list. The
// last node in the list is a terminator instruction.
Instruction *getNext() { return Next; }
const Instruction *getNext() const { return Next; }
Instruction *getPrev() { return Prev; }
const Instruction *getPrev() const { return Prev; }
/// removeFromParent - This method unlinks 'this' from the containing basic
/// block, but does not delete it.
///
void removeFromParent();
/// eraseFromParent - This method unlinks 'this' from the containing basic
/// block and deletes it.
///
void eraseFromParent();
// ---------------------------------------------------------------------------
/// Subclass classification... getOpcode() returns a member of
/// one of the enums that is coming soon (down below)...
///
unsigned getOpcode() const { return getValueType() - InstructionVal; }
virtual const char *getOpcodeName() const {
return getOpcodeName(getOpcode());
}
static const char* getOpcodeName(unsigned OpCode);
static inline bool isTerminator(unsigned OpCode) {
return OpCode >= TermOpsBegin && OpCode < TermOpsEnd;
}
inline bool isTerminator() const { // Instance of TerminatorInst?
return isTerminator(getOpcode());
}
inline bool isBinaryOp() const {
return getOpcode() >= BinaryOpsBegin && getOpcode() < BinaryOpsEnd;
}
/// isAssociative - Return true if the instruction is associative:
///
/// Associative operators satisfy: x op (y op z) === (x op y) op z
///
/// In LLVM, the Add, Mul, And, Or, and Xor operators are associative, when
/// not applied to floating point types.
///
bool isAssociative() const { return isAssociative(getOpcode(), getType()); }
static bool isAssociative(unsigned op, const Type *Ty);
/// isCommutative - Return true if the instruction is commutative:
///
/// Commutative operators satisfy: (x op y) === (y op x)
///
/// In LLVM, these are the associative operators, plus SetEQ and SetNE, when
/// applied to any type.
///
bool isCommutative() const { return isCommutative(getOpcode()); }
static bool isCommutative(unsigned op);
/// isRelational - Return true if the instruction is a Set* instruction:
///
bool isRelational() const { return isRelational(getOpcode()); }
static bool isRelational(unsigned op);
/// isTrappingInstruction - Return true if the instruction may trap.
///
bool isTrapping() const {
return isTrapping(getOpcode());
}
static bool isTrapping(unsigned op);
virtual void print(std::ostream &OS) const { print(OS, 0); }
void print(std::ostream &OS, AssemblyAnnotationWriter *AAW) const;
/// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const Instruction *I) { return true; }
static inline bool classof(const Value *V) {
return V->getValueType() >= Value::InstructionVal;
}
//----------------------------------------------------------------------
// Exported enumerations...
//
enum TermOps { // These terminate basic blocks
#define FIRST_TERM_INST(N) TermOpsBegin = N,
#define HANDLE_TERM_INST(N, OPC, CLASS) OPC = N,
#define LAST_TERM_INST(N) TermOpsEnd = N+1
#include "llvm/Instruction.def"
};
enum BinaryOps {
#define FIRST_BINARY_INST(N) BinaryOpsBegin = N,
#define HANDLE_BINARY_INST(N, OPC, CLASS) OPC = N,
#define LAST_BINARY_INST(N) BinaryOpsEnd = N+1
#include "llvm/Instruction.def"
};
enum MemoryOps {
#define FIRST_MEMORY_INST(N) MemoryOpsBegin = N,
#define HANDLE_MEMORY_INST(N, OPC, CLASS) OPC = N,
#define LAST_MEMORY_INST(N) MemoryOpsEnd = N+1
#include "llvm/Instruction.def"
};
enum OtherOps {
#define FIRST_OTHER_INST(N) OtherOpsBegin = N,
#define HANDLE_OTHER_INST(N, OPC, CLASS) OPC = N,
#define LAST_OTHER_INST(N) OtherOpsEnd = N+1
#include "llvm/Instruction.def"
};
};
} // End llvm namespace
#endif
|
