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<Constant>(V))
+ std::cerr << "While deleting: " << *this
+ << "\n\nUse still stuck around after Def is destroyed: "
+ << *V << "\n\n";
+#endif
+ assert(isa<Constant>(V) && "References remain to Constant being destroyed");
+ Constant *CPV = cast<Constant>(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()) {
}
}
-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<Constant>(V))
- std::cerr << "While deleting: " << *this
- << "\n\nUse still stuck around after Def is destroyed: "
- << *V << "\n\n";
-#endif
- assert(isa<Constant>(V) && "References remain to Constant being destroyed");
- Constant *CPV = cast<Constant>(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
//===----------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//
// 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;
}
//===----------------------------------------------------------------------===//
// classof implementations
+bool ConstantIntegral::classof(const Constant *CPV) {
+ return (CPV->getType()->isIntegral() || CPV->getType() == Type::BoolTy) &&
+ !isa<ConstantExpr>(CPV);
+}
+
bool ConstantInt::classof(const Constant *CPV) {
return CPV->getType()->isIntegral() && !isa<ConstantExpr>(CPV);
}
typedef pair<unsigned, vector<Constant*> > ExprMapKeyType;
static ValueMap<const ExprMapKeyType, ConstantExpr> 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<Constant*> 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;
}
projects / oota-llvm.git / blobdiff