From 5fac55fafb53fde5c548bcd08e07418e9d8e549f Mon Sep 17 00:00:00 2001 From: Matthijs Kooijman Date: Mon, 6 Oct 2008 16:23:31 +0000 Subject: [PATCH] Allow scalarrepl to treat an all-zero GEP just as bitcast. This includes not marking a GEP involving a vector as unsafe, but only when it has all zero indices. This allows scalarrepl to work in a few more cases. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@57177 91177308-0d34-0410-b5e6-96231b3b80d8 --- .../Scalar/ScalarReplAggregates.cpp | 42 ++++++++++++------- .../ScalarRepl/2008-09-22-vector-gep.ll | 24 +++++++++++ 2 files changed, 52 insertions(+), 14 deletions(-) create mode 100644 test/Transforms/ScalarRepl/2008-09-22-vector-gep.ll diff --git a/lib/Transforms/Scalar/ScalarReplAggregates.cpp b/lib/Transforms/Scalar/ScalarReplAggregates.cpp index c29202826c2..b319d8da951 100644 --- a/lib/Transforms/Scalar/ScalarReplAggregates.cpp +++ b/lib/Transforms/Scalar/ScalarReplAggregates.cpp @@ -530,7 +530,8 @@ void SROA::isSafeUseOfAllocation(Instruction *User, AllocationInst *AI, return MarkUnsafe(Info); } } - + + bool hasVector = false; // Walk through the GEP type indices, checking the types that this indexes // into. @@ -539,22 +540,30 @@ void SROA::isSafeUseOfAllocation(Instruction *User, AllocationInst *AI, if (isa(*I)) continue; - // Don't SROA pointers into vectors. - if (isa(*I)) - return MarkUnsafe(Info); - - // Otherwise, we must have an index into an array type. 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. ConstantInt *IdxVal = dyn_cast(I.getOperand()); if (!IdxVal) return MarkUnsafe(Info); - if (IdxVal->getZExtValue() >= cast(*I)->getNumElements()) - return MarkUnsafe(Info); - + + // Are all indices still zero? IsAllZeroIndices &= IdxVal->isZero(); + + if (const ArrayType *AT = dyn_cast(*I)) { + // 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); + } + + // Note if we've seen a vector type yet + hasVector |= isa(*I); + + // Don't SROA pointers into vectors, unless all indices are zero. When all + // indices are zero, we only consider this GEP as a bitcast, but will still + // not consider breaking up the vector. + if (hasVector && !IsAllZeroIndices) + return MarkUnsafe(Info); } // If there are any non-simple uses of this getelementptr, make sure to reject @@ -661,6 +670,11 @@ void SROA::RewriteBitCastUserOfAlloca(Instruction *BCInst, AllocationInst *AI, // It is likely that OtherPtr is a bitcast, if so, remove it. if (BitCastInst *BC = dyn_cast(OtherPtr)) OtherPtr = BC->getOperand(0); + // All zero GEPs are effectively casts + if (GetElementPtrInst *GEP = dyn_cast(OtherPtr)) + if (GEP->hasAllZeroIndices()) + OtherPtr = GEP->getOperand(0); + if (ConstantExpr *BCE = dyn_cast(OtherPtr)) if (BCE->getOpcode() == Instruction::BitCast) OtherPtr = BCE->getOperand(0); diff --git a/test/Transforms/ScalarRepl/2008-09-22-vector-gep.ll b/test/Transforms/ScalarRepl/2008-09-22-vector-gep.ll new file mode 100644 index 00000000000..6640383973e --- /dev/null +++ b/test/Transforms/ScalarRepl/2008-09-22-vector-gep.ll @@ -0,0 +1,24 @@ +; This test checks to see if scalarrepl also works when a gep with all zeroes is +; used instead of a bitcast to prepare a memmove pointer argument. Previously, +; this would not work when there was a vector involved in the struct, preventing +; scalarrepl from removing the alloca below. + +; RUN: llvm-as < %s | opt -scalarrepl | llvm-dis > %t +; RUN: cat %t | not grep alloca + +%struct.two = type <{ < 2 x i8 >, i16 }> + +define void @main(%struct.two* %D, i16 %V) { +entry: + %S = alloca %struct.two + %S.2 = getelementptr %struct.two* %S, i32 0, i32 1 + store i16 %V, i16* %S.2 + ; This gep is effectively a bitcast to i8*, but is sometimes generated + ; because the type of the first element in %struct.two is i8. + %tmpS = getelementptr %struct.two* %S, i32 0, i32 0, i32 0 + %tmpD = bitcast %struct.two* %D to i8* + call void @llvm.memmove.i32(i8* %tmpD, i8* %tmpS, i32 4, i32 1) + ret void +} + +declare void @llvm.memmove.i32(i8*, i8*, i32, i32) nounwind