- 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

diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp
index 856cd1ab16ebfa3adbcde028a0a9461263af0679..eb68ef68095b65fd5faa7b16c370b012f9c0a557 100644 (file)
--- 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<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()) {
@@ -58,34 +86,84 @@ 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<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:
+    assert(0 && "Non-integral type specified!");
+    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:
+    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)
-  : ConstantGenericIntegral(Ty) {
+ConstantInt::ConstantInt(const Type *Ty, uint64_t V) : ConstantIntegral(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);
 }