From: Chris Lattner Date: Sun, 9 Sep 2001 21:59:43 +0000 (+0000) Subject: Rename file to be consistent with header name X-Git-Url: http://plrg.eecs.uci.edu/git/?a=commitdiff_plain;h=167ed34a1f42045e0c18d3d3f33d917684c96ed5;p=oota-llvm.git Rename file to be consistent with header name git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@519 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/lib/VMCore/ConstPoolVals.cpp b/lib/VMCore/ConstPoolVals.cpp new file mode 100644 index 00000000000..019d66a0e70 --- /dev/null +++ b/lib/VMCore/ConstPoolVals.cpp @@ -0,0 +1,413 @@ +//===-- iConstPool.cpp - Implement ConstPool instructions --------*- C++ -*--=// +// +// This file implements the ConstPool* classes... +// +//===----------------------------------------------------------------------===// + +#define __STDC_LIMIT_MACROS // Get defs for INT64_MAX and friends... +#include "llvm/ConstPoolVals.h" +#include "llvm/Support/StringExtras.h" // itostr +#include "llvm/DerivedTypes.h" +#include "llvm/SymbolTable.h" +#include +#include + +ConstPoolBool *ConstPoolBool::True = new ConstPoolBool(true); +ConstPoolBool *ConstPoolBool::False = new ConstPoolBool(false); + + +//===----------------------------------------------------------------------===// +// ConstPoolVal Class +//===----------------------------------------------------------------------===// + +// Specialize setName to take care of symbol table majik +void ConstPoolVal::setName(const string &Name, SymbolTable *ST) { + assert(ST && "Type::setName - Must provide symbol table argument!"); + + if (Name.size()) ST->insert(Name, this); +} + +// Static constructor to create a '0' constant of arbitrary type... +ConstPoolVal *ConstPoolVal::getNullConstant(const Type *Ty) { + switch (Ty->getPrimitiveID()) { + case Type::BoolTyID: return ConstPoolBool::get(false); + case Type::SByteTyID: + case Type::ShortTyID: + case Type::IntTyID: + case Type::LongTyID: return ConstPoolSInt::get(Ty, 0); + + case Type::UByteTyID: + case Type::UShortTyID: + case Type::UIntTyID: + case Type::ULongTyID: return ConstPoolUInt::get(Ty, 0); + + case Type::FloatTyID: + case Type::DoubleTyID: return ConstPoolFP::get(Ty, 0); + default: + return 0; + } +} + + + +//===----------------------------------------------------------------------===// +// ConstPoolXXX Classes +//===----------------------------------------------------------------------===// + +//===----------------------------------------------------------------------===// +// Normal Constructors + +ConstPoolBool::ConstPoolBool(bool V) : ConstPoolVal(Type::BoolTy) { + Val = V; +} + +ConstPoolInt::ConstPoolInt(const Type *Ty, uint64_t V) : ConstPoolVal(Ty) { + Val.Unsigned = V; +} + +ConstPoolSInt::ConstPoolSInt(const Type *Ty, int64_t V) : ConstPoolInt(Ty, V) { + assert(isValueValidForType(Ty, V) && "Value too large for type!"); +} + +ConstPoolUInt::ConstPoolUInt(const Type *Ty, uint64_t V) : ConstPoolInt(Ty, V) { + assert(isValueValidForType(Ty, V) && "Value too large for type!"); +} + +ConstPoolFP::ConstPoolFP(const Type *Ty, double V) : ConstPoolVal(Ty) { + assert(isValueValidForType(Ty, V) && "Value too large for type!"); + Val = V; +} + +ConstPoolArray::ConstPoolArray(const ArrayType *T, + const vector &V) + : ConstPoolVal(T) { + for (unsigned i = 0; i < V.size(); i++) { + assert(V[i]->getType() == T->getElementType()); + Operands.push_back(Use(V[i], this)); + } +} + +ConstPoolStruct::ConstPoolStruct(const StructType *T, + const vector &V) + : ConstPoolVal(T) { + const StructType::ElementTypes &ETypes = T->getElementTypes(); + + for (unsigned i = 0; i < V.size(); i++) { + assert(V[i]->getType() == ETypes[i]); + Operands.push_back(Use(V[i], this)); + } +} + + +//===----------------------------------------------------------------------===// +// getStrValue implementations + +string ConstPoolBool::getStrValue() const { + return Val ? "true" : "false"; +} + +string ConstPoolSInt::getStrValue() const { + return itostr(Val.Signed); +} + +string ConstPoolUInt::getStrValue() const { + return utostr(Val.Unsigned); +} + +string ConstPoolFP::getStrValue() const { + return ftostr(Val); +} + +string ConstPoolArray::getStrValue() const { + string Result = "["; + if (Operands.size()) { + Result += " " + Operands[0]->getType()->getDescription() + + " " + Operands[0]->castConstantAsserting()->getStrValue(); + for (unsigned i = 1; i < Operands.size(); i++) + Result += ", " + Operands[i]->getType()->getDescription() + + " " + Operands[i]->castConstantAsserting()->getStrValue(); + } + + return Result + " ]"; +} + +string ConstPoolStruct::getStrValue() const { + string Result = "{"; + if (Operands.size()) { + Result += " " + Operands[0]->getType()->getDescription() + + " " + Operands[0]->castConstantAsserting()->getStrValue(); + for (unsigned i = 1; i < Operands.size(); i++) + Result += ", " + Operands[i]->getType()->getDescription() + + " " + Operands[i]->castConstantAsserting()->getStrValue(); + } + + return Result + " }"; +} + +//===----------------------------------------------------------------------===// +// isValueValidForType implementations + +bool ConstPoolSInt::isValueValidForType(const Type *Ty, int64_t Val) { + switch (Ty->getPrimitiveID()) { + default: + return false; // These can't be represented as integers!!! + + // Signed types... + case Type::SByteTyID: + return (Val <= INT8_MAX && Val >= INT8_MIN); + case Type::ShortTyID: + return (Val <= INT16_MAX && Val >= INT16_MIN); + case Type::IntTyID: + return (Val <= INT32_MAX && Val >= INT32_MIN); + case Type::LongTyID: + return true; // This is the largest type... + } + assert(0 && "WTF?"); + return false; +} + +bool ConstPoolUInt::isValueValidForType(const Type *Ty, uint64_t Val) { + switch (Ty->getPrimitiveID()) { + default: + return false; // These can't be represented as integers!!! + + // Unsigned types... + case Type::UByteTyID: + return (Val <= UINT8_MAX); + case Type::UShortTyID: + return (Val <= UINT16_MAX); + case Type::UIntTyID: + return (Val <= UINT32_MAX); + case Type::ULongTyID: + return true; // This is the largest type... + } + assert(0 && "WTF?"); + return false; +} + +bool ConstPoolFP::isValueValidForType(const Type *Ty, double Val) { + switch (Ty->getPrimitiveID()) { + default: + return false; // These can't be represented as floating point! + + // TODO: Figure out how to test if a double can be cast to a float! + case Type::FloatTyID: + /* + return (Val <= UINT8_MAX); + */ + case Type::DoubleTyID: + return true; // This is the largest type... + } +}; + +//===----------------------------------------------------------------------===// +// Hash Function Implementations +#if 0 +unsigned ConstPoolSInt::hash(const Type *Ty, int64_t V) { + return unsigned(Ty->getPrimitiveID() ^ V); +} + +unsigned ConstPoolUInt::hash(const Type *Ty, uint64_t V) { + return unsigned(Ty->getPrimitiveID() ^ V); +} + +unsigned ConstPoolFP::hash(const Type *Ty, double V) { + return Ty->getPrimitiveID() ^ unsigned(V); +} + +unsigned ConstPoolArray::hash(const ArrayType *Ty, + const vector &V) { + unsigned Result = (Ty->getUniqueID() << 5) ^ (Ty->getUniqueID() * 7); + for (unsigned i = 0; i < V.size(); ++i) + Result ^= V[i]->getHash() << (i & 7); + return Result; +} + +unsigned ConstPoolStruct::hash(const StructType *Ty, + const vector &V) { + unsigned Result = (Ty->getUniqueID() << 5) ^ (Ty->getUniqueID() * 7); + for (unsigned i = 0; i < V.size(); ++i) + Result ^= V[i]->getHash() << (i & 7); + return Result; +} +#endif + +//===----------------------------------------------------------------------===// +// Factory Function Implementation + +template +struct ValueMap { + typedef pair ConstHashKey; + map Map; + + inline ConstPoolClass *get(const Type *Ty, ValType V) { + map::iterator I = + Map.find(ConstHashKey(Ty, V)); + return (I != Map.end()) ? I->second : 0; + } + + inline void add(const Type *Ty, ValType V, ConstPoolClass *CP) { + Map.insert(make_pair(ConstHashKey(Ty, V), CP)); + } +}; + +//---- ConstPoolUInt::get() and ConstPoolSInt::get() implementations... +// +static ValueMap IntConstants; + +ConstPoolSInt *ConstPoolSInt::get(const Type *Ty, int64_t V) { + ConstPoolSInt *Result = (ConstPoolSInt*)IntConstants.get(Ty, (uint64_t)V); + if (!Result) // If no preexisting value, create one now... + IntConstants.add(Ty, V, Result = new ConstPoolSInt(Ty, V)); + return Result; +} + +ConstPoolUInt *ConstPoolUInt::get(const Type *Ty, uint64_t V) { + ConstPoolUInt *Result = (ConstPoolUInt*)IntConstants.get(Ty, V); + if (!Result) // If no preexisting value, create one now... + IntConstants.add(Ty, V, Result = new ConstPoolUInt(Ty, V)); + return Result; +} + +ConstPoolInt *ConstPoolInt::get(const Type *Ty, unsigned char V) { + assert(V <= 127 && "Can only be used with very small positive constants!"); + if (Ty->isSigned()) return ConstPoolSInt::get(Ty, V); + return ConstPoolUInt::get(Ty, V); +} + +//---- ConstPoolFP::get() implementation... +// +static ValueMap FPConstants; + +ConstPoolFP *ConstPoolFP::get(const Type *Ty, double V) { + ConstPoolFP *Result = FPConstants.get(Ty, V); + if (!Result) // If no preexisting value, create one now... + FPConstants.add(Ty, V, Result = new ConstPoolFP(Ty, V)); + return Result; +} + +//---- ConstPoolArray::get() implementation... +// +static ValueMap, ConstPoolArray> ArrayConstants; + +ConstPoolArray *ConstPoolArray::get(const ArrayType *Ty, + const vector &V) { + ConstPoolArray *Result = ArrayConstants.get(Ty, V); + if (!Result) // If no preexisting value, create one now... + ArrayConstants.add(Ty, V, Result = new ConstPoolArray(Ty, V)); + return Result; +} + +//---- ConstPoolStruct::get() implementation... +// +static ValueMap, ConstPoolStruct> StructConstants; + +ConstPoolStruct *ConstPoolStruct::get(const StructType *Ty, + const vector &V) { + ConstPoolStruct *Result = StructConstants.get(Ty, V); + if (!Result) // If no preexisting value, create one now... + StructConstants.add(Ty, V, Result = new ConstPoolStruct(Ty, V)); + return Result; +} + + + + +//===----------------------------------------------------------------------===// +// Extra Method implementations + + + + + + +// 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& isValidConstant) +{ + int64_t intValue = 0; + isValidConstant = false; + + if (val->getValueType() == Value::ConstantVal) + { + switch(val->getType()->getPrimitiveID()) + { + case Type::BoolTyID: + intValue = ((ConstPoolBool*) val)->getValue()? 1 : 0; + isValidConstant = true; + break; + case Type::SByteTyID: + case Type::ShortTyID: + case Type::IntTyID: + case Type::LongTyID: + intValue = ((ConstPoolSInt*) val)->getValue(); + isValidConstant = true; + break; + default: + break; + } + } + + return intValue; +} + +uint64_t +GetUnsignedIntConstantValue(const Value* val, bool& isValidConstant) +{ + uint64_t intValue = 0; + isValidConstant = false; + + if (val->getValueType() == Value::ConstantVal) + { + switch(val->getType()->getPrimitiveID()) + { + case Type::BoolTyID: + intValue = ((ConstPoolBool*) val)->getValue()? 1 : 0; + isValidConstant = true; + break; + case Type::UByteTyID: + case Type::UShortTyID: + case Type::UIntTyID: + case Type::ULongTyID: + case Type::PointerTyID: + intValue = ((ConstPoolUInt*) val)->getValue(); + isValidConstant = true; + break; + default: + break; + } + } + + return intValue; +} + + +int64_t +GetConstantValueAsSignedInt(const Value* val, bool& isValidConstant) +{ + int64_t intValue = 0; + + if (val->getType()->isSigned()) + { + intValue = GetSignedIntConstantValue(val, isValidConstant); + } + else // non-numeric types will fall here + { + uint64_t uintValue = GetUnsignedIntConstantValue(val, isValidConstant); + if (isValidConstant && uintValue < INT64_MAX) // then safe to cast to signed + intValue = (int64_t) uintValue; + else + isValidConstant = false; + } + + return intValue; +} diff --git a/lib/VMCore/ConstantPool.cpp b/lib/VMCore/ConstantPool.cpp deleted file mode 100644 index 019d66a0e70..00000000000 --- a/lib/VMCore/ConstantPool.cpp +++ /dev/null @@ -1,413 +0,0 @@ -//===-- iConstPool.cpp - Implement ConstPool instructions --------*- C++ -*--=// -// -// This file implements the ConstPool* classes... -// -//===----------------------------------------------------------------------===// - -#define __STDC_LIMIT_MACROS // Get defs for INT64_MAX and friends... -#include "llvm/ConstPoolVals.h" -#include "llvm/Support/StringExtras.h" // itostr -#include "llvm/DerivedTypes.h" -#include "llvm/SymbolTable.h" -#include -#include - -ConstPoolBool *ConstPoolBool::True = new ConstPoolBool(true); -ConstPoolBool *ConstPoolBool::False = new ConstPoolBool(false); - - -//===----------------------------------------------------------------------===// -// ConstPoolVal Class -//===----------------------------------------------------------------------===// - -// Specialize setName to take care of symbol table majik -void ConstPoolVal::setName(const string &Name, SymbolTable *ST) { - assert(ST && "Type::setName - Must provide symbol table argument!"); - - if (Name.size()) ST->insert(Name, this); -} - -// Static constructor to create a '0' constant of arbitrary type... -ConstPoolVal *ConstPoolVal::getNullConstant(const Type *Ty) { - switch (Ty->getPrimitiveID()) { - case Type::BoolTyID: return ConstPoolBool::get(false); - case Type::SByteTyID: - case Type::ShortTyID: - case Type::IntTyID: - case Type::LongTyID: return ConstPoolSInt::get(Ty, 0); - - case Type::UByteTyID: - case Type::UShortTyID: - case Type::UIntTyID: - case Type::ULongTyID: return ConstPoolUInt::get(Ty, 0); - - case Type::FloatTyID: - case Type::DoubleTyID: return ConstPoolFP::get(Ty, 0); - default: - return 0; - } -} - - - -//===----------------------------------------------------------------------===// -// ConstPoolXXX Classes -//===----------------------------------------------------------------------===// - -//===----------------------------------------------------------------------===// -// Normal Constructors - -ConstPoolBool::ConstPoolBool(bool V) : ConstPoolVal(Type::BoolTy) { - Val = V; -} - -ConstPoolInt::ConstPoolInt(const Type *Ty, uint64_t V) : ConstPoolVal(Ty) { - Val.Unsigned = V; -} - -ConstPoolSInt::ConstPoolSInt(const Type *Ty, int64_t V) : ConstPoolInt(Ty, V) { - assert(isValueValidForType(Ty, V) && "Value too large for type!"); -} - -ConstPoolUInt::ConstPoolUInt(const Type *Ty, uint64_t V) : ConstPoolInt(Ty, V) { - assert(isValueValidForType(Ty, V) && "Value too large for type!"); -} - -ConstPoolFP::ConstPoolFP(const Type *Ty, double V) : ConstPoolVal(Ty) { - assert(isValueValidForType(Ty, V) && "Value too large for type!"); - Val = V; -} - -ConstPoolArray::ConstPoolArray(const ArrayType *T, - const vector &V) - : ConstPoolVal(T) { - for (unsigned i = 0; i < V.size(); i++) { - assert(V[i]->getType() == T->getElementType()); - Operands.push_back(Use(V[i], this)); - } -} - -ConstPoolStruct::ConstPoolStruct(const StructType *T, - const vector &V) - : ConstPoolVal(T) { - const StructType::ElementTypes &ETypes = T->getElementTypes(); - - for (unsigned i = 0; i < V.size(); i++) { - assert(V[i]->getType() == ETypes[i]); - Operands.push_back(Use(V[i], this)); - } -} - - -//===----------------------------------------------------------------------===// -// getStrValue implementations - -string ConstPoolBool::getStrValue() const { - return Val ? "true" : "false"; -} - -string ConstPoolSInt::getStrValue() const { - return itostr(Val.Signed); -} - -string ConstPoolUInt::getStrValue() const { - return utostr(Val.Unsigned); -} - -string ConstPoolFP::getStrValue() const { - return ftostr(Val); -} - -string ConstPoolArray::getStrValue() const { - string Result = "["; - if (Operands.size()) { - Result += " " + Operands[0]->getType()->getDescription() + - " " + Operands[0]->castConstantAsserting()->getStrValue(); - for (unsigned i = 1; i < Operands.size(); i++) - Result += ", " + Operands[i]->getType()->getDescription() + - " " + Operands[i]->castConstantAsserting()->getStrValue(); - } - - return Result + " ]"; -} - -string ConstPoolStruct::getStrValue() const { - string Result = "{"; - if (Operands.size()) { - Result += " " + Operands[0]->getType()->getDescription() + - " " + Operands[0]->castConstantAsserting()->getStrValue(); - for (unsigned i = 1; i < Operands.size(); i++) - Result += ", " + Operands[i]->getType()->getDescription() + - " " + Operands[i]->castConstantAsserting()->getStrValue(); - } - - return Result + " }"; -} - -//===----------------------------------------------------------------------===// -// isValueValidForType implementations - -bool ConstPoolSInt::isValueValidForType(const Type *Ty, int64_t Val) { - switch (Ty->getPrimitiveID()) { - default: - return false; // These can't be represented as integers!!! - - // Signed types... - case Type::SByteTyID: - return (Val <= INT8_MAX && Val >= INT8_MIN); - case Type::ShortTyID: - return (Val <= INT16_MAX && Val >= INT16_MIN); - case Type::IntTyID: - return (Val <= INT32_MAX && Val >= INT32_MIN); - case Type::LongTyID: - return true; // This is the largest type... - } - assert(0 && "WTF?"); - return false; -} - -bool ConstPoolUInt::isValueValidForType(const Type *Ty, uint64_t Val) { - switch (Ty->getPrimitiveID()) { - default: - return false; // These can't be represented as integers!!! - - // Unsigned types... - case Type::UByteTyID: - return (Val <= UINT8_MAX); - case Type::UShortTyID: - return (Val <= UINT16_MAX); - case Type::UIntTyID: - return (Val <= UINT32_MAX); - case Type::ULongTyID: - return true; // This is the largest type... - } - assert(0 && "WTF?"); - return false; -} - -bool ConstPoolFP::isValueValidForType(const Type *Ty, double Val) { - switch (Ty->getPrimitiveID()) { - default: - return false; // These can't be represented as floating point! - - // TODO: Figure out how to test if a double can be cast to a float! - case Type::FloatTyID: - /* - return (Val <= UINT8_MAX); - */ - case Type::DoubleTyID: - return true; // This is the largest type... - } -}; - -//===----------------------------------------------------------------------===// -// Hash Function Implementations -#if 0 -unsigned ConstPoolSInt::hash(const Type *Ty, int64_t V) { - return unsigned(Ty->getPrimitiveID() ^ V); -} - -unsigned ConstPoolUInt::hash(const Type *Ty, uint64_t V) { - return unsigned(Ty->getPrimitiveID() ^ V); -} - -unsigned ConstPoolFP::hash(const Type *Ty, double V) { - return Ty->getPrimitiveID() ^ unsigned(V); -} - -unsigned ConstPoolArray::hash(const ArrayType *Ty, - const vector &V) { - unsigned Result = (Ty->getUniqueID() << 5) ^ (Ty->getUniqueID() * 7); - for (unsigned i = 0; i < V.size(); ++i) - Result ^= V[i]->getHash() << (i & 7); - return Result; -} - -unsigned ConstPoolStruct::hash(const StructType *Ty, - const vector &V) { - unsigned Result = (Ty->getUniqueID() << 5) ^ (Ty->getUniqueID() * 7); - for (unsigned i = 0; i < V.size(); ++i) - Result ^= V[i]->getHash() << (i & 7); - return Result; -} -#endif - -//===----------------------------------------------------------------------===// -// Factory Function Implementation - -template -struct ValueMap { - typedef pair ConstHashKey; - map Map; - - inline ConstPoolClass *get(const Type *Ty, ValType V) { - map::iterator I = - Map.find(ConstHashKey(Ty, V)); - return (I != Map.end()) ? I->second : 0; - } - - inline void add(const Type *Ty, ValType V, ConstPoolClass *CP) { - Map.insert(make_pair(ConstHashKey(Ty, V), CP)); - } -}; - -//---- ConstPoolUInt::get() and ConstPoolSInt::get() implementations... -// -static ValueMap IntConstants; - -ConstPoolSInt *ConstPoolSInt::get(const Type *Ty, int64_t V) { - ConstPoolSInt *Result = (ConstPoolSInt*)IntConstants.get(Ty, (uint64_t)V); - if (!Result) // If no preexisting value, create one now... - IntConstants.add(Ty, V, Result = new ConstPoolSInt(Ty, V)); - return Result; -} - -ConstPoolUInt *ConstPoolUInt::get(const Type *Ty, uint64_t V) { - ConstPoolUInt *Result = (ConstPoolUInt*)IntConstants.get(Ty, V); - if (!Result) // If no preexisting value, create one now... - IntConstants.add(Ty, V, Result = new ConstPoolUInt(Ty, V)); - return Result; -} - -ConstPoolInt *ConstPoolInt::get(const Type *Ty, unsigned char V) { - assert(V <= 127 && "Can only be used with very small positive constants!"); - if (Ty->isSigned()) return ConstPoolSInt::get(Ty, V); - return ConstPoolUInt::get(Ty, V); -} - -//---- ConstPoolFP::get() implementation... -// -static ValueMap FPConstants; - -ConstPoolFP *ConstPoolFP::get(const Type *Ty, double V) { - ConstPoolFP *Result = FPConstants.get(Ty, V); - if (!Result) // If no preexisting value, create one now... - FPConstants.add(Ty, V, Result = new ConstPoolFP(Ty, V)); - return Result; -} - -//---- ConstPoolArray::get() implementation... -// -static ValueMap, ConstPoolArray> ArrayConstants; - -ConstPoolArray *ConstPoolArray::get(const ArrayType *Ty, - const vector &V) { - ConstPoolArray *Result = ArrayConstants.get(Ty, V); - if (!Result) // If no preexisting value, create one now... - ArrayConstants.add(Ty, V, Result = new ConstPoolArray(Ty, V)); - return Result; -} - -//---- ConstPoolStruct::get() implementation... -// -static ValueMap, ConstPoolStruct> StructConstants; - -ConstPoolStruct *ConstPoolStruct::get(const StructType *Ty, - const vector &V) { - ConstPoolStruct *Result = StructConstants.get(Ty, V); - if (!Result) // If no preexisting value, create one now... - StructConstants.add(Ty, V, Result = new ConstPoolStruct(Ty, V)); - return Result; -} - - - - -//===----------------------------------------------------------------------===// -// Extra Method implementations - - - - - - -// 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& isValidConstant) -{ - int64_t intValue = 0; - isValidConstant = false; - - if (val->getValueType() == Value::ConstantVal) - { - switch(val->getType()->getPrimitiveID()) - { - case Type::BoolTyID: - intValue = ((ConstPoolBool*) val)->getValue()? 1 : 0; - isValidConstant = true; - break; - case Type::SByteTyID: - case Type::ShortTyID: - case Type::IntTyID: - case Type::LongTyID: - intValue = ((ConstPoolSInt*) val)->getValue(); - isValidConstant = true; - break; - default: - break; - } - } - - return intValue; -} - -uint64_t -GetUnsignedIntConstantValue(const Value* val, bool& isValidConstant) -{ - uint64_t intValue = 0; - isValidConstant = false; - - if (val->getValueType() == Value::ConstantVal) - { - switch(val->getType()->getPrimitiveID()) - { - case Type::BoolTyID: - intValue = ((ConstPoolBool*) val)->getValue()? 1 : 0; - isValidConstant = true; - break; - case Type::UByteTyID: - case Type::UShortTyID: - case Type::UIntTyID: - case Type::ULongTyID: - case Type::PointerTyID: - intValue = ((ConstPoolUInt*) val)->getValue(); - isValidConstant = true; - break; - default: - break; - } - } - - return intValue; -} - - -int64_t -GetConstantValueAsSignedInt(const Value* val, bool& isValidConstant) -{ - int64_t intValue = 0; - - if (val->getType()->isSigned()) - { - intValue = GetSignedIntConstantValue(val, isValidConstant); - } - else // non-numeric types will fall here - { - uint64_t uintValue = GetUnsignedIntConstantValue(val, isValidConstant); - if (isValidConstant && uintValue < INT64_MAX) // then safe to cast to signed - intValue = (int64_t) uintValue; - else - isValidConstant = false; - } - - return intValue; -}