Simplify ComputeMultiple so that it doesn't depend on TargetData.

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

diff --git a/include/llvm/Analysis/ValueTracking.h b/include/llvm/Analysis/ValueTracking.h
index a7a078fa3501ad5400ce7c3a0d5f5dd366973c1a..038d442cc6b976335d744ee32f9ab006e3ced726 100644 (file)
--- a/include/llvm/Analysis/ValueTracking.h
+++ b/include/llvm/Analysis/ValueTracking.h
@@ -68,8 +68,8 @@ namespace llvm {
   /// Multiple.  If unsuccessful, it returns false.  Also, if V can be
   /// simplified to an integer, then the simplified V is returned in Val.  Look
   /// through sext only if LookThroughSExt=true.
-  bool ComputeMultiple(Value *V, unsigned Base, Value *&Multiple, APInt &Val,
-                       bool LookThroughSExt = false, const TargetData *TD = 0,
+  bool ComputeMultiple(Value *V, unsigned Base, Value *&Multiple,
+                       bool LookThroughSExt = false,
                        unsigned Depth = 0);
 
   /// CannotBeNegativeZero - Return true if we can prove that the specified FP 

diff --git a/lib/Analysis/MemoryBuiltins.cpp b/lib/Analysis/MemoryBuiltins.cpp
index 9f036f4e2ae26b14215db752bcf93ff67219da75..b4486283feea1c35b6d88493c7e32f79afbe226a 100644 (file)
--- a/lib/Analysis/MemoryBuiltins.cpp
+++ b/lib/Analysis/MemoryBuiltins.cpp
@@ -105,9 +105,8 @@ static Value *computeArraySize(const CallInst *CI, const TargetData *TD,
   // return the multiple.  Otherwise, return NULL.
   Value *MallocArg = CI->getOperand(1);
   Value *Multiple = NULL;
-  APInt Val(TD->getTypeSizeInBits(MallocArg->getType()->getScalarType()), 0);
   if (ComputeMultiple(MallocArg, ElementSize, Multiple,
-                      Val, LookThroughSExt, TD))
+                      LookThroughSExt))
     return Multiple;
 
   return NULL;

diff --git a/lib/Analysis/ValueTracking.cpp b/lib/Analysis/ValueTracking.cpp
index 1db3f33885e667f515dc70380d424c109734d318..b0e6900b30d6b6c96fbd8e886a9a368bfd6b8278 100644 (file)
--- a/lib/Analysis/ValueTracking.cpp
+++ b/lib/Analysis/ValueTracking.cpp
@@ -791,24 +791,19 @@ unsigned llvm::ComputeNumSignBits(Value *V, const TargetData *TD,
 
 /// ComputeMultiple - This function computes the integer multiple of Base that
 /// equals V.  If successful, it returns true and returns the multiple in
-/// Multiple.  If unsuccessful, it returns false.  Also, if V can be
-/// simplified to an integer, then the simplified V is returned in Val. It looks
+/// Multiple.  If unsuccessful, it returns false. It looks
 /// through SExt instructions only if LookThroughSExt is true.
 bool llvm::ComputeMultiple(Value *V, unsigned Base, Value *&Multiple,
-                           APInt &Val, bool LookThroughSExt,
-                           const TargetData *TD, unsigned Depth) {
+                           bool LookThroughSExt, unsigned Depth) {
   const unsigned MaxDepth = 6;
 
-  assert(TD && V && "No Value?");
+  assert(V && "No Value?");
   assert(Depth <= MaxDepth && "Limit Search Depth");
   assert(V->getType()->isInteger() && "Not integer or pointer type!");
 
   const Type *T = V->getType();
-  unsigned TSize = TD->getTypeSizeInBits(T->getScalarType());
 
-  ConstantInt *CI = NULL;
-  if ((CI = dyn_cast<ConstantInt>(V)))
-    Val = CI->getValue();
+  ConstantInt *CI = dyn_cast<ConstantInt>(V);
 
   if (Base == 0)
     return false;
@@ -843,8 +838,8 @@ bool llvm::ComputeMultiple(Value *V, unsigned Base, Value *&Multiple,
     // otherwise fall through to ZExt
   }
   case Instruction::ZExt: {
-    return ComputeMultiple(I->getOperand(0), Base, Multiple, Val,
-                           LookThroughSExt, TD, Depth+1);
+    return ComputeMultiple(I->getOperand(0), Base, Multiple,
+                           LookThroughSExt, Depth+1);
   }
   case Instruction::Shl:
   case Instruction::Mul: {
@@ -863,17 +858,15 @@ bool llvm::ComputeMultiple(Value *V, unsigned Base, Value *&Multiple,
 
     Value *Mul0 = NULL;
     Value *Mul1 = NULL;
-    APInt Val0(TSize, 0), Val1(TSize, 0);
-    bool M0 = ComputeMultiple(Op0, Base, Mul0, Val0,
-                              LookThroughSExt, TD, Depth+1);
-    bool M1 = ComputeMultiple(Op1, Base, Mul1, Val1,
-                              LookThroughSExt, TD, Depth+1);
+    bool M0 = ComputeMultiple(Op0, Base, Mul0,
+                              LookThroughSExt, Depth+1);
+    bool M1 = ComputeMultiple(Op1, Base, Mul1,
+                              LookThroughSExt, Depth+1);
 
     if (M0) {
       if (isa<Constant>(Op1) && isa<Constant>(Mul0)) {
         // V == Base * (Mul0 * Op1), so return (Mul0 * Op1)
         Multiple = ConstantExpr::getMul(cast<Constant>(Mul0),
-                  Val1.getBoolValue() ? ConstantInt::get(V->getContext(), Val1):
                                         cast<Constant>(Op1));
         return true;
       }
@@ -890,7 +883,6 @@ bool llvm::ComputeMultiple(Value *V, unsigned Base, Value *&Multiple,
       if (isa<Constant>(Op0) && isa<Constant>(Mul1)) {
         // V == Base * (Mul1 * Op0), so return (Mul1 * Op0)
         Multiple = ConstantExpr::getMul(cast<Constant>(Mul1),
-                  Val0.getBoolValue() ? ConstantInt::get(V->getContext(), Val0):
                                         cast<Constant>(Op0));
         return true;
       }
@@ -902,11 +894,6 @@ bool llvm::ComputeMultiple(Value *V, unsigned Base, Value *&Multiple,
           return true;
         }
     }
-
-    if (Val0.getBoolValue() && Val1.getBoolValue())
-      // Op1*Op2 was simplified, try computing multiple again.
-      return ComputeMultiple(ConstantInt::get(V->getContext(), Val0 * Val1),
-                             Base, Multiple, Val, LookThroughSExt, TD, Depth+1);
   }
   }