[llvm-commits] CVS: llvm/lib/Analysis/AliasAnalysis.cpp
Chris Lattner
lattner at cs.uiuc.edu
Wed Feb 26 13:29:01 PST 2003
Changes in directory llvm/lib/Analysis:
AliasAnalysis.cpp updated: 1.10 -> 1.11
---
Log message:
- 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
---
Diffs of the changes:
Index: llvm/lib/Analysis/AliasAnalysis.cpp
diff -u llvm/lib/Analysis/AliasAnalysis.cpp:1.10 llvm/lib/Analysis/AliasAnalysis.cpp:1.11
--- llvm/lib/Analysis/AliasAnalysis.cpp:1.10 Sun Feb 9 13:38:11 2003
+++ llvm/lib/Analysis/AliasAnalysis.cpp Wed Feb 26 13:26:51 2003
@@ -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
-// arbitrary chunks of code can modify a specified pointer.
-//
-namespace {
- 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));
- }
+AliasAnalysis::ModRefResult
+AliasAnalysis::getModRefInfo(LoadInst *L, Value *P, unsigned Size) {
+ return alias(L->getOperand(0), TD->getTypeSize(L->getType()),
+ P, Size) ? Ref : NoModRef;
+}
- // 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 @@
//
AliasAnalysis::~AliasAnalysis() {}
-/// canBasicBlockModify - Return true if it is possible for execution of the
-/// specified basic block to modify the value pointed to by Ptr.
+/// setTargetData - Subclasses must call this method to initialize the
+/// AliasAnalysis interface before any other methods are called.
///
-bool AliasAnalysis::canBasicBlockModify(const BasicBlock &bb,
- const Value *Ptr) {
- CanModify CM(this, Ptr);
- BasicBlock &BB = const_cast<BasicBlock&>(bb);
+void AliasAnalysis::InitializeAliasAnalysis(Pass *P) {
+ TD = &P->getAnalysis<TargetData>();
+}
- 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;
+// 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.
+}
- return false;
+/// 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, 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::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)
- 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<Value*>(Ptr), Size) & Mod)
return true;
-
return false;
}
@@ -120,6 +113,10 @@
RegisterAnalysisGroup<AliasAnalysis, BasicAliasAnalysis, true> Y;
} // End of anonymous namespace
+void BasicAliasAnalysis::initializePass() {
+ InitializeAliasAnalysis(this);
+}
+
// hasUniqueAddress - Return true if the
@@ -146,8 +143,9 @@
// 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<ConstantPointerRef>(V1))
V1 = CPR->getValue();
@@ -163,43 +161,9 @@
// 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));
-
- // 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;
- }
+ 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 @@
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 @@
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;
+}
+
More information about the llvm-commits
mailing list