[llvm-commits] CVS: llvm/lib/Analysis/BasicAliasAnalysis.cpp

Chris Lattner sabre at nondot.org
Sat Feb 10 14:13:09 PST 2007



Changes in directory llvm/lib/Analysis:

BasicAliasAnalysis.cpp updated: 1.104 -> 1.105
---
Log message:

modify CheckGEPInstructions to take a pointer and size instead of a vector.


---
Diffs of the changes:  (+31 -23)

 BasicAliasAnalysis.cpp |   54 ++++++++++++++++++++++++++++---------------------
 1 files changed, 31 insertions(+), 23 deletions(-)


Index: llvm/lib/Analysis/BasicAliasAnalysis.cpp
diff -u llvm/lib/Analysis/BasicAliasAnalysis.cpp:1.104 llvm/lib/Analysis/BasicAliasAnalysis.cpp:1.105
--- llvm/lib/Analysis/BasicAliasAnalysis.cpp:1.104	Sat Feb 10 14:35:22 2007
+++ llvm/lib/Analysis/BasicAliasAnalysis.cpp	Sat Feb 10 16:12:53 2007
@@ -111,10 +111,10 @@
     // must-aliasing base pointers.  This checks to see if the index expressions
     // preclude the pointers from aliasing...
     AliasResult
-    CheckGEPInstructions(const Type* BasePtr1Ty, std::vector<Value*> &GEP1Ops,
-                         unsigned G1Size,
-                         const Type *BasePtr2Ty, std::vector<Value*> &GEP2Ops,
-                         unsigned G2Size);
+    CheckGEPInstructions(const Type* BasePtr1Ty,
+                         Value **GEP1Ops, unsigned NumGEP1Ops, unsigned G1Size,
+                         const Type *BasePtr2Ty,
+                         Value **GEP2Ops, unsigned NumGEP2Ops, unsigned G2Size);
   };
 
   // Register this pass...
@@ -377,8 +377,10 @@
       // do the comparison.
       if (BasePtr1 == BasePtr2) {
         AliasResult GAlias =
-          CheckGEPInstructions(BasePtr1->getType(), GEP1Ops, V1Size,
-                               BasePtr2->getType(), GEP2Ops, V2Size);
+          CheckGEPInstructions(BasePtr1->getType(),
+                               &GEP1Ops[0], GEP1Ops.size(), V1Size,
+                               BasePtr2->getType(),
+                               &GEP2Ops[0], GEP2Ops.size(), V2Size);
         if (GAlias != MayAlias)
           return GAlias;
       }
@@ -472,8 +474,8 @@
 /// pointers from aliasing...
 AliasAnalysis::AliasResult 
 BasicAliasAnalysis::CheckGEPInstructions(
-  const Type* BasePtr1Ty, std::vector<Value*> &GEP1Ops, unsigned G1S,
-  const Type *BasePtr2Ty, std::vector<Value*> &GEP2Ops, unsigned G2S) {
+  const Type* BasePtr1Ty, Value **GEP1Ops, unsigned NumGEP1Ops, unsigned G1S,
+  const Type *BasePtr2Ty, Value **GEP2Ops, unsigned NumGEP2Ops, unsigned G2S) {
   // We currently can't handle the case when the base pointers have different
   // primitive types.  Since this is uncommon anyway, we are happy being
   // extremely conservative.
@@ -484,7 +486,7 @@
 
   // Find the (possibly empty) initial sequence of equal values... which are not
   // necessarily constants.
-  unsigned NumGEP1Operands = GEP1Ops.size(), NumGEP2Operands = GEP2Ops.size();
+  unsigned NumGEP1Operands = NumGEP1Ops, NumGEP2Operands = NumGEP2Ops;
   unsigned MinOperands = std::min(NumGEP1Operands, NumGEP2Operands);
   unsigned MaxOperands = std::max(NumGEP1Operands, NumGEP2Operands);
   unsigned UnequalOper = 0;
@@ -508,7 +510,10 @@
   // getelementptrs, check to see if the tail of the leftover one is all zeros.
   // If so, return mustalias.
   if (UnequalOper == MinOperands) {
-    if (GEP1Ops.size() < GEP2Ops.size()) std::swap(GEP1Ops, GEP2Ops);
+    if (NumGEP1Ops < NumGEP2Ops) {
+      std::swap(GEP1Ops, GEP2Ops);
+      std::swap(NumGEP1Ops, NumGEP2Ops);
+    }
 
     bool AllAreZeros = true;
     for (unsigned i = UnequalOper; i != MaxOperands; ++i)
@@ -585,8 +590,10 @@
               Constant *Compare = ConstantExpr::getICmp(ICmpInst::ICMP_SGT, 
                                                         G1OC, G2OC);
               if (ConstantInt *CV = dyn_cast<ConstantInt>(Compare)) {
-                if (CV->getZExtValue())   // If they are comparable and G2 > G1
+                if (CV->getZExtValue()) {  // If they are comparable and G2 > G1
                   std::swap(GEP1Ops, GEP2Ops);  // Make GEP1 < GEP2
+                  std::swap(NumGEP1Ops, NumGEP2Ops);
+                }
                 break;
               }
             }
@@ -602,11 +609,13 @@
   // case, there may still be hope.  Check this now.
   if (FirstConstantOper == MinOperands) {
     // Make GEP1Ops be the longer one if there is a longer one.
-    if (GEP1Ops.size() < GEP2Ops.size())
+    if (NumGEP1Ops < NumGEP2Ops) {
       std::swap(GEP1Ops, GEP2Ops);
+      std::swap(NumGEP1Ops, NumGEP2Ops);
+    }
 
     // Is there anything to check?
-    if (GEP1Ops.size() > MinOperands) {
+    if (NumGEP1Ops > MinOperands) {
       for (unsigned i = FirstConstantOper; i != MaxOperands; ++i)
         if (isa<ConstantInt>(GEP1Ops[i]) && 
             !cast<Constant>(GEP1Ops[i])->isNullValue()) {
@@ -619,13 +628,12 @@
           // Okay, now get the offset.  This is the relative offset for the full
           // instruction.
           const TargetData &TD = getTargetData();
-          int64_t Offset1 = TD.getIndexedOffset(GEPPointerTy, &GEP1Ops[0],
-                                                GEP1Ops.size());
+          int64_t Offset1 = TD.getIndexedOffset(GEPPointerTy, GEP1Ops,
+                                                NumGEP1Ops);
 
-          // Now crop off any constants from the end...
-          GEP1Ops.resize(MinOperands);
-          int64_t Offset2 = TD.getIndexedOffset(GEPPointerTy, &GEP1Ops[0],
-                                                GEP1Ops.size());
+          // Now check without any constants at the end.
+          int64_t Offset2 = TD.getIndexedOffset(GEPPointerTy, GEP1Ops,
+                                                MinOperands);
 
           // If the tail provided a bit enough offset, return noalias!
           if ((uint64_t)(Offset2-Offset1) >= SizeMax)
@@ -665,8 +673,8 @@
 
   // Loop over the rest of the operands...
   for (unsigned i = FirstConstantOper+1; i != MaxOperands; ++i) {
-    const Value *Op1 = i < GEP1Ops.size() ? GEP1Ops[i] : 0;
-    const Value *Op2 = i < GEP2Ops.size() ? GEP2Ops[i] : 0;
+    const Value *Op1 = i < NumGEP1Ops ? GEP1Ops[i] : 0;
+    const Value *Op2 = i < NumGEP2Ops ? GEP2Ops[i] : 0;
     // If they are equal, use a zero index...
     if (Op1 == Op2 && BasePtr1Ty == BasePtr2Ty) {
       if (!isa<ConstantInt>(Op1))
@@ -736,9 +744,9 @@
 
   if (GEPPointerTy->getElementType()->isSized()) {
     int64_t Offset1 =
-      getTargetData().getIndexedOffset(GEPPointerTy,&GEP1Ops[0],GEP1Ops.size());
+      getTargetData().getIndexedOffset(GEPPointerTy, GEP1Ops, NumGEP1Ops);
     int64_t Offset2 = 
-      getTargetData().getIndexedOffset(GEPPointerTy,&GEP2Ops[0],GEP2Ops.size());
+      getTargetData().getIndexedOffset(GEPPointerTy, GEP2Ops, NumGEP2Ops);
     assert(Offset1<Offset2 && "There is at least one different constant here!");
 
     if ((uint64_t)(Offset2-Offset1) >= SizeMax) {






More information about the llvm-commits mailing list