6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-08-21 03:29:40 +00:00
Code Issues Projects Releases Wiki Activity

Generalize SROA to allow the first index of a GEP to be non-zero. Add a

Browse Source 
missing check that an array reference doesn't go past the end of the array,
and remove some redundant checks for in-bound array and vector references
that are no longer needed.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91897 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Bob Wilson 2009-12-22 06:57:14 +00:00
parent 665e947740
commit f27a4cd783
2 changed files with 57 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
lib/Transforms/Scalar/ScalarReplAggregates.cpp
View File

@ -464,13 +464,6 @@ void SROA::isSafeGEP(GetElementPtrInst *GEPI, AllocaInst *AI,
if (GEPIt == E)
return;
// The first GEP index must be zero.
if (!isa<ConstantInt>(GEPIt.getOperand()) ||
!cast<ConstantInt>(GEPIt.getOperand())->isZero())
return MarkUnsafe(Info);
if (++GEPIt == E)
return;
// Walk through the GEP type indices, checking the types that this indexes
// into.
for (; GEPIt != E; ++GEPIt) {
@ -481,24 +474,10 @@ void SROA::isSafeGEP(GetElementPtrInst *GEPI, AllocaInst *AI,
ConstantInt *IdxVal = dyn_cast<ConstantInt>(GEPIt.getOperand());
if (!IdxVal)
return MarkUnsafe(Info);
if (const ArrayType *AT = dyn_cast<ArrayType>(*GEPIt)) {
// This GEP indexes an array. Verify that this is an in-range constant
// integer. Specifically, consider A[0][i]. We cannot know that the user
// isn't doing invalid things like allowing i to index an out-of-range
// subscript that accesses A[1]. Because of this, we have to reject SROA
// of any accesses into structs where any of the components are variables.
if (IdxVal->getZExtValue() >= AT->getNumElements())
return MarkUnsafe(Info);
} else {
const VectorType *VT = cast<VectorType>(*GEPIt);
if (IdxVal->getZExtValue() >= VT->getNumElements())
return MarkUnsafe(Info);
}
}
// All the indices are safe. Now compute the offset due to this GEP and
// check if the alloca has a component element at that offset.
// Compute the offset due to this GEP and check if the alloca has a
// component element at that offset.
SmallVector<Value*, 8> Indices(GEPI->op_begin() + 1, GEPI->op_end());
Offset += TD->getIndexedOffset(GEPI->getPointerOperandType(),
&Indices[0], Indices.size());
@ -552,6 +531,8 @@ bool SROA::TypeHasComponent(const Type *T, uint64_t Offset, uint64_t Size) {
} else if (const ArrayType *AT = dyn_cast<ArrayType>(T)) {
EltTy = AT->getElementType();
EltSize = TD->getTypeAllocSize(EltTy);
if (Offset >= AT->getNumElements() * EltSize)
return false;
Offset %= EltSize;
} else {
return false;

53
test/Transforms/ScalarRepl/nonzero-first-index.ll Normal file
View File

@ -0,0 +1,53 @@
; RUN: opt < %s -scalarrepl -S | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32"
target triple = "i386-pc-linux-gnu"
%nested = type { i32, [4 x i32] }
; Check that a GEP with a non-zero first index does not prevent SROA as long
; as the resulting offset corresponds to an element in the alloca.
define i32 @test1() {
; CHECK: @test1
; CHECK-NOT: = i160
; CHECK: ret i32 undef
%A = alloca %nested
%B = getelementptr %nested* %A, i32 0, i32 1, i32 0
%C = getelementptr i32* %B, i32 2
%D = load i32* %C
ret i32 %D
}
; But, if the offset is out of range, then it should not be transformed.
define i32 @test2() {
; CHECK: @test2
; CHECK: i160
%A = alloca %nested
%B = getelementptr %nested* %A, i32 0, i32 1, i32 0
%C = getelementptr i32* %B, i32 4
%D = load i32* %C
ret i32 %D
}
; Try it with a bitcast and single GEP....
define i32 @test3() {
; CHECK: @test3
; CHECK-NOT: = i160
; CHECK: ret i32 undef
%A = alloca %nested
%B = bitcast %nested* %A to i32*
%C = getelementptr i32* %B, i32 2
%D = load i32* %C
ret i32 %D
}
; ...and again make sure that out-of-range accesses are not transformed.
define i32 @test4() {
; CHECK: @test4
; CHECK: i160
%A = alloca %nested
%B = bitcast %nested* %A to i32*
%C = getelementptr i32* %B, i32 -1
%D = load i32* %C
ret i32 %D
}