Use -Wl,-x instead of -s: it is more portable, and in particular,

[oota-llvm.git] / lib / VMCore / ConstantRange.cpp

diff --git a/lib/VMCore/ConstantRange.cpp b/lib/VMCore/ConstantRange.cpp
index fe005efbad764b2aba5d28c007732f566cef610a..b7ef5e05110343674f9d3a8a73ee61a9af8000df 100644 (file)
--- a/lib/VMCore/ConstantRange.cpp
+++ b/lib/VMCore/ConstantRange.cpp
@@ -67,16 +67,16 @@ ConstantRange::ConstantRange(unsigned SetCCOpcode, ConstantIntegral *C) {
     Upper = C;
     return;
   case Instruction::SetGT:
-    Upper = ConstantIntegral::getMaxValue(C->getType());
     Lower = Next(C);
+    Upper = ConstantIntegral::getMinValue(C->getType());  // Min = Next(Max)
     return;
   case Instruction::SetLE:
     Lower = ConstantIntegral::getMinValue(C->getType());
     Upper = Next(C);
     return;
   case Instruction::SetGE:
-    Upper = ConstantIntegral::getMaxValue(C->getType());
     Lower = C;
+    Upper = ConstantIntegral::getMinValue(C->getType());  // Min = Next(Max)
     return;
   }
 }
@@ -142,10 +142,6 @@ static ConstantRange intersect1Wrapped(const ConstantRange &LHS,
                                        const ConstantRange &RHS) {
   assert(LHS.isWrappedSet() && !RHS.isWrappedSet());
 
-  // Handle common special cases
-  if (RHS.isEmptySet()) return RHS;
-  if (RHS.isFullSet()) return LHS;
-
   // Check to see if we overlap on the Left side of RHS...
   //
   if ((*(Constant*)RHS.getLower() < *(Constant*)LHS.getUpper())->getValue()) {
@@ -178,21 +174,34 @@ static ConstantRange intersect1Wrapped(const ConstantRange &LHS,
   }
 }
 
+static ConstantIntegral *Min(ConstantIntegral *A, ConstantIntegral *B) {
+  if ((*(Constant*)A < *(Constant*)B)->getValue())
+    return A;
+  return B;
+}
+static ConstantIntegral *Max(ConstantIntegral *A, ConstantIntegral *B) {
+  if ((*(Constant*)A > *(Constant*)B)->getValue())
+    return A;
+  return B;
+}
+
   
 /// intersect - Return the range that results from the intersection of this
 /// range with another range.
 ///
 ConstantRange ConstantRange::intersectWith(const ConstantRange &CR) const {
   assert(getType() == CR.getType() && "ConstantRange types don't agree!");
+  // Handle common special cases
+  if (isEmptySet() || CR.isFullSet())  return *this;
+  if (isFullSet()  || CR.isEmptySet()) return CR;
 
   if (!isWrappedSet()) {
     if (!CR.isWrappedSet()) {
-      const Constant &L = std::max(*(Constant*)Lower, *(Constant*)CR.Lower);
-      const Constant &U = std::min(*(Constant*)Upper, *(Constant*)CR.Upper);
+      ConstantIntegral *L = Max(Lower, CR.Lower);
+      ConstantIntegral *U = Min(Upper, CR.Upper);
 
-      if ((L < U)->getValue())  // If range isn't empty...
-        return ConstantRange(cast<ConstantIntegral>((Constant*)&L),
-                             cast<ConstantIntegral>((Constant*)&U));
+      if ((*L < *U)->getValue())  // If range isn't empty...
+        return ConstantRange(L, U);
       else
         return ConstantRange(getType(), false);  // Otherwise, return empty set
     } else
@@ -202,11 +211,9 @@ ConstantRange ConstantRange::intersectWith(const ConstantRange &CR) const {
       return intersect1Wrapped(*this, CR);
     else {
       // Both ranges are wrapped...
-      const Constant &L = std::max(*(Constant*)Lower, *(Constant*)CR.Lower);
-      const Constant &U = std::min(*(Constant*)Upper, *(Constant*)CR.Upper);
-
-      return ConstantRange(cast<ConstantIntegral>((Constant*)&L),
-                           cast<ConstantIntegral>((Constant*)&U));      
+      ConstantIntegral *L = Max(Lower, CR.Lower);
+      ConstantIntegral *U = Min(Upper, CR.Upper);
+      return ConstantRange(L, U);
     }
   }
   return *this;
@@ -225,3 +232,15 @@ ConstantRange ConstantRange::unionWith(const ConstantRange &CR) const {
 
   return *this;
 }
+
+/// print - Print out the bounds to a stream...
+///
+void ConstantRange::print(std::ostream &OS) const {
+  OS << "[" << Lower << "," << Upper << " )";
+}
+
+/// dump - Allow printing from a debugger easily...
+///
+void ConstantRange::dump() const {
+  print(std::cerr);
+}