- Rename ConstantGenericIntegral -> ConstantIntegral

- Add new methods to ConstantIntegral: getMaxValue, getMinValue,
   getAllOnesValue


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@3299 91177308-0d34-0410-b5e6-96231b3b80d8

lib/VMCore/Constants.cpp

@@ -34,30 +34,6 @@ void Constant::setName(const std::string &Name, SymbolTable *ST) {
   if (Name.size()) ST->insert(Name, this);
 }
 
-// Static constructor to create a '0' constant of arbitrary type...
-Constant *Constant::getNullValue(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<PointerType>(Ty));
-  default:
-    return 0;
-  }
-}
-
 void Constant::destroyConstantImpl() {
   // When a Constant is destroyed, there may be lingering
   // references to the constant by other constants in the constant pool.  These
@@ -86,6 +62,108 @@ void Constant::destroyConstantImpl() {
   delete this;
 }
 
+// Static constructor to create a '0' constant of arbitrary type...
+Constant *Constant::getNullValue(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<PointerType>(Ty));
+  default:
+    return 0;
+  }
+}
+
+// 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);
+  }
+
+  case Type::UByteTyID:
+  case Type::UShortTyID:
+  case Type::UIntTyID:
+  case Type::ULongTyID:  return getAllOnesValue(Ty);
+
+  default:
+    assert(0 && "Non-integral type specified!");
+    return 0;
+  }
+}
+
+// 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:
+    assert(0 && "Non-integral type specified!");
+    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:
+    assert(0 && "Non-integral type specified!");
+    return 0;
+  }
+}
+
+
 //===----------------------------------------------------------------------===//
 //                            ConstantXXX Classes
 //===----------------------------------------------------------------------===//
@@ -93,12 +171,11 @@ void Constant::destroyConstantImpl() {
 //===----------------------------------------------------------------------===//
 //                             Normal Constructors
 
-ConstantBool::ConstantBool(bool V) : ConstantGenericIntegral(Type::BoolTy) {
+ConstantBool::ConstantBool(bool V) : ConstantIntegral(Type::BoolTy) {
   Val = V;
 }
 
-ConstantInt::ConstantInt(const Type *Ty, uint64_t V)
+ConstantInt::ConstantInt(const Type *Ty, uint64_t V) : ConstantIntegral(Ty) {
-  : ConstantGenericIntegral(Ty) {
   Val.Unsigned = V;
 }
 
@@ -164,7 +241,7 @@ ConstantExpr::ConstantExpr(Constant *C, const std::vector<Constant*> &IdxList,
 //===----------------------------------------------------------------------===//
 //                           classof implementations
 
-bool ConstantGenericIntegral::classof(const Constant *CPV) {
+bool ConstantIntegral::classof(const Constant *CPV) {
   return (CPV->getType()->isIntegral() || CPV->getType() == Type::BoolTy) &&
           !isa<ConstantExpr>(CPV);
 }