Eliminate ConstantBool::True and ConstantBool::False. Instead, provide

ConstantBool::getTrue() and ConstantBool::getFalse().

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

diff --git a/include/llvm/Constants.h b/include/llvm/Constants.h
index 6354c1166d9564c389dd9e5701d8ef047f9627bf..6b8e91958b64242e50e968bec9f823fcb246b390 100644 (file)
--- a/include/llvm/Constants.h
+++ b/include/llvm/Constants.h
@@ -125,12 +125,14 @@ public:
 class ConstantBool : public ConstantIntegral {
   ConstantBool(bool V);
 public:
-  static ConstantBool *True, *False;  ///< The True & False values
+  /// getTrue/getFalse - Return the singleton true/false values.
+  static ConstantBool *getTrue();
+  static ConstantBool *getFalse();
 
   /// This method is provided mostly for compatibility with the other 
   /// ConstantIntegral subclasses.
   /// @brief Static factory method for getting a ConstantBool instance.
-  static ConstantBool *get(bool Value) { return Value ? True : False; }
+  static ConstantBool *get(bool Value) { return Value ? getTrue() : getFalse();}
 
   /// This method is provided mostly for compatibility with the other 
   /// ConstantIntegral subclasses.
@@ -139,7 +141,9 @@ public:
 
   /// Returns the opposite value of this ConstantBool value.
   /// @brief Get inverse value.
-  inline ConstantBool *inverted() const { return (this==True) ? False : True; }
+  inline ConstantBool *inverted() const {
+    return getValue() ? getFalse() : getTrue();
+  }
 
   /// @returns the value of this ConstantBool
   /// @brief return the boolean value of this constant.
@@ -147,10 +151,10 @@ public:
 
   /// @see ConstantIntegral for details
   /// @brief Implement overrides
-  virtual bool isNullValue() const { return this == False; }
-  virtual bool isMaxValue() const { return this == True; }
-  virtual bool isMinValue() const { return this == False; }
-  virtual bool isAllOnesValue() const { return this == True; }
+  virtual bool isNullValue() const { return getValue() == false; }
+  virtual bool isMaxValue() const { return getValue() == true; }
+  virtual bool isMinValue() const { return getValue() == false; }
+  virtual bool isAllOnesValue() const { return getValue() == true; }
 
   /// @brief Methods to support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const ConstantBool *) { return true; }

diff --git a/lib/Analysis/ScalarEvolution.cpp b/lib/Analysis/ScalarEvolution.cpp
index 289297cf3a9c3b34b7f70e9c6410e95df3791bb8..2f8edd9fe2ba84b2b96387693601284472d84ca4 100644 (file)
--- a/lib/Analysis/ScalarEvolution.cpp
+++ b/lib/Analysis/ScalarEvolution.cpp
@@ -1689,7 +1689,7 @@ ComputeLoadConstantCompareIterationCount(LoadInst *LI, Constant *RHS,
     // Evaluate the condition for this iteration.
     Result = ConstantExpr::get(SetCCOpcode, Result, RHS);
     if (!isa<ConstantBool>(Result)) break;  // Couldn't decide for sure
-    if (Result == ConstantBool::False) {
+    if (cast<ConstantBool>(Result)->getValue() == false) {
 #if 0
       std::cerr << "\n***\n*** Computed loop count " << *ItCst
                 << "\n*** From global " << *GV << "*** BB: " << *L->getHeader()
@@ -2168,7 +2168,7 @@ SCEVHandle ScalarEvolutionsImpl::HowFarToZero(SCEV *V, const Loop *L) {
       if (ConstantBool *CB =
           dyn_cast<ConstantBool>(ConstantExpr::getSetLT(R1->getValue(),
                                                         R2->getValue()))) {
-        if (CB != ConstantBool::True)
+        if (CB->getValue() == false)
           std::swap(R1, R2);   // R1 is the minimum root now.
 
         // We can only use this value if the chrec ends up with an exact zero
@@ -2198,7 +2198,7 @@ SCEVHandle ScalarEvolutionsImpl::HowFarToNonZero(SCEV *V, const Loop *L) {
   if (SCEVConstant *C = dyn_cast<SCEVConstant>(V)) {
     Constant *Zero = Constant::getNullValue(C->getValue()->getType());
     Constant *NonZero = ConstantExpr::getSetNE(C->getValue(), Zero);
-    if (NonZero == ConstantBool::True)
+    if (NonZero == ConstantBool::getTrue())
       return getSCEV(Zero);
     return UnknownValue;  // Otherwise it will loop infinitely.
   }
@@ -2386,7 +2386,7 @@ SCEVHandle SCEVAddRecExpr::getNumIterationsInRange(ConstantRange Range) const {
       if (ConstantBool *CB =
           dyn_cast<ConstantBool>(ConstantExpr::getSetLT(R1->getValue(),
                                                         R2->getValue()))) {
-        if (CB != ConstantBool::True)
+        if (CB->getValue() == false)
           std::swap(R1, R2);   // R1 is the minimum root now.
 
         // Make sure the root is not off by one.  The returned iteration should

diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp
index 3308b9a6d40e1c4aee8b4e2c8b6975dce621e3d1..d187125233c50843ada17db15bb64b54f2765b7d 100644 (file)
--- a/lib/VMCore/Constants.cpp
+++ b/lib/VMCore/Constants.cpp
@@ -26,10 +26,6 @@
 #include <iostream>
 using namespace llvm;
 
-ConstantBool *ConstantBool::True  = new ConstantBool(true);
-ConstantBool *ConstantBool::False = new ConstantBool(false);
-
-
 //===----------------------------------------------------------------------===//
 //                              Constant Class
 //===----------------------------------------------------------------------===//
@@ -128,7 +124,7 @@ Constant *Constant::getNullValue(const Type *Ty) {
 // Static constructor to create the maximum constant of an integral type...
 ConstantIntegral *ConstantIntegral::getMaxValue(const Type *Ty) {
   switch (Ty->getTypeID()) {
-  case Type::BoolTyID:   return ConstantBool::True;
+  case Type::BoolTyID:   return ConstantBool::getTrue();
   case Type::SByteTyID:
   case Type::ShortTyID:
   case Type::IntTyID:
@@ -152,7 +148,7 @@ ConstantIntegral *ConstantIntegral::getMaxValue(const Type *Ty) {
 // Static constructor to create the minimum constant for an integral type...
 ConstantIntegral *ConstantIntegral::getMinValue(const Type *Ty) {
   switch (Ty->getTypeID()) {
-  case Type::BoolTyID:   return ConstantBool::False;
+  case Type::BoolTyID:   return ConstantBool::getFalse();
   case Type::SByteTyID:
   case Type::ShortTyID:
   case Type::IntTyID:
@@ -176,7 +172,7 @@ ConstantIntegral *ConstantIntegral::getMinValue(const Type *Ty) {
 // Static constructor to create an integral constant with all bits set
 ConstantIntegral *ConstantIntegral::getAllOnesValue(const Type *Ty) {
   switch (Ty->getTypeID()) {
-  case Type::BoolTyID:   return ConstantBool::True;
+  case Type::BoolTyID:   return ConstantBool::getTrue();
   case Type::SByteTyID:
   case Type::ShortTyID:
   case Type::IntTyID:
@@ -877,6 +873,20 @@ public:
   };
 }
 
+
+//---- ConstantBool::get*() implementation.
+
+ConstantBool *ConstantBool::getTrue() {
+  static ConstantBool *T = 0;
+  if (T) return T;
+  return T = new ConstantBool(true);
+}
+ConstantBool *ConstantBool::getFalse() {
+  static ConstantBool *F = 0;
+  if (F) return F;
+  return F = new ConstantBool(false);
+}
+
 //---- ConstantUInt::get() and ConstantSInt::get() implementations...
 //
 static ManagedStatic<ValueMap< int64_t, Type, ConstantSInt> > SIntConstants;
@@ -1380,7 +1390,7 @@ Constant *ConstantExpr::getSignExtend(Constant *C, const Type *Ty) {
     C = ConstantExpr::getCast(C, C->getType()->getSignedVersion());
     return ConstantExpr::getCast(C, Ty);
   } else {
-    if (C == ConstantBool::True)
+    if (C == ConstantBool::getTrue())
       return ConstantIntegral::getAllOnesValue(Ty);
     else
       return ConstantIntegral::getNullValue(Ty);