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
|
//===-- llvm/iOther.h - "Other" instruction node definitions -----*- C++ -*--=//
//
// This file contains the declarations for instructions that fall into the
// grandios 'other' catagory...
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_IOTHER_H
#define LLVM_IOTHER_H
#include "llvm/InstrTypes.h"
//===----------------------------------------------------------------------===//
// CastInst Class
//===----------------------------------------------------------------------===//
// CastInst - This class represents a cast from Operand[0] to the type of
// the instruction (i->getType()).
//
class CastInst : public Instruction {
CastInst(const CastInst &CI) : Instruction(CI.getType(), Cast) {
Operands.reserve(1);
Operands.push_back(Use(CI.Operands[0], this));
}
public:
CastInst(Value *S, const Type *Ty, const std::string &Name = "")
: Instruction(Ty, Cast, Name) {
Operands.reserve(1);
Operands.push_back(Use(S, this));
}
virtual Instruction *clone() const { return new CastInst(*this); }
virtual const char *getOpcodeName() const { return "cast"; }
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const CastInst *) { return true; }
static inline bool classof(const Instruction *I) {
return I->getOpcode() == Cast;
}
static inline bool classof(const Value *V) {
return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
};
//===----------------------------------------------------------------------===//
// FunctionArgument Class
//===----------------------------------------------------------------------===//
class FunctionArgument : public Value { // Defined in the InstrType.cpp file
Function *Parent;
friend class ValueHolder<FunctionArgument,Function,Function>;
inline void setParent(Function *parent) { Parent = parent; }
public:
FunctionArgument(const Type *Ty, const std::string &Name = "")
: Value(Ty, Value::FunctionArgumentVal, Name) {
Parent = 0;
}
// Specialize setName to handle symbol table majik...
virtual void setName(const std::string &name, SymbolTable *ST = 0);
inline const Function *getParent() const { return Parent; }
inline Function *getParent() { return Parent; }
virtual void print(std::ostream &OS) const;
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const FunctionArgument *) { return true; }
static inline bool classof(const Value *V) {
return V->getValueType() == FunctionArgumentVal;
}
};
//===----------------------------------------------------------------------===//
// Classes to function calls and method invocations
//===----------------------------------------------------------------------===//
class CallInst : public Instruction {
CallInst(const CallInst &CI);
public:
CallInst(Value *M, const std::vector<Value*> &Par, const std::string & = "");
virtual const char *getOpcodeName() const { return "call"; }
virtual Instruction *clone() const { return new CallInst(*this); }
bool hasSideEffects() const { return true; }
const Function *getCalledFunction() const {
return dyn_cast<Function>(Operands[0].get());
}
Function *getCalledFunction() {
return dyn_cast<Function>(Operands[0].get());
}
// getCalledValue - Get a pointer to a method that is invoked by this inst.
inline const Value *getCalledValue() const { return Operands[0]; }
inline Value *getCalledValue() { return Operands[0]; }
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const CallInst *) { return true; }
static inline bool classof(const Instruction *I) {
return I->getOpcode() == Instruction::Call;
}
static inline bool classof(const Value *V) {
return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
};
//===----------------------------------------------------------------------===//
// ShiftInst Class
//===----------------------------------------------------------------------===//
// ShiftInst - This class represents left and right shift instructions.
//
class ShiftInst : public Instruction {
ShiftInst(const ShiftInst &SI) : Instruction(SI.getType(), SI.getOpcode()) {
Operands.reserve(2);
Operands.push_back(Use(SI.Operands[0], this));
Operands.push_back(Use(SI.Operands[1], this));
}
public:
ShiftInst(OtherOps Opcode, Value *S, Value *SA, const std::string &Name = "")
: Instruction(S->getType(), Opcode, Name) {
assert((Opcode == Shl || Opcode == Shr) && "ShiftInst Opcode invalid!");
Operands.reserve(2);
Operands.push_back(Use(S, this));
Operands.push_back(Use(SA, this));
}
OtherOps getOpcode() const { return (OtherOps)Instruction::getOpcode(); }
virtual Instruction *clone() const { return new ShiftInst(*this); }
virtual const char *getOpcodeName() const {
return getOpcode() == Shl ? "shl" : "shr";
}
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const ShiftInst *) { return true; }
static inline bool classof(const Instruction *I) {
return (I->getOpcode() == Instruction::Shr) |
(I->getOpcode() == Instruction::Shl);
}
static inline bool classof(const Value *V) {
return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
};
#endif
|
