[llvm-commits] [llvm] r89175 - in /llvm/trunk: include/llvm/Analysis/ValueTracking.h lib/Analysis/MemoryBuiltins.cpp lib/Analysis/ValueTracking.cpp

Dan Gohman gohman at apple.com
Tue Nov 17 16:58:27 PST 2009


Author: djg
Date: Tue Nov 17 18:58:27 2009
New Revision: 89175

URL: http://llvm.org/viewvc/llvm-project?rev=89175&view=rev
Log:
Simplify ComputeMultiple so that it doesn't depend on TargetData.

Modified:
    llvm/trunk/include/llvm/Analysis/ValueTracking.h
    llvm/trunk/lib/Analysis/MemoryBuiltins.cpp
    llvm/trunk/lib/Analysis/ValueTracking.cpp

Modified: llvm/trunk/include/llvm/Analysis/ValueTracking.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/ValueTracking.h?rev=89175&r1=89174&r2=89175&view=diff

==============================================================================
--- llvm/trunk/include/llvm/Analysis/ValueTracking.h (original)
+++ llvm/trunk/include/llvm/Analysis/ValueTracking.h Tue Nov 17 18:58:27 2009
@@ -68,8 +68,8 @@
   /// 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 

Modified: llvm/trunk/lib/Analysis/MemoryBuiltins.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/MemoryBuiltins.cpp?rev=89175&r1=89174&r2=89175&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/MemoryBuiltins.cpp (original)
+++ llvm/trunk/lib/Analysis/MemoryBuiltins.cpp Tue Nov 17 18:58:27 2009
@@ -105,9 +105,8 @@
   // 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;

Modified: llvm/trunk/lib/Analysis/ValueTracking.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/ValueTracking.cpp?rev=89175&r1=89174&r2=89175&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/ValueTracking.cpp (original)
+++ llvm/trunk/lib/Analysis/ValueTracking.cpp Tue Nov 17 18:58:27 2009
@@ -791,24 +791,19 @@
 
 /// 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 @@
     // 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 @@
 
     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 @@
       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 @@
           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);
   }
   }
 





More information about the llvm-commits mailing list