From: Chris Lattner Date: Fri, 14 Dec 2001 16:42:30 +0000 (+0000) Subject: Rename ConstPoolVals.cpp to Constants.cpp X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=e917eaec6a473580033887d5745cc4e83240a36d;p=oota-llvm.git Rename ConstPoolVals.cpp to Constants.cpp git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@1471 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/lib/VMCore/ConstPoolVals.cpp b/lib/VMCore/ConstPoolVals.cpp deleted file mode 100644 index 257bd7622c9..00000000000 --- a/lib/VMCore/ConstPoolVals.cpp +++ /dev/null @@ -1,499 +0,0 @@ -//===-- ConstantVals.cpp - Implement Constant nodes --------------*- C++ -*--=// -// -// This file implements the Constant* classes... -// -//===----------------------------------------------------------------------===// - -#define __STDC_LIMIT_MACROS // Get defs for INT64_MAX and friends... -#include "llvm/ConstantVals.h" -#include "llvm/DerivedTypes.h" -#include "llvm/SymbolTable.h" -#include "llvm/GlobalValue.h" -#include "llvm/Module.h" -#include "llvm/Analysis/SlotCalculator.h" -#include "Support/StringExtras.h" -#include -#include - -ConstantBool *ConstantBool::True = new ConstantBool(true); -ConstantBool *ConstantBool::False = new ConstantBool(false); - - -//===----------------------------------------------------------------------===// -// Constant Class -//===----------------------------------------------------------------------===// - -// Specialize setName to take care of symbol table majik -void Constant::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... -Constant *Constant::getNullConstant(const Type *Ty) { - switch (Ty->getPrimitiveID()) { - case Type::BoolTyID: return ConstantBool::get(false); - case Type::SByteTyID: - case Type::ShortTyID: - case Type::IntTyID: - case Type::LongTyID: return ConstantSInt::get(Ty, 0); - - case Type::UByteTyID: - case Type::UShortTyID: - case Type::UIntTyID: - case Type::ULongTyID: return ConstantUInt::get(Ty, 0); - - case Type::FloatTyID: - case Type::DoubleTyID: return ConstantFP::get(Ty, 0); - - case Type::PointerTyID: - return ConstantPointerNull::get(cast(Ty)); - default: - return 0; - } -} - -#ifndef NDEBUG -#include "llvm/Assembly/Writer.h" -#endif - -void Constant::destroyConstantImpl() { - // When a Constant is destroyed, there may be lingering - // references to the constant by other constants in the constant pool. These - // constants are implicitly dependant on the module that is being deleted, - // but they don't know that. Because we only find out when the CPV is - // deleted, we must now notify all of our users (that should only be - // Constants) that they are, in fact, invalid now and should be deleted. - // - while (!use_empty()) { - Value *V = use_back(); -#ifndef NDEBUG // Only in -g mode... - if (!isa(V)) { - cerr << "While deleting: " << this << endl; - cerr << "Use still stuck around after Def is destroyed: " << V << endl; - } -#endif - assert(isa(V) && "References remain to ConstantPointerRef!"); - Constant *CPV = cast(V); - CPV->destroyConstant(); - - // The constant should remove itself from our use list... - assert((use_empty() || use_back() == V) && "Constant not removed!"); - } - - // Value has no outstanding references it is safe to delete it now... - delete this; -} - -//===----------------------------------------------------------------------===// -// ConstantXXX Classes -//===----------------------------------------------------------------------===// - -//===----------------------------------------------------------------------===// -// Normal Constructors - -ConstantBool::ConstantBool(bool V) : Constant(Type::BoolTy) { - Val = V; -} - -ConstantInt::ConstantInt(const Type *Ty, uint64_t V) : Constant(Ty) { - Val.Unsigned = V; -} - -ConstantSInt::ConstantSInt(const Type *Ty, int64_t V) : ConstantInt(Ty, V) { - assert(isValueValidForType(Ty, V) && "Value too large for type!"); -} - -ConstantUInt::ConstantUInt(const Type *Ty, uint64_t V) : ConstantInt(Ty, V) { - assert(isValueValidForType(Ty, V) && "Value too large for type!"); -} - -ConstantFP::ConstantFP(const Type *Ty, double V) : Constant(Ty) { - assert(isValueValidForType(Ty, V) && "Value too large for type!"); - Val = V; -} - -ConstantArray::ConstantArray(const ArrayType *T, - const vector &V) : Constant(T) { - for (unsigned i = 0; i < V.size(); i++) { - assert(V[i]->getType() == T->getElementType()); - Operands.push_back(Use(V[i], this)); - } -} - -ConstantStruct::ConstantStruct(const StructType *T, - const vector &V) : Constant(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)); - } -} - -ConstantPointerRef::ConstantPointerRef(GlobalValue *GV) - : ConstantPointer(GV->getType()) { - Operands.push_back(Use(GV, this)); -} - - - -//===----------------------------------------------------------------------===// -// getStrValue implementations - -string ConstantBool::getStrValue() const { - return Val ? "true" : "false"; -} - -string ConstantSInt::getStrValue() const { - return itostr(Val.Signed); -} - -string ConstantUInt::getStrValue() const { - return utostr(Val.Unsigned); -} - -string ConstantFP::getStrValue() const { - return ftostr(Val); -} - -string ConstantArray::getStrValue() const { - string Result; - - // As a special case, print the array as a string if it is an array of - // ubytes or an array of sbytes with positive values. - // - const Type *ETy = cast(getType())->getElementType(); - bool isString = (ETy == Type::SByteTy || ETy == Type::UByteTy); - - if (ETy == Type::SByteTy) { - for (unsigned i = 0; i < Operands.size(); ++i) - if (ETy == Type::SByteTy && - cast(Operands[i])->getValue() < 0) { - isString = false; - break; - } - } - - if (isString) { - Result = "c\""; - for (unsigned i = 0; i < Operands.size(); ++i) { - unsigned char C = (ETy == Type::SByteTy) ? - (unsigned char)cast(Operands[i])->getValue() : - (unsigned char)cast(Operands[i])->getValue(); - - if (isprint(C)) { - Result += C; - } else { - Result += '\\'; - Result += ( C/16 < 10) ? ( C/16 +'0') : ( C/16 -10+'A'); - Result += ((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A'); - } - } - Result += "\""; - - } else { - Result = "["; - if (Operands.size()) { - Result += " " + Operands[0]->getType()->getDescription() + - " " + cast(Operands[0])->getStrValue(); - for (unsigned i = 1; i < Operands.size(); i++) - Result += ", " + Operands[i]->getType()->getDescription() + - " " + cast(Operands[i])->getStrValue(); - } - Result += " ]"; - } - - return Result; -} - -string ConstantStruct::getStrValue() const { - string Result = "{"; - if (Operands.size()) { - Result += " " + Operands[0]->getType()->getDescription() + - " " + cast(Operands[0])->getStrValue(); - for (unsigned i = 1; i < Operands.size(); i++) - Result += ", " + Operands[i]->getType()->getDescription() + - " " + cast(Operands[i])->getStrValue(); - } - - return Result + " }"; -} - -string ConstantPointerNull::getStrValue() const { - return "null"; -} - -string ConstantPointerRef::getStrValue() const { - const GlobalValue *V = getValue(); - if (V->hasName()) return "%" + V->getName(); - - SlotCalculator *Table = new SlotCalculator(V->getParent(), true); - int Slot = Table->getValSlot(V); - delete Table; - - if (Slot >= 0) return string(" %") + itostr(Slot); - else return ""; -} - - -//===----------------------------------------------------------------------===// -// classof implementations - -bool ConstantInt::classof(const Constant *CPV) { - return CPV->getType()->isIntegral(); -} -bool ConstantSInt::classof(const Constant *CPV) { - return CPV->getType()->isSigned(); -} -bool ConstantUInt::classof(const Constant *CPV) { - return CPV->getType()->isUnsigned(); -} -bool ConstantFP::classof(const Constant *CPV) { - const Type *Ty = CPV->getType(); - return Ty == Type::FloatTy || Ty == Type::DoubleTy; -} -bool ConstantArray::classof(const Constant *CPV) { - return isa(CPV->getType()); -} -bool ConstantStruct::classof(const Constant *CPV) { - return isa(CPV->getType()); -} -bool ConstantPointer::classof(const Constant *CPV) { - return isa(CPV->getType()); -} - - -//===----------------------------------------------------------------------===// -// isValueValidForType implementations - -bool ConstantSInt::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 ConstantUInt::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 ConstantFP::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 ConstantSInt::hash(const Type *Ty, int64_t V) { - return unsigned(Ty->getPrimitiveID() ^ V); -} - -unsigned ConstantUInt::hash(const Type *Ty, uint64_t V) { - return unsigned(Ty->getPrimitiveID() ^ V); -} - -unsigned ConstantFP::hash(const Type *Ty, double V) { - return Ty->getPrimitiveID() ^ unsigned(V); -} - -unsigned ConstantArray::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 ConstantStruct::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 ConstantClass *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, ConstantClass *CP) { - Map.insert(make_pair(ConstHashKey(Ty, V), CP)); - } - - inline void remove(ConstantClass *CP) { - for (map::iterator I = Map.begin(), - E = Map.end(); I != E;++I) - if (I->second == CP) { - Map.erase(I); - return; - } - } -}; - -//---- ConstantUInt::get() and ConstantSInt::get() implementations... -// -static ValueMap IntConstants; - -ConstantSInt *ConstantSInt::get(const Type *Ty, int64_t V) { - ConstantSInt *Result = (ConstantSInt*)IntConstants.get(Ty, (uint64_t)V); - if (!Result) // If no preexisting value, create one now... - IntConstants.add(Ty, V, Result = new ConstantSInt(Ty, V)); - return Result; -} - -ConstantUInt *ConstantUInt::get(const Type *Ty, uint64_t V) { - ConstantUInt *Result = (ConstantUInt*)IntConstants.get(Ty, V); - if (!Result) // If no preexisting value, create one now... - IntConstants.add(Ty, V, Result = new ConstantUInt(Ty, V)); - return Result; -} - -ConstantInt *ConstantInt::get(const Type *Ty, unsigned char V) { - assert(V <= 127 && "Can only be used with very small positive constants!"); - if (Ty->isSigned()) return ConstantSInt::get(Ty, V); - return ConstantUInt::get(Ty, V); -} - -//---- ConstantFP::get() implementation... -// -static ValueMap FPConstants; - -ConstantFP *ConstantFP::get(const Type *Ty, double V) { - ConstantFP *Result = FPConstants.get(Ty, V); - if (!Result) // If no preexisting value, create one now... - FPConstants.add(Ty, V, Result = new ConstantFP(Ty, V)); - return Result; -} - -//---- ConstantArray::get() implementation... -// -static ValueMap, ConstantArray> ArrayConstants; - -ConstantArray *ConstantArray::get(const ArrayType *Ty, - const vector &V) { - ConstantArray *Result = ArrayConstants.get(Ty, V); - if (!Result) // If no preexisting value, create one now... - ArrayConstants.add(Ty, V, Result = new ConstantArray(Ty, V)); - return Result; -} - -// ConstantArray::get(const string&) - Return an array that is initialized to -// contain the specified string. A null terminator is added to the specified -// string so that it may be used in a natural way... -// -ConstantArray *ConstantArray::get(const string &Str) { - vector ElementVals; - - for (unsigned i = 0; i < Str.length(); ++i) - ElementVals.push_back(ConstantSInt::get(Type::SByteTy, Str[i])); - - // Add a null terminator to the string... - ElementVals.push_back(ConstantSInt::get(Type::SByteTy, 0)); - - ArrayType *ATy = ArrayType::get(Type::SByteTy, Str.length()+1); - return ConstantArray::get(ATy, ElementVals); -} - - -// destroyConstant - Remove the constant from the constant table... -// -void ConstantArray::destroyConstant() { - ArrayConstants.remove(this); - destroyConstantImpl(); -} - -//---- ConstantStruct::get() implementation... -// -static ValueMap, ConstantStruct> StructConstants; - -ConstantStruct *ConstantStruct::get(const StructType *Ty, - const vector &V) { - ConstantStruct *Result = StructConstants.get(Ty, V); - if (!Result) // If no preexisting value, create one now... - StructConstants.add(Ty, V, Result = new ConstantStruct(Ty, V)); - return Result; -} - -// destroyConstant - Remove the constant from the constant table... -// -void ConstantStruct::destroyConstant() { - StructConstants.remove(this); - destroyConstantImpl(); -} - -//---- ConstantPointerNull::get() implementation... -// -static ValueMap NullPtrConstants; - -ConstantPointerNull *ConstantPointerNull::get(const PointerType *Ty) { - ConstantPointerNull *Result = NullPtrConstants.get(Ty, 0); - if (!Result) // If no preexisting value, create one now... - NullPtrConstants.add(Ty, 0, Result = new ConstantPointerNull(Ty)); - return Result; -} - -//---- ConstantPointerRef::get() implementation... -// -ConstantPointerRef *ConstantPointerRef::get(GlobalValue *GV) { - assert(GV->getParent() && "Global Value must be attached to a module!"); - - // The Module handles the pointer reference sharing... - return GV->getParent()->getConstantPointerRef(GV); -} - - -void ConstantPointerRef::mutateReference(GlobalValue *NewGV) { - getValue()->getParent()->mutateConstantPointerRef(getValue(), NewGV); - Operands[0] = NewGV; -} diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp new file mode 100644 index 00000000000..257bd7622c9 --- /dev/null +++ b/lib/VMCore/Constants.cpp @@ -0,0 +1,499 @@ +//===-- ConstantVals.cpp - Implement Constant nodes --------------*- C++ -*--=// +// +// This file implements the Constant* classes... +// +//===----------------------------------------------------------------------===// + +#define __STDC_LIMIT_MACROS // Get defs for INT64_MAX and friends... +#include "llvm/ConstantVals.h" +#include "llvm/DerivedTypes.h" +#include "llvm/SymbolTable.h" +#include "llvm/GlobalValue.h" +#include "llvm/Module.h" +#include "llvm/Analysis/SlotCalculator.h" +#include "Support/StringExtras.h" +#include +#include + +ConstantBool *ConstantBool::True = new ConstantBool(true); +ConstantBool *ConstantBool::False = new ConstantBool(false); + + +//===----------------------------------------------------------------------===// +// Constant Class +//===----------------------------------------------------------------------===// + +// Specialize setName to take care of symbol table majik +void Constant::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... +Constant *Constant::getNullConstant(const Type *Ty) { + switch (Ty->getPrimitiveID()) { + case Type::BoolTyID: return ConstantBool::get(false); + case Type::SByteTyID: + case Type::ShortTyID: + case Type::IntTyID: + case Type::LongTyID: return ConstantSInt::get(Ty, 0); + + case Type::UByteTyID: + case Type::UShortTyID: + case Type::UIntTyID: + case Type::ULongTyID: return ConstantUInt::get(Ty, 0); + + case Type::FloatTyID: + case Type::DoubleTyID: return ConstantFP::get(Ty, 0); + + case Type::PointerTyID: + return ConstantPointerNull::get(cast(Ty)); + default: + return 0; + } +} + +#ifndef NDEBUG +#include "llvm/Assembly/Writer.h" +#endif + +void Constant::destroyConstantImpl() { + // When a Constant is destroyed, there may be lingering + // references to the constant by other constants in the constant pool. These + // constants are implicitly dependant on the module that is being deleted, + // but they don't know that. Because we only find out when the CPV is + // deleted, we must now notify all of our users (that should only be + // Constants) that they are, in fact, invalid now and should be deleted. + // + while (!use_empty()) { + Value *V = use_back(); +#ifndef NDEBUG // Only in -g mode... + if (!isa(V)) { + cerr << "While deleting: " << this << endl; + cerr << "Use still stuck around after Def is destroyed: " << V << endl; + } +#endif + assert(isa(V) && "References remain to ConstantPointerRef!"); + Constant *CPV = cast(V); + CPV->destroyConstant(); + + // The constant should remove itself from our use list... + assert((use_empty() || use_back() == V) && "Constant not removed!"); + } + + // Value has no outstanding references it is safe to delete it now... + delete this; +} + +//===----------------------------------------------------------------------===// +// ConstantXXX Classes +//===----------------------------------------------------------------------===// + +//===----------------------------------------------------------------------===// +// Normal Constructors + +ConstantBool::ConstantBool(bool V) : Constant(Type::BoolTy) { + Val = V; +} + +ConstantInt::ConstantInt(const Type *Ty, uint64_t V) : Constant(Ty) { + Val.Unsigned = V; +} + +ConstantSInt::ConstantSInt(const Type *Ty, int64_t V) : ConstantInt(Ty, V) { + assert(isValueValidForType(Ty, V) && "Value too large for type!"); +} + +ConstantUInt::ConstantUInt(const Type *Ty, uint64_t V) : ConstantInt(Ty, V) { + assert(isValueValidForType(Ty, V) && "Value too large for type!"); +} + +ConstantFP::ConstantFP(const Type *Ty, double V) : Constant(Ty) { + assert(isValueValidForType(Ty, V) && "Value too large for type!"); + Val = V; +} + +ConstantArray::ConstantArray(const ArrayType *T, + const vector &V) : Constant(T) { + for (unsigned i = 0; i < V.size(); i++) { + assert(V[i]->getType() == T->getElementType()); + Operands.push_back(Use(V[i], this)); + } +} + +ConstantStruct::ConstantStruct(const StructType *T, + const vector &V) : Constant(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)); + } +} + +ConstantPointerRef::ConstantPointerRef(GlobalValue *GV) + : ConstantPointer(GV->getType()) { + Operands.push_back(Use(GV, this)); +} + + + +//===----------------------------------------------------------------------===// +// getStrValue implementations + +string ConstantBool::getStrValue() const { + return Val ? "true" : "false"; +} + +string ConstantSInt::getStrValue() const { + return itostr(Val.Signed); +} + +string ConstantUInt::getStrValue() const { + return utostr(Val.Unsigned); +} + +string ConstantFP::getStrValue() const { + return ftostr(Val); +} + +string ConstantArray::getStrValue() const { + string Result; + + // As a special case, print the array as a string if it is an array of + // ubytes or an array of sbytes with positive values. + // + const Type *ETy = cast(getType())->getElementType(); + bool isString = (ETy == Type::SByteTy || ETy == Type::UByteTy); + + if (ETy == Type::SByteTy) { + for (unsigned i = 0; i < Operands.size(); ++i) + if (ETy == Type::SByteTy && + cast(Operands[i])->getValue() < 0) { + isString = false; + break; + } + } + + if (isString) { + Result = "c\""; + for (unsigned i = 0; i < Operands.size(); ++i) { + unsigned char C = (ETy == Type::SByteTy) ? + (unsigned char)cast(Operands[i])->getValue() : + (unsigned char)cast(Operands[i])->getValue(); + + if (isprint(C)) { + Result += C; + } else { + Result += '\\'; + Result += ( C/16 < 10) ? ( C/16 +'0') : ( C/16 -10+'A'); + Result += ((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A'); + } + } + Result += "\""; + + } else { + Result = "["; + if (Operands.size()) { + Result += " " + Operands[0]->getType()->getDescription() + + " " + cast(Operands[0])->getStrValue(); + for (unsigned i = 1; i < Operands.size(); i++) + Result += ", " + Operands[i]->getType()->getDescription() + + " " + cast(Operands[i])->getStrValue(); + } + Result += " ]"; + } + + return Result; +} + +string ConstantStruct::getStrValue() const { + string Result = "{"; + if (Operands.size()) { + Result += " " + Operands[0]->getType()->getDescription() + + " " + cast(Operands[0])->getStrValue(); + for (unsigned i = 1; i < Operands.size(); i++) + Result += ", " + Operands[i]->getType()->getDescription() + + " " + cast(Operands[i])->getStrValue(); + } + + return Result + " }"; +} + +string ConstantPointerNull::getStrValue() const { + return "null"; +} + +string ConstantPointerRef::getStrValue() const { + const GlobalValue *V = getValue(); + if (V->hasName()) return "%" + V->getName(); + + SlotCalculator *Table = new SlotCalculator(V->getParent(), true); + int Slot = Table->getValSlot(V); + delete Table; + + if (Slot >= 0) return string(" %") + itostr(Slot); + else return ""; +} + + +//===----------------------------------------------------------------------===// +// classof implementations + +bool ConstantInt::classof(const Constant *CPV) { + return CPV->getType()->isIntegral(); +} +bool ConstantSInt::classof(const Constant *CPV) { + return CPV->getType()->isSigned(); +} +bool ConstantUInt::classof(const Constant *CPV) { + return CPV->getType()->isUnsigned(); +} +bool ConstantFP::classof(const Constant *CPV) { + const Type *Ty = CPV->getType(); + return Ty == Type::FloatTy || Ty == Type::DoubleTy; +} +bool ConstantArray::classof(const Constant *CPV) { + return isa(CPV->getType()); +} +bool ConstantStruct::classof(const Constant *CPV) { + return isa(CPV->getType()); +} +bool ConstantPointer::classof(const Constant *CPV) { + return isa(CPV->getType()); +} + + +//===----------------------------------------------------------------------===// +// isValueValidForType implementations + +bool ConstantSInt::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 ConstantUInt::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 ConstantFP::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 ConstantSInt::hash(const Type *Ty, int64_t V) { + return unsigned(Ty->getPrimitiveID() ^ V); +} + +unsigned ConstantUInt::hash(const Type *Ty, uint64_t V) { + return unsigned(Ty->getPrimitiveID() ^ V); +} + +unsigned ConstantFP::hash(const Type *Ty, double V) { + return Ty->getPrimitiveID() ^ unsigned(V); +} + +unsigned ConstantArray::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 ConstantStruct::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 ConstantClass *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, ConstantClass *CP) { + Map.insert(make_pair(ConstHashKey(Ty, V), CP)); + } + + inline void remove(ConstantClass *CP) { + for (map::iterator I = Map.begin(), + E = Map.end(); I != E;++I) + if (I->second == CP) { + Map.erase(I); + return; + } + } +}; + +//---- ConstantUInt::get() and ConstantSInt::get() implementations... +// +static ValueMap IntConstants; + +ConstantSInt *ConstantSInt::get(const Type *Ty, int64_t V) { + ConstantSInt *Result = (ConstantSInt*)IntConstants.get(Ty, (uint64_t)V); + if (!Result) // If no preexisting value, create one now... + IntConstants.add(Ty, V, Result = new ConstantSInt(Ty, V)); + return Result; +} + +ConstantUInt *ConstantUInt::get(const Type *Ty, uint64_t V) { + ConstantUInt *Result = (ConstantUInt*)IntConstants.get(Ty, V); + if (!Result) // If no preexisting value, create one now... + IntConstants.add(Ty, V, Result = new ConstantUInt(Ty, V)); + return Result; +} + +ConstantInt *ConstantInt::get(const Type *Ty, unsigned char V) { + assert(V <= 127 && "Can only be used with very small positive constants!"); + if (Ty->isSigned()) return ConstantSInt::get(Ty, V); + return ConstantUInt::get(Ty, V); +} + +//---- ConstantFP::get() implementation... +// +static ValueMap FPConstants; + +ConstantFP *ConstantFP::get(const Type *Ty, double V) { + ConstantFP *Result = FPConstants.get(Ty, V); + if (!Result) // If no preexisting value, create one now... + FPConstants.add(Ty, V, Result = new ConstantFP(Ty, V)); + return Result; +} + +//---- ConstantArray::get() implementation... +// +static ValueMap, ConstantArray> ArrayConstants; + +ConstantArray *ConstantArray::get(const ArrayType *Ty, + const vector &V) { + ConstantArray *Result = ArrayConstants.get(Ty, V); + if (!Result) // If no preexisting value, create one now... + ArrayConstants.add(Ty, V, Result = new ConstantArray(Ty, V)); + return Result; +} + +// ConstantArray::get(const string&) - Return an array that is initialized to +// contain the specified string. A null terminator is added to the specified +// string so that it may be used in a natural way... +// +ConstantArray *ConstantArray::get(const string &Str) { + vector ElementVals; + + for (unsigned i = 0; i < Str.length(); ++i) + ElementVals.push_back(ConstantSInt::get(Type::SByteTy, Str[i])); + + // Add a null terminator to the string... + ElementVals.push_back(ConstantSInt::get(Type::SByteTy, 0)); + + ArrayType *ATy = ArrayType::get(Type::SByteTy, Str.length()+1); + return ConstantArray::get(ATy, ElementVals); +} + + +// destroyConstant - Remove the constant from the constant table... +// +void ConstantArray::destroyConstant() { + ArrayConstants.remove(this); + destroyConstantImpl(); +} + +//---- ConstantStruct::get() implementation... +// +static ValueMap, ConstantStruct> StructConstants; + +ConstantStruct *ConstantStruct::get(const StructType *Ty, + const vector &V) { + ConstantStruct *Result = StructConstants.get(Ty, V); + if (!Result) // If no preexisting value, create one now... + StructConstants.add(Ty, V, Result = new ConstantStruct(Ty, V)); + return Result; +} + +// destroyConstant - Remove the constant from the constant table... +// +void ConstantStruct::destroyConstant() { + StructConstants.remove(this); + destroyConstantImpl(); +} + +//---- ConstantPointerNull::get() implementation... +// +static ValueMap NullPtrConstants; + +ConstantPointerNull *ConstantPointerNull::get(const PointerType *Ty) { + ConstantPointerNull *Result = NullPtrConstants.get(Ty, 0); + if (!Result) // If no preexisting value, create one now... + NullPtrConstants.add(Ty, 0, Result = new ConstantPointerNull(Ty)); + return Result; +} + +//---- ConstantPointerRef::get() implementation... +// +ConstantPointerRef *ConstantPointerRef::get(GlobalValue *GV) { + assert(GV->getParent() && "Global Value must be attached to a module!"); + + // The Module handles the pointer reference sharing... + return GV->getParent()->getConstantPointerRef(GV); +} + + +void ConstantPointerRef::mutateReference(GlobalValue *NewGV) { + getValue()->getParent()->mutateConstantPointerRef(getValue(), NewGV); + Operands[0] = NewGV; +}