From 14ac877e0a898ab46eeba1b0b72b8e5a9918179f Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Wed, 26 Feb 2003 19:26:51 +0000 Subject: [PATCH] - 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 | 267 +++++++++++++++++++++++---------- 1 file changed, 188 insertions(+), 79 deletions(-) diff --git a/lib/Analysis/AliasAnalysis.cpp b/lib/Analysis/AliasAnalysis.cpp index 57867dd6eed..3562e33b250 100644 --- a/lib/Analysis/AliasAnalysis.cpp +++ b/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 Z("Alias Analysis"); } -// CanModify - Define a little visitor class that is used to check to see if -// arbitrary chunks of code can modify a specified pointer. -// -namespace { - struct CanModify : public InstVisitor { - 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(LoadInst *L, Value *P, unsigned Size) { + return alias(L->getOperand(0), TD->getTypeSize(L->getType()), + P, Size) ? Ref : NoModRef; } +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(); +} + +// 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(); // 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, - const Value *Ptr) { - CanModify CM(this, Ptr); - BasicBlock &BB = const_cast(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; +bool AliasAnalysis::canBasicBlockModify(const BasicBlock &BB, + const Value *Ptr, unsigned Size) { + return canInstructionRangeModify(BB.front(), BB.back(), Ptr, Size); } /// 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(&I1); BasicBlock::iterator E = const_cast(&I2); ++E; // Convert from inclusive to exclusive range. - for (; I != E; ++I) - if (CM.visit(I)) // Check every instruction in the basic block... + for (; I != E; ++I) // Check every instruction in range + if (getModRefInfo(I, const_cast(Ptr), Size) & Mod) return true; - return false; } @@ -120,6 +113,10 @@ namespace { RegisterAnalysisGroup 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, - const Value *V2) { +AliasAnalysis::AliasResult +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(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(V1)) - return alias(I->getOperand(0), V2); + return alias(I->getOperand(0), V1Size, V2, V2Size); if (const Instruction *I = dyn_cast(V2)) - return alias(V1, I->getOperand(0)); - - // 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(V1)) - if (const GetElementPtrInst *GEP2 = dyn_cast(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(GEP1->getOperand(i)) || - !isa(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; - } + return alias(V1, V1Size, I->getOperand(0), V2Size); // 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(V1)) + if (const GetElementPtrInst *GEP2 = dyn_cast(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(V2)) + if (isa(V2)) { std::swap(V1, V2); + std::swap(V1Size, V2Size); + } if (const GetElementPtrInst *GEP = dyn_cast(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(G1Oper) && isa(G2Oper)) { + // Make sure they are comparable... and make sure the GEP with + // the smaller leading constant is GEP1. + ConstantBool *Compare = + *cast(GEP1->getOperand(FirstConstantOper)) > + *cast(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 Indices1; + Indices1.reserve(NumGEPOperands-1); + for (unsigned i = 1; i != FirstConstantOper; ++i) + Indices1.push_back(Constant::getNullValue(GEP1->getOperand(i) + ->getType())); + std::vector 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(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(ElTy)) { + Indices1.push_back(ConstantUInt::get(Type::UByteTy, + STy->getNumContainedTypes())); + } else { + Indices1.push_back(ConstantSInt::get(Type::LongTy, + cast(ElTy)->getNumElements())); + } + } + + if (isa(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; +} +