1 //===-- iConstPool.cpp - Implement ConstPool instructions --------*- C++ -*--=//
3 // This file implements the ConstPool* classes...
5 //===----------------------------------------------------------------------===//
7 #define __STDC_LIMIT_MACROS // Get defs for INT64_MAX and friends...
8 #include "llvm/ConstPoolVals.h"
9 #include "llvm/Support/StringExtras.h" // itostr
10 #include "llvm/DerivedTypes.h"
11 #include "llvm/SymbolTable.h"
15 ConstPoolBool *ConstPoolBool::True = new ConstPoolBool(true);
16 ConstPoolBool *ConstPoolBool::False = new ConstPoolBool(false);
19 //===----------------------------------------------------------------------===//
21 //===----------------------------------------------------------------------===//
23 // Specialize setName to take care of symbol table majik
24 void ConstPoolVal::setName(const string &Name, SymbolTable *ST) {
25 assert(ST && "Type::setName - Must provide symbol table argument!");
27 if (Name.size()) ST->insert(Name, this);
30 // Static constructor to create a '0' constant of arbitrary type...
31 ConstPoolVal *ConstPoolVal::getNullConstant(const Type *Ty) {
32 switch (Ty->getPrimitiveID()) {
33 case Type::BoolTyID: return ConstPoolBool::get(false);
37 case Type::LongTyID: return ConstPoolSInt::get(Ty, 0);
40 case Type::UShortTyID:
42 case Type::ULongTyID: return ConstPoolUInt::get(Ty, 0);
45 case Type::DoubleTyID: return ConstPoolFP::get(Ty, 0);
53 //===----------------------------------------------------------------------===//
54 // ConstPoolXXX Classes
55 //===----------------------------------------------------------------------===//
57 //===----------------------------------------------------------------------===//
58 // Normal Constructors
60 ConstPoolBool::ConstPoolBool(bool V) : ConstPoolVal(Type::BoolTy) {
64 ConstPoolInt::ConstPoolInt(const Type *Ty, uint64_t V) : ConstPoolVal(Ty) {
68 ConstPoolSInt::ConstPoolSInt(const Type *Ty, int64_t V) : ConstPoolInt(Ty, V) {
69 assert(isValueValidForType(Ty, V) && "Value too large for type!");
72 ConstPoolUInt::ConstPoolUInt(const Type *Ty, uint64_t V) : ConstPoolInt(Ty, V) {
73 assert(isValueValidForType(Ty, V) && "Value too large for type!");
76 ConstPoolFP::ConstPoolFP(const Type *Ty, double V) : ConstPoolVal(Ty) {
77 assert(isValueValidForType(Ty, V) && "Value too large for type!");
81 ConstPoolArray::ConstPoolArray(const ArrayType *T,
82 const vector<ConstPoolVal*> &V)
84 for (unsigned i = 0; i < V.size(); i++) {
85 assert(V[i]->getType() == T->getElementType());
86 Operands.push_back(Use(V[i], this));
90 ConstPoolStruct::ConstPoolStruct(const StructType *T,
91 const vector<ConstPoolVal*> &V)
93 const StructType::ElementTypes &ETypes = T->getElementTypes();
95 for (unsigned i = 0; i < V.size(); i++) {
96 assert(V[i]->getType() == ETypes[i]);
97 Operands.push_back(Use(V[i], this));
102 //===----------------------------------------------------------------------===//
103 // getStrValue implementations
105 string ConstPoolBool::getStrValue() const {
106 return Val ? "true" : "false";
109 string ConstPoolSInt::getStrValue() const {
110 return itostr(Val.Signed);
113 string ConstPoolUInt::getStrValue() const {
114 return utostr(Val.Unsigned);
117 string ConstPoolFP::getStrValue() const {
121 string ConstPoolArray::getStrValue() const {
123 if (Operands.size()) {
124 Result += " " + Operands[0]->getType()->getDescription() +
125 " " + Operands[0]->castConstantAsserting()->getStrValue();
126 for (unsigned i = 1; i < Operands.size(); i++)
127 Result += ", " + Operands[i]->getType()->getDescription() +
128 " " + Operands[i]->castConstantAsserting()->getStrValue();
131 return Result + " ]";
134 string ConstPoolStruct::getStrValue() const {
136 if (Operands.size()) {
137 Result += " " + Operands[0]->getType()->getDescription() +
138 " " + Operands[0]->castConstantAsserting()->getStrValue();
139 for (unsigned i = 1; i < Operands.size(); i++)
140 Result += ", " + Operands[i]->getType()->getDescription() +
141 " " + Operands[i]->castConstantAsserting()->getStrValue();
144 return Result + " }";
147 //===----------------------------------------------------------------------===//
148 // isValueValidForType implementations
150 bool ConstPoolSInt::isValueValidForType(const Type *Ty, int64_t Val) {
151 switch (Ty->getPrimitiveID()) {
153 return false; // These can't be represented as integers!!!
156 case Type::SByteTyID:
157 return (Val <= INT8_MAX && Val >= INT8_MIN);
158 case Type::ShortTyID:
159 return (Val <= INT16_MAX && Val >= INT16_MIN);
161 return (Val <= INT32_MAX && Val >= INT32_MIN);
163 return true; // This is the largest type...
169 bool ConstPoolUInt::isValueValidForType(const Type *Ty, uint64_t Val) {
170 switch (Ty->getPrimitiveID()) {
172 return false; // These can't be represented as integers!!!
175 case Type::UByteTyID:
176 return (Val <= UINT8_MAX);
177 case Type::UShortTyID:
178 return (Val <= UINT16_MAX);
180 return (Val <= UINT32_MAX);
181 case Type::ULongTyID:
182 return true; // This is the largest type...
188 bool ConstPoolFP::isValueValidForType(const Type *Ty, double Val) {
189 switch (Ty->getPrimitiveID()) {
191 return false; // These can't be represented as floating point!
193 // TODO: Figure out how to test if a double can be cast to a float!
194 case Type::FloatTyID:
196 return (Val <= UINT8_MAX);
198 case Type::DoubleTyID:
199 return true; // This is the largest type...
203 //===----------------------------------------------------------------------===//
204 // Hash Function Implementations
206 unsigned ConstPoolSInt::hash(const Type *Ty, int64_t V) {
207 return unsigned(Ty->getPrimitiveID() ^ V);
210 unsigned ConstPoolUInt::hash(const Type *Ty, uint64_t V) {
211 return unsigned(Ty->getPrimitiveID() ^ V);
214 unsigned ConstPoolFP::hash(const Type *Ty, double V) {
215 return Ty->getPrimitiveID() ^ unsigned(V);
218 unsigned ConstPoolArray::hash(const ArrayType *Ty,
219 const vector<ConstPoolVal*> &V) {
220 unsigned Result = (Ty->getUniqueID() << 5) ^ (Ty->getUniqueID() * 7);
221 for (unsigned i = 0; i < V.size(); ++i)
222 Result ^= V[i]->getHash() << (i & 7);
226 unsigned ConstPoolStruct::hash(const StructType *Ty,
227 const vector<ConstPoolVal*> &V) {
228 unsigned Result = (Ty->getUniqueID() << 5) ^ (Ty->getUniqueID() * 7);
229 for (unsigned i = 0; i < V.size(); ++i)
230 Result ^= V[i]->getHash() << (i & 7);
235 //===----------------------------------------------------------------------===//
236 // Factory Function Implementation
238 template<class ValType, class ConstPoolClass>
240 typedef pair<const Type*, ValType> ConstHashKey;
241 map<ConstHashKey, ConstPoolClass *> Map;
243 inline ConstPoolClass *get(const Type *Ty, ValType V) {
244 map<ConstHashKey,ConstPoolClass *>::iterator I =
245 Map.find(ConstHashKey(Ty, V));
246 return (I != Map.end()) ? I->second : 0;
249 inline void add(const Type *Ty, ValType V, ConstPoolClass *CP) {
250 Map.insert(make_pair(ConstHashKey(Ty, V), CP));
254 //---- ConstPoolUInt::get() and ConstPoolSInt::get() implementations...
256 static ValueMap<uint64_t, ConstPoolInt> IntConstants;
258 ConstPoolSInt *ConstPoolSInt::get(const Type *Ty, int64_t V) {
259 ConstPoolSInt *Result = (ConstPoolSInt*)IntConstants.get(Ty, (uint64_t)V);
260 if (!Result) // If no preexisting value, create one now...
261 IntConstants.add(Ty, V, Result = new ConstPoolSInt(Ty, V));
265 ConstPoolUInt *ConstPoolUInt::get(const Type *Ty, uint64_t V) {
266 ConstPoolUInt *Result = (ConstPoolUInt*)IntConstants.get(Ty, V);
267 if (!Result) // If no preexisting value, create one now...
268 IntConstants.add(Ty, V, Result = new ConstPoolUInt(Ty, V));
272 ConstPoolInt *ConstPoolInt::get(const Type *Ty, unsigned char V) {
273 assert(V <= 127 && "Can only be used with very small positive constants!");
274 if (Ty->isSigned()) return ConstPoolSInt::get(Ty, V);
275 return ConstPoolUInt::get(Ty, V);
278 //---- ConstPoolFP::get() implementation...
280 static ValueMap<double, ConstPoolFP> FPConstants;
282 ConstPoolFP *ConstPoolFP::get(const Type *Ty, double V) {
283 ConstPoolFP *Result = FPConstants.get(Ty, V);
284 if (!Result) // If no preexisting value, create one now...
285 FPConstants.add(Ty, V, Result = new ConstPoolFP(Ty, V));
289 //---- ConstPoolArray::get() implementation...
291 static ValueMap<vector<ConstPoolVal*>, ConstPoolArray> ArrayConstants;
293 ConstPoolArray *ConstPoolArray::get(const ArrayType *Ty,
294 const vector<ConstPoolVal*> &V) {
295 ConstPoolArray *Result = ArrayConstants.get(Ty, V);
296 if (!Result) // If no preexisting value, create one now...
297 ArrayConstants.add(Ty, V, Result = new ConstPoolArray(Ty, V));
301 //---- ConstPoolStruct::get() implementation...
303 static ValueMap<vector<ConstPoolVal*>, ConstPoolStruct> StructConstants;
305 ConstPoolStruct *ConstPoolStruct::get(const StructType *Ty,
306 const vector<ConstPoolVal*> &V) {
307 ConstPoolStruct *Result = StructConstants.get(Ty, V);
308 if (!Result) // If no preexisting value, create one now...
309 StructConstants.add(Ty, V, Result = new ConstPoolStruct(Ty, V));
316 //===----------------------------------------------------------------------===//
317 // Extra Method implementations
324 // Convenience functions to get the value of an integer constant, for an
325 // appropriate integer or non-integer type that can be held in an integer.
326 // The type of the argument must be the following:
327 // GetSignedIntConstantValue: signed integer or bool
328 // GetUnsignedIntConstantValue: unsigned integer, bool, or pointer
329 // GetConstantValueAsSignedInt: any of the above, but the value
330 // must fit into a int64_t.
332 // isValidConstant is set to true if a valid constant was found.
335 GetSignedIntConstantValue(const Value* val, bool& isValidConstant)
337 int64_t intValue = 0;
338 isValidConstant = false;
340 if (val->getValueType() == Value::ConstantVal)
342 switch(val->getType()->getPrimitiveID())
345 intValue = ((ConstPoolBool*) val)->getValue()? 1 : 0;
346 isValidConstant = true;
348 case Type::SByteTyID:
349 case Type::ShortTyID:
352 intValue = ((ConstPoolSInt*) val)->getValue();
353 isValidConstant = true;
364 GetUnsignedIntConstantValue(const Value* val, bool& isValidConstant)
366 uint64_t intValue = 0;
367 isValidConstant = false;
369 if (val->getValueType() == Value::ConstantVal)
371 switch(val->getType()->getPrimitiveID())
374 intValue = ((ConstPoolBool*) val)->getValue()? 1 : 0;
375 isValidConstant = true;
377 case Type::UByteTyID:
378 case Type::UShortTyID:
380 case Type::ULongTyID:
381 case Type::PointerTyID:
382 intValue = ((ConstPoolUInt*) val)->getValue();
383 isValidConstant = true;
395 GetConstantValueAsSignedInt(const Value* val, bool& isValidConstant)
397 int64_t intValue = 0;
399 if (val->getType()->isSigned())
401 intValue = GetSignedIntConstantValue(val, isValidConstant);
403 else // non-numeric types will fall here
405 uint64_t uintValue = GetUnsignedIntConstantValue(val, isValidConstant);
406 if (isValidConstant && uintValue < INT64_MAX) // then safe to cast to signed
407 intValue = (int64_t) uintValue;
409 isValidConstant = false;