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
195
196
197
198
|
//===-- llvm/ConstPoolVals.h - Constant Value nodes --------------*- C++ -*--=//
//
// This file contains the declarations for the ConstPoolVal class and all of
// its subclasses, which represent the different type of constant pool values
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CONSTPOOLVALS_H
#define LLVM_CONSTPOOLVALS_H
#include "llvm/User.h"
#include "llvm/Support/DataTypes.h"
#include <vector>
class ArrayType;
class StructType;
//===----------------------------------------------------------------------===//
// ConstPoolVal Class
//===----------------------------------------------------------------------===//
class ConstPoolVal : public User {
protected:
inline ConstPoolVal(const Type *Ty) : User(Ty, Value::ConstantVal) {}
public:
// Specialize setName to handle symbol table majik...
virtual void setName(const string &name, SymbolTable *ST = 0);
virtual string getStrValue() const = 0;
// Static constructor to get a '0' constant of arbitrary type...
static ConstPoolVal *getNullConstant(const Type *Ty);
};
//===----------------------------------------------------------------------===//
// Classes to represent constant pool variable defs
//===----------------------------------------------------------------------===//
//===---------------------------------------------------------------------------
// ConstPoolBool - Boolean Values
//
class ConstPoolBool : public ConstPoolVal {
bool Val;
ConstPoolBool(const ConstPoolBool &); // DO NOT IMPLEMENT
ConstPoolBool(bool V);
public:
static ConstPoolBool *True, *False; // The True & False values
// Factory objects - Return objects of the specified value
static ConstPoolBool *get(bool Value) { return Value ? True : False; }
static ConstPoolBool *get(const Type *Ty, bool Value) { return get(Value); }
// inverted - Return the opposite value of the current value.
inline ConstPoolBool *inverted() const { return (this==True) ? False : True; }
virtual string getStrValue() const;
inline bool getValue() const { return Val; }
};
//===---------------------------------------------------------------------------
// ConstPoolInt - Superclass of ConstPoolSInt & ConstPoolUInt, to make dealing
// with integral constants easier.
//
class ConstPoolInt : public ConstPoolVal {
protected:
union {
int64_t Signed;
uint64_t Unsigned;
} Val;
ConstPoolInt(const ConstPoolInt &); // DO NOT IMPLEMENT
ConstPoolInt(const Type *Ty, uint64_t V);
public:
// equalsInt - Provide a helper method that can be used to determine if the
// constant contained within is equal to a constant. This only works for very
// small values, because this is all that can be represented with all types.
//
bool equalsInt(unsigned char V) const {
assert(V <= 127 &&
"equals: Can only be used with very small positive constants!");
return Val.Unsigned == V;
}
// ConstPoolInt::get static method: return a constant pool int with the
// specified value. as above, we work only with very small values here.
//
static ConstPoolInt *get(const Type *Ty, unsigned char V);
};
//===---------------------------------------------------------------------------
// ConstPoolSInt - Signed Integer Values [sbyte, short, int, long]
//
class ConstPoolSInt : public ConstPoolInt {
ConstPoolSInt(const ConstPoolSInt &); // DO NOT IMPLEMENT
protected:
ConstPoolSInt(const Type *Ty, int64_t V);
public:
static ConstPoolSInt *get(const Type *Ty, int64_t V);
virtual string getStrValue() const;
static bool isValueValidForType(const Type *Ty, int64_t V);
inline int64_t getValue() const { return Val.Signed; }
};
//===---------------------------------------------------------------------------
// ConstPoolUInt - Unsigned Integer Values [ubyte, ushort, uint, ulong]
//
class ConstPoolUInt : public ConstPoolInt {
ConstPoolUInt(const ConstPoolUInt &); // DO NOT IMPLEMENT
protected:
ConstPoolUInt(const Type *Ty, uint64_t V);
public:
static ConstPoolUInt *get(const Type *Ty, uint64_t V);
virtual string getStrValue() const;
static bool isValueValidForType(const Type *Ty, uint64_t V);
inline uint64_t getValue() const { return Val.Unsigned; }
};
//===---------------------------------------------------------------------------
// ConstPoolFP - Floating Point Values [float, double]
//
class ConstPoolFP : public ConstPoolVal {
double Val;
ConstPoolFP(const ConstPoolFP &); // DO NOT IMPLEMENT
protected:
ConstPoolFP(const Type *Ty, double V);
public:
static ConstPoolFP *get(const Type *Ty, double V);
virtual string getStrValue() const;
static bool isValueValidForType(const Type *Ty, double V);
inline double getValue() const { return Val; }
};
//===---------------------------------------------------------------------------
// ConstPoolArray - Constant Array Declarations
//
class ConstPoolArray : public ConstPoolVal {
ConstPoolArray(const ConstPoolArray &); // DO NOT IMPLEMENT
protected:
ConstPoolArray(const ArrayType *T, const vector<ConstPoolVal*> &Val);
public:
static ConstPoolArray *get(const ArrayType *T, const vector<ConstPoolVal*> &);
virtual string getStrValue() const;
inline const vector<Use> &getValues() const { return Operands; }
};
//===---------------------------------------------------------------------------
// ConstPoolStruct - Constant Struct Declarations
//
class ConstPoolStruct : public ConstPoolVal {
ConstPoolStruct(const ConstPoolStruct &); // DO NOT IMPLEMENT
protected:
ConstPoolStruct(const StructType *T, const vector<ConstPoolVal*> &Val);
public:
static ConstPoolStruct *get(const StructType *T,
const vector<ConstPoolVal*> &V);
virtual string getStrValue() const;
inline const vector<Use> &getValues() const { return Operands; }
};
//===---------------------------------------------------------------------------
// External functions
//
// Convenience functions to get the value of an integer constant, for an
// appropriate integer or non-integer type that can be held in an integer.
// The type of the argument must be the following:
// GetSignedIntConstantValue: signed integer or bool
// GetUnsignedIntConstantValue: unsigned integer, bool, or pointer
// GetConstantValueAsSignedInt: any of the above, but the value
// must fit into a int64_t.
//
// isValidConstant is set to true if a valid constant was found.
//
int64_t GetSignedIntConstantValue (const Value* val, bool& isValidConst);
uint64_t GetUnsignedIntConstantValue (const Value* val, bool& isValidConst);
int64_t GetConstantValueAsSignedInt (const Value* val, bool& isValidConst);
//===---------------------------------------------------------------------------
#endif
|
