6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-25 16:24:23 +00:00
Code Issues Projects Releases Wiki Activity

teach basicaa that A[i] != A[i+1].

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@89951 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner
2009-11-26 16:18:10 +00:00
parent 61d2462400
commit f6ac4d9dad
3 changed files with 48 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
lib/Analysis/BasicAliasAnalysis.cpp
View File

@ -378,6 +378,30 @@ BasicAliasAnalysis::getModRefInfo(CallSite CS1, CallSite CS2) {
return NoAA::getModRefInfo(CS1, CS2); return NoAA::getModRefInfo(CS1, CS2);
} }
/// GetLinearExpression - Analyze the specified value as a linear expression:
/// "A*V + B". Return the scale and offset values as APInts and return V as a
/// Value*. The incoming Value is known to be a scalar integer.
static Value *GetLinearExpression(Value *V, APInt &Scale, APInt &Offset) {
assert(isa<IntegerType>(V->getType()) && "Not an integer value");
if (BinaryOperator *BOp = dyn_cast<BinaryOperator>(V)) {
if (ConstantInt *RHSC = dyn_cast<ConstantInt>(BOp->getOperand(1))) {
switch (BOp->getOpcode()) {
default: break;
case Instruction::Add:
V = GetLinearExpression(BOp->getOperand(0), Scale, Offset);
Offset += RHSC->getValue();
return V;
// TODO: SHL, MUL, OR.
}
}
}
Scale = 1;
Offset = 0;
return V;
}
/// DecomposeGEPExpression - If V is a symbolic pointer expression, decompose it /// DecomposeGEPExpression - If V is a symbolic pointer expression, decompose it
/// into a base pointer with a constant offset and a number of scaled symbolic /// into a base pointer with a constant offset and a number of scaled symbolic
/// offsets. /// offsets.
@ -456,6 +480,14 @@ static const Value *DecomposeGEPExpression(const Value *V, int64_t &BaseOffs,
// TODO: Could handle linear expressions here like A[X+1], also A[X*4|1]. // TODO: Could handle linear expressions here like A[X+1], also A[X*4|1].
uint64_t Scale = TD->getTypeAllocSize(*GTI); uint64_t Scale = TD->getTypeAllocSize(*GTI);
unsigned Width = cast<IntegerType>(Index->getType())->getBitWidth();
APInt IndexScale(Width, 0), IndexOffset(Width, 0);
Index = GetLinearExpression(Index, IndexScale, IndexOffset);
Scale *= IndexScale.getZExtValue();
BaseOffs += IndexOffset.getZExtValue()*Scale;
// If we already had an occurrance of this index variable, merge this // If we already had an occurrance of this index variable, merge this
// scale into it. For example, we want to handle: // scale into it. For example, we want to handle:
// A[x][x] -> x*16 + x*4 -> x*20 // A[x][x] -> x*16 + x*4 -> x*20

2
lib/Target/README.txt
View File

@ -458,8 +458,6 @@ int i;
} }
} }
BasicAA also doesn't do this for add. It needs to know that &A[i+1] != &A[i].
//===---------------------------------------------------------------------===// //===---------------------------------------------------------------------===//
We should investigate an instruction sinking pass. Consider this silly We should investigate an instruction sinking pass. Consider this silly

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

@ -71,3 +71,19 @@ entry:
; CHECK: @test4 ; CHECK: @test4
; CHECK: ret i32 64 ; CHECK: ret i32 64
} }
; P[i] != p[i+1]
define i32 @test5(i32* %p, i64 %i) {
%pi = getelementptr i32* %p, i64 %i
%i.next = add i64 %i, 1
%pi.next = getelementptr i32* %p, i64 %i.next
%x = load i32* %pi
store i32 42, i32* %pi.next
%y = load i32* %pi
%z = sub i32 %x, %y
ret i32 %z
; CHECK: @test5
; CHECK: ret i32 0
}