RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2024-11-25 12:50:00 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

- Checkin of the alias analysis work:

Browse Source 
* 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
This commit is contained in:
Chris Lattner 2003-02-26 19:26:51 +00:00
parent 13b6f22f04
commit 14ac877e0a
1 changed files with 188 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

263
lib/Analysis/AliasAnalysis.cpp
View File

@ -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 @@ 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,
const Value *Ptr) {
CanModify CM(this, Ptr);
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;
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<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 @@ 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,
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 @@ 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));
// 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 @@ 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;
}