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
|
//===-- llvm/Instruction.h - Instruction class definition -------*- C++ -*-===//
//
// 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"
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);
protected:
unsigned iType; // InstructionType: The opcode of the instruction
Instruction(const Type *Ty, unsigned iType, const std::string &Name = "",
Instruction *InsertBefore = 0);
public:
virtual ~Instruction() {
assert(Parent == 0 && "Instruction still embedded in basic block!");
}
// Specialize setName to handle symbol table majik...
virtual void setName(const std::string &name, SymbolTable *ST = 0);
/// 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;
// 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; }
/// mayWriteToMemory - Return true if this instruction may modify memory.
///
virtual bool mayWriteToMemory() const { return false; }
// ---------------------------------------------------------------------------
/// Subclass classification... getOpcode() returns a member of
/// one of the enums that is coming soon (down below)...
///
unsigned getOpcode() const { return iType; }
virtual const char *getOpcodeName() const {
return getOpcodeName(getOpcode());
}
static const char* getOpcodeName(unsigned OpCode);
inline bool isTerminator() const { // Instance of TerminatorInst?
return iType >= TermOpsBegin && iType < TermOpsEnd;
}
inline bool isBinaryOp() const {
return iType >= BinaryOpsBegin && iType < 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 satistify: (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);
virtual void print(std::ostream &OS) 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"
};
};
#endif
|
