Update CMakeLists.txt

[oota-llvm.git] / lib / Analysis / ValueTracking.cpp

diff --git a/lib/Analysis/ValueTracking.cpp b/lib/Analysis/ValueTracking.cpp
index 8c6a7f582fb231a57938820084a05b32b150b133..c51a719313f2a12ae7d000faa27eb86342f10697 100644 (file)
--- a/lib/Analysis/ValueTracking.cpp
+++ b/lib/Analysis/ValueTracking.cpp
@@ -369,15 +369,13 @@ void llvm::ComputeMaskedBits(Value *V, const APInt &Mask,
         ComputeMaskedBits(I->getOperand(0), Mask2, KnownZero2, KnownOne2, TD, 
                           Depth+1);
 
-        // The sign of a remainder is equal to the sign of the first
-        // operand (zero being positive).
+        // If the sign bit of the first operand is zero, the sign bit of
+        // the result is zero. If the first operand has no one bits below
+        // the second operand's single 1 bit, its sign will be zero.
         if (KnownZero2[BitWidth-1] || ((KnownZero2 & LowBits) == LowBits))
           KnownZero2 |= ~LowBits;
-        else if (KnownOne2[BitWidth-1])
-          KnownOne2 |= ~LowBits;
 
         KnownZero |= KnownZero2 & Mask;
-        KnownOne |= KnownOne2 & Mask;
 
         assert((KnownZero & KnownOne) == 0&&"Bits known to be one AND zero?"); 
       }
@@ -511,12 +509,15 @@ void llvm::ComputeMaskedBits(Value *V, const APInt &Mask,
           ComputeMaskedBits(R, Mask2, KnownZero2, KnownOne2, TD, Depth+1);
           Mask2 = APInt::getLowBitsSet(BitWidth,
                                        KnownZero2.countTrailingOnes());
-          KnownOne2.clear();
-          KnownZero2.clear();
-          ComputeMaskedBits(L, Mask2, KnownZero2, KnownOne2, TD, Depth+1);
+
+          // We need to take the minimum number of known bits
+          APInt KnownZero3(KnownZero), KnownOne3(KnownOne);
+          ComputeMaskedBits(L, Mask2, KnownZero3, KnownOne3, TD, Depth+1);
+
           KnownZero = Mask &
                       APInt::getLowBitsSet(BitWidth,
-                                           KnownZero2.countTrailingOnes());
+                                           std::min(KnownZero2.countTrailingOnes(),
+                                                    KnownZero3.countTrailingOnes()));
           break;
         }
       }
@@ -864,7 +865,7 @@ Value *llvm::FindInsertedValue(Value *V, const unsigned *idx_begin,
   else if (Constant *C = dyn_cast<Constant>(V)) {
     if (isa<ConstantArray>(C) || isa<ConstantStruct>(C))
       // Recursively process this constant
-      return FindInsertedValue(C->getOperand(*idx_begin), ++idx_begin, idx_end,
+      return FindInsertedValue(C->getOperand(*idx_begin), idx_begin + 1, idx_end,
                                InsertBefore);
   } else if (InsertValueInst *I = dyn_cast<InsertValueInst>(V)) {
     // Loop the indices for the insertvalue instruction in parallel with the
@@ -935,13 +936,14 @@ Value *llvm::FindInsertedValue(Value *V, const unsigned *idx_begin,
 /// GetConstantStringInfo - This function computes the length of a
 /// null-terminated C string pointed to by V.  If successful, it returns true
 /// and returns the string in Str.  If unsuccessful, it returns false.
-bool llvm::GetConstantStringInfo(Value *V, std::string &Str, uint64_t Offset) {
+bool llvm::GetConstantStringInfo(Value *V, std::string &Str, uint64_t Offset,
+                                 bool StopAtNul) {
   // If V is NULL then return false;
   if (V == NULL) return false;
 
   // Look through bitcast instructions.
   if (BitCastInst *BCI = dyn_cast<BitCastInst>(V))
-    return GetConstantStringInfo(BCI->getOperand(0), Str, Offset);
+    return GetConstantStringInfo(BCI->getOperand(0), Str, Offset, StopAtNul);
   
   // If the value is not a GEP instruction nor a constant expression with a
   // GEP instruction, then return false because ConstantArray can't occur
@@ -950,6 +952,8 @@ bool llvm::GetConstantStringInfo(Value *V, std::string &Str, uint64_t Offset) {
   if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(V)) {
     GEP = GEPI;
   } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
+    if (CE->getOpcode() == Instruction::BitCast)
+      return GetConstantStringInfo(CE->getOperand(0), Str, Offset, StopAtNul);
     if (CE->getOpcode() != Instruction::GetElementPtr)
       return false;
     GEP = CE;
@@ -960,12 +964,16 @@ bool llvm::GetConstantStringInfo(Value *V, std::string &Str, uint64_t Offset) {
     if (GEP->getNumOperands() != 3)
       return false;
     
+    // Make sure the index-ee is a pointer to array of i8.
+    const PointerType *PT = cast<PointerType>(GEP->getOperand(0)->getType());
+    const ArrayType *AT = dyn_cast<ArrayType>(PT->getElementType());
+    if (AT == 0 || AT->getElementType() != Type::Int8Ty)
+      return false;
+    
     // Check to make sure that the first operand of the GEP is an integer and
     // has value 0 so that we are sure we're indexing into the initializer.
-    if (ConstantInt *Idx = dyn_cast<ConstantInt>(GEP->getOperand(1))) {
-      if (!Idx->isZero())
-        return false;
-    } else
+    ConstantInt *FirstIdx = dyn_cast<ConstantInt>(GEP->getOperand(1));
+    if (FirstIdx == 0 || !FirstIdx->isZero())
       return false;
     
     // If the second index isn't a ConstantInt, then this is a variable index
@@ -976,7 +984,8 @@ bool llvm::GetConstantStringInfo(Value *V, std::string &Str, uint64_t Offset) {
       StartIdx = CI->getZExtValue();
     else
       return false;
-    return GetConstantStringInfo(GEP->getOperand(0), Str, StartIdx+Offset);
+    return GetConstantStringInfo(GEP->getOperand(0), Str, StartIdx+Offset,
+                                 StopAtNul);
   }
   
   // The GEP instruction, constant or instruction, must reference a global
@@ -1014,7 +1023,7 @@ bool llvm::GetConstantStringInfo(Value *V, std::string &Str, uint64_t Offset) {
     ConstantInt *CI = dyn_cast<ConstantInt>(Elt);
     if (!CI) // This array isn't suitable, non-int initializer.
       return false;
-    if (CI->isZero())
+    if (StopAtNul && CI->isZero())
       return true; // we found end of string, success!
     Str += (char)CI->getZExtValue();
   }