RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-23 19:23:23 +01:00
Code Issues Projects Releases Wiki Activity

refix PR1143 by making basicaa analyze zexts of indices aggresively,

Browse Source 
which I broke with a recent patch.

llvm-svn: 111452
This commit is contained in:
Chris Lattner 2010-08-18 23:09:49 +00:00
parent 4690ffd18a
commit 7663b66c31
2 changed files with 37 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
lib/Analysis/BasicAliasAnalysis.cpp
View File

@ -215,10 +215,14 @@ namespace {
/// GetLinearExpression - Analyze the specified value as a linear expression:
/// "A*V + B", where A and B are constant integers. Return the scale and offset
/// values as APInts and return V as a Value*. The incoming Value is known to
/// have IntegerType. Note that this looks through extends, so the high bits
/// may not be represented in the result.
/// values as APInts and return V as a Value*, and return whether we looked
/// through any sign or zero extends. The incoming Value is known to have
/// IntegerType and it may already be sign or zero extended.
///
/// Note that this looks through extends, so the high bits may not be
/// represented in the result.
static Value *GetLinearExpression(Value *V, APInt &Scale, APInt &Offset,
ExtensionKind &Extension,
const TargetData &TD, unsigned Depth) {
assert(V->getType()->isIntegerTy() && "Not an integer value");
@ -240,16 +244,19 @@ static Value *GetLinearExpression(Value *V, APInt &Scale, APInt &Offset,
break;
// FALL THROUGH.
case Instruction::Add:
V = GetLinearExpression(BOp->getOperand(0), Scale, Offset, TD, Depth+1);
V = GetLinearExpression(BOp->getOperand(0), Scale, Offset, Extension,
TD, Depth+1);
Offset += RHSC->getValue();
return V;
case Instruction::Mul:
V = GetLinearExpression(BOp->getOperand(0), Scale, Offset, TD, Depth+1);
V = GetLinearExpression(BOp->getOperand(0), Scale, Offset, Extension,
TD, Depth+1);
Offset *= RHSC->getValue();
Scale *= RHSC->getValue();
return V;
case Instruction::Shl:
V = GetLinearExpression(BOp->getOperand(0), Scale, Offset, TD, Depth+1);
V = GetLinearExpression(BOp->getOperand(0), Scale, Offset, Extension,
TD, Depth+1);
Offset <<= RHSC->getValue().getLimitedValue();
Scale <<= RHSC->getValue().getLimitedValue();
return V;
@ -258,16 +265,22 @@ static Value *GetLinearExpression(Value *V, APInt &Scale, APInt &Offset,
}
// Since GEP indices are sign extended anyway, we don't care about the high
// bits of a sign extended value - just scales and offsets.
if (isa<SExtInst>(V)) {
// bits of a sign or zero extended value - just scales and offsets. The
// extensions have to be consistent though.
if ((isa<SExtInst>(V) && Extension != EK_ZeroExt) ||
(isa<ZExtInst>(V) && Extension != EK_SignExt)) {
Value *CastOp = cast<CastInst>(V)->getOperand(0);
unsigned OldWidth = Scale.getBitWidth();
unsigned SmallWidth = CastOp->getType()->getPrimitiveSizeInBits();
Scale.trunc(SmallWidth);
Offset.trunc(SmallWidth);
Value *Result = GetLinearExpression(CastOp, Scale, Offset, TD, Depth+1);
Extension = isa<SExtInst>(V) ? EK_SignExt : EK_ZeroExt;
Value *Result = GetLinearExpression(CastOp, Scale, Offset, Extension,
TD, Depth+1);
Scale.zext(OldWidth);
Offset.zext(OldWidth);
return Result;
}
@ -360,10 +373,16 @@ DecomposeGEPExpression(const Value *V, int64_t &BaseOffs,
uint64_t Scale = TD->getTypeAllocSize(*GTI);
ExtensionKind Extension = EK_NotExtended;
// Use GetLinearExpression to decompose the index into a C1*V+C2 form.
// If the integer type is smaller than the pointer size, it is implicitly
// sign extended to pointer size.
unsigned Width = cast<IntegerType>(Index->getType())->getBitWidth();
if (TD->getPointerSizeInBits() > Width)
Extension = EK_SignExt;
// Use GetLinearExpression to decompose the index into a C1*V+C2 form.
APInt IndexScale(Width, 0), IndexOffset(Width, 0);
Index = GetLinearExpression(Index, IndexScale, IndexOffset, *TD, 0);
Index = GetLinearExpression(Index, IndexScale, IndexOffset, Extension,
*TD, 0);
// The GEP index scale ("Scale") scales C1*V+C2, yielding (C1*V+C2)*Scale.
// This gives us an aggregate computation of (C1*Scale)*V + C2*Scale.

14
test/Analysis/BasicAA/gep-alias.ll
View File

@ -115,14 +115,14 @@ define i32 @test7(i32* %p, i64 %i) {
; CHECK: ret i32 0
}
; P[sext(i)] != p[sext(i+1)]
; P[zext(i)] != p[zext(i+1)]
; PR1143
define i32 @test8(i32* %p, i32 %i) {
%i1 = sext i32 %i to i64
%pi = getelementptr i32* %p, i64 %i1
%i.next = add i32 %i, 1
%i.next2 = sext i32 %i.next to i64
%pi.next = getelementptr i32* %p, i64 %i.next2
define i32 @test8(i32* %p, i16 %i) {
%i1 = zext i16 %i to i32
%pi = getelementptr i32* %p, i32 %i1
%i.next = add i16 %i, 1
%i.next2 = zext i16 %i.next to i32
%pi.next = getelementptr i32* %p, i32 %i.next2
%x = load i32* %pi
store i32 42, i32* %pi.next
%y = load i32* %pi