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

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

diff --git a/lib/Transforms/Scalar/ScalarReplAggregates.cpp b/lib/Transforms/Scalar/ScalarReplAggregates.cpp
index d849472a5b9def3a62415d5dc6ea4f34617dd26f..d27610810b381487d836ace9fa61ca8cc443473a 100644 (file)
--- a/lib/Transforms/Scalar/ScalarReplAggregates.cpp
+++ b/lib/Transforms/Scalar/ScalarReplAggregates.cpp
@@ -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;

diff --git a/test/Transforms/ScalarRepl/nonzero-first-index.ll b/test/Transforms/ScalarRepl/nonzero-first-index.ll
new file mode 100644 (file)
index 0000000..60f414b
--- /dev/null
+++ b/test/Transforms/ScalarRepl/nonzero-first-index.ll
@@ -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
+}