- Checkin of the alias analysis work:

* Takes into account the size of the memory reference to determine aliasing.
    * Expose mod/ref information in a more consistent way
    * BasicAA can now disambiguate A[i][1] and A[j][2] for conservative request
      sizes


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

lib/Analysis/AliasAnalysis.cpp

@@ -19,44 +19,32 @@
 
 #include "llvm/Analysis/BasicAliasAnalysis.h"
 #include "llvm/BasicBlock.h"
-#include "llvm/Support/InstVisitor.h"
 #include "llvm/iMemory.h"
 #include "llvm/iOther.h"
 #include "llvm/Constants.h"
+#include "llvm/ConstantHandling.h"
 #include "llvm/GlobalValue.h"
 #include "llvm/DerivedTypes.h"
+#include "llvm/Target/TargetData.h"
 
 // Register the AliasAnalysis interface, providing a nice name to refer to.
 namespace {
   RegisterAnalysisGroup<AliasAnalysis> Z("Alias Analysis");
 }
 
-// CanModify - Define a little visitor class that is used to check to see if
+AliasAnalysis::ModRefResult
-// arbitrary chunks of code can modify a specified pointer.
+AliasAnalysis::getModRefInfo(LoadInst *L, Value *P, unsigned Size) {
-//
+  return alias(L->getOperand(0), TD->getTypeSize(L->getType()),
-namespace {
+               P, Size) ? Ref : NoModRef;
-  struct CanModify : public InstVisitor<CanModify, bool> {
-    AliasAnalysis &AA;
-    const Value *Ptr;
-
-    CanModify(AliasAnalysis *aa, const Value *ptr)
-      : AA(*aa), Ptr(ptr) {}
-
-    bool visitInvokeInst(InvokeInst &II) {
-      return AA.canInvokeModify(II, Ptr);
-    }
-    bool visitCallInst(CallInst &CI) {
-      return AA.canCallModify(CI, Ptr);
-    }
-    bool visitStoreInst(StoreInst &SI) {
-      return AA.alias(Ptr, SI.getOperand(1));
-    }
-
-    // Other instructions do not alias anything.
-    bool visitInstruction(Instruction &I) { return false; }
-  };
 }
 
+AliasAnalysis::ModRefResult
+AliasAnalysis::getModRefInfo(StoreInst *S, Value *P, unsigned Size) {
+  return alias(S->getOperand(1), TD->getTypeSize(S->getOperand(0)->getType()),
+               P, Size) ? Mod : NoModRef;
+}
+
+
 // AliasAnalysis destructor: DO NOT move this to the header file for
 // AliasAnalysis or else clients of the AliasAnalysis class may not depend on
 // the AliasAnalysis.o file in the current .a file, causing alias analysis
@@ -64,19 +52,26 @@ namespace {
 //
 AliasAnalysis::~AliasAnalysis() {}
 
+/// setTargetData - Subclasses must call this method to initialize the
+/// AliasAnalysis interface before any other methods are called.
+///
+void AliasAnalysis::InitializeAliasAnalysis(Pass *P) {
+  TD = &P->getAnalysis<TargetData>();
+}
+
+// getAnalysisUsage - All alias analysis implementations should invoke this
+// directly (using AliasAnalysis::getAnalysisUsage(AU)) to make sure that
+// TargetData is required by the pass.
+void AliasAnalysis::getAnalysisUsage(AnalysisUsage &AU) const {
+  AU.addRequired<TargetData>();            // All AA's need TargetData.
+}
+
 /// canBasicBlockModify - Return true if it is possible for execution of the
 /// specified basic block to modify the value pointed to by Ptr.
 ///
-bool AliasAnalysis::canBasicBlockModify(const BasicBlock &bb,
+bool AliasAnalysis::canBasicBlockModify(const BasicBlock &BB,
-                                        const Value *Ptr) {
+                                        const Value *Ptr, unsigned Size) {
-  CanModify CM(this, Ptr);
+  return canInstructionRangeModify(BB.front(), BB.back(), Ptr, Size);
-  BasicBlock &BB = const_cast<BasicBlock&>(bb);
-
-  for (BasicBlock::iterator I = BB.begin(), E = BB.end(); I != E; ++I)
-    if (CM.visit(I))        // Check every instruction in the basic block...
-      return true;
-
-  return false;
 }
 
 /// canInstructionRangeModify - Return true if it is possible for the execution
@@ -86,18 +81,16 @@ bool AliasAnalysis::canBasicBlockModify(const BasicBlock &bb,
 ///
 bool AliasAnalysis::canInstructionRangeModify(const Instruction &I1,
                                               const Instruction &I2,
-                                              const Value *Ptr) {
+                                              const Value *Ptr, unsigned Size) {
   assert(I1.getParent() == I2.getParent() &&
          "Instructions not in same basic block!");
-  CanModify CM(this, Ptr);
   BasicBlock::iterator I = const_cast<Instruction*>(&I1);
   BasicBlock::iterator E = const_cast<Instruction*>(&I2);
   ++E;  // Convert from inclusive to exclusive range.
 
-  for (; I != E; ++I)
+  for (; I != E; ++I) // Check every instruction in range
-    if (CM.visit(I))        // Check every instruction in the basic block...
+    if (getModRefInfo(I, const_cast<Value*>(Ptr), Size) & Mod)
       return true;
-
   return false;
 }
 
@@ -120,6 +113,10 @@ namespace {
   RegisterAnalysisGroup<AliasAnalysis, BasicAliasAnalysis, true> Y;
 }  // End of anonymous namespace
 
+void BasicAliasAnalysis::initializePass() {
+  InitializeAliasAnalysis(this);
+}
+
 
 
 // hasUniqueAddress - Return true if the 
@@ -146,8 +143,9 @@ static const Value *getUnderlyingObject(const Value *V) {
 // as array references.  Note that this function is heavily tail recursive.
 // Hopefully we have a smart C++ compiler.  :)
 //
-AliasAnalysis::Result BasicAliasAnalysis::alias(const Value *V1,
+AliasAnalysis::AliasResult
-                                                const Value *V2) {
+BasicAliasAnalysis::alias(const Value *V1, unsigned V1Size,
+                          const Value *V2, unsigned V2Size) {
   // Strip off constant pointer refs if they exist
   if (const ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(V1))
     V1 = CPR->getValue();
@@ -163,43 +161,9 @@ AliasAnalysis::Result BasicAliasAnalysis::alias(const Value *V1,
 
   // Strip off cast instructions...
   if (const Instruction *I = dyn_cast<CastInst>(V1))
-    return alias(I->getOperand(0), V2);
+    return alias(I->getOperand(0), V1Size, V2, V2Size);
   if (const Instruction *I = dyn_cast<CastInst>(V2))
-    return alias(V1, I->getOperand(0));
+    return alias(V1, V1Size, I->getOperand(0), V2Size);
-
-  // If we have two gep instructions with identical indices, return an alias
-  // result equal to the alias result of the original pointer...
-  //
-  if (const GetElementPtrInst *GEP1 = dyn_cast<GetElementPtrInst>(V1))
-    if (const GetElementPtrInst *GEP2 = dyn_cast<GetElementPtrInst>(V2))
-      if (GEP1->getNumOperands() == GEP2->getNumOperands() &&
-          GEP1->getOperand(0)->getType() == GEP2->getOperand(0)->getType()) {
-        if (std::equal(GEP1->op_begin()+1, GEP1->op_end(), GEP2->op_begin()+1))
-          return alias(GEP1->getOperand(0), GEP2->getOperand(0));
-
-        // If all of the indexes to the getelementptr are constant, but
-        // different (well we already know they are different), then we know
-        // that there cannot be an alias here if the two base pointers DO alias.
-        //
-        bool AllConstant = true;
-        for (unsigned i = 1, e = GEP1->getNumOperands(); i != e; ++i)
-          if (!isa<Constant>(GEP1->getOperand(i)) ||
-              !isa<Constant>(GEP2->getOperand(i))) {
-            AllConstant = false;
-            break;
-          }
-
-        // If we are all constant, then look at where the the base pointers
-        // alias.  If they are known not to alias, then we are dealing with two
-        // different arrays or something, so no alias is possible.  If they are
-        // known to be the same object, then we cannot alias because we are
-        // indexing into a different part of the object.  As usual, MayAlias
-        // doesn't tell us anything.
-        //
-        if (AllConstant &&
-            alias(GEP1->getOperand(0), GEP2->getOperand(0)) != MayAlias)
-            return NoAlias;
-      }
 
   // Figure out what objects these things are pointing to if we can...
   const Value *O1 = getUnderlyingObject(V1);
@@ -220,12 +184,28 @@ AliasAnalysis::Result BasicAliasAnalysis::alias(const Value *V1,
     return NoAlias;                    // Unique values don't alias null
   }
 
+  // If we have two gep instructions with identical indices, return an alias
+  // result equal to the alias result of the original pointer...
+  //
+  if (const GetElementPtrInst *GEP1 = dyn_cast<GetElementPtrInst>(V1))
+    if (const GetElementPtrInst *GEP2 = dyn_cast<GetElementPtrInst>(V2))
+      if (GEP1->getNumOperands() == GEP2->getNumOperands() &&
+          GEP1->getOperand(0)->getType() == GEP2->getOperand(0)->getType()) {
+        AliasResult GAlias =
+          CheckGEPInstructions((GetElementPtrInst*)GEP1, V1Size,
+                               (GetElementPtrInst*)GEP2, V2Size);
+        if (GAlias != MayAlias)
+          return GAlias;
+      }
+
   // Check to see if these two pointers are related by a getelementptr
   // instruction.  If one pointer is a GEP with a non-zero index of the other
   // pointer, we know they cannot alias.
   //
-  if (isa<GetElementPtrInst>(V2))
+  if (isa<GetElementPtrInst>(V2)) {
     std::swap(V1, V2);
+    std::swap(V1Size, V2Size);
+  }
 
   if (const GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(V1))
     if (GEP->getOperand(0) == V2) {
@@ -239,3 +219,132 @@ AliasAnalysis::Result BasicAliasAnalysis::alias(const Value *V1,
 
   return MayAlias;
 }
+
+// CheckGEPInstructions - Check two GEP instructions of compatible types and
+// equal number of arguments.  This checks to see if the index expressions
+// preclude the pointers from aliasing...
+//
+AliasAnalysis::AliasResult
+BasicAliasAnalysis::CheckGEPInstructions(GetElementPtrInst *GEP1, unsigned G1S, 
+                                         GetElementPtrInst *GEP2, unsigned G2S){
+  // Do the base pointers alias?
+  AliasResult BaseAlias = alias(GEP1->getOperand(0), G1S,
+                                GEP2->getOperand(0), G2S);
+  if (BaseAlias != MustAlias)   // No or May alias: We cannot add anything...
+    return BaseAlias;
+  
+  // Find the (possibly empty) initial sequence of equal values...
+  unsigned NumGEPOperands = GEP1->getNumOperands();
+  unsigned UnequalOper = 1;
+  while (UnequalOper != NumGEPOperands &&
+         GEP1->getOperand(UnequalOper) == GEP2->getOperand(UnequalOper))
+    ++UnequalOper;
+    
+  // If all operands equal each other, then the derived pointers must
+  // alias each other...
+  if (UnequalOper == NumGEPOperands) return MustAlias;
+    
+  // So now we know that the indexes derived from the base pointers,
+  // which are known to alias, are different.  We can still determine a
+  // no-alias result if there are differing constant pairs in the index
+  // chain.  For example:
+  //        A[i][0] != A[j][1] iff (&A[0][1]-&A[0][0] >= std::max(G1S, G2S))
+  //
+  unsigned SizeMax = std::max(G1S, G2S);
+  if (SizeMax == ~0U) return MayAlias; // Avoid frivolous work...
+      
+  // Scan for the first operand that is constant and unequal in the
+  // two getelemenptrs...
+  unsigned FirstConstantOper = UnequalOper;
+  for (; FirstConstantOper != NumGEPOperands; ++FirstConstantOper) {
+    const Value *G1Oper = GEP1->getOperand(FirstConstantOper);
+    const Value *G2Oper = GEP2->getOperand(FirstConstantOper);
+    if (G1Oper != G2Oper &&   // Found non-equal constant indexes...
+        isa<Constant>(G1Oper) && isa<Constant>(G2Oper)) {
+      // Make sure they are comparable...  and make sure the GEP with
+      // the smaller leading constant is GEP1.
+      ConstantBool *Compare =
+        *cast<Constant>(GEP1->getOperand(FirstConstantOper)) >
+        *cast<Constant>(GEP2->getOperand(FirstConstantOper));
+      if (Compare) {  // If they are comparable...
+        if (Compare->getValue())
+          std::swap(GEP1, GEP2);  // Make GEP1 < GEP2
+        break;
+      }
+    }
+  }
+  
+  // No constant operands, we cannot tell anything...
+  if (FirstConstantOper == NumGEPOperands) return MayAlias;
+
+  // If there are non-equal constants arguments, then we can figure
+  // out a minimum known delta between the two index expressions... at
+  // this point we know that the first constant index of GEP1 is less
+  // than the first constant index of GEP2.
+  //
+  std::vector<Value*> Indices1;
+  Indices1.reserve(NumGEPOperands-1);
+  for (unsigned i = 1; i != FirstConstantOper; ++i)
+    Indices1.push_back(Constant::getNullValue(GEP1->getOperand(i)
+                                              ->getType()));
+  std::vector<Value*> Indices2;
+  Indices2.reserve(NumGEPOperands-1);
+  Indices2 = Indices1;           // Copy the zeros prefix...
+  
+  // Add the two known constant operands...
+  Indices1.push_back((Value*)GEP1->getOperand(FirstConstantOper));
+  Indices2.push_back((Value*)GEP2->getOperand(FirstConstantOper));
+  
+  const Type *GEPPointerTy = GEP1->getOperand(0)->getType();
+  
+  // Loop over the rest of the operands...
+  for (unsigned i = FirstConstantOper+1; i!=NumGEPOperands; ++i){
+    const Value *Op1 = GEP1->getOperand(i);
+    const Value *Op2 = GEP1->getOperand(i);
+    if (Op1 == Op2) {   // If they are equal, use a zero index...
+      Indices1.push_back(Constant::getNullValue(Op1->getType()));
+      Indices2.push_back(Indices1.back());
+    } else {
+      if (isa<Constant>(Op1))
+        Indices1.push_back((Value*)Op1);
+      else {
+        // GEP1 is known to produce a value less than GEP2.  To be
+        // conservatively correct, we must assume the largest
+        // possible constant is used in this position.  This cannot
+        // be the initial index to the GEP instructions (because we
+        // know we have at least one element before this one with
+        // the different constant arguments), so we know that the
+        // current index must be into either a struct or array.
+        // Because of this, we can calculate the maximum value
+        // possible.
+        //
+        const Type *ElTy = GEP1->getIndexedType(GEPPointerTy,
+                                                Indices1, true);
+        if (const StructType *STy = dyn_cast<StructType>(ElTy)) {
+          Indices1.push_back(ConstantUInt::get(Type::UByteTy,
+                                               STy->getNumContainedTypes()));
+        } else {
+          Indices1.push_back(ConstantSInt::get(Type::LongTy,
+                                               cast<ArrayType>(ElTy)->getNumElements()));
+        }
+      }
+      
+      if (isa<Constant>(Op2))
+        Indices2.push_back((Value*)Op2);
+      else // Conservatively assume the minimum value for this index
+        Indices2.push_back(Constant::getNullValue(Op1->getType()));
+    }
+  }
+  
+  unsigned Offset1 = getTargetData().getIndexedOffset(GEPPointerTy, Indices1);
+  unsigned Offset2 = getTargetData().getIndexedOffset(GEPPointerTy, Indices2);
+  assert(Offset1 < Offset2 &&"There is at least one different constant here!");
+
+  if (Offset2-Offset1 >= SizeMax) {
+    //std::cerr << "Determined that these two GEP's don't alias [" 
+    //          << SizeMax << " bytes]: \n" << *GEP1 << *GEP2;
+    return NoAlias;
+  }
+  return MayAlias;
+}
+