X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FConstants.cpp;h=ff803dcf61ca9cac94dd87633d03787071693cd8;hb=95586b8c833aeca112907e69f545a6ea6e2103ff;hp=faef1473da087cfb8bf41ff62cf25d0e27adf291;hpb=c188eeb08c873da142a47398be6c405ce3f34f51;p=oota-llvm.git diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp index faef1473da0..ff803dcf61c 100644 --- a/lib/VMCore/Constants.cpp +++ b/lib/VMCore/Constants.cpp @@ -34,6 +34,34 @@ void Constant::setName(const std::string &Name, SymbolTable *ST) { if (Name.size()) ST->insert(Name, this); } +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)) + std::cerr << "While deleting: " << *this + << "\n\nUse still stuck around after Def is destroyed: " + << *V << "\n\n"; +#endif + assert(isa(V) && "References remain to Constant being destroyed"); + 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; +} + // Static constructor to create a '0' constant of arbitrary type... Constant *Constant::getNullValue(const Type *Ty) { switch (Ty->getPrimitiveID()) { @@ -58,34 +86,78 @@ Constant *Constant::getNullValue(const Type *Ty) { } } -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)) - std::cerr << "While deleting: " << *this - << "\n\nUse still stuck around after Def is destroyed: " - << *V << "\n\n"; -#endif - assert(isa(V) && "References remain to Constant being destroyed"); - Constant *CPV = cast(V); - CPV->destroyConstant(); +// Static constructor to create the maximum constant of an integral type... +ConstantIntegral *ConstantIntegral::getMaxValue(const Type *Ty) { + switch (Ty->getPrimitiveID()) { + case Type::BoolTyID: return ConstantBool::True; + case Type::SByteTyID: + case Type::ShortTyID: + case Type::IntTyID: + case Type::LongTyID: { + // Calculate 011111111111111... + unsigned TypeBits = Ty->getPrimitiveSize()*8; + int64_t Val = INT64_MAX; // All ones + Val >>= 64-TypeBits; // Shift out unwanted 1 bits... + return ConstantSInt::get(Ty, Val); + } - // The constant should remove itself from our use list... - assert((use_empty() || use_back() != V) && "Constant not removed!"); + case Type::UByteTyID: + case Type::UShortTyID: + case Type::UIntTyID: + case Type::ULongTyID: return getAllOnesValue(Ty); + + default: return 0; } +} - // Value has no outstanding references it is safe to delete it now... - delete this; +// Static constructor to create the minimum constant for an integral type... +ConstantIntegral *ConstantIntegral::getMinValue(const Type *Ty) { + switch (Ty->getPrimitiveID()) { + case Type::BoolTyID: return ConstantBool::False; + case Type::SByteTyID: + case Type::ShortTyID: + case Type::IntTyID: + case Type::LongTyID: { + // Calculate 1111111111000000000000 + unsigned TypeBits = Ty->getPrimitiveSize()*8; + int64_t Val = -1; // All ones + Val <<= TypeBits-1; // Shift over to the right spot + return ConstantSInt::get(Ty, Val); + } + + case Type::UByteTyID: + case Type::UShortTyID: + case Type::UIntTyID: + case Type::ULongTyID: return ConstantUInt::get(Ty, 0); + + default: return 0; + } +} + +// Static constructor to create an integral constant with all bits set +ConstantIntegral *ConstantIntegral::getAllOnesValue(const Type *Ty) { + switch (Ty->getPrimitiveID()) { + case Type::BoolTyID: return ConstantBool::True; + case Type::SByteTyID: + case Type::ShortTyID: + case Type::IntTyID: + case Type::LongTyID: return ConstantSInt::get(Ty, -1); + + case Type::UByteTyID: + case Type::UShortTyID: + case Type::UIntTyID: + case Type::ULongTyID: { + // Calculate ~0 of the right type... + unsigned TypeBits = Ty->getPrimitiveSize()*8; + uint64_t Val = ~0ULL; // All ones + Val >>= 64-TypeBits; // Shift out unwanted 1 bits... + return ConstantUInt::get(Ty, Val); + } + default: return 0; + } } + //===----------------------------------------------------------------------===// // ConstantXXX Classes //===----------------------------------------------------------------------===// @@ -93,11 +165,11 @@ void Constant::destroyConstantImpl() { //===----------------------------------------------------------------------===// // Normal Constructors -ConstantBool::ConstantBool(bool V) : Constant(Type::BoolTy) { +ConstantBool::ConstantBool(bool V) : ConstantIntegral(Type::BoolTy) { Val = V; } -ConstantInt::ConstantInt(const Type *Ty, uint64_t V) : Constant(Ty) { +ConstantInt::ConstantInt(const Type *Ty, uint64_t V) : ConstantIntegral(Ty) { Val.Unsigned = V; } @@ -163,6 +235,11 @@ ConstantExpr::ConstantExpr(Constant *C, const std::vector &IdxList, //===----------------------------------------------------------------------===// // classof implementations +bool ConstantIntegral::classof(const Constant *CPV) { + return (CPV->getType()->isIntegral() || CPV->getType() == Type::BoolTy) && + !isa(CPV); +} + bool ConstantInt::classof(const Constant *CPV) { return CPV->getType()->isIntegral() && !isa(CPV); } @@ -389,26 +466,16 @@ ConstantPointerRef *ConstantPointerRef::get(GlobalValue *GV) { typedef pair > ExprMapKeyType; static ValueMap ExprConstants; -ConstantExpr *ConstantExpr::get(unsigned Opcode, Constant *C, const Type *Ty) { +ConstantExpr *ConstantExpr::getCast(Constant *C, const Type *Ty) { // Look up the constant in the table first to ensure uniqueness vector argVec(1, C); - const ExprMapKeyType &Key = make_pair(Opcode, argVec); + const ExprMapKeyType &Key = make_pair(Instruction::Cast, argVec); ConstantExpr *Result = ExprConstants.get(Ty, Key); if (Result) return Result; // Its not in the table so create a new one and put it in the table. - // Check the operands for consistency first - assert(Opcode == Instruction::Cast || - (Opcode >= Instruction::FirstUnaryOp && - Opcode < Instruction::NumUnaryOps) && - "Invalid opcode in unary ConstantExpr!"); - - // type of operand will not match result for Cast operation - assert((Opcode == Instruction::Cast || Ty == C->getType()) && - "Type of operand in unary constant expression should match result"); - - Result = new ConstantExpr(Opcode, C, Ty); + Result = new ConstantExpr(Instruction::Cast, C, Ty); ExprConstants.add(Ty, Key, Result); return Result; }