[llvm] 74e6527 - [SROA] Migrate tests to opaque pointers (NFC)
Nikita Popov via llvm-commits
llvm-commits at lists.llvm.org
Tue Jun 21 03:55:02 PDT 2022
Author: Nikita Popov
Date: 2022-06-21T12:54:52+02:00
New Revision: 74e652786b2402c529f550959dc7ab58ed4e9ffc
URL: https://github.com/llvm/llvm-project/commit/74e652786b2402c529f550959dc7ab58ed4e9ffc
DIFF: https://github.com/llvm/llvm-project/commit/74e652786b2402c529f550959dc7ab58ed4e9ffc.diff
LOG: [SROA] Migrate tests to opaque pointers (NFC)
Tests were updated with this script:
https://gist.github.com/nikic/98357b71fd67756b0f064c9517b62a34
However, in this case a lot of fixup was required, due to many
minor, but ultimately immaterial differences in results. In
particular, the GEP representation changes slightly in many cases,
either because we now use an i8 GEP, or because we now leave a
GEP alone, using it's original index types and (lack of) inbounds.
basictest-opaque-ptrs.ll has been dropped, because it was an
opaque pointers duplicate of basictest.ll.
Added:
Modified:
llvm/test/Transforms/SROA/2009-02-20-InstCombine-SROA.ll
llvm/test/Transforms/SROA/address-spaces.ll
llvm/test/Transforms/SROA/addrspacecast.ll
llvm/test/Transforms/SROA/alignment.ll
llvm/test/Transforms/SROA/alloca-address-space.ll
llvm/test/Transforms/SROA/assume.ll
llvm/test/Transforms/SROA/basictest.ll
llvm/test/Transforms/SROA/big-endian.ll
llvm/test/Transforms/SROA/dbg-addr-diamond.ll
llvm/test/Transforms/SROA/dbg-inline.ll
llvm/test/Transforms/SROA/dbg-single-piece.ll
llvm/test/Transforms/SROA/dead-inst.ll
llvm/test/Transforms/SROA/fca.ll
llvm/test/Transforms/SROA/ignore-droppable.ll
llvm/test/Transforms/SROA/invariant-group.ll
llvm/test/Transforms/SROA/irregular-type.ll
llvm/test/Transforms/SROA/lifetime-intrinsic.ll
llvm/test/Transforms/SROA/mem-par-metadata-sroa-cast.ll
llvm/test/Transforms/SROA/mem-par-metadata-sroa.ll
llvm/test/Transforms/SROA/non-capturing-call-readonly.ll
llvm/test/Transforms/SROA/non-integral-pointers.ll
llvm/test/Transforms/SROA/phi-and-select.ll
llvm/test/Transforms/SROA/phi-catchswitch.ll
llvm/test/Transforms/SROA/phi-gep.ll
llvm/test/Transforms/SROA/phi-with-duplicate-pred.ll
llvm/test/Transforms/SROA/pointer-offset-size.ll
llvm/test/Transforms/SROA/ppcf128-no-fold.ll
llvm/test/Transforms/SROA/pr26972.ll
llvm/test/Transforms/SROA/pr37267.ll
llvm/test/Transforms/SROA/preserve-nonnull.ll
llvm/test/Transforms/SROA/scalable-vectors.ll
llvm/test/Transforms/SROA/select-gep.ll
llvm/test/Transforms/SROA/select-load.ll
llvm/test/Transforms/SROA/slice-order-independence.ll
llvm/test/Transforms/SROA/slice-width.ll
llvm/test/Transforms/SROA/std-clamp.ll
llvm/test/Transforms/SROA/tbaa-struct.ll
llvm/test/Transforms/SROA/tbaa-struct2.ll
llvm/test/Transforms/SROA/tbaa-subload.ll
llvm/test/Transforms/SROA/vector-conversion.ll
llvm/test/Transforms/SROA/vector-lifetime-intrinsic.ll
llvm/test/Transforms/SROA/vector-promotion-different-size.ll
llvm/test/Transforms/SROA/vector-promotion.ll
llvm/test/Transforms/SROA/vectors-of-pointers.ll
Removed:
llvm/test/Transforms/SROA/basictest-opaque-ptrs.ll
################################################################################
diff --git a/llvm/test/Transforms/SROA/2009-02-20-InstCombine-SROA.ll b/llvm/test/Transforms/SROA/2009-02-20-InstCombine-SROA.ll
index 7323d64d2289..a83bd3b6893a 100644
--- a/llvm/test/Transforms/SROA/2009-02-20-InstCombine-SROA.ll
+++ b/llvm/test/Transforms/SROA/2009-02-20-InstCombine-SROA.ll
@@ -8,62 +8,62 @@ target triple = "i386-apple-darwin9.6"
%"struct.std::vector<int,std::allocator<int> >" = type { %"struct.std::_Vector_base<int,std::allocator<int> >" }
%"struct.std::_Vector_base<int,std::allocator<int> >" = type { %"struct.std::_Vector_base<int,std::allocator<int> >::_Vector_impl" }
-%"struct.std::_Vector_base<int,std::allocator<int> >::_Vector_impl" = type { i32*, i32*, i32* }
+%"struct.std::_Vector_base<int,std::allocator<int> >::_Vector_impl" = type { ptr, ptr, ptr }
-define i32* @_Z3fooRSt6vectorIiSaIiEE(%"struct.std::vector<int,std::allocator<int> >"* %X) {
+define ptr @_Z3fooRSt6vectorIiSaIiEE(ptr %X) {
; CHECK-LABEL: @_Z3fooRSt6vectorIiSaIiEE(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[__FIRST_ADDR_I_I_SROA_0:%.*]] = alloca i32*, align 8
-; CHECK-NEXT: [[__LAST_ADDR_I_I_SROA_0:%.*]] = alloca i32*, align 8
-; CHECK-NEXT: [[TMP0:%.*]] = getelementptr %"struct.std::vector<int,std::allocator<int> >", %"struct.std::vector<int,std::allocator<int> >"* [[X:%.*]], i32 0, i32 0, i32 0, i32 1
-; CHECK-NEXT: [[TMP1:%.*]] = load i32*, i32** [[TMP0]], align 4
-; CHECK-NEXT: [[TMP2:%.*]] = getelementptr %"struct.std::vector<int,std::allocator<int> >", %"struct.std::vector<int,std::allocator<int> >"* [[X]], i32 0, i32 0, i32 0, i32 0
-; CHECK-NEXT: [[TMP3:%.*]] = load i32*, i32** [[TMP2]], align 4
-; CHECK-NEXT: store i32* [[TMP3]], i32** [[__FIRST_ADDR_I_I_SROA_0]], align 8
-; CHECK-NEXT: store i32* [[TMP1]], i32** [[__LAST_ADDR_I_I_SROA_0]], align 8
-; CHECK-NEXT: [[TMP4:%.*]] = ptrtoint i32* [[TMP1]] to i32
-; CHECK-NEXT: [[TMP5:%.*]] = ptrtoint i32* [[TMP3]] to i32
+; CHECK-NEXT: [[__FIRST_ADDR_I_I_SROA_0:%.*]] = alloca ptr, align 8
+; CHECK-NEXT: [[__LAST_ADDR_I_I_SROA_0:%.*]] = alloca ptr, align 8
+; CHECK-NEXT: [[TMP0:%.*]] = getelementptr %"struct.std::vector<int,std::allocator<int> >", ptr [[X:%.*]], i32 0, i32 0, i32 0, i32 1
+; CHECK-NEXT: [[TMP1:%.*]] = load ptr, ptr [[TMP0]], align 4
+; CHECK-NEXT: [[TMP2:%.*]] = getelementptr %"struct.std::vector<int,std::allocator<int> >", ptr [[X]], i32 0, i32 0, i32 0, i32 0
+; CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TMP2]], align 4
+; CHECK-NEXT: store ptr [[TMP3]], ptr [[__FIRST_ADDR_I_I_SROA_0]], align 8
+; CHECK-NEXT: store ptr [[TMP1]], ptr [[__LAST_ADDR_I_I_SROA_0]], align 8
+; CHECK-NEXT: [[TMP4:%.*]] = ptrtoint ptr [[TMP1]] to i32
+; CHECK-NEXT: [[TMP5:%.*]] = ptrtoint ptr [[TMP3]] to i32
; CHECK-NEXT: [[TMP6:%.*]] = sub i32 [[TMP4]], [[TMP5]]
; CHECK-NEXT: [[TMP7:%.*]] = ashr i32 [[TMP6]], 4
; CHECK-NEXT: br label [[BB12_I_I:%.*]]
; CHECK: bb.i.i:
-; CHECK-NEXT: [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_13:%.*]] = load i32*, i32** [[__FIRST_ADDR_I_I_SROA_0]], align 8
-; CHECK-NEXT: [[TMP8:%.*]] = load i32, i32* [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_13]], align 4
+; CHECK-NEXT: [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_13:%.*]] = load ptr, ptr [[__FIRST_ADDR_I_I_SROA_0]], align 8
+; CHECK-NEXT: [[TMP8:%.*]] = load i32, ptr [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_13]], align 4
; CHECK-NEXT: [[TMP9:%.*]] = icmp eq i32 [[TMP8]], 42
; CHECK-NEXT: br i1 [[TMP9]], label [[BB1_I_I:%.*]], label [[BB2_I_I:%.*]]
; CHECK: bb1.i.i:
; CHECK-NEXT: br label [[_ZST4FINDIN9__GNU_CXX17__NORMAL_ITERATORIPIST6VECTORIISAIIEEEEIET_S7_S7_RKT0__EXIT:%.*]]
; CHECK: bb2.i.i:
-; CHECK-NEXT: [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_14:%.*]] = load i32*, i32** [[__FIRST_ADDR_I_I_SROA_0]], align 8
-; CHECK-NEXT: [[TMP10:%.*]] = getelementptr i32, i32* [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_14]], i32 1
-; CHECK-NEXT: store i32* [[TMP10]], i32** [[__FIRST_ADDR_I_I_SROA_0]], align 8
-; CHECK-NEXT: [[TMP11:%.*]] = load i32, i32* [[TMP10]], align 4
+; CHECK-NEXT: [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_14:%.*]] = load ptr, ptr [[__FIRST_ADDR_I_I_SROA_0]], align 8
+; CHECK-NEXT: [[TMP10:%.*]] = getelementptr i32, ptr [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_14]], i32 1
+; CHECK-NEXT: store ptr [[TMP10]], ptr [[__FIRST_ADDR_I_I_SROA_0]], align 8
+; CHECK-NEXT: [[TMP11:%.*]] = load i32, ptr [[TMP10]], align 4
; CHECK-NEXT: [[TMP12:%.*]] = icmp eq i32 [[TMP11]], 42
; CHECK-NEXT: br i1 [[TMP12]], label [[BB4_I_I:%.*]], label [[BB5_I_I:%.*]]
; CHECK: bb4.i.i:
; CHECK-NEXT: br label [[_ZST4FINDIN9__GNU_CXX17__NORMAL_ITERATORIPIST6VECTORIISAIIEEEEIET_S7_S7_RKT0__EXIT]]
; CHECK: bb5.i.i:
-; CHECK-NEXT: [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_15:%.*]] = load i32*, i32** [[__FIRST_ADDR_I_I_SROA_0]], align 8
-; CHECK-NEXT: [[TMP13:%.*]] = getelementptr i32, i32* [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_15]], i32 1
-; CHECK-NEXT: store i32* [[TMP13]], i32** [[__FIRST_ADDR_I_I_SROA_0]], align 8
-; CHECK-NEXT: [[TMP14:%.*]] = load i32, i32* [[TMP13]], align 4
+; CHECK-NEXT: [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_15:%.*]] = load ptr, ptr [[__FIRST_ADDR_I_I_SROA_0]], align 8
+; CHECK-NEXT: [[TMP13:%.*]] = getelementptr i32, ptr [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_15]], i32 1
+; CHECK-NEXT: store ptr [[TMP13]], ptr [[__FIRST_ADDR_I_I_SROA_0]], align 8
+; CHECK-NEXT: [[TMP14:%.*]] = load i32, ptr [[TMP13]], align 4
; CHECK-NEXT: [[TMP15:%.*]] = icmp eq i32 [[TMP14]], 42
; CHECK-NEXT: br i1 [[TMP15]], label [[BB7_I_I:%.*]], label [[BB8_I_I:%.*]]
; CHECK: bb7.i.i:
; CHECK-NEXT: br label [[_ZST4FINDIN9__GNU_CXX17__NORMAL_ITERATORIPIST6VECTORIISAIIEEEEIET_S7_S7_RKT0__EXIT]]
; CHECK: bb8.i.i:
-; CHECK-NEXT: [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_16:%.*]] = load i32*, i32** [[__FIRST_ADDR_I_I_SROA_0]], align 8
-; CHECK-NEXT: [[TMP16:%.*]] = getelementptr i32, i32* [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_16]], i32 1
-; CHECK-NEXT: store i32* [[TMP16]], i32** [[__FIRST_ADDR_I_I_SROA_0]], align 8
-; CHECK-NEXT: [[TMP17:%.*]] = load i32, i32* [[TMP16]], align 4
+; CHECK-NEXT: [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_16:%.*]] = load ptr, ptr [[__FIRST_ADDR_I_I_SROA_0]], align 8
+; CHECK-NEXT: [[TMP16:%.*]] = getelementptr i32, ptr [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_16]], i32 1
+; CHECK-NEXT: store ptr [[TMP16]], ptr [[__FIRST_ADDR_I_I_SROA_0]], align 8
+; CHECK-NEXT: [[TMP17:%.*]] = load i32, ptr [[TMP16]], align 4
; CHECK-NEXT: [[TMP18:%.*]] = icmp eq i32 [[TMP17]], 42
; CHECK-NEXT: br i1 [[TMP18]], label [[BB10_I_I:%.*]], label [[BB11_I_I:%.*]]
; CHECK: bb10.i.i:
; CHECK-NEXT: br label [[_ZST4FINDIN9__GNU_CXX17__NORMAL_ITERATORIPIST6VECTORIISAIIEEEEIET_S7_S7_RKT0__EXIT]]
; CHECK: bb11.i.i:
-; CHECK-NEXT: [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_17:%.*]] = load i32*, i32** [[__FIRST_ADDR_I_I_SROA_0]], align 8
-; CHECK-NEXT: [[TMP19:%.*]] = getelementptr i32, i32* [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_17]], i32 1
-; CHECK-NEXT: store i32* [[TMP19]], i32** [[__FIRST_ADDR_I_I_SROA_0]], align 8
+; CHECK-NEXT: [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_17:%.*]] = load ptr, ptr [[__FIRST_ADDR_I_I_SROA_0]], align 8
+; CHECK-NEXT: [[TMP19:%.*]] = getelementptr i32, ptr [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_17]], i32 1
+; CHECK-NEXT: store ptr [[TMP19]], ptr [[__FIRST_ADDR_I_I_SROA_0]], align 8
; CHECK-NEXT: [[TMP20:%.*]] = add i32 [[__TRIP_COUNT_0_I_I:%.*]], -1
; CHECK-NEXT: br label [[BB12_I_I]]
; CHECK: bb12.i.i:
@@ -71,10 +71,10 @@ define i32* @_Z3fooRSt6vectorIiSaIiEE(%"struct.std::vector<int,std::allocator<in
; CHECK-NEXT: [[TMP21:%.*]] = icmp sgt i32 [[__TRIP_COUNT_0_I_I]], 0
; CHECK-NEXT: br i1 [[TMP21]], label [[BB_I_I:%.*]], label [[BB13_I_I:%.*]]
; CHECK: bb13.i.i:
-; CHECK-NEXT: [[__LAST_ADDR_I_I_SROA_0_0___LAST_ADDR_I_I_SROA_0_0___LAST_ADDR_I_I_SROA_0_0___LAST_ADDR_I_I_SROA_0_0_:%.*]] = load i32*, i32** [[__LAST_ADDR_I_I_SROA_0]], align 8
-; CHECK-NEXT: [[TMP22:%.*]] = ptrtoint i32* [[__LAST_ADDR_I_I_SROA_0_0___LAST_ADDR_I_I_SROA_0_0___LAST_ADDR_I_I_SROA_0_0___LAST_ADDR_I_I_SROA_0_0_]] to i32
-; CHECK-NEXT: [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_:%.*]] = load i32*, i32** [[__FIRST_ADDR_I_I_SROA_0]], align 8
-; CHECK-NEXT: [[TMP23:%.*]] = ptrtoint i32* [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_]] to i32
+; CHECK-NEXT: [[__LAST_ADDR_I_I_SROA_0_0___LAST_ADDR_I_I_SROA_0_0___LAST_ADDR_I_I_SROA_0_0___LAST_ADDR_I_I_SROA_0_0_:%.*]] = load ptr, ptr [[__LAST_ADDR_I_I_SROA_0]], align 8
+; CHECK-NEXT: [[TMP22:%.*]] = ptrtoint ptr [[__LAST_ADDR_I_I_SROA_0_0___LAST_ADDR_I_I_SROA_0_0___LAST_ADDR_I_I_SROA_0_0___LAST_ADDR_I_I_SROA_0_0_]] to i32
+; CHECK-NEXT: [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_:%.*]] = load ptr, ptr [[__FIRST_ADDR_I_I_SROA_0]], align 8
+; CHECK-NEXT: [[TMP23:%.*]] = ptrtoint ptr [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_]] to i32
; CHECK-NEXT: [[TMP24:%.*]] = sub i32 [[TMP22]], [[TMP23]]
; CHECK-NEXT: [[TMP25:%.*]] = ashr i32 [[TMP24]], 2
; CHECK-NEXT: switch i32 [[TMP25]], label [[BB26_I_I:%.*]] [
@@ -83,68 +83,68 @@ define i32* @_Z3fooRSt6vectorIiSaIiEE(%"struct.std::vector<int,std::allocator<in
; CHECK-NEXT: i32 3, label [[BB14_I_I:%.*]]
; CHECK-NEXT: ]
; CHECK: bb14.i.i:
-; CHECK-NEXT: [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_7:%.*]] = load i32*, i32** [[__FIRST_ADDR_I_I_SROA_0]], align 8
-; CHECK-NEXT: [[TMP26:%.*]] = load i32, i32* [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_7]], align 4
+; CHECK-NEXT: [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_7:%.*]] = load ptr, ptr [[__FIRST_ADDR_I_I_SROA_0]], align 8
+; CHECK-NEXT: [[TMP26:%.*]] = load i32, ptr [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_7]], align 4
; CHECK-NEXT: [[TMP27:%.*]] = icmp eq i32 [[TMP26]], 42
; CHECK-NEXT: br i1 [[TMP27]], label [[BB16_I_I:%.*]], label [[BB17_I_I:%.*]]
; CHECK: bb16.i.i:
; CHECK-NEXT: br label [[_ZST4FINDIN9__GNU_CXX17__NORMAL_ITERATORIPIST6VECTORIISAIIEEEEIET_S7_S7_RKT0__EXIT]]
; CHECK: bb17.i.i:
-; CHECK-NEXT: [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_8:%.*]] = load i32*, i32** [[__FIRST_ADDR_I_I_SROA_0]], align 8
-; CHECK-NEXT: [[TMP28:%.*]] = getelementptr i32, i32* [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_8]], i32 1
-; CHECK-NEXT: store i32* [[TMP28]], i32** [[__FIRST_ADDR_I_I_SROA_0]], align 8
+; CHECK-NEXT: [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_8:%.*]] = load ptr, ptr [[__FIRST_ADDR_I_I_SROA_0]], align 8
+; CHECK-NEXT: [[TMP28:%.*]] = getelementptr i32, ptr [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_8]], i32 1
+; CHECK-NEXT: store ptr [[TMP28]], ptr [[__FIRST_ADDR_I_I_SROA_0]], align 8
; CHECK-NEXT: br label [[BB18_I_I]]
; CHECK: bb18.i.i:
-; CHECK-NEXT: [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_9:%.*]] = load i32*, i32** [[__FIRST_ADDR_I_I_SROA_0]], align 8
-; CHECK-NEXT: [[TMP29:%.*]] = load i32, i32* [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_9]], align 4
+; CHECK-NEXT: [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_9:%.*]] = load ptr, ptr [[__FIRST_ADDR_I_I_SROA_0]], align 8
+; CHECK-NEXT: [[TMP29:%.*]] = load i32, ptr [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_9]], align 4
; CHECK-NEXT: [[TMP30:%.*]] = icmp eq i32 [[TMP29]], 42
; CHECK-NEXT: br i1 [[TMP30]], label [[BB20_I_I:%.*]], label [[BB21_I_I:%.*]]
; CHECK: bb20.i.i:
; CHECK-NEXT: br label [[_ZST4FINDIN9__GNU_CXX17__NORMAL_ITERATORIPIST6VECTORIISAIIEEEEIET_S7_S7_RKT0__EXIT]]
; CHECK: bb21.i.i:
-; CHECK-NEXT: [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_10:%.*]] = load i32*, i32** [[__FIRST_ADDR_I_I_SROA_0]], align 8
-; CHECK-NEXT: [[TMP31:%.*]] = getelementptr i32, i32* [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_10]], i32 1
-; CHECK-NEXT: store i32* [[TMP31]], i32** [[__FIRST_ADDR_I_I_SROA_0]], align 8
+; CHECK-NEXT: [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_10:%.*]] = load ptr, ptr [[__FIRST_ADDR_I_I_SROA_0]], align 8
+; CHECK-NEXT: [[TMP31:%.*]] = getelementptr i32, ptr [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_10]], i32 1
+; CHECK-NEXT: store ptr [[TMP31]], ptr [[__FIRST_ADDR_I_I_SROA_0]], align 8
; CHECK-NEXT: br label [[BB22_I_I]]
; CHECK: bb22.i.i:
-; CHECK-NEXT: [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_11:%.*]] = load i32*, i32** [[__FIRST_ADDR_I_I_SROA_0]], align 8
-; CHECK-NEXT: [[TMP32:%.*]] = load i32, i32* [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_11]], align 4
+; CHECK-NEXT: [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_11:%.*]] = load ptr, ptr [[__FIRST_ADDR_I_I_SROA_0]], align 8
+; CHECK-NEXT: [[TMP32:%.*]] = load i32, ptr [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_11]], align 4
; CHECK-NEXT: [[TMP33:%.*]] = icmp eq i32 [[TMP32]], 42
; CHECK-NEXT: br i1 [[TMP33]], label [[BB24_I_I:%.*]], label [[BB25_I_I:%.*]]
; CHECK: bb24.i.i:
; CHECK-NEXT: br label [[_ZST4FINDIN9__GNU_CXX17__NORMAL_ITERATORIPIST6VECTORIISAIIEEEEIET_S7_S7_RKT0__EXIT]]
; CHECK: bb25.i.i:
-; CHECK-NEXT: [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_12:%.*]] = load i32*, i32** [[__FIRST_ADDR_I_I_SROA_0]], align 8
-; CHECK-NEXT: [[TMP34:%.*]] = getelementptr i32, i32* [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_12]], i32 1
-; CHECK-NEXT: store i32* [[TMP34]], i32** [[__FIRST_ADDR_I_I_SROA_0]], align 8
+; CHECK-NEXT: [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_12:%.*]] = load ptr, ptr [[__FIRST_ADDR_I_I_SROA_0]], align 8
+; CHECK-NEXT: [[TMP34:%.*]] = getelementptr i32, ptr [[__FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0___FIRST_ADDR_I_I_SROA_0_0_12]], i32 1
+; CHECK-NEXT: store ptr [[TMP34]], ptr [[__FIRST_ADDR_I_I_SROA_0]], align 8
; CHECK-NEXT: br label [[BB26_I_I]]
; CHECK: bb26.i.i:
; CHECK-NEXT: br label [[_ZST4FINDIN9__GNU_CXX17__NORMAL_ITERATORIPIST6VECTORIISAIIEEEEIET_S7_S7_RKT0__EXIT]]
; CHECK: _ZSt4findIN9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEEiET_S7_S7_RKT0_.exit:
-; CHECK-NEXT: [[DOTIN_IN:%.*]] = phi i32** [ [[__LAST_ADDR_I_I_SROA_0]], [[BB26_I_I]] ], [ [[__FIRST_ADDR_I_I_SROA_0]], [[BB24_I_I]] ], [ [[__FIRST_ADDR_I_I_SROA_0]], [[BB20_I_I]] ], [ [[__FIRST_ADDR_I_I_SROA_0]], [[BB16_I_I]] ], [ [[__FIRST_ADDR_I_I_SROA_0]], [[BB10_I_I]] ], [ [[__FIRST_ADDR_I_I_SROA_0]], [[BB7_I_I]] ], [ [[__FIRST_ADDR_I_I_SROA_0]], [[BB4_I_I]] ], [ [[__FIRST_ADDR_I_I_SROA_0]], [[BB1_I_I]] ]
+; CHECK-NEXT: [[DOTIN_IN:%.*]] = phi ptr [ [[__LAST_ADDR_I_I_SROA_0]], [[BB26_I_I]] ], [ [[__FIRST_ADDR_I_I_SROA_0]], [[BB24_I_I]] ], [ [[__FIRST_ADDR_I_I_SROA_0]], [[BB20_I_I]] ], [ [[__FIRST_ADDR_I_I_SROA_0]], [[BB16_I_I]] ], [ [[__FIRST_ADDR_I_I_SROA_0]], [[BB10_I_I]] ], [ [[__FIRST_ADDR_I_I_SROA_0]], [[BB7_I_I]] ], [ [[__FIRST_ADDR_I_I_SROA_0]], [[BB4_I_I]] ], [ [[__FIRST_ADDR_I_I_SROA_0]], [[BB1_I_I]] ]
; CHECK-NEXT: br label [[RETURN:%.*]]
; CHECK: return:
-; CHECK-NEXT: [[TMP35:%.*]] = load i32*, i32** [[DOTIN_IN]], align 4
-; CHECK-NEXT: ret i32* [[TMP35]]
+; CHECK-NEXT: [[TMP35:%.*]] = load ptr, ptr [[DOTIN_IN]], align 4
+; CHECK-NEXT: ret ptr [[TMP35]]
;
entry:
- %__first_addr.i.i.sroa.0 = alloca i32*, align 8
- %__last_addr.i.i.sroa.0 = alloca i32*, align 8
- %0 = getelementptr %"struct.std::vector<int,std::allocator<int> >", %"struct.std::vector<int,std::allocator<int> >"* %X, i32 0, i32 0, i32 0, i32 1
- %1 = load i32*, i32** %0, align 4
- %2 = getelementptr %"struct.std::vector<int,std::allocator<int> >", %"struct.std::vector<int,std::allocator<int> >"* %X, i32 0, i32 0, i32 0, i32 0
- %3 = load i32*, i32** %2, align 4
- store i32* %3, i32** %__first_addr.i.i.sroa.0, align 8
- store i32* %1, i32** %__last_addr.i.i.sroa.0, align 8
- %4 = ptrtoint i32* %1 to i32
- %5 = ptrtoint i32* %3 to i32
+ %__first_addr.i.i.sroa.0 = alloca ptr, align 8
+ %__last_addr.i.i.sroa.0 = alloca ptr, align 8
+ %0 = getelementptr %"struct.std::vector<int,std::allocator<int> >", ptr %X, i32 0, i32 0, i32 0, i32 1
+ %1 = load ptr, ptr %0, align 4
+ %2 = getelementptr %"struct.std::vector<int,std::allocator<int> >", ptr %X, i32 0, i32 0, i32 0, i32 0
+ %3 = load ptr, ptr %2, align 4
+ store ptr %3, ptr %__first_addr.i.i.sroa.0, align 8
+ store ptr %1, ptr %__last_addr.i.i.sroa.0, align 8
+ %4 = ptrtoint ptr %1 to i32
+ %5 = ptrtoint ptr %3 to i32
%6 = sub i32 %4, %5
%7 = ashr i32 %6, 4
br label %bb12.i.i
bb.i.i: ; preds = %bb12.i.i
- %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.13 = load i32*, i32** %__first_addr.i.i.sroa.0, align 8
- %8 = load i32, i32* %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.13, align 4
+ %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.13 = load ptr, ptr %__first_addr.i.i.sroa.0, align 8
+ %8 = load i32, ptr %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.13, align 4
%9 = icmp eq i32 %8, 42
br i1 %9, label %bb1.i.i, label %bb2.i.i
@@ -152,10 +152,10 @@ bb1.i.i: ; preds = %bb.i.i
br label %_ZSt4findIN9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEEiET_S7_S7_RKT0_.exit
bb2.i.i: ; preds = %bb.i.i
- %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.14 = load i32*, i32** %__first_addr.i.i.sroa.0, align 8
- %10 = getelementptr i32, i32* %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.14, i32 1
- store i32* %10, i32** %__first_addr.i.i.sroa.0, align 8
- %11 = load i32, i32* %10, align 4
+ %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.14 = load ptr, ptr %__first_addr.i.i.sroa.0, align 8
+ %10 = getelementptr i32, ptr %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.14, i32 1
+ store ptr %10, ptr %__first_addr.i.i.sroa.0, align 8
+ %11 = load i32, ptr %10, align 4
%12 = icmp eq i32 %11, 42
br i1 %12, label %bb4.i.i, label %bb5.i.i
@@ -163,10 +163,10 @@ bb4.i.i: ; preds = %bb2.i.i
br label %_ZSt4findIN9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEEiET_S7_S7_RKT0_.exit
bb5.i.i: ; preds = %bb2.i.i
- %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.15 = load i32*, i32** %__first_addr.i.i.sroa.0, align 8
- %13 = getelementptr i32, i32* %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.15, i32 1
- store i32* %13, i32** %__first_addr.i.i.sroa.0, align 8
- %14 = load i32, i32* %13, align 4
+ %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.15 = load ptr, ptr %__first_addr.i.i.sroa.0, align 8
+ %13 = getelementptr i32, ptr %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.15, i32 1
+ store ptr %13, ptr %__first_addr.i.i.sroa.0, align 8
+ %14 = load i32, ptr %13, align 4
%15 = icmp eq i32 %14, 42
br i1 %15, label %bb7.i.i, label %bb8.i.i
@@ -174,10 +174,10 @@ bb7.i.i: ; preds = %bb5.i.i
br label %_ZSt4findIN9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEEiET_S7_S7_RKT0_.exit
bb8.i.i: ; preds = %bb5.i.i
- %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.16 = load i32*, i32** %__first_addr.i.i.sroa.0, align 8
- %16 = getelementptr i32, i32* %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.16, i32 1
- store i32* %16, i32** %__first_addr.i.i.sroa.0, align 8
- %17 = load i32, i32* %16, align 4
+ %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.16 = load ptr, ptr %__first_addr.i.i.sroa.0, align 8
+ %16 = getelementptr i32, ptr %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.16, i32 1
+ store ptr %16, ptr %__first_addr.i.i.sroa.0, align 8
+ %17 = load i32, ptr %16, align 4
%18 = icmp eq i32 %17, 42
br i1 %18, label %bb10.i.i, label %bb11.i.i
@@ -185,9 +185,9 @@ bb10.i.i: ; preds = %bb8.i.i
br label %_ZSt4findIN9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEEiET_S7_S7_RKT0_.exit
bb11.i.i: ; preds = %bb8.i.i
- %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.17 = load i32*, i32** %__first_addr.i.i.sroa.0, align 8
- %19 = getelementptr i32, i32* %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.17, i32 1
- store i32* %19, i32** %__first_addr.i.i.sroa.0, align 8
+ %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.17 = load ptr, ptr %__first_addr.i.i.sroa.0, align 8
+ %19 = getelementptr i32, ptr %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.17, i32 1
+ store ptr %19, ptr %__first_addr.i.i.sroa.0, align 8
%20 = add i32 %__trip_count.0.i.i, -1
br label %bb12.i.i
@@ -197,10 +197,10 @@ bb12.i.i: ; preds = %bb11.i.i, %entry
br i1 %21, label %bb.i.i, label %bb13.i.i
bb13.i.i: ; preds = %bb12.i.i
- %__last_addr.i.i.sroa.0.0.__last_addr.i.i.sroa.0.0.__last_addr.i.i.sroa.0.0. = load i32*, i32** %__last_addr.i.i.sroa.0, align 8
- %22 = ptrtoint i32* %__last_addr.i.i.sroa.0.0.__last_addr.i.i.sroa.0.0.__last_addr.i.i.sroa.0.0. to i32
- %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0. = load i32*, i32** %__first_addr.i.i.sroa.0, align 8
- %23 = ptrtoint i32* %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0. to i32
+ %__last_addr.i.i.sroa.0.0.__last_addr.i.i.sroa.0.0.__last_addr.i.i.sroa.0.0. = load ptr, ptr %__last_addr.i.i.sroa.0, align 8
+ %22 = ptrtoint ptr %__last_addr.i.i.sroa.0.0.__last_addr.i.i.sroa.0.0.__last_addr.i.i.sroa.0.0. to i32
+ %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0. = load ptr, ptr %__first_addr.i.i.sroa.0, align 8
+ %23 = ptrtoint ptr %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0. to i32
%24 = sub i32 %22, %23
%25 = ashr i32 %24, 2
switch i32 %25, label %bb26.i.i [
@@ -210,8 +210,8 @@ bb13.i.i: ; preds = %bb12.i.i
]
bb14.i.i: ; preds = %bb13.i.i
- %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.7 = load i32*, i32** %__first_addr.i.i.sroa.0, align 8
- %26 = load i32, i32* %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.7, align 4
+ %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.7 = load ptr, ptr %__first_addr.i.i.sroa.0, align 8
+ %26 = load i32, ptr %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.7, align 4
%27 = icmp eq i32 %26, 42
br i1 %27, label %bb16.i.i, label %bb17.i.i
@@ -219,14 +219,14 @@ bb16.i.i: ; preds = %bb14.i.i
br label %_ZSt4findIN9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEEiET_S7_S7_RKT0_.exit
bb17.i.i: ; preds = %bb14.i.i
- %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.8 = load i32*, i32** %__first_addr.i.i.sroa.0, align 8
- %28 = getelementptr i32, i32* %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.8, i32 1
- store i32* %28, i32** %__first_addr.i.i.sroa.0, align 8
+ %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.8 = load ptr, ptr %__first_addr.i.i.sroa.0, align 8
+ %28 = getelementptr i32, ptr %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.8, i32 1
+ store ptr %28, ptr %__first_addr.i.i.sroa.0, align 8
br label %bb18.i.i
bb18.i.i: ; preds = %bb17.i.i, %bb13.i.i
- %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.9 = load i32*, i32** %__first_addr.i.i.sroa.0, align 8
- %29 = load i32, i32* %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.9, align 4
+ %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.9 = load ptr, ptr %__first_addr.i.i.sroa.0, align 8
+ %29 = load i32, ptr %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.9, align 4
%30 = icmp eq i32 %29, 42
br i1 %30, label %bb20.i.i, label %bb21.i.i
@@ -234,14 +234,14 @@ bb20.i.i: ; preds = %bb18.i.i
br label %_ZSt4findIN9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEEiET_S7_S7_RKT0_.exit
bb21.i.i: ; preds = %bb18.i.i
- %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.10 = load i32*, i32** %__first_addr.i.i.sroa.0, align 8
- %31 = getelementptr i32, i32* %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.10, i32 1
- store i32* %31, i32** %__first_addr.i.i.sroa.0, align 8
+ %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.10 = load ptr, ptr %__first_addr.i.i.sroa.0, align 8
+ %31 = getelementptr i32, ptr %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.10, i32 1
+ store ptr %31, ptr %__first_addr.i.i.sroa.0, align 8
br label %bb22.i.i
bb22.i.i: ; preds = %bb21.i.i, %bb13.i.i
- %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.11 = load i32*, i32** %__first_addr.i.i.sroa.0, align 8
- %32 = load i32, i32* %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.11, align 4
+ %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.11 = load ptr, ptr %__first_addr.i.i.sroa.0, align 8
+ %32 = load i32, ptr %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.11, align 4
%33 = icmp eq i32 %32, 42
br i1 %33, label %bb24.i.i, label %bb25.i.i
@@ -249,24 +249,24 @@ bb24.i.i: ; preds = %bb22.i.i
br label %_ZSt4findIN9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEEiET_S7_S7_RKT0_.exit
bb25.i.i: ; preds = %bb22.i.i
- %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.12 = load i32*, i32** %__first_addr.i.i.sroa.0, align 8
- %34 = getelementptr i32, i32* %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.12, i32 1
- store i32* %34, i32** %__first_addr.i.i.sroa.0, align 8
+ %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.12 = load ptr, ptr %__first_addr.i.i.sroa.0, align 8
+ %34 = getelementptr i32, ptr %__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.__first_addr.i.i.sroa.0.0.12, i32 1
+ store ptr %34, ptr %__first_addr.i.i.sroa.0, align 8
br label %bb26.i.i
bb26.i.i: ; preds = %bb25.i.i, %bb13.i.i
br label %_ZSt4findIN9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEEiET_S7_S7_RKT0_.exit
_ZSt4findIN9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEEiET_S7_S7_RKT0_.exit: ; preds = %bb26.i.i, %bb24.i.i, %bb20.i.i, %bb16.i.i, %bb10.i.i, %bb7.i.i, %bb4.i.i, %bb1.i.i
- %.in.in = phi i32** [ %__last_addr.i.i.sroa.0, %bb26.i.i ], [ %__first_addr.i.i.sroa.0, %bb24.i.i ], [ %__first_addr.i.i.sroa.0, %bb20.i.i ], [ %__first_addr.i.i.sroa.0, %bb16.i.i ], [ %__first_addr.i.i.sroa.0, %bb10.i.i ], [ %__first_addr.i.i.sroa.0, %bb7.i.i ], [ %__first_addr.i.i.sroa.0, %bb4.i.i ], [ %__first_addr.i.i.sroa.0, %bb1.i.i ]
+ %.in.in = phi ptr [ %__last_addr.i.i.sroa.0, %bb26.i.i ], [ %__first_addr.i.i.sroa.0, %bb24.i.i ], [ %__first_addr.i.i.sroa.0, %bb20.i.i ], [ %__first_addr.i.i.sroa.0, %bb16.i.i ], [ %__first_addr.i.i.sroa.0, %bb10.i.i ], [ %__first_addr.i.i.sroa.0, %bb7.i.i ], [ %__first_addr.i.i.sroa.0, %bb4.i.i ], [ %__first_addr.i.i.sroa.0, %bb1.i.i ]
br label %return
return: ; preds = %_ZSt4findIN9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEEiET_S7_S7_RKT0_.exit
- %35 = load i32*, i32** %.in.in, align 4
- ret i32* %35
+ %35 = load ptr, ptr %.in.in, align 4
+ ret ptr %35
}
; Function Attrs: argmemonly nofree nosync nounwind willreturn
-declare void @llvm.memcpy.p0i8.p0i8.i64(i8* noalias nocapture writeonly, i8* noalias nocapture readonly, i64, i1 immarg) #0
+declare void @llvm.memcpy.p0.p0.i64(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i64, i1 immarg) #0
attributes #0 = { argmemonly nofree nosync nounwind willreturn }
diff --git a/llvm/test/Transforms/SROA/address-spaces.ll b/llvm/test/Transforms/SROA/address-spaces.ll
index 520b162116d7..d899c3443768 100644
--- a/llvm/test/Transforms/SROA/address-spaces.ll
+++ b/llvm/test/Transforms/SROA/address-spaces.ll
@@ -2,93 +2,77 @@
; RUN: opt < %s -passes=sroa -S | FileCheck %s
target datalayout = "e-p:64:64:64-p1:16:16:16-p3:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
-declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture readonly, i32, i1)
-declare void @llvm.memcpy.p1i8.p0i8.i32(i8 addrspace(1)* nocapture, i8* nocapture readonly, i32, i1)
-declare void @llvm.memcpy.p0i8.p1i8.i32(i8* nocapture, i8 addrspace(1)* nocapture readonly, i32, i1)
-declare void @llvm.memcpy.p1i8.p1i8.i32(i8 addrspace(1)* nocapture, i8 addrspace(1)* nocapture readonly, i32, i1)
+declare void @llvm.memcpy.p0.p0.i32(ptr nocapture, ptr nocapture readonly, i32, i1)
+declare void @llvm.memcpy.p1.p0.i32(ptr addrspace(1) nocapture, ptr nocapture readonly, i32, i1)
+declare void @llvm.memcpy.p0.p1.i32(ptr nocapture, ptr addrspace(1) nocapture readonly, i32, i1)
+declare void @llvm.memcpy.p1.p1.i32(ptr addrspace(1) nocapture, ptr addrspace(1) nocapture readonly, i32, i1)
; Make sure an illegal bitcast isn't introduced
-define void @test_address_space_1_1(<2 x i64> addrspace(1)* %a, i16 addrspace(1)* %b) {
+define void @test_address_space_1_1(ptr addrspace(1) %a, ptr addrspace(1) %b) {
; CHECK-LABEL: @test_address_space_1_1(
-; CHECK-NEXT: [[AA_0_COPYLOAD:%.*]] = load <2 x i64>, <2 x i64> addrspace(1)* [[A:%.*]], align 2
-; CHECK-NEXT: [[AA_0_BPTR_SROA_CAST:%.*]] = bitcast i16 addrspace(1)* [[B:%.*]] to <2 x i64> addrspace(1)*
-; CHECK-NEXT: store <2 x i64> [[AA_0_COPYLOAD]], <2 x i64> addrspace(1)* [[AA_0_BPTR_SROA_CAST]], align 2
+; CHECK-NEXT: [[AA_0_COPYLOAD:%.*]] = load <2 x i64>, ptr addrspace(1) [[A:%.*]], align 2
+; CHECK-NEXT: store <2 x i64> [[AA_0_COPYLOAD]], ptr addrspace(1) [[B:%.*]], align 2
; CHECK-NEXT: ret void
;
%aa = alloca <2 x i64>, align 16
- %aptr = bitcast <2 x i64> addrspace(1)* %a to i8 addrspace(1)*
- %aaptr = bitcast <2 x i64>* %aa to i8*
- call void @llvm.memcpy.p0i8.p1i8.i32(i8* align 2 %aaptr, i8 addrspace(1)* align 2 %aptr, i32 16, i1 false)
- %bptr = bitcast i16 addrspace(1)* %b to i8 addrspace(1)*
- call void @llvm.memcpy.p1i8.p0i8.i32(i8 addrspace(1)* align 2 %bptr, i8* align 2 %aaptr, i32 16, i1 false)
+ call void @llvm.memcpy.p0.p1.i32(ptr align 2 %aa, ptr addrspace(1) align 2 %a, i32 16, i1 false)
+ call void @llvm.memcpy.p1.p0.i32(ptr addrspace(1) align 2 %b, ptr align 2 %aa, i32 16, i1 false)
ret void
}
-define void @test_address_space_1_0(<2 x i64> addrspace(1)* %a, i16* %b) {
+define void @test_address_space_1_0(ptr addrspace(1) %a, ptr %b) {
; CHECK-LABEL: @test_address_space_1_0(
-; CHECK-NEXT: [[AA_0_COPYLOAD:%.*]] = load <2 x i64>, <2 x i64> addrspace(1)* [[A:%.*]], align 2
-; CHECK-NEXT: [[AA_0_BPTR_SROA_CAST:%.*]] = bitcast i16* [[B:%.*]] to <2 x i64>*
-; CHECK-NEXT: store <2 x i64> [[AA_0_COPYLOAD]], <2 x i64>* [[AA_0_BPTR_SROA_CAST]], align 2
+; CHECK-NEXT: [[AA_0_COPYLOAD:%.*]] = load <2 x i64>, ptr addrspace(1) [[A:%.*]], align 2
+; CHECK-NEXT: store <2 x i64> [[AA_0_COPYLOAD]], ptr [[B:%.*]], align 2
; CHECK-NEXT: ret void
;
%aa = alloca <2 x i64>, align 16
- %aptr = bitcast <2 x i64> addrspace(1)* %a to i8 addrspace(1)*
- %aaptr = bitcast <2 x i64>* %aa to i8*
- call void @llvm.memcpy.p0i8.p1i8.i32(i8* align 2 %aaptr, i8 addrspace(1)* align 2 %aptr, i32 16, i1 false)
- %bptr = bitcast i16* %b to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 2 %bptr, i8* align 2 %aaptr, i32 16, i1 false)
+ call void @llvm.memcpy.p0.p1.i32(ptr align 2 %aa, ptr addrspace(1) align 2 %a, i32 16, i1 false)
+ call void @llvm.memcpy.p0.p0.i32(ptr align 2 %b, ptr align 2 %aa, i32 16, i1 false)
ret void
}
-define void @test_address_space_0_1(<2 x i64>* %a, i16 addrspace(1)* %b) {
+define void @test_address_space_0_1(ptr %a, ptr addrspace(1) %b) {
; CHECK-LABEL: @test_address_space_0_1(
-; CHECK-NEXT: [[AA_0_COPYLOAD:%.*]] = load <2 x i64>, <2 x i64>* [[A:%.*]], align 2
-; CHECK-NEXT: [[AA_0_BPTR_SROA_CAST:%.*]] = bitcast i16 addrspace(1)* [[B:%.*]] to <2 x i64> addrspace(1)*
-; CHECK-NEXT: store <2 x i64> [[AA_0_COPYLOAD]], <2 x i64> addrspace(1)* [[AA_0_BPTR_SROA_CAST]], align 2
+; CHECK-NEXT: [[AA_0_COPYLOAD:%.*]] = load <2 x i64>, ptr [[A:%.*]], align 2
+; CHECK-NEXT: store <2 x i64> [[AA_0_COPYLOAD]], ptr addrspace(1) [[B:%.*]], align 2
; CHECK-NEXT: ret void
;
%aa = alloca <2 x i64>, align 16
- %aptr = bitcast <2 x i64>* %a to i8*
- %aaptr = bitcast <2 x i64>* %aa to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 2 %aaptr, i8* align 2 %aptr, i32 16, i1 false)
- %bptr = bitcast i16 addrspace(1)* %b to i8 addrspace(1)*
- call void @llvm.memcpy.p1i8.p0i8.i32(i8 addrspace(1)* align 2 %bptr, i8* align 2 %aaptr, i32 16, i1 false)
+ call void @llvm.memcpy.p0.p0.i32(ptr align 2 %aa, ptr align 2 %a, i32 16, i1 false)
+ call void @llvm.memcpy.p1.p0.i32(ptr addrspace(1) align 2 %b, ptr align 2 %aa, i32 16, i1 false)
ret void
}
%struct.struct_test_27.0.13 = type { i32, float, i64, i8, [4 x i32] }
-define void @copy_struct([5 x i64] %in.coerce, i8 addrspace(1)* align 4 %ptr) {
+define void @copy_struct([5 x i64] %in.coerce, ptr addrspace(1) align 4 %ptr) {
; CHECK-LABEL: @copy_struct(
; CHECK-NEXT: for.end:
; CHECK-NEXT: [[IN_COERCE_FCA_0_EXTRACT:%.*]] = extractvalue [5 x i64] [[IN_COERCE:%.*]], 0
; CHECK-NEXT: [[IN_COERCE_FCA_1_EXTRACT:%.*]] = extractvalue [5 x i64] [[IN_COERCE]], 1
; CHECK-NEXT: [[IN_COERCE_FCA_2_EXTRACT:%.*]] = extractvalue [5 x i64] [[IN_COERCE]], 2
; CHECK-NEXT: [[IN_COERCE_FCA_3_EXTRACT:%.*]] = extractvalue [5 x i64] [[IN_COERCE]], 3
-; CHECK-NEXT: [[IN_SROA_2_4_PTR_SROA_CAST:%.*]] = bitcast i8 addrspace(1)* [[PTR:%.*]] to i32 addrspace(1)*
; CHECK-NEXT: [[IN_SROA_2_4_EXTRACT_SHIFT:%.*]] = lshr i64 [[IN_COERCE_FCA_2_EXTRACT]], 32
; CHECK-NEXT: [[IN_SROA_2_4_EXTRACT_TRUNC:%.*]] = trunc i64 [[IN_SROA_2_4_EXTRACT_SHIFT]] to i32
-; CHECK-NEXT: store i32 [[IN_SROA_2_4_EXTRACT_TRUNC]], i32 addrspace(1)* [[IN_SROA_2_4_PTR_SROA_CAST]], align 4
-; CHECK-NEXT: [[IN_SROA_4_20_PTR_SROA_IDX:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[PTR]], i16 4
-; CHECK-NEXT: [[IN_SROA_4_20_PTR_SROA_CAST:%.*]] = bitcast i8 addrspace(1)* [[IN_SROA_4_20_PTR_SROA_IDX]] to i64 addrspace(1)*
-; CHECK-NEXT: store i64 [[IN_COERCE_FCA_3_EXTRACT]], i64 addrspace(1)* [[IN_SROA_4_20_PTR_SROA_CAST]], align 4
-; CHECK-NEXT: [[IN_SROA_5_20_PTR_SROA_IDX:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[PTR]], i16 12
-; CHECK-NEXT: [[IN_SROA_5_20_PTR_SROA_CAST:%.*]] = bitcast i8 addrspace(1)* [[IN_SROA_5_20_PTR_SROA_IDX]] to i32 addrspace(1)*
-; CHECK-NEXT: store i32 undef, i32 addrspace(1)* [[IN_SROA_5_20_PTR_SROA_CAST]], align 4
+; CHECK-NEXT: store i32 [[IN_SROA_2_4_EXTRACT_TRUNC]], ptr addrspace(1) [[PTR:%.*]], align 4
+; CHECK-NEXT: [[IN_SROA_4_20_PTR_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr addrspace(1) [[PTR]], i16 4
+; CHECK-NEXT: store i64 [[IN_COERCE_FCA_3_EXTRACT]], ptr addrspace(1) [[IN_SROA_4_20_PTR_SROA_IDX]], align 4
+; CHECK-NEXT: [[IN_SROA_5_20_PTR_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr addrspace(1) [[PTR]], i16 12
+; CHECK-NEXT: store i32 undef, ptr addrspace(1) [[IN_SROA_5_20_PTR_SROA_IDX]], align 4
; CHECK-NEXT: ret void
;
for.end:
%in = alloca %struct.struct_test_27.0.13, align 8
- %0 = bitcast %struct.struct_test_27.0.13* %in to [5 x i64]*
- store [5 x i64] %in.coerce, [5 x i64]* %0, align 8
- %scevgep9 = getelementptr %struct.struct_test_27.0.13, %struct.struct_test_27.0.13* %in, i32 0, i32 4, i32 0
- %scevgep910 = bitcast i32* %scevgep9 to i8*
- call void @llvm.memcpy.p1i8.p0i8.i32(i8 addrspace(1)* align 4 %ptr, i8* align 4 %scevgep910, i32 16, i1 false)
+ %0 = bitcast ptr %in to ptr
+ store [5 x i64] %in.coerce, ptr %0, align 8
+ %scevgep9 = getelementptr %struct.struct_test_27.0.13, ptr %in, i32 0, i32 4, i32 0
+ call void @llvm.memcpy.p1.p0.i32(ptr addrspace(1) align 4 %ptr, ptr align 4 %scevgep9, i32 16, i1 false)
ret void
}
-%union.anon = type { i32* }
+%union.anon = type { ptr }
@g = common global i32 0, align 4
@l = common addrspace(3) global i32 0, align 4
@@ -97,17 +81,16 @@ for.end:
; illegal bitcast isn't introduced
define void @pr27557() {
; CHECK-LABEL: @pr27557(
-; CHECK-NEXT: [[DOTSROA_0:%.*]] = alloca i32*, align 8
-; CHECK-NEXT: store i32* @g, i32** [[DOTSROA_0]], align 8
-; CHECK-NEXT: [[DOTSROA_0_0__SROA_CAST1:%.*]] = bitcast i32** [[DOTSROA_0]] to i32 addrspace(3)**
-; CHECK-NEXT: store i32 addrspace(3)* @l, i32 addrspace(3)** [[DOTSROA_0_0__SROA_CAST1]], align 8
+; CHECK-NEXT: [[DOTSROA_0:%.*]] = alloca ptr, align 8
+; CHECK-NEXT: store ptr @g, ptr [[DOTSROA_0]], align 8
+; CHECK-NEXT: store ptr addrspace(3) @l, ptr [[DOTSROA_0]], align 8
; CHECK-NEXT: ret void
;
%1 = alloca %union.anon, align 8
- %2 = bitcast %union.anon* %1 to i32**
- store i32* @g, i32** %2, align 8
- %3 = bitcast %union.anon* %1 to i32 addrspace(3)**
- store i32 addrspace(3)* @l, i32 addrspace(3)** %3, align 8
+ %2 = bitcast ptr %1 to ptr
+ store ptr @g, ptr %2, align 8
+ %3 = bitcast ptr %1 to ptr
+ store ptr addrspace(3) @l, ptr %3, align 8
ret void
}
@@ -115,82 +98,67 @@ define void @pr27557() {
; If pointers from
diff erent address spaces have the same size, that pointer
; should be promoted through the pair of `ptrtoint`/`inttoptr`.
-define i32* @pr27557.alt() {
+define ptr @pr27557.alt() {
; CHECK-LABEL: @pr27557.alt(
-; CHECK-NEXT: ret i32* inttoptr (i64 ptrtoint (i32 addrspace(2)* @l2 to i64) to i32*)
+; CHECK-NEXT: ret ptr inttoptr (i64 ptrtoint (ptr addrspace(2) @l2 to i64) to ptr)
;
%1 = alloca %union.anon, align 8
- %2 = bitcast %union.anon* %1 to i32 addrspace(2)**
- store i32 addrspace(2)* @l2, i32 addrspace(2)** %2, align 8
- %3 = bitcast %union.anon* %1 to i32**
- %4 = load i32*, i32** %3, align 8
- ret i32* %4
+ %2 = bitcast ptr %1 to ptr
+ store ptr addrspace(2) @l2, ptr %2, align 8
+ %3 = bitcast ptr %1 to ptr
+ %4 = load ptr, ptr %3, align 8
+ ret ptr %4
}
; Make sure pre-splitting doesn't try to introduce an illegal bitcast
-define float @presplit(i64 addrspace(1)* %p) {
+define float @presplit(ptr addrspace(1) %p) {
; CHECK-LABEL: @presplit(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[P_SROA_CAST:%.*]] = bitcast i64 addrspace(1)* [[P:%.*]] to i32 addrspace(1)*
-; CHECK-NEXT: [[L1:%.*]] = load i32, i32 addrspace(1)* [[P_SROA_CAST]], align 4
-; CHECK-NEXT: [[P_SROA_RAW_CAST:%.*]] = bitcast i64 addrspace(1)* [[P]] to i8 addrspace(1)*
-; CHECK-NEXT: [[P_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[P_SROA_RAW_CAST]], i16 4
-; CHECK-NEXT: [[P_SROA_CAST2:%.*]] = bitcast i8 addrspace(1)* [[P_SROA_RAW_IDX]] to i32 addrspace(1)*
-; CHECK-NEXT: [[L3:%.*]] = load i32, i32 addrspace(1)* [[P_SROA_CAST2]], align 4
+; CHECK-NEXT: [[L1:%.*]] = load i32, ptr addrspace(1) [[P:%.*]], align 4
+; CHECK-NEXT: [[P_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr addrspace(1) [[P]], i16 4
+; CHECK-NEXT: [[L2:%.*]] = load i32, ptr addrspace(1) [[P_SROA_IDX]], align 4
; CHECK-NEXT: [[TMP0:%.*]] = bitcast i32 [[L1]] to float
-; CHECK-NEXT: [[TMP1:%.*]] = bitcast i32 [[L3]] to float
+; CHECK-NEXT: [[TMP1:%.*]] = bitcast i32 [[L2]] to float
; CHECK-NEXT: [[RET:%.*]] = fadd float [[TMP0]], [[TMP1]]
; CHECK-NEXT: ret float [[RET]]
;
entry:
%b = alloca i64
- %b.cast = bitcast i64* %b to [2 x float]*
- %b.gep1 = getelementptr [2 x float], [2 x float]* %b.cast, i32 0, i32 0
- %b.gep2 = getelementptr [2 x float], [2 x float]* %b.cast, i32 0, i32 1
- %l = load i64, i64 addrspace(1)* %p
- store i64 %l, i64* %b
- %f1 = load float, float* %b.gep1
- %f2 = load float, float* %b.gep2
+ %b.gep2 = getelementptr [2 x float], ptr %b, i32 0, i32 1
+ %l = load i64, ptr addrspace(1) %p
+ store i64 %l, ptr %b
+ %f1 = load float, ptr %b
+ %f2 = load float, ptr %b.gep2
%ret = fadd float %f1, %f2
ret float %ret
}
; Test load from and store to non-zero address space.
-define void @test_load_store_
diff _addr_space([2 x float] addrspace(1)* %complex1, [2 x float] addrspace(1)* %complex2) {
+define void @test_load_store_
diff _addr_space(ptr addrspace(1) %complex1, ptr addrspace(1) %complex2) {
; CHECK-LABEL: @test_load_store_
diff _addr_space(
-; CHECK-NEXT: [[P1_SROA_CAST:%.*]] = bitcast [2 x float] addrspace(1)* [[COMPLEX1:%.*]] to i32 addrspace(1)*
-; CHECK-NEXT: [[V15:%.*]] = load i32, i32 addrspace(1)* [[P1_SROA_CAST]], align 4
-; CHECK-NEXT: [[P1_SROA_IDX:%.*]] = getelementptr inbounds [2 x float], [2 x float] addrspace(1)* [[COMPLEX1]], i16 0, i16 1
-; CHECK-NEXT: [[P1_SROA_CAST7:%.*]] = bitcast float addrspace(1)* [[P1_SROA_IDX]] to i32 addrspace(1)*
-; CHECK-NEXT: [[V18:%.*]] = load i32, i32 addrspace(1)* [[P1_SROA_CAST7]], align 4
-; CHECK-NEXT: [[TMP1:%.*]] = bitcast i32 [[V15]] to float
-; CHECK-NEXT: [[TMP2:%.*]] = bitcast i32 [[V18]] to float
+; CHECK-NEXT: [[V13:%.*]] = load i32, ptr addrspace(1) [[COMPLEX1:%.*]], align 4
+; CHECK-NEXT: [[COMPLEX1_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr addrspace(1) [[COMPLEX1]], i16 4
+; CHECK-NEXT: [[V14:%.*]] = load i32, ptr addrspace(1) [[COMPLEX1_SROA_IDX]], align 4
+; CHECK-NEXT: [[TMP1:%.*]] = bitcast i32 [[V13]] to float
+; CHECK-NEXT: [[TMP2:%.*]] = bitcast i32 [[V14]] to float
; CHECK-NEXT: [[SUM:%.*]] = fadd float [[TMP1]], [[TMP2]]
; CHECK-NEXT: [[TMP3:%.*]] = bitcast float [[SUM]] to i32
; CHECK-NEXT: [[TMP4:%.*]] = bitcast float [[SUM]] to i32
-; CHECK-NEXT: [[P2_SROA_CAST:%.*]] = bitcast [2 x float] addrspace(1)* [[COMPLEX2:%.*]] to i32 addrspace(1)*
-; CHECK-NEXT: store i32 [[TMP3]], i32 addrspace(1)* [[P2_SROA_CAST]], align 4
-; CHECK-NEXT: [[P2_SROA_IDX:%.*]] = getelementptr inbounds [2 x float], [2 x float] addrspace(1)* [[COMPLEX2]], i16 0, i16 1
-; CHECK-NEXT: [[P2_SROA_CAST4:%.*]] = bitcast float addrspace(1)* [[P2_SROA_IDX]] to i32 addrspace(1)*
-; CHECK-NEXT: store i32 [[TMP4]], i32 addrspace(1)* [[P2_SROA_CAST4]], align 4
+; CHECK-NEXT: store i32 [[TMP3]], ptr addrspace(1) [[COMPLEX2:%.*]], align 4
+; CHECK-NEXT: [[COMPLEX2_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr addrspace(1) [[COMPLEX2]], i16 4
+; CHECK-NEXT: store i32 [[TMP4]], ptr addrspace(1) [[COMPLEX2_SROA_IDX]], align 4
; CHECK-NEXT: ret void
;
%a = alloca i64
- %a.cast = bitcast i64* %a to [2 x float]*
- %a.gep1 = getelementptr [2 x float], [2 x float]* %a.cast, i32 0, i32 0
- %a.gep2 = getelementptr [2 x float], [2 x float]* %a.cast, i32 0, i32 1
- %complex1.gep = getelementptr [2 x float], [2 x float] addrspace(1)* %complex1, i32 0, i32 0
- %p1 = bitcast float addrspace(1)* %complex1.gep to i64 addrspace(1)*
- %v1 = load i64, i64 addrspace(1)* %p1
- store i64 %v1, i64* %a
- %f1 = load float, float* %a.gep1
- %f2 = load float, float* %a.gep2
+ %a.gep2 = getelementptr [2 x float], ptr %a, i32 0, i32 1
+ %v1 = load i64, ptr addrspace(1) %complex1
+ store i64 %v1, ptr %a
+ %f1 = load float, ptr %a
+ %f2 = load float, ptr %a.gep2
%sum = fadd float %f1, %f2
- store float %sum, float* %a.gep1
- store float %sum, float* %a.gep2
- %v2 = load i64, i64* %a
- %complex2.gep = getelementptr [2 x float], [2 x float] addrspace(1)* %complex2, i32 0, i32 0
- %p2 = bitcast float addrspace(1)* %complex2.gep to i64 addrspace(1)*
- store i64 %v2, i64 addrspace(1)* %p2
+ store float %sum, ptr %a
+ store float %sum, ptr %a.gep2
+ %v2 = load i64, ptr %a
+ store i64 %v2, ptr addrspace(1) %complex2
ret void
}
diff --git a/llvm/test/Transforms/SROA/addrspacecast.ll b/llvm/test/Transforms/SROA/addrspacecast.ll
index aed08f8ebe56..a5a325769564 100644
--- a/llvm/test/Transforms/SROA/addrspacecast.ll
+++ b/llvm/test/Transforms/SROA/addrspacecast.ll
@@ -3,8 +3,8 @@
target datalayout = "e-p:64:64:64-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
-declare void @llvm.memcpy.p0i8.p1i8.i32(i8* nocapture writeonly, i8 addrspace(1)* nocapture readonly, i32, i1 immarg) #0
-declare void @llvm.memcpy.p1i8.p0i8.i32(i8 addrspace(1)* nocapture writeonly, i8* nocapture readonly, i32, i1 immarg) #0
+declare void @llvm.memcpy.p0.p1.i32(ptr nocapture writeonly, ptr addrspace(1) nocapture readonly, i32, i1 immarg) #0
+declare void @llvm.memcpy.p1.p0.i32(ptr addrspace(1) nocapture writeonly, ptr nocapture readonly, i32, i1 immarg) #0
define i64 @alloca_addrspacecast_bitcast(i64 %X) {
; CHECK-LABEL: @alloca_addrspacecast_bitcast(
@@ -13,10 +13,9 @@ define i64 @alloca_addrspacecast_bitcast(i64 %X) {
;
entry:
%A = alloca [8 x i8]
- %A.cast = addrspacecast [8 x i8]* %A to [8 x i8] addrspace(1)*
- %B = bitcast [8 x i8] addrspace(1)* %A.cast to i64 addrspace(1)*
- store i64 %X, i64 addrspace(1)* %B
- %Z = load i64, i64 addrspace(1)* %B
+ %A.cast = addrspacecast ptr %A to ptr addrspace(1)
+ store i64 %X, ptr addrspace(1) %A.cast
+ %Z = load i64, ptr addrspace(1) %A.cast
ret i64 %Z
}
@@ -27,10 +26,9 @@ define i64 @alloca_bitcast_addrspacecast(i64 %X) {
;
entry:
%A = alloca [8 x i8]
- %A.cast = bitcast [8 x i8]* %A to i64*
- %B = addrspacecast i64* %A.cast to i64 addrspace(1)*
- store i64 %X, i64 addrspace(1)* %B
- %Z = load i64, i64 addrspace(1)* %B
+ %B = addrspacecast ptr %A to ptr addrspace(1)
+ store i64 %X, ptr addrspace(1) %B
+ %Z = load i64, ptr addrspace(1) %B
ret i64 %Z
}
@@ -42,14 +40,12 @@ define i64 @alloca_addrspacecast_gep(i64 %X) {
entry:
%A.as0 = alloca [256 x i8], align 4
- %gepA.as0 = getelementptr [256 x i8], [256 x i8]* %A.as0, i16 0, i16 32
- %gepA.as0.bc = bitcast i8* %gepA.as0 to i64*
- store i64 %X, i64* %gepA.as0.bc, align 4
+ %gepA.as0 = getelementptr [256 x i8], ptr %A.as0, i16 0, i16 32
+ store i64 %X, ptr %gepA.as0, align 4
- %A.as1 = addrspacecast [256 x i8]* %A.as0 to [256 x i8] addrspace(1)*
- %gepA.as1 = getelementptr [256 x i8], [256 x i8] addrspace(1)* %A.as1, i16 0, i16 32
- %gepA.as1.bc = bitcast i8 addrspace(1)* %gepA.as1 to i64 addrspace(1)*
- %Z = load i64, i64 addrspace(1)* %gepA.as1.bc, align 4
+ %A.as1 = addrspacecast ptr %A.as0 to ptr addrspace(1)
+ %gepA.as1 = getelementptr [256 x i8], ptr addrspace(1) %A.as1, i16 0, i16 32
+ %Z = load i64, ptr addrspace(1) %gepA.as1, align 4
ret i64 %Z
}
@@ -62,12 +58,11 @@ define i64 @alloca_gep_addrspacecast(i64 %X) {
entry:
%A.as0 = alloca [256 x i8], align 4
- %gepA.as0 = getelementptr [256 x i8], [256 x i8]* %A.as0, i16 0, i16 32
- %gepA.as0.bc = bitcast i8* %gepA.as0 to i64*
- store i64 %X, i64* %gepA.as0.bc, align 4
+ %gepA.as0 = getelementptr [256 x i8], ptr %A.as0, i16 0, i16 32
+ store i64 %X, ptr %gepA.as0, align 4
- %gepA.as1.bc = addrspacecast i64* %gepA.as0.bc to i64 addrspace(1)*
- %Z = load i64, i64 addrspace(1)* %gepA.as1.bc, align 4
+ %gepA.as1.bc = addrspacecast ptr %gepA.as0 to ptr addrspace(1)
+ %Z = load i64, ptr addrspace(1) %gepA.as1.bc, align 4
ret i64 %Z
}
@@ -79,91 +74,74 @@ define i64 @alloca_gep_addrspacecast_gep(i64 %X) {
entry:
%A.as0 = alloca [256 x i8], align 4
- %gepA.as0 = getelementptr [256 x i8], [256 x i8]* %A.as0, i16 0, i16 32
- %gepA.as0.bc = bitcast i8* %gepA.as0 to i64*
- store i64 %X, i64* %gepA.as0.bc, align 4
+ %gepA.as0 = getelementptr [256 x i8], ptr %A.as0, i16 0, i16 32
+ store i64 %X, ptr %gepA.as0, align 4
- %gepB.as0 = getelementptr [256 x i8], [256 x i8]* %A.as0, i16 0, i16 16
- %gepB.as1 = addrspacecast i8* %gepB.as0 to i8 addrspace(1)*
- %gepC.as1 = getelementptr i8, i8 addrspace(1)* %gepB.as1, i16 16
- %gepC.as1.bc = bitcast i8 addrspace(1)* %gepC.as1 to i64 addrspace(1)*
- %Z = load i64, i64 addrspace(1)* %gepC.as1.bc, align 4
+ %gepB.as0 = getelementptr [256 x i8], ptr %A.as0, i16 0, i16 16
+ %gepB.as1 = addrspacecast ptr %gepB.as0 to ptr addrspace(1)
+ %gepC.as1 = getelementptr i8, ptr addrspace(1) %gepB.as1, i16 16
+ %Z = load i64, ptr addrspace(1) %gepC.as1, align 4
ret i64 %Z
}
-define i64 @getAdjustedPtr_addrspacecast_gep([32 x i8]* %x) {
+define i64 @getAdjustedPtr_addrspacecast_gep(ptr %x) {
; CHECK-LABEL: @getAdjustedPtr_addrspacecast_gep(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[CAST1:%.*]] = addrspacecast [32 x i8]* [[X:%.*]] to i8 addrspace(1)*
-; CHECK-NEXT: [[A_SROA_0_0_CAST1_SROA_CAST:%.*]] = bitcast i8 addrspace(1)* [[CAST1]] to i64 addrspace(1)*
-; CHECK-NEXT: [[A_SROA_0_0_COPYLOAD:%.*]] = load i64, i64 addrspace(1)* [[A_SROA_0_0_CAST1_SROA_CAST]], align 1
-; CHECK-NEXT: [[A_SROA_2_0_CAST1_SROA_IDX:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[CAST1]], i16 8
-; CHECK-NEXT: [[A_SROA_2_0_CAST1_SROA_CAST:%.*]] = bitcast i8 addrspace(1)* [[A_SROA_2_0_CAST1_SROA_IDX]] to i64 addrspace(1)*
-; CHECK-NEXT: [[A_SROA_2_0_COPYLOAD:%.*]] = load i64, i64 addrspace(1)* [[A_SROA_2_0_CAST1_SROA_CAST]], align 1
+; CHECK-NEXT: [[CAST1:%.*]] = addrspacecast ptr [[X:%.*]] to ptr addrspace(1)
+; CHECK-NEXT: [[A_SROA_0_0_COPYLOAD:%.*]] = load i64, ptr addrspace(1) [[CAST1]], align 1
+; CHECK-NEXT: [[A_SROA_2_0_CAST1_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr addrspace(1) [[CAST1]], i16 8
+; CHECK-NEXT: [[A_SROA_2_0_COPYLOAD:%.*]] = load i64, ptr addrspace(1) [[A_SROA_2_0_CAST1_SROA_IDX]], align 1
; CHECK-NEXT: ret i64 [[A_SROA_0_0_COPYLOAD]]
;
entry:
%a = alloca [32 x i8], align 8
- %cast1 = addrspacecast [32 x i8]* %x to i8 addrspace(1)*
- %cast2 = bitcast [32 x i8]* %a to i8*
- call void @llvm.memcpy.p0i8.p1i8.i32(i8* %cast2, i8 addrspace(1)* %cast1, i32 16, i1 false)
- %gep = getelementptr [32 x i8], [32 x i8]* %a, i32 0
- %gep.bitcast = bitcast [32 x i8]* %gep to i64*
- %val = load i64, i64* %gep.bitcast
+ %cast1 = addrspacecast ptr %x to ptr addrspace(1)
+ call void @llvm.memcpy.p0.p1.i32(ptr %a, ptr addrspace(1) %cast1, i32 16, i1 false)
+ %val = load i64, ptr %a
ret i64 %val
}
-define i64 @getAdjustedPtr_gep_addrspacecast([32 x i8]* %x) {
+define i64 @getAdjustedPtr_gep_addrspacecast(ptr %x) {
; CHECK-LABEL: @getAdjustedPtr_gep_addrspacecast(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[GEP_X:%.*]] = getelementptr [32 x i8], [32 x i8]* [[X:%.*]], i32 0, i32 16
-; CHECK-NEXT: [[CAST1:%.*]] = addrspacecast i8* [[GEP_X]] to i8 addrspace(1)*
-; CHECK-NEXT: [[A_SROA_0_0_CAST1_SROA_CAST:%.*]] = bitcast i8 addrspace(1)* [[CAST1]] to i64 addrspace(1)*
-; CHECK-NEXT: [[A_SROA_0_0_COPYLOAD:%.*]] = load i64, i64 addrspace(1)* [[A_SROA_0_0_CAST1_SROA_CAST]], align 1
-; CHECK-NEXT: [[A_SROA_2_0_CAST1_SROA_IDX:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[CAST1]], i16 8
-; CHECK-NEXT: [[A_SROA_2_0_CAST1_SROA_CAST:%.*]] = bitcast i8 addrspace(1)* [[A_SROA_2_0_CAST1_SROA_IDX]] to i64 addrspace(1)*
-; CHECK-NEXT: [[A_SROA_2_0_COPYLOAD:%.*]] = load i64, i64 addrspace(1)* [[A_SROA_2_0_CAST1_SROA_CAST]], align 1
+; CHECK-NEXT: [[GEP_X:%.*]] = getelementptr [32 x i8], ptr [[X:%.*]], i32 0, i32 16
+; CHECK-NEXT: [[CAST1:%.*]] = addrspacecast ptr [[GEP_X]] to ptr addrspace(1)
+; CHECK-NEXT: [[A_SROA_0_0_COPYLOAD:%.*]] = load i64, ptr addrspace(1) [[CAST1]], align 1
+; CHECK-NEXT: [[A_SROA_2_0_CAST1_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr addrspace(1) [[CAST1]], i16 8
+; CHECK-NEXT: [[A_SROA_2_0_COPYLOAD:%.*]] = load i64, ptr addrspace(1) [[A_SROA_2_0_CAST1_SROA_IDX]], align 1
; CHECK-NEXT: ret i64 [[A_SROA_0_0_COPYLOAD]]
;
entry:
%a = alloca [32 x i8], align 8
- %gep.x = getelementptr [32 x i8], [32 x i8]* %x, i32 0, i32 16
- %cast1 = addrspacecast i8* %gep.x to i8 addrspace(1)*
-
- %cast2 = bitcast [32 x i8]* %a to i8*
- call void @llvm.memcpy.p0i8.p1i8.i32(i8* %cast2, i8 addrspace(1)* %cast1, i32 16, i1 false)
- %gep = getelementptr [32 x i8], [32 x i8]* %a, i32 0
- %gep.bitcast = bitcast [32 x i8]* %gep to i64*
- %val = load i64, i64* %gep.bitcast
+ %gep.x = getelementptr [32 x i8], ptr %x, i32 0, i32 16
+ %cast1 = addrspacecast ptr %gep.x to ptr addrspace(1)
+
+ call void @llvm.memcpy.p0.p1.i32(ptr %a, ptr addrspace(1) %cast1, i32 16, i1 false)
+ %val = load i64, ptr %a
ret i64 %val
}
-define i64 @getAdjustedPtr_gep_addrspacecast_gep([32 x i8]* %x) {
+define i64 @getAdjustedPtr_gep_addrspacecast_gep(ptr %x) {
; CHECK-LABEL: @getAdjustedPtr_gep_addrspacecast_gep(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[GEP0_X:%.*]] = getelementptr [32 x i8], [32 x i8]* [[X:%.*]], i32 0, i32 8
-; CHECK-NEXT: [[CAST1:%.*]] = addrspacecast i8* [[GEP0_X]] to i8 addrspace(1)*
-; CHECK-NEXT: [[A_SROA_0_0_GEP1_X_SROA_IDX:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[CAST1]], i16 8
-; CHECK-NEXT: [[A_SROA_0_0_GEP1_X_SROA_CAST:%.*]] = bitcast i8 addrspace(1)* [[A_SROA_0_0_GEP1_X_SROA_IDX]] to i64 addrspace(1)*
-; CHECK-NEXT: [[A_SROA_0_0_COPYLOAD:%.*]] = load i64, i64 addrspace(1)* [[A_SROA_0_0_GEP1_X_SROA_CAST]], align 1
-; CHECK-NEXT: [[A_SROA_2_0_GEP1_X_SROA_IDX:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[CAST1]], i16 16
-; CHECK-NEXT: [[A_SROA_2_0_GEP1_X_SROA_CAST:%.*]] = bitcast i8 addrspace(1)* [[A_SROA_2_0_GEP1_X_SROA_IDX]] to i64 addrspace(1)*
-; CHECK-NEXT: [[A_SROA_2_0_COPYLOAD:%.*]] = load i64, i64 addrspace(1)* [[A_SROA_2_0_GEP1_X_SROA_CAST]], align 1
+; CHECK-NEXT: [[GEP0_X:%.*]] = getelementptr [32 x i8], ptr [[X:%.*]], i32 0, i32 8
+; CHECK-NEXT: [[CAST1:%.*]] = addrspacecast ptr [[GEP0_X]] to ptr addrspace(1)
+; CHECK-NEXT: [[GEP1_X:%.*]] = getelementptr i8, ptr addrspace(1) [[CAST1]], i32 8
+; CHECK-NEXT: [[A_SROA_0_0_COPYLOAD:%.*]] = load i64, ptr addrspace(1) [[GEP1_X]], align 1
+; CHECK-NEXT: [[A_SROA_2_0_GEP1_X_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr addrspace(1) [[GEP1_X]], i16 8
+; CHECK-NEXT: [[A_SROA_2_0_COPYLOAD:%.*]] = load i64, ptr addrspace(1) [[A_SROA_2_0_GEP1_X_SROA_IDX]], align 1
; CHECK-NEXT: ret i64 [[A_SROA_0_0_COPYLOAD]]
;
entry:
%a = alloca [32 x i8], align 8
- %gep0.x = getelementptr [32 x i8], [32 x i8]* %x, i32 0, i32 8
- %cast1 = addrspacecast i8* %gep0.x to i8 addrspace(1)*
- %gep1.x = getelementptr i8, i8 addrspace(1)* %cast1, i32 8
-
- %cast2 = bitcast [32 x i8]* %a to i8*
- call void @llvm.memcpy.p0i8.p1i8.i32(i8* %cast2, i8 addrspace(1)* %gep1.x, i32 16, i1 false)
- %gep = getelementptr [32 x i8], [32 x i8]* %a, i32 0
- %gep.bitcast = bitcast [32 x i8]* %gep to i64*
- %val = load i64, i64* %gep.bitcast
+ %gep0.x = getelementptr [32 x i8], ptr %x, i32 0, i32 8
+ %cast1 = addrspacecast ptr %gep0.x to ptr addrspace(1)
+ %gep1.x = getelementptr i8, ptr addrspace(1) %cast1, i32 8
+
+ call void @llvm.memcpy.p0.p1.i32(ptr %a, ptr addrspace(1) %gep1.x, i32 16, i1 false)
+ %val = load i64, ptr %a
ret i64 %val
}
@@ -172,18 +150,16 @@ define i64 @alloca_addrspacecast_bitcast_volatile_store(i64 %X) {
; CHECK-LABEL: @alloca_addrspacecast_bitcast_volatile_store(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca [8 x i8], align 1
-; CHECK-NEXT: [[A_CAST:%.*]] = addrspacecast [8 x i8]* [[A]] to [8 x i8] addrspace(1)*
-; CHECK-NEXT: [[B:%.*]] = bitcast [8 x i8] addrspace(1)* [[A_CAST]] to i64 addrspace(1)*
-; CHECK-NEXT: store volatile i64 [[X:%.*]], i64 addrspace(1)* [[B]], align 4
-; CHECK-NEXT: [[Z:%.*]] = load i64, i64 addrspace(1)* [[B]], align 4
+; CHECK-NEXT: [[A_CAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(1)
+; CHECK-NEXT: store volatile i64 [[X:%.*]], ptr addrspace(1) [[A_CAST]], align 4
+; CHECK-NEXT: [[Z:%.*]] = load i64, ptr addrspace(1) [[A_CAST]], align 4
; CHECK-NEXT: ret i64 [[Z]]
;
entry:
%A = alloca [8 x i8]
- %A.cast = addrspacecast [8 x i8]* %A to [8 x i8] addrspace(1)*
- %B = bitcast [8 x i8] addrspace(1)* %A.cast to i64 addrspace(1)*
- store volatile i64 %X, i64 addrspace(1)* %B
- %Z = load i64, i64 addrspace(1)* %B
+ %A.cast = addrspacecast ptr %A to ptr addrspace(1)
+ store volatile i64 %X, ptr addrspace(1) %A.cast
+ %Z = load i64, ptr addrspace(1) %A.cast
ret i64 %Z
}
@@ -192,62 +168,54 @@ define i64 @alloca_addrspacecast_bitcast_volatile_load(i64 %X) {
; CHECK-LABEL: @alloca_addrspacecast_bitcast_volatile_load(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca [8 x i8], align 1
-; CHECK-NEXT: [[A_CAST:%.*]] = addrspacecast [8 x i8]* [[A]] to [8 x i8] addrspace(1)*
-; CHECK-NEXT: [[B:%.*]] = bitcast [8 x i8] addrspace(1)* [[A_CAST]] to i64 addrspace(1)*
-; CHECK-NEXT: store i64 [[X:%.*]], i64 addrspace(1)* [[B]], align 4
-; CHECK-NEXT: [[Z:%.*]] = load volatile i64, i64 addrspace(1)* [[B]], align 4
+; CHECK-NEXT: [[A_CAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(1)
+; CHECK-NEXT: store i64 [[X:%.*]], ptr addrspace(1) [[A_CAST]], align 4
+; CHECK-NEXT: [[Z:%.*]] = load volatile i64, ptr addrspace(1) [[A_CAST]], align 4
; CHECK-NEXT: ret i64 [[Z]]
;
entry:
%A = alloca [8 x i8]
- %A.cast = addrspacecast [8 x i8]* %A to [8 x i8] addrspace(1)*
- %B = bitcast [8 x i8] addrspace(1)* %A.cast to i64 addrspace(1)*
- store i64 %X, i64 addrspace(1)* %B
- %Z = load volatile i64, i64 addrspace(1)* %B
+ %A.cast = addrspacecast ptr %A to ptr addrspace(1)
+ store i64 %X, ptr addrspace(1) %A.cast
+ %Z = load volatile i64, ptr addrspace(1) %A.cast
ret i64 %Z
}
-declare void @llvm.memset.p1i8.i32(i8 addrspace(1)* nocapture, i8, i32, i1) nounwind
+declare void @llvm.memset.p1.i32(ptr addrspace(1) nocapture, i8, i32, i1) nounwind
; Don't change the address space of a volatile operation
define i32 @volatile_memset() {
; CHECK-LABEL: @volatile_memset(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca [4 x i8], align 1
-; CHECK-NEXT: [[PTR:%.*]] = getelementptr [4 x i8], [4 x i8]* [[A]], i32 0, i32 0
-; CHECK-NEXT: [[ASC:%.*]] = addrspacecast i8* [[PTR]] to i8 addrspace(1)*
-; CHECK-NEXT: call void @llvm.memset.p1i8.i32(i8 addrspace(1)* [[ASC]], i8 42, i32 4, i1 true)
-; CHECK-NEXT: [[IPTR:%.*]] = bitcast i8* [[PTR]] to i32*
-; CHECK-NEXT: [[VAL:%.*]] = load i32, i32* [[IPTR]], align 4
+; CHECK-NEXT: [[ASC:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(1)
+; CHECK-NEXT: call void @llvm.memset.p1.i32(ptr addrspace(1) [[ASC]], i8 42, i32 4, i1 true)
+; CHECK-NEXT: [[VAL:%.*]] = load i32, ptr [[A]], align 4
; CHECK-NEXT: ret i32 [[VAL]]
;
entry:
%a = alloca [4 x i8]
- %ptr = getelementptr [4 x i8], [4 x i8]* %a, i32 0, i32 0
- %asc = addrspacecast i8* %ptr to i8 addrspace(1)*
- call void @llvm.memset.p1i8.i32(i8 addrspace(1)* %asc, i8 42, i32 4, i1 true)
- %iptr = bitcast i8* %ptr to i32*
- %val = load i32, i32* %iptr
+ %asc = addrspacecast ptr %a to ptr addrspace(1)
+ call void @llvm.memset.p1.i32(ptr addrspace(1) %asc, i8 42, i32 4, i1 true)
+ %val = load i32, ptr %a
ret i32 %val
}
; Don't change the address space of a volatile operation
-define void @volatile_memcpy(i8* %src, i8* %dst) {
+define void @volatile_memcpy(ptr %src, ptr %dst) {
; CHECK-LABEL: @volatile_memcpy(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca [4 x i8], align 1
-; CHECK-NEXT: [[PTR:%.*]] = getelementptr [4 x i8], [4 x i8]* [[A]], i32 0, i32 0
-; CHECK-NEXT: [[ASC:%.*]] = addrspacecast i8* [[PTR]] to i8 addrspace(1)*
-; CHECK-NEXT: call void @llvm.memcpy.p1i8.p0i8.i32(i8 addrspace(1)* [[ASC]], i8* [[SRC:%.*]], i32 4, i1 true), !tbaa [[TBAA0:![0-9]+]]
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p1i8.i32(i8* [[DST:%.*]], i8 addrspace(1)* [[ASC]], i32 4, i1 true), !tbaa [[TBAA3:![0-9]+]]
+; CHECK-NEXT: [[ASC:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(1)
+; CHECK-NEXT: call void @llvm.memcpy.p1.p0.i32(ptr addrspace(1) [[ASC]], ptr [[SRC:%.*]], i32 4, i1 true), !tbaa [[TBAA0:![0-9]+]]
+; CHECK-NEXT: call void @llvm.memcpy.p0.p1.i32(ptr [[DST:%.*]], ptr addrspace(1) [[ASC]], i32 4, i1 true), !tbaa [[TBAA3:![0-9]+]]
; CHECK-NEXT: ret void
;
entry:
%a = alloca [4 x i8]
- %ptr = getelementptr [4 x i8], [4 x i8]* %a, i32 0, i32 0
- %asc = addrspacecast i8* %ptr to i8 addrspace(1)*
- call void @llvm.memcpy.p1i8.p0i8.i32(i8 addrspace(1)* %asc, i8* %src, i32 4, i1 true), !tbaa !0
- call void @llvm.memcpy.p0i8.p1i8.i32(i8* %dst, i8 addrspace(1)* %asc, i32 4, i1 true), !tbaa !3
+ %asc = addrspacecast ptr %a to ptr addrspace(1)
+ call void @llvm.memcpy.p1.p0.i32(ptr addrspace(1) %asc, ptr %src, i32 4, i1 true), !tbaa !0
+ call void @llvm.memcpy.p0.p1.i32(ptr %dst, ptr addrspace(1) %asc, i32 4, i1 true), !tbaa !3
ret void
}
@@ -256,28 +224,28 @@ define void @select_addrspacecast(i1 %a, i1 %b) {
; CHECK-NEXT: ret void
;
%c = alloca i64, align 8
- %p.0.c = select i1 %a, i64* %c, i64* %c
- %asc = addrspacecast i64* %p.0.c to i64 addrspace(1)*
+ %p.0.c = select i1 %a, ptr %c, ptr %c
+ %asc = addrspacecast ptr %p.0.c to ptr addrspace(1)
- %cond.in = select i1 %b, i64 addrspace(1)* %asc, i64 addrspace(1)* %asc
- %cond = load i64, i64 addrspace(1)* %cond.in, align 8
+ %cond.in = select i1 %b, ptr addrspace(1) %asc, ptr addrspace(1) %asc
+ %cond = load i64, ptr addrspace(1) %cond.in, align 8
ret void
}
define void @select_addrspacecast_const_op(i1 %a, i1 %b) {
; CHECK-LABEL: @select_addrspacecast_const_op(
; CHECK-NEXT: [[C:%.*]] = alloca i64, align 8
-; CHECK-NEXT: [[C_0_ASC_SROA_CAST:%.*]] = addrspacecast i64* [[C]] to i64 addrspace(1)*
-; CHECK-NEXT: [[COND_IN:%.*]] = select i1 [[B:%.*]], i64 addrspace(1)* [[C_0_ASC_SROA_CAST]], i64 addrspace(1)* null
-; CHECK-NEXT: [[COND:%.*]] = load i64, i64 addrspace(1)* [[COND_IN]], align 8
+; CHECK-NEXT: [[C_0_ASC_SROA_CAST:%.*]] = addrspacecast ptr [[C]] to ptr addrspace(1)
+; CHECK-NEXT: [[COND_IN:%.*]] = select i1 [[B:%.*]], ptr addrspace(1) [[C_0_ASC_SROA_CAST]], ptr addrspace(1) null
+; CHECK-NEXT: [[COND:%.*]] = load i64, ptr addrspace(1) [[COND_IN]], align 8
; CHECK-NEXT: ret void
;
%c = alloca i64, align 8
- %p.0.c = select i1 %a, i64* %c, i64* %c
- %asc = addrspacecast i64* %p.0.c to i64 addrspace(1)*
+ %p.0.c = select i1 %a, ptr %c, ptr %c
+ %asc = addrspacecast ptr %p.0.c to ptr addrspace(1)
- %cond.in = select i1 %b, i64 addrspace(1)* %asc, i64 addrspace(1)* null
- %cond = load i64, i64 addrspace(1)* %cond.in, align 8
+ %cond.in = select i1 %b, ptr addrspace(1) %asc, ptr addrspace(1) null
+ %cond = load i64, ptr addrspace(1) %cond.in, align 8
ret void
}
@@ -287,31 +255,31 @@ define void @select_addrspacecast_const_op(i1 %a, i1 %b) {
define void @select_addrspacecast_gv(i1 %a, i1 %b) {
; CHECK-LABEL: @select_addrspacecast_gv(
-; CHECK-NEXT: [[COND_SROA_SPECULATE_LOAD_FALSE:%.*]] = load i64, i64 addrspace(1)* @gv, align 8
+; CHECK-NEXT: [[COND_SROA_SPECULATE_LOAD_FALSE:%.*]] = load i64, ptr addrspace(1) @gv, align 8
; CHECK-NEXT: [[COND_SROA_SPECULATED:%.*]] = select i1 [[B:%.*]], i64 undef, i64 [[COND_SROA_SPECULATE_LOAD_FALSE]]
; CHECK-NEXT: ret void
;
%c = alloca i64, align 8
- %p.0.c = select i1 %a, i64* %c, i64* %c
- %asc = addrspacecast i64* %p.0.c to i64 addrspace(1)*
+ %p.0.c = select i1 %a, ptr %c, ptr %c
+ %asc = addrspacecast ptr %p.0.c to ptr addrspace(1)
- %cond.in = select i1 %b, i64 addrspace(1)* %asc, i64 addrspace(1)* @gv
- %cond = load i64, i64 addrspace(1)* %cond.in, align 8
+ %cond.in = select i1 %b, ptr addrspace(1) %asc, ptr addrspace(1) @gv
+ %cond = load i64, ptr addrspace(1) %cond.in, align 8
ret void
}
define void @select_addrspacecast_gv_constexpr(i1 %a, i1 %b) {
; CHECK-LABEL: @select_addrspacecast_gv_constexpr(
-; CHECK-NEXT: [[COND_SROA_SPECULATE_LOAD_FALSE:%.*]] = load i64, i64 addrspace(2)* addrspacecast (i64 addrspace(1)* @gv to i64 addrspace(2)*), align 8
+; CHECK-NEXT: [[COND_SROA_SPECULATE_LOAD_FALSE:%.*]] = load i64, ptr addrspace(2) addrspacecast (ptr addrspace(1) @gv to ptr addrspace(2)), align 8
; CHECK-NEXT: [[COND_SROA_SPECULATED:%.*]] = select i1 [[B:%.*]], i64 undef, i64 [[COND_SROA_SPECULATE_LOAD_FALSE]]
; CHECK-NEXT: ret void
;
%c = alloca i64, align 8
- %p.0.c = select i1 %a, i64* %c, i64* %c
- %asc = addrspacecast i64* %p.0.c to i64 addrspace(2)*
+ %p.0.c = select i1 %a, ptr %c, ptr %c
+ %asc = addrspacecast ptr %p.0.c to ptr addrspace(2)
- %cond.in = select i1 %b, i64 addrspace(2)* %asc, i64 addrspace(2)* addrspacecast (i64 addrspace(1)* @gv to i64 addrspace(2)*)
- %cond = load i64, i64 addrspace(2)* %cond.in, align 8
+ %cond.in = select i1 %b, ptr addrspace(2) %asc, ptr addrspace(2) addrspacecast (ptr addrspace(1) @gv to ptr addrspace(2))
+ %cond = load i64, ptr addrspace(2) %cond.in, align 8
ret void
}
@@ -323,11 +291,11 @@ define i8 @select_addrspacecast_i8(i1 %c) {
%a = alloca i8
%b = alloca i8
- %a.ptr = addrspacecast i8* %a to i8 addrspace(1)*
- %b.ptr = addrspacecast i8* %b to i8 addrspace(1)*
+ %a.ptr = addrspacecast ptr %a to ptr addrspace(1)
+ %b.ptr = addrspacecast ptr %b to ptr addrspace(1)
- %ptr = select i1 %c, i8 addrspace(1)* %a.ptr, i8 addrspace(1)* %b.ptr
- %ret = load i8, i8 addrspace(1)* %ptr
+ %ptr = select i1 %c, ptr addrspace(1) %a.ptr, ptr addrspace(1) %b.ptr
+ %ret = load i8, ptr addrspace(1) %ptr
ret i8 %ret
}
diff --git a/llvm/test/Transforms/SROA/alignment.ll b/llvm/test/Transforms/SROA/alignment.ll
index 0fe9c849e964..d130d326949f 100644
--- a/llvm/test/Transforms/SROA/alignment.ll
+++ b/llvm/test/Transforms/SROA/alignment.ll
@@ -3,38 +3,38 @@
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
-declare void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1)
+declare void @llvm.memcpy.p0.p0.i32(ptr, ptr, i32, i1)
-define void @test1({ i8, i8 }* %a, { i8, i8 }* %b) {
+define void @test1(ptr %a, ptr %b) {
; CHECK-LABEL: @test1(
-; CHECK: %[[gep_a0:.*]] = getelementptr inbounds { i8, i8 }, { i8, i8 }* %a, i64 0, i32 0
-; CHECK: %[[a0:.*]] = load i8, i8* %[[gep_a0]], align 16
-; CHECK: %[[gep_a1:.*]] = getelementptr inbounds { i8, i8 }, { i8, i8 }* %a, i64 0, i32 1
-; CHECK: %[[a1:.*]] = load i8, i8* %[[gep_a1]], align 1
-; CHECK: %[[gep_b0:.*]] = getelementptr inbounds { i8, i8 }, { i8, i8 }* %b, i64 0, i32 0
-; CHECK: store i8 %[[a0]], i8* %[[gep_b0]], align 16
-; CHECK: %[[gep_b1:.*]] = getelementptr inbounds { i8, i8 }, { i8, i8 }* %b, i64 0, i32 1
-; CHECK: store i8 %[[a1]], i8* %[[gep_b1]], align 1
+; CHECK: %[[gep_a0:.*]] = getelementptr { i8, i8 }, ptr %a, i32 0, i32 0
+; CHECK: %[[gep_b0:.*]] = getelementptr { i8, i8 }, ptr %b, i32 0, i32 0
+; CHECK: %[[a0:.*]] = load i8, ptr %[[gep_a0]], align 16
+; CHECK: %[[gep_a1:.*]] = getelementptr inbounds i8, ptr %[[gep_a0]], i64 1
+; CHECK: %[[a1:.*]] = load i8, ptr %[[gep_a1]], align 1
+; CHECK: store i8 %[[a0]], ptr %[[gep_b0]], align 16
+; CHECK: %[[gep_b1:.*]] = getelementptr inbounds i8, ptr %[[gep_b0]], i64 1
+; CHECK: store i8 %[[a1]], ptr %[[gep_b1]], align 1
; CHECK: ret void
entry:
%alloca = alloca { i8, i8 }, align 16
- %gep_a = getelementptr { i8, i8 }, { i8, i8 }* %a, i32 0, i32 0
- %gep_alloca = getelementptr { i8, i8 }, { i8, i8 }* %alloca, i32 0, i32 0
- %gep_b = getelementptr { i8, i8 }, { i8, i8 }* %b, i32 0, i32 0
+ %gep_a = getelementptr { i8, i8 }, ptr %a, i32 0, i32 0
+ %gep_alloca = getelementptr { i8, i8 }, ptr %alloca, i32 0, i32 0
+ %gep_b = getelementptr { i8, i8 }, ptr %b, i32 0, i32 0
- store i8 420, i8* %gep_alloca, align 16
+ store i8 420, ptr %gep_alloca, align 16
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %gep_alloca, i8* align 16 %gep_a, i32 2, i1 false)
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %gep_b, i8* align 16 %gep_alloca, i32 2, i1 false)
+ call void @llvm.memcpy.p0.p0.i32(ptr align 16 %gep_alloca, ptr align 16 %gep_a, i32 2, i1 false)
+ call void @llvm.memcpy.p0.p0.i32(ptr align 16 %gep_b, ptr align 16 %gep_alloca, i32 2, i1 false)
ret void
}
define void @test2() {
; CHECK-LABEL: @test2(
; CHECK: alloca i16
-; CHECK: load i8, i8* %{{.*}}
-; CHECK: store i8 42, i8* %{{.*}}
+; CHECK: load i8, ptr %{{.*}}
+; CHECK: store i8 42, ptr %{{.*}}
; CHECK: ret void
; Check that when sroa rewrites the alloca partition
@@ -47,33 +47,29 @@ define void @test2() {
entry:
%a = alloca { i8, i8, i8, i8 }, align 2 ; "line 9" to -debugify
- %gep1 = getelementptr { i8, i8, i8, i8 }, { i8, i8, i8, i8 }* %a, i32 0, i32 1
- %cast1 = bitcast i8* %gep1 to i16*
- store volatile i16 0, i16* %cast1
- %gep2 = getelementptr { i8, i8, i8, i8 }, { i8, i8, i8, i8 }* %a, i32 0, i32 2
- %result = load i8, i8* %gep2
- store i8 42, i8* %gep2
+ %gep1 = getelementptr { i8, i8, i8, i8 }, ptr %a, i32 0, i32 1
+ store volatile i16 0, ptr %gep1
+ %gep2 = getelementptr { i8, i8, i8, i8 }, ptr %a, i32 0, i32 2
+ %result = load i8, ptr %gep2
+ store i8 42, ptr %gep2
ret void
}
-define void @PR13920(<2 x i64>* %a, i16* %b) {
+define void @PR13920(ptr %a, ptr %b) {
; Test that alignments on memcpy intrinsics get propagated to loads and stores.
; CHECK-LABEL: @PR13920(
-; CHECK: load <2 x i64>, <2 x i64>* %a, align 2
-; CHECK: store <2 x i64> {{.*}}, <2 x i64>* {{.*}}, align 2
+; CHECK: load <2 x i64>, ptr %a, align 2
+; CHECK: store <2 x i64> {{.*}}, ptr {{.*}}, align 2
; CHECK: ret void
entry:
%aa = alloca <2 x i64>, align 16
- %aptr = bitcast <2 x i64>* %a to i8*
- %aaptr = bitcast <2 x i64>* %aa to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 2 %aaptr, i8* align 2 %aptr, i32 16, i1 false)
- %bptr = bitcast i16* %b to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 2 %bptr, i8* align 2 %aaptr, i32 16, i1 false)
+ call void @llvm.memcpy.p0.p0.i32(ptr align 2 %aa, ptr align 2 %a, i32 16, i1 false)
+ call void @llvm.memcpy.p0.p0.i32(ptr align 2 %b, ptr align 2 %aa, i32 16, i1 false)
ret void
}
-define void @test3(i8* %x) {
+define void @test3(ptr %x) {
; Test that when we promote an alloca to a type with lower ABI alignment, we
; provide the needed explicit alignment that code using the alloca may be
; expecting. However, also check that any offset within an alloca can in turn
@@ -84,13 +80,11 @@ define void @test3(i8* %x) {
; CHECK: ret void
entry:
- %a = alloca { i8*, i8*, i8* }
- %b = alloca { i8*, i8*, i8* }
- %a_raw = bitcast { i8*, i8*, i8* }* %a to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %a_raw, i8* align 8 %x, i32 22, i1 false)
- %b_raw = bitcast { i8*, i8*, i8* }* %b to i8*
- %b_gep = getelementptr i8, i8* %b_raw, i32 6
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 2 %b_gep, i8* align 2 %x, i32 18, i1 false)
+ %a = alloca { ptr, ptr, ptr }
+ %b = alloca { ptr, ptr, ptr }
+ call void @llvm.memcpy.p0.p0.i32(ptr align 8 %a, ptr align 8 %x, i32 22, i1 false)
+ %b_gep = getelementptr i8, ptr %b, i32 6
+ call void @llvm.memcpy.p0.p0.i32(ptr align 2 %b_gep, ptr align 2 %x, i32 18, i1 false)
ret void
}
@@ -102,29 +96,24 @@ define void @test5() {
; CHECK-LABEL: @test5(
; CHECK: alloca [9 x i8]
; CHECK: alloca [9 x i8]
-; CHECK: store volatile double 0.0{{.*}}, double* %{{.*}}, align 1
-; CHECK: load volatile i16, i16* %{{.*}}, align 1
-; CHECK: load double, double* %{{.*}}, align 1
-; CHECK: store volatile double %{{.*}}, double* %{{.*}}, align 1
-; CHECK: load volatile i16, i16* %{{.*}}, align 1
+; CHECK: store volatile double 0.0{{.*}}, ptr %{{.*}}, align 1
+; CHECK: load volatile i16, ptr %{{.*}}, align 1
+; CHECK: load double, ptr %{{.*}}, align 1
+; CHECK: store volatile double %{{.*}}, ptr %{{.*}}, align 1
+; CHECK: load volatile i16, ptr %{{.*}}, align 1
; CHECK: ret void
entry:
%a = alloca [18 x i8]
- %raw1 = getelementptr inbounds [18 x i8], [18 x i8]* %a, i32 0, i32 0
- %ptr1 = bitcast i8* %raw1 to double*
- store volatile double 0.0, double* %ptr1, align 1
- %weird_gep1 = getelementptr inbounds [18 x i8], [18 x i8]* %a, i32 0, i32 7
- %weird_cast1 = bitcast i8* %weird_gep1 to i16*
- %weird_load1 = load volatile i16, i16* %weird_cast1, align 1
-
- %raw2 = getelementptr inbounds [18 x i8], [18 x i8]* %a, i32 0, i32 9
- %ptr2 = bitcast i8* %raw2 to double*
- %d1 = load double, double* %ptr1, align 1
- store volatile double %d1, double* %ptr2, align 1
- %weird_gep2 = getelementptr inbounds [18 x i8], [18 x i8]* %a, i32 0, i32 16
- %weird_cast2 = bitcast i8* %weird_gep2 to i16*
- %weird_load2 = load volatile i16, i16* %weird_cast2, align 1
+ store volatile double 0.0, ptr %a, align 1
+ %weird_gep1 = getelementptr inbounds [18 x i8], ptr %a, i32 0, i32 7
+ %weird_load1 = load volatile i16, ptr %weird_gep1, align 1
+
+ %raw2 = getelementptr inbounds [18 x i8], ptr %a, i32 0, i32 9
+ %d1 = load double, ptr %a, align 1
+ store volatile double %d1, ptr %raw2, align 1
+ %weird_gep2 = getelementptr inbounds [18 x i8], ptr %a, i32 0, i32 16
+ %weird_load2 = load volatile i16, ptr %weird_gep2, align 1
ret void
}
@@ -143,19 +132,16 @@ define void @test6() {
entry:
%a = alloca [16 x i8]
- %raw1 = getelementptr inbounds [16 x i8], [16 x i8]* %a, i32 0, i32 0
- %ptr1 = bitcast i8* %raw1 to double*
- store volatile double 0.0, double* %ptr1, align 1
+ store volatile double 0.0, ptr %a, align 1
- %raw2 = getelementptr inbounds [16 x i8], [16 x i8]* %a, i32 0, i32 8
- %ptr2 = bitcast i8* %raw2 to double*
- %val = load double, double* %ptr1, align 1
- store volatile double %val, double* %ptr2, align 1
+ %raw2 = getelementptr inbounds [16 x i8], ptr %a, i32 0, i32 8
+ %val = load double, ptr %a, align 1
+ store volatile double %val, ptr %raw2, align 1
ret void
}
-define void @test7(i8* %out) {
+define void @test7(ptr %out) {
; Test that we properly compute the destination alignment when rewriting
; memcpys as direct loads or stores.
; CHECK-LABEL: @test7(
@@ -163,24 +149,21 @@ define void @test7(i8* %out) {
entry:
%a = alloca [16 x i8]
- %raw1 = getelementptr inbounds [16 x i8], [16 x i8]* %a, i32 0, i32 0
- %ptr1 = bitcast i8* %raw1 to double*
- %raw2 = getelementptr inbounds [16 x i8], [16 x i8]* %a, i32 0, i32 8
- %ptr2 = bitcast i8* %raw2 to double*
+ %raw2 = getelementptr inbounds [16 x i8], ptr %a, i32 0, i32 8
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %raw1, i8* %out, i32 16, i1 false)
-; CHECK: %[[val2:.*]] = load double, double* %{{.*}}, align 1
-; CHECK: %[[val1:.*]] = load double, double* %{{.*}}, align 1
+ call void @llvm.memcpy.p0.p0.i32(ptr %a, ptr %out, i32 16, i1 false)
+; CHECK: %[[val2:.*]] = load double, ptr %{{.*}}, align 1
+; CHECK: %[[val1:.*]] = load double, ptr %{{.*}}, align 1
- %val1 = load double, double* %ptr2, align 1
- %val2 = load double, double* %ptr1, align 1
+ %val1 = load double, ptr %raw2, align 1
+ %val2 = load double, ptr %a, align 1
- store double %val1, double* %ptr1, align 1
- store double %val2, double* %ptr2, align 1
+ store double %val1, ptr %a, align 1
+ store double %val2, ptr %raw2, align 1
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %out, i8* %raw1, i32 16, i1 false)
-; CHECK: store double %[[val1]], double* %{{.*}}, align 1
-; CHECK: store double %[[val2]], double* %{{.*}}, align 1
+ call void @llvm.memcpy.p0.p0.i32(ptr %out, ptr %a, i32 16, i1 false)
+; CHECK: store double %[[val1]], ptr %{{.*}}, align 1
+; CHECK: store double %[[val2]], ptr %{{.*}}, align 1
ret void
; CHECK: ret void
@@ -195,9 +178,8 @@ define void @test8() {
; CHECK: load i32, {{.*}}, align 1
%ptr = alloca [5 x i32], align 1
- %ptr.8 = bitcast [5 x i32]* %ptr to i8*
- call void @populate(i8* %ptr.8)
- %val = load [5 x i32], [5 x i32]* %ptr, align 1
+ call void @populate(ptr %ptr)
+ %val = load [5 x i32], ptr %ptr, align 1
ret void
}
@@ -210,9 +192,8 @@ define void @test9() {
; CHECK: load i32, {{.*}}, align 8
%ptr = alloca [5 x i32], align 8
- %ptr.8 = bitcast [5 x i32]* %ptr to i8*
- call void @populate(i8* %ptr.8)
- %val = load [5 x i32], [5 x i32]* %ptr, align 8
+ call void @populate(ptr %ptr)
+ %val = load [5 x i32], ptr %ptr, align 8
ret void
}
@@ -225,25 +206,22 @@ define void @test10() {
; CHECK: load i16, {{.*}}, align 2
%ptr = alloca {i32, i8, i8, {i8, i16}}, align 2
- %ptr.8 = bitcast {i32, i8, i8, {i8, i16}}* %ptr to i8*
- call void @populate(i8* %ptr.8)
- %val = load {i32, i8, i8, {i8, i16}}, {i32, i8, i8, {i8, i16}}* %ptr, align 2
+ call void @populate(ptr %ptr)
+ %val = load {i32, i8, i8, {i8, i16}}, ptr %ptr, align 2
ret void
}
%struct = type { i32, i32 }
-define dso_local i32 @pr45010(%struct* %A) {
+define dso_local i32 @pr45010(ptr %A) {
; CHECK-LABEL: @pr45010
; CHECK: load atomic volatile i32, {{.*}}, align 4
%B = alloca %struct, align 4
- %A.i = getelementptr inbounds %struct, %struct* %A, i32 0, i32 0
- %B.i = getelementptr inbounds %struct, %struct* %B, i32 0, i32 0
- %1 = load i32, i32* %A.i, align 4
- store atomic volatile i32 %1, i32* %B.i release, align 4
- %2 = bitcast %struct* %B to i32*
- %x = load atomic volatile i32, i32* %2 acquire, align 4
+ %1 = load i32, ptr %A, align 4
+ store atomic volatile i32 %1, ptr %B release, align 4
+ %2 = bitcast ptr %B to ptr
+ %x = load atomic volatile i32, ptr %2 acquire, align 4
ret i32 %x
}
-declare void @populate(i8*)
+declare void @populate(ptr)
diff --git a/llvm/test/Transforms/SROA/alloca-address-space.ll b/llvm/test/Transforms/SROA/alloca-address-space.ll
index 01cd543eabec..bc880211f8ac 100644
--- a/llvm/test/Transforms/SROA/alloca-address-space.ll
+++ b/llvm/test/Transforms/SROA/alloca-address-space.ll
@@ -2,92 +2,76 @@
; RUN: opt < %s -passes=sroa -S | FileCheck %s
target datalayout = "e-p:64:64:64-p1:16:16:16-p2:32:32-p3:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64-A2"
-declare void @llvm.memcpy.p2i8.p2i8.i32(i8 addrspace(2)* nocapture, i8 addrspace(2)* nocapture readonly, i32, i1)
-declare void @llvm.memcpy.p1i8.p2i8.i32(i8 addrspace(1)* nocapture, i8 addrspace(2)* nocapture readonly, i32, i1)
-declare void @llvm.memcpy.p2i8.p1i8.i32(i8 addrspace(2)* nocapture, i8 addrspace(1)* nocapture readonly, i32, i1)
-declare void @llvm.memcpy.p1i8.p1i8.i32(i8 addrspace(1)* nocapture, i8 addrspace(1)* nocapture readonly, i32, i1)
+declare void @llvm.memcpy.p2.p2.i32(ptr addrspace(2) nocapture, ptr addrspace(2) nocapture readonly, i32, i1)
+declare void @llvm.memcpy.p1.p2.i32(ptr addrspace(1) nocapture, ptr addrspace(2) nocapture readonly, i32, i1)
+declare void @llvm.memcpy.p2.p1.i32(ptr addrspace(2) nocapture, ptr addrspace(1) nocapture readonly, i32, i1)
+declare void @llvm.memcpy.p1.p1.i32(ptr addrspace(1) nocapture, ptr addrspace(1) nocapture readonly, i32, i1)
-define void @test_address_space_1_1(<2 x i64> addrspace(1)* %a, i16 addrspace(1)* %b) {
+define void @test_address_space_1_1(ptr addrspace(1) %a, ptr addrspace(1) %b) {
; CHECK-LABEL: @test_address_space_1_1(
-; CHECK-NEXT: [[AA_0_COPYLOAD:%.*]] = load <2 x i64>, <2 x i64> addrspace(1)* [[A:%.*]], align 2
-; CHECK-NEXT: [[AA_0_BPTR_SROA_CAST:%.*]] = bitcast i16 addrspace(1)* [[B:%.*]] to <2 x i64> addrspace(1)*
-; CHECK-NEXT: store <2 x i64> [[AA_0_COPYLOAD]], <2 x i64> addrspace(1)* [[AA_0_BPTR_SROA_CAST]], align 2
+; CHECK-NEXT: [[AA_0_COPYLOAD:%.*]] = load <2 x i64>, ptr addrspace(1) [[A:%.*]], align 2
+; CHECK-NEXT: store <2 x i64> [[AA_0_COPYLOAD]], ptr addrspace(1) [[B:%.*]], align 2
; CHECK-NEXT: ret void
;
%aa = alloca <2 x i64>, align 16, addrspace(2)
- %aptr = bitcast <2 x i64> addrspace(1)* %a to i8 addrspace(1)*
- %aaptr = bitcast <2 x i64> addrspace(2)* %aa to i8 addrspace(2)*
- call void @llvm.memcpy.p2i8.p1i8.i32(i8 addrspace(2)* align 2 %aaptr, i8 addrspace(1)* align 2 %aptr, i32 16, i1 false)
- %bptr = bitcast i16 addrspace(1)* %b to i8 addrspace(1)*
- call void @llvm.memcpy.p1i8.p2i8.i32(i8 addrspace(1)* align 2 %bptr, i8 addrspace(2)* align 2 %aaptr, i32 16, i1 false)
+ call void @llvm.memcpy.p2.p1.i32(ptr addrspace(2) align 2 %aa, ptr addrspace(1) align 2 %a, i32 16, i1 false)
+ call void @llvm.memcpy.p1.p2.i32(ptr addrspace(1) align 2 %b, ptr addrspace(2) align 2 %aa, i32 16, i1 false)
ret void
}
-define void @test_address_space_1_0(<2 x i64> addrspace(1)* %a, i16 addrspace(2)* %b) {
+define void @test_address_space_1_0(ptr addrspace(1) %a, ptr addrspace(2) %b) {
; CHECK-LABEL: @test_address_space_1_0(
-; CHECK-NEXT: [[AA_0_COPYLOAD:%.*]] = load <2 x i64>, <2 x i64> addrspace(1)* [[A:%.*]], align 2
-; CHECK-NEXT: [[AA_0_BPTR_SROA_CAST:%.*]] = bitcast i16 addrspace(2)* [[B:%.*]] to <2 x i64> addrspace(2)*
-; CHECK-NEXT: store <2 x i64> [[AA_0_COPYLOAD]], <2 x i64> addrspace(2)* [[AA_0_BPTR_SROA_CAST]], align 2
+; CHECK-NEXT: [[AA_0_COPYLOAD:%.*]] = load <2 x i64>, ptr addrspace(1) [[A:%.*]], align 2
+; CHECK-NEXT: store <2 x i64> [[AA_0_COPYLOAD]], ptr addrspace(2) [[B:%.*]], align 2
; CHECK-NEXT: ret void
;
%aa = alloca <2 x i64>, align 16, addrspace(2)
- %aptr = bitcast <2 x i64> addrspace(1)* %a to i8 addrspace(1)*
- %aaptr = bitcast <2 x i64> addrspace(2)* %aa to i8 addrspace(2)*
- call void @llvm.memcpy.p2i8.p1i8.i32(i8 addrspace(2)* align 2 %aaptr, i8 addrspace(1)* align 2 %aptr, i32 16, i1 false)
- %bptr = bitcast i16 addrspace(2)* %b to i8 addrspace(2)*
- call void @llvm.memcpy.p2i8.p2i8.i32(i8 addrspace(2)* align 2 %bptr, i8 addrspace(2)* align 2 %aaptr, i32 16, i1 false)
+ call void @llvm.memcpy.p2.p1.i32(ptr addrspace(2) align 2 %aa, ptr addrspace(1) align 2 %a, i32 16, i1 false)
+ call void @llvm.memcpy.p2.p2.i32(ptr addrspace(2) align 2 %b, ptr addrspace(2) align 2 %aa, i32 16, i1 false)
ret void
}
-define void @test_address_space_0_1(<2 x i64> addrspace(2)* %a, i16 addrspace(1)* %b) {
+define void @test_address_space_0_1(ptr addrspace(2) %a, ptr addrspace(1) %b) {
; CHECK-LABEL: @test_address_space_0_1(
-; CHECK-NEXT: [[AA_0_COPYLOAD:%.*]] = load <2 x i64>, <2 x i64> addrspace(2)* [[A:%.*]], align 2
-; CHECK-NEXT: [[AA_0_BPTR_SROA_CAST:%.*]] = bitcast i16 addrspace(1)* [[B:%.*]] to <2 x i64> addrspace(1)*
-; CHECK-NEXT: store <2 x i64> [[AA_0_COPYLOAD]], <2 x i64> addrspace(1)* [[AA_0_BPTR_SROA_CAST]], align 2
+; CHECK-NEXT: [[AA_0_COPYLOAD:%.*]] = load <2 x i64>, ptr addrspace(2) [[A:%.*]], align 2
+; CHECK-NEXT: store <2 x i64> [[AA_0_COPYLOAD]], ptr addrspace(1) [[B:%.*]], align 2
; CHECK-NEXT: ret void
;
%aa = alloca <2 x i64>, align 16, addrspace(2)
- %aptr = bitcast <2 x i64> addrspace(2)* %a to i8 addrspace(2)*
- %aaptr = bitcast <2 x i64> addrspace(2)* %aa to i8 addrspace(2)*
- call void @llvm.memcpy.p2i8.p2i8.i32(i8 addrspace(2)* align 2 %aaptr, i8 addrspace(2)* align 2 %aptr, i32 16, i1 false)
- %bptr = bitcast i16 addrspace(1)* %b to i8 addrspace(1)*
- call void @llvm.memcpy.p1i8.p2i8.i32(i8 addrspace(1)* align 2 %bptr, i8 addrspace(2)* align 2 %aaptr, i32 16, i1 false)
+ call void @llvm.memcpy.p2.p2.i32(ptr addrspace(2) align 2 %aa, ptr addrspace(2) align 2 %a, i32 16, i1 false)
+ call void @llvm.memcpy.p1.p2.i32(ptr addrspace(1) align 2 %b, ptr addrspace(2) align 2 %aa, i32 16, i1 false)
ret void
}
%struct.struct_test_27.0.13 = type { i32, float, i64, i8, [4 x i32] }
-define void @copy_struct([5 x i64] %in.coerce, i8 addrspace(1)* align 4 %ptr) {
+define void @copy_struct([5 x i64] %in.coerce, ptr addrspace(1) align 4 %ptr) {
; CHECK-LABEL: @copy_struct(
; CHECK-NEXT: for.end:
; CHECK-NEXT: [[IN_COERCE_FCA_0_EXTRACT:%.*]] = extractvalue [5 x i64] [[IN_COERCE:%.*]], 0
; CHECK-NEXT: [[IN_COERCE_FCA_1_EXTRACT:%.*]] = extractvalue [5 x i64] [[IN_COERCE]], 1
; CHECK-NEXT: [[IN_COERCE_FCA_2_EXTRACT:%.*]] = extractvalue [5 x i64] [[IN_COERCE]], 2
; CHECK-NEXT: [[IN_COERCE_FCA_3_EXTRACT:%.*]] = extractvalue [5 x i64] [[IN_COERCE]], 3
-; CHECK-NEXT: [[IN_SROA_2_4_PTR_SROA_CAST:%.*]] = bitcast i8 addrspace(1)* [[PTR:%.*]] to i32 addrspace(1)*
; CHECK-NEXT: [[IN_SROA_2_4_EXTRACT_SHIFT:%.*]] = lshr i64 [[IN_COERCE_FCA_2_EXTRACT]], 32
; CHECK-NEXT: [[IN_SROA_2_4_EXTRACT_TRUNC:%.*]] = trunc i64 [[IN_SROA_2_4_EXTRACT_SHIFT]] to i32
-; CHECK-NEXT: store i32 [[IN_SROA_2_4_EXTRACT_TRUNC]], i32 addrspace(1)* [[IN_SROA_2_4_PTR_SROA_CAST]], align 4
-; CHECK-NEXT: [[IN_SROA_4_20_PTR_SROA_IDX:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[PTR]], i16 4
-; CHECK-NEXT: [[IN_SROA_4_20_PTR_SROA_CAST:%.*]] = bitcast i8 addrspace(1)* [[IN_SROA_4_20_PTR_SROA_IDX]] to i64 addrspace(1)*
-; CHECK-NEXT: store i64 [[IN_COERCE_FCA_3_EXTRACT]], i64 addrspace(1)* [[IN_SROA_4_20_PTR_SROA_CAST]], align 4
-; CHECK-NEXT: [[IN_SROA_5_20_PTR_SROA_IDX:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[PTR]], i16 12
-; CHECK-NEXT: [[IN_SROA_5_20_PTR_SROA_CAST:%.*]] = bitcast i8 addrspace(1)* [[IN_SROA_5_20_PTR_SROA_IDX]] to i32 addrspace(1)*
-; CHECK-NEXT: store i32 undef, i32 addrspace(1)* [[IN_SROA_5_20_PTR_SROA_CAST]], align 4
+; CHECK-NEXT: store i32 [[IN_SROA_2_4_EXTRACT_TRUNC]], ptr addrspace(1) [[PTR:%.*]], align 4
+; CHECK-NEXT: [[IN_SROA_4_20_PTR_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr addrspace(1) [[PTR]], i16 4
+; CHECK-NEXT: store i64 [[IN_COERCE_FCA_3_EXTRACT]], ptr addrspace(1) [[IN_SROA_4_20_PTR_SROA_IDX]], align 4
+; CHECK-NEXT: [[IN_SROA_5_20_PTR_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr addrspace(1) [[PTR]], i16 12
+; CHECK-NEXT: store i32 undef, ptr addrspace(1) [[IN_SROA_5_20_PTR_SROA_IDX]], align 4
; CHECK-NEXT: ret void
;
for.end:
%in = alloca %struct.struct_test_27.0.13, align 8, addrspace(2)
- %0 = bitcast %struct.struct_test_27.0.13 addrspace(2)* %in to [5 x i64] addrspace(2)*
- store [5 x i64] %in.coerce, [5 x i64] addrspace(2)* %0, align 8
- %scevgep9 = getelementptr %struct.struct_test_27.0.13, %struct.struct_test_27.0.13 addrspace(2)* %in, i32 0, i32 4, i32 0
- %scevgep910 = bitcast i32 addrspace(2)* %scevgep9 to i8 addrspace(2)*
- call void @llvm.memcpy.p1i8.p2i8.i32(i8 addrspace(1)* align 4 %ptr, i8 addrspace(2)* align 4 %scevgep910, i32 16, i1 false)
+ %0 = bitcast ptr addrspace(2) %in to ptr addrspace(2)
+ store [5 x i64] %in.coerce, ptr addrspace(2) %0, align 8
+ %scevgep9 = getelementptr %struct.struct_test_27.0.13, ptr addrspace(2) %in, i32 0, i32 4, i32 0
+ call void @llvm.memcpy.p1.p2.i32(ptr addrspace(1) align 4 %ptr, ptr addrspace(2) align 4 %scevgep9, i32 16, i1 false)
ret void
}
-%union.anon = type { i32* }
+%union.anon = type { ptr }
@g = common global i32 0, align 4
@l = common addrspace(3) global i32 0, align 4
@@ -96,17 +80,16 @@ for.end:
; illegal bitcast isn't introduced
define void @pr27557() {
; CHECK-LABEL: @pr27557(
-; CHECK-NEXT: [[DOTSROA_0:%.*]] = alloca i32*, align 8, addrspace(2)
-; CHECK-NEXT: store i32* @g, i32* addrspace(2)* [[DOTSROA_0]], align 8
-; CHECK-NEXT: [[DOTSROA_0_0__SROA_CAST1:%.*]] = bitcast i32* addrspace(2)* [[DOTSROA_0]] to i32 addrspace(3)* addrspace(2)*
-; CHECK-NEXT: store i32 addrspace(3)* @l, i32 addrspace(3)* addrspace(2)* [[DOTSROA_0_0__SROA_CAST1]], align 8
+; CHECK-NEXT: [[DOTSROA_0:%.*]] = alloca ptr, align 8, addrspace(2)
+; CHECK-NEXT: store ptr @g, ptr addrspace(2) [[DOTSROA_0]], align 8
+; CHECK-NEXT: store ptr addrspace(3) @l, ptr addrspace(2) [[DOTSROA_0]], align 8
; CHECK-NEXT: ret void
;
%1 = alloca %union.anon, align 8, addrspace(2)
- %2 = bitcast %union.anon addrspace(2)* %1 to i32* addrspace(2)*
- store i32* @g, i32* addrspace(2)* %2, align 8
- %3 = bitcast %union.anon addrspace(2)* %1 to i32 addrspace(3)* addrspace(2)*
- store i32 addrspace(3)* @l, i32 addrspace(3)* addrspace(2)* %3, align 8
+ %2 = bitcast ptr addrspace(2) %1 to ptr addrspace(2)
+ store ptr @g, ptr addrspace(2) %2, align 8
+ %3 = bitcast ptr addrspace(2) %1 to ptr addrspace(2)
+ store ptr addrspace(3) @l, ptr addrspace(2) %3, align 8
ret void
}
@@ -114,56 +97,45 @@ define void @pr27557() {
; If pointers from
diff erent address spaces have the same size, that pointer
; should be promoted through the pair of `ptrtoint`/`inttoptr`.
-define i32* @pr27557.alt() {
+define ptr @pr27557.alt() {
; CHECK-LABEL: @pr27557.alt(
-; CHECK-NEXT: ret i32* inttoptr (i64 ptrtoint (i32 addrspace(4)* @l4 to i64) to i32*)
+; CHECK-NEXT: ret ptr inttoptr (i64 ptrtoint (ptr addrspace(4) @l4 to i64) to ptr)
;
%1 = alloca %union.anon, align 8, addrspace(2)
- %2 = bitcast %union.anon addrspace(2)* %1 to i32 addrspace(4)* addrspace(2)*
- store i32 addrspace(4)* @l4, i32 addrspace(4)* addrspace(2)* %2, align 8
- %3 = bitcast %union.anon addrspace(2)* %1 to i32* addrspace(2)*
- %4 = load i32*, i32* addrspace(2)* %3, align 8
- ret i32* %4
+ %2 = bitcast ptr addrspace(2) %1 to ptr addrspace(2)
+ store ptr addrspace(4) @l4, ptr addrspace(2) %2, align 8
+ %3 = bitcast ptr addrspace(2) %1 to ptr addrspace(2)
+ %4 = load ptr, ptr addrspace(2) %3, align 8
+ ret ptr %4
}
; Test load from and store to non-zero address space.
-define void @test_load_store_
diff _addr_space([2 x float] addrspace(1)* %complex1, [2 x float] addrspace(1)* %complex2) {
+define void @test_load_store_
diff _addr_space(ptr addrspace(1) %complex1, ptr addrspace(1) %complex2) {
; CHECK-LABEL: @test_load_store_
diff _addr_space(
-; CHECK-NEXT: [[P1_SROA_CAST:%.*]] = bitcast [2 x float] addrspace(1)* [[COMPLEX1:%.*]] to i32 addrspace(1)*
-; CHECK-NEXT: [[V15:%.*]] = load i32, i32 addrspace(1)* [[P1_SROA_CAST]], align 4
-; CHECK-NEXT: [[P1_SROA_IDX:%.*]] = getelementptr inbounds [2 x float], [2 x float] addrspace(1)* [[COMPLEX1]], i16 0, i16 1
-; CHECK-NEXT: [[P1_SROA_CAST7:%.*]] = bitcast float addrspace(1)* [[P1_SROA_IDX]] to i32 addrspace(1)*
-; CHECK-NEXT: [[V18:%.*]] = load i32, i32 addrspace(1)* [[P1_SROA_CAST7]], align 4
-; CHECK-NEXT: [[TMP1:%.*]] = bitcast i32 [[V15]] to float
-; CHECK-NEXT: [[TMP2:%.*]] = bitcast i32 [[V18]] to float
+; CHECK-NEXT: [[V13:%.*]] = load i32, ptr addrspace(1) [[COMPLEX1:%.*]], align 4
+; CHECK-NEXT: [[COMPLEX1_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr addrspace(1) [[COMPLEX1]], i16 4
+; CHECK-NEXT: [[V14:%.*]] = load i32, ptr addrspace(1) [[COMPLEX1_SROA_IDX]], align 4
+; CHECK-NEXT: [[TMP1:%.*]] = bitcast i32 [[V13]] to float
+; CHECK-NEXT: [[TMP2:%.*]] = bitcast i32 [[V14]] to float
; CHECK-NEXT: [[SUM:%.*]] = fadd float [[TMP1]], [[TMP2]]
; CHECK-NEXT: [[TMP3:%.*]] = bitcast float [[SUM]] to i32
; CHECK-NEXT: [[TMP4:%.*]] = bitcast float [[SUM]] to i32
-; CHECK-NEXT: [[P2_SROA_CAST:%.*]] = bitcast [2 x float] addrspace(1)* [[COMPLEX2:%.*]] to i32 addrspace(1)*
-; CHECK-NEXT: store i32 [[TMP3]], i32 addrspace(1)* [[P2_SROA_CAST]], align 4
-; CHECK-NEXT: [[P2_SROA_IDX:%.*]] = getelementptr inbounds [2 x float], [2 x float] addrspace(1)* [[COMPLEX2]], i16 0, i16 1
-; CHECK-NEXT: [[P2_SROA_CAST4:%.*]] = bitcast float addrspace(1)* [[P2_SROA_IDX]] to i32 addrspace(1)*
-; CHECK-NEXT: store i32 [[TMP4]], i32 addrspace(1)* [[P2_SROA_CAST4]], align 4
+; CHECK-NEXT: store i32 [[TMP3]], ptr addrspace(1) [[COMPLEX2:%.*]], align 4
+; CHECK-NEXT: [[COMPLEX2_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr addrspace(1) [[COMPLEX2]], i16 4
+; CHECK-NEXT: store i32 [[TMP4]], ptr addrspace(1) [[COMPLEX2_SROA_IDX]], align 4
; CHECK-NEXT: ret void
;
%a0 = alloca [2 x i64], align 8, addrspace(2)
- %a = getelementptr [2 x i64], [2 x i64] addrspace(2)* %a0, i32 0, i32 0
- %a.cast = bitcast i64 addrspace(2)* %a to [2 x float] addrspace(2)*
- %a.gep1 = getelementptr [2 x float], [2 x float] addrspace(2)* %a.cast, i32 0, i32 0
- %a.gep2 = getelementptr [2 x float], [2 x float] addrspace(2)* %a.cast, i32 0, i32 1
- %complex1.gep = getelementptr [2 x float], [2 x float] addrspace(1)* %complex1, i32 0, i32 0
- %p1 = bitcast float addrspace(1)* %complex1.gep to i64 addrspace(1)*
- %v1 = load i64, i64 addrspace(1)* %p1
- store i64 %v1, i64 addrspace(2)* %a
- %f1 = load float, float addrspace(2)* %a.gep1
- %f2 = load float, float addrspace(2)* %a.gep2
+ %a.gep2 = getelementptr [2 x float], ptr addrspace(2) %a0, i32 0, i32 1
+ %v1 = load i64, ptr addrspace(1) %complex1
+ store i64 %v1, ptr addrspace(2) %a0
+ %f1 = load float, ptr addrspace(2) %a0
+ %f2 = load float, ptr addrspace(2) %a.gep2
%sum = fadd float %f1, %f2
- store float %sum, float addrspace(2)* %a.gep1
- store float %sum, float addrspace(2)* %a.gep2
- %v2 = load i64, i64 addrspace(2)* %a
- %complex2.gep = getelementptr [2 x float], [2 x float] addrspace(1)* %complex2, i32 0, i32 0
- %p2 = bitcast float addrspace(1)* %complex2.gep to i64 addrspace(1)*
- store i64 %v2, i64 addrspace(1)* %p2
+ store float %sum, ptr addrspace(2) %a0
+ store float %sum, ptr addrspace(2) %a.gep2
+ %v2 = load i64, ptr addrspace(2) %a0
+ store i64 %v2, ptr addrspace(1) %complex2
ret void
}
@@ -172,9 +144,9 @@ define void @addressspace_alloca_lifetime() {
; CHECK-NEXT: ret void
;
%alloca = alloca i8, align 8, addrspace(2)
- %cast = addrspacecast i8 addrspace(2)* %alloca to i8*
- call void @llvm.lifetime.start.p0i8(i64 2, i8* %cast)
+ %cast = addrspacecast ptr addrspace(2) %alloca to ptr
+ call void @llvm.lifetime.start.p0(i64 2, ptr %cast)
ret void
}
-declare void @llvm.lifetime.start.p0i8(i64 %size, i8* nocapture %ptr)
+declare void @llvm.lifetime.start.p0(i64 %size, ptr nocapture %ptr)
diff --git a/llvm/test/Transforms/SROA/assume.ll b/llvm/test/Transforms/SROA/assume.ll
index 9043d49dce9b..fa619a4a9b86 100644
--- a/llvm/test/Transforms/SROA/assume.ll
+++ b/llvm/test/Transforms/SROA/assume.ll
@@ -13,15 +13,15 @@ target triple = "x86_64-unknown-linux-gnu"
define void @_ZN2bg2baIiEC2ES_(i64 %v) {
; CHECK-LABEL: @_ZN2bg2baIiEC2ES_(
; CHECK-NEXT: entry:
-; CHECK-NEXT: call void @llvm.assume(i1 true) [ "ignore"(%struct.bi* undef) ]
+; CHECK-NEXT: call void @llvm.assume(i1 true) [ "ignore"(ptr undef) ]
; CHECK-NEXT: ret void
;
entry:
%y = alloca i64, align 8
- store i64 %v, i64* %y, align 8
- %0 = bitcast i64* %y to %struct.n.2*
- %1 = bitcast %struct.n.2* %0 to %struct.bi*
- call void @llvm.assume(i1 true) [ "nonnull"(%struct.bi* %1) ]
+ store i64 %v, ptr %y, align 8
+ %0 = bitcast ptr %y to ptr
+ %1 = bitcast ptr %0 to ptr
+ call void @llvm.assume(i1 true) [ "nonnull"(ptr %1) ]
ret void
}
diff --git a/llvm/test/Transforms/SROA/basictest-opaque-ptrs.ll b/llvm/test/Transforms/SROA/basictest-opaque-ptrs.ll
deleted file mode 100644
index a524adda403e..000000000000
--- a/llvm/test/Transforms/SROA/basictest-opaque-ptrs.ll
+++ /dev/null
@@ -1,2159 +0,0 @@
-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -passes=sroa -opaque-pointers -S | FileCheck %s
-
-target datalayout = "e-p:64:64:64-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
-
-declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
-declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
-
-define i32 @test0() {
-; CHECK-LABEL: @test0(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[V2_INT:%.*]] = bitcast float 0.000000e+00 to i32
-; CHECK-NEXT: [[SUM1:%.*]] = add i32 0, [[V2_INT]]
-; CHECK-NEXT: ret i32 [[SUM1]]
-;
-
-entry:
- %a1 = alloca i32
- %a2 = alloca float
-
- %a1.i8 = bitcast i32* %a1 to i8*
- call void @llvm.lifetime.start.p0i8(i64 4, i8* %a1.i8)
-
- store i32 0, i32* %a1
- %v1 = load i32, i32* %a1
-
- call void @llvm.lifetime.end.p0i8(i64 4, i8* %a1.i8)
-
- %a2.i8 = bitcast float* %a2 to i8*
- call void @llvm.lifetime.start.p0i8(i64 4, i8* %a2.i8)
-
- store float 0.0, float* %a2
- %v2 = load float , float * %a2
- %v2.int = bitcast float %v2 to i32
- %sum1 = add i32 %v1, %v2.int
-
- call void @llvm.lifetime.end.p0i8(i64 4, i8* %a2.i8)
-
- ret i32 %sum1
-}
-
-define i32 @test1() {
-; CHECK-LABEL: @test1(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: ret i32 0
-;
-
-entry:
- %X = alloca { i32, float }
- %Y = getelementptr { i32, float }, { i32, float }* %X, i64 0, i32 0
- store i32 0, i32* %Y
- %Z = load i32, i32* %Y
- ret i32 %Z
-}
-
-define i64 @test2(i64 %X) {
-; CHECK-LABEL: @test2(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: br label [[L2:%.*]]
-; CHECK: L2:
-; CHECK-NEXT: ret i64 [[X:%.*]]
-;
-
-entry:
- %A = alloca [8 x i8]
- %B = bitcast [8 x i8]* %A to i64*
- store i64 %X, i64* %B
- br label %L2
-
-L2:
- %Z = load i64, i64* %B
- ret i64 %Z
-}
-
-define i64 @test2_addrspacecast(i64 %X) {
-; CHECK-LABEL: @test2_addrspacecast(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: br label [[L2:%.*]]
-; CHECK: L2:
-; CHECK-NEXT: ret i64 [[X:%.*]]
-;
-
-entry:
- %A = alloca [8 x i8]
- %B = addrspacecast [8 x i8]* %A to i64 addrspace(1)*
- store i64 %X, i64 addrspace(1)* %B
- br label %L2
-
-L2:
- %Z = load i64, i64 addrspace(1)* %B
- ret i64 %Z
-}
-
-define i64 @test2_addrspacecast_gep(i64 %X, i16 %idx) {
-; CHECK-LABEL: @test2_addrspacecast_gep(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: br label [[L2:%.*]]
-; CHECK: L2:
-; CHECK-NEXT: ret i64 [[X:%.*]]
-;
-
-entry:
- %A = alloca [256 x i8]
- %B = addrspacecast [256 x i8]* %A to i64 addrspace(1)*
- %gepA = getelementptr [256 x i8], [256 x i8]* %A, i16 0, i16 32
- %gepB = getelementptr i64, i64 addrspace(1)* %B, i16 4
- store i64 %X, i64 addrspace(1)* %gepB, align 1
- br label %L2
-
-L2:
- %gepA.bc = bitcast i8* %gepA to i64*
- %Z = load i64, i64* %gepA.bc, align 1
- ret i64 %Z
-}
-
-; Avoid crashing when load/storing at at
diff erent offsets.
-define i64 @test2_addrspacecast_gep_offset(i64 %X) {
-; CHECK-LABEL: @test2_addrspacecast_gep_offset(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[A_SROA_0:%.*]] = alloca [10 x i8], align 1
-; CHECK-NEXT: [[A_SROA_0_2_GEPB_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_0]], i16 2
-; CHECK-NEXT: [[A_SROA_0_2_GEPB_SROA_CAST:%.*]] = addrspacecast ptr [[A_SROA_0_2_GEPB_SROA_IDX]] to ptr addrspace(1)
-; CHECK-NEXT: store i64 [[X:%.*]], ptr addrspace(1) [[A_SROA_0_2_GEPB_SROA_CAST]], align 1
-; CHECK-NEXT: br label [[L2:%.*]]
-; CHECK: L2:
-; CHECK-NEXT: [[A_SROA_0_0_A_SROA_0_30_Z:%.*]] = load i64, ptr [[A_SROA_0]], align 1
-; CHECK-NEXT: ret i64 [[A_SROA_0_0_A_SROA_0_30_Z]]
-;
-
-entry:
- %A = alloca [256 x i8]
- %B = addrspacecast [256 x i8]* %A to i64 addrspace(1)*
- %gepA = getelementptr [256 x i8], [256 x i8]* %A, i16 0, i16 30
- %gepB = getelementptr i64, i64 addrspace(1)* %B, i16 4
- store i64 %X, i64 addrspace(1)* %gepB, align 1
- br label %L2
-
-L2:
- %gepA.bc = bitcast i8* %gepA to i64*
- %Z = load i64, i64* %gepA.bc, align 1
- ret i64 %Z
-}
-
-define void @test3(i8* %dst, i8* align 8 %src) {
-; CHECK-LABEL: @test3(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[A_SROA_0:%.*]] = alloca [42 x i8], align 1
-; CHECK-NEXT: [[A_SROA_3:%.*]] = alloca [99 x i8], align 1
-; CHECK-NEXT: [[A_SROA_32:%.*]] = alloca [16 x i8], align 1
-; CHECK-NEXT: [[A_SROA_15:%.*]] = alloca [42 x i8], align 1
-; CHECK-NEXT: [[A_SROA_16:%.*]] = alloca [7 x i8], align 1
-; CHECK-NEXT: [[A_SROA_234:%.*]] = alloca [7 x i8], align 1
-; CHECK-NEXT: [[A_SROA_31:%.*]] = alloca [85 x i8], align 1
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_0]], ptr align 8 [[SRC:%.*]], i32 42, i1 false), !tbaa [[TBAA0:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_2_0_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 42
-; CHECK-NEXT: [[A_SROA_2_0_COPYLOAD:%.*]] = load i8, ptr [[A_SROA_2_0_SRC_SROA_IDX]], align 2, !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_3_0_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 43
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_3]], ptr align 1 [[A_SROA_3_0_SRC_SROA_IDX]], i32 99, i1 false), !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_32_0_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 142
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_32]], ptr align 2 [[A_SROA_32_0_SRC_SROA_IDX]], i32 16, i1 false), !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_15_0_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 158
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_15]], ptr align 2 [[A_SROA_15_0_SRC_SROA_IDX]], i32 42, i1 false), !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_16_0_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 200
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_16]], ptr align 8 [[A_SROA_16_0_SRC_SROA_IDX]], i32 7, i1 false), !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_23_0_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 207
-; CHECK-NEXT: [[A_SROA_23_0_COPYLOAD:%.*]] = load i8, ptr [[A_SROA_23_0_SRC_SROA_IDX]], align 1, !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_234_0_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 208
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_234]], ptr align 8 [[A_SROA_234_0_SRC_SROA_IDX]], i32 7, i1 false), !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_31_0_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 215
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_31]], ptr align 1 [[A_SROA_31_0_SRC_SROA_IDX]], i32 85, i1 false), !tbaa [[TBAA0]]
-; CHECK-NEXT: store i8 1, ptr [[A_SROA_32]], align 1, !tbaa [[TBAA3:![0-9]+]]
-; CHECK-NEXT: store i16 1, ptr [[A_SROA_32]], align 1, !tbaa [[TBAA5:![0-9]+]]
-; CHECK-NEXT: store i32 1, ptr [[A_SROA_32]], align 1, !tbaa [[TBAA7:![0-9]+]]
-; CHECK-NEXT: store i64 1, ptr [[A_SROA_32]], align 1, !tbaa [[TBAA9:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_32_1_OVERLAP_2_I64_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_32]], i64 1
-; CHECK-NEXT: store i64 2, ptr [[A_SROA_32_1_OVERLAP_2_I64_SROA_IDX]], align 1, !tbaa [[TBAA11:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_32_2_OVERLAP_3_I64_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_32]], i64 2
-; CHECK-NEXT: store i64 3, ptr [[A_SROA_32_2_OVERLAP_3_I64_SROA_IDX]], align 1, !tbaa [[TBAA13:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_32_3_OVERLAP_4_I64_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_32]], i64 3
-; CHECK-NEXT: store i64 4, ptr [[A_SROA_32_3_OVERLAP_4_I64_SROA_IDX]], align 1, !tbaa [[TBAA15:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_32_4_OVERLAP_5_I64_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_32]], i64 4
-; CHECK-NEXT: store i64 5, ptr [[A_SROA_32_4_OVERLAP_5_I64_SROA_IDX]], align 1, !tbaa [[TBAA17:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_32_5_OVERLAP_6_I64_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_32]], i64 5
-; CHECK-NEXT: store i64 6, ptr [[A_SROA_32_5_OVERLAP_6_I64_SROA_IDX]], align 1, !tbaa [[TBAA19:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_32_6_OVERLAP_7_I64_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_32]], i64 6
-; CHECK-NEXT: store i64 7, ptr [[A_SROA_32_6_OVERLAP_7_I64_SROA_IDX]], align 1, !tbaa [[TBAA21:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_32_7_OVERLAP_8_I64_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_32]], i64 7
-; CHECK-NEXT: store i64 8, ptr [[A_SROA_32_7_OVERLAP_8_I64_SROA_IDX]], align 1, !tbaa [[TBAA23:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_32_8_OVERLAP_9_I64_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_32]], i64 8
-; CHECK-NEXT: store i64 9, ptr [[A_SROA_32_8_OVERLAP_9_I64_SROA_IDX]], align 1, !tbaa [[TBAA25:![0-9]+]]
-; CHECK-NEXT: store i8 1, ptr [[A_SROA_16]], align 1, !tbaa [[TBAA27:![0-9]+]]
-; CHECK-NEXT: store i16 1, ptr [[A_SROA_16]], align 1, !tbaa [[TBAA29:![0-9]+]]
-; CHECK-NEXT: store i32 1, ptr [[A_SROA_16]], align 1, !tbaa [[TBAA31:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_16_1_OVERLAP2_1_1_I32_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_16]], i64 1
-; CHECK-NEXT: store i32 2, ptr [[A_SROA_16_1_OVERLAP2_1_1_I32_SROA_IDX]], align 1, !tbaa [[TBAA33:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_16_2_OVERLAP2_1_2_I32_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_16]], i64 2
-; CHECK-NEXT: store i32 3, ptr [[A_SROA_16_2_OVERLAP2_1_2_I32_SROA_IDX]], align 1, !tbaa [[TBAA35:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_16_3_OVERLAP2_1_3_I32_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_16]], i64 3
-; CHECK-NEXT: store i32 4, ptr [[A_SROA_16_3_OVERLAP2_1_3_I32_SROA_IDX]], align 1, !tbaa [[TBAA37:![0-9]+]]
-; CHECK-NEXT: store i32 1, ptr [[A_SROA_234]], align 1, !tbaa [[TBAA39:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_234_1_OVERLAP2_2_1_I8_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_234]], i64 1
-; CHECK-NEXT: store i8 1, ptr [[A_SROA_234_1_OVERLAP2_2_1_I8_SROA_IDX]], align 1, !tbaa [[TBAA41:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_234_1_OVERLAP2_2_1_I16_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_234]], i64 1
-; CHECK-NEXT: store i16 1, ptr [[A_SROA_234_1_OVERLAP2_2_1_I16_SROA_IDX]], align 1, !tbaa [[TBAA43:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_234_1_OVERLAP2_2_1_I32_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_234]], i64 1
-; CHECK-NEXT: store i32 1, ptr [[A_SROA_234_1_OVERLAP2_2_1_I32_SROA_IDX]], align 1, !tbaa [[TBAA45:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_234_2_OVERLAP2_2_2_I32_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_234]], i64 2
-; CHECK-NEXT: store i32 3, ptr [[A_SROA_234_2_OVERLAP2_2_2_I32_SROA_IDX]], align 1, !tbaa [[TBAA47:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_234_3_OVERLAP2_2_3_I32_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_234]], i64 3
-; CHECK-NEXT: store i32 4, ptr [[A_SROA_234_3_OVERLAP2_2_3_I32_SROA_IDX]], align 1, !tbaa [[TBAA49:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_15_197_OVERLAP2_PREFIX_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_15]], i64 39
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_15_197_OVERLAP2_PREFIX_SROA_IDX]], ptr align 1 [[SRC]], i32 3, i1 false), !tbaa [[TBAA51:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_16_197_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 3
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_16]], ptr align 1 [[A_SROA_16_197_SRC_SROA_IDX]], i32 5, i1 false), !tbaa [[TBAA51]]
-; CHECK-NEXT: [[A_SROA_16_2_OVERLAP2_1_2_I8_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_16]], i64 2
-; CHECK-NEXT: call void @llvm.memset.p0.i32(ptr align 1 [[A_SROA_16_2_OVERLAP2_1_2_I8_SROA_IDX]], i8 42, i32 5, i1 false), !tbaa [[TBAA53:![0-9]+]]
-; CHECK-NEXT: call void @llvm.memset.p0.i32(ptr align 1 [[A_SROA_234]], i8 42, i32 2, i1 false), !tbaa [[TBAA53]]
-; CHECK-NEXT: [[A_SROA_234_209_OVERLAP2_2_1_I8_SROA_IDX5:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_234]], i64 1
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_234_209_OVERLAP2_2_1_I8_SROA_IDX5]], ptr align 1 [[SRC]], i32 5, i1 false), !tbaa [[TBAA55:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_234_210_OVERLAP2_2_2_I8_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_234]], i64 2
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_234_210_OVERLAP2_2_2_I8_SROA_IDX]], ptr align 1 [[SRC]], i32 5, i1 false), !tbaa [[TBAA57:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_31_210_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 5
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_31]], ptr align 1 [[A_SROA_31_210_SRC_SROA_IDX]], i32 3, i1 false), !tbaa [[TBAA57]]
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[DST:%.*]], ptr align 1 [[A_SROA_0]], i32 42, i1 false), !tbaa [[TBAA59:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_2_0_DST_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 42
-; CHECK-NEXT: store i8 0, ptr [[A_SROA_2_0_DST_SROA_IDX]], align 1, !tbaa [[TBAA59]]
-; CHECK-NEXT: [[A_SROA_3_0_DST_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 43
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_3_0_DST_SROA_IDX]], ptr align 1 [[A_SROA_3]], i32 99, i1 false), !tbaa [[TBAA59]]
-; CHECK-NEXT: [[A_SROA_32_0_DST_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 142
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_32_0_DST_SROA_IDX]], ptr align 1 [[A_SROA_32]], i32 16, i1 false), !tbaa [[TBAA59]]
-; CHECK-NEXT: [[A_SROA_15_0_DST_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 158
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_15_0_DST_SROA_IDX]], ptr align 1 [[A_SROA_15]], i32 42, i1 false), !tbaa [[TBAA59]]
-; CHECK-NEXT: [[A_SROA_16_0_DST_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 200
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_16_0_DST_SROA_IDX]], ptr align 1 [[A_SROA_16]], i32 7, i1 false), !tbaa [[TBAA59]]
-; CHECK-NEXT: [[A_SROA_23_0_DST_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 207
-; CHECK-NEXT: store i8 42, ptr [[A_SROA_23_0_DST_SROA_IDX]], align 1, !tbaa [[TBAA59]]
-; CHECK-NEXT: [[A_SROA_234_0_DST_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 208
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_234_0_DST_SROA_IDX]], ptr align 1 [[A_SROA_234]], i32 7, i1 false), !tbaa [[TBAA59]]
-; CHECK-NEXT: [[A_SROA_31_0_DST_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 215
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_31_0_DST_SROA_IDX]], ptr align 1 [[A_SROA_31]], i32 85, i1 false), !tbaa [[TBAA59]]
-; CHECK-NEXT: ret void
-;
-
-entry:
- %a = alloca [300 x i8]
-
- %b = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 0
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %b, i8* align 8 %src, i32 300, i1 false), !tbaa !0
-
- ; Clobber a single element of the array, this should be promotable, and be deleted.
- %c = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 42
- store i8 0, i8* %c
-
- ; Make a sequence of overlapping stores to the array. These overlap both in
- ; forward strides and in shrinking accesses.
- %overlap.1.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 142
- %overlap.2.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 143
- %overlap.3.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 144
- %overlap.4.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 145
- %overlap.5.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 146
- %overlap.6.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 147
- %overlap.7.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 148
- %overlap.8.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 149
- %overlap.9.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 150
- %overlap.1.i16 = bitcast i8* %overlap.1.i8 to i16*
- %overlap.1.i32 = bitcast i8* %overlap.1.i8 to i32*
- %overlap.1.i64 = bitcast i8* %overlap.1.i8 to i64*
- %overlap.2.i64 = bitcast i8* %overlap.2.i8 to i64*
- %overlap.3.i64 = bitcast i8* %overlap.3.i8 to i64*
- %overlap.4.i64 = bitcast i8* %overlap.4.i8 to i64*
- %overlap.5.i64 = bitcast i8* %overlap.5.i8 to i64*
- %overlap.6.i64 = bitcast i8* %overlap.6.i8 to i64*
- %overlap.7.i64 = bitcast i8* %overlap.7.i8 to i64*
- %overlap.8.i64 = bitcast i8* %overlap.8.i8 to i64*
- %overlap.9.i64 = bitcast i8* %overlap.9.i8 to i64*
- store i8 1, i8* %overlap.1.i8, !tbaa !3
- store i16 1, i16* %overlap.1.i16, !tbaa !5
- store i32 1, i32* %overlap.1.i32, !tbaa !7
- store i64 1, i64* %overlap.1.i64, !tbaa !9
- store i64 2, i64* %overlap.2.i64, !tbaa !11
- store i64 3, i64* %overlap.3.i64, !tbaa !13
- store i64 4, i64* %overlap.4.i64, !tbaa !15
- store i64 5, i64* %overlap.5.i64, !tbaa !17
- store i64 6, i64* %overlap.6.i64, !tbaa !19
- store i64 7, i64* %overlap.7.i64, !tbaa !21
- store i64 8, i64* %overlap.8.i64, !tbaa !23
- store i64 9, i64* %overlap.9.i64, !tbaa !25
-
- ; Make two sequences of overlapping stores with more gaps and irregularities.
- %overlap2.1.0.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 200
- %overlap2.1.1.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 201
- %overlap2.1.2.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 202
- %overlap2.1.3.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 203
-
- %overlap2.2.0.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 208
- %overlap2.2.1.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 209
- %overlap2.2.2.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 210
- %overlap2.2.3.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 211
-
- %overlap2.1.0.i16 = bitcast i8* %overlap2.1.0.i8 to i16*
- %overlap2.1.0.i32 = bitcast i8* %overlap2.1.0.i8 to i32*
- %overlap2.1.1.i32 = bitcast i8* %overlap2.1.1.i8 to i32*
- %overlap2.1.2.i32 = bitcast i8* %overlap2.1.2.i8 to i32*
- %overlap2.1.3.i32 = bitcast i8* %overlap2.1.3.i8 to i32*
- store i8 1, i8* %overlap2.1.0.i8, !tbaa !27
- store i16 1, i16* %overlap2.1.0.i16, !tbaa !29
- store i32 1, i32* %overlap2.1.0.i32, !tbaa !31
- store i32 2, i32* %overlap2.1.1.i32, !tbaa !33
- store i32 3, i32* %overlap2.1.2.i32, !tbaa !35
- store i32 4, i32* %overlap2.1.3.i32, !tbaa !37
-
- %overlap2.2.0.i32 = bitcast i8* %overlap2.2.0.i8 to i32*
- %overlap2.2.1.i16 = bitcast i8* %overlap2.2.1.i8 to i16*
- %overlap2.2.1.i32 = bitcast i8* %overlap2.2.1.i8 to i32*
- %overlap2.2.2.i32 = bitcast i8* %overlap2.2.2.i8 to i32*
- %overlap2.2.3.i32 = bitcast i8* %overlap2.2.3.i8 to i32*
- store i32 1, i32* %overlap2.2.0.i32, !tbaa !39
- store i8 1, i8* %overlap2.2.1.i8, !tbaa !41
- store i16 1, i16* %overlap2.2.1.i16, !tbaa !43
- store i32 1, i32* %overlap2.2.1.i32, !tbaa !45
- store i32 3, i32* %overlap2.2.2.i32, !tbaa !47
- store i32 4, i32* %overlap2.2.3.i32, !tbaa !49
-
- %overlap2.prefix = getelementptr i8, i8* %overlap2.1.1.i8, i64 -4
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %overlap2.prefix, i8* %src, i32 8, i1 false), !tbaa !51
-
- ; Bridge between the overlapping areas
- call void @llvm.memset.p0i8.i32(i8* %overlap2.1.2.i8, i8 42, i32 8, i1 false), !tbaa !53
-; ...promoted i8 store...
-
- ; Entirely within the second overlap.
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %overlap2.2.1.i8, i8* %src, i32 5, i1 false), !tbaa !55
-
- ; Trailing past the second overlap.
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %overlap2.2.2.i8, i8* %src, i32 8, i1 false), !tbaa !57
-
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %b, i32 300, i1 false), !tbaa !59
-
- ret void
-}
-
-define void @test4(i8* %dst, i8* %src) {
-; CHECK-LABEL: @test4(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[A_SROA_0:%.*]] = alloca [20 x i8], align 1
-; CHECK-NEXT: [[A_SROA_2_SROA_4:%.*]] = alloca [7 x i8], align 1
-; CHECK-NEXT: [[A_SROA_3:%.*]] = alloca [10 x i8], align 1
-; CHECK-NEXT: [[A_SROA_31_SROA_5:%.*]] = alloca [7 x i8], align 1
-; CHECK-NEXT: [[A_SROA_6_SROA_4:%.*]] = alloca [7 x i8], align 1
-; CHECK-NEXT: [[A_SROA_7:%.*]] = alloca [40 x i8], align 1
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_0]], ptr align 1 [[SRC:%.*]], i32 20, i1 false), !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_2_0_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 20
-; CHECK-NEXT: [[A_SROA_2_SROA_0_0_COPYLOAD:%.*]] = load i16, ptr [[A_SROA_2_0_SRC_SROA_IDX]], align 1, !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_2_SROA_3_0_A_SROA_2_0_SRC_SROA_IDX_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_2_0_SRC_SROA_IDX]], i64 2
-; CHECK-NEXT: [[A_SROA_2_SROA_3_0_COPYLOAD:%.*]] = load i8, ptr [[A_SROA_2_SROA_3_0_A_SROA_2_0_SRC_SROA_IDX_SROA_IDX]], align 1, !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_2_SROA_4_0_A_SROA_2_0_SRC_SROA_IDX_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_2_0_SRC_SROA_IDX]], i64 3
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_2_SROA_4]], ptr align 1 [[A_SROA_2_SROA_4_0_A_SROA_2_0_SRC_SROA_IDX_SROA_IDX]], i32 7, i1 false), !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_3_0_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 30
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_3]], ptr align 1 [[A_SROA_3_0_SRC_SROA_IDX]], i32 10, i1 false), !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_31_0_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 40
-; CHECK-NEXT: [[A_SROA_31_SROA_0_0_COPYLOAD:%.*]] = load i16, ptr [[A_SROA_31_0_SRC_SROA_IDX]], align 1, !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_31_SROA_4_0_A_SROA_31_0_SRC_SROA_IDX_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_31_0_SRC_SROA_IDX]], i64 2
-; CHECK-NEXT: [[A_SROA_31_SROA_4_0_COPYLOAD:%.*]] = load i8, ptr [[A_SROA_31_SROA_4_0_A_SROA_31_0_SRC_SROA_IDX_SROA_IDX]], align 1, !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_31_SROA_5_0_A_SROA_31_0_SRC_SROA_IDX_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_31_0_SRC_SROA_IDX]], i64 3
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_31_SROA_5]], ptr align 1 [[A_SROA_31_SROA_5_0_A_SROA_31_0_SRC_SROA_IDX_SROA_IDX]], i32 7, i1 false), !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_6_0_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 50
-; CHECK-NEXT: [[A_SROA_6_SROA_0_0_COPYLOAD:%.*]] = load i16, ptr [[A_SROA_6_0_SRC_SROA_IDX]], align 1, !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_6_SROA_3_0_A_SROA_6_0_SRC_SROA_IDX_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_6_0_SRC_SROA_IDX]], i64 2
-; CHECK-NEXT: [[A_SROA_6_SROA_3_0_COPYLOAD:%.*]] = load i8, ptr [[A_SROA_6_SROA_3_0_A_SROA_6_0_SRC_SROA_IDX_SROA_IDX]], align 1, !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_6_SROA_4_0_A_SROA_6_0_SRC_SROA_IDX_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_6_0_SRC_SROA_IDX]], i64 3
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_6_SROA_4]], ptr align 1 [[A_SROA_6_SROA_4_0_A_SROA_6_0_SRC_SROA_IDX_SROA_IDX]], i32 7, i1 false), !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_7_0_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 60
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_7]], ptr align 1 [[A_SROA_7_0_SRC_SROA_IDX]], i32 40, i1 false), !tbaa [[TBAA0]]
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_31_SROA_5]], ptr align 1 [[A_SROA_2_SROA_4]], i32 7, i1 false), !tbaa [[TBAA3]]
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_31_SROA_5]], ptr align 1 [[A_SROA_6_SROA_4]], i32 7, i1 false), !tbaa [[TBAA5]]
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[DST:%.*]], ptr align 1 [[A_SROA_0]], i32 20, i1 false), !tbaa [[TBAA7]]
-; CHECK-NEXT: [[A_SROA_2_0_DST_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 20
-; CHECK-NEXT: store i16 [[A_SROA_2_SROA_0_0_COPYLOAD]], ptr [[A_SROA_2_0_DST_SROA_IDX]], align 1, !tbaa [[TBAA7]]
-; CHECK-NEXT: [[A_SROA_2_SROA_3_0_A_SROA_2_0_DST_SROA_IDX_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_2_0_DST_SROA_IDX]], i64 2
-; CHECK-NEXT: store i8 [[A_SROA_2_SROA_3_0_COPYLOAD]], ptr [[A_SROA_2_SROA_3_0_A_SROA_2_0_DST_SROA_IDX_SROA_IDX]], align 1, !tbaa [[TBAA7]]
-; CHECK-NEXT: [[A_SROA_2_SROA_4_0_A_SROA_2_0_DST_SROA_IDX_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_2_0_DST_SROA_IDX]], i64 3
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_2_SROA_4_0_A_SROA_2_0_DST_SROA_IDX_SROA_IDX]], ptr align 1 [[A_SROA_2_SROA_4]], i32 7, i1 false), !tbaa [[TBAA7]]
-; CHECK-NEXT: [[A_SROA_3_0_DST_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 30
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_3_0_DST_SROA_IDX]], ptr align 1 [[A_SROA_3]], i32 10, i1 false), !tbaa [[TBAA7]]
-; CHECK-NEXT: [[A_SROA_31_0_DST_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 40
-; CHECK-NEXT: store i16 [[A_SROA_6_SROA_0_0_COPYLOAD]], ptr [[A_SROA_31_0_DST_SROA_IDX]], align 1, !tbaa [[TBAA7]]
-; CHECK-NEXT: [[A_SROA_31_SROA_4_0_A_SROA_31_0_DST_SROA_IDX_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_31_0_DST_SROA_IDX]], i64 2
-; CHECK-NEXT: store i8 [[A_SROA_6_SROA_3_0_COPYLOAD]], ptr [[A_SROA_31_SROA_4_0_A_SROA_31_0_DST_SROA_IDX_SROA_IDX]], align 1, !tbaa [[TBAA7]]
-; CHECK-NEXT: [[A_SROA_31_SROA_5_0_A_SROA_31_0_DST_SROA_IDX_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_31_0_DST_SROA_IDX]], i64 3
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_31_SROA_5_0_A_SROA_31_0_DST_SROA_IDX_SROA_IDX]], ptr align 1 [[A_SROA_31_SROA_5]], i32 7, i1 false), !tbaa [[TBAA7]]
-; CHECK-NEXT: [[A_SROA_6_0_DST_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 50
-; CHECK-NEXT: store i16 [[A_SROA_6_SROA_0_0_COPYLOAD]], ptr [[A_SROA_6_0_DST_SROA_IDX]], align 1, !tbaa [[TBAA7]]
-; CHECK-NEXT: [[A_SROA_6_SROA_3_0_A_SROA_6_0_DST_SROA_IDX_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_6_0_DST_SROA_IDX]], i64 2
-; CHECK-NEXT: store i8 [[A_SROA_6_SROA_3_0_COPYLOAD]], ptr [[A_SROA_6_SROA_3_0_A_SROA_6_0_DST_SROA_IDX_SROA_IDX]], align 1, !tbaa [[TBAA7]]
-; CHECK-NEXT: [[A_SROA_6_SROA_4_0_A_SROA_6_0_DST_SROA_IDX_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_6_0_DST_SROA_IDX]], i64 3
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_6_SROA_4_0_A_SROA_6_0_DST_SROA_IDX_SROA_IDX]], ptr align 1 [[A_SROA_6_SROA_4]], i32 7, i1 false), !tbaa [[TBAA7]]
-; CHECK-NEXT: [[A_SROA_7_0_DST_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 60
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_7_0_DST_SROA_IDX]], ptr align 1 [[A_SROA_7]], i32 40, i1 false), !tbaa [[TBAA7]]
-; CHECK-NEXT: ret void
-;
-
-entry:
- %a = alloca [100 x i8]
-
- %b = getelementptr [100 x i8], [100 x i8]* %a, i64 0, i64 0
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %b, i8* %src, i32 100, i1 false), !tbaa !0
-
- %a.src.1 = getelementptr [100 x i8], [100 x i8]* %a, i64 0, i64 20
- %a.dst.1 = getelementptr [100 x i8], [100 x i8]* %a, i64 0, i64 40
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %a.dst.1, i8* %a.src.1, i32 10, i1 false), !tbaa !3
-
- ; Clobber a single element of the array, this should be promotable, and be deleted.
- %c = getelementptr [100 x i8], [100 x i8]* %a, i64 0, i64 42
- store i8 0, i8* %c
-
- %a.src.2 = getelementptr [100 x i8], [100 x i8]* %a, i64 0, i64 50
- call void @llvm.memmove.p0i8.p0i8.i32(i8* %a.dst.1, i8* %a.src.2, i32 10, i1 false), !tbaa !5
-
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %b, i32 100, i1 false), !tbaa !7
-
- ret void
-}
-
-declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i1) nounwind
-declare void @llvm.memcpy.p1i8.p0i8.i32(i8 addrspace(1)* nocapture, i8* nocapture, i32, i1) nounwind
-declare void @llvm.memmove.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i1) nounwind
-declare void @llvm.memset.p0i8.i32(i8* nocapture, i8, i32, i1) nounwind
-
-define i16 @test5() {
-; CHECK-LABEL: @test5(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[TMP0:%.*]] = bitcast float 0.000000e+00 to i32
-; CHECK-NEXT: [[A_SROA_0_2_EXTRACT_SHIFT:%.*]] = lshr i32 [[TMP0]], 16
-; CHECK-NEXT: [[A_SROA_0_2_EXTRACT_TRUNC:%.*]] = trunc i32 [[A_SROA_0_2_EXTRACT_SHIFT]] to i16
-; CHECK-NEXT: ret i16 [[A_SROA_0_2_EXTRACT_TRUNC]]
-;
-
-entry:
- %a = alloca [4 x i8]
- %fptr = bitcast [4 x i8]* %a to float*
- store float 0.0, float* %fptr
- %ptr = getelementptr [4 x i8], [4 x i8]* %a, i32 0, i32 2
- %iptr = bitcast i8* %ptr to i16*
- %val = load i16, i16* %iptr
- ret i16 %val
-}
-
-define i16 @test5_multi_addrspace_access() {
-; CHECK-LABEL: @test5_multi_addrspace_access(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[TMP0:%.*]] = bitcast float 0.000000e+00 to i32
-; CHECK-NEXT: [[A_SROA_0_2_EXTRACT_SHIFT:%.*]] = lshr i32 [[TMP0]], 16
-; CHECK-NEXT: [[A_SROA_0_2_EXTRACT_TRUNC:%.*]] = trunc i32 [[A_SROA_0_2_EXTRACT_SHIFT]] to i16
-; CHECK-NEXT: ret i16 [[A_SROA_0_2_EXTRACT_TRUNC]]
-;
-
-entry:
- %a = alloca [4 x i8]
- %fptr = bitcast [4 x i8]* %a to float*
- %fptr.as1 = addrspacecast float* %fptr to float addrspace(1)*
- store float 0.0, float addrspace(1)* %fptr.as1
- %ptr = getelementptr [4 x i8], [4 x i8]* %a, i32 0, i32 2
- %iptr = bitcast i8* %ptr to i16*
- %val = load i16, i16* %iptr
- ret i16 %val
-}
-
-define i32 @test6() {
-; CHECK-LABEL: @test6(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[A_SROA_0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store volatile i32 707406378, ptr [[A_SROA_0]], align 4
-; CHECK-NEXT: [[A_SROA_0_0_A_SROA_0_0_VAL:%.*]] = load i32, ptr [[A_SROA_0]], align 4
-; CHECK-NEXT: ret i32 [[A_SROA_0_0_A_SROA_0_0_VAL]]
-;
-
-entry:
- %a = alloca [4 x i8]
- %ptr = getelementptr [4 x i8], [4 x i8]* %a, i32 0, i32 0
- call void @llvm.memset.p0i8.i32(i8* %ptr, i8 42, i32 4, i1 true)
- %iptr = bitcast i8* %ptr to i32*
- %val = load i32, i32* %iptr
- ret i32 %val
-}
-
-define void @test7(i8* %src, i8* %dst) {
-; CHECK-LABEL: @test7(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[A_SROA_0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[A_SROA_0_0_COPYLOAD:%.*]] = load volatile i32, ptr [[SRC:%.*]], align 1, !tbaa [[TBAA0]]
-; CHECK-NEXT: store volatile i32 [[A_SROA_0_0_COPYLOAD]], ptr [[A_SROA_0]], align 4, !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_0_0_A_SROA_0_0_COPYLOAD1:%.*]] = load volatile i32, ptr [[A_SROA_0]], align 4, !tbaa [[TBAA3]]
-; CHECK-NEXT: store volatile i32 [[A_SROA_0_0_A_SROA_0_0_COPYLOAD1]], ptr [[DST:%.*]], align 1, !tbaa [[TBAA3]]
-; CHECK-NEXT: ret void
-;
-
-entry:
- %a = alloca [4 x i8]
- %ptr = getelementptr [4 x i8], [4 x i8]* %a, i32 0, i32 0
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %ptr, i8* %src, i32 4, i1 true), !tbaa !0
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %ptr, i32 4, i1 true), !tbaa !3
- ret void
-}
-
-
-%S1 = type { i32, i32, [16 x i8] }
-%S2 = type { %S1*, %S2* }
-
-define %S2 @test8(%S2* %arg) {
-; CHECK-LABEL: @test8(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[S2_NEXT_PTR:%.*]] = getelementptr [[S2:%.*]], ptr [[ARG:%.*]], i64 0, i32 1
-; CHECK-NEXT: [[S2_NEXT:%.*]] = load ptr, ptr [[S2_NEXT_PTR]], align 8, !tbaa [[TBAA0]]
-; CHECK-NEXT: [[S2_NEXT_S1_PTR:%.*]] = getelementptr [[S2]], ptr [[S2_NEXT]], i64 0, i32 0
-; CHECK-NEXT: [[S2_NEXT_S1:%.*]] = load ptr, ptr [[S2_NEXT_S1_PTR]], align 8, !tbaa [[TBAA3]]
-; CHECK-NEXT: [[S2_NEXT_NEXT_PTR:%.*]] = getelementptr [[S2]], ptr [[S2_NEXT]], i64 0, i32 1
-; CHECK-NEXT: [[S2_NEXT_NEXT:%.*]] = load ptr, ptr [[S2_NEXT_NEXT_PTR]], align 8, !tbaa [[TBAA7]]
-; CHECK-NEXT: [[RESULT1:%.*]] = insertvalue [[S2]] poison, ptr [[S2_NEXT_S1]], 0
-; CHECK-NEXT: [[RESULT2:%.*]] = insertvalue [[S2]] [[RESULT1]], ptr [[S2_NEXT_NEXT]], 1
-; CHECK-NEXT: ret [[S2]] [[RESULT2]]
-;
-entry:
- %new = alloca %S2
-
- %s2.next.ptr = getelementptr %S2, %S2* %arg, i64 0, i32 1
- %s2.next = load %S2*, %S2** %s2.next.ptr, !tbaa !0
-
- %s2.next.s1.ptr = getelementptr %S2, %S2* %s2.next, i64 0, i32 0
- %s2.next.s1 = load %S1*, %S1** %s2.next.s1.ptr, !tbaa !3
- %new.s1.ptr = getelementptr %S2, %S2* %new, i64 0, i32 0
- store %S1* %s2.next.s1, %S1** %new.s1.ptr, !tbaa !5
- %s2.next.next.ptr = getelementptr %S2, %S2* %s2.next, i64 0, i32 1
- %s2.next.next = load %S2*, %S2** %s2.next.next.ptr, !tbaa !7
- %new.next.ptr = getelementptr %S2, %S2* %new, i64 0, i32 1
- store %S2* %s2.next.next, %S2** %new.next.ptr, !tbaa !9
-
- %new.s1 = load %S1*, %S1** %new.s1.ptr
- %result1 = insertvalue %S2 poison, %S1* %new.s1, 0
- %new.next = load %S2*, %S2** %new.next.ptr
- %result2 = insertvalue %S2 %result1, %S2* %new.next, 1
- ret %S2 %result2
-}
-
-define i64 @test9() {
-; Ensure we can handle loads off the end of an alloca even when wrapped in
-; weird bit casts and types. This is valid IR due to the alignment and masking
-; off the bits past the end of the alloca.
-;
-; CHECK-LABEL: @test9(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[A_SROA_3_0_INSERT_EXT:%.*]] = zext i8 26 to i64
-; CHECK-NEXT: [[A_SROA_3_0_INSERT_SHIFT:%.*]] = shl i64 [[A_SROA_3_0_INSERT_EXT]], 16
-; CHECK-NEXT: [[A_SROA_3_0_INSERT_MASK:%.*]] = and i64 undef, -16711681
-; CHECK-NEXT: [[A_SROA_3_0_INSERT_INSERT:%.*]] = or i64 [[A_SROA_3_0_INSERT_MASK]], [[A_SROA_3_0_INSERT_SHIFT]]
-; CHECK-NEXT: [[A_SROA_2_0_INSERT_EXT:%.*]] = zext i8 0 to i64
-; CHECK-NEXT: [[A_SROA_2_0_INSERT_SHIFT:%.*]] = shl i64 [[A_SROA_2_0_INSERT_EXT]], 8
-; CHECK-NEXT: [[A_SROA_2_0_INSERT_MASK:%.*]] = and i64 [[A_SROA_3_0_INSERT_INSERT]], -65281
-; CHECK-NEXT: [[A_SROA_2_0_INSERT_INSERT:%.*]] = or i64 [[A_SROA_2_0_INSERT_MASK]], [[A_SROA_2_0_INSERT_SHIFT]]
-; CHECK-NEXT: [[A_SROA_0_0_INSERT_EXT:%.*]] = zext i8 0 to i64
-; CHECK-NEXT: [[A_SROA_0_0_INSERT_MASK:%.*]] = and i64 [[A_SROA_2_0_INSERT_INSERT]], -256
-; CHECK-NEXT: [[A_SROA_0_0_INSERT_INSERT:%.*]] = or i64 [[A_SROA_0_0_INSERT_MASK]], [[A_SROA_0_0_INSERT_EXT]]
-; CHECK-NEXT: [[RESULT:%.*]] = and i64 [[A_SROA_0_0_INSERT_INSERT]], 16777215
-; CHECK-NEXT: ret i64 [[RESULT]]
-;
-
-entry:
- %a = alloca { [3 x i8] }, align 8
- %gep1 = getelementptr inbounds { [3 x i8] }, { [3 x i8] }* %a, i32 0, i32 0, i32 0
- store i8 0, i8* %gep1, align 1
- %gep2 = getelementptr inbounds { [3 x i8] }, { [3 x i8] }* %a, i32 0, i32 0, i32 1
- store i8 0, i8* %gep2, align 1
- %gep3 = getelementptr inbounds { [3 x i8] }, { [3 x i8] }* %a, i32 0, i32 0, i32 2
- store i8 26, i8* %gep3, align 1
- %cast = bitcast { [3 x i8] }* %a to { i64 }*
- %elt = getelementptr inbounds { i64 }, { i64 }* %cast, i32 0, i32 0
- %load = load i64, i64* %elt
- %result = and i64 %load, 16777215
- ret i64 %result
-}
-
-define %S2* @test10() {
-; CHECK-LABEL: @test10(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[TMP0:%.*]] = ptrtoint ptr null to i64
-; CHECK-NEXT: ret ptr null
-;
-
-entry:
- %a = alloca [8 x i8]
- %ptr = getelementptr [8 x i8], [8 x i8]* %a, i32 0, i32 0
- call void @llvm.memset.p0i8.i32(i8* %ptr, i8 0, i32 8, i1 false)
- %s2ptrptr = bitcast i8* %ptr to %S2**
- %s2ptr = load %S2*, %S2** %s2ptrptr
- ret %S2* %s2ptr
-}
-
-define i32 @test11(i1 %c) {
-; CHECK-LABEL: @test11(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: br i1 [[C:%.*]], label [[GOOD:%.*]], label [[BAD:%.*]]
-; CHECK: good:
-; CHECK-NEXT: ret i32 0
-; CHECK: bad:
-; CHECK-NEXT: ret i32 poison
-;
-
-entry:
- %X = alloca i32
- br i1 %c, label %good, label %bad
-
-good:
- %Y = getelementptr i32, i32* %X, i64 0
- store i32 0, i32* %Y
- %Z = load i32, i32* %Y
- ret i32 %Z
-
-bad:
- %Y2 = getelementptr i32, i32* %X, i64 1
- store i32 0, i32* %Y2
- %Z2 = load i32, i32* %Y2
- ret i32 %Z2
-}
-
-define i8 @test12() {
-; We fully promote these to the i24 load or store size, resulting in just masks
-; and other operations that instcombine will fold, but no alloca.
-;
-; CHECK-LABEL: @test12(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[A_SROA_3_0_INSERT_EXT:%.*]] = zext i8 0 to i24
-; CHECK-NEXT: [[A_SROA_3_0_INSERT_SHIFT:%.*]] = shl i24 [[A_SROA_3_0_INSERT_EXT]], 16
-; CHECK-NEXT: [[A_SROA_3_0_INSERT_MASK:%.*]] = and i24 undef, 65535
-; CHECK-NEXT: [[A_SROA_3_0_INSERT_INSERT:%.*]] = or i24 [[A_SROA_3_0_INSERT_MASK]], [[A_SROA_3_0_INSERT_SHIFT]]
-; CHECK-NEXT: [[A_SROA_2_0_INSERT_EXT:%.*]] = zext i8 0 to i24
-; CHECK-NEXT: [[A_SROA_2_0_INSERT_SHIFT:%.*]] = shl i24 [[A_SROA_2_0_INSERT_EXT]], 8
-; CHECK-NEXT: [[A_SROA_2_0_INSERT_MASK:%.*]] = and i24 [[A_SROA_3_0_INSERT_INSERT]], -65281
-; CHECK-NEXT: [[A_SROA_2_0_INSERT_INSERT:%.*]] = or i24 [[A_SROA_2_0_INSERT_MASK]], [[A_SROA_2_0_INSERT_SHIFT]]
-; CHECK-NEXT: [[A_SROA_0_0_INSERT_EXT:%.*]] = zext i8 0 to i24
-; CHECK-NEXT: [[A_SROA_0_0_INSERT_MASK:%.*]] = and i24 [[A_SROA_2_0_INSERT_INSERT]], -256
-; CHECK-NEXT: [[A_SROA_0_0_INSERT_INSERT:%.*]] = or i24 [[A_SROA_0_0_INSERT_MASK]], [[A_SROA_0_0_INSERT_EXT]]
-; CHECK-NEXT: [[B_SROA_0_0_EXTRACT_TRUNC:%.*]] = trunc i24 [[A_SROA_0_0_INSERT_INSERT]] to i8
-; CHECK-NEXT: [[B_SROA_2_0_EXTRACT_SHIFT:%.*]] = lshr i24 [[A_SROA_0_0_INSERT_INSERT]], 8
-; CHECK-NEXT: [[B_SROA_2_0_EXTRACT_TRUNC:%.*]] = trunc i24 [[B_SROA_2_0_EXTRACT_SHIFT]] to i8
-; CHECK-NEXT: [[B_SROA_3_0_EXTRACT_SHIFT:%.*]] = lshr i24 [[A_SROA_0_0_INSERT_INSERT]], 16
-; CHECK-NEXT: [[B_SROA_3_0_EXTRACT_TRUNC:%.*]] = trunc i24 [[B_SROA_3_0_EXTRACT_SHIFT]] to i8
-; CHECK-NEXT: [[BSUM0:%.*]] = add i8 [[B_SROA_0_0_EXTRACT_TRUNC]], [[B_SROA_2_0_EXTRACT_TRUNC]]
-; CHECK-NEXT: [[BSUM1:%.*]] = add i8 [[BSUM0]], [[B_SROA_3_0_EXTRACT_TRUNC]]
-; CHECK-NEXT: ret i8 [[BSUM1]]
-;
-
-entry:
- %a = alloca [3 x i8]
- %b = alloca [3 x i8]
-
- %a0ptr = getelementptr [3 x i8], [3 x i8]* %a, i64 0, i32 0
- store i8 0, i8* %a0ptr
- %a1ptr = getelementptr [3 x i8], [3 x i8]* %a, i64 0, i32 1
- store i8 0, i8* %a1ptr
- %a2ptr = getelementptr [3 x i8], [3 x i8]* %a, i64 0, i32 2
- store i8 0, i8* %a2ptr
- %aiptr = bitcast [3 x i8]* %a to i24*
- %ai = load i24, i24* %aiptr
-
- %biptr = bitcast [3 x i8]* %b to i24*
- store i24 %ai, i24* %biptr
- %b0ptr = getelementptr [3 x i8], [3 x i8]* %b, i64 0, i32 0
- %b0 = load i8, i8* %b0ptr
- %b1ptr = getelementptr [3 x i8], [3 x i8]* %b, i64 0, i32 1
- %b1 = load i8, i8* %b1ptr
- %b2ptr = getelementptr [3 x i8], [3 x i8]* %b, i64 0, i32 2
- %b2 = load i8, i8* %b2ptr
-
- %bsum0 = add i8 %b0, %b1
- %bsum1 = add i8 %bsum0, %b2
- ret i8 %bsum1
-}
-
-define i32 @test13() {
-; Ensure we don't crash and handle undefined loads that straddle the end of the
-; allocation.
-; CHECK-LABEL: @test13(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[A_SROA_2_2_LOAD_EXT:%.*]] = zext i8 0 to i16
-; CHECK-NEXT: [[RET:%.*]] = zext i16 [[A_SROA_2_2_LOAD_EXT]] to i32
-; CHECK-NEXT: ret i32 [[RET]]
-;
-
-entry:
- %a = alloca [3 x i8], align 2
- %b0ptr = getelementptr [3 x i8], [3 x i8]* %a, i64 0, i32 0
- store i8 0, i8* %b0ptr
- %b1ptr = getelementptr [3 x i8], [3 x i8]* %a, i64 0, i32 1
- store i8 0, i8* %b1ptr
- %b2ptr = getelementptr [3 x i8], [3 x i8]* %a, i64 0, i32 2
- store i8 0, i8* %b2ptr
- %iptrcast = bitcast [3 x i8]* %a to i16*
- %iptrgep = getelementptr i16, i16* %iptrcast, i64 1
- %i = load i16, i16* %iptrgep
- %ret = zext i16 %i to i32
- ret i32 %ret
-}
-
-%test14.struct = type { [3 x i32] }
-
-define void @test14(...) nounwind uwtable {
-; This is a strange case where we split allocas into promotable partitions, but
-; also gain enough data to prove they must be dead allocas due to GEPs that walk
-; across two adjacent allocas. Test that we don't try to promote or otherwise
-; do bad things to these dead allocas, they should just be removed.
-; CHECK-LABEL: @test14(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: ret void
-;
-
-entry:
- %a = alloca %test14.struct
- %p = alloca %test14.struct*
- %0 = bitcast %test14.struct* %a to i8*
- %1 = getelementptr i8, i8* %0, i64 12
- %2 = bitcast i8* %1 to %test14.struct*
- %3 = getelementptr inbounds %test14.struct, %test14.struct* %2, i32 0, i32 0
- %4 = getelementptr inbounds %test14.struct, %test14.struct* %a, i32 0, i32 0
- %5 = bitcast [3 x i32]* %3 to i32*
- %6 = bitcast [3 x i32]* %4 to i32*
- %7 = load i32, i32* %6, align 4
- store i32 %7, i32* %5, align 4
- %8 = getelementptr inbounds i32, i32* %5, i32 1
- %9 = getelementptr inbounds i32, i32* %6, i32 1
- %10 = load i32, i32* %9, align 4
- store i32 %10, i32* %8, align 4
- %11 = getelementptr inbounds i32, i32* %5, i32 2
- %12 = getelementptr inbounds i32, i32* %6, i32 2
- %13 = load i32, i32* %12, align 4
- store i32 %13, i32* %11, align 4
- ret void
-}
-
-define i32 @test15(i1 %flag) nounwind uwtable {
-; Ensure that when there are dead instructions using an alloca that are not
-; loads or stores we still delete them during partitioning and rewriting.
-; Otherwise we'll go to promote them while thy still have unpromotable uses.
-; CHECK-LABEL: @test15(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: br label [[LOOP:%.*]]
-; CHECK: loop:
-; CHECK-NEXT: br label [[LOOP]]
-;
-
-entry:
- %l0 = alloca i64
- %l1 = alloca i64
- %l2 = alloca i64
- %l3 = alloca i64
- br label %loop
-
-loop:
- %dead3 = phi i8* [ %gep3, %loop ], [ null, %entry ]
-
- store i64 1879048192, i64* %l0, align 8
- %bc0 = bitcast i64* %l0 to i8*
- %gep0 = getelementptr i8, i8* %bc0, i64 3
- %dead0 = bitcast i8* %gep0 to i64*
-
- store i64 1879048192, i64* %l1, align 8
- %bc1 = bitcast i64* %l1 to i8*
- %gep1 = getelementptr i8, i8* %bc1, i64 3
- %dead1 = getelementptr i8, i8* %gep1, i64 1
-
- store i64 1879048192, i64* %l2, align 8
- %bc2 = bitcast i64* %l2 to i8*
- %gep2.1 = getelementptr i8, i8* %bc2, i64 1
- %gep2.2 = getelementptr i8, i8* %bc2, i64 3
- ; Note that this select should get visited multiple times due to using two
- ;
diff erent GEPs off the same alloca. We should only delete it once.
- %dead2 = select i1 %flag, i8* %gep2.1, i8* %gep2.2
-
- store i64 1879048192, i64* %l3, align 8
- %bc3 = bitcast i64* %l3 to i8*
- %gep3 = getelementptr i8, i8* %bc3, i64 3
-
- br label %loop
-}
-
-define void @test16(i8* %src, i8* %dst) {
-; Ensure that we can promote an alloca of [3 x i8] to an i24 SSA value.
-; CHECK-LABEL: @test16(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[A_SROA_0_0_COPYLOAD:%.*]] = load i24, ptr [[SRC:%.*]], align 1, !tbaa [[TBAA0]]
-; CHECK-NEXT: store i24 0, ptr [[DST:%.*]], align 1, !tbaa [[TBAA5]]
-; CHECK-NEXT: ret void
-;
-
-entry:
- %a = alloca [3 x i8]
- %ptr = getelementptr [3 x i8], [3 x i8]* %a, i32 0, i32 0
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %ptr, i8* %src, i32 4, i1 false), !tbaa !0
- %cast = bitcast i8* %ptr to i24*
- store i24 0, i24* %cast, !tbaa !3
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %ptr, i32 4, i1 false), !tbaa !5
- ret void
-}
-
-define void @test17(i8* %src, i8* %dst) {
-; Ensure that we can rewrite unpromotable memcpys which extend past the end of
-; the alloca.
-; CHECK-LABEL: @test17(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[A:%.*]] = alloca [3 x i8], align 1
-; CHECK-NEXT: [[PTR:%.*]] = getelementptr [3 x i8], ptr [[A]], i32 0, i32 0
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr [[PTR]], ptr [[SRC:%.*]], i32 4, i1 true), !tbaa [[TBAA0]]
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr [[DST:%.*]], ptr [[PTR]], i32 4, i1 true), !tbaa [[TBAA3]]
-; CHECK-NEXT: ret void
-;
-
-entry:
- %a = alloca [3 x i8]
- %ptr = getelementptr [3 x i8], [3 x i8]* %a, i32 0, i32 0
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %ptr, i8* %src, i32 4, i1 true), !tbaa !0
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %ptr, i32 4, i1 true), !tbaa !3
- ret void
-}
-
-define void @test18(i8* %src, i8* %dst, i32 %size) {
-; Preserve transfer intrinsics with a variable size, even if they overlap with
-; fixed size operations. Further, continue to split and promote allocas preceding
-; the variable sized intrinsic.
-; CHECK-LABEL: @test18(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[A_SROA_33:%.*]] = alloca [34 x i8], align 1
-; CHECK-NEXT: [[A_SROA_0_0_COPYLOAD:%.*]] = load i32, ptr [[SRC:%.*]], align 1, !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_3_0_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 4
-; CHECK-NEXT: [[A_SROA_3_0_COPYLOAD:%.*]] = load i32, ptr [[A_SROA_3_0_SRC_SROA_IDX]], align 1, !tbaa [[TBAA0]]
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_33]], ptr [[SRC]], i32 [[SIZE:%.*]], i1 false), !tbaa [[TBAA3]]
-; CHECK-NEXT: call void @llvm.memset.p0.i32(ptr align 1 [[A_SROA_33]], i8 42, i32 [[SIZE]], i1 false), !tbaa [[TBAA5]]
-; CHECK-NEXT: store i32 42, ptr [[DST:%.*]], align 1, !tbaa [[TBAA9]]
-; CHECK-NEXT: [[A_SROA_3_0_DST_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 4
-; CHECK-NEXT: store i32 [[A_SROA_3_0_COPYLOAD]], ptr [[A_SROA_3_0_DST_SROA_IDX]], align 1, !tbaa [[TBAA9]]
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr [[DST]], ptr align 1 [[A_SROA_33]], i32 [[SIZE]], i1 false), !tbaa [[TBAA11]]
-; CHECK-NEXT: ret void
-;
-
-entry:
- %a = alloca [42 x i8]
- %ptr = getelementptr [42 x i8], [42 x i8]* %a, i32 0, i32 0
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %ptr, i8* %src, i32 8, i1 false), !tbaa !0
- %ptr2 = getelementptr [42 x i8], [42 x i8]* %a, i32 0, i32 8
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %ptr2, i8* %src, i32 %size, i1 false), !tbaa !3
- call void @llvm.memset.p0i8.i32(i8* %ptr2, i8 42, i32 %size, i1 false), !tbaa !5
- %cast = bitcast i8* %ptr to i32*
- store i32 42, i32* %cast, !tbaa !7
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %ptr, i32 8, i1 false), !tbaa !9
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %ptr2, i32 %size, i1 false), !tbaa !11
- ret void
-}
-
-%opaque = type opaque
-
-define i64 @test19(%opaque* %x) {
-; This input will cause us to try to compute a natural GEP when rewriting
-; pointers in such a way that we try to GEP through the opaque type. Previously,
-; a check for an unsized type was missing and this crashed. Ensure it behaves
-; reasonably now.
-; CHECK-LABEL: @test19(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[CAST1:%.*]] = bitcast ptr [[X:%.*]] to ptr
-; CHECK-NEXT: [[A_SROA_0_0_COPYLOAD:%.*]] = load i64, ptr [[CAST1]], align 1
-; CHECK-NEXT: [[A_SROA_2_0_CAST1_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[CAST1]], i64 8
-; CHECK-NEXT: [[A_SROA_2_0_COPYLOAD:%.*]] = load ptr, ptr [[A_SROA_2_0_CAST1_SROA_IDX]], align 1
-; CHECK-NEXT: ret i64 [[A_SROA_0_0_COPYLOAD]]
-;
-
-entry:
- %a = alloca { i64, i8* }
- %cast1 = bitcast %opaque* %x to i8*
- %cast2 = bitcast { i64, i8* }* %a to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %cast2, i8* %cast1, i32 16, i1 false)
- %gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %a, i32 0, i32 0
- %val = load i64, i64* %gep
- ret i64 %val
-}
-
-declare void @llvm.memcpy.p0i8.p1i8.i32(i8* nocapture, i8 addrspace(1)* nocapture, i32, i32, i1) nounwind
-
-define i64 @test19_addrspacecast(%opaque* %x) {
-; This input will cause us to try to compute a natural GEP when rewriting
-; pointers in such a way that we try to GEP through the opaque type. Previously,
-; a check for an unsized type was missing and this crashed. Ensure it behaves
-; reasonably now.
-; CHECK-LABEL: @test19_addrspacecast(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[CAST1:%.*]] = addrspacecast ptr [[X:%.*]] to ptr addrspace(1)
-; CHECK-NEXT: [[A_SROA_0_0_COPYLOAD:%.*]] = load i64, ptr addrspace(1) [[CAST1]], align 1
-; CHECK-NEXT: [[A_SROA_2_0_CAST1_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr addrspace(1) [[CAST1]], i16 8
-; CHECK-NEXT: [[A_SROA_2_0_COPYLOAD:%.*]] = load ptr, ptr addrspace(1) [[A_SROA_2_0_CAST1_SROA_IDX]], align 1
-; CHECK-NEXT: ret i64 [[A_SROA_0_0_COPYLOAD]]
-;
-
-entry:
- %a = alloca { i64, i8* }
- %cast1 = addrspacecast %opaque* %x to i8 addrspace(1)*
- %cast2 = bitcast { i64, i8* }* %a to i8*
- call void @llvm.memcpy.p0i8.p1i8.i32(i8* %cast2, i8 addrspace(1)* %cast1, i32 16, i32 1, i1 false)
- %gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %a, i32 0, i32 0
- %val = load i64, i64* %gep
- ret i64 %val
-}
-
-define i32 @test20() {
-; Ensure we can track negative offsets (before the beginning of the alloca) and
-; negative relative offsets from offsets starting past the end of the alloca.
-; CHECK-LABEL: @test20(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[SUM1:%.*]] = add i32 1, 2
-; CHECK-NEXT: [[SUM2:%.*]] = add i32 [[SUM1]], 3
-; CHECK-NEXT: ret i32 [[SUM2]]
-;
-
-entry:
- %a = alloca [3 x i32]
- %gep1 = getelementptr [3 x i32], [3 x i32]* %a, i32 0, i32 0
- store i32 1, i32* %gep1
- %gep2.1 = getelementptr [3 x i32], [3 x i32]* %a, i32 0, i32 -2
- %gep2.2 = getelementptr i32, i32* %gep2.1, i32 3
- store i32 2, i32* %gep2.2
- %gep3.1 = getelementptr [3 x i32], [3 x i32]* %a, i32 0, i32 14
- %gep3.2 = getelementptr i32, i32* %gep3.1, i32 -12
- store i32 3, i32* %gep3.2
-
- %load1 = load i32, i32* %gep1
- %load2 = load i32, i32* %gep2.2
- %load3 = load i32, i32* %gep3.2
- %sum1 = add i32 %load1, %load2
- %sum2 = add i32 %sum1, %load3
- ret i32 %sum2
-}
-
-declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i1) nounwind
-
-define i8 @test21() {
-; Test allocations and offsets which border on overflow of the int64_t used
-; internally. This is really awkward to really test as LLVM doesn't really
-; support such extreme constructs cleanly.
-; CHECK-LABEL: @test21(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[RESULT:%.*]] = or i8 -1, -1
-; CHECK-NEXT: ret i8 [[RESULT]]
-;
-
-entry:
- %a = alloca [2305843009213693951 x i8]
- %gep0 = getelementptr [2305843009213693951 x i8], [2305843009213693951 x i8]* %a, i64 0, i64 2305843009213693949
- store i8 255, i8* %gep0
- %gep1 = getelementptr [2305843009213693951 x i8], [2305843009213693951 x i8]* %a, i64 0, i64 -9223372036854775807
- %gep2 = getelementptr i8, i8* %gep1, i64 -1
- call void @llvm.memset.p0i8.i64(i8* %gep2, i8 0, i64 18446744073709551615, i1 false)
- %gep3 = getelementptr i8, i8* %gep1, i64 9223372036854775807
- %gep4 = getelementptr i8, i8* %gep3, i64 9223372036854775807
- %gep5 = getelementptr i8, i8* %gep4, i64 -6917529027641081857
- store i8 255, i8* %gep5
- %cast1 = bitcast i8* %gep4 to i32*
- store i32 0, i32* %cast1
- %load = load i8, i8* %gep0
- %gep6 = getelementptr i8, i8* %gep0, i32 1
- %load2 = load i8, i8* %gep6
- %result = or i8 %load, %load2
- ret i8 %result
-}
-
-%PR13916.struct = type { i8 }
-
-define void @PR13916.1() {
-; Ensure that we handle overlapping memcpy intrinsics correctly, especially in
-; the case where there is a directly identical value for both source and dest.
-; CHECK-LABEL: @PR13916.1(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: ret void
-;
-
-entry:
- %a = alloca i8
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %a, i8* %a, i32 1, i1 false)
- %tmp2 = load i8, i8* %a
- ret void
-}
-
-define void @PR13916.2(i1 %c) {
-; Check whether we continue to handle them correctly when they start off with
-;
diff erent pointer value chains, but during rewriting we coalesce them into the
-; same value.
-; CHECK-LABEL: @PR13916.2(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: br i1 [[C:%.*]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
-; CHECK: if.then:
-; CHECK-NEXT: br label [[IF_END]]
-; CHECK: if.end:
-; CHECK-NEXT: ret void
-;
-
-entry:
- %a = alloca %PR13916.struct, align 1
- br i1 %c, label %if.then, label %if.end
-
-if.then:
- %tmp0 = bitcast %PR13916.struct* %a to i8*
- %tmp1 = bitcast %PR13916.struct* %a to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %tmp0, i8* %tmp1, i32 1, i1 false)
- br label %if.end
-
-if.end:
- %gep = getelementptr %PR13916.struct, %PR13916.struct* %a, i32 0, i32 0
- %tmp2 = load i8, i8* %gep
- ret void
-}
-
-define void @PR13990(i1 %c1, i1 %c2, i1 %c3, i1 %c4, i8* %ptr) {
-; Ensure we can handle cases where processing one alloca causes the other
-; alloca to become dead and get deleted. This might crash or fail under
-; Valgrind if we regress.
-; CHECK-LABEL: @PR13990(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: br i1 [[C1:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
-; CHECK: bb1:
-; CHECK-NEXT: br i1 [[C2:%.*]], label [[BB2]], label [[BB3:%.*]]
-; CHECK: bb2:
-; CHECK-NEXT: br i1 [[C4:%.*]], label [[BB3]], label [[BB4:%.*]]
-; CHECK: bb3:
-; CHECK-NEXT: ret void
-; CHECK: bb4:
-; CHECK-NEXT: ret void
-;
-
-entry:
- %tmp1 = alloca i8*
- %tmp2 = alloca i8*
- br i1 %c1, label %bb1, label %bb2
-
-bb1:
- store i8* %ptr, i8** %tmp2
- br i1 %c2, label %bb2, label %bb3
-
-bb2:
- %tmp50 = select i1 %c3, i8** %tmp2, i8** %tmp1
- br i1 %c4, label %bb3, label %bb4
-
-bb3:
- ret void
-
-bb4:
- ret void
-}
-
-define double @PR13969(double %x) {
-; Check that we detect when promotion will un-escape an alloca and iterate to
-; re-try running SROA over that alloca. Without that, the two allocas that are
-; stored into a dead alloca don't get rewritten and promoted.
-; CHECK-LABEL: @PR13969(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: ret double [[X:%.*]]
-;
-
-entry:
- %a = alloca double
- %b = alloca double*
- %c = alloca double
-
- store double %x, double* %a
- store double* %c, double** %b
- store double* %a, double** %b
- store double %x, double* %c
- %ret = load double, double* %a
-
- ret double %ret
-}
-
-%PR14034.struct = type { { {} }, i32, %PR14034.list }
-%PR14034.list = type { %PR14034.list*, %PR14034.list* }
-
-define void @PR14034(%PR14034.list* %ptr, %PR14034.struct* %ptr2) {
-; This test case tries to form GEPs into the empty leading struct members, and
-; subsequently crashed (under valgrind) before we fixed the PR. The important
-; thing is to handle empty structs gracefully.
-; CHECK-LABEL: @PR14034(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[A_SROA_0:%.*]] = alloca [12 x i8], align 8
-; CHECK-NEXT: [[CAST0:%.*]] = bitcast ptr [[PTR2:%.*]] to ptr
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[CAST0]], ptr align 8 [[A_SROA_0]], i32 12, i1 false)
-; CHECK-NEXT: ret void
-;
-
-entry:
- %a = alloca %PR14034.struct
- %list = getelementptr %PR14034.struct, %PR14034.struct* %a, i32 0, i32 2
- %prev = getelementptr %PR14034.list, %PR14034.list* %list, i32 0, i32 1
- store %PR14034.list* %ptr, %PR14034.list** %prev
- %cast0 = bitcast %PR14034.struct* %ptr2 to i8*
- %cast1 = bitcast %PR14034.struct* %a to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %cast0, i8* %cast1, i32 12, i1 false)
- ret void
-}
-
-define i32 @test22(i32 %x) {
-; Test that SROA and promotion is not confused by a grab bax mixture of pointer
-; types involving wrapper aggregates and zero-length aggregate members.
-; CHECK-LABEL: @test22(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[WRAP1:%.*]] = insertvalue [1 x { i32 }] poison, i32 [[X:%.*]], 0, 0
-; CHECK-NEXT: [[WRAP1_FCA_0_0_EXTRACT:%.*]] = extractvalue [1 x { i32 }] [[WRAP1]], 0, 0
-; CHECK-NEXT: [[TMP0:%.*]] = bitcast i32 [[WRAP1_FCA_0_0_EXTRACT]] to float
-; CHECK-NEXT: [[LOAD1_FCA_0_0_0_INSERT:%.*]] = insertvalue { [1 x { float }] } poison, float [[TMP0]], 0, 0, 0
-; CHECK-NEXT: [[UNWRAP1:%.*]] = extractvalue { [1 x { float }] } [[LOAD1_FCA_0_0_0_INSERT]], 0, 0
-; CHECK-NEXT: [[WRAP2:%.*]] = insertvalue { {}, { float }, [0 x i8] } poison, { float } [[UNWRAP1]], 1
-; CHECK-NEXT: [[WRAP2_FCA_1_0_EXTRACT:%.*]] = extractvalue { {}, { float }, [0 x i8] } [[WRAP2]], 1, 0
-; CHECK-NEXT: [[TMP1:%.*]] = bitcast float [[WRAP2_FCA_1_0_EXTRACT]] to <4 x i8>
-; CHECK-NEXT: [[VALCAST1:%.*]] = bitcast <4 x i8> [[TMP1]] to i32
-; CHECK-NEXT: [[WRAP3:%.*]] = insertvalue [1 x [1 x i32]] poison, i32 [[VALCAST1]], 0, 0
-; CHECK-NEXT: [[WRAP4:%.*]] = insertvalue { [1 x [1 x i32]], {} } poison, [1 x [1 x i32]] [[WRAP3]], 0
-; CHECK-NEXT: [[WRAP4_FCA_0_0_0_EXTRACT:%.*]] = extractvalue { [1 x [1 x i32]], {} } [[WRAP4]], 0, 0, 0
-; CHECK-NEXT: [[TMP2:%.*]] = bitcast i32 [[WRAP4_FCA_0_0_0_EXTRACT]] to <4 x i8>
-; CHECK-NEXT: [[TMP3:%.*]] = bitcast <4 x i8> [[TMP2]] to float
-; CHECK-NEXT: [[LOAD4_FCA_1_INSERT:%.*]] = insertvalue { {}, float, {} } poison, float [[TMP3]], 1
-; CHECK-NEXT: [[UNWRAP2:%.*]] = extractvalue { {}, float, {} } [[LOAD4_FCA_1_INSERT]], 1
-; CHECK-NEXT: [[VALCAST2:%.*]] = bitcast float [[UNWRAP2]] to i32
-; CHECK-NEXT: ret i32 [[VALCAST2]]
-;
-
-entry:
- %a1 = alloca { { [1 x { i32 }] } }
- %a2 = alloca { {}, { float }, [0 x i8] }
- %a3 = alloca { [0 x i8], { [0 x double], [1 x [1 x <4 x i8>]], {} }, { { {} } } }
-
- %wrap1 = insertvalue [1 x { i32 }] poison, i32 %x, 0, 0
- %gep1 = getelementptr { { [1 x { i32 }] } }, { { [1 x { i32 }] } }* %a1, i32 0, i32 0, i32 0
- store [1 x { i32 }] %wrap1, [1 x { i32 }]* %gep1
-
- %gep2 = getelementptr { { [1 x { i32 }] } }, { { [1 x { i32 }] } }* %a1, i32 0, i32 0
- %ptrcast1 = bitcast { [1 x { i32 }] }* %gep2 to { [1 x { float }] }*
- %load1 = load { [1 x { float }] }, { [1 x { float }] }* %ptrcast1
- %unwrap1 = extractvalue { [1 x { float }] } %load1, 0, 0
-
- %wrap2 = insertvalue { {}, { float }, [0 x i8] } poison, { float } %unwrap1, 1
- store { {}, { float }, [0 x i8] } %wrap2, { {}, { float }, [0 x i8] }* %a2
-
- %gep3 = getelementptr { {}, { float }, [0 x i8] }, { {}, { float }, [0 x i8] }* %a2, i32 0, i32 1, i32 0
- %ptrcast2 = bitcast float* %gep3 to <4 x i8>*
- %load3 = load <4 x i8>, <4 x i8>* %ptrcast2
- %valcast1 = bitcast <4 x i8> %load3 to i32
-
- %wrap3 = insertvalue [1 x [1 x i32]] poison, i32 %valcast1, 0, 0
- %wrap4 = insertvalue { [1 x [1 x i32]], {} } poison, [1 x [1 x i32]] %wrap3, 0
- %gep4 = getelementptr { [0 x i8], { [0 x double], [1 x [1 x <4 x i8>]], {} }, { { {} } } }, { [0 x i8], { [0 x double], [1 x [1 x <4 x i8>]], {} }, { { {} } } }* %a3, i32 0, i32 1
- %ptrcast3 = bitcast { [0 x double], [1 x [1 x <4 x i8>]], {} }* %gep4 to { [1 x [1 x i32]], {} }*
- store { [1 x [1 x i32]], {} } %wrap4, { [1 x [1 x i32]], {} }* %ptrcast3
-
- %gep5 = getelementptr { [0 x i8], { [0 x double], [1 x [1 x <4 x i8>]], {} }, { { {} } } }, { [0 x i8], { [0 x double], [1 x [1 x <4 x i8>]], {} }, { { {} } } }* %a3, i32 0, i32 1, i32 1, i32 0
- %ptrcast4 = bitcast [1 x <4 x i8>]* %gep5 to { {}, float, {} }*
- %load4 = load { {}, float, {} }, { {}, float, {} }* %ptrcast4
- %unwrap2 = extractvalue { {}, float, {} } %load4, 1
- %valcast2 = bitcast float %unwrap2 to i32
-
- ret i32 %valcast2
-}
-
-define void @PR14059.1(double* %d) {
-; In PR14059 a peculiar construct was identified as something that is used
-; pervasively in ARM's ABI-calling-convention lowering: the passing of a struct
-; of doubles via an array of i32 in order to place the data into integer
-; registers. This in turn was missed as an optimization by SROA due to the
-; partial loads and stores of integers to the double alloca we were trying to
-; form and promote. The solution is to widen the integer operations to be
-; whole-alloca operations, and perform the appropriate bitcasting on the
-; *values* rather than the pointers. When this works, partial reads and writes
-; via integers can be promoted away.
-; CHECK-LABEL: @PR14059.1(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[TMP0:%.*]] = bitcast double undef to i64
-; CHECK-NEXT: [[X_SROA_0_I_0_INSERT_MASK:%.*]] = and i64 [[TMP0]], -4294967296
-; CHECK-NEXT: [[X_SROA_0_I_0_INSERT_INSERT:%.*]] = or i64 [[X_SROA_0_I_0_INSERT_MASK]], 0
-; CHECK-NEXT: [[TMP1:%.*]] = bitcast i64 [[X_SROA_0_I_0_INSERT_INSERT]] to double
-; CHECK-NEXT: [[TMP2:%.*]] = bitcast double [[TMP1]] to i64
-; CHECK-NEXT: [[X_SROA_0_I_2_INSERT_MASK:%.*]] = and i64 [[TMP2]], -281474976645121
-; CHECK-NEXT: [[X_SROA_0_I_2_INSERT_INSERT:%.*]] = or i64 [[X_SROA_0_I_2_INSERT_MASK]], 0
-; CHECK-NEXT: [[TMP3:%.*]] = bitcast i64 [[X_SROA_0_I_2_INSERT_INSERT]] to double
-; CHECK-NEXT: [[TMP4:%.*]] = bitcast double [[TMP3]] to i64
-; CHECK-NEXT: [[D_RAW:%.*]] = bitcast ptr [[D:%.*]] to ptr
-; CHECK-NEXT: [[X_SROA_0_I_4_COPYLOAD:%.*]] = load i32, ptr [[D_RAW]], align 1
-; CHECK-NEXT: [[TMP5:%.*]] = bitcast double 0.000000e+00 to i64
-; CHECK-NEXT: [[X_SROA_0_I_4_INSERT_EXT:%.*]] = zext i32 [[X_SROA_0_I_4_COPYLOAD]] to i64
-; CHECK-NEXT: [[X_SROA_0_I_4_INSERT_SHIFT:%.*]] = shl i64 [[X_SROA_0_I_4_INSERT_EXT]], 32
-; CHECK-NEXT: [[X_SROA_0_I_4_INSERT_MASK3:%.*]] = and i64 [[TMP5]], 4294967295
-; CHECK-NEXT: [[X_SROA_0_I_4_INSERT_INSERT4:%.*]] = or i64 [[X_SROA_0_I_4_INSERT_MASK3]], [[X_SROA_0_I_4_INSERT_SHIFT]]
-; CHECK-NEXT: [[TMP6:%.*]] = bitcast i64 [[X_SROA_0_I_4_INSERT_INSERT4]] to double
-; CHECK-NEXT: [[TMP7:%.*]] = bitcast double [[TMP6]] to i64
-; CHECK-NEXT: [[X_SROA_0_I_4_INSERT_MASK:%.*]] = and i64 [[TMP7]], 4294967295
-; CHECK-NEXT: [[X_SROA_0_I_4_INSERT_INSERT:%.*]] = or i64 [[X_SROA_0_I_4_INSERT_MASK]], 4607182418800017408
-; CHECK-NEXT: [[TMP8:%.*]] = bitcast i64 [[X_SROA_0_I_4_INSERT_INSERT]] to double
-; CHECK-NEXT: [[ACCUM_REAL_I:%.*]] = load double, ptr [[D]], align 8
-; CHECK-NEXT: [[ADD_R_I:%.*]] = fadd double [[ACCUM_REAL_I]], [[TMP8]]
-; CHECK-NEXT: store double [[ADD_R_I]], ptr [[D]], align 8
-; CHECK-NEXT: ret void
-;
-
-entry:
- %X.sroa.0.i = alloca double, align 8
- %0 = bitcast double* %X.sroa.0.i to i8*
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %0)
-
- ; Store to the low 32-bits...
- %X.sroa.0.0.cast2.i = bitcast double* %X.sroa.0.i to i32*
- store i32 0, i32* %X.sroa.0.0.cast2.i, align 8
-
- ; Also use a memset to the middle 32-bits for fun.
- %X.sroa.0.2.raw_idx2.i = getelementptr inbounds i8, i8* %0, i32 2
- call void @llvm.memset.p0i8.i64(i8* %X.sroa.0.2.raw_idx2.i, i8 0, i64 4, i1 false)
-
- ; Or a memset of the whole thing.
- call void @llvm.memset.p0i8.i64(i8* %0, i8 0, i64 8, i1 false)
-
- ; Write to the high 32-bits with a memcpy.
- %X.sroa.0.4.raw_idx4.i = getelementptr inbounds i8, i8* %0, i32 4
- %d.raw = bitcast double* %d to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %X.sroa.0.4.raw_idx4.i, i8* %d.raw, i32 4, i1 false)
-
- ; Store to the high 32-bits...
- %X.sroa.0.4.cast5.i = bitcast i8* %X.sroa.0.4.raw_idx4.i to i32*
- store i32 1072693248, i32* %X.sroa.0.4.cast5.i, align 4
-
- ; Do the actual math...
- %X.sroa.0.0.load1.i = load double, double* %X.sroa.0.i, align 8
- %accum.real.i = load double, double* %d, align 8
- %add.r.i = fadd double %accum.real.i, %X.sroa.0.0.load1.i
- store double %add.r.i, double* %d, align 8
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %0)
- ret void
-}
-
-define i64 @PR14059.2({ float, float }* %phi) {
-; Check that SROA can split up alloca-wide integer loads and stores where the
-; underlying alloca has smaller components that are accessed independently. This
-; shows up particularly with ABI lowering patterns coming out of Clang that rely
-; on the particular register placement of a single large integer return value.
-; CHECK-LABEL: @PR14059.2(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[PHI_REALP:%.*]] = getelementptr inbounds { float, float }, ptr [[PHI:%.*]], i32 0, i32 0
-; CHECK-NEXT: [[PHI_REAL:%.*]] = load float, ptr [[PHI_REALP]], align 4
-; CHECK-NEXT: [[PHI_IMAGP:%.*]] = getelementptr inbounds { float, float }, ptr [[PHI]], i32 0, i32 1
-; CHECK-NEXT: [[PHI_IMAG:%.*]] = load float, ptr [[PHI_IMAGP]], align 4
-; CHECK-NEXT: [[TMP0:%.*]] = bitcast float [[PHI_REAL]] to i32
-; CHECK-NEXT: [[TMP1:%.*]] = bitcast float [[PHI_IMAG]] to i32
-; CHECK-NEXT: [[RETVAL_SROA_3_0_INSERT_EXT:%.*]] = zext i32 [[TMP1]] to i64
-; CHECK-NEXT: [[RETVAL_SROA_3_0_INSERT_SHIFT:%.*]] = shl i64 [[RETVAL_SROA_3_0_INSERT_EXT]], 32
-; CHECK-NEXT: [[RETVAL_SROA_3_0_INSERT_MASK:%.*]] = and i64 undef, 4294967295
-; CHECK-NEXT: [[RETVAL_SROA_3_0_INSERT_INSERT:%.*]] = or i64 [[RETVAL_SROA_3_0_INSERT_MASK]], [[RETVAL_SROA_3_0_INSERT_SHIFT]]
-; CHECK-NEXT: [[RETVAL_SROA_0_0_INSERT_EXT:%.*]] = zext i32 [[TMP0]] to i64
-; CHECK-NEXT: [[RETVAL_SROA_0_0_INSERT_MASK:%.*]] = and i64 [[RETVAL_SROA_3_0_INSERT_INSERT]], -4294967296
-; CHECK-NEXT: [[RETVAL_SROA_0_0_INSERT_INSERT:%.*]] = or i64 [[RETVAL_SROA_0_0_INSERT_MASK]], [[RETVAL_SROA_0_0_INSERT_EXT]]
-; CHECK-NEXT: ret i64 [[RETVAL_SROA_0_0_INSERT_INSERT]]
-;
-
-entry:
- %retval = alloca { float, float }, align 4
-
- %0 = bitcast { float, float }* %retval to i64*
- store i64 0, i64* %0
-
- %phi.realp = getelementptr inbounds { float, float }, { float, float }* %phi, i32 0, i32 0
- %phi.real = load float, float* %phi.realp
- %phi.imagp = getelementptr inbounds { float, float }, { float, float }* %phi, i32 0, i32 1
- %phi.imag = load float, float* %phi.imagp
-
- %real = getelementptr inbounds { float, float }, { float, float }* %retval, i32 0, i32 0
- %imag = getelementptr inbounds { float, float }, { float, float }* %retval, i32 0, i32 1
- store float %phi.real, float* %real
- store float %phi.imag, float* %imag
-
- %1 = load i64, i64* %0, align 1
- ret i64 %1
-}
-
-define void @PR14105({ [16 x i8] }* %ptr) {
-; Ensure that when rewriting the GEP index '-1' for this alloca we preserve is
-; sign as negative. We use a volatile memcpy to ensure promotion never actually
-; occurs.
-; CHECK-LABEL: @PR14105(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[A_SROA_0:%.*]] = alloca [16 x i8], align 8
-; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds { [16 x i8] }, ptr [[PTR:%.*]], i64 -1
-; CHECK-NEXT: [[CAST1:%.*]] = bitcast ptr [[GEP]] to ptr
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 8 [[CAST1]], ptr align 8 [[A_SROA_0]], i32 16, i1 true)
-; CHECK-NEXT: ret void
-;
-
-entry:
- %a = alloca { [16 x i8] }, align 8
-
- %gep = getelementptr inbounds { [16 x i8] }, { [16 x i8] }* %ptr, i64 -1
-
- %cast1 = bitcast { [16 x i8 ] }* %gep to i8*
- %cast2 = bitcast { [16 x i8 ] }* %a to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %cast1, i8* align 8 %cast2, i32 16, i1 true)
- ret void
-}
-
-define void @PR14105_as1({ [16 x i8] } addrspace(1)* %ptr) {
-; Make sure this the right address space pointer is used for type check.
-; CHECK-LABEL: @PR14105_as1(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[A:%.*]] = alloca { [16 x i8] }, align 8
-; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds { [16 x i8] }, ptr addrspace(1) [[PTR:%.*]], i64 -1
-; CHECK-NEXT: [[CAST1:%.*]] = bitcast ptr addrspace(1) [[GEP]] to ptr addrspace(1)
-; CHECK-NEXT: [[CAST2:%.*]] = bitcast ptr [[A]] to ptr
-; CHECK-NEXT: call void @llvm.memcpy.p1.p0.i32(ptr addrspace(1) align 8 [[CAST1]], ptr align 8 [[CAST2]], i32 16, i1 true)
-; CHECK-NEXT: ret void
-;
-
-entry:
- %a = alloca { [16 x i8] }, align 8
- %gep = getelementptr inbounds { [16 x i8] }, { [16 x i8] } addrspace(1)* %ptr, i64 -1
- %cast1 = bitcast { [16 x i8 ] } addrspace(1)* %gep to i8 addrspace(1)*
- %cast2 = bitcast { [16 x i8 ] }* %a to i8*
- call void @llvm.memcpy.p1i8.p0i8.i32(i8 addrspace(1)* align 8 %cast1, i8* align 8 %cast2, i32 16, i1 true)
- ret void
-}
-
-define void @PR14465() {
-; Ensure that we don't crash when analyzing a alloca larger than the maximum
-; integer type width (MAX_INT_BITS) supported by llvm (1048576*32 > (1<<23)-1).
-; CHECK-LABEL: @PR14465(
-; CHECK-NEXT: [[STACK:%.*]] = alloca [1048576 x i32], align 16
-; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 16 [[STACK]], i8 -2, i64 4194304, i1 false)
-; CHECK-NEXT: ret void
-;
-
- %stack = alloca [1048576 x i32], align 16
- %cast = bitcast [1048576 x i32]* %stack to i8*
- call void @llvm.memset.p0i8.i64(i8* align 16 %cast, i8 -2, i64 4194304, i1 false)
- ret void
-}
-
-define void @PR14548(i1 %x) {
-; Handle a mixture of i1 and i8 loads and stores to allocas. This particular
-; pattern caused crashes and invalid output in the PR, and its nature will
-; trigger a mixture in several permutations as we resolve each alloca
-; iteratively.
-; Note that we don't do a particularly good *job* of handling these mixtures,
-; but the hope is that this is very rare.
-; CHECK-LABEL: @PR14548(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[A_SROA_0:%.*]] = alloca i8, align 8
-; CHECK-NEXT: [[B_SROA_0:%.*]] = alloca i8, align 8
-; CHECK-NEXT: store i1 [[X:%.*]], ptr [[B_SROA_0]], align 8
-; CHECK-NEXT: [[B_SROA_0_0_B_SROA_0_0_FOO:%.*]] = load i8, ptr [[B_SROA_0]], align 8
-; CHECK-NEXT: [[B_SROA_0_0_B_SROA_0_0_COPYLOAD:%.*]] = load i8, ptr [[B_SROA_0]], align 8
-; CHECK-NEXT: store i8 [[B_SROA_0_0_B_SROA_0_0_COPYLOAD]], ptr [[A_SROA_0]], align 8
-; CHECK-NEXT: [[A_SROA_0_0_A_SROA_0_0_BAR:%.*]] = load i8, ptr [[A_SROA_0]], align 8
-; CHECK-NEXT: [[A_SROA_0_0_A_SROA_0_0_BAZ:%.*]] = load i1, ptr [[A_SROA_0]], align 8
-; CHECK-NEXT: ret void
-;
-
-entry:
- %a = alloca <{ i1 }>, align 8
- %b = alloca <{ i1 }>, align 8
-
- %b.i1 = bitcast <{ i1 }>* %b to i1*
- store i1 %x, i1* %b.i1, align 8
- %b.i8 = bitcast <{ i1 }>* %b to i8*
- %foo = load i8, i8* %b.i8, align 1
-
- %a.i8 = bitcast <{ i1 }>* %a to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %a.i8, i8* %b.i8, i32 1, i1 false) nounwind
- %bar = load i8, i8* %a.i8, align 1
- %a.i1 = getelementptr inbounds <{ i1 }>, <{ i1 }>* %a, i32 0, i32 0
- %baz = load i1, i1* %a.i1, align 1
-
- ret void
-}
-
-define <3 x i8> @PR14572.1(i32 %x) {
-; Ensure that a split integer store which is wider than the type size of the
-; alloca (relying on the alloc size padding) doesn't trigger an assert.
-; CHECK-LABEL: @PR14572.1(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[A_0_EXTRACT_TRUNC:%.*]] = trunc i32 [[X:%.*]] to i24
-; CHECK-NEXT: [[TMP0:%.*]] = bitcast i24 [[A_0_EXTRACT_TRUNC]] to <3 x i8>
-; CHECK-NEXT: [[A_SROA_2_0_EXTRACT_SHIFT:%.*]] = lshr i32 [[X]], 24
-; CHECK-NEXT: [[A_SROA_2_0_EXTRACT_TRUNC:%.*]] = trunc i32 [[A_SROA_2_0_EXTRACT_SHIFT]] to i8
-; CHECK-NEXT: ret <3 x i8> [[TMP0]]
-;
-
-entry:
- %a = alloca <3 x i8>, align 4
-
- %cast = bitcast <3 x i8>* %a to i32*
- store i32 %x, i32* %cast, align 1
- %y = load <3 x i8>, <3 x i8>* %a, align 4
- ret <3 x i8> %y
-}
-
-define i32 @PR14572.2(<3 x i8> %x) {
-; Ensure that a split integer load which is wider than the type size of the
-; alloca (relying on the alloc size padding) doesn't trigger an assert.
-; CHECK-LABEL: @PR14572.2(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[TMP0:%.*]] = bitcast <3 x i8> [[X:%.*]] to i24
-; CHECK-NEXT: [[A_SROA_2_0_INSERT_EXT:%.*]] = zext i8 undef to i32
-; CHECK-NEXT: [[A_SROA_2_0_INSERT_SHIFT:%.*]] = shl i32 [[A_SROA_2_0_INSERT_EXT]], 24
-; CHECK-NEXT: [[A_SROA_2_0_INSERT_MASK:%.*]] = and i32 undef, 16777215
-; CHECK-NEXT: [[A_SROA_2_0_INSERT_INSERT:%.*]] = or i32 [[A_SROA_2_0_INSERT_MASK]], [[A_SROA_2_0_INSERT_SHIFT]]
-; CHECK-NEXT: [[A_0_INSERT_EXT:%.*]] = zext i24 [[TMP0]] to i32
-; CHECK-NEXT: [[A_0_INSERT_MASK:%.*]] = and i32 [[A_SROA_2_0_INSERT_INSERT]], -16777216
-; CHECK-NEXT: [[A_0_INSERT_INSERT:%.*]] = or i32 [[A_0_INSERT_MASK]], [[A_0_INSERT_EXT]]
-; CHECK-NEXT: ret i32 [[A_0_INSERT_INSERT]]
-;
-
-entry:
- %a = alloca <3 x i8>, align 4
-
- store <3 x i8> %x, <3 x i8>* %a, align 1
- %cast = bitcast <3 x i8>* %a to i32*
- %y = load i32, i32* %cast, align 4
- ret i32 %y
-}
-
-define i32 @PR14601(i32 %x) {
-; Don't try to form a promotable integer alloca when there is a variable length
-; memory intrinsic.
-; CHECK-LABEL: @PR14601(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @llvm.memset.p0.i32(ptr align 4 [[A]], i8 0, i32 [[X:%.*]], i1 false)
-; CHECK-NEXT: [[A_0_V:%.*]] = load i32, ptr [[A]], align 4
-; CHECK-NEXT: ret i32 [[A_0_V]]
-;
-
-entry:
- %a = alloca i32
-
- %a.i8 = bitcast i32* %a to i8*
- call void @llvm.memset.p0i8.i32(i8* %a.i8, i8 0, i32 %x, i1 false)
- %v = load i32, i32* %a
- ret i32 %v
-}
-
-define void @PR15674(i8* %data, i8* %src, i32 %size) {
-; Arrange (via control flow) to have unmerged stores of a particular width to
-; an alloca where we incrementally store from the end of the array toward the
-; beginning of the array. Ensure that the final integer store, despite being
-; convertable to the integer type that we end up promoting this alloca toward,
-; doesn't get widened to a full alloca store.
-; CHECK-LABEL: @PR15674(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[TMP_SROA_0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: switch i32 [[SIZE:%.*]], label [[END:%.*]] [
-; CHECK-NEXT: i32 4, label [[BB4:%.*]]
-; CHECK-NEXT: i32 3, label [[BB3:%.*]]
-; CHECK-NEXT: i32 2, label [[BB2:%.*]]
-; CHECK-NEXT: i32 1, label [[BB1:%.*]]
-; CHECK-NEXT: ]
-; CHECK: bb4:
-; CHECK-NEXT: [[SRC_GEP3:%.*]] = getelementptr inbounds i8, ptr [[SRC:%.*]], i32 3
-; CHECK-NEXT: [[SRC_3:%.*]] = load i8, ptr [[SRC_GEP3]], align 1
-; CHECK-NEXT: [[TMP_SROA_0_3_TMP_GEP3_SROA_IDX3:%.*]] = getelementptr inbounds i8, ptr [[TMP_SROA_0]], i64 3
-; CHECK-NEXT: store i8 [[SRC_3]], ptr [[TMP_SROA_0_3_TMP_GEP3_SROA_IDX3]], align 1
-; CHECK-NEXT: br label [[BB3]]
-; CHECK: bb3:
-; CHECK-NEXT: [[SRC_GEP2:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i32 2
-; CHECK-NEXT: [[SRC_2:%.*]] = load i8, ptr [[SRC_GEP2]], align 1
-; CHECK-NEXT: [[TMP_SROA_0_2_TMP_GEP2_SROA_IDX2:%.*]] = getelementptr inbounds i8, ptr [[TMP_SROA_0]], i64 2
-; CHECK-NEXT: store i8 [[SRC_2]], ptr [[TMP_SROA_0_2_TMP_GEP2_SROA_IDX2]], align 2
-; CHECK-NEXT: br label [[BB2]]
-; CHECK: bb2:
-; CHECK-NEXT: [[SRC_GEP1:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i32 1
-; CHECK-NEXT: [[SRC_1:%.*]] = load i8, ptr [[SRC_GEP1]], align 1
-; CHECK-NEXT: [[TMP_SROA_0_1_TMP_GEP1_SROA_IDX1:%.*]] = getelementptr inbounds i8, ptr [[TMP_SROA_0]], i64 1
-; CHECK-NEXT: store i8 [[SRC_1]], ptr [[TMP_SROA_0_1_TMP_GEP1_SROA_IDX1]], align 1
-; CHECK-NEXT: br label [[BB1]]
-; CHECK: bb1:
-; CHECK-NEXT: [[SRC_GEP0:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i32 0
-; CHECK-NEXT: [[SRC_0:%.*]] = load i8, ptr [[SRC_GEP0]], align 1
-; CHECK-NEXT: store i8 [[SRC_0]], ptr [[TMP_SROA_0]], align 4
-; CHECK-NEXT: br label [[END]]
-; CHECK: end:
-; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr [[DATA:%.*]], ptr align 4 [[TMP_SROA_0]], i32 [[SIZE]], i1 false)
-; CHECK-NEXT: ret void
-;
-
-entry:
- %tmp = alloca [4 x i8], align 1
-
- switch i32 %size, label %end [
- i32 4, label %bb4
- i32 3, label %bb3
- i32 2, label %bb2
- i32 1, label %bb1
- ]
-
-bb4:
- %src.gep3 = getelementptr inbounds i8, i8* %src, i32 3
- %src.3 = load i8, i8* %src.gep3
- %tmp.gep3 = getelementptr inbounds [4 x i8], [4 x i8]* %tmp, i32 0, i32 3
- store i8 %src.3, i8* %tmp.gep3
-
- br label %bb3
-
-bb3:
- %src.gep2 = getelementptr inbounds i8, i8* %src, i32 2
- %src.2 = load i8, i8* %src.gep2
- %tmp.gep2 = getelementptr inbounds [4 x i8], [4 x i8]* %tmp, i32 0, i32 2
- store i8 %src.2, i8* %tmp.gep2
-
- br label %bb2
-
-bb2:
- %src.gep1 = getelementptr inbounds i8, i8* %src, i32 1
- %src.1 = load i8, i8* %src.gep1
- %tmp.gep1 = getelementptr inbounds [4 x i8], [4 x i8]* %tmp, i32 0, i32 1
- store i8 %src.1, i8* %tmp.gep1
-
- br label %bb1
-
-bb1:
- %src.gep0 = getelementptr inbounds i8, i8* %src, i32 0
- %src.0 = load i8, i8* %src.gep0
- %tmp.gep0 = getelementptr inbounds [4 x i8], [4 x i8]* %tmp, i32 0, i32 0
- store i8 %src.0, i8* %tmp.gep0
-
- br label %end
-
-end:
- %tmp.raw = bitcast [4 x i8]* %tmp to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %data, i8* %tmp.raw, i32 %size, i1 false)
- ret void
-}
-
-define i64 @PR15805(i1 %a, i1 %b) {
-; CHECK-LABEL: @PR15805(
-; CHECK-NEXT: [[COND_SROA_SPECULATED:%.*]] = select i1 [[B:%.*]], i64 undef, i64 undef
-; CHECK-NEXT: ret i64 [[COND_SROA_SPECULATED]]
-;
-
- %c = alloca i64, align 8
- %p.0.c = select i1 %a, i64* %c, i64* %c
- %cond.in = select i1 %b, i64* %p.0.c, i64* %c
- %cond = load i64, i64* %cond.in, align 8
- ret i64 %cond
-}
-
-define void @PR15805.1(i1 %a, i1 %b, i1 %c1) {
-; Same as the normal PR15805, but rigged to place the use before the def inside
-; of looping unreachable code. This helps ensure that we aren't sensitive to the
-; order in which the uses of the alloca are visited.
-;
-; CHECK-LABEL: @PR15805.1(
-; CHECK-NEXT: br label [[EXIT:%.*]]
-; CHECK: loop:
-; CHECK-NEXT: [[COND_SROA_SPECULATED:%.*]] = select i1 [[A:%.*]], i64 undef, i64 undef
-; CHECK-NEXT: br i1 [[C1:%.*]], label [[LOOP:%.*]], label [[EXIT]]
-; CHECK: exit:
-; CHECK-NEXT: ret void
-;
-
- %c = alloca i64, align 8
- br label %exit
-
-loop:
- %cond.in = select i1 %a, i64* %c, i64* %p.0.c
- %p.0.c = select i1 %b, i64* %c, i64* %c
- %cond = load i64, i64* %cond.in, align 8
- br i1 %c1, label %loop, label %exit
-
-exit:
- ret void
-}
-
-define i8 @PR16651.1(i8* %a) {
-; This test case caused a crash due to the volatile memcpy in combination with
-; lowering to integer loads and stores of a width other than that of the original
-; memcpy.
-;
-; CHECK-LABEL: @PR16651.1(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[B_SROA_0:%.*]] = alloca i16, align 4
-; CHECK-NEXT: [[B_SROA_1:%.*]] = alloca i8, align 2
-; CHECK-NEXT: [[B_SROA_2:%.*]] = alloca i8, align 1
-; CHECK-NEXT: [[B_SROA_0_0_COPYLOAD:%.*]] = load volatile i16, ptr [[A:%.*]], align 4
-; CHECK-NEXT: store volatile i16 [[B_SROA_0_0_COPYLOAD]], ptr [[B_SROA_0]], align 4
-; CHECK-NEXT: [[B_SROA_1_0_A_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 2
-; CHECK-NEXT: [[B_SROA_1_0_COPYLOAD:%.*]] = load volatile i8, ptr [[B_SROA_1_0_A_SROA_IDX]], align 2
-; CHECK-NEXT: store volatile i8 [[B_SROA_1_0_COPYLOAD]], ptr [[B_SROA_1]], align 2
-; CHECK-NEXT: [[B_SROA_2_0_A_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 3
-; CHECK-NEXT: [[B_SROA_2_0_COPYLOAD:%.*]] = load volatile i8, ptr [[B_SROA_2_0_A_SROA_IDX]], align 1
-; CHECK-NEXT: store volatile i8 [[B_SROA_2_0_COPYLOAD]], ptr [[B_SROA_2]], align 1
-; CHECK-NEXT: [[B_SROA_1_0_B_SROA_1_2_V:%.*]] = load i8, ptr [[B_SROA_1]], align 2
-; CHECK-NEXT: ret i8 [[B_SROA_1_0_B_SROA_1_2_V]]
-;
-
-entry:
- %b = alloca i32, align 4
- %b.cast = bitcast i32* %b to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %b.cast, i8* align 4 %a, i32 4, i1 true)
- %b.gep = getelementptr inbounds i8, i8* %b.cast, i32 2
- %v = load i8, i8* %b.gep, align 2
- ret i8 %v
-}
-
-define float @PR16651.2(<2 x float> %val, i1 %c1) {
-; This test case caused a crash due to failing to promote given a select that
-; can't be speculated. It shouldn't be promoted, but we missed that fact when
-; analyzing whether we could form a vector promotion because that code didn't
-; bail on select instructions.
-;
-; CHECK-LABEL: @PR16651.2(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[TV1_SROA_0:%.*]] = alloca <2 x float>, align 8
-; CHECK-NEXT: store <2 x float> [[VAL:%.*]], ptr [[TV1_SROA_0]], align 8
-; CHECK-NEXT: [[COND105_IN_I_I:%.*]] = select i1 [[C1:%.*]], ptr null, ptr [[TV1_SROA_0]]
-; CHECK-NEXT: [[COND105_I_I:%.*]] = load float, ptr [[COND105_IN_I_I]], align 8
-; CHECK-NEXT: ret float [[COND105_I_I]]
-;
-
-entry:
- %tv1 = alloca { <2 x float>, <2 x float> }, align 8
- %0 = getelementptr { <2 x float>, <2 x float> }, { <2 x float>, <2 x float> }* %tv1, i64 0, i32 1
- store <2 x float> %val, <2 x float>* %0, align 8
- %1 = getelementptr inbounds { <2 x float>, <2 x float> }, { <2 x float>, <2 x float> }* %tv1, i64 0, i32 1, i64 0
- %cond105.in.i.i = select i1 %c1, float* null, float* %1
- %cond105.i.i = load float, float* %cond105.in.i.i, align 8
- ret float %cond105.i.i
-}
-
-define void @test23(i32 %x) {
-; CHECK-LABEL: @test23(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: ret void
-;
-entry:
- %a = alloca i32, align 4
- store i32 %x, i32* %a, align 4
- %gep1 = getelementptr inbounds i32, i32* %a, i32 1
- %gep0 = getelementptr inbounds i32, i32* %a, i32 0
- %cast1 = bitcast i32* %gep1 to i8*
- %cast0 = bitcast i32* %gep0 to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %cast1, i8* %cast0, i32 4, i1 false)
- ret void
-}
-
-define void @PR18615(i8* %ptr) {
-; CHECK-LABEL: @PR18615(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: ret void
-;
-entry:
- %f = alloca i8
- %gep = getelementptr i8, i8* %f, i64 -1
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %ptr, i8* %gep, i32 1, i1 false)
- ret void
-}
-
-define void @test24(i8* %src, i8* %dst) {
-; CHECK-LABEL: @test24(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[A:%.*]] = alloca i64, align 16
-; CHECK-NEXT: [[A_0_COPYLOAD:%.*]] = load volatile i64, ptr [[SRC:%.*]], align 1, !tbaa [[TBAA0]]
-; CHECK-NEXT: store volatile i64 [[A_0_COPYLOAD]], ptr [[A]], align 16, !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_0_COPYLOAD1:%.*]] = load volatile i64, ptr [[A]], align 16, !tbaa [[TBAA3]]
-; CHECK-NEXT: store volatile i64 [[A_0_COPYLOAD1]], ptr [[DST:%.*]], align 1, !tbaa [[TBAA3]]
-; CHECK-NEXT: ret void
-;
-
-entry:
- %a = alloca i64, align 16
- %ptr = bitcast i64* %a to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %ptr, i8* %src, i32 8, i1 true), !tbaa !0
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %ptr, i32 8, i1 true), !tbaa !3
- ret void
-}
-
-define float @test25() {
-; Check that we split up stores in order to promote the smaller SSA values.. These types
-; of patterns can arise because LLVM maps small memcpy's to integer load and
-; stores. If we get a memcpy of an aggregate (such as C and C++ frontends would
-; produce, but so might any language frontend), this will in many cases turn into
-; an integer load and store. SROA needs to be extremely powerful to correctly
-; handle these cases and form splitable and promotable SSA values.
-;
-; CHECK-LABEL: @test25(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[TMP0:%.*]] = bitcast i32 0 to float
-; CHECK-NEXT: [[TMP1:%.*]] = bitcast i32 1065353216 to float
-; CHECK-NEXT: [[RET:%.*]] = fadd float [[TMP0]], [[TMP1]]
-; CHECK-NEXT: ret float [[RET]]
-;
-
-entry:
- %a = alloca i64
- %b = alloca i64
- %a.cast = bitcast i64* %a to [2 x float]*
- %a.gep1 = getelementptr [2 x float], [2 x float]* %a.cast, i32 0, i32 0
- %a.gep2 = getelementptr [2 x float], [2 x float]* %a.cast, i32 0, i32 1
- %b.cast = bitcast i64* %b to [2 x float]*
- %b.gep1 = getelementptr [2 x float], [2 x float]* %b.cast, i32 0, i32 0
- %b.gep2 = getelementptr [2 x float], [2 x float]* %b.cast, i32 0, i32 1
- store float 0.0, float* %a.gep1
- store float 1.0, float* %a.gep2
- %v = load i64, i64* %a
- store i64 %v, i64* %b
- %f1 = load float, float* %b.gep1
- %f2 = load float, float* %b.gep2
- %ret = fadd float %f1, %f2
- ret float %ret
-}
-
- at complex1 = external global [2 x float]
- at complex2 = external global [2 x float]
-
-define void @test26() {
-; Test a case of splitting up loads and stores against a globals.
-;
-; CHECK-LABEL: @test26(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[V13:%.*]] = load i32, ptr @complex1, align 4
-; CHECK-NEXT: [[V14:%.*]] = load i32, ptr getelementptr inbounds (i8, ptr @complex1, i64 4), align 4
-; CHECK-NEXT: [[TMP0:%.*]] = bitcast i32 [[V13]] to float
-; CHECK-NEXT: [[TMP1:%.*]] = bitcast i32 [[V14]] to float
-; CHECK-NEXT: [[SUM:%.*]] = fadd float [[TMP0]], [[TMP1]]
-; CHECK-NEXT: [[TMP2:%.*]] = bitcast float [[SUM]] to i32
-; CHECK-NEXT: [[TMP3:%.*]] = bitcast float [[SUM]] to i32
-; CHECK-NEXT: store i32 [[TMP2]], ptr @complex2, align 4
-; CHECK-NEXT: store i32 [[TMP3]], ptr getelementptr inbounds (i8, ptr @complex2, i64 4), align 4
-; CHECK-NEXT: ret void
-;
-
-entry:
- %a = alloca i64
- %a.cast = bitcast i64* %a to [2 x float]*
- %a.gep1 = getelementptr [2 x float], [2 x float]* %a.cast, i32 0, i32 0
- %a.gep2 = getelementptr [2 x float], [2 x float]* %a.cast, i32 0, i32 1
- %v1 = load i64, i64* bitcast ([2 x float]* @complex1 to i64*)
- store i64 %v1, i64* %a
- %f1 = load float, float* %a.gep1
- %f2 = load float, float* %a.gep2
- %sum = fadd float %f1, %f2
- store float %sum, float* %a.gep1
- store float %sum, float* %a.gep2
- %v2 = load i64, i64* %a
- store i64 %v2, i64* bitcast ([2 x float]* @complex2 to i64*)
- ret void
-}
-
-define float @test27() {
-; Another, more complex case of splittable i64 loads and stores. This example
-; is a particularly challenging one because the load and store both point into
-; the alloca SROA is processing, and they overlap but at an offset.
-;
-; CHECK-LABEL: @test27(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[TMP0:%.*]] = bitcast i32 0 to float
-; CHECK-NEXT: [[TMP1:%.*]] = bitcast i32 1065353216 to float
-; CHECK-NEXT: [[RET:%.*]] = fadd float [[TMP0]], [[TMP1]]
-; CHECK-NEXT: ret float [[RET]]
-;
-
-entry:
- %a = alloca [12 x i8]
- %gep1 = getelementptr [12 x i8], [12 x i8]* %a, i32 0, i32 0
- %gep2 = getelementptr [12 x i8], [12 x i8]* %a, i32 0, i32 4
- %gep3 = getelementptr [12 x i8], [12 x i8]* %a, i32 0, i32 8
- %iptr1 = bitcast i8* %gep1 to i64*
- %iptr2 = bitcast i8* %gep2 to i64*
- %fptr1 = bitcast i8* %gep1 to float*
- %fptr2 = bitcast i8* %gep2 to float*
- %fptr3 = bitcast i8* %gep3 to float*
- store float 0.0, float* %fptr1
- store float 1.0, float* %fptr2
- %v = load i64, i64* %iptr1
- store i64 %v, i64* %iptr2
- %f1 = load float, float* %fptr2
- %f2 = load float, float* %fptr3
- %ret = fadd float %f1, %f2
- ret float %ret
-}
-
-define i32 @PR22093() {
-; Test that we don't try to pre-split a splittable store of a splittable but
-; not pre-splittable load over the same alloca. We "handle" this case when the
-; load is unsplittable but unrelated to this alloca by just generating extra
-; loads without touching the original, but when the original load was out of
-; this alloca we need to handle it specially to ensure the splits line up
-; properly for rewriting.
-;
-; CHECK-LABEL: @PR22093(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[A_SROA_0:%.*]] = alloca i16, align 4
-; CHECK-NEXT: store volatile i16 42, ptr [[A_SROA_0]], align 4
-; CHECK-NEXT: [[A_SROA_0_0_A_SROA_0_0_LOAD:%.*]] = load i16, ptr [[A_SROA_0]], align 4
-; CHECK-NEXT: [[A_SROA_3_0_INSERT_EXT:%.*]] = zext i16 undef to i32
-; CHECK-NEXT: [[A_SROA_3_0_INSERT_SHIFT:%.*]] = shl i32 [[A_SROA_3_0_INSERT_EXT]], 16
-; CHECK-NEXT: [[A_SROA_3_0_INSERT_MASK:%.*]] = and i32 undef, 65535
-; CHECK-NEXT: [[A_SROA_3_0_INSERT_INSERT:%.*]] = or i32 [[A_SROA_3_0_INSERT_MASK]], [[A_SROA_3_0_INSERT_SHIFT]]
-; CHECK-NEXT: [[A_SROA_0_0_INSERT_EXT:%.*]] = zext i16 [[A_SROA_0_0_A_SROA_0_0_LOAD]] to i32
-; CHECK-NEXT: [[A_SROA_0_0_INSERT_MASK:%.*]] = and i32 [[A_SROA_3_0_INSERT_INSERT]], -65536
-; CHECK-NEXT: [[A_SROA_0_0_INSERT_INSERT:%.*]] = or i32 [[A_SROA_0_0_INSERT_MASK]], [[A_SROA_0_0_INSERT_EXT]]
-; CHECK-NEXT: [[A_SROA_0_0_EXTRACT_TRUNC:%.*]] = trunc i32 [[A_SROA_0_0_INSERT_INSERT]] to i16
-; CHECK-NEXT: store i16 [[A_SROA_0_0_EXTRACT_TRUNC]], ptr [[A_SROA_0]], align 4
-; CHECK-NEXT: [[A_SROA_3_0_EXTRACT_SHIFT:%.*]] = lshr i32 [[A_SROA_0_0_INSERT_INSERT]], 16
-; CHECK-NEXT: [[A_SROA_3_0_EXTRACT_TRUNC:%.*]] = trunc i32 [[A_SROA_3_0_EXTRACT_SHIFT]] to i16
-; CHECK-NEXT: ret i32 [[A_SROA_0_0_INSERT_INSERT]]
-;
-
-entry:
- %a = alloca i32
- %a.cast = bitcast i32* %a to i16*
- store volatile i16 42, i16* %a.cast
- %load = load i32, i32* %a
- store i32 %load, i32* %a
- ret i32 %load
-}
-
-define void @PR22093.2() {
-; Another way that we end up being unable to split a particular set of loads
-; and stores can even have ordering importance. Here we have a load which is
-; pre-splittable by itself, and the first store is also compatible. But the
-; second store of the load makes the load unsplittable because of a mismatch of
-; splits. Because this makes the load unsplittable, we also have to go back and
-; remove the first store from the presplit candidates as its load won't be
-; presplit.
-;
-; CHECK-LABEL: @PR22093.2(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[A_SROA_0:%.*]] = alloca i16, align 8
-; CHECK-NEXT: [[A_SROA_31:%.*]] = alloca i8, align 4
-; CHECK-NEXT: store volatile i16 42, ptr [[A_SROA_0]], align 8
-; CHECK-NEXT: [[A_SROA_0_0_A_SROA_0_0_LOAD:%.*]] = load i16, ptr [[A_SROA_0]], align 8
-; CHECK-NEXT: [[A_SROA_3_0_INSERT_EXT:%.*]] = zext i16 undef to i32
-; CHECK-NEXT: [[A_SROA_3_0_INSERT_SHIFT:%.*]] = shl i32 [[A_SROA_3_0_INSERT_EXT]], 16
-; CHECK-NEXT: [[A_SROA_3_0_INSERT_MASK:%.*]] = and i32 undef, 65535
-; CHECK-NEXT: [[A_SROA_3_0_INSERT_INSERT:%.*]] = or i32 [[A_SROA_3_0_INSERT_MASK]], [[A_SROA_3_0_INSERT_SHIFT]]
-; CHECK-NEXT: [[A_SROA_0_0_INSERT_EXT:%.*]] = zext i16 [[A_SROA_0_0_A_SROA_0_0_LOAD]] to i32
-; CHECK-NEXT: [[A_SROA_0_0_INSERT_MASK:%.*]] = and i32 [[A_SROA_3_0_INSERT_INSERT]], -65536
-; CHECK-NEXT: [[A_SROA_0_0_INSERT_INSERT:%.*]] = or i32 [[A_SROA_0_0_INSERT_MASK]], [[A_SROA_0_0_INSERT_EXT]]
-; CHECK-NEXT: [[A_SROA_0_0_EXTRACT_TRUNC:%.*]] = trunc i32 [[A_SROA_0_0_INSERT_INSERT]] to i16
-; CHECK-NEXT: store i16 [[A_SROA_0_0_EXTRACT_TRUNC]], ptr [[A_SROA_0]], align 8
-; CHECK-NEXT: [[A_SROA_3_0_EXTRACT_SHIFT:%.*]] = lshr i32 [[A_SROA_0_0_INSERT_INSERT]], 16
-; CHECK-NEXT: [[A_SROA_3_0_EXTRACT_TRUNC:%.*]] = trunc i32 [[A_SROA_3_0_EXTRACT_SHIFT]] to i16
-; CHECK-NEXT: store volatile i8 13, ptr [[A_SROA_31]], align 4
-; CHECK-NEXT: [[A_SROA_31_4_EXTRACT_TRUNC:%.*]] = trunc i32 [[A_SROA_0_0_INSERT_INSERT]] to i8
-; CHECK-NEXT: store i8 [[A_SROA_31_4_EXTRACT_TRUNC]], ptr [[A_SROA_31]], align 4
-; CHECK-NEXT: [[A_SROA_5_4_EXTRACT_SHIFT:%.*]] = lshr i32 [[A_SROA_0_0_INSERT_INSERT]], 8
-; CHECK-NEXT: [[A_SROA_5_4_EXTRACT_TRUNC:%.*]] = trunc i32 [[A_SROA_5_4_EXTRACT_SHIFT]] to i24
-; CHECK-NEXT: ret void
-;
-
-entry:
- %a = alloca i64
- %a.cast1 = bitcast i64* %a to i32*
- %a.cast2 = bitcast i64* %a to i16*
- store volatile i16 42, i16* %a.cast2
- %load = load i32, i32* %a.cast1
- store i32 %load, i32* %a.cast1
- %a.gep1 = getelementptr i32, i32* %a.cast1, i32 1
- %a.cast3 = bitcast i32* %a.gep1 to i8*
- store volatile i8 13, i8* %a.cast3
- store i32 %load, i32* %a.gep1
- ret void
-}
-
-define void @PR23737() {
-; CHECK-LABEL: @PR23737(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[PTR:%.*]] = alloca i64, align 8
-; CHECK-NEXT: store atomic volatile i64 0, ptr [[PTR]] seq_cst, align 8
-; CHECK-NEXT: [[PTR_0_LOAD:%.*]] = load atomic volatile i64, ptr [[PTR]] seq_cst, align 8
-; CHECK-NEXT: ret void
-;
-entry:
- %ptr = alloca i64, align 8
- store atomic volatile i64 0, i64* %ptr seq_cst, align 8
- %load = load atomic volatile i64, i64* %ptr seq_cst, align 8
- ret void
-}
-
-define i16 @PR24463() {
-; Ensure we can handle a very interesting case where there is an integer-based
-; rewrite of the uses of the alloca, but where one of the integers in that is
-; a sub-integer that requires extraction *and* extends past the end of the
-; alloca. SROA can split the alloca to avoid shift or trunc.
-;
-; CHECK-LABEL: @PR24463(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[ALLOCA_SROA_1_2_LOAD_EXT:%.*]] = zext i8 0 to i16
-; CHECK-NEXT: ret i16 [[ALLOCA_SROA_1_2_LOAD_EXT]]
-;
-entry:
- %alloca = alloca [3 x i8]
- %gep1 = getelementptr inbounds [3 x i8], [3 x i8]* %alloca, i64 0, i64 1
- %bc1 = bitcast i8* %gep1 to i16*
- store i16 0, i16* %bc1
- %gep2 = getelementptr inbounds [3 x i8], [3 x i8]* %alloca, i64 0, i64 2
- %bc2 = bitcast i8* %gep2 to i16*
- %load = load i16, i16* %bc2
- ret i16 %load
-}
-
-%struct.STest = type { %struct.SPos, %struct.SPos }
-%struct.SPos = type { float, float }
-
-define void @PR25873(%struct.STest* %outData) {
-; CHECK-LABEL: @PR25873(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[TMP0:%.*]] = bitcast ptr [[OUTDATA:%.*]] to ptr
-; CHECK-NEXT: store i32 1123418112, ptr [[TMP0]], align 4
-; CHECK-NEXT: [[DOTSROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[TMP0]], i64 4
-; CHECK-NEXT: store i32 1139015680, ptr [[DOTSROA_IDX]], align 4
-; CHECK-NEXT: [[TMPDATA_SROA_6_0__SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[TMP0]], i64 8
-; CHECK-NEXT: [[TMPDATA_SROA_6_SROA_4_0_INSERT_EXT:%.*]] = zext i32 1139015680 to i64
-; CHECK-NEXT: [[TMPDATA_SROA_6_SROA_4_0_INSERT_SHIFT:%.*]] = shl i64 [[TMPDATA_SROA_6_SROA_4_0_INSERT_EXT]], 32
-; CHECK-NEXT: [[TMPDATA_SROA_6_SROA_4_0_INSERT_MASK:%.*]] = and i64 undef, 4294967295
-; CHECK-NEXT: [[TMPDATA_SROA_6_SROA_4_0_INSERT_INSERT:%.*]] = or i64 [[TMPDATA_SROA_6_SROA_4_0_INSERT_MASK]], [[TMPDATA_SROA_6_SROA_4_0_INSERT_SHIFT]]
-; CHECK-NEXT: [[TMPDATA_SROA_6_SROA_0_0_INSERT_EXT:%.*]] = zext i32 1123418112 to i64
-; CHECK-NEXT: [[TMPDATA_SROA_6_SROA_0_0_INSERT_MASK:%.*]] = and i64 [[TMPDATA_SROA_6_SROA_4_0_INSERT_INSERT]], -4294967296
-; CHECK-NEXT: [[TMPDATA_SROA_6_SROA_0_0_INSERT_INSERT:%.*]] = or i64 [[TMPDATA_SROA_6_SROA_0_0_INSERT_MASK]], [[TMPDATA_SROA_6_SROA_0_0_INSERT_EXT]]
-; CHECK-NEXT: store i64 [[TMPDATA_SROA_6_SROA_0_0_INSERT_INSERT]], ptr [[TMPDATA_SROA_6_0__SROA_IDX]], align 4
-; CHECK-NEXT: ret void
-;
-entry:
- %tmpData = alloca %struct.STest, align 8
- %0 = bitcast %struct.STest* %tmpData to i8*
- call void @llvm.lifetime.start.p0i8(i64 16, i8* %0)
- %x = getelementptr inbounds %struct.STest, %struct.STest* %tmpData, i64 0, i32 0, i32 0
- store float 1.230000e+02, float* %x, align 8
- %y = getelementptr inbounds %struct.STest, %struct.STest* %tmpData, i64 0, i32 0, i32 1
- store float 4.560000e+02, float* %y, align 4
- %m_posB = getelementptr inbounds %struct.STest, %struct.STest* %tmpData, i64 0, i32 1
- %1 = bitcast %struct.STest* %tmpData to i64*
- %2 = bitcast %struct.SPos* %m_posB to i64*
- %3 = load i64, i64* %1, align 8
- store i64 %3, i64* %2, align 8
- %4 = bitcast %struct.STest* %outData to i8*
- call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %4, i8* align 4 %0, i64 16, i1 false)
- call void @llvm.lifetime.end.p0i8(i64 16, i8* %0)
- ret void
-}
-
-declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) nounwind
-
-define void @PR27999() unnamed_addr {
-; CHECK-LABEL: @PR27999(
-; CHECK-NEXT: entry-block:
-; CHECK-NEXT: ret void
-;
-entry-block:
- %0 = alloca [2 x i64], align 8
- %1 = bitcast [2 x i64]* %0 to i8*
- call void @llvm.lifetime.start.p0i8(i64 16, i8* %1)
- %2 = getelementptr inbounds [2 x i64], [2 x i64]* %0, i32 0, i32 1
- %3 = bitcast i64* %2 to i8*
- call void @llvm.lifetime.end.p0i8(i64 8, i8* %3)
- ret void
-}
-
-define void @PR29139() {
-; CHECK-LABEL: @PR29139(
-; CHECK-NEXT: bb1:
-; CHECK-NEXT: ret void
-;
-bb1:
- %e.7.sroa.6.i = alloca i32, align 1
- %e.7.sroa.6.0.load81.i = load i32, i32* %e.7.sroa.6.i, align 1
- %0 = bitcast i32* %e.7.sroa.6.i to i8*
- call void @llvm.lifetime.end.p0i8(i64 2, i8* %0)
- ret void
-}
-
-; PR35657 reports assertion failure with this code
-define void @PR35657(i64 %v) {
-; CHECK-LABEL: @PR35657(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[A48_SROA_0_0_EXTRACT_TRUNC:%.*]] = trunc i64 [[V:%.*]] to i16
-; CHECK-NEXT: [[A48_SROA_2_0_EXTRACT_SHIFT:%.*]] = lshr i64 [[V]], 16
-; CHECK-NEXT: [[A48_SROA_2_0_EXTRACT_TRUNC:%.*]] = trunc i64 [[A48_SROA_2_0_EXTRACT_SHIFT]] to i48
-; CHECK-NEXT: call void @callee16(i16 [[A48_SROA_0_0_EXTRACT_TRUNC]])
-; CHECK-NEXT: call void @callee48(i48 [[A48_SROA_2_0_EXTRACT_TRUNC]])
-; CHECK-NEXT: ret void
-;
-entry:
- %a48 = alloca i48
- %a48.cast64 = bitcast i48* %a48 to i64*
- store i64 %v, i64* %a48.cast64
- %a48.cast16 = bitcast i48* %a48 to i16*
- %b0_15 = load i16, i16* %a48.cast16
- %a48.cast8 = bitcast i48* %a48 to i8*
- %a48_offset2 = getelementptr inbounds i8, i8* %a48.cast8, i64 2
- %a48_offset2.cast48 = bitcast i8* %a48_offset2 to i48*
- %b16_63 = load i48, i48* %a48_offset2.cast48, align 2
- call void @callee16(i16 %b0_15)
- call void @callee48(i48 %b16_63)
- ret void
-}
-
-declare void @callee16(i16 %a)
-declare void @callee48(i48 %a)
-
-define void @test28(i64 %v) #0 {
-; SROA should split the first i64 store to avoid additional and/or instructions
-; when storing into i32 fields
-; CHECK-LABEL: @test28(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[T_SROA_0_8_EXTRACT_TRUNC:%.*]] = trunc i64 [[V:%.*]] to i32
-; CHECK-NEXT: [[T_SROA_2_8_EXTRACT_SHIFT:%.*]] = lshr i64 [[V]], 32
-; CHECK-NEXT: [[T_SROA_2_8_EXTRACT_TRUNC:%.*]] = trunc i64 [[T_SROA_2_8_EXTRACT_SHIFT]] to i32
-; CHECK-NEXT: ret void
-;
-
-entry:
- %t = alloca { i64, i32, i32 }
-
- %b = getelementptr { i64, i32, i32 }, { i64, i32, i32 }* %t, i32 0, i32 1
- %0 = bitcast i32* %b to i64*
- store i64 %v, i64* %0
-
- %1 = load i32, i32* %b
- %c = getelementptr { i64, i32, i32 }, { i64, i32, i32 }* %t, i32 0, i32 2
- store i32 %1, i32* %c
- ret void
-}
-
-declare void @llvm.lifetime.start.isVoid.i64.p0i8(i64, [10 x float]* nocapture)
-declare void @llvm.lifetime.end.isVoid.i64.p0i8(i64, [10 x float]* nocapture)
- at array = dso_local global [10 x float] zeroinitializer, align 4
-
-define void @test29(i32 %num, i32 %tid) {
-; CHECK-LABEL: @test29(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[CMP1:%.*]] = icmp sgt i32 [[NUM:%.*]], 0
-; CHECK-NEXT: br i1 [[CMP1]], label [[BB1:%.*]], label [[BB7:%.*]]
-; CHECK: bb1:
-; CHECK-NEXT: [[TOBOOL:%.*]] = icmp eq i32 [[TID:%.*]], 0
-; CHECK-NEXT: [[CONV_I:%.*]] = zext i32 [[TID]] to i64
-; CHECK-NEXT: [[ARRAYIDX5:%.*]] = getelementptr inbounds [10 x float], ptr @array, i64 0, i64 [[CONV_I]]
-; CHECK-NEXT: [[TMP0:%.*]] = bitcast ptr [[ARRAYIDX5]] to ptr
-; CHECK-NEXT: br label [[BB2:%.*]]
-; CHECK: bb2:
-; CHECK-NEXT: [[I_02:%.*]] = phi i32 [ [[NUM]], [[BB1]] ], [ [[SUB:%.*]], [[BB5:%.*]] ]
-; CHECK-NEXT: br i1 [[TOBOOL]], label [[BB3:%.*]], label [[BB4:%.*]]
-; CHECK: bb3:
-; CHECK-NEXT: br label [[BB5]]
-; CHECK: bb4:
-; CHECK-NEXT: store i32 undef, ptr [[TMP0]], align 4
-; CHECK-NEXT: br label [[BB5]]
-; CHECK: bb5:
-; CHECK-NEXT: [[SUB]] = add i32 [[I_02]], -1
-; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i32 [[SUB]], 0
-; CHECK-NEXT: br i1 [[CMP]], label [[BB2]], label [[BB6:%.*]]
-; CHECK: bb6:
-; CHECK-NEXT: br label [[BB7]]
-; CHECK: bb7:
-; CHECK-NEXT: ret void
-;
-
-entry:
- %ra = alloca [10 x float], align 4
- call void @llvm.lifetime.start.isVoid.i64.p0i8(i64 40, [10 x float]* nonnull %ra)
-
- %cmp1 = icmp sgt i32 %num, 0
- br i1 %cmp1, label %bb1, label %bb7
-
-bb1:
- %tobool = icmp eq i32 %tid, 0
- %conv.i = zext i32 %tid to i64
- %0 = bitcast [10 x float]* %ra to i32*
- %1 = load i32, i32* %0, align 4
- %arrayidx5 = getelementptr inbounds [10 x float], [10 x float]* @array, i64 0, i64 %conv.i
- %2 = bitcast float* %arrayidx5 to i32*
- br label %bb2
-
-bb2:
- %i.02 = phi i32 [ %num, %bb1 ], [ %sub, %bb5 ]
- br i1 %tobool, label %bb3, label %bb4
-
-bb3:
- br label %bb5
-
-bb4:
- store i32 %1, i32* %2, align 4
- br label %bb5
-
-bb5:
- %sub = add i32 %i.02, -1
- %cmp = icmp sgt i32 %sub, 0
- br i1 %cmp, label %bb2, label %bb6
-
-bb6:
- br label %bb7
-
-bb7:
- call void @llvm.lifetime.end.isVoid.i64.p0i8(i64 40, [10 x float]* nonnull %ra)
- ret void
-}
-
-!0 = !{!1, !1, i64 0, i64 200}
-!1 = !{!2, i64 1, !"type_0"}
-!2 = !{!"root"}
-!3 = !{!4, !4, i64 0, i64 1}
-!4 = !{!2, i64 1, !"type_3"}
-!5 = !{!6, !6, i64 0, i64 1}
-!6 = !{!2, i64 1, !"type_5"}
-!7 = !{!8, !8, i64 0, i64 1}
-!8 = !{!2, i64 1, !"type_7"}
-!9 = !{!10, !10, i64 0, i64 1}
-!10 = !{!2, i64 1, !"type_9"}
-!11 = !{!12, !12, i64 0, i64 1}
-!12 = !{!2, i64 1, !"type_11"}
-!13 = !{!14, !14, i64 0, i64 1}
-!14 = !{!2, i64 1, !"type_13"}
-!15 = !{!16, !16, i64 0, i64 1}
-!16 = !{!2, i64 1, !"type_15"}
-!17 = !{!18, !18, i64 0, i64 1}
-!18 = !{!2, i64 1, !"type_17"}
-!19 = !{!20, !20, i64 0, i64 1}
-!20 = !{!2, i64 1, !"type_19"}
-!21 = !{!22, !22, i64 0, i64 1}
-!22 = !{!2, i64 1, !"type_21"}
-!23 = !{!24, !24, i64 0, i64 1}
-!24 = !{!2, i64 1, !"type_23"}
-!25 = !{!26, !26, i64 0, i64 1}
-!26 = !{!2, i64 1, !"type_25"}
-!27 = !{!28, !28, i64 0, i64 1}
-!28 = !{!2, i64 1, !"type_27"}
-!29 = !{!30, !30, i64 0, i64 1}
-!30 = !{!2, i64 1, !"type_29"}
-!31 = !{!32, !32, i64 0, i64 1}
-!32 = !{!2, i64 1, !"type_31"}
-!33 = !{!34, !34, i64 0, i64 1}
-!34 = !{!2, i64 1, !"type_33"}
-!35 = !{!36, !36, i64 0, i64 1}
-!36 = !{!2, i64 1, !"type_35"}
-!37 = !{!38, !38, i64 0, i64 1}
-!38 = !{!2, i64 1, !"type_37"}
-!39 = !{!40, !40, i64 0, i64 1}
-!40 = !{!2, i64 1, !"type_39"}
-!41 = !{!42, !42, i64 0, i64 1}
-!42 = !{!2, i64 1, !"type_41"}
-!43 = !{!44, !44, i64 0, i64 1}
-!44 = !{!2, i64 1, !"type_43"}
-!45 = !{!46, !46, i64 0, i64 1}
-!46 = !{!2, i64 1, !"type_45"}
-!47 = !{!48, !48, i64 0, i64 1}
-!48 = !{!2, i64 1, !"type_47"}
-!49 = !{!50, !50, i64 0, i64 1}
-!50 = !{!2, i64 1, !"type_49"}
-!51 = !{!52, !52, i64 0, i64 1}
-!52 = !{!2, i64 1, !"type_51"}
-!53 = !{!54, !54, i64 0, i64 1}
-!54 = !{!2, i64 1, !"type_53"}
-!55 = !{!56, !56, i64 0, i64 1}
-!56 = !{!2, i64 1, !"type_55"}
-!57 = !{!58, !58, i64 0, i64 1}
-!58 = !{!2, i64 1, !"type_57"}
-!59 = !{!60, !60, i64 0, i64 1}
-!60 = !{!2, i64 1, !"type_59"}
diff --git a/llvm/test/Transforms/SROA/basictest.ll b/llvm/test/Transforms/SROA/basictest.ll
index 82221b49c5f0..6c02dfbfd193 100644
--- a/llvm/test/Transforms/SROA/basictest.ll
+++ b/llvm/test/Transforms/SROA/basictest.ll
@@ -3,8 +3,8 @@
target datalayout = "e-p:64:64:64-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
-declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
-declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
+declare void @llvm.lifetime.start.p0(i64, ptr nocapture)
+declare void @llvm.lifetime.end.p0(i64, ptr nocapture)
define i32 @test0() {
; CHECK-LABEL: @test0(
@@ -18,23 +18,21 @@ entry:
%a1 = alloca i32
%a2 = alloca float
- %a1.i8 = bitcast i32* %a1 to i8*
- call void @llvm.lifetime.start.p0i8(i64 4, i8* %a1.i8)
+ call void @llvm.lifetime.start.p0(i64 4, ptr %a1)
- store i32 0, i32* %a1
- %v1 = load i32, i32* %a1
+ store i32 0, ptr %a1
+ %v1 = load i32, ptr %a1
- call void @llvm.lifetime.end.p0i8(i64 4, i8* %a1.i8)
+ call void @llvm.lifetime.end.p0(i64 4, ptr %a1)
- %a2.i8 = bitcast float* %a2 to i8*
- call void @llvm.lifetime.start.p0i8(i64 4, i8* %a2.i8)
+ call void @llvm.lifetime.start.p0(i64 4, ptr %a2)
- store float 0.0, float* %a2
- %v2 = load float , float * %a2
+ store float 0.0, ptr %a2
+ %v2 = load float , ptr %a2
%v2.int = bitcast float %v2 to i32
%sum1 = add i32 %v1, %v2.int
- call void @llvm.lifetime.end.p0i8(i64 4, i8* %a2.i8)
+ call void @llvm.lifetime.end.p0(i64 4, ptr %a2)
ret i32 %sum1
}
@@ -47,9 +45,9 @@ define i32 @test1() {
entry:
%X = alloca { i32, float }
- %Y = getelementptr { i32, float }, { i32, float }* %X, i64 0, i32 0
- store i32 0, i32* %Y
- %Z = load i32, i32* %Y
+ %Y = getelementptr { i32, float }, ptr %X, i64 0, i32 0
+ store i32 0, ptr %Y
+ %Z = load i32, ptr %Y
ret i32 %Z
}
@@ -63,12 +61,11 @@ define i64 @test2(i64 %X) {
entry:
%A = alloca [8 x i8]
- %B = bitcast [8 x i8]* %A to i64*
- store i64 %X, i64* %B
+ store i64 %X, ptr %A
br label %L2
L2:
- %Z = load i64, i64* %B
+ %Z = load i64, ptr %A
ret i64 %Z
}
@@ -82,12 +79,12 @@ define i64 @test2_addrspacecast(i64 %X) {
entry:
%A = alloca [8 x i8]
- %B = addrspacecast [8 x i8]* %A to i64 addrspace(1)*
- store i64 %X, i64 addrspace(1)* %B
+ %B = addrspacecast ptr %A to ptr addrspace(1)
+ store i64 %X, ptr addrspace(1) %B
br label %L2
L2:
- %Z = load i64, i64 addrspace(1)* %B
+ %Z = load i64, ptr addrspace(1) %B
ret i64 %Z
}
@@ -101,15 +98,14 @@ define i64 @test2_addrspacecast_gep(i64 %X, i16 %idx) {
entry:
%A = alloca [256 x i8]
- %B = addrspacecast [256 x i8]* %A to i64 addrspace(1)*
- %gepA = getelementptr [256 x i8], [256 x i8]* %A, i16 0, i16 32
- %gepB = getelementptr i64, i64 addrspace(1)* %B, i16 4
- store i64 %X, i64 addrspace(1)* %gepB, align 1
+ %B = addrspacecast ptr %A to ptr addrspace(1)
+ %gepA = getelementptr [256 x i8], ptr %A, i16 0, i16 32
+ %gepB = getelementptr i64, ptr addrspace(1) %B, i16 4
+ store i64 %X, ptr addrspace(1) %gepB, align 1
br label %L2
L2:
- %gepA.bc = bitcast i8* %gepA to i64*
- %Z = load i64, i64* %gepA.bc, align 1
+ %Z = load i64, ptr %gepA, align 1
ret i64 %Z
}
@@ -118,376 +114,289 @@ define i64 @test2_addrspacecast_gep_offset(i64 %X) {
; CHECK-LABEL: @test2_addrspacecast_gep_offset(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A_SROA_0:%.*]] = alloca [10 x i8], align 1
-; CHECK-NEXT: [[A_SROA_0_2_GEPB_SROA_IDX:%.*]] = getelementptr inbounds [10 x i8], [10 x i8]* [[A_SROA_0]], i16 0, i16 2
-; CHECK-NEXT: [[A_SROA_0_2_GEPB_SROA_CAST:%.*]] = addrspacecast i8* [[A_SROA_0_2_GEPB_SROA_IDX]] to i64 addrspace(1)*
-; CHECK-NEXT: store i64 [[X:%.*]], i64 addrspace(1)* [[A_SROA_0_2_GEPB_SROA_CAST]], align 1
+; CHECK-NEXT: [[A_SROA_0_2_GEPB_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_0]], i16 2
+; CHECK-NEXT: [[A_SROA_0_2_GEPB_SROA_CAST:%.*]] = addrspacecast ptr [[A_SROA_0_2_GEPB_SROA_IDX]] to ptr addrspace(1)
+; CHECK-NEXT: store i64 [[X:%.*]], ptr addrspace(1) [[A_SROA_0_2_GEPB_SROA_CAST]], align 1
; CHECK-NEXT: br label [[L2:%.*]]
; CHECK: L2:
-; CHECK-NEXT: [[A_SROA_0_0_GEPA_BC_SROA_CAST:%.*]] = bitcast [10 x i8]* [[A_SROA_0]] to i64*
-; CHECK-NEXT: [[A_SROA_0_0_A_SROA_0_30_Z:%.*]] = load i64, i64* [[A_SROA_0_0_GEPA_BC_SROA_CAST]], align 1
+; CHECK-NEXT: [[A_SROA_0_0_A_SROA_0_30_Z:%.*]] = load i64, ptr [[A_SROA_0]], align 1
; CHECK-NEXT: ret i64 [[A_SROA_0_0_A_SROA_0_30_Z]]
;
entry:
%A = alloca [256 x i8]
- %B = addrspacecast [256 x i8]* %A to i64 addrspace(1)*
- %gepA = getelementptr [256 x i8], [256 x i8]* %A, i16 0, i16 30
- %gepB = getelementptr i64, i64 addrspace(1)* %B, i16 4
- store i64 %X, i64 addrspace(1)* %gepB, align 1
+ %B = addrspacecast ptr %A to ptr addrspace(1)
+ %gepA = getelementptr [256 x i8], ptr %A, i16 0, i16 30
+ %gepB = getelementptr i64, ptr addrspace(1) %B, i16 4
+ store i64 %X, ptr addrspace(1) %gepB, align 1
br label %L2
L2:
- %gepA.bc = bitcast i8* %gepA to i64*
- %Z = load i64, i64* %gepA.bc, align 1
+ %Z = load i64, ptr %gepA, align 1
ret i64 %Z
}
-define void @test3(i8* %dst, i8* align 8 %src) {
+define void @test3(ptr %dst, ptr align 8 %src) {
; CHECK-LABEL: @test3(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A_SROA_0:%.*]] = alloca [42 x i8], align 1
; CHECK-NEXT: [[A_SROA_3:%.*]] = alloca [99 x i8], align 1
-; CHECK-NEXT: [[A_SROA_34:%.*]] = alloca [16 x i8], align 1
+; CHECK-NEXT: [[A_SROA_32:%.*]] = alloca [16 x i8], align 1
; CHECK-NEXT: [[A_SROA_15:%.*]] = alloca [42 x i8], align 1
; CHECK-NEXT: [[A_SROA_16:%.*]] = alloca [7 x i8], align 1
-; CHECK-NEXT: [[A_SROA_239:%.*]] = alloca [7 x i8], align 1
+; CHECK-NEXT: [[A_SROA_235:%.*]] = alloca [7 x i8], align 1
; CHECK-NEXT: [[A_SROA_31:%.*]] = alloca [85 x i8], align 1
-; CHECK-NEXT: [[A_SROA_0_0_B_SROA_IDX:%.*]] = getelementptr inbounds [42 x i8], [42 x i8]* [[A_SROA_0]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_0_0_B_SROA_IDX]], i8* align 8 [[SRC:%.*]], i32 42, i1 false), !tbaa [[TBAA0:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_2_0_SRC_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i64 42
-; CHECK-NEXT: [[A_SROA_2_0_COPYLOAD:%.*]] = load i8, i8* [[A_SROA_2_0_SRC_SROA_RAW_IDX]], align 2, !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_3_0_SRC_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i64 43
-; CHECK-NEXT: [[A_SROA_3_0_B_SROA_IDX:%.*]] = getelementptr inbounds [99 x i8], [99 x i8]* [[A_SROA_3]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_3_0_B_SROA_IDX]], i8* align 1 [[A_SROA_3_0_SRC_SROA_RAW_IDX]], i32 99, i1 false), !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_34_0_SRC_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i64 142
-; CHECK-NEXT: [[A_SROA_34_0_B_SROA_IDX:%.*]] = getelementptr inbounds [16 x i8], [16 x i8]* [[A_SROA_34]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_34_0_B_SROA_IDX]], i8* align 2 [[A_SROA_34_0_SRC_SROA_RAW_IDX]], i32 16, i1 false), !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_15_0_SRC_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i64 158
-; CHECK-NEXT: [[A_SROA_15_0_B_SROA_IDX:%.*]] = getelementptr inbounds [42 x i8], [42 x i8]* [[A_SROA_15]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_15_0_B_SROA_IDX]], i8* align 2 [[A_SROA_15_0_SRC_SROA_RAW_IDX]], i32 42, i1 false), !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_16_0_SRC_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i64 200
-; CHECK-NEXT: [[A_SROA_16_0_B_SROA_IDX:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_16]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_16_0_B_SROA_IDX]], i8* align 8 [[A_SROA_16_0_SRC_SROA_RAW_IDX]], i32 7, i1 false), !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_23_0_SRC_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i64 207
-; CHECK-NEXT: [[A_SROA_23_0_COPYLOAD:%.*]] = load i8, i8* [[A_SROA_23_0_SRC_SROA_RAW_IDX]], align 1, !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_239_0_SRC_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i64 208
-; CHECK-NEXT: [[A_SROA_239_0_B_SROA_IDX:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_239]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_239_0_B_SROA_IDX]], i8* align 8 [[A_SROA_239_0_SRC_SROA_RAW_IDX]], i32 7, i1 false), !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_31_0_SRC_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i64 215
-; CHECK-NEXT: [[A_SROA_31_0_B_SROA_IDX:%.*]] = getelementptr inbounds [85 x i8], [85 x i8]* [[A_SROA_31]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_31_0_B_SROA_IDX]], i8* align 1 [[A_SROA_31_0_SRC_SROA_RAW_IDX]], i32 85, i1 false), !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_34_0_OVERLAP_1_I8_SROA_IDX:%.*]] = getelementptr inbounds [16 x i8], [16 x i8]* [[A_SROA_34]], i64 0, i64 0
-; CHECK-NEXT: store i8 1, i8* [[A_SROA_34_0_OVERLAP_1_I8_SROA_IDX]], align 1, !tbaa [[TBAA3:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_34_0_OVERLAP_1_I16_SROA_CAST:%.*]] = bitcast [16 x i8]* [[A_SROA_34]] to i16*
-; CHECK-NEXT: store i16 1, i16* [[A_SROA_34_0_OVERLAP_1_I16_SROA_CAST]], align 1, !tbaa [[TBAA5:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_34_0_OVERLAP_1_I32_SROA_CAST:%.*]] = bitcast [16 x i8]* [[A_SROA_34]] to i32*
-; CHECK-NEXT: store i32 1, i32* [[A_SROA_34_0_OVERLAP_1_I32_SROA_CAST]], align 1, !tbaa [[TBAA7:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_34_0_OVERLAP_1_I64_SROA_CAST:%.*]] = bitcast [16 x i8]* [[A_SROA_34]] to i64*
-; CHECK-NEXT: store i64 1, i64* [[A_SROA_34_0_OVERLAP_1_I64_SROA_CAST]], align 1, !tbaa [[TBAA9:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_34_1_OVERLAP_2_I64_SROA_IDX:%.*]] = getelementptr inbounds [16 x i8], [16 x i8]* [[A_SROA_34]], i64 0, i64 1
-; CHECK-NEXT: [[A_SROA_34_1_OVERLAP_2_I64_SROA_CAST:%.*]] = bitcast i8* [[A_SROA_34_1_OVERLAP_2_I64_SROA_IDX]] to i64*
-; CHECK-NEXT: store i64 2, i64* [[A_SROA_34_1_OVERLAP_2_I64_SROA_CAST]], align 1, !tbaa [[TBAA11:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_34_2_OVERLAP_3_I64_SROA_IDX:%.*]] = getelementptr inbounds [16 x i8], [16 x i8]* [[A_SROA_34]], i64 0, i64 2
-; CHECK-NEXT: [[A_SROA_34_2_OVERLAP_3_I64_SROA_CAST:%.*]] = bitcast i8* [[A_SROA_34_2_OVERLAP_3_I64_SROA_IDX]] to i64*
-; CHECK-NEXT: store i64 3, i64* [[A_SROA_34_2_OVERLAP_3_I64_SROA_CAST]], align 1, !tbaa [[TBAA13:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_34_3_OVERLAP_4_I64_SROA_IDX:%.*]] = getelementptr inbounds [16 x i8], [16 x i8]* [[A_SROA_34]], i64 0, i64 3
-; CHECK-NEXT: [[A_SROA_34_3_OVERLAP_4_I64_SROA_CAST:%.*]] = bitcast i8* [[A_SROA_34_3_OVERLAP_4_I64_SROA_IDX]] to i64*
-; CHECK-NEXT: store i64 4, i64* [[A_SROA_34_3_OVERLAP_4_I64_SROA_CAST]], align 1, !tbaa [[TBAA15:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_34_4_OVERLAP_5_I64_SROA_IDX:%.*]] = getelementptr inbounds [16 x i8], [16 x i8]* [[A_SROA_34]], i64 0, i64 4
-; CHECK-NEXT: [[A_SROA_34_4_OVERLAP_5_I64_SROA_CAST:%.*]] = bitcast i8* [[A_SROA_34_4_OVERLAP_5_I64_SROA_IDX]] to i64*
-; CHECK-NEXT: store i64 5, i64* [[A_SROA_34_4_OVERLAP_5_I64_SROA_CAST]], align 1, !tbaa [[TBAA17:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_34_5_OVERLAP_6_I64_SROA_IDX:%.*]] = getelementptr inbounds [16 x i8], [16 x i8]* [[A_SROA_34]], i64 0, i64 5
-; CHECK-NEXT: [[A_SROA_34_5_OVERLAP_6_I64_SROA_CAST:%.*]] = bitcast i8* [[A_SROA_34_5_OVERLAP_6_I64_SROA_IDX]] to i64*
-; CHECK-NEXT: store i64 6, i64* [[A_SROA_34_5_OVERLAP_6_I64_SROA_CAST]], align 1, !tbaa [[TBAA19:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_34_6_OVERLAP_7_I64_SROA_IDX:%.*]] = getelementptr inbounds [16 x i8], [16 x i8]* [[A_SROA_34]], i64 0, i64 6
-; CHECK-NEXT: [[A_SROA_34_6_OVERLAP_7_I64_SROA_CAST:%.*]] = bitcast i8* [[A_SROA_34_6_OVERLAP_7_I64_SROA_IDX]] to i64*
-; CHECK-NEXT: store i64 7, i64* [[A_SROA_34_6_OVERLAP_7_I64_SROA_CAST]], align 1, !tbaa [[TBAA21:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_34_7_OVERLAP_8_I64_SROA_IDX:%.*]] = getelementptr inbounds [16 x i8], [16 x i8]* [[A_SROA_34]], i64 0, i64 7
-; CHECK-NEXT: [[A_SROA_34_7_OVERLAP_8_I64_SROA_CAST:%.*]] = bitcast i8* [[A_SROA_34_7_OVERLAP_8_I64_SROA_IDX]] to i64*
-; CHECK-NEXT: store i64 8, i64* [[A_SROA_34_7_OVERLAP_8_I64_SROA_CAST]], align 1, !tbaa [[TBAA23:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_34_8_OVERLAP_9_I64_SROA_IDX:%.*]] = getelementptr inbounds [16 x i8], [16 x i8]* [[A_SROA_34]], i64 0, i64 8
-; CHECK-NEXT: [[A_SROA_34_8_OVERLAP_9_I64_SROA_CAST:%.*]] = bitcast i8* [[A_SROA_34_8_OVERLAP_9_I64_SROA_IDX]] to i64*
-; CHECK-NEXT: store i64 9, i64* [[A_SROA_34_8_OVERLAP_9_I64_SROA_CAST]], align 1, !tbaa [[TBAA25:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_16_0_OVERLAP2_1_0_I8_SROA_IDX:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_16]], i64 0, i64 0
-; CHECK-NEXT: store i8 1, i8* [[A_SROA_16_0_OVERLAP2_1_0_I8_SROA_IDX]], align 1, !tbaa [[TBAA27:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_16_0_OVERLAP2_1_0_I16_SROA_CAST:%.*]] = bitcast [7 x i8]* [[A_SROA_16]] to i16*
-; CHECK-NEXT: store i16 1, i16* [[A_SROA_16_0_OVERLAP2_1_0_I16_SROA_CAST]], align 1, !tbaa [[TBAA29:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_16_0_OVERLAP2_1_0_I32_SROA_CAST:%.*]] = bitcast [7 x i8]* [[A_SROA_16]] to i32*
-; CHECK-NEXT: store i32 1, i32* [[A_SROA_16_0_OVERLAP2_1_0_I32_SROA_CAST]], align 1, !tbaa [[TBAA31:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_16_1_OVERLAP2_1_1_I32_SROA_IDX:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_16]], i64 0, i64 1
-; CHECK-NEXT: [[A_SROA_16_1_OVERLAP2_1_1_I32_SROA_CAST:%.*]] = bitcast i8* [[A_SROA_16_1_OVERLAP2_1_1_I32_SROA_IDX]] to i32*
-; CHECK-NEXT: store i32 2, i32* [[A_SROA_16_1_OVERLAP2_1_1_I32_SROA_CAST]], align 1, !tbaa [[TBAA33:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_16_2_OVERLAP2_1_2_I32_SROA_IDX:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_16]], i64 0, i64 2
-; CHECK-NEXT: [[A_SROA_16_2_OVERLAP2_1_2_I32_SROA_CAST:%.*]] = bitcast i8* [[A_SROA_16_2_OVERLAP2_1_2_I32_SROA_IDX]] to i32*
-; CHECK-NEXT: store i32 3, i32* [[A_SROA_16_2_OVERLAP2_1_2_I32_SROA_CAST]], align 1, !tbaa [[TBAA35:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_16_3_OVERLAP2_1_3_I32_SROA_IDX:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_16]], i64 0, i64 3
-; CHECK-NEXT: [[A_SROA_16_3_OVERLAP2_1_3_I32_SROA_CAST:%.*]] = bitcast i8* [[A_SROA_16_3_OVERLAP2_1_3_I32_SROA_IDX]] to i32*
-; CHECK-NEXT: store i32 4, i32* [[A_SROA_16_3_OVERLAP2_1_3_I32_SROA_CAST]], align 1, !tbaa [[TBAA37:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_239_0_OVERLAP2_2_0_I32_SROA_CAST:%.*]] = bitcast [7 x i8]* [[A_SROA_239]] to i32*
-; CHECK-NEXT: store i32 1, i32* [[A_SROA_239_0_OVERLAP2_2_0_I32_SROA_CAST]], align 1, !tbaa [[TBAA39:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_239_1_OVERLAP2_2_1_I8_SROA_IDX:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_239]], i64 0, i64 1
-; CHECK-NEXT: store i8 1, i8* [[A_SROA_239_1_OVERLAP2_2_1_I8_SROA_IDX]], align 1, !tbaa [[TBAA41:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_239_1_OVERLAP2_2_1_I16_SROA_IDX:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_239]], i64 0, i64 1
-; CHECK-NEXT: [[A_SROA_239_1_OVERLAP2_2_1_I16_SROA_CAST:%.*]] = bitcast i8* [[A_SROA_239_1_OVERLAP2_2_1_I16_SROA_IDX]] to i16*
-; CHECK-NEXT: store i16 1, i16* [[A_SROA_239_1_OVERLAP2_2_1_I16_SROA_CAST]], align 1, !tbaa [[TBAA43:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_239_1_OVERLAP2_2_1_I32_SROA_IDX:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_239]], i64 0, i64 1
-; CHECK-NEXT: [[A_SROA_239_1_OVERLAP2_2_1_I32_SROA_CAST:%.*]] = bitcast i8* [[A_SROA_239_1_OVERLAP2_2_1_I32_SROA_IDX]] to i32*
-; CHECK-NEXT: store i32 1, i32* [[A_SROA_239_1_OVERLAP2_2_1_I32_SROA_CAST]], align 1, !tbaa [[TBAA45:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_239_2_OVERLAP2_2_2_I32_SROA_IDX:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_239]], i64 0, i64 2
-; CHECK-NEXT: [[A_SROA_239_2_OVERLAP2_2_2_I32_SROA_CAST:%.*]] = bitcast i8* [[A_SROA_239_2_OVERLAP2_2_2_I32_SROA_IDX]] to i32*
-; CHECK-NEXT: store i32 3, i32* [[A_SROA_239_2_OVERLAP2_2_2_I32_SROA_CAST]], align 1, !tbaa [[TBAA47:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_239_3_OVERLAP2_2_3_I32_SROA_IDX:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_239]], i64 0, i64 3
-; CHECK-NEXT: [[A_SROA_239_3_OVERLAP2_2_3_I32_SROA_CAST:%.*]] = bitcast i8* [[A_SROA_239_3_OVERLAP2_2_3_I32_SROA_IDX]] to i32*
-; CHECK-NEXT: store i32 4, i32* [[A_SROA_239_3_OVERLAP2_2_3_I32_SROA_CAST]], align 1, !tbaa [[TBAA49:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_15_197_OVERLAP2_PREFIX_SROA_IDX:%.*]] = getelementptr inbounds [42 x i8], [42 x i8]* [[A_SROA_15]], i64 0, i64 39
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_15_197_OVERLAP2_PREFIX_SROA_IDX]], i8* align 1 [[SRC]], i32 3, i1 false), !tbaa [[TBAA51:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_16_197_SRC_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i64 3
-; CHECK-NEXT: [[A_SROA_16_197_OVERLAP2_PREFIX_SROA_IDX:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_16]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_16_197_OVERLAP2_PREFIX_SROA_IDX]], i8* align 1 [[A_SROA_16_197_SRC_SROA_RAW_IDX]], i32 5, i1 false), !tbaa [[TBAA51]]
-; CHECK-NEXT: [[A_SROA_16_2_OVERLAP2_1_2_I8_SROA_IDX:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_16]], i64 0, i64 2
-; CHECK-NEXT: call void @llvm.memset.p0i8.i32(i8* align 1 [[A_SROA_16_2_OVERLAP2_1_2_I8_SROA_IDX]], i8 42, i32 5, i1 false), !tbaa [[TBAA53:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_239_0_OVERLAP2_1_2_I8_SROA_IDX:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_239]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memset.p0i8.i32(i8* align 1 [[A_SROA_239_0_OVERLAP2_1_2_I8_SROA_IDX]], i8 42, i32 2, i1 false), !tbaa [[TBAA53]]
-; CHECK-NEXT: [[A_SROA_239_209_OVERLAP2_2_1_I8_SROA_IDX11:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_239]], i64 0, i64 1
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_239_209_OVERLAP2_2_1_I8_SROA_IDX11]], i8* align 1 [[SRC]], i32 5, i1 false), !tbaa [[TBAA55:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_239_210_OVERLAP2_2_2_I8_SROA_IDX:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_239]], i64 0, i64 2
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_239_210_OVERLAP2_2_2_I8_SROA_IDX]], i8* align 1 [[SRC]], i32 5, i1 false), !tbaa [[TBAA57:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_31_210_SRC_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i64 5
-; CHECK-NEXT: [[A_SROA_31_210_OVERLAP2_2_2_I8_SROA_IDX:%.*]] = getelementptr inbounds [85 x i8], [85 x i8]* [[A_SROA_31]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_31_210_OVERLAP2_2_2_I8_SROA_IDX]], i8* align 1 [[A_SROA_31_210_SRC_SROA_RAW_IDX]], i32 3, i1 false), !tbaa [[TBAA57]]
-; CHECK-NEXT: [[A_SROA_0_0_B_SROA_IDX1:%.*]] = getelementptr inbounds [42 x i8], [42 x i8]* [[A_SROA_0]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[DST:%.*]], i8* align 1 [[A_SROA_0_0_B_SROA_IDX1]], i32 42, i1 false), !tbaa [[TBAA59:![0-9]+]]
-; CHECK-NEXT: [[A_SROA_2_0_DST_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[DST]], i64 42
-; CHECK-NEXT: store i8 0, i8* [[A_SROA_2_0_DST_SROA_RAW_IDX]], align 1, !tbaa [[TBAA59]]
-; CHECK-NEXT: [[A_SROA_3_0_DST_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[DST]], i64 43
-; CHECK-NEXT: [[A_SROA_3_0_B_SROA_IDX3:%.*]] = getelementptr inbounds [99 x i8], [99 x i8]* [[A_SROA_3]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_3_0_DST_SROA_RAW_IDX]], i8* align 1 [[A_SROA_3_0_B_SROA_IDX3]], i32 99, i1 false), !tbaa [[TBAA59]]
-; CHECK-NEXT: [[A_SROA_34_0_DST_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[DST]], i64 142
-; CHECK-NEXT: [[A_SROA_34_0_B_SROA_IDX5:%.*]] = getelementptr inbounds [16 x i8], [16 x i8]* [[A_SROA_34]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_34_0_DST_SROA_RAW_IDX]], i8* align 1 [[A_SROA_34_0_B_SROA_IDX5]], i32 16, i1 false), !tbaa [[TBAA59]]
-; CHECK-NEXT: [[A_SROA_15_0_DST_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[DST]], i64 158
-; CHECK-NEXT: [[A_SROA_15_0_B_SROA_IDX6:%.*]] = getelementptr inbounds [42 x i8], [42 x i8]* [[A_SROA_15]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_15_0_DST_SROA_RAW_IDX]], i8* align 1 [[A_SROA_15_0_B_SROA_IDX6]], i32 42, i1 false), !tbaa [[TBAA59]]
-; CHECK-NEXT: [[A_SROA_16_0_DST_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[DST]], i64 200
-; CHECK-NEXT: [[A_SROA_16_0_B_SROA_IDX7:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_16]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_16_0_DST_SROA_RAW_IDX]], i8* align 1 [[A_SROA_16_0_B_SROA_IDX7]], i32 7, i1 false), !tbaa [[TBAA59]]
-; CHECK-NEXT: [[A_SROA_23_0_DST_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[DST]], i64 207
-; CHECK-NEXT: store i8 42, i8* [[A_SROA_23_0_DST_SROA_RAW_IDX]], align 1, !tbaa [[TBAA59]]
-; CHECK-NEXT: [[A_SROA_239_0_DST_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[DST]], i64 208
-; CHECK-NEXT: [[A_SROA_239_0_B_SROA_IDX10:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_239]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_239_0_DST_SROA_RAW_IDX]], i8* align 1 [[A_SROA_239_0_B_SROA_IDX10]], i32 7, i1 false), !tbaa [[TBAA59]]
-; CHECK-NEXT: [[A_SROA_31_0_DST_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[DST]], i64 215
-; CHECK-NEXT: [[A_SROA_31_0_B_SROA_IDX12:%.*]] = getelementptr inbounds [85 x i8], [85 x i8]* [[A_SROA_31]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_31_0_DST_SROA_RAW_IDX]], i8* align 1 [[A_SROA_31_0_B_SROA_IDX12]], i32 85, i1 false), !tbaa [[TBAA59]]
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_0]], ptr align 8 [[SRC:%.*]], i32 42, i1 false), !tbaa [[TBAA0:![0-9]+]]
+; CHECK-NEXT: [[A_SROA_2_0_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 42
+; CHECK-NEXT: [[A_SROA_2_0_COPYLOAD:%.*]] = load i8, ptr [[A_SROA_2_0_SRC_SROA_IDX]], align 2, !tbaa [[TBAA0]]
+; CHECK-NEXT: [[A_SROA_3_0_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 43
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_3]], ptr align 1 [[A_SROA_3_0_SRC_SROA_IDX]], i32 99, i1 false), !tbaa [[TBAA0]]
+; CHECK-NEXT: [[A_SROA_32_0_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 142
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_32]], ptr align 2 [[A_SROA_32_0_SRC_SROA_IDX]], i32 16, i1 false), !tbaa [[TBAA0]]
+; CHECK-NEXT: [[A_SROA_15_0_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 158
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_15]], ptr align 2 [[A_SROA_15_0_SRC_SROA_IDX]], i32 42, i1 false), !tbaa [[TBAA0]]
+; CHECK-NEXT: [[A_SROA_16_0_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 200
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_16]], ptr align 8 [[A_SROA_16_0_SRC_SROA_IDX]], i32 7, i1 false), !tbaa [[TBAA0]]
+; CHECK-NEXT: [[A_SROA_23_0_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 207
+; CHECK-NEXT: [[A_SROA_23_0_COPYLOAD:%.*]] = load i8, ptr [[A_SROA_23_0_SRC_SROA_IDX]], align 1, !tbaa [[TBAA0]]
+; CHECK-NEXT: [[A_SROA_235_0_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 208
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_235]], ptr align 8 [[A_SROA_235_0_SRC_SROA_IDX]], i32 7, i1 false), !tbaa [[TBAA0]]
+; CHECK-NEXT: [[A_SROA_31_0_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 215
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_31]], ptr align 1 [[A_SROA_31_0_SRC_SROA_IDX]], i32 85, i1 false), !tbaa [[TBAA0]]
+; CHECK-NEXT: store i8 1, ptr [[A_SROA_32]], align 1, !tbaa [[TBAA3:![0-9]+]]
+; CHECK-NEXT: store i16 1, ptr [[A_SROA_32]], align 1, !tbaa [[TBAA5:![0-9]+]]
+; CHECK-NEXT: store i32 1, ptr [[A_SROA_32]], align 1, !tbaa [[TBAA7:![0-9]+]]
+; CHECK-NEXT: store i64 1, ptr [[A_SROA_32]], align 1, !tbaa [[TBAA9:![0-9]+]]
+; CHECK-NEXT: [[A_SROA_32_1_OVERLAP_2_I8_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_32]], i64 1
+; CHECK-NEXT: store i64 2, ptr [[A_SROA_32_1_OVERLAP_2_I8_SROA_IDX]], align 1, !tbaa [[TBAA11:![0-9]+]]
+; CHECK-NEXT: [[A_SROA_32_2_OVERLAP_3_I8_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_32]], i64 2
+; CHECK-NEXT: store i64 3, ptr [[A_SROA_32_2_OVERLAP_3_I8_SROA_IDX]], align 1, !tbaa [[TBAA13:![0-9]+]]
+; CHECK-NEXT: [[A_SROA_32_3_OVERLAP_4_I8_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_32]], i64 3
+; CHECK-NEXT: store i64 4, ptr [[A_SROA_32_3_OVERLAP_4_I8_SROA_IDX]], align 1, !tbaa [[TBAA15:![0-9]+]]
+; CHECK-NEXT: [[A_SROA_32_4_OVERLAP_5_I8_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_32]], i64 4
+; CHECK-NEXT: store i64 5, ptr [[A_SROA_32_4_OVERLAP_5_I8_SROA_IDX]], align 1, !tbaa [[TBAA17:![0-9]+]]
+; CHECK-NEXT: [[A_SROA_32_5_OVERLAP_6_I8_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_32]], i64 5
+; CHECK-NEXT: store i64 6, ptr [[A_SROA_32_5_OVERLAP_6_I8_SROA_IDX]], align 1, !tbaa [[TBAA19:![0-9]+]]
+; CHECK-NEXT: [[A_SROA_32_6_OVERLAP_7_I8_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_32]], i64 6
+; CHECK-NEXT: store i64 7, ptr [[A_SROA_32_6_OVERLAP_7_I8_SROA_IDX]], align 1, !tbaa [[TBAA21:![0-9]+]]
+; CHECK-NEXT: [[A_SROA_32_7_OVERLAP_8_I8_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_32]], i64 7
+; CHECK-NEXT: store i64 8, ptr [[A_SROA_32_7_OVERLAP_8_I8_SROA_IDX]], align 1, !tbaa [[TBAA23:![0-9]+]]
+; CHECK-NEXT: [[A_SROA_32_8_OVERLAP_9_I8_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_32]], i64 8
+; CHECK-NEXT: store i64 9, ptr [[A_SROA_32_8_OVERLAP_9_I8_SROA_IDX]], align 1, !tbaa [[TBAA25:![0-9]+]]
+; CHECK-NEXT: store i8 1, ptr [[A_SROA_16]], align 1, !tbaa [[TBAA27:![0-9]+]]
+; CHECK-NEXT: store i16 1, ptr [[A_SROA_16]], align 1, !tbaa [[TBAA29:![0-9]+]]
+; CHECK-NEXT: store i32 1, ptr [[A_SROA_16]], align 1, !tbaa [[TBAA31:![0-9]+]]
+; CHECK-NEXT: [[A_SROA_16_1_OVERLAP2_1_1_I8_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_16]], i64 1
+; CHECK-NEXT: store i32 2, ptr [[A_SROA_16_1_OVERLAP2_1_1_I8_SROA_IDX]], align 1, !tbaa [[TBAA33:![0-9]+]]
+; CHECK-NEXT: [[A_SROA_16_2_OVERLAP2_1_2_I8_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_16]], i64 2
+; CHECK-NEXT: store i32 3, ptr [[A_SROA_16_2_OVERLAP2_1_2_I8_SROA_IDX]], align 1, !tbaa [[TBAA35:![0-9]+]]
+; CHECK-NEXT: [[A_SROA_16_3_OVERLAP2_1_3_I8_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_16]], i64 3
+; CHECK-NEXT: store i32 4, ptr [[A_SROA_16_3_OVERLAP2_1_3_I8_SROA_IDX]], align 1, !tbaa [[TBAA37:![0-9]+]]
+; CHECK-NEXT: store i32 1, ptr [[A_SROA_235]], align 1, !tbaa [[TBAA39:![0-9]+]]
+; CHECK-NEXT: [[A_SROA_235_1_OVERLAP2_2_1_I8_SROA_IDX11:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_235]], i64 1
+; CHECK-NEXT: store i8 1, ptr [[A_SROA_235_1_OVERLAP2_2_1_I8_SROA_IDX11]], align 1, !tbaa [[TBAA41:![0-9]+]]
+; CHECK-NEXT: [[A_SROA_235_1_OVERLAP2_2_1_I8_SROA_IDX10:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_235]], i64 1
+; CHECK-NEXT: store i16 1, ptr [[A_SROA_235_1_OVERLAP2_2_1_I8_SROA_IDX10]], align 1, !tbaa [[TBAA43:![0-9]+]]
+; CHECK-NEXT: [[A_SROA_235_1_OVERLAP2_2_1_I8_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_235]], i64 1
+; CHECK-NEXT: store i32 1, ptr [[A_SROA_235_1_OVERLAP2_2_1_I8_SROA_IDX]], align 1, !tbaa [[TBAA45:![0-9]+]]
+; CHECK-NEXT: [[A_SROA_235_2_OVERLAP2_2_2_I8_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_235]], i64 2
+; CHECK-NEXT: store i32 3, ptr [[A_SROA_235_2_OVERLAP2_2_2_I8_SROA_IDX]], align 1, !tbaa [[TBAA47:![0-9]+]]
+; CHECK-NEXT: [[A_SROA_235_3_OVERLAP2_2_3_I8_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_235]], i64 3
+; CHECK-NEXT: store i32 4, ptr [[A_SROA_235_3_OVERLAP2_2_3_I8_SROA_IDX]], align 1, !tbaa [[TBAA49:![0-9]+]]
+; CHECK-NEXT: [[A_SROA_15_197_OVERLAP2_PREFIX_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_15]], i64 39
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_15_197_OVERLAP2_PREFIX_SROA_IDX]], ptr align 1 [[SRC]], i32 3, i1 false), !tbaa [[TBAA51:![0-9]+]]
+; CHECK-NEXT: [[A_SROA_16_197_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 3
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_16]], ptr align 1 [[A_SROA_16_197_SRC_SROA_IDX]], i32 5, i1 false), !tbaa [[TBAA51]]
+; CHECK-NEXT: [[A_SROA_16_2_OVERLAP2_1_2_I8_SROA_IDX12:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_16]], i64 2
+; CHECK-NEXT: call void @llvm.memset.p0.i32(ptr align 1 [[A_SROA_16_2_OVERLAP2_1_2_I8_SROA_IDX12]], i8 42, i32 5, i1 false), !tbaa [[TBAA53:![0-9]+]]
+; CHECK-NEXT: call void @llvm.memset.p0.i32(ptr align 1 [[A_SROA_235]], i8 42, i32 2, i1 false), !tbaa [[TBAA53]]
+; CHECK-NEXT: [[A_SROA_235_209_OVERLAP2_2_1_I8_SROA_IDX8:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_235]], i64 1
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_235_209_OVERLAP2_2_1_I8_SROA_IDX8]], ptr align 1 [[SRC]], i32 5, i1 false), !tbaa [[TBAA55:![0-9]+]]
+; CHECK-NEXT: [[A_SROA_235_210_OVERLAP2_2_2_I8_SROA_IDX9:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_235]], i64 2
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_235_210_OVERLAP2_2_2_I8_SROA_IDX9]], ptr align 1 [[SRC]], i32 5, i1 false), !tbaa [[TBAA57:![0-9]+]]
+; CHECK-NEXT: [[A_SROA_31_210_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 5
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_31]], ptr align 1 [[A_SROA_31_210_SRC_SROA_IDX]], i32 3, i1 false), !tbaa [[TBAA57]]
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[DST:%.*]], ptr align 1 [[A_SROA_0]], i32 42, i1 false), !tbaa [[TBAA59:![0-9]+]]
+; CHECK-NEXT: [[A_SROA_2_0_DST_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 42
+; CHECK-NEXT: store i8 0, ptr [[A_SROA_2_0_DST_SROA_IDX]], align 1, !tbaa [[TBAA59]]
+; CHECK-NEXT: [[A_SROA_3_0_DST_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 43
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_3_0_DST_SROA_IDX]], ptr align 1 [[A_SROA_3]], i32 99, i1 false), !tbaa [[TBAA59]]
+; CHECK-NEXT: [[A_SROA_32_0_DST_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 142
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_32_0_DST_SROA_IDX]], ptr align 1 [[A_SROA_32]], i32 16, i1 false), !tbaa [[TBAA59]]
+; CHECK-NEXT: [[A_SROA_15_0_DST_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 158
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_15_0_DST_SROA_IDX]], ptr align 1 [[A_SROA_15]], i32 42, i1 false), !tbaa [[TBAA59]]
+; CHECK-NEXT: [[A_SROA_16_0_DST_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 200
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_16_0_DST_SROA_IDX]], ptr align 1 [[A_SROA_16]], i32 7, i1 false), !tbaa [[TBAA59]]
+; CHECK-NEXT: [[A_SROA_23_0_DST_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 207
+; CHECK-NEXT: store i8 42, ptr [[A_SROA_23_0_DST_SROA_IDX]], align 1, !tbaa [[TBAA59]]
+; CHECK-NEXT: [[A_SROA_235_0_DST_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 208
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_235_0_DST_SROA_IDX]], ptr align 1 [[A_SROA_235]], i32 7, i1 false), !tbaa [[TBAA59]]
+; CHECK-NEXT: [[A_SROA_31_0_DST_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 215
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_31_0_DST_SROA_IDX]], ptr align 1 [[A_SROA_31]], i32 85, i1 false), !tbaa [[TBAA59]]
; CHECK-NEXT: ret void
;
entry:
%a = alloca [300 x i8]
- %b = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 0
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %b, i8* align 8 %src, i32 300, i1 false), !tbaa !0
+ call void @llvm.memcpy.p0.p0.i32(ptr %a, ptr align 8 %src, i32 300, i1 false), !tbaa !0
; Clobber a single element of the array, this should be promotable, and be deleted.
- %c = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 42
- store i8 0, i8* %c
+ %c = getelementptr [300 x i8], ptr %a, i64 0, i64 42
+ store i8 0, ptr %c
; Make a sequence of overlapping stores to the array. These overlap both in
; forward strides and in shrinking accesses.
- %overlap.1.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 142
- %overlap.2.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 143
- %overlap.3.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 144
- %overlap.4.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 145
- %overlap.5.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 146
- %overlap.6.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 147
- %overlap.7.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 148
- %overlap.8.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 149
- %overlap.9.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 150
- %overlap.1.i16 = bitcast i8* %overlap.1.i8 to i16*
- %overlap.1.i32 = bitcast i8* %overlap.1.i8 to i32*
- %overlap.1.i64 = bitcast i8* %overlap.1.i8 to i64*
- %overlap.2.i64 = bitcast i8* %overlap.2.i8 to i64*
- %overlap.3.i64 = bitcast i8* %overlap.3.i8 to i64*
- %overlap.4.i64 = bitcast i8* %overlap.4.i8 to i64*
- %overlap.5.i64 = bitcast i8* %overlap.5.i8 to i64*
- %overlap.6.i64 = bitcast i8* %overlap.6.i8 to i64*
- %overlap.7.i64 = bitcast i8* %overlap.7.i8 to i64*
- %overlap.8.i64 = bitcast i8* %overlap.8.i8 to i64*
- %overlap.9.i64 = bitcast i8* %overlap.9.i8 to i64*
- store i8 1, i8* %overlap.1.i8, !tbaa !3
- store i16 1, i16* %overlap.1.i16, !tbaa !5
- store i32 1, i32* %overlap.1.i32, !tbaa !7
- store i64 1, i64* %overlap.1.i64, !tbaa !9
- store i64 2, i64* %overlap.2.i64, !tbaa !11
- store i64 3, i64* %overlap.3.i64, !tbaa !13
- store i64 4, i64* %overlap.4.i64, !tbaa !15
- store i64 5, i64* %overlap.5.i64, !tbaa !17
- store i64 6, i64* %overlap.6.i64, !tbaa !19
- store i64 7, i64* %overlap.7.i64, !tbaa !21
- store i64 8, i64* %overlap.8.i64, !tbaa !23
- store i64 9, i64* %overlap.9.i64, !tbaa !25
+ %overlap.1.i8 = getelementptr [300 x i8], ptr %a, i64 0, i64 142
+ %overlap.2.i8 = getelementptr [300 x i8], ptr %a, i64 0, i64 143
+ %overlap.3.i8 = getelementptr [300 x i8], ptr %a, i64 0, i64 144
+ %overlap.4.i8 = getelementptr [300 x i8], ptr %a, i64 0, i64 145
+ %overlap.5.i8 = getelementptr [300 x i8], ptr %a, i64 0, i64 146
+ %overlap.6.i8 = getelementptr [300 x i8], ptr %a, i64 0, i64 147
+ %overlap.7.i8 = getelementptr [300 x i8], ptr %a, i64 0, i64 148
+ %overlap.8.i8 = getelementptr [300 x i8], ptr %a, i64 0, i64 149
+ %overlap.9.i8 = getelementptr [300 x i8], ptr %a, i64 0, i64 150
+ store i8 1, ptr %overlap.1.i8, !tbaa !3
+ store i16 1, ptr %overlap.1.i8, !tbaa !5
+ store i32 1, ptr %overlap.1.i8, !tbaa !7
+ store i64 1, ptr %overlap.1.i8, !tbaa !9
+ store i64 2, ptr %overlap.2.i8, !tbaa !11
+ store i64 3, ptr %overlap.3.i8, !tbaa !13
+ store i64 4, ptr %overlap.4.i8, !tbaa !15
+ store i64 5, ptr %overlap.5.i8, !tbaa !17
+ store i64 6, ptr %overlap.6.i8, !tbaa !19
+ store i64 7, ptr %overlap.7.i8, !tbaa !21
+ store i64 8, ptr %overlap.8.i8, !tbaa !23
+ store i64 9, ptr %overlap.9.i8, !tbaa !25
; Make two sequences of overlapping stores with more gaps and irregularities.
- %overlap2.1.0.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 200
- %overlap2.1.1.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 201
- %overlap2.1.2.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 202
- %overlap2.1.3.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 203
-
- %overlap2.2.0.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 208
- %overlap2.2.1.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 209
- %overlap2.2.2.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 210
- %overlap2.2.3.i8 = getelementptr [300 x i8], [300 x i8]* %a, i64 0, i64 211
-
- %overlap2.1.0.i16 = bitcast i8* %overlap2.1.0.i8 to i16*
- %overlap2.1.0.i32 = bitcast i8* %overlap2.1.0.i8 to i32*
- %overlap2.1.1.i32 = bitcast i8* %overlap2.1.1.i8 to i32*
- %overlap2.1.2.i32 = bitcast i8* %overlap2.1.2.i8 to i32*
- %overlap2.1.3.i32 = bitcast i8* %overlap2.1.3.i8 to i32*
- store i8 1, i8* %overlap2.1.0.i8, !tbaa !27
- store i16 1, i16* %overlap2.1.0.i16, !tbaa !29
- store i32 1, i32* %overlap2.1.0.i32, !tbaa !31
- store i32 2, i32* %overlap2.1.1.i32, !tbaa !33
- store i32 3, i32* %overlap2.1.2.i32, !tbaa !35
- store i32 4, i32* %overlap2.1.3.i32, !tbaa !37
-
- %overlap2.2.0.i32 = bitcast i8* %overlap2.2.0.i8 to i32*
- %overlap2.2.1.i16 = bitcast i8* %overlap2.2.1.i8 to i16*
- %overlap2.2.1.i32 = bitcast i8* %overlap2.2.1.i8 to i32*
- %overlap2.2.2.i32 = bitcast i8* %overlap2.2.2.i8 to i32*
- %overlap2.2.3.i32 = bitcast i8* %overlap2.2.3.i8 to i32*
- store i32 1, i32* %overlap2.2.0.i32, !tbaa !39
- store i8 1, i8* %overlap2.2.1.i8, !tbaa !41
- store i16 1, i16* %overlap2.2.1.i16, !tbaa !43
- store i32 1, i32* %overlap2.2.1.i32, !tbaa !45
- store i32 3, i32* %overlap2.2.2.i32, !tbaa !47
- store i32 4, i32* %overlap2.2.3.i32, !tbaa !49
-
- %overlap2.prefix = getelementptr i8, i8* %overlap2.1.1.i8, i64 -4
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %overlap2.prefix, i8* %src, i32 8, i1 false), !tbaa !51
+ %overlap2.1.0.i8 = getelementptr [300 x i8], ptr %a, i64 0, i64 200
+ %overlap2.1.1.i8 = getelementptr [300 x i8], ptr %a, i64 0, i64 201
+ %overlap2.1.2.i8 = getelementptr [300 x i8], ptr %a, i64 0, i64 202
+ %overlap2.1.3.i8 = getelementptr [300 x i8], ptr %a, i64 0, i64 203
+
+ %overlap2.2.0.i8 = getelementptr [300 x i8], ptr %a, i64 0, i64 208
+ %overlap2.2.1.i8 = getelementptr [300 x i8], ptr %a, i64 0, i64 209
+ %overlap2.2.2.i8 = getelementptr [300 x i8], ptr %a, i64 0, i64 210
+ %overlap2.2.3.i8 = getelementptr [300 x i8], ptr %a, i64 0, i64 211
+
+ store i8 1, ptr %overlap2.1.0.i8, !tbaa !27
+ store i16 1, ptr %overlap2.1.0.i8, !tbaa !29
+ store i32 1, ptr %overlap2.1.0.i8, !tbaa !31
+ store i32 2, ptr %overlap2.1.1.i8, !tbaa !33
+ store i32 3, ptr %overlap2.1.2.i8, !tbaa !35
+ store i32 4, ptr %overlap2.1.3.i8, !tbaa !37
+
+ store i32 1, ptr %overlap2.2.0.i8, !tbaa !39
+ store i8 1, ptr %overlap2.2.1.i8, !tbaa !41
+ store i16 1, ptr %overlap2.2.1.i8, !tbaa !43
+ store i32 1, ptr %overlap2.2.1.i8, !tbaa !45
+ store i32 3, ptr %overlap2.2.2.i8, !tbaa !47
+ store i32 4, ptr %overlap2.2.3.i8, !tbaa !49
+
+ %overlap2.prefix = getelementptr i8, ptr %overlap2.1.1.i8, i64 -4
+ call void @llvm.memcpy.p0.p0.i32(ptr %overlap2.prefix, ptr %src, i32 8, i1 false), !tbaa !51
; Bridge between the overlapping areas
- call void @llvm.memset.p0i8.i32(i8* %overlap2.1.2.i8, i8 42, i32 8, i1 false), !tbaa !53
+ call void @llvm.memset.p0.i32(ptr %overlap2.1.2.i8, i8 42, i32 8, i1 false), !tbaa !53
; ...promoted i8 store...
; Entirely within the second overlap.
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %overlap2.2.1.i8, i8* %src, i32 5, i1 false), !tbaa !55
+ call void @llvm.memcpy.p0.p0.i32(ptr %overlap2.2.1.i8, ptr %src, i32 5, i1 false), !tbaa !55
; Trailing past the second overlap.
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %overlap2.2.2.i8, i8* %src, i32 8, i1 false), !tbaa !57
+ call void @llvm.memcpy.p0.p0.i32(ptr %overlap2.2.2.i8, ptr %src, i32 8, i1 false), !tbaa !57
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %b, i32 300, i1 false), !tbaa !59
+ call void @llvm.memcpy.p0.p0.i32(ptr %dst, ptr %a, i32 300, i1 false), !tbaa !59
ret void
}
-define void @test4(i8* %dst, i8* %src) {
+define void @test4(ptr %dst, ptr %src) {
; CHECK-LABEL: @test4(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A_SROA_0:%.*]] = alloca [20 x i8], align 1
; CHECK-NEXT: [[A_SROA_2_SROA_4:%.*]] = alloca [7 x i8], align 1
; CHECK-NEXT: [[A_SROA_3:%.*]] = alloca [10 x i8], align 1
-; CHECK-NEXT: [[A_SROA_34_SROA_5:%.*]] = alloca [7 x i8], align 1
+; CHECK-NEXT: [[A_SROA_31_SROA_5:%.*]] = alloca [7 x i8], align 1
; CHECK-NEXT: [[A_SROA_6_SROA_4:%.*]] = alloca [7 x i8], align 1
; CHECK-NEXT: [[A_SROA_7:%.*]] = alloca [40 x i8], align 1
-; CHECK-NEXT: [[A_SROA_0_0_B_SROA_IDX:%.*]] = getelementptr inbounds [20 x i8], [20 x i8]* [[A_SROA_0]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_0_0_B_SROA_IDX]], i8* align 1 [[SRC:%.*]], i32 20, i1 false), !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_2_SROA_0_0_A_SROA_2_0_SRC_SROA_RAW_IDX_SROA_IDX:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i64 20
-; CHECK-NEXT: [[A_SROA_2_SROA_0_0_A_SROA_2_0_SRC_SROA_RAW_IDX_SROA_CAST:%.*]] = bitcast i8* [[A_SROA_2_SROA_0_0_A_SROA_2_0_SRC_SROA_RAW_IDX_SROA_IDX]] to i16*
-; CHECK-NEXT: [[A_SROA_2_SROA_0_0_COPYLOAD:%.*]] = load i16, i16* [[A_SROA_2_SROA_0_0_A_SROA_2_0_SRC_SROA_RAW_IDX_SROA_CAST]], align 1, !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_2_SROA_3_0_A_SROA_2_0_SRC_SROA_RAW_IDX_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i64 22
-; CHECK-NEXT: [[A_SROA_2_SROA_3_0_COPYLOAD:%.*]] = load i8, i8* [[A_SROA_2_SROA_3_0_A_SROA_2_0_SRC_SROA_RAW_IDX_SROA_RAW_IDX]], align 1, !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_2_SROA_4_0_A_SROA_2_0_SRC_SROA_RAW_IDX_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i64 23
-; CHECK-NEXT: [[A_SROA_2_SROA_4_0_B_SROA_IDX:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_2_SROA_4]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_2_SROA_4_0_B_SROA_IDX]], i8* align 1 [[A_SROA_2_SROA_4_0_A_SROA_2_0_SRC_SROA_RAW_IDX_SROA_RAW_IDX]], i32 7, i1 false), !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_3_0_SRC_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i64 30
-; CHECK-NEXT: [[A_SROA_3_0_B_SROA_IDX:%.*]] = getelementptr inbounds [10 x i8], [10 x i8]* [[A_SROA_3]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_3_0_B_SROA_IDX]], i8* align 1 [[A_SROA_3_0_SRC_SROA_RAW_IDX]], i32 10, i1 false), !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_34_SROA_0_0_A_SROA_34_0_SRC_SROA_RAW_IDX_SROA_IDX:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i64 40
-; CHECK-NEXT: [[A_SROA_34_SROA_0_0_A_SROA_34_0_SRC_SROA_RAW_IDX_SROA_CAST:%.*]] = bitcast i8* [[A_SROA_34_SROA_0_0_A_SROA_34_0_SRC_SROA_RAW_IDX_SROA_IDX]] to i16*
-; CHECK-NEXT: [[A_SROA_34_SROA_0_0_COPYLOAD:%.*]] = load i16, i16* [[A_SROA_34_SROA_0_0_A_SROA_34_0_SRC_SROA_RAW_IDX_SROA_CAST]], align 1, !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_34_SROA_4_0_A_SROA_34_0_SRC_SROA_RAW_IDX_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i64 42
-; CHECK-NEXT: [[A_SROA_34_SROA_4_0_COPYLOAD:%.*]] = load i8, i8* [[A_SROA_34_SROA_4_0_A_SROA_34_0_SRC_SROA_RAW_IDX_SROA_RAW_IDX]], align 1, !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_34_SROA_5_0_A_SROA_34_0_SRC_SROA_RAW_IDX_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i64 43
-; CHECK-NEXT: [[A_SROA_34_SROA_5_0_B_SROA_IDX:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_34_SROA_5]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_34_SROA_5_0_B_SROA_IDX]], i8* align 1 [[A_SROA_34_SROA_5_0_A_SROA_34_0_SRC_SROA_RAW_IDX_SROA_RAW_IDX]], i32 7, i1 false), !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_6_SROA_0_0_A_SROA_6_0_SRC_SROA_RAW_IDX_SROA_IDX:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i64 50
-; CHECK-NEXT: [[A_SROA_6_SROA_0_0_A_SROA_6_0_SRC_SROA_RAW_IDX_SROA_CAST:%.*]] = bitcast i8* [[A_SROA_6_SROA_0_0_A_SROA_6_0_SRC_SROA_RAW_IDX_SROA_IDX]] to i16*
-; CHECK-NEXT: [[A_SROA_6_SROA_0_0_COPYLOAD:%.*]] = load i16, i16* [[A_SROA_6_SROA_0_0_A_SROA_6_0_SRC_SROA_RAW_IDX_SROA_CAST]], align 1, !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_6_SROA_3_0_A_SROA_6_0_SRC_SROA_RAW_IDX_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i64 52
-; CHECK-NEXT: [[A_SROA_6_SROA_3_0_COPYLOAD:%.*]] = load i8, i8* [[A_SROA_6_SROA_3_0_A_SROA_6_0_SRC_SROA_RAW_IDX_SROA_RAW_IDX]], align 1, !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_6_SROA_4_0_A_SROA_6_0_SRC_SROA_RAW_IDX_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i64 53
-; CHECK-NEXT: [[A_SROA_6_SROA_4_0_B_SROA_IDX:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_6_SROA_4]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_6_SROA_4_0_B_SROA_IDX]], i8* align 1 [[A_SROA_6_SROA_4_0_A_SROA_6_0_SRC_SROA_RAW_IDX_SROA_RAW_IDX]], i32 7, i1 false), !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_7_0_SRC_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i64 60
-; CHECK-NEXT: [[A_SROA_7_0_B_SROA_IDX:%.*]] = getelementptr inbounds [40 x i8], [40 x i8]* [[A_SROA_7]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_7_0_B_SROA_IDX]], i8* align 1 [[A_SROA_7_0_SRC_SROA_RAW_IDX]], i32 40, i1 false), !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_2_SROA_4_3_A_SROA_34_SROA_5_0_A_DST_1_SROA_IDX_SROA_IDX:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_34_SROA_5]], i64 0, i64 0
-; CHECK-NEXT: [[A_SROA_2_SROA_4_3_A_SRC_1_SROA_IDX:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_2_SROA_4]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_2_SROA_4_3_A_SROA_34_SROA_5_0_A_DST_1_SROA_IDX_SROA_IDX]], i8* align 1 [[A_SROA_2_SROA_4_3_A_SRC_1_SROA_IDX]], i32 7, i1 false), !tbaa [[TBAA3]]
-; CHECK-NEXT: [[A_SROA_6_SROA_4_3_A_SROA_34_SROA_5_0_A_DST_1_SROA_IDX16_SROA_IDX:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_34_SROA_5]], i64 0, i64 0
-; CHECK-NEXT: [[A_SROA_6_SROA_4_3_A_SRC_2_SROA_IDX:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_6_SROA_4]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_6_SROA_4_3_A_SROA_34_SROA_5_0_A_DST_1_SROA_IDX16_SROA_IDX]], i8* align 1 [[A_SROA_6_SROA_4_3_A_SRC_2_SROA_IDX]], i32 7, i1 false), !tbaa [[TBAA5]]
-; CHECK-NEXT: [[A_SROA_0_0_B_SROA_IDX1:%.*]] = getelementptr inbounds [20 x i8], [20 x i8]* [[A_SROA_0]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[DST:%.*]], i8* align 1 [[A_SROA_0_0_B_SROA_IDX1]], i32 20, i1 false), !tbaa [[TBAA7]]
-; CHECK-NEXT: [[A_SROA_2_SROA_0_0_A_SROA_2_0_DST_SROA_RAW_IDX_SROA_IDX:%.*]] = getelementptr inbounds i8, i8* [[DST]], i64 20
-; CHECK-NEXT: [[A_SROA_2_SROA_0_0_A_SROA_2_0_DST_SROA_RAW_IDX_SROA_CAST:%.*]] = bitcast i8* [[A_SROA_2_SROA_0_0_A_SROA_2_0_DST_SROA_RAW_IDX_SROA_IDX]] to i16*
-; CHECK-NEXT: store i16 [[A_SROA_2_SROA_0_0_COPYLOAD]], i16* [[A_SROA_2_SROA_0_0_A_SROA_2_0_DST_SROA_RAW_IDX_SROA_CAST]], align 1, !tbaa [[TBAA7]]
-; CHECK-NEXT: [[A_SROA_2_SROA_3_0_A_SROA_2_0_DST_SROA_RAW_IDX_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[DST]], i64 22
-; CHECK-NEXT: store i8 [[A_SROA_2_SROA_3_0_COPYLOAD]], i8* [[A_SROA_2_SROA_3_0_A_SROA_2_0_DST_SROA_RAW_IDX_SROA_RAW_IDX]], align 1, !tbaa [[TBAA7]]
-; CHECK-NEXT: [[A_SROA_2_SROA_4_0_A_SROA_2_0_DST_SROA_RAW_IDX_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[DST]], i64 23
-; CHECK-NEXT: [[A_SROA_2_SROA_4_0_B_SROA_IDX22:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_2_SROA_4]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_2_SROA_4_0_A_SROA_2_0_DST_SROA_RAW_IDX_SROA_RAW_IDX]], i8* align 1 [[A_SROA_2_SROA_4_0_B_SROA_IDX22]], i32 7, i1 false), !tbaa [[TBAA7]]
-; CHECK-NEXT: [[A_SROA_3_0_DST_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[DST]], i64 30
-; CHECK-NEXT: [[A_SROA_3_0_B_SROA_IDX3:%.*]] = getelementptr inbounds [10 x i8], [10 x i8]* [[A_SROA_3]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_3_0_DST_SROA_RAW_IDX]], i8* align 1 [[A_SROA_3_0_B_SROA_IDX3]], i32 10, i1 false), !tbaa [[TBAA7]]
-; CHECK-NEXT: [[A_SROA_34_SROA_0_0_A_SROA_34_0_DST_SROA_RAW_IDX_SROA_IDX:%.*]] = getelementptr inbounds i8, i8* [[DST]], i64 40
-; CHECK-NEXT: [[A_SROA_34_SROA_0_0_A_SROA_34_0_DST_SROA_RAW_IDX_SROA_CAST:%.*]] = bitcast i8* [[A_SROA_34_SROA_0_0_A_SROA_34_0_DST_SROA_RAW_IDX_SROA_IDX]] to i16*
-; CHECK-NEXT: store i16 [[A_SROA_6_SROA_0_0_COPYLOAD]], i16* [[A_SROA_34_SROA_0_0_A_SROA_34_0_DST_SROA_RAW_IDX_SROA_CAST]], align 1, !tbaa [[TBAA7]]
-; CHECK-NEXT: [[A_SROA_34_SROA_4_0_A_SROA_34_0_DST_SROA_RAW_IDX_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[DST]], i64 42
-; CHECK-NEXT: store i8 [[A_SROA_6_SROA_3_0_COPYLOAD]], i8* [[A_SROA_34_SROA_4_0_A_SROA_34_0_DST_SROA_RAW_IDX_SROA_RAW_IDX]], align 1, !tbaa [[TBAA7]]
-; CHECK-NEXT: [[A_SROA_34_SROA_5_0_A_SROA_34_0_DST_SROA_RAW_IDX_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[DST]], i64 43
-; CHECK-NEXT: [[A_SROA_34_SROA_5_0_B_SROA_IDX15:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_34_SROA_5]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_34_SROA_5_0_A_SROA_34_0_DST_SROA_RAW_IDX_SROA_RAW_IDX]], i8* align 1 [[A_SROA_34_SROA_5_0_B_SROA_IDX15]], i32 7, i1 false), !tbaa [[TBAA7]]
-; CHECK-NEXT: [[A_SROA_6_SROA_0_0_A_SROA_6_0_DST_SROA_RAW_IDX_SROA_IDX:%.*]] = getelementptr inbounds i8, i8* [[DST]], i64 50
-; CHECK-NEXT: [[A_SROA_6_SROA_0_0_A_SROA_6_0_DST_SROA_RAW_IDX_SROA_CAST:%.*]] = bitcast i8* [[A_SROA_6_SROA_0_0_A_SROA_6_0_DST_SROA_RAW_IDX_SROA_IDX]] to i16*
-; CHECK-NEXT: store i16 [[A_SROA_6_SROA_0_0_COPYLOAD]], i16* [[A_SROA_6_SROA_0_0_A_SROA_6_0_DST_SROA_RAW_IDX_SROA_CAST]], align 1, !tbaa [[TBAA7]]
-; CHECK-NEXT: [[A_SROA_6_SROA_3_0_A_SROA_6_0_DST_SROA_RAW_IDX_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[DST]], i64 52
-; CHECK-NEXT: store i8 [[A_SROA_6_SROA_3_0_COPYLOAD]], i8* [[A_SROA_6_SROA_3_0_A_SROA_6_0_DST_SROA_RAW_IDX_SROA_RAW_IDX]], align 1, !tbaa [[TBAA7]]
-; CHECK-NEXT: [[A_SROA_6_SROA_4_0_A_SROA_6_0_DST_SROA_RAW_IDX_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[DST]], i64 53
-; CHECK-NEXT: [[A_SROA_6_SROA_4_0_B_SROA_IDX19:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_6_SROA_4]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_6_SROA_4_0_A_SROA_6_0_DST_SROA_RAW_IDX_SROA_RAW_IDX]], i8* align 1 [[A_SROA_6_SROA_4_0_B_SROA_IDX19]], i32 7, i1 false), !tbaa [[TBAA7]]
-; CHECK-NEXT: [[A_SROA_7_0_DST_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[DST]], i64 60
-; CHECK-NEXT: [[A_SROA_7_0_B_SROA_IDX8:%.*]] = getelementptr inbounds [40 x i8], [40 x i8]* [[A_SROA_7]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_7_0_DST_SROA_RAW_IDX]], i8* align 1 [[A_SROA_7_0_B_SROA_IDX8]], i32 40, i1 false), !tbaa [[TBAA7]]
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_0]], ptr align 1 [[SRC:%.*]], i32 20, i1 false), !tbaa [[TBAA0]]
+; CHECK-NEXT: [[A_SROA_2_0_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 20
+; CHECK-NEXT: [[A_SROA_2_SROA_0_0_COPYLOAD:%.*]] = load i16, ptr [[A_SROA_2_0_SRC_SROA_IDX]], align 1, !tbaa [[TBAA0]]
+; CHECK-NEXT: [[A_SROA_2_SROA_3_0_A_SROA_2_0_SRC_SROA_IDX_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_2_0_SRC_SROA_IDX]], i64 2
+; CHECK-NEXT: [[A_SROA_2_SROA_3_0_COPYLOAD:%.*]] = load i8, ptr [[A_SROA_2_SROA_3_0_A_SROA_2_0_SRC_SROA_IDX_SROA_IDX]], align 1, !tbaa [[TBAA0]]
+; CHECK-NEXT: [[A_SROA_2_SROA_4_0_A_SROA_2_0_SRC_SROA_IDX_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_2_0_SRC_SROA_IDX]], i64 3
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_2_SROA_4]], ptr align 1 [[A_SROA_2_SROA_4_0_A_SROA_2_0_SRC_SROA_IDX_SROA_IDX]], i32 7, i1 false), !tbaa [[TBAA0]]
+; CHECK-NEXT: [[A_SROA_3_0_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 30
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_3]], ptr align 1 [[A_SROA_3_0_SRC_SROA_IDX]], i32 10, i1 false), !tbaa [[TBAA0]]
+; CHECK-NEXT: [[A_SROA_31_0_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 40
+; CHECK-NEXT: [[A_SROA_31_SROA_0_0_COPYLOAD:%.*]] = load i16, ptr [[A_SROA_31_0_SRC_SROA_IDX]], align 1, !tbaa [[TBAA0]]
+; CHECK-NEXT: [[A_SROA_31_SROA_4_0_A_SROA_31_0_SRC_SROA_IDX_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_31_0_SRC_SROA_IDX]], i64 2
+; CHECK-NEXT: [[A_SROA_31_SROA_4_0_COPYLOAD:%.*]] = load i8, ptr [[A_SROA_31_SROA_4_0_A_SROA_31_0_SRC_SROA_IDX_SROA_IDX]], align 1, !tbaa [[TBAA0]]
+; CHECK-NEXT: [[A_SROA_31_SROA_5_0_A_SROA_31_0_SRC_SROA_IDX_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_31_0_SRC_SROA_IDX]], i64 3
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_31_SROA_5]], ptr align 1 [[A_SROA_31_SROA_5_0_A_SROA_31_0_SRC_SROA_IDX_SROA_IDX]], i32 7, i1 false), !tbaa [[TBAA0]]
+; CHECK-NEXT: [[A_SROA_6_0_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 50
+; CHECK-NEXT: [[A_SROA_6_SROA_0_0_COPYLOAD:%.*]] = load i16, ptr [[A_SROA_6_0_SRC_SROA_IDX]], align 1, !tbaa [[TBAA0]]
+; CHECK-NEXT: [[A_SROA_6_SROA_3_0_A_SROA_6_0_SRC_SROA_IDX_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_6_0_SRC_SROA_IDX]], i64 2
+; CHECK-NEXT: [[A_SROA_6_SROA_3_0_COPYLOAD:%.*]] = load i8, ptr [[A_SROA_6_SROA_3_0_A_SROA_6_0_SRC_SROA_IDX_SROA_IDX]], align 1, !tbaa [[TBAA0]]
+; CHECK-NEXT: [[A_SROA_6_SROA_4_0_A_SROA_6_0_SRC_SROA_IDX_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_6_0_SRC_SROA_IDX]], i64 3
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_6_SROA_4]], ptr align 1 [[A_SROA_6_SROA_4_0_A_SROA_6_0_SRC_SROA_IDX_SROA_IDX]], i32 7, i1 false), !tbaa [[TBAA0]]
+; CHECK-NEXT: [[A_SROA_7_0_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 60
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_7]], ptr align 1 [[A_SROA_7_0_SRC_SROA_IDX]], i32 40, i1 false), !tbaa [[TBAA0]]
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_31_SROA_5]], ptr align 1 [[A_SROA_2_SROA_4]], i32 7, i1 false), !tbaa [[TBAA3]]
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_31_SROA_5]], ptr align 1 [[A_SROA_6_SROA_4]], i32 7, i1 false), !tbaa [[TBAA5]]
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[DST:%.*]], ptr align 1 [[A_SROA_0]], i32 20, i1 false), !tbaa [[TBAA7]]
+; CHECK-NEXT: [[A_SROA_2_0_DST_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 20
+; CHECK-NEXT: store i16 [[A_SROA_2_SROA_0_0_COPYLOAD]], ptr [[A_SROA_2_0_DST_SROA_IDX]], align 1, !tbaa [[TBAA7]]
+; CHECK-NEXT: [[A_SROA_2_SROA_3_0_A_SROA_2_0_DST_SROA_IDX_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_2_0_DST_SROA_IDX]], i64 2
+; CHECK-NEXT: store i8 [[A_SROA_2_SROA_3_0_COPYLOAD]], ptr [[A_SROA_2_SROA_3_0_A_SROA_2_0_DST_SROA_IDX_SROA_IDX]], align 1, !tbaa [[TBAA7]]
+; CHECK-NEXT: [[A_SROA_2_SROA_4_0_A_SROA_2_0_DST_SROA_IDX_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_2_0_DST_SROA_IDX]], i64 3
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_2_SROA_4_0_A_SROA_2_0_DST_SROA_IDX_SROA_IDX]], ptr align 1 [[A_SROA_2_SROA_4]], i32 7, i1 false), !tbaa [[TBAA7]]
+; CHECK-NEXT: [[A_SROA_3_0_DST_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 30
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_3_0_DST_SROA_IDX]], ptr align 1 [[A_SROA_3]], i32 10, i1 false), !tbaa [[TBAA7]]
+; CHECK-NEXT: [[A_SROA_31_0_DST_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 40
+; CHECK-NEXT: store i16 [[A_SROA_6_SROA_0_0_COPYLOAD]], ptr [[A_SROA_31_0_DST_SROA_IDX]], align 1, !tbaa [[TBAA7]]
+; CHECK-NEXT: [[A_SROA_31_SROA_4_0_A_SROA_31_0_DST_SROA_IDX_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_31_0_DST_SROA_IDX]], i64 2
+; CHECK-NEXT: store i8 [[A_SROA_6_SROA_3_0_COPYLOAD]], ptr [[A_SROA_31_SROA_4_0_A_SROA_31_0_DST_SROA_IDX_SROA_IDX]], align 1, !tbaa [[TBAA7]]
+; CHECK-NEXT: [[A_SROA_31_SROA_5_0_A_SROA_31_0_DST_SROA_IDX_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_31_0_DST_SROA_IDX]], i64 3
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_31_SROA_5_0_A_SROA_31_0_DST_SROA_IDX_SROA_IDX]], ptr align 1 [[A_SROA_31_SROA_5]], i32 7, i1 false), !tbaa [[TBAA7]]
+; CHECK-NEXT: [[A_SROA_6_0_DST_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 50
+; CHECK-NEXT: store i16 [[A_SROA_6_SROA_0_0_COPYLOAD]], ptr [[A_SROA_6_0_DST_SROA_IDX]], align 1, !tbaa [[TBAA7]]
+; CHECK-NEXT: [[A_SROA_6_SROA_3_0_A_SROA_6_0_DST_SROA_IDX_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_6_0_DST_SROA_IDX]], i64 2
+; CHECK-NEXT: store i8 [[A_SROA_6_SROA_3_0_COPYLOAD]], ptr [[A_SROA_6_SROA_3_0_A_SROA_6_0_DST_SROA_IDX_SROA_IDX]], align 1, !tbaa [[TBAA7]]
+; CHECK-NEXT: [[A_SROA_6_SROA_4_0_A_SROA_6_0_DST_SROA_IDX_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_6_0_DST_SROA_IDX]], i64 3
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_6_SROA_4_0_A_SROA_6_0_DST_SROA_IDX_SROA_IDX]], ptr align 1 [[A_SROA_6_SROA_4]], i32 7, i1 false), !tbaa [[TBAA7]]
+; CHECK-NEXT: [[A_SROA_7_0_DST_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 60
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_7_0_DST_SROA_IDX]], ptr align 1 [[A_SROA_7]], i32 40, i1 false), !tbaa [[TBAA7]]
; CHECK-NEXT: ret void
;
entry:
%a = alloca [100 x i8]
- %b = getelementptr [100 x i8], [100 x i8]* %a, i64 0, i64 0
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %b, i8* %src, i32 100, i1 false), !tbaa !0
+ call void @llvm.memcpy.p0.p0.i32(ptr %a, ptr %src, i32 100, i1 false), !tbaa !0
- %a.src.1 = getelementptr [100 x i8], [100 x i8]* %a, i64 0, i64 20
- %a.dst.1 = getelementptr [100 x i8], [100 x i8]* %a, i64 0, i64 40
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %a.dst.1, i8* %a.src.1, i32 10, i1 false), !tbaa !3
+ %a.src.1 = getelementptr [100 x i8], ptr %a, i64 0, i64 20
+ %a.dst.1 = getelementptr [100 x i8], ptr %a, i64 0, i64 40
+ call void @llvm.memcpy.p0.p0.i32(ptr %a.dst.1, ptr %a.src.1, i32 10, i1 false), !tbaa !3
; Clobber a single element of the array, this should be promotable, and be deleted.
- %c = getelementptr [100 x i8], [100 x i8]* %a, i64 0, i64 42
- store i8 0, i8* %c
+ %c = getelementptr [100 x i8], ptr %a, i64 0, i64 42
+ store i8 0, ptr %c
- %a.src.2 = getelementptr [100 x i8], [100 x i8]* %a, i64 0, i64 50
- call void @llvm.memmove.p0i8.p0i8.i32(i8* %a.dst.1, i8* %a.src.2, i32 10, i1 false), !tbaa !5
+ %a.src.2 = getelementptr [100 x i8], ptr %a, i64 0, i64 50
+ call void @llvm.memmove.p0.p0.i32(ptr %a.dst.1, ptr %a.src.2, i32 10, i1 false), !tbaa !5
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %b, i32 100, i1 false), !tbaa !7
+ call void @llvm.memcpy.p0.p0.i32(ptr %dst, ptr %a, i32 100, i1 false), !tbaa !7
ret void
}
-declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i1) nounwind
-declare void @llvm.memcpy.p1i8.p0i8.i32(i8 addrspace(1)* nocapture, i8* nocapture, i32, i1) nounwind
-declare void @llvm.memmove.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i1) nounwind
-declare void @llvm.memset.p0i8.i32(i8* nocapture, i8, i32, i1) nounwind
+declare void @llvm.memcpy.p0.p0.i32(ptr nocapture, ptr nocapture, i32, i1) nounwind
+declare void @llvm.memcpy.p1.p0.i32(ptr addrspace(1) nocapture, ptr nocapture, i32, i1) nounwind
+declare void @llvm.memmove.p0.p0.i32(ptr nocapture, ptr nocapture, i32, i1) nounwind
+declare void @llvm.memset.p0.i32(ptr nocapture, i8, i32, i1) nounwind
define i16 @test5() {
; CHECK-LABEL: @test5(
@@ -500,11 +409,9 @@ define i16 @test5() {
entry:
%a = alloca [4 x i8]
- %fptr = bitcast [4 x i8]* %a to float*
- store float 0.0, float* %fptr
- %ptr = getelementptr [4 x i8], [4 x i8]* %a, i32 0, i32 2
- %iptr = bitcast i8* %ptr to i16*
- %val = load i16, i16* %iptr
+ store float 0.0, ptr %a
+ %ptr = getelementptr [4 x i8], ptr %a, i32 0, i32 2
+ %val = load i16, ptr %ptr
ret i16 %val
}
@@ -519,12 +426,10 @@ define i16 @test5_multi_addrspace_access() {
entry:
%a = alloca [4 x i8]
- %fptr = bitcast [4 x i8]* %a to float*
- %fptr.as1 = addrspacecast float* %fptr to float addrspace(1)*
- store float 0.0, float addrspace(1)* %fptr.as1
- %ptr = getelementptr [4 x i8], [4 x i8]* %a, i32 0, i32 2
- %iptr = bitcast i8* %ptr to i16*
- %val = load i16, i16* %iptr
+ %fptr.as1 = addrspacecast ptr %a to ptr addrspace(1)
+ store float 0.0, ptr addrspace(1) %fptr.as1
+ %ptr = getelementptr [4 x i8], ptr %a, i32 0, i32 2
+ %val = load i16, ptr %ptr
ret i16 %val
}
@@ -532,77 +437,69 @@ define i32 @test6() {
; CHECK-LABEL: @test6(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A_SROA_0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store volatile i32 707406378, i32* [[A_SROA_0]], align 4
-; CHECK-NEXT: [[A_SROA_0_0_A_SROA_0_0_VAL:%.*]] = load i32, i32* [[A_SROA_0]], align 4
+; CHECK-NEXT: store volatile i32 707406378, ptr [[A_SROA_0]], align 4
+; CHECK-NEXT: [[A_SROA_0_0_A_SROA_0_0_VAL:%.*]] = load i32, ptr [[A_SROA_0]], align 4
; CHECK-NEXT: ret i32 [[A_SROA_0_0_A_SROA_0_0_VAL]]
;
entry:
%a = alloca [4 x i8]
- %ptr = getelementptr [4 x i8], [4 x i8]* %a, i32 0, i32 0
- call void @llvm.memset.p0i8.i32(i8* %ptr, i8 42, i32 4, i1 true)
- %iptr = bitcast i8* %ptr to i32*
- %val = load i32, i32* %iptr
+ call void @llvm.memset.p0.i32(ptr %a, i8 42, i32 4, i1 true)
+ %val = load i32, ptr %a
ret i32 %val
}
-define void @test7(i8* %src, i8* %dst) {
+define void @test7(ptr %src, ptr %dst) {
; CHECK-LABEL: @test7(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A_SROA_0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[A_SROA_0_0_SRC_SROA_CAST:%.*]] = bitcast i8* [[SRC:%.*]] to i32*
-; CHECK-NEXT: [[A_SROA_0_0_COPYLOAD:%.*]] = load volatile i32, i32* [[A_SROA_0_0_SRC_SROA_CAST]], align 1, !tbaa [[TBAA0]]
-; CHECK-NEXT: store volatile i32 [[A_SROA_0_0_COPYLOAD]], i32* [[A_SROA_0]], align 4, !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_0_0_DST_SROA_CAST:%.*]] = bitcast i8* [[DST:%.*]] to i32*
-; CHECK-NEXT: [[A_SROA_0_0_A_SROA_0_0_COPYLOAD1:%.*]] = load volatile i32, i32* [[A_SROA_0]], align 4, !tbaa [[TBAA3]]
-; CHECK-NEXT: store volatile i32 [[A_SROA_0_0_A_SROA_0_0_COPYLOAD1]], i32* [[A_SROA_0_0_DST_SROA_CAST]], align 1, !tbaa [[TBAA3]]
+; CHECK-NEXT: [[A_SROA_0_0_COPYLOAD:%.*]] = load volatile i32, ptr [[SRC:%.*]], align 1, !tbaa [[TBAA0]]
+; CHECK-NEXT: store volatile i32 [[A_SROA_0_0_COPYLOAD]], ptr [[A_SROA_0]], align 4, !tbaa [[TBAA0]]
+; CHECK-NEXT: [[A_SROA_0_0_A_SROA_0_0_COPYLOAD1:%.*]] = load volatile i32, ptr [[A_SROA_0]], align 4, !tbaa [[TBAA3]]
+; CHECK-NEXT: store volatile i32 [[A_SROA_0_0_A_SROA_0_0_COPYLOAD1]], ptr [[DST:%.*]], align 1, !tbaa [[TBAA3]]
; CHECK-NEXT: ret void
;
entry:
%a = alloca [4 x i8]
- %ptr = getelementptr [4 x i8], [4 x i8]* %a, i32 0, i32 0
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %ptr, i8* %src, i32 4, i1 true), !tbaa !0
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %ptr, i32 4, i1 true), !tbaa !3
+ call void @llvm.memcpy.p0.p0.i32(ptr %a, ptr %src, i32 4, i1 true), !tbaa !0
+ call void @llvm.memcpy.p0.p0.i32(ptr %dst, ptr %a, i32 4, i1 true), !tbaa !3
ret void
}
%S1 = type { i32, i32, [16 x i8] }
-%S2 = type { %S1*, %S2* }
+%S2 = type { ptr, ptr }
-define %S2 @test8(%S2* %arg) {
+define %S2 @test8(ptr %arg) {
; CHECK-LABEL: @test8(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[S2_NEXT_PTR:%.*]] = getelementptr [[S2:%.*]], %S2* [[ARG:%.*]], i64 0, i32 1
-; CHECK-NEXT: [[S2_NEXT:%.*]] = load %S2*, %S2** [[S2_NEXT_PTR]], align 8, !tbaa [[TBAA0]]
-; CHECK-NEXT: [[S2_NEXT_S1_PTR:%.*]] = getelementptr [[S2]], %S2* [[S2_NEXT]], i64 0, i32 0
-; CHECK-NEXT: [[S2_NEXT_S1:%.*]] = load %S1*, %S1** [[S2_NEXT_S1_PTR]], align 8, !tbaa [[TBAA3]]
-; CHECK-NEXT: [[S2_NEXT_NEXT_PTR:%.*]] = getelementptr [[S2]], %S2* [[S2_NEXT]], i64 0, i32 1
-; CHECK-NEXT: [[S2_NEXT_NEXT:%.*]] = load %S2*, %S2** [[S2_NEXT_NEXT_PTR]], align 8, !tbaa [[TBAA7]]
-; CHECK-NEXT: [[RESULT1:%.*]] = insertvalue [[S2]] poison, %S1* [[S2_NEXT_S1]], 0
-; CHECK-NEXT: [[RESULT2:%.*]] = insertvalue [[S2]] [[RESULT1]], %S2* [[S2_NEXT_NEXT]], 1
+; CHECK-NEXT: [[S2_NEXT_PTR:%.*]] = getelementptr [[S2:%.*]], ptr [[ARG:%.*]], i64 0, i32 1
+; CHECK-NEXT: [[S2_NEXT:%.*]] = load ptr, ptr [[S2_NEXT_PTR]], align 8, !tbaa [[TBAA0]]
+; CHECK-NEXT: [[S2_NEXT_S1:%.*]] = load ptr, ptr [[S2_NEXT]], align 8, !tbaa [[TBAA3]]
+; CHECK-NEXT: [[S2_NEXT_NEXT_PTR:%.*]] = getelementptr [[S2]], ptr [[S2_NEXT]], i64 0, i32 1
+; CHECK-NEXT: [[S2_NEXT_NEXT:%.*]] = load ptr, ptr [[S2_NEXT_NEXT_PTR]], align 8, !tbaa [[TBAA7]]
+; CHECK-NEXT: [[RESULT1:%.*]] = insertvalue [[S2]] poison, ptr [[S2_NEXT_S1]], 0
+; CHECK-NEXT: [[RESULT2:%.*]] = insertvalue [[S2]] [[RESULT1]], ptr [[S2_NEXT_NEXT]], 1
; CHECK-NEXT: ret [[S2]] [[RESULT2]]
;
entry:
%new = alloca %S2
- %s2.next.ptr = getelementptr %S2, %S2* %arg, i64 0, i32 1
- %s2.next = load %S2*, %S2** %s2.next.ptr, !tbaa !0
-
- %s2.next.s1.ptr = getelementptr %S2, %S2* %s2.next, i64 0, i32 0
- %s2.next.s1 = load %S1*, %S1** %s2.next.s1.ptr, !tbaa !3
- %new.s1.ptr = getelementptr %S2, %S2* %new, i64 0, i32 0
- store %S1* %s2.next.s1, %S1** %new.s1.ptr, !tbaa !5
- %s2.next.next.ptr = getelementptr %S2, %S2* %s2.next, i64 0, i32 1
- %s2.next.next = load %S2*, %S2** %s2.next.next.ptr, !tbaa !7
- %new.next.ptr = getelementptr %S2, %S2* %new, i64 0, i32 1
- store %S2* %s2.next.next, %S2** %new.next.ptr, !tbaa !9
-
- %new.s1 = load %S1*, %S1** %new.s1.ptr
- %result1 = insertvalue %S2 poison, %S1* %new.s1, 0
- %new.next = load %S2*, %S2** %new.next.ptr
- %result2 = insertvalue %S2 %result1, %S2* %new.next, 1
+ %s2.next.ptr = getelementptr %S2, ptr %arg, i64 0, i32 1
+ %s2.next = load ptr, ptr %s2.next.ptr, !tbaa !0
+
+ %s2.next.s1 = load ptr, ptr %s2.next, !tbaa !3
+ store ptr %s2.next.s1, ptr %new, !tbaa !5
+ %s2.next.next.ptr = getelementptr %S2, ptr %s2.next, i64 0, i32 1
+ %s2.next.next = load ptr, ptr %s2.next.next.ptr, !tbaa !7
+ %new.next.ptr = getelementptr %S2, ptr %new, i64 0, i32 1
+ store ptr %s2.next.next, ptr %new.next.ptr, !tbaa !9
+
+ %new.s1 = load ptr, ptr %new
+ %result1 = insertvalue %S2 poison, ptr %new.s1, 0
+ %new.next = load ptr, ptr %new.next.ptr
+ %result2 = insertvalue %S2 %result1, ptr %new.next, 1
ret %S2 %result2
}
@@ -630,33 +527,28 @@ define i64 @test9() {
entry:
%a = alloca { [3 x i8] }, align 8
- %gep1 = getelementptr inbounds { [3 x i8] }, { [3 x i8] }* %a, i32 0, i32 0, i32 0
- store i8 0, i8* %gep1, align 1
- %gep2 = getelementptr inbounds { [3 x i8] }, { [3 x i8] }* %a, i32 0, i32 0, i32 1
- store i8 0, i8* %gep2, align 1
- %gep3 = getelementptr inbounds { [3 x i8] }, { [3 x i8] }* %a, i32 0, i32 0, i32 2
- store i8 26, i8* %gep3, align 1
- %cast = bitcast { [3 x i8] }* %a to { i64 }*
- %elt = getelementptr inbounds { i64 }, { i64 }* %cast, i32 0, i32 0
- %load = load i64, i64* %elt
+ store i8 0, ptr %a, align 1
+ %gep2 = getelementptr inbounds { [3 x i8] }, ptr %a, i32 0, i32 0, i32 1
+ store i8 0, ptr %gep2, align 1
+ %gep3 = getelementptr inbounds { [3 x i8] }, ptr %a, i32 0, i32 0, i32 2
+ store i8 26, ptr %gep3, align 1
+ %load = load i64, ptr %a
%result = and i64 %load, 16777215
ret i64 %result
}
-define %S2* @test10() {
+define ptr @test10() {
; CHECK-LABEL: @test10(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[TMP0:%.*]] = ptrtoint %S2* null to i64
-; CHECK-NEXT: ret %S2* null
+; CHECK-NEXT: [[TMP0:%.*]] = ptrtoint ptr null to i64
+; CHECK-NEXT: ret ptr null
;
entry:
%a = alloca [8 x i8]
- %ptr = getelementptr [8 x i8], [8 x i8]* %a, i32 0, i32 0
- call void @llvm.memset.p0i8.i32(i8* %ptr, i8 0, i32 8, i1 false)
- %s2ptrptr = bitcast i8* %ptr to %S2**
- %s2ptr = load %S2*, %S2** %s2ptrptr
- ret %S2* %s2ptr
+ call void @llvm.memset.p0.i32(ptr %a, i8 0, i32 8, i1 false)
+ %s2ptr = load ptr, ptr %a
+ ret ptr %s2ptr
}
define i32 @test11(i1 %c1) {
@@ -674,15 +566,14 @@ entry:
br i1 %c1, label %good, label %bad
good:
- %Y = getelementptr i32, i32* %X, i64 0
- store i32 0, i32* %Y
- %Z = load i32, i32* %Y
+ store i32 0, ptr %X
+ %Z = load i32, ptr %X
ret i32 %Z
bad:
- %Y2 = getelementptr i32, i32* %X, i64 1
- store i32 0, i32* %Y2
- %Z2 = load i32, i32* %Y2
+ %Y2 = getelementptr i32, ptr %X, i64 1
+ store i32 0, ptr %Y2
+ %Z2 = load i32, ptr %Y2
ret i32 %Z2
}
@@ -717,23 +608,19 @@ entry:
%a = alloca [3 x i8]
%b = alloca [3 x i8]
- %a0ptr = getelementptr [3 x i8], [3 x i8]* %a, i64 0, i32 0
- store i8 0, i8* %a0ptr
- %a1ptr = getelementptr [3 x i8], [3 x i8]* %a, i64 0, i32 1
- store i8 0, i8* %a1ptr
- %a2ptr = getelementptr [3 x i8], [3 x i8]* %a, i64 0, i32 2
- store i8 0, i8* %a2ptr
- %aiptr = bitcast [3 x i8]* %a to i24*
- %ai = load i24, i24* %aiptr
-
- %biptr = bitcast [3 x i8]* %b to i24*
- store i24 %ai, i24* %biptr
- %b0ptr = getelementptr [3 x i8], [3 x i8]* %b, i64 0, i32 0
- %b0 = load i8, i8* %b0ptr
- %b1ptr = getelementptr [3 x i8], [3 x i8]* %b, i64 0, i32 1
- %b1 = load i8, i8* %b1ptr
- %b2ptr = getelementptr [3 x i8], [3 x i8]* %b, i64 0, i32 2
- %b2 = load i8, i8* %b2ptr
+ store i8 0, ptr %a
+ %a1ptr = getelementptr [3 x i8], ptr %a, i64 0, i32 1
+ store i8 0, ptr %a1ptr
+ %a2ptr = getelementptr [3 x i8], ptr %a, i64 0, i32 2
+ store i8 0, ptr %a2ptr
+ %ai = load i24, ptr %a
+
+ store i24 %ai, ptr %b
+ %b0 = load i8, ptr %b
+ %b1ptr = getelementptr [3 x i8], ptr %b, i64 0, i32 1
+ %b1 = load i8, ptr %b1ptr
+ %b2ptr = getelementptr [3 x i8], ptr %b, i64 0, i32 2
+ %b2 = load i8, ptr %b2ptr
%bsum0 = add i8 %b0, %b1
%bsum1 = add i8 %bsum0, %b2
@@ -752,15 +639,13 @@ define i32 @test13() {
entry:
%a = alloca [3 x i8], align 2
- %b0ptr = getelementptr [3 x i8], [3 x i8]* %a, i64 0, i32 0
- store i8 0, i8* %b0ptr
- %b1ptr = getelementptr [3 x i8], [3 x i8]* %a, i64 0, i32 1
- store i8 0, i8* %b1ptr
- %b2ptr = getelementptr [3 x i8], [3 x i8]* %a, i64 0, i32 2
- store i8 0, i8* %b2ptr
- %iptrcast = bitcast [3 x i8]* %a to i16*
- %iptrgep = getelementptr i16, i16* %iptrcast, i64 1
- %i = load i16, i16* %iptrgep
+ store i8 0, ptr %a
+ %b1ptr = getelementptr [3 x i8], ptr %a, i64 0, i32 1
+ store i8 0, ptr %b1ptr
+ %b2ptr = getelementptr [3 x i8], ptr %a, i64 0, i32 2
+ store i8 0, ptr %b2ptr
+ %iptrgep = getelementptr i16, ptr %a, i64 1
+ %i = load i16, ptr %iptrgep
%ret = zext i16 %i to i32
ret i32 %ret
}
@@ -779,24 +664,24 @@ define void @test14(...) nounwind uwtable {
entry:
%a = alloca %test14.struct
- %p = alloca %test14.struct*
- %0 = bitcast %test14.struct* %a to i8*
- %1 = getelementptr i8, i8* %0, i64 12
- %2 = bitcast i8* %1 to %test14.struct*
- %3 = getelementptr inbounds %test14.struct, %test14.struct* %2, i32 0, i32 0
- %4 = getelementptr inbounds %test14.struct, %test14.struct* %a, i32 0, i32 0
- %5 = bitcast [3 x i32]* %3 to i32*
- %6 = bitcast [3 x i32]* %4 to i32*
- %7 = load i32, i32* %6, align 4
- store i32 %7, i32* %5, align 4
- %8 = getelementptr inbounds i32, i32* %5, i32 1
- %9 = getelementptr inbounds i32, i32* %6, i32 1
- %10 = load i32, i32* %9, align 4
- store i32 %10, i32* %8, align 4
- %11 = getelementptr inbounds i32, i32* %5, i32 2
- %12 = getelementptr inbounds i32, i32* %6, i32 2
- %13 = load i32, i32* %12, align 4
- store i32 %13, i32* %11, align 4
+ %p = alloca ptr
+ %0 = bitcast ptr %a to ptr
+ %1 = getelementptr i8, ptr %0, i64 12
+ %2 = bitcast ptr %1 to ptr
+ %3 = getelementptr inbounds %test14.struct, ptr %2, i32 0, i32 0
+ %4 = getelementptr inbounds %test14.struct, ptr %a, i32 0, i32 0
+ %5 = bitcast ptr %3 to ptr
+ %6 = bitcast ptr %4 to ptr
+ %7 = load i32, ptr %6, align 4
+ store i32 %7, ptr %5, align 4
+ %8 = getelementptr inbounds i32, ptr %5, i32 1
+ %9 = getelementptr inbounds i32, ptr %6, i32 1
+ %10 = load i32, ptr %9, align 4
+ store i32 %10, ptr %8, align 4
+ %11 = getelementptr inbounds i32, ptr %5, i32 2
+ %12 = getelementptr inbounds i32, ptr %6, i32 2
+ %13 = load i32, ptr %12, align 4
+ store i32 %13, ptr %11, align 4
ret void
}
@@ -819,167 +704,139 @@ entry:
br label %loop
loop:
- %dead3 = phi i8* [ %gep3, %loop ], [ null, %entry ]
-
- store i64 1879048192, i64* %l0, align 8
- %bc0 = bitcast i64* %l0 to i8*
- %gep0 = getelementptr i8, i8* %bc0, i64 3
- %dead0 = bitcast i8* %gep0 to i64*
-
- store i64 1879048192, i64* %l1, align 8
- %bc1 = bitcast i64* %l1 to i8*
- %gep1 = getelementptr i8, i8* %bc1, i64 3
- %dead1 = getelementptr i8, i8* %gep1, i64 1
-
- store i64 1879048192, i64* %l2, align 8
- %bc2 = bitcast i64* %l2 to i8*
- %gep2.1 = getelementptr i8, i8* %bc2, i64 1
- %gep2.2 = getelementptr i8, i8* %bc2, i64 3
+ %dead3 = phi ptr [ %gep3, %loop ], [ null, %entry ]
+
+ store i64 1879048192, ptr %l0, align 8
+ %gep0 = getelementptr i8, ptr %l0, i64 3
+
+ store i64 1879048192, ptr %l1, align 8
+ %gep1 = getelementptr i8, ptr %l1, i64 3
+ %dead1 = getelementptr i8, ptr %gep1, i64 1
+
+ store i64 1879048192, ptr %l2, align 8
+ %gep2.1 = getelementptr i8, ptr %l2, i64 1
+ %gep2.2 = getelementptr i8, ptr %l2, i64 3
; Note that this select should get visited multiple times due to using two
;
diff erent GEPs off the same alloca. We should only delete it once.
- %dead2 = select i1 %flag, i8* %gep2.1, i8* %gep2.2
+ %dead2 = select i1 %flag, ptr %gep2.1, ptr %gep2.2
- store i64 1879048192, i64* %l3, align 8
- %bc3 = bitcast i64* %l3 to i8*
- %gep3 = getelementptr i8, i8* %bc3, i64 3
+ store i64 1879048192, ptr %l3, align 8
+ %gep3 = getelementptr i8, ptr %l3, i64 3
br label %loop
}
-define void @test16(i8* %src, i8* %dst) {
+define void @test16(ptr %src, ptr %dst) {
; Ensure that we can promote an alloca of [3 x i8] to an i24 SSA value.
; CHECK-LABEL: @test16(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[A_SROA_0_0_SRC_SROA_CAST:%.*]] = bitcast i8* [[SRC:%.*]] to i24*
-; CHECK-NEXT: [[A_SROA_0_0_COPYLOAD:%.*]] = load i24, i24* [[A_SROA_0_0_SRC_SROA_CAST]], align 1, !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_0_0_DST_SROA_CAST:%.*]] = bitcast i8* [[DST:%.*]] to i24*
-; CHECK-NEXT: store i24 0, i24* [[A_SROA_0_0_DST_SROA_CAST]], align 1, !tbaa [[TBAA5]]
+; CHECK-NEXT: [[A_SROA_0_0_COPYLOAD:%.*]] = load i24, ptr [[SRC:%.*]], align 1, !tbaa [[TBAA0]]
+; CHECK-NEXT: store i24 0, ptr [[DST:%.*]], align 1, !tbaa [[TBAA5]]
; CHECK-NEXT: ret void
;
entry:
%a = alloca [3 x i8]
- %ptr = getelementptr [3 x i8], [3 x i8]* %a, i32 0, i32 0
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %ptr, i8* %src, i32 4, i1 false), !tbaa !0
- %cast = bitcast i8* %ptr to i24*
- store i24 0, i24* %cast, !tbaa !3
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %ptr, i32 4, i1 false), !tbaa !5
+ call void @llvm.memcpy.p0.p0.i32(ptr %a, ptr %src, i32 4, i1 false), !tbaa !0
+ store i24 0, ptr %a, !tbaa !3
+ call void @llvm.memcpy.p0.p0.i32(ptr %dst, ptr %a, i32 4, i1 false), !tbaa !5
ret void
}
-define void @test17(i8* %src, i8* %dst) {
+define void @test17(ptr %src, ptr %dst) {
; Ensure that we can rewrite unpromotable memcpys which extend past the end of
; the alloca.
; CHECK-LABEL: @test17(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca [3 x i8], align 1
-; CHECK-NEXT: [[PTR:%.*]] = getelementptr [3 x i8], [3 x i8]* [[A]], i32 0, i32 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* [[PTR]], i8* [[SRC:%.*]], i32 4, i1 true), !tbaa [[TBAA0]]
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* [[DST:%.*]], i8* [[PTR]], i32 4, i1 true), !tbaa [[TBAA3]]
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr [[A]], ptr [[SRC:%.*]], i32 4, i1 true), !tbaa [[TBAA0]]
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr [[DST:%.*]], ptr [[A]], i32 4, i1 true), !tbaa [[TBAA3]]
; CHECK-NEXT: ret void
;
entry:
%a = alloca [3 x i8]
- %ptr = getelementptr [3 x i8], [3 x i8]* %a, i32 0, i32 0
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %ptr, i8* %src, i32 4, i1 true), !tbaa !0
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %ptr, i32 4, i1 true), !tbaa !3
+ call void @llvm.memcpy.p0.p0.i32(ptr %a, ptr %src, i32 4, i1 true), !tbaa !0
+ call void @llvm.memcpy.p0.p0.i32(ptr %dst, ptr %a, i32 4, i1 true), !tbaa !3
ret void
}
-define void @test18(i8* %src, i8* %dst, i32 %size) {
+define void @test18(ptr %src, ptr %dst, i32 %size) {
; Preserve transfer intrinsics with a variable size, even if they overlap with
; fixed size operations. Further, continue to split and promote allocas preceding
; the variable sized intrinsic.
; CHECK-LABEL: @test18(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A_SROA_33:%.*]] = alloca [34 x i8], align 1
-; CHECK-NEXT: [[A_SROA_0_0_SRC_SROA_CAST:%.*]] = bitcast i8* [[SRC:%.*]] to i32*
-; CHECK-NEXT: [[A_SROA_0_0_COPYLOAD:%.*]] = load i32, i32* [[A_SROA_0_0_SRC_SROA_CAST]], align 1, !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_3_0_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i64 4
-; CHECK-NEXT: [[A_SROA_3_0_SRC_SROA_CAST:%.*]] = bitcast i8* [[A_SROA_3_0_SRC_SROA_IDX]] to i32*
-; CHECK-NEXT: [[A_SROA_3_0_COPYLOAD:%.*]] = load i32, i32* [[A_SROA_3_0_SRC_SROA_CAST]], align 1, !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_SROA_33_0_PTR2_SROA_IDX:%.*]] = getelementptr inbounds [34 x i8], [34 x i8]* [[A_SROA_33]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_33_0_PTR2_SROA_IDX]], i8* [[SRC]], i32 [[SIZE:%.*]], i1 false), !tbaa [[TBAA3]]
-; CHECK-NEXT: [[A_SROA_33_0_PTR2_SROA_IDX6:%.*]] = getelementptr inbounds [34 x i8], [34 x i8]* [[A_SROA_33]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memset.p0i8.i32(i8* align 1 [[A_SROA_33_0_PTR2_SROA_IDX6]], i8 42, i32 [[SIZE]], i1 false), !tbaa [[TBAA5]]
-; CHECK-NEXT: [[A_SROA_0_0_DST_SROA_CAST:%.*]] = bitcast i8* [[DST:%.*]] to i32*
-; CHECK-NEXT: store i32 42, i32* [[A_SROA_0_0_DST_SROA_CAST]], align 1, !tbaa [[TBAA9]]
-; CHECK-NEXT: [[A_SROA_3_0_DST_SROA_IDX:%.*]] = getelementptr inbounds i8, i8* [[DST]], i64 4
-; CHECK-NEXT: [[A_SROA_3_0_DST_SROA_CAST:%.*]] = bitcast i8* [[A_SROA_3_0_DST_SROA_IDX]] to i32*
-; CHECK-NEXT: store i32 [[A_SROA_3_0_COPYLOAD]], i32* [[A_SROA_3_0_DST_SROA_CAST]], align 1, !tbaa [[TBAA9]]
-; CHECK-NEXT: [[A_SROA_33_0_PTR2_SROA_IDX7:%.*]] = getelementptr inbounds [34 x i8], [34 x i8]* [[A_SROA_33]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* [[DST]], i8* align 1 [[A_SROA_33_0_PTR2_SROA_IDX7]], i32 [[SIZE]], i1 false), !tbaa [[TBAA11]]
+; CHECK-NEXT: [[A_SROA_0_0_COPYLOAD:%.*]] = load i32, ptr [[SRC:%.*]], align 1, !tbaa [[TBAA0]]
+; CHECK-NEXT: [[A_SROA_3_0_SRC_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i64 4
+; CHECK-NEXT: [[A_SROA_3_0_COPYLOAD:%.*]] = load i32, ptr [[A_SROA_3_0_SRC_SROA_IDX]], align 1, !tbaa [[TBAA0]]
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[A_SROA_33]], ptr [[SRC]], i32 [[SIZE:%.*]], i1 false), !tbaa [[TBAA3]]
+; CHECK-NEXT: call void @llvm.memset.p0.i32(ptr align 1 [[A_SROA_33]], i8 42, i32 [[SIZE]], i1 false), !tbaa [[TBAA5]]
+; CHECK-NEXT: store i32 42, ptr [[DST:%.*]], align 1, !tbaa [[TBAA9]]
+; CHECK-NEXT: [[A_SROA_3_0_DST_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 4
+; CHECK-NEXT: store i32 [[A_SROA_3_0_COPYLOAD]], ptr [[A_SROA_3_0_DST_SROA_IDX]], align 1, !tbaa [[TBAA9]]
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr [[DST]], ptr align 1 [[A_SROA_33]], i32 [[SIZE]], i1 false), !tbaa [[TBAA11]]
; CHECK-NEXT: ret void
;
entry:
%a = alloca [42 x i8]
- %ptr = getelementptr [42 x i8], [42 x i8]* %a, i32 0, i32 0
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %ptr, i8* %src, i32 8, i1 false), !tbaa !0
- %ptr2 = getelementptr [42 x i8], [42 x i8]* %a, i32 0, i32 8
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %ptr2, i8* %src, i32 %size, i1 false), !tbaa !3
- call void @llvm.memset.p0i8.i32(i8* %ptr2, i8 42, i32 %size, i1 false), !tbaa !5
- %cast = bitcast i8* %ptr to i32*
- store i32 42, i32* %cast, !tbaa !7
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %ptr, i32 8, i1 false), !tbaa !9
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %ptr2, i32 %size, i1 false), !tbaa !11
+ call void @llvm.memcpy.p0.p0.i32(ptr %a, ptr %src, i32 8, i1 false), !tbaa !0
+ %ptr2 = getelementptr [42 x i8], ptr %a, i32 0, i32 8
+ call void @llvm.memcpy.p0.p0.i32(ptr %ptr2, ptr %src, i32 %size, i1 false), !tbaa !3
+ call void @llvm.memset.p0.i32(ptr %ptr2, i8 42, i32 %size, i1 false), !tbaa !5
+ store i32 42, ptr %a, !tbaa !7
+ call void @llvm.memcpy.p0.p0.i32(ptr %dst, ptr %a, i32 8, i1 false), !tbaa !9
+ call void @llvm.memcpy.p0.p0.i32(ptr %dst, ptr %ptr2, i32 %size, i1 false), !tbaa !11
ret void
}
%opaque = type opaque
-define i64 @test19(%opaque* %x) {
+define i64 @test19(ptr %x) {
; This input will cause us to try to compute a natural GEP when rewriting
; pointers in such a way that we try to GEP through the opaque type. Previously,
; a check for an unsized type was missing and this crashed. Ensure it behaves
; reasonably now.
; CHECK-LABEL: @test19(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[CAST1:%.*]] = bitcast %opaque* [[X:%.*]] to i8*
-; CHECK-NEXT: [[A_SROA_0_0_CAST1_SROA_CAST:%.*]] = bitcast i8* [[CAST1]] to i64*
-; CHECK-NEXT: [[A_SROA_0_0_COPYLOAD:%.*]] = load i64, i64* [[A_SROA_0_0_CAST1_SROA_CAST]], align 1
-; CHECK-NEXT: [[A_SROA_2_0_CAST1_SROA_IDX:%.*]] = getelementptr inbounds i8, i8* [[CAST1]], i64 8
-; CHECK-NEXT: [[A_SROA_2_0_CAST1_SROA_CAST:%.*]] = bitcast i8* [[A_SROA_2_0_CAST1_SROA_IDX]] to i8**
-; CHECK-NEXT: [[A_SROA_2_0_COPYLOAD:%.*]] = load i8*, i8** [[A_SROA_2_0_CAST1_SROA_CAST]], align 1
+; CHECK-NEXT: [[A_SROA_0_0_COPYLOAD:%.*]] = load i64, ptr [[X:%.*]], align 1
+; CHECK-NEXT: [[A_SROA_2_0_X_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[X]], i64 8
+; CHECK-NEXT: [[A_SROA_2_0_COPYLOAD:%.*]] = load ptr, ptr [[A_SROA_2_0_X_SROA_IDX]], align 1
; CHECK-NEXT: ret i64 [[A_SROA_0_0_COPYLOAD]]
;
entry:
- %a = alloca { i64, i8* }
- %cast1 = bitcast %opaque* %x to i8*
- %cast2 = bitcast { i64, i8* }* %a to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %cast2, i8* %cast1, i32 16, i1 false)
- %gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %a, i32 0, i32 0
- %val = load i64, i64* %gep
+ %a = alloca { i64, ptr }
+ call void @llvm.memcpy.p0.p0.i32(ptr %a, ptr %x, i32 16, i1 false)
+ %gep = getelementptr inbounds { i64, ptr }, ptr %a, i32 0, i32 0
+ %val = load i64, ptr %gep
ret i64 %val
}
-declare void @llvm.memcpy.p0i8.p1i8.i32(i8* nocapture, i8 addrspace(1)* nocapture, i32, i32, i1) nounwind
+declare void @llvm.memcpy.p0.p1.i32(ptr nocapture, ptr addrspace(1) nocapture, i32, i32, i1) nounwind
-define i64 @test19_addrspacecast(%opaque* %x) {
+define i64 @test19_addrspacecast(ptr %x) {
; This input will cause us to try to compute a natural GEP when rewriting
; pointers in such a way that we try to GEP through the opaque type. Previously,
; a check for an unsized type was missing and this crashed. Ensure it behaves
; reasonably now.
; CHECK-LABEL: @test19_addrspacecast(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[CAST1:%.*]] = addrspacecast %opaque* [[X:%.*]] to i8 addrspace(1)*
-; CHECK-NEXT: [[A_SROA_0_0_CAST1_SROA_CAST:%.*]] = bitcast i8 addrspace(1)* [[CAST1]] to i64 addrspace(1)*
-; CHECK-NEXT: [[A_SROA_0_0_COPYLOAD:%.*]] = load i64, i64 addrspace(1)* [[A_SROA_0_0_CAST1_SROA_CAST]], align 1
-; CHECK-NEXT: [[A_SROA_2_0_CAST1_SROA_IDX:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[CAST1]], i16 8
-; CHECK-NEXT: [[A_SROA_2_0_CAST1_SROA_CAST:%.*]] = bitcast i8 addrspace(1)* [[A_SROA_2_0_CAST1_SROA_IDX]] to i8* addrspace(1)*
-; CHECK-NEXT: [[A_SROA_2_0_COPYLOAD:%.*]] = load i8*, i8* addrspace(1)* [[A_SROA_2_0_CAST1_SROA_CAST]], align 1
+; CHECK-NEXT: [[CAST1:%.*]] = addrspacecast ptr [[X:%.*]] to ptr addrspace(1)
+; CHECK-NEXT: [[A_SROA_0_0_COPYLOAD:%.*]] = load i64, ptr addrspace(1) [[CAST1]], align 1
+; CHECK-NEXT: [[A_SROA_2_0_CAST1_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr addrspace(1) [[CAST1]], i16 8
+; CHECK-NEXT: [[A_SROA_2_0_COPYLOAD:%.*]] = load ptr, ptr addrspace(1) [[A_SROA_2_0_CAST1_SROA_IDX]], align 1
; CHECK-NEXT: ret i64 [[A_SROA_0_0_COPYLOAD]]
;
entry:
- %a = alloca { i64, i8* }
- %cast1 = addrspacecast %opaque* %x to i8 addrspace(1)*
- %cast2 = bitcast { i64, i8* }* %a to i8*
- call void @llvm.memcpy.p0i8.p1i8.i32(i8* %cast2, i8 addrspace(1)* %cast1, i32 16, i32 1, i1 false)
- %gep = getelementptr inbounds { i64, i8* }, { i64, i8* }* %a, i32 0, i32 0
- %val = load i64, i64* %gep
+ %a = alloca { i64, ptr }
+ %cast1 = addrspacecast ptr %x to ptr addrspace(1)
+ call void @llvm.memcpy.p0.p1.i32(ptr %a, ptr addrspace(1) %cast1, i32 16, i32 1, i1 false)
+ %gep = getelementptr inbounds { i64, ptr }, ptr %a, i32 0, i32 0
+ %val = load i64, ptr %gep
ret i64 %val
}
@@ -995,24 +852,23 @@ define i32 @test20() {
entry:
%a = alloca [3 x i32]
- %gep1 = getelementptr [3 x i32], [3 x i32]* %a, i32 0, i32 0
- store i32 1, i32* %gep1
- %gep2.1 = getelementptr [3 x i32], [3 x i32]* %a, i32 0, i32 -2
- %gep2.2 = getelementptr i32, i32* %gep2.1, i32 3
- store i32 2, i32* %gep2.2
- %gep3.1 = getelementptr [3 x i32], [3 x i32]* %a, i32 0, i32 14
- %gep3.2 = getelementptr i32, i32* %gep3.1, i32 -12
- store i32 3, i32* %gep3.2
-
- %load1 = load i32, i32* %gep1
- %load2 = load i32, i32* %gep2.2
- %load3 = load i32, i32* %gep3.2
+ store i32 1, ptr %a
+ %gep2.1 = getelementptr [3 x i32], ptr %a, i32 0, i32 -2
+ %gep2.2 = getelementptr i32, ptr %gep2.1, i32 3
+ store i32 2, ptr %gep2.2
+ %gep3.1 = getelementptr [3 x i32], ptr %a, i32 0, i32 14
+ %gep3.2 = getelementptr i32, ptr %gep3.1, i32 -12
+ store i32 3, ptr %gep3.2
+
+ %load1 = load i32, ptr %a
+ %load2 = load i32, ptr %gep2.2
+ %load3 = load i32, ptr %gep3.2
%sum1 = add i32 %load1, %load2
%sum2 = add i32 %sum1, %load3
ret i32 %sum2
}
-declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i1) nounwind
+declare void @llvm.memset.p0.i64(ptr nocapture, i8, i64, i1) nounwind
define i8 @test21() {
; Test allocations and offsets which border on overflow of the int64_t used
@@ -1026,20 +882,19 @@ define i8 @test21() {
entry:
%a = alloca [2305843009213693951 x i8]
- %gep0 = getelementptr [2305843009213693951 x i8], [2305843009213693951 x i8]* %a, i64 0, i64 2305843009213693949
- store i8 255, i8* %gep0
- %gep1 = getelementptr [2305843009213693951 x i8], [2305843009213693951 x i8]* %a, i64 0, i64 -9223372036854775807
- %gep2 = getelementptr i8, i8* %gep1, i64 -1
- call void @llvm.memset.p0i8.i64(i8* %gep2, i8 0, i64 18446744073709551615, i1 false)
- %gep3 = getelementptr i8, i8* %gep1, i64 9223372036854775807
- %gep4 = getelementptr i8, i8* %gep3, i64 9223372036854775807
- %gep5 = getelementptr i8, i8* %gep4, i64 -6917529027641081857
- store i8 255, i8* %gep5
- %cast1 = bitcast i8* %gep4 to i32*
- store i32 0, i32* %cast1
- %load = load i8, i8* %gep0
- %gep6 = getelementptr i8, i8* %gep0, i32 1
- %load2 = load i8, i8* %gep6
+ %gep0 = getelementptr [2305843009213693951 x i8], ptr %a, i64 0, i64 2305843009213693949
+ store i8 255, ptr %gep0
+ %gep1 = getelementptr [2305843009213693951 x i8], ptr %a, i64 0, i64 -9223372036854775807
+ %gep2 = getelementptr i8, ptr %gep1, i64 -1
+ call void @llvm.memset.p0.i64(ptr %gep2, i8 0, i64 18446744073709551615, i1 false)
+ %gep3 = getelementptr i8, ptr %gep1, i64 9223372036854775807
+ %gep4 = getelementptr i8, ptr %gep3, i64 9223372036854775807
+ %gep5 = getelementptr i8, ptr %gep4, i64 -6917529027641081857
+ store i8 255, ptr %gep5
+ store i32 0, ptr %gep4
+ %load = load i8, ptr %gep0
+ %gep6 = getelementptr i8, ptr %gep0, i32 1
+ %load2 = load i8, ptr %gep6
%result = or i8 %load, %load2
ret i8 %result
}
@@ -1056,8 +911,8 @@ define void @PR13916.1() {
entry:
%a = alloca i8
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %a, i8* %a, i32 1, i1 false)
- %tmp2 = load i8, i8* %a
+ call void @llvm.memcpy.p0.p0.i32(ptr %a, ptr %a, i32 1, i1 false)
+ %tmp2 = load i8, ptr %a
ret void
}
@@ -1079,18 +934,15 @@ entry:
br i1 %c1, label %if.then, label %if.end
if.then:
- %tmp0 = bitcast %PR13916.struct* %a to i8*
- %tmp1 = bitcast %PR13916.struct* %a to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %tmp0, i8* %tmp1, i32 1, i1 false)
+ call void @llvm.memcpy.p0.p0.i32(ptr %a, ptr %a, i32 1, i1 false)
br label %if.end
if.end:
- %gep = getelementptr %PR13916.struct, %PR13916.struct* %a, i32 0, i32 0
- %tmp2 = load i8, i8* %gep
+ %tmp2 = load i8, ptr %a
ret void
}
-define void @PR13990(i1 %c1, i1 %c2, i1 %c3, i1 %c4, i8* %ptr) {
+define void @PR13990(i1 %c1, i1 %c2, i1 %c3, i1 %c4, ptr %ptr) {
; Ensure we can handle cases where processing one alloca causes the other
; alloca to become dead and get deleted. This might crash or fail under
; Valgrind if we regress.
@@ -1108,16 +960,16 @@ define void @PR13990(i1 %c1, i1 %c2, i1 %c3, i1 %c4, i8* %ptr) {
;
entry:
- %tmp1 = alloca i8*
- %tmp2 = alloca i8*
+ %tmp1 = alloca ptr
+ %tmp2 = alloca ptr
br i1 %c1, label %bb1, label %bb2
bb1:
- store i8* %ptr, i8** %tmp2
+ store ptr %ptr, ptr %tmp2
br i1 %c2, label %bb2, label %bb3
bb2:
- %tmp50 = select i1 %c3, i8** %tmp2, i8** %tmp1
+ %tmp50 = select i1 %c3, ptr %tmp2, ptr %tmp1
br i1 %c4, label %bb3, label %bb4
bb3:
@@ -1138,42 +990,38 @@ define double @PR13969(double %x) {
entry:
%a = alloca double
- %b = alloca double*
+ %b = alloca ptr
%c = alloca double
- store double %x, double* %a
- store double* %c, double** %b
- store double* %a, double** %b
- store double %x, double* %c
- %ret = load double, double* %a
+ store double %x, ptr %a
+ store ptr %c, ptr %b
+ store ptr %a, ptr %b
+ store double %x, ptr %c
+ %ret = load double, ptr %a
ret double %ret
}
%PR14034.struct = type { { {} }, i32, %PR14034.list }
-%PR14034.list = type { %PR14034.list*, %PR14034.list* }
+%PR14034.list = type { ptr, ptr }
-define void @PR14034(%PR14034.list* %ptr, %PR14034.struct* %ptr2) {
+define void @PR14034(ptr %ptr, ptr %ptr2) {
; This test case tries to form GEPs into the empty leading struct members, and
; subsequently crashed (under valgrind) before we fixed the PR. The important
; thing is to handle empty structs gracefully.
; CHECK-LABEL: @PR14034(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A_SROA_0:%.*]] = alloca [12 x i8], align 8
-; CHECK-NEXT: [[A_SROA_0_0_CAST0_SROA_CAST:%.*]] = bitcast %PR14034.struct* [[PTR2:%.*]] to i8*
-; CHECK-NEXT: [[A_SROA_0_0_CAST1_SROA_IDX:%.*]] = getelementptr inbounds [12 x i8], [12 x i8]* [[A_SROA_0]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A_SROA_0_0_CAST0_SROA_CAST]], i8* align 8 [[A_SROA_0_0_CAST1_SROA_IDX]], i32 12, i1 false)
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[PTR2:%.*]], ptr align 8 [[A_SROA_0]], i32 12, i1 false)
; CHECK-NEXT: ret void
;
entry:
%a = alloca %PR14034.struct
- %list = getelementptr %PR14034.struct, %PR14034.struct* %a, i32 0, i32 2
- %prev = getelementptr %PR14034.list, %PR14034.list* %list, i32 0, i32 1
- store %PR14034.list* %ptr, %PR14034.list** %prev
- %cast0 = bitcast %PR14034.struct* %ptr2 to i8*
- %cast1 = bitcast %PR14034.struct* %a to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %cast0, i8* %cast1, i32 12, i1 false)
+ %list = getelementptr %PR14034.struct, ptr %a, i32 0, i32 2
+ %prev = getelementptr %PR14034.list, ptr %list, i32 0, i32 1
+ store ptr %ptr, ptr %prev
+ call void @llvm.memcpy.p0.p0.i32(ptr %ptr2, ptr %a, i32 12, i1 false)
ret void
}
@@ -1208,38 +1056,32 @@ entry:
%a3 = alloca { [0 x i8], { [0 x double], [1 x [1 x <4 x i8>]], {} }, { { {} } } }
%wrap1 = insertvalue [1 x { i32 }] poison, i32 %x, 0, 0
- %gep1 = getelementptr { { [1 x { i32 }] } }, { { [1 x { i32 }] } }* %a1, i32 0, i32 0, i32 0
- store [1 x { i32 }] %wrap1, [1 x { i32 }]* %gep1
+ store [1 x { i32 }] %wrap1, ptr %a1
- %gep2 = getelementptr { { [1 x { i32 }] } }, { { [1 x { i32 }] } }* %a1, i32 0, i32 0
- %ptrcast1 = bitcast { [1 x { i32 }] }* %gep2 to { [1 x { float }] }*
- %load1 = load { [1 x { float }] }, { [1 x { float }] }* %ptrcast1
+ %load1 = load { [1 x { float }] }, ptr %a1
%unwrap1 = extractvalue { [1 x { float }] } %load1, 0, 0
%wrap2 = insertvalue { {}, { float }, [0 x i8] } poison, { float } %unwrap1, 1
- store { {}, { float }, [0 x i8] } %wrap2, { {}, { float }, [0 x i8] }* %a2
+ store { {}, { float }, [0 x i8] } %wrap2, ptr %a2
- %gep3 = getelementptr { {}, { float }, [0 x i8] }, { {}, { float }, [0 x i8] }* %a2, i32 0, i32 1, i32 0
- %ptrcast2 = bitcast float* %gep3 to <4 x i8>*
- %load3 = load <4 x i8>, <4 x i8>* %ptrcast2
+ %gep3 = getelementptr { {}, { float }, [0 x i8] }, ptr %a2, i32 0, i32 1, i32 0
+ %load3 = load <4 x i8>, ptr %gep3
%valcast1 = bitcast <4 x i8> %load3 to i32
%wrap3 = insertvalue [1 x [1 x i32]] poison, i32 %valcast1, 0, 0
%wrap4 = insertvalue { [1 x [1 x i32]], {} } poison, [1 x [1 x i32]] %wrap3, 0
- %gep4 = getelementptr { [0 x i8], { [0 x double], [1 x [1 x <4 x i8>]], {} }, { { {} } } }, { [0 x i8], { [0 x double], [1 x [1 x <4 x i8>]], {} }, { { {} } } }* %a3, i32 0, i32 1
- %ptrcast3 = bitcast { [0 x double], [1 x [1 x <4 x i8>]], {} }* %gep4 to { [1 x [1 x i32]], {} }*
- store { [1 x [1 x i32]], {} } %wrap4, { [1 x [1 x i32]], {} }* %ptrcast3
+ %gep4 = getelementptr { [0 x i8], { [0 x double], [1 x [1 x <4 x i8>]], {} }, { { {} } } }, ptr %a3, i32 0, i32 1
+ store { [1 x [1 x i32]], {} } %wrap4, ptr %gep4
- %gep5 = getelementptr { [0 x i8], { [0 x double], [1 x [1 x <4 x i8>]], {} }, { { {} } } }, { [0 x i8], { [0 x double], [1 x [1 x <4 x i8>]], {} }, { { {} } } }* %a3, i32 0, i32 1, i32 1, i32 0
- %ptrcast4 = bitcast [1 x <4 x i8>]* %gep5 to { {}, float, {} }*
- %load4 = load { {}, float, {} }, { {}, float, {} }* %ptrcast4
+ %gep5 = getelementptr { [0 x i8], { [0 x double], [1 x [1 x <4 x i8>]], {} }, { { {} } } }, ptr %a3, i32 0, i32 1, i32 1, i32 0
+ %load4 = load { {}, float, {} }, ptr %gep5
%unwrap2 = extractvalue { {}, float, {} } %load4, 1
%valcast2 = bitcast float %unwrap2 to i32
ret i32 %valcast2
}
-define void @PR14059.1(double* %d) {
+define void @PR14059.1(ptr %d) {
; In PR14059 a peculiar construct was identified as something that is used
; pervasively in ARM's ABI-calling-convention lowering: the passing of a struct
; of doubles via an array of i32 in order to place the data into integer
@@ -1260,69 +1102,65 @@ define void @PR14059.1(double* %d) {
; CHECK-NEXT: [[X_SROA_0_I_2_INSERT_INSERT:%.*]] = or i64 [[X_SROA_0_I_2_INSERT_MASK]], 0
; CHECK-NEXT: [[TMP3:%.*]] = bitcast i64 [[X_SROA_0_I_2_INSERT_INSERT]] to double
; CHECK-NEXT: [[TMP4:%.*]] = bitcast double [[TMP3]] to i64
-; CHECK-NEXT: [[X_SROA_0_I_4_D_RAW_SROA_CAST:%.*]] = bitcast double* [[D:%.*]] to i32*
-; CHECK-NEXT: [[X_SROA_0_I_4_COPYLOAD:%.*]] = load i32, i32* [[X_SROA_0_I_4_D_RAW_SROA_CAST]], align 1
+; CHECK-NEXT: [[X_SROA_0_I_4_COPYLOAD:%.*]] = load i32, ptr [[D:%.*]], align 1
; CHECK-NEXT: [[TMP5:%.*]] = bitcast double 0.000000e+00 to i64
; CHECK-NEXT: [[X_SROA_0_I_4_INSERT_EXT:%.*]] = zext i32 [[X_SROA_0_I_4_COPYLOAD]] to i64
; CHECK-NEXT: [[X_SROA_0_I_4_INSERT_SHIFT:%.*]] = shl i64 [[X_SROA_0_I_4_INSERT_EXT]], 32
-; CHECK-NEXT: [[X_SROA_0_I_4_INSERT_MASK4:%.*]] = and i64 [[TMP5]], 4294967295
-; CHECK-NEXT: [[X_SROA_0_I_4_INSERT_INSERT5:%.*]] = or i64 [[X_SROA_0_I_4_INSERT_MASK4]], [[X_SROA_0_I_4_INSERT_SHIFT]]
-; CHECK-NEXT: [[TMP6:%.*]] = bitcast i64 [[X_SROA_0_I_4_INSERT_INSERT5]] to double
+; CHECK-NEXT: [[X_SROA_0_I_4_INSERT_MASK3:%.*]] = and i64 [[TMP5]], 4294967295
+; CHECK-NEXT: [[X_SROA_0_I_4_INSERT_INSERT4:%.*]] = or i64 [[X_SROA_0_I_4_INSERT_MASK3]], [[X_SROA_0_I_4_INSERT_SHIFT]]
+; CHECK-NEXT: [[TMP6:%.*]] = bitcast i64 [[X_SROA_0_I_4_INSERT_INSERT4]] to double
; CHECK-NEXT: [[TMP7:%.*]] = bitcast double [[TMP6]] to i64
; CHECK-NEXT: [[X_SROA_0_I_4_INSERT_MASK:%.*]] = and i64 [[TMP7]], 4294967295
; CHECK-NEXT: [[X_SROA_0_I_4_INSERT_INSERT:%.*]] = or i64 [[X_SROA_0_I_4_INSERT_MASK]], 4607182418800017408
; CHECK-NEXT: [[TMP8:%.*]] = bitcast i64 [[X_SROA_0_I_4_INSERT_INSERT]] to double
-; CHECK-NEXT: [[ACCUM_REAL_I:%.*]] = load double, double* [[D]], align 8
+; CHECK-NEXT: [[ACCUM_REAL_I:%.*]] = load double, ptr [[D]], align 8
; CHECK-NEXT: [[ADD_R_I:%.*]] = fadd double [[ACCUM_REAL_I]], [[TMP8]]
-; CHECK-NEXT: store double [[ADD_R_I]], double* [[D]], align 8
+; CHECK-NEXT: store double [[ADD_R_I]], ptr [[D]], align 8
; CHECK-NEXT: ret void
;
entry:
%X.sroa.0.i = alloca double, align 8
- %0 = bitcast double* %X.sroa.0.i to i8*
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %0)
+ %0 = bitcast ptr %X.sroa.0.i to ptr
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %0)
; Store to the low 32-bits...
- %X.sroa.0.0.cast2.i = bitcast double* %X.sroa.0.i to i32*
- store i32 0, i32* %X.sroa.0.0.cast2.i, align 8
+ store i32 0, ptr %X.sroa.0.i, align 8
; Also use a memset to the middle 32-bits for fun.
- %X.sroa.0.2.raw_idx2.i = getelementptr inbounds i8, i8* %0, i32 2
- call void @llvm.memset.p0i8.i64(i8* %X.sroa.0.2.raw_idx2.i, i8 0, i64 4, i1 false)
+ %X.sroa.0.2.raw_idx2.i = getelementptr inbounds i8, ptr %0, i32 2
+ call void @llvm.memset.p0.i64(ptr %X.sroa.0.2.raw_idx2.i, i8 0, i64 4, i1 false)
; Or a memset of the whole thing.
- call void @llvm.memset.p0i8.i64(i8* %0, i8 0, i64 8, i1 false)
+ call void @llvm.memset.p0.i64(ptr %0, i8 0, i64 8, i1 false)
; Write to the high 32-bits with a memcpy.
- %X.sroa.0.4.raw_idx4.i = getelementptr inbounds i8, i8* %0, i32 4
- %d.raw = bitcast double* %d to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %X.sroa.0.4.raw_idx4.i, i8* %d.raw, i32 4, i1 false)
+ %X.sroa.0.4.raw_idx4.i = getelementptr inbounds i8, ptr %0, i32 4
+ call void @llvm.memcpy.p0.p0.i32(ptr %X.sroa.0.4.raw_idx4.i, ptr %d, i32 4, i1 false)
; Store to the high 32-bits...
- %X.sroa.0.4.cast5.i = bitcast i8* %X.sroa.0.4.raw_idx4.i to i32*
- store i32 1072693248, i32* %X.sroa.0.4.cast5.i, align 4
+ store i32 1072693248, ptr %X.sroa.0.4.raw_idx4.i, align 4
; Do the actual math...
- %X.sroa.0.0.load1.i = load double, double* %X.sroa.0.i, align 8
- %accum.real.i = load double, double* %d, align 8
+ %X.sroa.0.0.load1.i = load double, ptr %X.sroa.0.i, align 8
+ %accum.real.i = load double, ptr %d, align 8
%add.r.i = fadd double %accum.real.i, %X.sroa.0.0.load1.i
- store double %add.r.i, double* %d, align 8
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %0)
+ store double %add.r.i, ptr %d, align 8
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %0)
ret void
}
-define i64 @PR14059.2({ float, float }* %phi) {
+define i64 @PR14059.2(ptr %phi) {
; Check that SROA can split up alloca-wide integer loads and stores where the
; underlying alloca has smaller components that are accessed independently. This
; shows up particularly with ABI lowering patterns coming out of Clang that rely
; on the particular register placement of a single large integer return value.
; CHECK-LABEL: @PR14059.2(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[PHI_REALP:%.*]] = getelementptr inbounds { float, float }, { float, float }* [[PHI:%.*]], i32 0, i32 0
-; CHECK-NEXT: [[PHI_REAL:%.*]] = load float, float* [[PHI_REALP]], align 4
-; CHECK-NEXT: [[PHI_IMAGP:%.*]] = getelementptr inbounds { float, float }, { float, float }* [[PHI]], i32 0, i32 1
-; CHECK-NEXT: [[PHI_IMAG:%.*]] = load float, float* [[PHI_IMAGP]], align 4
+; CHECK-NEXT: [[PHI_REALP:%.*]] = getelementptr inbounds { float, float }, ptr [[PHI:%.*]], i32 0, i32 0
+; CHECK-NEXT: [[PHI_REAL:%.*]] = load float, ptr [[PHI_REALP]], align 4
+; CHECK-NEXT: [[PHI_IMAGP:%.*]] = getelementptr inbounds { float, float }, ptr [[PHI]], i32 0, i32 1
+; CHECK-NEXT: [[PHI_IMAG:%.*]] = load float, ptr [[PHI_IMAGP]], align 4
; CHECK-NEXT: [[TMP0:%.*]] = bitcast float [[PHI_REAL]] to i32
; CHECK-NEXT: [[TMP1:%.*]] = bitcast float [[PHI_IMAG]] to i32
; CHECK-NEXT: [[RETVAL_SROA_3_0_INSERT_EXT:%.*]] = zext i32 [[TMP1]] to i64
@@ -1338,65 +1176,58 @@ define i64 @PR14059.2({ float, float }* %phi) {
entry:
%retval = alloca { float, float }, align 4
- %0 = bitcast { float, float }* %retval to i64*
- store i64 0, i64* %0
+ %0 = bitcast ptr %retval to ptr
+ store i64 0, ptr %0
- %phi.realp = getelementptr inbounds { float, float }, { float, float }* %phi, i32 0, i32 0
- %phi.real = load float, float* %phi.realp
- %phi.imagp = getelementptr inbounds { float, float }, { float, float }* %phi, i32 0, i32 1
- %phi.imag = load float, float* %phi.imagp
+ %phi.realp = getelementptr inbounds { float, float }, ptr %phi, i32 0, i32 0
+ %phi.real = load float, ptr %phi.realp
+ %phi.imagp = getelementptr inbounds { float, float }, ptr %phi, i32 0, i32 1
+ %phi.imag = load float, ptr %phi.imagp
- %real = getelementptr inbounds { float, float }, { float, float }* %retval, i32 0, i32 0
- %imag = getelementptr inbounds { float, float }, { float, float }* %retval, i32 0, i32 1
- store float %phi.real, float* %real
- store float %phi.imag, float* %imag
+ %real = getelementptr inbounds { float, float }, ptr %retval, i32 0, i32 0
+ %imag = getelementptr inbounds { float, float }, ptr %retval, i32 0, i32 1
+ store float %phi.real, ptr %real
+ store float %phi.imag, ptr %imag
- %1 = load i64, i64* %0, align 1
+ %1 = load i64, ptr %0, align 1
ret i64 %1
}
-define void @PR14105({ [16 x i8] }* %ptr) {
+define void @PR14105(ptr %ptr) {
; Ensure that when rewriting the GEP index '-1' for this alloca we preserve is
; sign as negative. We use a volatile memcpy to ensure promotion never actually
; occurs.
; CHECK-LABEL: @PR14105(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A_SROA_0:%.*]] = alloca [16 x i8], align 8
-; CHECK-NEXT: [[A_SROA_0_0_CAST1_SROA_IDX:%.*]] = getelementptr inbounds { [16 x i8] }, { [16 x i8] }* [[PTR:%.*]], i64 -1, i32 0, i64 0
-; CHECK-NEXT: [[A_SROA_0_0_CAST2_SROA_IDX:%.*]] = getelementptr inbounds [16 x i8], [16 x i8]* [[A_SROA_0]], i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 [[A_SROA_0_0_CAST1_SROA_IDX]], i8* align 8 [[A_SROA_0_0_CAST2_SROA_IDX]], i32 16, i1 true)
+; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds { [16 x i8] }, ptr [[PTR:%.*]], i64 -1
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 8 [[GEP]], ptr align 8 [[A_SROA_0]], i32 16, i1 true)
; CHECK-NEXT: ret void
;
entry:
%a = alloca { [16 x i8] }, align 8
- %gep = getelementptr inbounds { [16 x i8] }, { [16 x i8] }* %ptr, i64 -1
+ %gep = getelementptr inbounds { [16 x i8] }, ptr %ptr, i64 -1
- %cast1 = bitcast { [16 x i8 ] }* %gep to i8*
- %cast2 = bitcast { [16 x i8 ] }* %a to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %cast1, i8* align 8 %cast2, i32 16, i1 true)
+ call void @llvm.memcpy.p0.p0.i32(ptr align 8 %gep, ptr align 8 %a, i32 16, i1 true)
ret void
}
-define void @PR14105_as1({ [16 x i8] } addrspace(1)* %ptr) {
+define void @PR14105_as1(ptr addrspace(1) %ptr) {
; Make sure this the right address space pointer is used for type check.
; CHECK-LABEL: @PR14105_as1(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca { [16 x i8] }, align 8
-; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds { [16 x i8] }, { [16 x i8] } addrspace(1)* [[PTR:%.*]], i64 -1
-; CHECK-NEXT: [[CAST1:%.*]] = bitcast { [16 x i8] } addrspace(1)* [[GEP]] to i8 addrspace(1)*
-; CHECK-NEXT: [[CAST2:%.*]] = bitcast { [16 x i8] }* [[A]] to i8*
-; CHECK-NEXT: call void @llvm.memcpy.p1i8.p0i8.i32(i8 addrspace(1)* align 8 [[CAST1]], i8* align 8 [[CAST2]], i32 16, i1 true)
+; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds { [16 x i8] }, ptr addrspace(1) [[PTR:%.*]], i64 -1
+; CHECK-NEXT: call void @llvm.memcpy.p1.p0.i32(ptr addrspace(1) align 8 [[GEP]], ptr align 8 [[A]], i32 16, i1 true)
; CHECK-NEXT: ret void
;
entry:
%a = alloca { [16 x i8] }, align 8
- %gep = getelementptr inbounds { [16 x i8] }, { [16 x i8] } addrspace(1)* %ptr, i64 -1
- %cast1 = bitcast { [16 x i8 ] } addrspace(1)* %gep to i8 addrspace(1)*
- %cast2 = bitcast { [16 x i8 ] }* %a to i8*
- call void @llvm.memcpy.p1i8.p0i8.i32(i8 addrspace(1)* align 8 %cast1, i8* align 8 %cast2, i32 16, i1 true)
+ %gep = getelementptr inbounds { [16 x i8] }, ptr addrspace(1) %ptr, i64 -1
+ call void @llvm.memcpy.p1.p0.i32(ptr addrspace(1) align 8 %gep, ptr align 8 %a, i32 16, i1 true)
ret void
}
@@ -1405,14 +1236,12 @@ define void @PR14465() {
; integer type width (MAX_INT_BITS) supported by llvm (1048576*32 > (1<<23)-1).
; CHECK-LABEL: @PR14465(
; CHECK-NEXT: [[STACK:%.*]] = alloca [1048576 x i32], align 16
-; CHECK-NEXT: [[STACK_0_CAST_SROA_CAST:%.*]] = bitcast [1048576 x i32]* [[STACK]] to i8*
-; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* align 16 [[STACK_0_CAST_SROA_CAST]], i8 -2, i64 4194304, i1 false)
+; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 16 [[STACK]], i8 -2, i64 4194304, i1 false)
; CHECK-NEXT: ret void
;
%stack = alloca [1048576 x i32], align 16
- %cast = bitcast [1048576 x i32]* %stack to i8*
- call void @llvm.memset.p0i8.i64(i8* align 16 %cast, i8 -2, i64 4194304, i1 false)
+ call void @llvm.memset.p0.i64(ptr align 16 %stack, i8 -2, i64 4194304, i1 false)
ret void
}
@@ -1427,14 +1256,12 @@ define void @PR14548(i1 %x) {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A_SROA_0:%.*]] = alloca i8, align 8
; CHECK-NEXT: [[B_SROA_0:%.*]] = alloca i8, align 8
-; CHECK-NEXT: [[B_SROA_0_0_B_I1_SROA_CAST1:%.*]] = bitcast i8* [[B_SROA_0]] to i1*
-; CHECK-NEXT: store i1 [[X:%.*]], i1* [[B_SROA_0_0_B_I1_SROA_CAST1]], align 8
-; CHECK-NEXT: [[B_SROA_0_0_B_SROA_0_0_FOO:%.*]] = load i8, i8* [[B_SROA_0]], align 8
-; CHECK-NEXT: [[B_SROA_0_0_B_SROA_0_0_COPYLOAD:%.*]] = load i8, i8* [[B_SROA_0]], align 8
-; CHECK-NEXT: store i8 [[B_SROA_0_0_B_SROA_0_0_COPYLOAD]], i8* [[A_SROA_0]], align 8
-; CHECK-NEXT: [[A_SROA_0_0_A_SROA_0_0_BAR:%.*]] = load i8, i8* [[A_SROA_0]], align 8
-; CHECK-NEXT: [[A_SROA_0_0_A_I1_SROA_CAST2:%.*]] = bitcast i8* [[A_SROA_0]] to i1*
-; CHECK-NEXT: [[A_SROA_0_0_A_SROA_0_0_BAZ:%.*]] = load i1, i1* [[A_SROA_0_0_A_I1_SROA_CAST2]], align 8
+; CHECK-NEXT: store i1 [[X:%.*]], ptr [[B_SROA_0]], align 8
+; CHECK-NEXT: [[B_SROA_0_0_B_SROA_0_0_FOO:%.*]] = load i8, ptr [[B_SROA_0]], align 8
+; CHECK-NEXT: [[B_SROA_0_0_B_SROA_0_0_COPYLOAD:%.*]] = load i8, ptr [[B_SROA_0]], align 8
+; CHECK-NEXT: store i8 [[B_SROA_0_0_B_SROA_0_0_COPYLOAD]], ptr [[A_SROA_0]], align 8
+; CHECK-NEXT: [[A_SROA_0_0_A_SROA_0_0_BAR:%.*]] = load i8, ptr [[A_SROA_0]], align 8
+; CHECK-NEXT: [[A_SROA_0_0_A_SROA_0_0_BAZ:%.*]] = load i1, ptr [[A_SROA_0]], align 8
; CHECK-NEXT: ret void
;
@@ -1442,16 +1269,12 @@ entry:
%a = alloca <{ i1 }>, align 8
%b = alloca <{ i1 }>, align 8
- %b.i1 = bitcast <{ i1 }>* %b to i1*
- store i1 %x, i1* %b.i1, align 8
- %b.i8 = bitcast <{ i1 }>* %b to i8*
- %foo = load i8, i8* %b.i8, align 1
+ store i1 %x, ptr %b, align 8
+ %foo = load i8, ptr %b, align 1
- %a.i8 = bitcast <{ i1 }>* %a to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %a.i8, i8* %b.i8, i32 1, i1 false) nounwind
- %bar = load i8, i8* %a.i8, align 1
- %a.i1 = getelementptr inbounds <{ i1 }>, <{ i1 }>* %a, i32 0, i32 0
- %baz = load i1, i1* %a.i1, align 1
+ call void @llvm.memcpy.p0.p0.i32(ptr %a, ptr %b, i32 1, i1 false) nounwind
+ %bar = load i8, ptr %a, align 1
+ %baz = load i1, ptr %a, align 1
ret void
}
@@ -1471,9 +1294,8 @@ define <3 x i8> @PR14572.1(i32 %x) {
entry:
%a = alloca <3 x i8>, align 4
- %cast = bitcast <3 x i8>* %a to i32*
- store i32 %x, i32* %cast, align 1
- %y = load <3 x i8>, <3 x i8>* %a, align 4
+ store i32 %x, ptr %a, align 1
+ %y = load <3 x i8>, ptr %a, align 4
ret <3 x i8> %y
}
@@ -1496,9 +1318,8 @@ define i32 @PR14572.2(<3 x i8> %x) {
entry:
%a = alloca <3 x i8>, align 4
- store <3 x i8> %x, <3 x i8>* %a, align 1
- %cast = bitcast <3 x i8>* %a to i32*
- %y = load i32, i32* %cast, align 4
+ store <3 x i8> %x, ptr %a, align 1
+ %y = load i32, ptr %a, align 4
ret i32 %y
}
@@ -1508,22 +1329,20 @@ define i32 @PR14601(i32 %x) {
; CHECK-LABEL: @PR14601(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[A_0_A_I8_SROA_CAST:%.*]] = bitcast i32* [[A]] to i8*
-; CHECK-NEXT: call void @llvm.memset.p0i8.i32(i8* align 4 [[A_0_A_I8_SROA_CAST]], i8 0, i32 [[X:%.*]], i1 false)
-; CHECK-NEXT: [[A_0_V:%.*]] = load i32, i32* [[A]], align 4
+; CHECK-NEXT: call void @llvm.memset.p0.i32(ptr align 4 [[A]], i8 0, i32 [[X:%.*]], i1 false)
+; CHECK-NEXT: [[A_0_V:%.*]] = load i32, ptr [[A]], align 4
; CHECK-NEXT: ret i32 [[A_0_V]]
;
entry:
%a = alloca i32
- %a.i8 = bitcast i32* %a to i8*
- call void @llvm.memset.p0i8.i32(i8* %a.i8, i8 0, i32 %x, i1 false)
- %v = load i32, i32* %a
+ call void @llvm.memset.p0.i32(ptr %a, i8 0, i32 %x, i1 false)
+ %v = load i32, ptr %a
ret i32 %v
}
-define void @PR15674(i8* %data, i8* %src, i32 %size) {
+define void @PR15674(ptr %data, ptr %src, i32 %size) {
; Arrange (via control flow) to have unmerged stores of a particular width to
; an alloca where we incrementally store from the end of the array toward the
; beginning of the array. Ensure that the final integer store, despite being
@@ -1539,35 +1358,29 @@ define void @PR15674(i8* %data, i8* %src, i32 %size) {
; CHECK-NEXT: i32 1, label [[BB1:%.*]]
; CHECK-NEXT: ]
; CHECK: bb4:
-; CHECK-NEXT: [[SRC_GEP3:%.*]] = getelementptr inbounds i8, i8* [[SRC:%.*]], i32 3
-; CHECK-NEXT: [[SRC_3:%.*]] = load i8, i8* [[SRC_GEP3]], align 1
-; CHECK-NEXT: [[TMP_SROA_0_3_TMP_GEP3_SROA_RAW_CAST7:%.*]] = bitcast i32* [[TMP_SROA_0]] to i8*
-; CHECK-NEXT: [[TMP_SROA_0_3_TMP_GEP3_SROA_RAW_IDX8:%.*]] = getelementptr inbounds i8, i8* [[TMP_SROA_0_3_TMP_GEP3_SROA_RAW_CAST7]], i64 3
-; CHECK-NEXT: store i8 [[SRC_3]], i8* [[TMP_SROA_0_3_TMP_GEP3_SROA_RAW_IDX8]], align 1
+; CHECK-NEXT: [[SRC_GEP3:%.*]] = getelementptr inbounds i8, ptr [[SRC:%.*]], i32 3
+; CHECK-NEXT: [[SRC_3:%.*]] = load i8, ptr [[SRC_GEP3]], align 1
+; CHECK-NEXT: [[TMP_SROA_0_3_TMP_GEP3_SROA_IDX3:%.*]] = getelementptr inbounds i8, ptr [[TMP_SROA_0]], i64 3
+; CHECK-NEXT: store i8 [[SRC_3]], ptr [[TMP_SROA_0_3_TMP_GEP3_SROA_IDX3]], align 1
; CHECK-NEXT: br label [[BB3]]
; CHECK: bb3:
-; CHECK-NEXT: [[SRC_GEP2:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i32 2
-; CHECK-NEXT: [[SRC_2:%.*]] = load i8, i8* [[SRC_GEP2]], align 1
-; CHECK-NEXT: [[TMP_SROA_0_2_TMP_GEP2_SROA_RAW_CAST5:%.*]] = bitcast i32* [[TMP_SROA_0]] to i8*
-; CHECK-NEXT: [[TMP_SROA_0_2_TMP_GEP2_SROA_RAW_IDX6:%.*]] = getelementptr inbounds i8, i8* [[TMP_SROA_0_2_TMP_GEP2_SROA_RAW_CAST5]], i64 2
-; CHECK-NEXT: store i8 [[SRC_2]], i8* [[TMP_SROA_0_2_TMP_GEP2_SROA_RAW_IDX6]], align 2
+; CHECK-NEXT: [[SRC_GEP2:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i32 2
+; CHECK-NEXT: [[SRC_2:%.*]] = load i8, ptr [[SRC_GEP2]], align 1
+; CHECK-NEXT: [[TMP_SROA_0_2_TMP_GEP2_SROA_IDX2:%.*]] = getelementptr inbounds i8, ptr [[TMP_SROA_0]], i64 2
+; CHECK-NEXT: store i8 [[SRC_2]], ptr [[TMP_SROA_0_2_TMP_GEP2_SROA_IDX2]], align 2
; CHECK-NEXT: br label [[BB2]]
; CHECK: bb2:
-; CHECK-NEXT: [[SRC_GEP1:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i32 1
-; CHECK-NEXT: [[SRC_1:%.*]] = load i8, i8* [[SRC_GEP1]], align 1
-; CHECK-NEXT: [[TMP_SROA_0_1_TMP_GEP1_SROA_RAW_CAST3:%.*]] = bitcast i32* [[TMP_SROA_0]] to i8*
-; CHECK-NEXT: [[TMP_SROA_0_1_TMP_GEP1_SROA_RAW_IDX4:%.*]] = getelementptr inbounds i8, i8* [[TMP_SROA_0_1_TMP_GEP1_SROA_RAW_CAST3]], i64 1
-; CHECK-NEXT: store i8 [[SRC_1]], i8* [[TMP_SROA_0_1_TMP_GEP1_SROA_RAW_IDX4]], align 1
+; CHECK-NEXT: [[SRC_GEP1:%.*]] = getelementptr inbounds i8, ptr [[SRC]], i32 1
+; CHECK-NEXT: [[SRC_1:%.*]] = load i8, ptr [[SRC_GEP1]], align 1
+; CHECK-NEXT: [[TMP_SROA_0_1_TMP_GEP1_SROA_IDX1:%.*]] = getelementptr inbounds i8, ptr [[TMP_SROA_0]], i64 1
+; CHECK-NEXT: store i8 [[SRC_1]], ptr [[TMP_SROA_0_1_TMP_GEP1_SROA_IDX1]], align 1
; CHECK-NEXT: br label [[BB1]]
; CHECK: bb1:
-; CHECK-NEXT: [[SRC_GEP0:%.*]] = getelementptr inbounds i8, i8* [[SRC]], i32 0
-; CHECK-NEXT: [[SRC_0:%.*]] = load i8, i8* [[SRC_GEP0]], align 1
-; CHECK-NEXT: [[TMP_SROA_0_0_TMP_GEP0_SROA_CAST2:%.*]] = bitcast i32* [[TMP_SROA_0]] to i8*
-; CHECK-NEXT: store i8 [[SRC_0]], i8* [[TMP_SROA_0_0_TMP_GEP0_SROA_CAST2]], align 4
+; CHECK-NEXT: [[SRC_0:%.*]] = load i8, ptr [[SRC]], align 1
+; CHECK-NEXT: store i8 [[SRC_0]], ptr [[TMP_SROA_0]], align 4
; CHECK-NEXT: br label [[END]]
; CHECK: end:
-; CHECK-NEXT: [[TMP_SROA_0_0_TMP_RAW_SROA_CAST1:%.*]] = bitcast i32* [[TMP_SROA_0]] to i8*
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* [[DATA:%.*]], i8* align 4 [[TMP_SROA_0_0_TMP_RAW_SROA_CAST1]], i32 [[SIZE]], i1 false)
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr [[DATA:%.*]], ptr align 4 [[TMP_SROA_0]], i32 [[SIZE]], i1 false)
; CHECK-NEXT: ret void
;
@@ -1582,40 +1395,37 @@ entry:
]
bb4:
- %src.gep3 = getelementptr inbounds i8, i8* %src, i32 3
- %src.3 = load i8, i8* %src.gep3
- %tmp.gep3 = getelementptr inbounds [4 x i8], [4 x i8]* %tmp, i32 0, i32 3
- store i8 %src.3, i8* %tmp.gep3
+ %src.gep3 = getelementptr inbounds i8, ptr %src, i32 3
+ %src.3 = load i8, ptr %src.gep3
+ %tmp.gep3 = getelementptr inbounds [4 x i8], ptr %tmp, i32 0, i32 3
+ store i8 %src.3, ptr %tmp.gep3
br label %bb3
bb3:
- %src.gep2 = getelementptr inbounds i8, i8* %src, i32 2
- %src.2 = load i8, i8* %src.gep2
- %tmp.gep2 = getelementptr inbounds [4 x i8], [4 x i8]* %tmp, i32 0, i32 2
- store i8 %src.2, i8* %tmp.gep2
+ %src.gep2 = getelementptr inbounds i8, ptr %src, i32 2
+ %src.2 = load i8, ptr %src.gep2
+ %tmp.gep2 = getelementptr inbounds [4 x i8], ptr %tmp, i32 0, i32 2
+ store i8 %src.2, ptr %tmp.gep2
br label %bb2
bb2:
- %src.gep1 = getelementptr inbounds i8, i8* %src, i32 1
- %src.1 = load i8, i8* %src.gep1
- %tmp.gep1 = getelementptr inbounds [4 x i8], [4 x i8]* %tmp, i32 0, i32 1
- store i8 %src.1, i8* %tmp.gep1
+ %src.gep1 = getelementptr inbounds i8, ptr %src, i32 1
+ %src.1 = load i8, ptr %src.gep1
+ %tmp.gep1 = getelementptr inbounds [4 x i8], ptr %tmp, i32 0, i32 1
+ store i8 %src.1, ptr %tmp.gep1
br label %bb1
bb1:
- %src.gep0 = getelementptr inbounds i8, i8* %src, i32 0
- %src.0 = load i8, i8* %src.gep0
- %tmp.gep0 = getelementptr inbounds [4 x i8], [4 x i8]* %tmp, i32 0, i32 0
- store i8 %src.0, i8* %tmp.gep0
+ %src.0 = load i8, ptr %src
+ store i8 %src.0, ptr %tmp
br label %end
end:
- %tmp.raw = bitcast [4 x i8]* %tmp to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %data, i8* %tmp.raw, i32 %size, i1 false)
+ call void @llvm.memcpy.p0.p0.i32(ptr %data, ptr %tmp, i32 %size, i1 false)
ret void
}
@@ -1626,9 +1436,9 @@ define void @PR15805(i1 %a, i1 %b) {
;
%c = alloca i64, align 8
- %p.0.c = select i1 %a, i64* %c, i64* %c
- %cond.in = select i1 %b, i64* %p.0.c, i64* %c
- %cond = load i64, i64* %cond.in, align 8
+ %p.0.c = select i1 %a, ptr %c, ptr %c
+ %cond.in = select i1 %b, ptr %p.0.c, ptr %c
+ %cond = load i64, ptr %cond.in, align 8
ret void
}
@@ -1650,16 +1460,16 @@ define void @PR15805.1(i1 %a, i1 %b, i1 %c2) {
br label %exit
loop:
- %cond.in = select i1 %a, i64* %c, i64* %p.0.c
- %p.0.c = select i1 %b, i64* %c, i64* %c
- %cond = load i64, i64* %cond.in, align 8
+ %cond.in = select i1 %a, ptr %c, ptr %p.0.c
+ %p.0.c = select i1 %b, ptr %c, ptr %c
+ %cond = load i64, ptr %cond.in, align 8
br i1 %c2, label %loop, label %exit
exit:
ret void
}
-define void @PR16651.1(i8* %a) {
+define void @PR16651.1(ptr %a) {
; This test case caused a crash due to the volatile memcpy in combination with
; lowering to integer loads and stores of a width other than that of the original
; memcpy.
@@ -1669,25 +1479,23 @@ define void @PR16651.1(i8* %a) {
; CHECK-NEXT: [[B_SROA_0:%.*]] = alloca i16, align 4
; CHECK-NEXT: [[B_SROA_1:%.*]] = alloca i8, align 2
; CHECK-NEXT: [[B_SROA_2:%.*]] = alloca i8, align 1
-; CHECK-NEXT: [[B_SROA_0_0_A_SROA_CAST:%.*]] = bitcast i8* [[A:%.*]] to i16*
-; CHECK-NEXT: [[B_SROA_0_0_COPYLOAD:%.*]] = load volatile i16, i16* [[B_SROA_0_0_A_SROA_CAST]], align 4
-; CHECK-NEXT: store volatile i16 [[B_SROA_0_0_COPYLOAD]], i16* [[B_SROA_0]], align 4
-; CHECK-NEXT: [[B_SROA_1_0_A_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[A]], i64 2
-; CHECK-NEXT: [[B_SROA_1_0_COPYLOAD:%.*]] = load volatile i8, i8* [[B_SROA_1_0_A_SROA_RAW_IDX]], align 2
-; CHECK-NEXT: store volatile i8 [[B_SROA_1_0_COPYLOAD]], i8* [[B_SROA_1]], align 2
-; CHECK-NEXT: [[B_SROA_2_0_A_SROA_RAW_IDX:%.*]] = getelementptr inbounds i8, i8* [[A]], i64 3
-; CHECK-NEXT: [[B_SROA_2_0_COPYLOAD:%.*]] = load volatile i8, i8* [[B_SROA_2_0_A_SROA_RAW_IDX]], align 1
-; CHECK-NEXT: store volatile i8 [[B_SROA_2_0_COPYLOAD]], i8* [[B_SROA_2]], align 1
-; CHECK-NEXT: [[B_SROA_1_0_B_SROA_1_2_:%.*]] = load i8, i8* [[B_SROA_1]], align 2
+; CHECK-NEXT: [[B_SROA_0_0_COPYLOAD:%.*]] = load volatile i16, ptr [[A:%.*]], align 4
+; CHECK-NEXT: store volatile i16 [[B_SROA_0_0_COPYLOAD]], ptr [[B_SROA_0]], align 4
+; CHECK-NEXT: [[B_SROA_1_0_A_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 2
+; CHECK-NEXT: [[B_SROA_1_0_COPYLOAD:%.*]] = load volatile i8, ptr [[B_SROA_1_0_A_SROA_IDX]], align 2
+; CHECK-NEXT: store volatile i8 [[B_SROA_1_0_COPYLOAD]], ptr [[B_SROA_1]], align 2
+; CHECK-NEXT: [[B_SROA_2_0_A_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 3
+; CHECK-NEXT: [[B_SROA_2_0_COPYLOAD:%.*]] = load volatile i8, ptr [[B_SROA_2_0_A_SROA_IDX]], align 1
+; CHECK-NEXT: store volatile i8 [[B_SROA_2_0_COPYLOAD]], ptr [[B_SROA_2]], align 1
+; CHECK-NEXT: [[B_SROA_1_0_B_SROA_1_2_:%.*]] = load i8, ptr [[B_SROA_1]], align 2
; CHECK-NEXT: unreachable
;
entry:
%b = alloca i32, align 4
- %b.cast = bitcast i32* %b to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %b.cast, i8* align 4 %a, i32 4, i1 true)
- %b.gep = getelementptr inbounds i8, i8* %b.cast, i32 2
- load i8, i8* %b.gep, align 2
+ call void @llvm.memcpy.p0.p0.i32(ptr align 4 %b, ptr align 4 %a, i32 4, i1 true)
+ %b.gep = getelementptr inbounds i8, ptr %b, i32 2
+ load i8, ptr %b.gep, align 2
unreachable
}
@@ -1700,20 +1508,19 @@ define void @PR16651.2(<2 x float> %val, i1 %c1) {
; CHECK-LABEL: @PR16651.2(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[TV1_SROA_0:%.*]] = alloca <2 x float>, align 8
-; CHECK-NEXT: store <2 x float> [[VAL:%.*]], <2 x float>* [[TV1_SROA_0]], align 8
-; CHECK-NEXT: [[TV1_SROA_0_0__SROA_IDX:%.*]] = getelementptr inbounds <2 x float>, <2 x float>* [[TV1_SROA_0]], i64 0, i32 0
-; CHECK-NEXT: [[COND105_IN_I_I:%.*]] = select i1 [[C1:%.*]], float* null, float* [[TV1_SROA_0_0__SROA_IDX]]
-; CHECK-NEXT: [[COND105_I_I:%.*]] = load float, float* [[COND105_IN_I_I]], align 8
+; CHECK-NEXT: store <2 x float> [[VAL:%.*]], ptr [[TV1_SROA_0]], align 8
+; CHECK-NEXT: [[COND105_IN_I_I:%.*]] = select i1 [[C1:%.*]], ptr null, ptr [[TV1_SROA_0]]
+; CHECK-NEXT: [[COND105_I_I:%.*]] = load float, ptr [[COND105_IN_I_I]], align 8
; CHECK-NEXT: ret void
;
entry:
%tv1 = alloca { <2 x float>, <2 x float> }, align 8
- %0 = getelementptr { <2 x float>, <2 x float> }, { <2 x float>, <2 x float> }* %tv1, i64 0, i32 1
- store <2 x float> %val, <2 x float>* %0, align 8
- %1 = getelementptr inbounds { <2 x float>, <2 x float> }, { <2 x float>, <2 x float> }* %tv1, i64 0, i32 1, i64 0
- %cond105.in.i.i = select i1 %c1, float* null, float* %1
- %cond105.i.i = load float, float* %cond105.in.i.i, align 8
+ %0 = getelementptr { <2 x float>, <2 x float> }, ptr %tv1, i64 0, i32 1
+ store <2 x float> %val, ptr %0, align 8
+ %1 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %tv1, i64 0, i32 1, i64 0
+ %cond105.in.i.i = select i1 %c1, ptr null, ptr %1
+ %cond105.i.i = load float, ptr %cond105.in.i.i, align 8
ret void
}
@@ -1724,45 +1531,39 @@ define void @test23(i32 %x) {
;
entry:
%a = alloca i32, align 4
- store i32 %x, i32* %a, align 4
- %gep1 = getelementptr inbounds i32, i32* %a, i32 1
- %gep0 = getelementptr inbounds i32, i32* %a, i32 0
- %cast1 = bitcast i32* %gep1 to i8*
- %cast0 = bitcast i32* %gep0 to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %cast1, i8* %cast0, i32 4, i1 false)
+ store i32 %x, ptr %a, align 4
+ %gep1 = getelementptr inbounds i32, ptr %a, i32 1
+ call void @llvm.memcpy.p0.p0.i32(ptr %gep1, ptr %a, i32 4, i1 false)
ret void
}
-define void @PR18615(i8* %ptr) {
+define void @PR18615(ptr %ptr) {
; CHECK-LABEL: @PR18615(
; CHECK-NEXT: entry:
; CHECK-NEXT: ret void
;
entry:
%f = alloca i8
- %gep = getelementptr i8, i8* %f, i64 -1
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %ptr, i8* %gep, i32 1, i1 false)
+ %gep = getelementptr i8, ptr %f, i64 -1
+ call void @llvm.memcpy.p0.p0.i32(ptr %ptr, ptr %gep, i32 1, i1 false)
ret void
}
-define void @test24(i8* %src, i8* %dst) {
+define void @test24(ptr %src, ptr %dst) {
; CHECK-LABEL: @test24(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca i64, align 16
-; CHECK-NEXT: [[A_0_SRC_SROA_CAST:%.*]] = bitcast i8* [[SRC:%.*]] to i64*
-; CHECK-NEXT: [[A_0_COPYLOAD:%.*]] = load volatile i64, i64* [[A_0_SRC_SROA_CAST]], align 1, !tbaa [[TBAA0]]
-; CHECK-NEXT: store volatile i64 [[A_0_COPYLOAD]], i64* [[A]], align 16, !tbaa [[TBAA0]]
-; CHECK-NEXT: [[A_0_DST_SROA_CAST:%.*]] = bitcast i8* [[DST:%.*]] to i64*
-; CHECK-NEXT: [[A_0_COPYLOAD1:%.*]] = load volatile i64, i64* [[A]], align 16, !tbaa [[TBAA3]]
-; CHECK-NEXT: store volatile i64 [[A_0_COPYLOAD1]], i64* [[A_0_DST_SROA_CAST]], align 1, !tbaa [[TBAA3]]
+; CHECK-NEXT: [[A_0_COPYLOAD:%.*]] = load volatile i64, ptr [[SRC:%.*]], align 1, !tbaa [[TBAA0]]
+; CHECK-NEXT: store volatile i64 [[A_0_COPYLOAD]], ptr [[A]], align 16, !tbaa [[TBAA0]]
+; CHECK-NEXT: [[A_0_COPYLOAD1:%.*]] = load volatile i64, ptr [[A]], align 16, !tbaa [[TBAA3]]
+; CHECK-NEXT: store volatile i64 [[A_0_COPYLOAD1]], ptr [[DST:%.*]], align 1, !tbaa [[TBAA3]]
; CHECK-NEXT: ret void
;
entry:
%a = alloca i64, align 16
- %ptr = bitcast i64* %a to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %ptr, i8* %src, i32 8, i1 true), !tbaa !0
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %ptr, i32 8, i1 true), !tbaa !3
+ call void @llvm.memcpy.p0.p0.i32(ptr %a, ptr %src, i32 8, i1 true), !tbaa !0
+ call void @llvm.memcpy.p0.p0.i32(ptr %dst, ptr %a, i32 8, i1 true), !tbaa !3
ret void
}
@@ -1785,18 +1586,14 @@ define float @test25() {
entry:
%a = alloca i64
%b = alloca i64
- %a.cast = bitcast i64* %a to [2 x float]*
- %a.gep1 = getelementptr [2 x float], [2 x float]* %a.cast, i32 0, i32 0
- %a.gep2 = getelementptr [2 x float], [2 x float]* %a.cast, i32 0, i32 1
- %b.cast = bitcast i64* %b to [2 x float]*
- %b.gep1 = getelementptr [2 x float], [2 x float]* %b.cast, i32 0, i32 0
- %b.gep2 = getelementptr [2 x float], [2 x float]* %b.cast, i32 0, i32 1
- store float 0.0, float* %a.gep1
- store float 1.0, float* %a.gep2
- %v = load i64, i64* %a
- store i64 %v, i64* %b
- %f1 = load float, float* %b.gep1
- %f2 = load float, float* %b.gep2
+ %a.gep2 = getelementptr [2 x float], ptr %a, i32 0, i32 1
+ %b.gep2 = getelementptr [2 x float], ptr %b, i32 0, i32 1
+ store float 0.0, ptr %a
+ store float 1.0, ptr %a.gep2
+ %v = load i64, ptr %a
+ store i64 %v, ptr %b
+ %f1 = load float, ptr %b
+ %f2 = load float, ptr %b.gep2
%ret = fadd float %f1, %f2
ret float %ret
}
@@ -1809,32 +1606,30 @@ define void @test26() {
;
; CHECK-LABEL: @test26(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[V14:%.*]] = load i32, i32* bitcast ([2 x float]* @complex1 to i32*), align 4
-; CHECK-NEXT: [[V16:%.*]] = load i32, i32* bitcast (float* getelementptr inbounds ([2 x float], [2 x float]* @complex1, i64 0, i64 1) to i32*), align 4
-; CHECK-NEXT: [[TMP0:%.*]] = bitcast i32 [[V14]] to float
-; CHECK-NEXT: [[TMP1:%.*]] = bitcast i32 [[V16]] to float
+; CHECK-NEXT: [[V13:%.*]] = load i32, ptr @complex1, align 4
+; CHECK-NEXT: [[V14:%.*]] = load i32, ptr getelementptr inbounds (i8, ptr @complex1, i64 4), align 4
+; CHECK-NEXT: [[TMP0:%.*]] = bitcast i32 [[V13]] to float
+; CHECK-NEXT: [[TMP1:%.*]] = bitcast i32 [[V14]] to float
; CHECK-NEXT: [[SUM:%.*]] = fadd float [[TMP0]], [[TMP1]]
; CHECK-NEXT: [[TMP2:%.*]] = bitcast float [[SUM]] to i32
; CHECK-NEXT: [[TMP3:%.*]] = bitcast float [[SUM]] to i32
-; CHECK-NEXT: store i32 [[TMP2]], i32* bitcast ([2 x float]* @complex2 to i32*), align 4
-; CHECK-NEXT: store i32 [[TMP3]], i32* bitcast (float* getelementptr inbounds ([2 x float], [2 x float]* @complex2, i64 0, i64 1) to i32*), align 4
+; CHECK-NEXT: store i32 [[TMP2]], ptr @complex2, align 4
+; CHECK-NEXT: store i32 [[TMP3]], ptr getelementptr inbounds (i8, ptr @complex2, i64 4), align 4
; CHECK-NEXT: ret void
;
entry:
%a = alloca i64
- %a.cast = bitcast i64* %a to [2 x float]*
- %a.gep1 = getelementptr [2 x float], [2 x float]* %a.cast, i32 0, i32 0
- %a.gep2 = getelementptr [2 x float], [2 x float]* %a.cast, i32 0, i32 1
- %v1 = load i64, i64* bitcast ([2 x float]* @complex1 to i64*)
- store i64 %v1, i64* %a
- %f1 = load float, float* %a.gep1
- %f2 = load float, float* %a.gep2
+ %a.gep2 = getelementptr [2 x float], ptr %a, i32 0, i32 1
+ %v1 = load i64, ptr @complex1
+ store i64 %v1, ptr %a
+ %f1 = load float, ptr %a
+ %f2 = load float, ptr %a.gep2
%sum = fadd float %f1, %f2
- store float %sum, float* %a.gep1
- store float %sum, float* %a.gep2
- %v2 = load i64, i64* %a
- store i64 %v2, i64* bitcast ([2 x float]* @complex2 to i64*)
+ store float %sum, ptr %a
+ store float %sum, ptr %a.gep2
+ %v2 = load i64, ptr %a
+ store i64 %v2, ptr @complex2
ret void
}
@@ -1853,20 +1648,14 @@ define float @test27() {
entry:
%a = alloca [12 x i8]
- %gep1 = getelementptr [12 x i8], [12 x i8]* %a, i32 0, i32 0
- %gep2 = getelementptr [12 x i8], [12 x i8]* %a, i32 0, i32 4
- %gep3 = getelementptr [12 x i8], [12 x i8]* %a, i32 0, i32 8
- %iptr1 = bitcast i8* %gep1 to i64*
- %iptr2 = bitcast i8* %gep2 to i64*
- %fptr1 = bitcast i8* %gep1 to float*
- %fptr2 = bitcast i8* %gep2 to float*
- %fptr3 = bitcast i8* %gep3 to float*
- store float 0.0, float* %fptr1
- store float 1.0, float* %fptr2
- %v = load i64, i64* %iptr1
- store i64 %v, i64* %iptr2
- %f1 = load float, float* %fptr2
- %f2 = load float, float* %fptr3
+ %gep2 = getelementptr [12 x i8], ptr %a, i32 0, i32 4
+ %gep3 = getelementptr [12 x i8], ptr %a, i32 0, i32 8
+ store float 0.0, ptr %a
+ store float 1.0, ptr %gep2
+ %v = load i64, ptr %a
+ store i64 %v, ptr %gep2
+ %f1 = load float, ptr %gep2
+ %f2 = load float, ptr %gep3
%ret = fadd float %f1, %f2
ret float %ret
}
@@ -1882,8 +1671,8 @@ define i32 @PR22093() {
; CHECK-LABEL: @PR22093(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A_SROA_0:%.*]] = alloca i16, align 4
-; CHECK-NEXT: store volatile i16 42, i16* [[A_SROA_0]], align 4
-; CHECK-NEXT: [[A_SROA_0_0_A_SROA_0_0_LOAD:%.*]] = load i16, i16* [[A_SROA_0]], align 4
+; CHECK-NEXT: store volatile i16 42, ptr [[A_SROA_0]], align 4
+; CHECK-NEXT: [[A_SROA_0_0_A_SROA_0_0_LOAD:%.*]] = load i16, ptr [[A_SROA_0]], align 4
; CHECK-NEXT: [[A_SROA_3_0_INSERT_EXT:%.*]] = zext i16 undef to i32
; CHECK-NEXT: [[A_SROA_3_0_INSERT_SHIFT:%.*]] = shl i32 [[A_SROA_3_0_INSERT_EXT]], 16
; CHECK-NEXT: [[A_SROA_3_0_INSERT_MASK:%.*]] = and i32 undef, 65535
@@ -1892,7 +1681,7 @@ define i32 @PR22093() {
; CHECK-NEXT: [[A_SROA_0_0_INSERT_MASK:%.*]] = and i32 [[A_SROA_3_0_INSERT_INSERT]], -65536
; CHECK-NEXT: [[A_SROA_0_0_INSERT_INSERT:%.*]] = or i32 [[A_SROA_0_0_INSERT_MASK]], [[A_SROA_0_0_INSERT_EXT]]
; CHECK-NEXT: [[A_SROA_0_0_EXTRACT_TRUNC:%.*]] = trunc i32 [[A_SROA_0_0_INSERT_INSERT]] to i16
-; CHECK-NEXT: store i16 [[A_SROA_0_0_EXTRACT_TRUNC]], i16* [[A_SROA_0]], align 4
+; CHECK-NEXT: store i16 [[A_SROA_0_0_EXTRACT_TRUNC]], ptr [[A_SROA_0]], align 4
; CHECK-NEXT: [[A_SROA_3_0_EXTRACT_SHIFT:%.*]] = lshr i32 [[A_SROA_0_0_INSERT_INSERT]], 16
; CHECK-NEXT: [[A_SROA_3_0_EXTRACT_TRUNC:%.*]] = trunc i32 [[A_SROA_3_0_EXTRACT_SHIFT]] to i16
; CHECK-NEXT: ret i32 [[A_SROA_0_0_INSERT_INSERT]]
@@ -1900,10 +1689,9 @@ define i32 @PR22093() {
entry:
%a = alloca i32
- %a.cast = bitcast i32* %a to i16*
- store volatile i16 42, i16* %a.cast
- %load = load i32, i32* %a
- store i32 %load, i32* %a
+ store volatile i16 42, ptr %a
+ %load = load i32, ptr %a
+ store i32 %load, ptr %a
ret i32 %load
}
@@ -1920,8 +1708,8 @@ define void @PR22093.2() {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A_SROA_0:%.*]] = alloca i16, align 8
; CHECK-NEXT: [[A_SROA_31:%.*]] = alloca i8, align 4
-; CHECK-NEXT: store volatile i16 42, i16* [[A_SROA_0]], align 8
-; CHECK-NEXT: [[A_SROA_0_0_A_SROA_0_0_LOAD:%.*]] = load i16, i16* [[A_SROA_0]], align 8
+; CHECK-NEXT: store volatile i16 42, ptr [[A_SROA_0]], align 8
+; CHECK-NEXT: [[A_SROA_0_0_A_SROA_0_0_LOAD:%.*]] = load i16, ptr [[A_SROA_0]], align 8
; CHECK-NEXT: [[A_SROA_3_0_INSERT_EXT:%.*]] = zext i16 undef to i32
; CHECK-NEXT: [[A_SROA_3_0_INSERT_SHIFT:%.*]] = shl i32 [[A_SROA_3_0_INSERT_EXT]], 16
; CHECK-NEXT: [[A_SROA_3_0_INSERT_MASK:%.*]] = and i32 undef, 65535
@@ -1930,12 +1718,12 @@ define void @PR22093.2() {
; CHECK-NEXT: [[A_SROA_0_0_INSERT_MASK:%.*]] = and i32 [[A_SROA_3_0_INSERT_INSERT]], -65536
; CHECK-NEXT: [[A_SROA_0_0_INSERT_INSERT:%.*]] = or i32 [[A_SROA_0_0_INSERT_MASK]], [[A_SROA_0_0_INSERT_EXT]]
; CHECK-NEXT: [[A_SROA_0_0_EXTRACT_TRUNC:%.*]] = trunc i32 [[A_SROA_0_0_INSERT_INSERT]] to i16
-; CHECK-NEXT: store i16 [[A_SROA_0_0_EXTRACT_TRUNC]], i16* [[A_SROA_0]], align 8
+; CHECK-NEXT: store i16 [[A_SROA_0_0_EXTRACT_TRUNC]], ptr [[A_SROA_0]], align 8
; CHECK-NEXT: [[A_SROA_3_0_EXTRACT_SHIFT:%.*]] = lshr i32 [[A_SROA_0_0_INSERT_INSERT]], 16
; CHECK-NEXT: [[A_SROA_3_0_EXTRACT_TRUNC:%.*]] = trunc i32 [[A_SROA_3_0_EXTRACT_SHIFT]] to i16
-; CHECK-NEXT: store volatile i8 13, i8* [[A_SROA_31]], align 4
+; CHECK-NEXT: store volatile i8 13, ptr [[A_SROA_31]], align 4
; CHECK-NEXT: [[A_SROA_31_4_EXTRACT_TRUNC:%.*]] = trunc i32 [[A_SROA_0_0_INSERT_INSERT]] to i8
-; CHECK-NEXT: store i8 [[A_SROA_31_4_EXTRACT_TRUNC]], i8* [[A_SROA_31]], align 4
+; CHECK-NEXT: store i8 [[A_SROA_31_4_EXTRACT_TRUNC]], ptr [[A_SROA_31]], align 4
; CHECK-NEXT: [[A_SROA_5_4_EXTRACT_SHIFT:%.*]] = lshr i32 [[A_SROA_0_0_INSERT_INSERT]], 8
; CHECK-NEXT: [[A_SROA_5_4_EXTRACT_TRUNC:%.*]] = trunc i32 [[A_SROA_5_4_EXTRACT_SHIFT]] to i24
; CHECK-NEXT: ret void
@@ -1943,15 +1731,12 @@ define void @PR22093.2() {
entry:
%a = alloca i64
- %a.cast1 = bitcast i64* %a to i32*
- %a.cast2 = bitcast i64* %a to i16*
- store volatile i16 42, i16* %a.cast2
- %load = load i32, i32* %a.cast1
- store i32 %load, i32* %a.cast1
- %a.gep1 = getelementptr i32, i32* %a.cast1, i32 1
- %a.cast3 = bitcast i32* %a.gep1 to i8*
- store volatile i8 13, i8* %a.cast3
- store i32 %load, i32* %a.gep1
+ store volatile i16 42, ptr %a
+ %load = load i32, ptr %a
+ store i32 %load, ptr %a
+ %a.gep1 = getelementptr i32, ptr %a, i32 1
+ store volatile i8 13, ptr %a.gep1
+ store i32 %load, ptr %a.gep1
ret void
}
@@ -1959,14 +1744,14 @@ define void @PR23737() {
; CHECK-LABEL: @PR23737(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[PTR:%.*]] = alloca i64, align 8
-; CHECK-NEXT: store atomic volatile i64 0, i64* [[PTR]] seq_cst, align 8
-; CHECK-NEXT: [[PTR_0_LOAD:%.*]] = load atomic volatile i64, i64* [[PTR]] seq_cst, align 8
+; CHECK-NEXT: store atomic volatile i64 0, ptr [[PTR]] seq_cst, align 8
+; CHECK-NEXT: [[PTR_0_LOAD:%.*]] = load atomic volatile i64, ptr [[PTR]] seq_cst, align 8
; CHECK-NEXT: ret void
;
entry:
%ptr = alloca i64, align 8
- store atomic volatile i64 0, i64* %ptr seq_cst, align 8
- %load = load atomic volatile i64, i64* %ptr seq_cst, align 8
+ store atomic volatile i64 0, ptr %ptr seq_cst, align 8
+ %load = load atomic volatile i64, ptr %ptr seq_cst, align 8
ret void
}
@@ -1983,28 +1768,24 @@ define i16 @PR24463() {
;
entry:
%alloca = alloca [3 x i8]
- %gep1 = getelementptr inbounds [3 x i8], [3 x i8]* %alloca, i64 0, i64 1
- %bc1 = bitcast i8* %gep1 to i16*
- store i16 0, i16* %bc1
- %gep2 = getelementptr inbounds [3 x i8], [3 x i8]* %alloca, i64 0, i64 2
- %bc2 = bitcast i8* %gep2 to i16*
- %load = load i16, i16* %bc2
+ %gep1 = getelementptr inbounds [3 x i8], ptr %alloca, i64 0, i64 1
+ store i16 0, ptr %gep1
+ %gep2 = getelementptr inbounds [3 x i8], ptr %alloca, i64 0, i64 2
+ %load = load i16, ptr %gep2
ret i16 %load
}
%struct.STest = type { %struct.SPos, %struct.SPos }
%struct.SPos = type { float, float }
-define void @PR25873(%struct.STest* %outData) {
+define void @PR25873(ptr %outData) {
; CHECK-LABEL: @PR25873(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[TMPDATA_SROA_0_0__SROA_CAST1_SROA_CAST:%.*]] = bitcast %struct.STest* [[OUTDATA:%.*]] to i32*
-; CHECK-NEXT: store i32 1123418112, i32* [[TMPDATA_SROA_0_0__SROA_CAST1_SROA_CAST]], align 4
-; CHECK-NEXT: [[TMPDATA_SROA_0_0__SROA_CAST1_SROA_IDX:%.*]] = getelementptr inbounds [[STRUCT_STEST:%.*]], %struct.STest* [[OUTDATA]], i64 0, i32 0, i32 1
-; CHECK-NEXT: [[TMPDATA_SROA_0_0__SROA_CAST1_SROA_CAST16:%.*]] = bitcast float* [[TMPDATA_SROA_0_0__SROA_CAST1_SROA_IDX]] to i32*
-; CHECK-NEXT: store i32 1139015680, i32* [[TMPDATA_SROA_0_0__SROA_CAST1_SROA_CAST16]], align 4
-; CHECK-NEXT: [[TMPDATA_SROA_6_0__SROA_IDX3:%.*]] = getelementptr inbounds [[STRUCT_STEST]], %struct.STest* [[OUTDATA]], i64 0, i32 1
-; CHECK-NEXT: [[TMPDATA_SROA_6_0__SROA_CAST4:%.*]] = bitcast %struct.SPos* [[TMPDATA_SROA_6_0__SROA_IDX3]] to i64*
+; CHECK-NEXT: [[TMP0:%.*]] = bitcast ptr [[OUTDATA:%.*]] to ptr
+; CHECK-NEXT: store i32 1123418112, ptr [[TMP0]], align 4
+; CHECK-NEXT: [[DOTSROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[TMP0]], i64 4
+; CHECK-NEXT: store i32 1139015680, ptr [[DOTSROA_IDX]], align 4
+; CHECK-NEXT: [[TMPDATA_SROA_6_0__SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[TMP0]], i64 8
; CHECK-NEXT: [[TMPDATA_SROA_6_SROA_4_0_INSERT_EXT:%.*]] = zext i32 1139015680 to i64
; CHECK-NEXT: [[TMPDATA_SROA_6_SROA_4_0_INSERT_SHIFT:%.*]] = shl i64 [[TMPDATA_SROA_6_SROA_4_0_INSERT_EXT]], 32
; CHECK-NEXT: [[TMPDATA_SROA_6_SROA_4_0_INSERT_MASK:%.*]] = and i64 undef, 4294967295
@@ -2012,29 +1793,28 @@ define void @PR25873(%struct.STest* %outData) {
; CHECK-NEXT: [[TMPDATA_SROA_6_SROA_0_0_INSERT_EXT:%.*]] = zext i32 1123418112 to i64
; CHECK-NEXT: [[TMPDATA_SROA_6_SROA_0_0_INSERT_MASK:%.*]] = and i64 [[TMPDATA_SROA_6_SROA_4_0_INSERT_INSERT]], -4294967296
; CHECK-NEXT: [[TMPDATA_SROA_6_SROA_0_0_INSERT_INSERT:%.*]] = or i64 [[TMPDATA_SROA_6_SROA_0_0_INSERT_MASK]], [[TMPDATA_SROA_6_SROA_0_0_INSERT_EXT]]
-; CHECK-NEXT: store i64 [[TMPDATA_SROA_6_SROA_0_0_INSERT_INSERT]], i64* [[TMPDATA_SROA_6_0__SROA_CAST4]], align 4
+; CHECK-NEXT: store i64 [[TMPDATA_SROA_6_SROA_0_0_INSERT_INSERT]], ptr [[TMPDATA_SROA_6_0__SROA_IDX]], align 4
; CHECK-NEXT: ret void
;
entry:
%tmpData = alloca %struct.STest, align 8
- %0 = bitcast %struct.STest* %tmpData to i8*
- call void @llvm.lifetime.start.p0i8(i64 16, i8* %0)
- %x = getelementptr inbounds %struct.STest, %struct.STest* %tmpData, i64 0, i32 0, i32 0
- store float 1.230000e+02, float* %x, align 8
- %y = getelementptr inbounds %struct.STest, %struct.STest* %tmpData, i64 0, i32 0, i32 1
- store float 4.560000e+02, float* %y, align 4
- %m_posB = getelementptr inbounds %struct.STest, %struct.STest* %tmpData, i64 0, i32 1
- %1 = bitcast %struct.STest* %tmpData to i64*
- %2 = bitcast %struct.SPos* %m_posB to i64*
- %3 = load i64, i64* %1, align 8
- store i64 %3, i64* %2, align 8
- %4 = bitcast %struct.STest* %outData to i8*
- call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %4, i8* align 4 %0, i64 16, i1 false)
- call void @llvm.lifetime.end.p0i8(i64 16, i8* %0)
+ %0 = bitcast ptr %tmpData to ptr
+ call void @llvm.lifetime.start.p0(i64 16, ptr %0)
+ store float 1.230000e+02, ptr %tmpData, align 8
+ %y = getelementptr inbounds %struct.STest, ptr %tmpData, i64 0, i32 0, i32 1
+ store float 4.560000e+02, ptr %y, align 4
+ %m_posB = getelementptr inbounds %struct.STest, ptr %tmpData, i64 0, i32 1
+ %1 = bitcast ptr %tmpData to ptr
+ %2 = bitcast ptr %m_posB to ptr
+ %3 = load i64, ptr %1, align 8
+ store i64 %3, ptr %2, align 8
+ %4 = bitcast ptr %outData to ptr
+ call void @llvm.memcpy.p0.p0.i64(ptr align 4 %4, ptr align 4 %0, i64 16, i1 false)
+ call void @llvm.lifetime.end.p0(i64 16, ptr %0)
ret void
}
-declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) nounwind
+declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1) nounwind
define void @PR27999() unnamed_addr {
; CHECK-LABEL: @PR27999(
@@ -2043,11 +1823,11 @@ define void @PR27999() unnamed_addr {
;
entry-block:
%0 = alloca [2 x i64], align 8
- %1 = bitcast [2 x i64]* %0 to i8*
- call void @llvm.lifetime.start.p0i8(i64 16, i8* %1)
- %2 = getelementptr inbounds [2 x i64], [2 x i64]* %0, i32 0, i32 1
- %3 = bitcast i64* %2 to i8*
- call void @llvm.lifetime.end.p0i8(i64 8, i8* %3)
+ %1 = bitcast ptr %0 to ptr
+ call void @llvm.lifetime.start.p0(i64 16, ptr %1)
+ %2 = getelementptr inbounds [2 x i64], ptr %0, i32 0, i32 1
+ %3 = bitcast ptr %2 to ptr
+ call void @llvm.lifetime.end.p0(i64 8, ptr %3)
ret void
}
@@ -2058,9 +1838,9 @@ define void @PR29139() {
;
bb1:
%e.7.sroa.6.i = alloca i32, align 1
- %e.7.sroa.6.0.load81.i = load i32, i32* %e.7.sroa.6.i, align 1
- %0 = bitcast i32* %e.7.sroa.6.i to i8*
- call void @llvm.lifetime.end.p0i8(i64 2, i8* %0)
+ %e.7.sroa.6.0.load81.i = load i32, ptr %e.7.sroa.6.i, align 1
+ %0 = bitcast ptr %e.7.sroa.6.i to ptr
+ call void @llvm.lifetime.end.p0(i64 2, ptr %0)
ret void
}
@@ -2077,14 +1857,10 @@ define void @PR35657(i64 %v) {
;
entry:
%a48 = alloca i48
- %a48.cast64 = bitcast i48* %a48 to i64*
- store i64 %v, i64* %a48.cast64
- %a48.cast16 = bitcast i48* %a48 to i16*
- %b0_15 = load i16, i16* %a48.cast16
- %a48.cast8 = bitcast i48* %a48 to i8*
- %a48_offset2 = getelementptr inbounds i8, i8* %a48.cast8, i64 2
- %a48_offset2.cast48 = bitcast i8* %a48_offset2 to i48*
- %b16_63 = load i48, i48* %a48_offset2.cast48, align 2
+ store i64 %v, ptr %a48
+ %b0_15 = load i16, ptr %a48
+ %a48_offset2 = getelementptr inbounds i8, ptr %a48, i64 2
+ %b16_63 = load i48, ptr %a48_offset2, align 2
call void @callee16(i16 %b0_15)
call void @callee48(i48 %b16_63)
ret void
@@ -2107,18 +1883,18 @@ define void @test28(i64 %v) #0 {
entry:
%t = alloca { i64, i32, i32 }
- %b = getelementptr { i64, i32, i32 }, { i64, i32, i32 }* %t, i32 0, i32 1
- %0 = bitcast i32* %b to i64*
- store i64 %v, i64* %0
+ %b = getelementptr { i64, i32, i32 }, ptr %t, i32 0, i32 1
+ %0 = bitcast ptr %b to ptr
+ store i64 %v, ptr %0
- %1 = load i32, i32* %b
- %c = getelementptr { i64, i32, i32 }, { i64, i32, i32 }* %t, i32 0, i32 2
- store i32 %1, i32* %c
+ %1 = load i32, ptr %b
+ %c = getelementptr { i64, i32, i32 }, ptr %t, i32 0, i32 2
+ store i32 %1, ptr %c
ret void
}
-declare void @llvm.lifetime.start.isVoid.i64.p0i8(i64, [10 x float]* nocapture)
-declare void @llvm.lifetime.end.isVoid.i64.p0i8(i64, [10 x float]* nocapture)
+declare void @llvm.lifetime.start.isVoid.i64.p0(i64, ptr nocapture)
+declare void @llvm.lifetime.end.isVoid.i64.p0(i64, ptr nocapture)
@array = dso_local global [10 x float] zeroinitializer, align 4
define void @test29(i32 %num, i32 %tid) {
@@ -2129,8 +1905,8 @@ define void @test29(i32 %num, i32 %tid) {
; CHECK: bb1:
; CHECK-NEXT: [[TOBOOL:%.*]] = icmp eq i32 [[TID:%.*]], 0
; CHECK-NEXT: [[CONV_I:%.*]] = zext i32 [[TID]] to i64
-; CHECK-NEXT: [[ARRAYIDX5:%.*]] = getelementptr inbounds [10 x float], [10 x float]* @array, i64 0, i64 [[CONV_I]]
-; CHECK-NEXT: [[TMP0:%.*]] = bitcast float* [[ARRAYIDX5]] to i32*
+; CHECK-NEXT: [[ARRAYIDX5:%.*]] = getelementptr inbounds [10 x float], ptr @array, i64 0, i64 [[CONV_I]]
+; CHECK-NEXT: [[TMP0:%.*]] = bitcast ptr [[ARRAYIDX5]] to ptr
; CHECK-NEXT: br label [[BB2:%.*]]
; CHECK: bb2:
; CHECK-NEXT: [[I_02:%.*]] = phi i32 [ [[NUM]], [[BB1]] ], [ [[SUB:%.*]], [[BB5:%.*]] ]
@@ -2138,7 +1914,7 @@ define void @test29(i32 %num, i32 %tid) {
; CHECK: bb3:
; CHECK-NEXT: br label [[BB5]]
; CHECK: bb4:
-; CHECK-NEXT: store i32 undef, i32* [[TMP0]], align 4
+; CHECK-NEXT: store i32 undef, ptr [[TMP0]], align 4
; CHECK-NEXT: br label [[BB5]]
; CHECK: bb5:
; CHECK-NEXT: [[SUB]] = add i32 [[I_02]], -1
@@ -2152,7 +1928,7 @@ define void @test29(i32 %num, i32 %tid) {
entry:
%ra = alloca [10 x float], align 4
- call void @llvm.lifetime.start.isVoid.i64.p0i8(i64 40, [10 x float]* nonnull %ra)
+ call void @llvm.lifetime.start.isVoid.i64.p0(i64 40, ptr nonnull %ra)
%cmp1 = icmp sgt i32 %num, 0
br i1 %cmp1, label %bb1, label %bb7
@@ -2160,10 +1936,10 @@ entry:
bb1:
%tobool = icmp eq i32 %tid, 0
%conv.i = zext i32 %tid to i64
- %0 = bitcast [10 x float]* %ra to i32*
- %1 = load i32, i32* %0, align 4
- %arrayidx5 = getelementptr inbounds [10 x float], [10 x float]* @array, i64 0, i64 %conv.i
- %2 = bitcast float* %arrayidx5 to i32*
+ %0 = bitcast ptr %ra to ptr
+ %1 = load i32, ptr %0, align 4
+ %arrayidx5 = getelementptr inbounds [10 x float], ptr @array, i64 0, i64 %conv.i
+ %2 = bitcast ptr %arrayidx5 to ptr
br label %bb2
bb2:
@@ -2174,7 +1950,7 @@ bb3:
br label %bb5
bb4:
- store i32 %1, i32* %2, align 4
+ store i32 %1, ptr %2, align 4
br label %bb5
bb5:
@@ -2186,7 +1962,7 @@ bb6:
br label %bb7
bb7:
- call void @llvm.lifetime.end.isVoid.i64.p0i8(i64 40, [10 x float]* nonnull %ra)
+ call void @llvm.lifetime.end.isVoid.i64.p0(i64 40, ptr nonnull %ra)
ret void
}
diff --git a/llvm/test/Transforms/SROA/big-endian.ll b/llvm/test/Transforms/SROA/big-endian.ll
index 0853f9e9ed4a..30edb896697e 100644
--- a/llvm/test/Transforms/SROA/big-endian.ll
+++ b/llvm/test/Transforms/SROA/big-endian.ll
@@ -15,14 +15,12 @@ entry:
%b = alloca [3 x i8]
; CHECK-NOT: alloca
- %a0ptr = getelementptr [3 x i8], [3 x i8]* %a, i64 0, i32 0
- store i8 0, i8* %a0ptr
- %a1ptr = getelementptr [3 x i8], [3 x i8]* %a, i64 0, i32 1
- store i8 0, i8* %a1ptr
- %a2ptr = getelementptr [3 x i8], [3 x i8]* %a, i64 0, i32 2
- store i8 0, i8* %a2ptr
- %aiptr = bitcast [3 x i8]* %a to i24*
- %ai = load i24, i24* %aiptr
+ store i8 0, ptr %a
+ %a1ptr = getelementptr [3 x i8], ptr %a, i64 0, i32 1
+ store i8 0, ptr %a1ptr
+ %a2ptr = getelementptr [3 x i8], ptr %a, i64 0, i32 2
+ store i8 0, ptr %a2ptr
+ %ai = load i24, ptr %a
; CHECK-NOT: store
; CHECK-NOT: load
; CHECK: %[[ext2:.*]] = zext i8 0 to i24
@@ -37,14 +35,12 @@ entry:
; CHECK-NEXT: %[[mask0:.*]] = and i24 %[[insert1]], 65535
; CHECK-NEXT: %[[insert0:.*]] = or i24 %[[mask0]], %[[shift0]]
- %biptr = bitcast [3 x i8]* %b to i24*
- store i24 %ai, i24* %biptr
- %b0ptr = getelementptr [3 x i8], [3 x i8]* %b, i64 0, i32 0
- %b0 = load i8, i8* %b0ptr
- %b1ptr = getelementptr [3 x i8], [3 x i8]* %b, i64 0, i32 1
- %b1 = load i8, i8* %b1ptr
- %b2ptr = getelementptr [3 x i8], [3 x i8]* %b, i64 0, i32 2
- %b2 = load i8, i8* %b2ptr
+ store i24 %ai, ptr %b
+ %b0 = load i8, ptr %b
+ %b1ptr = getelementptr [3 x i8], ptr %b, i64 0, i32 1
+ %b1 = load i8, ptr %b1ptr
+ %b2ptr = getelementptr [3 x i8], ptr %b, i64 0, i32 2
+ %b2 = load i8, ptr %b2ptr
; CHECK-NOT: store
; CHECK-NOT: load
; CHECK: %[[shift0:.*]] = lshr i24 %[[insert0]], 16
@@ -71,24 +67,20 @@ entry:
%a = alloca [7 x i8]
; CHECK-NOT: alloca
- %a0ptr = getelementptr [7 x i8], [7 x i8]* %a, i64 0, i32 0
- %a1ptr = getelementptr [7 x i8], [7 x i8]* %a, i64 0, i32 1
- %a2ptr = getelementptr [7 x i8], [7 x i8]* %a, i64 0, i32 2
- %a3ptr = getelementptr [7 x i8], [7 x i8]* %a, i64 0, i32 3
+ %a1ptr = getelementptr [7 x i8], ptr %a, i64 0, i32 1
+ %a2ptr = getelementptr [7 x i8], ptr %a, i64 0, i32 2
+ %a3ptr = getelementptr [7 x i8], ptr %a, i64 0, i32 3
; CHECK-NOT: store
; CHECK-NOT: load
- %a0i16ptr = bitcast i8* %a0ptr to i16*
- store i16 1, i16* %a0i16ptr
+ store i16 1, ptr %a
- store i8 1, i8* %a2ptr
+ store i8 1, ptr %a2ptr
- %a3i24ptr = bitcast i8* %a3ptr to i24*
- store i24 1, i24* %a3i24ptr
+ store i24 1, ptr %a3ptr
- %a2i40ptr = bitcast i8* %a2ptr to i40*
- store i40 1, i40* %a2i40ptr
+ store i40 1, ptr %a2ptr
; the alloca is splitted into multiple slices
; Here, i8 1 is for %a[6]
@@ -115,8 +107,7 @@ entry:
; CHECK-NOT: store
; CHECK-NOT: load
- %aiptr = bitcast [7 x i8]* %a to i56*
- %ai = load i56, i56* %aiptr
+ %ai = load i56, ptr %a
%ret = zext i56 %ai to i64
ret i64 %ret
; Here, i16 1 is for %a[0] to %a[1]
@@ -141,25 +132,24 @@ define i64 @PR14132(i1 %flag) {
entry:
%a = alloca i64, align 8
%b = alloca i8, align 8
- %ptr = alloca i64*, align 8
+ %ptr = alloca ptr, align 8
; CHECK-NOT: alloca
- %ptr.cast = bitcast i64** %ptr to i8**
- store i64 0, i64* %a
- store i8 1, i8* %b
- store i64* %a, i64** %ptr
+ store i64 0, ptr %a
+ store i8 1, ptr %b
+ store ptr %a, ptr %ptr
br i1 %flag, label %if.then, label %if.end
if.then:
- store i8* %b, i8** %ptr.cast
+ store ptr %b, ptr %ptr
br label %if.end
; CHECK-NOT: store
; CHECK: %[[ext:.*]] = zext i8 1 to i64
; CHECK: %[[shift:.*]] = shl i64 %[[ext]], 56
if.end:
- %tmp = load i64*, i64** %ptr
- %result = load i64, i64* %tmp
+ %tmp = load ptr, ptr %ptr
+ %result = load i64, ptr %tmp
; CHECK-NOT: load
; CHECK: %[[result:.*]] = phi i64 [ %[[shift]], %if.then ], [ 0, %entry ]
@@ -191,11 +181,9 @@ entry:
%a = alloca { i32, i24 }, align 4
; CHECK-NOT: alloca
- %tmp0 = bitcast { i32, i24 }* %a to i64*
- store i64 34494054408, i64* %tmp0
- %tmp1 = load i64, i64* %tmp0, align 4
- %tmp2 = bitcast { i32, i24 }* %a to i32*
- %tmp3 = load i32, i32* %tmp2, align 4
+ store i64 34494054408, ptr %a
+ %tmp1 = load i64, ptr %a, align 4
+ %tmp3 = load i32, ptr %a, align 4
; CHECK: %[[HI_EXT:.*]] = zext i32 134316040 to i64
; CHECK: %[[HI_INPUT:.*]] = and i64 undef, -4294967296
; CHECK: %[[HI_MERGE:.*]] = or i64 %[[HI_INPUT]], %[[HI_EXT]]
@@ -223,18 +211,14 @@ entry:
%a2 = alloca i64, align 4
; CHECK-NOT: alloca
- store i64 34494054408, i64* %a2
- %tmp0 = bitcast { i32, i24 }* %a to i8*
- %tmp1 = bitcast i64* %a2 to i8*
- call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %tmp0, i8* align 4 %tmp1, i64 8, i1 false)
+ store i64 34494054408, ptr %a2
+ call void @llvm.memcpy.p0.p0.i64(ptr align 4 %a, ptr align 4 %a2, i64 8, i1 false)
; CHECK: %[[LO_SHR:.*]] = lshr i64 34494054408, 32
; CHECK: %[[LO_START:.*]] = trunc i64 %[[LO_SHR]] to i32
; CHECK: %[[HI_START:.*]] = trunc i64 34494054408 to i32
- %tmp2 = bitcast { i32, i24 }* %a to i64*
- %tmp3 = load i64, i64* %tmp2, align 4
- %tmp4 = bitcast { i32, i24 }* %a to i32*
- %tmp5 = load i32, i32* %tmp4, align 4
+ %tmp3 = load i64, ptr %a, align 4
+ %tmp5 = load i32, ptr %a, align 4
; CHECK: %[[HI_EXT:.*]] = zext i32 %[[HI_START]] to i64
; CHECK: %[[HI_INPUT:.*]] = and i64 undef, -4294967296
; CHECK: %[[HI_MERGE:.*]] = or i64 %[[HI_INPUT]], %[[HI_EXT]]
@@ -249,4 +233,4 @@ entry:
; CHECK: ret void
}
-declare void @llvm.memcpy.p0i8.p0i8.i64(i8*, i8*, i64, i1)
+declare void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1)
diff --git a/llvm/test/Transforms/SROA/dbg-addr-diamond.ll b/llvm/test/Transforms/SROA/dbg-addr-diamond.ll
index b665c84cd355..8fa14c6d1019 100644
--- a/llvm/test/Transforms/SROA/dbg-addr-diamond.ll
+++ b/llvm/test/Transforms/SROA/dbg-addr-diamond.ll
@@ -13,33 +13,30 @@ target triple = "x86_64-pc-windows-msvc19.0.24215"
define void @if_else(i32 %cond, i32 %a, i32 %b) !dbg !8 {
entry:
%p = alloca %struct.Pair, align 4
- %0 = bitcast %struct.Pair* %p to i8*, !dbg !25
- call void @llvm.dbg.addr(metadata %struct.Pair* %p, metadata !20, metadata !DIExpression()), !dbg !26
- %x = getelementptr inbounds %struct.Pair, %struct.Pair* %p, i32 0, i32 0, !dbg !27
- store i32 %a, i32* %x, align 4, !dbg !28
- %y = getelementptr inbounds %struct.Pair, %struct.Pair* %p, i32 0, i32 1, !dbg !34
- store i32 %b, i32* %y, align 4, !dbg !35
+ %0 = bitcast ptr %p to ptr, !dbg !25
+ call void @llvm.dbg.addr(metadata ptr %p, metadata !20, metadata !DIExpression()), !dbg !26
+ store i32 %a, ptr %p, align 4, !dbg !28
+ %y = getelementptr inbounds %struct.Pair, ptr %p, i32 0, i32 1, !dbg !34
+ store i32 %b, ptr %y, align 4, !dbg !35
%tobool = icmp ne i32 %cond, 0, !dbg !37
br i1 %tobool, label %if.then, label %if.else, !dbg !39
if.then: ; preds = %entry
- %x1 = getelementptr inbounds %struct.Pair, %struct.Pair* %p, i32 0, i32 0, !dbg !40
- store i32 0, i32* %x1, align 4, !dbg !42
- %y2 = getelementptr inbounds %struct.Pair, %struct.Pair* %p, i32 0, i32 1, !dbg !43
- store i32 %a, i32* %y2, align 4, !dbg !44
+ store i32 0, ptr %p, align 4, !dbg !42
+ %y2 = getelementptr inbounds %struct.Pair, ptr %p, i32 0, i32 1, !dbg !43
+ store i32 %a, ptr %y2, align 4, !dbg !44
br label %if.end, !dbg !45
if.else: ; preds = %entry
- %x3 = getelementptr inbounds %struct.Pair, %struct.Pair* %p, i32 0, i32 0, !dbg !46
- store i32 %b, i32* %x3, align 4, !dbg !48
- %y4 = getelementptr inbounds %struct.Pair, %struct.Pair* %p, i32 0, i32 1, !dbg !49
- store i32 0, i32* %y4, align 4, !dbg !50
+ store i32 %b, ptr %p, align 4, !dbg !48
+ %y4 = getelementptr inbounds %struct.Pair, ptr %p, i32 0, i32 1, !dbg !49
+ store i32 0, ptr %y4, align 4, !dbg !50
br label %if.end
if.end: ; preds = %if.else, %if.then
- %1 = bitcast %struct.Pair* %p to i8*, !dbg !51
- %2 = bitcast %struct.Pair* @pair to i8*, !dbg !51
- call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %2, i8* align 4 %1, i64 8, i1 false), !dbg !51
+ %1 = bitcast ptr %p to ptr, !dbg !51
+ %2 = bitcast ptr @pair to ptr, !dbg !51
+ call void @llvm.memcpy.p0.p0.i64(ptr align 4 %2, ptr align 4 %1, i64 8, i1 false), !dbg !51
ret void
}
@@ -62,7 +59,7 @@ if.end: ; preds = %if.else, %if.then
; CHECK: ![[PVAR]] = !DILocalVariable(name: "p", {{.*}})
; Function Attrs: argmemonly nounwind
-declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1) #2
+declare void @llvm.memcpy.p0.p0.i64(ptr nocapture writeonly, ptr nocapture readonly, i64, i1) #2
; Function Attrs: nounwind readnone speculatable
declare void @llvm.dbg.addr(metadata, metadata, metadata)
diff --git a/llvm/test/Transforms/SROA/dbg-inline.ll b/llvm/test/Transforms/SROA/dbg-inline.ll
index b3b3660f6414..57880ff4afb5 100644
--- a/llvm/test/Transforms/SROA/dbg-inline.ll
+++ b/llvm/test/Transforms/SROA/dbg-inline.ll
@@ -12,18 +12,17 @@ target triple = "x86_64-apple-macosx10.15.0"
define i64 @_Z1g4pair(i64 %p.coerce0, i64 %p.coerce1) #0 !dbg !8 {
entry:
%p = alloca %struct.pair, align 8
- %0 = getelementptr inbounds %struct.pair, %struct.pair* %p, i32 0, i32 0
- store i64 %p.coerce0, i64* %0, align 8
- %1 = getelementptr inbounds %struct.pair, %struct.pair* %p, i32 0, i32 1
- store i64 %p.coerce1, i64* %1, align 8
+ %0 = getelementptr inbounds %struct.pair, ptr %p, i32 0, i32 0
+ store i64 %p.coerce0, ptr %0, align 8
+ %1 = getelementptr inbounds %struct.pair, ptr %p, i32 0, i32 1
+ store i64 %p.coerce1, ptr %1, align 8
; CHECK-DAG: call void @llvm.dbg.value(metadata i64 %p.coerce0, metadata ![[VAR:[0-9]+]], metadata !DIExpression(DW_OP_LLVM_fragment, 0, 64)), !dbg ![[LOC:[0-9]+]]
; CHECK-DAG: call void @llvm.dbg.value(metadata i64 %p.coerce1, metadata ![[VAR]], metadata !DIExpression(DW_OP_LLVM_fragment, 64, 64)), !dbg ![[LOC]]
; CHECK-DAG: call void @llvm.dbg.value(metadata i64 %p.coerce0, metadata ![[INLINED_VAR:[0-9]+]], metadata !DIExpression(DW_OP_LLVM_fragment, 0, 64)), !dbg ![[INLINED_LOC:[0-9]+]]
; CHECK-DAG: call void @llvm.dbg.value(metadata i64 %p.coerce1, metadata ![[INLINED_VAR]], metadata !DIExpression(DW_OP_LLVM_fragment, 64, 64)), !dbg ![[INLINED_LOC]]
- call void @llvm.dbg.declare(metadata %struct.pair* %p, metadata !17, metadata !DIExpression()), !dbg !18
- call void @llvm.dbg.declare(metadata %struct.pair* %p, metadata !21, metadata !DIExpression()), !dbg !23
- %a.i = getelementptr inbounds %struct.pair, %struct.pair* %p, i32 0, i32 0, !dbg !25
- %x2 = load i64, i64* %0, align 8, !dbg !25
+ call void @llvm.dbg.declare(metadata ptr %p, metadata !17, metadata !DIExpression()), !dbg !18
+ call void @llvm.dbg.declare(metadata ptr %p, metadata !21, metadata !DIExpression()), !dbg !23
+ %x2 = load i64, ptr %0, align 8, !dbg !25
ret i64 %x2, !dbg !26
}
@@ -31,7 +30,7 @@ entry:
declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
; Function Attrs: argmemonly nounwind willreturn
-declare void @llvm.memcpy.p0i8.p0i8.i64(i8* noalias nocapture writeonly, i8* noalias nocapture readonly, i64, i1 immarg) #2
+declare void @llvm.memcpy.p0.p0.i64(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i64, i1 immarg) #2
attributes #0 = { noinline ssp uwtable }
attributes #1 = { nounwind readnone speculatable willreturn }
diff --git a/llvm/test/Transforms/SROA/dbg-single-piece.ll b/llvm/test/Transforms/SROA/dbg-single-piece.ll
index ba5b60952079..7e34b300a4af 100644
--- a/llvm/test/Transforms/SROA/dbg-single-piece.ll
+++ b/llvm/test/Transforms/SROA/dbg-single-piece.ll
@@ -8,18 +8,18 @@ declare void @llvm.dbg.declare(metadata, metadata, metadata) #0
define void @_ZL18findInsertLocationPN4llvm17MachineBasicBlockENS_9SlotIndexERNS_13LiveIntervalsE() {
; CHECK-LABEL: @_ZL18findInsertLocationPN4llvm17MachineBasicBlockENS_9SlotIndexERNS_13LiveIntervalsE(
; CHECK-NEXT: entry:
-; CHECK-NEXT: call void @llvm.dbg.value(metadata %foo* poison, metadata [[META3:![0-9]+]], metadata !DIExpression(DW_OP_LLVM_fragment, 64, 64)), !dbg [[DBG8:![0-9]+]]
+; CHECK-NEXT: call void @llvm.dbg.value(metadata ptr poison, metadata [[META3:![0-9]+]], metadata !DIExpression(DW_OP_LLVM_fragment, 64, 64)), !dbg [[DBG8:![0-9]+]]
; CHECK-NEXT: ret void
;
entry:
%retval = alloca %foo, align 8
- call void @llvm.dbg.declare(metadata %foo* %retval, metadata !1, metadata !7), !dbg !8
+ call void @llvm.dbg.declare(metadata ptr %retval, metadata !1, metadata !7), !dbg !8
; Checks that SROA still inserts a bit_piece expression, even if it produces only one piece
; (as long as that piece is smaller than the whole thing)
- %0 = bitcast %foo* %retval to i8*
- %1 = getelementptr inbounds i8, i8* %0, i64 8
- %2 = bitcast i8* %1 to %foo**
- store %foo* poison, %foo** %2, align 8
+ %0 = bitcast ptr %retval to ptr
+ %1 = getelementptr inbounds i8, ptr %0, i64 8
+ %2 = bitcast ptr %1 to ptr
+ store ptr poison, ptr %2, align 8
ret void
}
diff --git a/llvm/test/Transforms/SROA/dead-inst.ll b/llvm/test/Transforms/SROA/dead-inst.ll
index 7f77f90daeef..97e6995588b0 100644
--- a/llvm/test/Transforms/SROA/dead-inst.ll
+++ b/llvm/test/Transforms/SROA/dead-inst.ll
@@ -15,13 +15,13 @@ target triple = "powerpc64le-grtev4-linux-gnu"
%class.b = type { i64 }
-declare void @D(%class.b* sret(%class.b), %class.b* dereferenceable(32)) local_unnamed_addr
+declare void @D(ptr sret(%class.b), ptr dereferenceable(32)) local_unnamed_addr
; Function Attrs: nounwind
-define void @H(%class.b* noalias nocapture readnone, [2 x i64], i8* %ptr, i32 signext %v, i64 %l, i64 %idx, %class.b* nonnull dereferenceable(32) %ptr2) {
+define void @H(ptr noalias nocapture readnone, [2 x i64], ptr %ptr, i32 signext %v, i64 %l, i64 %idx, ptr nonnull dereferenceable(32) %ptr2) {
%3 = alloca %class.b, align 8
%.sroa.0 = alloca i64, align 8
- store i64 0, i64* %.sroa.0, align 8
+ store i64 0, ptr %.sroa.0, align 8
%4 = extractvalue [2 x i64] %1, 1
switch i64 %4, label %6 [
i64 4, label %foo
@@ -29,22 +29,20 @@ define void @H(%class.b* noalias nocapture readnone, [2 x i64], i8* %ptr, i32 si
]
; <label>:5:
- %.sroa.0.0..sroa_cast3 = bitcast i64* %.sroa.0 to i8**
br label %12
; <label>:6:
%7 = icmp ugt i64 %4, 5
- %.sroa.0.0..sroa_cast5 = bitcast i64* %.sroa.0 to i8**
br i1 %7, label %8, label %12
; <label>:8:
- %9 = load i8, i8* inttoptr (i64 4 to i8*), align 4
+ %9 = load i8, ptr inttoptr (i64 4 to ptr), align 4
%10 = icmp eq i8 %9, 47
%11 = select i1 %10, i64 5, i64 4
br label %12
; <label>:12:
- %13 = phi i8** [ %.sroa.0.0..sroa_cast3, %5 ], [ %.sroa.0.0..sroa_cast5, %8 ], [ %.sroa.0.0..sroa_cast5, %6 ]
+ %13 = phi ptr [ %.sroa.0, %5 ], [ %.sroa.0, %8 ], [ %.sroa.0, %6 ]
%14 = phi i64 [ 4, %5 ], [ %11, %8 ], [ 4, %6 ]
%15 = icmp ne i64 %4, 0
%16 = icmp ugt i64 %4, %14
@@ -52,34 +50,34 @@ define void @H(%class.b* noalias nocapture readnone, [2 x i64], i8* %ptr, i32 si
br i1 %17, label %18, label %a.exit
; <label>:18:
- %19 = tail call i8* @memchr(i8* %ptr, i32 signext %v, i64 %l)
- %20 = icmp eq i8* %19, null
+ %19 = tail call ptr @memchr(ptr %ptr, i32 signext %v, i64 %l)
+ %20 = icmp eq ptr %19, null
%21 = sext i1 %20 to i64
br label %a.exit
a.exit:
%22 = phi i64 [ -1, %12 ], [ %21, %18 ]
- %23 = load i8*, i8** %13, align 8
+ %23 = load ptr, ptr %13, align 8
%24 = sub nsw i64 %22, %14
- %25 = bitcast %class.b* %3 to i8*
- call void @llvm.lifetime.start.p0i8(i64 32, i8* nonnull %25)
+ %25 = bitcast ptr %3 to ptr
+ call void @llvm.lifetime.start.p0(i64 32, ptr nonnull %25)
%26 = icmp ult i64 %24, 2
br i1 %26, label %G.exit, label %27
; <label>:27:
- %28 = getelementptr inbounds i8, i8* %23, i64 %idx
- %29 = icmp eq i8* %28, null
+ %28 = getelementptr inbounds i8, ptr %23, i64 %idx
+ %29 = icmp eq ptr %28, null
br i1 %29, label %30, label %31
; <label>:30:
unreachable
; <label>:31:
- call void @D(%class.b* nonnull sret(%class.b) %3, %class.b* nonnull dereferenceable(32) %ptr2)
+ call void @D(ptr nonnull sret(%class.b) %3, ptr nonnull dereferenceable(32) %ptr2)
br label %G.exit
G.exit:
- call void @llvm.lifetime.end.p0i8(i64 32, i8* nonnull %25)
+ call void @llvm.lifetime.end.p0(i64 32, ptr nonnull %25)
br label %foo
foo:
@@ -87,10 +85,10 @@ foo:
}
; Function Attrs: nounwind readonly
-declare i8* @memchr(i8*, i32 signext, i64) local_unnamed_addr
+declare ptr @memchr(ptr, i32 signext, i64) local_unnamed_addr
; Function Attrs: argmemonly nounwind
-declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
+declare void @llvm.lifetime.start.p0(i64, ptr nocapture)
; Function Attrs: argmemonly nounwind
-declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
+declare void @llvm.lifetime.end.p0(i64, ptr nocapture)
diff --git a/llvm/test/Transforms/SROA/fca.ll b/llvm/test/Transforms/SROA/fca.ll
index 6eaebc3732d4..3ffeadd8bf89 100644
--- a/llvm/test/Transforms/SROA/fca.ll
+++ b/llvm/test/Transforms/SROA/fca.ll
@@ -11,14 +11,14 @@ define { i32, i32 } @test0(i32 %x, i32 %y, { i32, i32 } %v) {
entry:
%a = alloca { i32, i32 }
- store { i32, i32 } %v, { i32, i32 }* %a
+ store { i32, i32 } %v, ptr %a
- %gep1 = getelementptr inbounds { i32, i32 }, { i32, i32 }* %a, i32 0, i32 0
- store i32 %x, i32* %gep1
- %gep2 = getelementptr inbounds { i32, i32 }, { i32, i32 }* %a, i32 0, i32 1
- store i32 %y, i32* %gep2
+ %gep1 = getelementptr inbounds { i32, i32 }, ptr %a, i32 0, i32 0
+ store i32 %x, ptr %gep1
+ %gep2 = getelementptr inbounds { i32, i32 }, ptr %a, i32 0, i32 1
+ store i32 %y, ptr %gep2
- %result = load { i32, i32 }, { i32, i32 }* %a
+ %result = load { i32, i32 }, ptr %a
ret { i32, i32 } %result
}
@@ -29,7 +29,7 @@ define { i32, i32 } @test1(i32 %x, i32 %y) {
; CHECK-LABEL: @test1(
; CHECK: alloca
; CHECK: alloca
-; CHECK: load volatile { i32, i32 }, { i32, i32 }*
+; CHECK: load volatile { i32, i32 }, ptr
; CHECK: store volatile { i32, i32 }
; CHECK: ret { i32, i32 }
@@ -37,12 +37,12 @@ entry:
%a = alloca { i32, i32 }
%b = alloca { i32, i32 }
- %gep1 = getelementptr inbounds { i32, i32 }, { i32, i32 }* %a, i32 0, i32 0
- store i32 %x, i32* %gep1
- %gep2 = getelementptr inbounds { i32, i32 }, { i32, i32 }* %a, i32 0, i32 1
- store i32 %y, i32* %gep2
+ %gep1 = getelementptr inbounds { i32, i32 }, ptr %a, i32 0, i32 0
+ store i32 %x, ptr %gep1
+ %gep2 = getelementptr inbounds { i32, i32 }, ptr %a, i32 0, i32 1
+ store i32 %y, ptr %gep2
- %result = load volatile { i32, i32 }, { i32, i32 }* %a
- store volatile { i32, i32 } %result, { i32, i32 }* %b
+ %result = load volatile { i32, i32 }, ptr %a
+ store volatile { i32, i32 } %result, ptr %b
ret { i32, i32 } %result
}
diff --git a/llvm/test/Transforms/SROA/ignore-droppable.ll b/llvm/test/Transforms/SROA/ignore-droppable.ll
index 20df9836a327..e4aaf963a51b 100644
--- a/llvm/test/Transforms/SROA/ignore-droppable.ll
+++ b/llvm/test/Transforms/SROA/ignore-droppable.ll
@@ -2,83 +2,79 @@
; RUN: opt < %s -passes=sroa -S | FileCheck %s
declare void @llvm.assume(i1)
-declare void @llvm.lifetime.start.p0i8(i64 %size, i8* nocapture %ptr)
-declare void @llvm.lifetime.end.p0i8(i64 %size, i8* nocapture %ptr)
+declare void @llvm.lifetime.start.p0(i64 %size, ptr nocapture %ptr)
+declare void @llvm.lifetime.end.p0(i64 %size, ptr nocapture %ptr)
-define void @positive_assume_uses(i32* %arg) {
+define void @positive_assume_uses(ptr %arg) {
; CHECK-LABEL: @positive_assume_uses(
-; CHECK-NEXT: call void @llvm.assume(i1 true) [ "nonnull"(i32* [[ARG:%.*]]), "ignore"(i32* undef, i64 2) ]
-; CHECK-NEXT: call void @llvm.assume(i1 true) [ "ignore"(i32* undef, i64 8), "nonnull"(i32* [[ARG]]) ]
+; CHECK-NEXT: call void @llvm.assume(i1 true) [ "nonnull"(ptr [[ARG:%.*]]), "ignore"(ptr undef, i64 2) ]
+; CHECK-NEXT: call void @llvm.assume(i1 true) [ "ignore"(ptr undef, i64 8), "nonnull"(ptr [[ARG]]) ]
; CHECK-NEXT: ret void
;
%A = alloca i32
- call void @llvm.assume(i1 true) ["nonnull"(i32* %arg), "align"(i32* %A, i64 2)]
- store i32 1, i32* %A
- call void @llvm.assume(i1 true) ["align"(i32* %A, i64 8), "nonnull"(i32* %arg)]
+ call void @llvm.assume(i1 true) ["nonnull"(ptr %arg), "align"(ptr %A, i64 2)]
+ store i32 1, ptr %A
+ call void @llvm.assume(i1 true) ["align"(ptr %A, i64 8), "nonnull"(ptr %arg)]
ret void
}
define void @negative_assume_condition_use() {
; CHECK-LABEL: @negative_assume_condition_use(
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[B:%.*]] = bitcast i32* [[A]] to i8*
-; CHECK-NEXT: [[CND:%.*]] = icmp eq i8* [[B]], null
+; CHECK-NEXT: [[CND:%.*]] = icmp eq ptr [[A]], null
; CHECK-NEXT: call void @llvm.assume(i1 [[CND]])
-; CHECK-NEXT: store i32 1, i32* [[A]], align 4
+; CHECK-NEXT: store i32 1, ptr [[A]], align 4
; CHECK-NEXT: ret void
;
%A = alloca i32
- %B = bitcast i32* %A to i8*
- %cnd = icmp eq i8* %B, null
+ %cnd = icmp eq ptr %A, null
call void @llvm.assume(i1 %cnd)
- store i32 1, i32* %A
+ store i32 1, ptr %A
ret void
}
define void @positive_multiple_assume_uses() {
; CHECK-LABEL: @positive_multiple_assume_uses(
-; CHECK-NEXT: call void @llvm.assume(i1 true) [ "ignore"({ i8, i16 }* undef, i64 8), "ignore"({ i8, i16 }* undef, i64 16) ]
-; CHECK-NEXT: call void @llvm.assume(i1 true) [ "ignore"({ i8, i16 }* undef), "ignore"({ i8, i16 }* undef, i64 2) ]
+; CHECK-NEXT: call void @llvm.assume(i1 true) [ "ignore"(ptr undef, i64 8), "ignore"(ptr undef, i64 16) ]
+; CHECK-NEXT: call void @llvm.assume(i1 true) [ "ignore"(ptr undef), "ignore"(ptr undef, i64 2) ]
; CHECK-NEXT: ret void
;
%A = alloca {i8, i16}
- call void @llvm.assume(i1 true) ["align"({i8, i16}* %A, i64 8), "align"({i8, i16}* %A, i64 16)]
- store {i8, i16} zeroinitializer, {i8, i16}* %A
- call void @llvm.assume(i1 true) ["nonnull"({i8, i16}* %A), "align"({i8, i16}* %A, i64 2)]
+ call void @llvm.assume(i1 true) ["align"(ptr %A, i64 8), "align"(ptr %A, i64 16)]
+ store {i8, i16} zeroinitializer, ptr %A
+ call void @llvm.assume(i1 true) ["nonnull"(ptr %A), "align"(ptr %A, i64 2)]
ret void
}
define void @positive_gep_assume_uses() {
; CHECK-LABEL: @positive_gep_assume_uses(
-; CHECK-NEXT: call void @llvm.assume(i1 true) [ "ignore"(i8* undef, i64 8), "ignore"(i8* undef, i64 16) ]
-; CHECK-NEXT: call void @llvm.assume(i1 true) [ "ignore"(i8* undef), "ignore"(i8* undef, i64 2) ]
+; CHECK-NEXT: call void @llvm.assume(i1 true) [ "ignore"(ptr undef, i64 8), "ignore"(ptr undef, i64 16) ]
+; CHECK-NEXT: call void @llvm.assume(i1 true) [ "ignore"(ptr undef), "ignore"(ptr undef, i64 2) ]
; CHECK-NEXT: ret void
;
%A = alloca {i8, i16}
- %B = getelementptr {i8, i16}, {i8, i16}* %A, i32 0, i32 0
- call void @llvm.lifetime.start.p0i8(i64 2, i8* %B)
- call void @llvm.assume(i1 true) ["align"(i8* %B, i64 8), "align"(i8* %B, i64 16)]
- store {i8, i16} zeroinitializer, {i8, i16}* %A
- call void @llvm.lifetime.end.p0i8(i64 2, i8* %B)
- call void @llvm.assume(i1 true) ["nonnull"(i8* %B), "align"(i8* %B, i64 2)]
+ %B = getelementptr {i8, i16}, ptr %A, i32 0, i32 0
+ call void @llvm.lifetime.start.p0(i64 2, ptr %B)
+ call void @llvm.assume(i1 true) ["align"(ptr %B, i64 8), "align"(ptr %B, i64 16)]
+ store {i8, i16} zeroinitializer, ptr %A
+ call void @llvm.lifetime.end.p0(i64 2, ptr %B)
+ call void @llvm.assume(i1 true) ["nonnull"(ptr %B), "align"(ptr %B, i64 2)]
ret void
}
define void @positive_mixed_assume_uses() {
; CHECK-LABEL: @positive_mixed_assume_uses(
-; CHECK-NEXT: call void @llvm.assume(i1 true) [ "ignore"(i8* undef), "ignore"(i8* undef, i64 8), "ignore"(i8* undef, i64 16) ]
-; CHECK-NEXT: call void @llvm.assume(i1 true) [ "ignore"(i8* undef), "ignore"(i8* undef, i64 2), "ignore"(i8* undef) ]
-; CHECK-NEXT: call void @llvm.assume(i1 true) [ "ignore"(i32* undef), "ignore"(i32* undef, i64 2), "ignore"(i8* undef) ]
+; CHECK-NEXT: call void @llvm.assume(i1 true) [ "ignore"(ptr undef), "ignore"(ptr undef, i64 8), "ignore"(ptr undef, i64 16) ]
+; CHECK-NEXT: call void @llvm.assume(i1 true) [ "ignore"(ptr undef), "ignore"(ptr undef, i64 2), "ignore"(ptr undef) ]
+; CHECK-NEXT: call void @llvm.assume(i1 true) [ "ignore"(ptr undef), "ignore"(ptr undef, i64 2), "ignore"(ptr undef) ]
; CHECK-NEXT: ret void
;
%A = alloca i8
- %B = getelementptr i8, i8* %A, i32 0
- %C = bitcast i8* %A to i32*
- call void @llvm.lifetime.start.p0i8(i64 2, i8* %B)
- call void @llvm.assume(i1 true) ["nonnull"(i8* %B), "align"(i8* %A, i64 8), "align"(i8* %B, i64 16)]
- store i8 1, i8* %A
- call void @llvm.lifetime.end.p0i8(i64 2, i8* %B)
- call void @llvm.assume(i1 true) ["nonnull"(i8* %B), "align"(i8* %A, i64 2), "nonnull"(i8* %A)]
- call void @llvm.assume(i1 true) ["nonnull"(i32* %C), "align"(i32* %C, i64 2), "nonnull"(i8* %A)]
+ call void @llvm.lifetime.start.p0(i64 2, ptr %A)
+ call void @llvm.assume(i1 true) ["nonnull"(ptr %A), "align"(ptr %A, i64 8), "align"(ptr %A, i64 16)]
+ store i8 1, ptr %A
+ call void @llvm.lifetime.end.p0(i64 2, ptr %A)
+ call void @llvm.assume(i1 true) ["nonnull"(ptr %A), "align"(ptr %A, i64 2), "nonnull"(ptr %A)]
+ call void @llvm.assume(i1 true) ["nonnull"(ptr %A), "align"(ptr %A, i64 2), "nonnull"(ptr %A)]
ret void
}
diff --git a/llvm/test/Transforms/SROA/invariant-group.ll b/llvm/test/Transforms/SROA/invariant-group.ll
index a01e91d79668..8d487ebe842b 100644
--- a/llvm/test/Transforms/SROA/invariant-group.ll
+++ b/llvm/test/Transforms/SROA/invariant-group.ll
@@ -3,8 +3,8 @@
%t = type { i32, i32 }
-declare i8* @llvm.launder.invariant.group.p0i8(i8* %a)
-declare i8* @llvm.strip.invariant.group.p0i8(i8* %a)
+declare ptr @llvm.launder.invariant.group.p0(ptr %a)
+declare ptr @llvm.strip.invariant.group.p0(ptr %a)
declare void @h(i32 %a)
declare i32 @somevalue()
@@ -18,20 +18,17 @@ define void @f() {
;
%a = alloca %t
- %a1 = getelementptr inbounds %t, %t* %a, i32 0, i32 0
- %a1_i8 = bitcast i32* %a1 to i8*
- %a1_i8_inv = call i8* @llvm.launder.invariant.group.p0i8(i8* %a1_i8)
- %a1_inv = bitcast i8* %a1_i8_inv to i32*
- %a2 = getelementptr inbounds %t, %t* %a, i32 0, i32 1
+ %a1_i8_inv = call ptr @llvm.launder.invariant.group.p0(ptr %a)
+ %a2 = getelementptr inbounds %t, ptr %a, i32 0, i32 1
%sv1 = call i32 @somevalue()
%sv2 = call i32 @somevalue()
- store i32 %sv1, i32* %a1_inv, !invariant.group !0
- store i32 %sv2, i32* %a2
+ store i32 %sv1, ptr %a1_i8_inv, !invariant.group !0
+ store i32 %sv2, ptr %a2
- %v1 = load i32, i32* %a1_inv, !invariant.group !0
- %v2 = load i32, i32* %a2
+ %v1 = load i32, ptr %a1_i8_inv, !invariant.group !0
+ %v2 = load i32, ptr %a2
call void @h(i32 %v1)
call void @h(i32 %v2)
@@ -42,46 +39,40 @@ define void @f() {
define void @g() {
; CHECK-LABEL: @g(
; CHECK-NEXT: [[A:%.*]] = alloca [[T:%.*]], align 8
-; CHECK-NEXT: [[A1:%.*]] = getelementptr inbounds [[T]], %t* [[A]], i32 0, i32 0
-; CHECK-NEXT: [[A1_I8:%.*]] = bitcast i32* [[A1]] to i8*
-; CHECK-NEXT: [[A1_I8_INV:%.*]] = call i8* @llvm.launder.invariant.group.p0i8(i8* [[A1_I8]])
-; CHECK-NEXT: [[A1_INV:%.*]] = bitcast i8* [[A1_I8_INV]] to i32*
-; CHECK-NEXT: [[A2:%.*]] = getelementptr inbounds [[T]], %t* [[A]], i32 0, i32 1
+; CHECK-NEXT: [[A1_I8_INV:%.*]] = call ptr @llvm.launder.invariant.group.p0(ptr [[A]])
+; CHECK-NEXT: [[A2:%.*]] = getelementptr inbounds [[T]], ptr [[A]], i32 0, i32 1
; CHECK-NEXT: [[SV1:%.*]] = call i32 @somevalue()
; CHECK-NEXT: [[SV2:%.*]] = call i32 @somevalue()
-; CHECK-NEXT: store i32 [[SV1]], i32* [[A1_INV]], align 4, !invariant.group !0
-; CHECK-NEXT: store i32 [[SV2]], i32* [[A2]], align 4
-; CHECK-NEXT: [[V1:%.*]] = load i32, i32* [[A1_INV]], align 4, !invariant.group !0
-; CHECK-NEXT: [[V2:%.*]] = load i32, i32* [[A2]], align 4
+; CHECK-NEXT: store i32 [[SV1]], ptr [[A1_I8_INV]], align 4, !invariant.group !0
+; CHECK-NEXT: store i32 [[SV2]], ptr [[A2]], align 4
+; CHECK-NEXT: [[V1:%.*]] = load i32, ptr [[A1_I8_INV]], align 4, !invariant.group !0
+; CHECK-NEXT: [[V2:%.*]] = load i32, ptr [[A2]], align 4
; CHECK-NEXT: call void @h(i32 [[V1]])
; CHECK-NEXT: call void @h(i32 [[V2]])
-; CHECK-NEXT: [[A1_STRIPPED:%.*]] = call i8* @llvm.strip.invariant.group.p0i8(i8* [[A1_I8]])
-; CHECK-NEXT: [[A1_INT:%.*]] = ptrtoint i8* [[A1_STRIPPED]] to i32
+; CHECK-NEXT: [[A1_STRIPPED:%.*]] = call ptr @llvm.strip.invariant.group.p0(ptr [[A]])
+; CHECK-NEXT: [[A1_INT:%.*]] = ptrtoint ptr [[A1_STRIPPED]] to i32
; CHECK-NEXT: call void @h(i32 [[A1_INT]])
; CHECK-NEXT: ret void
;
%a = alloca %t
- %a1 = getelementptr inbounds %t, %t* %a, i32 0, i32 0
- %a1_i8 = bitcast i32* %a1 to i8*
- %a1_i8_inv = call i8* @llvm.launder.invariant.group.p0i8(i8* %a1_i8)
- %a1_inv = bitcast i8* %a1_i8_inv to i32*
- %a2 = getelementptr inbounds %t, %t* %a, i32 0, i32 1
+ %a1_i8_inv = call ptr @llvm.launder.invariant.group.p0(ptr %a)
+ %a2 = getelementptr inbounds %t, ptr %a, i32 0, i32 1
%sv1 = call i32 @somevalue()
%sv2 = call i32 @somevalue()
- store i32 %sv1, i32* %a1_inv, !invariant.group !0
- store i32 %sv2, i32* %a2
+ store i32 %sv1, ptr %a1_i8_inv, !invariant.group !0
+ store i32 %sv2, ptr %a2
- %v1 = load i32, i32* %a1_inv, !invariant.group !0
- %v2 = load i32, i32* %a2
+ %v1 = load i32, ptr %a1_i8_inv, !invariant.group !0
+ %v2 = load i32, ptr %a2
call void @h(i32 %v1)
call void @h(i32 %v2)
- %a1_stripped = call i8* @llvm.strip.invariant.group.p0i8(i8* %a1_i8)
- %a1_int = ptrtoint i8* %a1_stripped to i32
+ %a1_stripped = call ptr @llvm.strip.invariant.group.p0(ptr %a)
+ %a1_int = ptrtoint ptr %a1_stripped to i32
call void @h(i32 %a1_int)
ret void
diff --git a/llvm/test/Transforms/SROA/irregular-type.ll b/llvm/test/Transforms/SROA/irregular-type.ll
index 82a3ecdcc7a9..d32ff51aec13 100644
--- a/llvm/test/Transforms/SROA/irregular-type.ll
+++ b/llvm/test/Transforms/SROA/irregular-type.ll
@@ -10,18 +10,17 @@ define i8 @foo(i23 %0) {
; CHECK-LABEL: @foo(
; CHECK-NEXT: Entry:
; CHECK-NEXT: [[DOTSROA_0:%.*]] = alloca [3 x i8], align 8
-; CHECK-NEXT: [[DOTSROA_0_0__SROA_CAST1:%.*]] = bitcast [3 x i8]* [[DOTSROA_0]] to i23*
-; CHECK-NEXT: store i23 [[TMP0:%.*]], i23* [[DOTSROA_0_0__SROA_CAST1]], align 8
-; CHECK-NEXT: [[DOTSROA_0_1__SROA_IDX2:%.*]] = getelementptr inbounds [3 x i8], [3 x i8]* [[DOTSROA_0]], i64 0, i64 1
-; CHECK-NEXT: [[DOTSROA_0_1__SROA_0_1_:%.*]] = load i8, i8* [[DOTSROA_0_1__SROA_IDX2]], align 1
+; CHECK-NEXT: store i23 [[TMP0:%.*]], ptr [[DOTSROA_0]], align 8
+; CHECK-NEXT: [[DOTSROA_0_1__SROA_IDX1:%.*]] = getelementptr inbounds i8, ptr [[DOTSROA_0]], i64 1
+; CHECK-NEXT: [[DOTSROA_0_1__SROA_0_1_:%.*]] = load i8, ptr [[DOTSROA_0_1__SROA_IDX1]], align 1
; CHECK-NEXT: ret i8 [[DOTSROA_0_1__SROA_0_1_]]
;
Entry:
%1 = alloca %S
- %2 = bitcast %S* %1 to i23*
- store i23 %0, i23* %2
- %3 = getelementptr inbounds %S, %S* %1, i64 0, i32 0, i32 1
- %4 = load i8, i8* %3
+ %2 = bitcast ptr %1 to ptr
+ store i23 %0, ptr %2
+ %3 = getelementptr inbounds %S, ptr %1, i64 0, i32 0, i32 1
+ %4 = load i8, ptr %3
ret i8 %4
}
@@ -29,20 +28,17 @@ define i32 @bar(i16 %0) {
; CHECK-LABEL: @bar(
; CHECK-NEXT: Entry:
; CHECK-NEXT: [[DOTSROA_0:%.*]] = alloca [3 x i8], align 8
-; CHECK-NEXT: [[DOTSROA_0_0__SROA_CAST2:%.*]] = bitcast [3 x i8]* [[DOTSROA_0]] to i16*
-; CHECK-NEXT: store i16 [[TMP0:%.*]], i16* [[DOTSROA_0_0__SROA_CAST2]], align 8
-; CHECK-NEXT: [[DOTSROA_0_0_Q_SROA_CAST1:%.*]] = bitcast [3 x i8]* [[DOTSROA_0]] to i17*
-; CHECK-NEXT: [[DOTSROA_0_0__SROA_0_0_:%.*]] = load i17, i17* [[DOTSROA_0_0_Q_SROA_CAST1]], align 8
+; CHECK-NEXT: store i16 [[TMP0:%.*]], ptr [[DOTSROA_0]], align 8
+; CHECK-NEXT: [[DOTSROA_0_0__SROA_0_0_:%.*]] = load i17, ptr [[DOTSROA_0]], align 8
; CHECK-NEXT: [[TMP1:%.*]] = zext i17 [[DOTSROA_0_0__SROA_0_0_]] to i32
; CHECK-NEXT: ret i32 [[TMP1]]
;
Entry:
%1 = alloca %S
- %2 = bitcast %S* %1 to i16*
- store i16 %0, i16* %2
- %3 = getelementptr inbounds %S, %S* %1, i64 0, i32 0
- %q = bitcast [4 x i8]* %3 to i17*
- %4 = load i17, i17* %q
+ %2 = bitcast ptr %1 to ptr
+ store i16 %0, ptr %2
+ %3 = getelementptr inbounds %S, ptr %1, i64 0, i32 0
+ %4 = load i17, ptr %3
%5 = zext i17 %4 to i32
ret i32 %5
}
diff --git a/llvm/test/Transforms/SROA/lifetime-intrinsic.ll b/llvm/test/Transforms/SROA/lifetime-intrinsic.ll
index 97137a9d4de4..68cfd3c787d0 100644
--- a/llvm/test/Transforms/SROA/lifetime-intrinsic.ll
+++ b/llvm/test/Transforms/SROA/lifetime-intrinsic.ll
@@ -17,18 +17,14 @@ define i16 @with_lifetime(i32 %a, i32 %b) #0 {
; CHECK-NEXT: ret i16 [[RET]]
;
%arr = alloca %i32x2, align 4
- %p = bitcast %i32x2* %arr to i8*
- call void @llvm.lifetime.start.p0i8(i64 8, i8* %p)
- %p0 = getelementptr inbounds %i32x2, %i32x2* %arr, i64 0, i32 0, i32 0
- %p1 = getelementptr inbounds %i32x2, %i32x2* %arr, i64 0, i32 0, i32 1
- store i32 %a, i32* %p0, align 4
- store i32 %b, i32* %p1, align 4
- %p0_i16 = bitcast %i32x2* %arr to i16*
- %s0 = load i16, i16* %p0_i16, align 4
- %p1_i16 = bitcast i32* %p1 to i16*
- %s2 = load i16, i16* %p1_i16, align 4
+ call void @llvm.lifetime.start.p0(i64 8, ptr %arr)
+ %p1 = getelementptr inbounds %i32x2, ptr %arr, i64 0, i32 0, i32 1
+ store i32 %a, ptr %arr, align 4
+ store i32 %b, ptr %p1, align 4
+ %s0 = load i16, ptr %arr, align 4
+ %s2 = load i16, ptr %p1, align 4
%ret = add i16 %s0, %s2
- call void @llvm.lifetime.end.p0i8(i64 8, i8* %p)
+ call void @llvm.lifetime.end.p0(i64 8, ptr %arr)
ret i16 %ret
}
@@ -44,21 +40,18 @@ define i16 @no_lifetime(i32 %a, i32 %b) #0 {
; CHECK-NEXT: ret i16 [[RET]]
;
%arr = alloca %i32x2, align 4
- %p0 = getelementptr inbounds %i32x2, %i32x2* %arr, i64 0, i32 0, i32 0
- %p1 = getelementptr inbounds %i32x2, %i32x2* %arr, i64 0, i32 0, i32 1
- store i32 %a, i32* %p0, align 4
- store i32 %b, i32* %p1, align 4
- %p0_i16 = bitcast %i32x2* %arr to i16*
- %s0 = load i16, i16* %p0_i16, align 4
- %p1_i16 = bitcast i32* %p1 to i16*
- %s2 = load i16, i16* %p1_i16, align 4
+ %p1 = getelementptr inbounds %i32x2, ptr %arr, i64 0, i32 0, i32 1
+ store i32 %a, ptr %arr, align 4
+ store i32 %b, ptr %p1, align 4
+ %s0 = load i16, ptr %arr, align 4
+ %s2 = load i16, ptr %p1, align 4
%ret = add i16 %s0, %s2
ret i16 %ret
}
-declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
+declare void @llvm.lifetime.start.p0(i64, ptr nocapture) #1
-declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
+declare void @llvm.lifetime.end.p0(i64, ptr nocapture) #1
attributes #0 = { alwaysinline nounwind }
attributes #1 = { argmemonly nounwind }
diff --git a/llvm/test/Transforms/SROA/mem-par-metadata-sroa-cast.ll b/llvm/test/Transforms/SROA/mem-par-metadata-sroa-cast.ll
index 4a2d7307540a..9adb896a165c 100644
--- a/llvm/test/Transforms/SROA/mem-par-metadata-sroa-cast.ll
+++ b/llvm/test/Transforms/SROA/mem-par-metadata-sroa-cast.ll
@@ -5,8 +5,8 @@
; Ensure this is done for casting too.
;
; CHECK: entry:
-; CHECK: load i32, i32* {{.*}}, !llvm.access.group [[DISTINCT:![0-9]*]]
-; CHECK: load i32, i32* {{.*}}, !llvm.access.group [[DISTINCT]]
+; CHECK: load i32, ptr {{.*}}, !llvm.access.group [[DISTINCT:![0-9]*]]
+; CHECK: load i32, ptr {{.*}}, !llvm.access.group [[DISTINCT]]
; CHECK: ret void
; CHECK: [[DISTINCT]] = distinct !{}
@@ -16,16 +16,13 @@ define dso_local void @test() {
entry:
%PART = alloca %CMPLX, align 8
%PREV = alloca %CMPLX, align 8
- %r2 = getelementptr %CMPLX, %CMPLX* %PREV, i32 0, i32 0
- store float 0.000000e+00, float* %r2, align 4
- %i2 = getelementptr %CMPLX, %CMPLX* %PREV, i32 0, i32 1
- store float 0.000000e+00, float* %i2, align 4
+ store float 0.000000e+00, ptr %PREV, align 4
+ %i2 = getelementptr %CMPLX, ptr %PREV, i32 0, i32 1
+ store float 0.000000e+00, ptr %i2, align 4
%dummy = sext i16 0 to i64
- %T = getelementptr %CMPLX, %CMPLX* %PART, i64 %dummy
- %X35 = bitcast %CMPLX* %T to i64*
- %X36 = bitcast %CMPLX* %PREV to i64*
- %X37 = load i64, i64* %X35, align 8, !llvm.access.group !0
- store i64 %X37, i64* %X36, align 8
+ %T = getelementptr %CMPLX, ptr %PART, i64 %dummy
+ %X37 = load i64, ptr %T, align 8, !llvm.access.group !0
+ store i64 %X37, ptr %PREV, align 8
ret void
}
diff --git a/llvm/test/Transforms/SROA/mem-par-metadata-sroa.ll b/llvm/test/Transforms/SROA/mem-par-metadata-sroa.ll
index 95814d841eb5..872aa89e48aa 100644
--- a/llvm/test/Transforms/SROA/mem-par-metadata-sroa.ll
+++ b/llvm/test/Transforms/SROA/mem-par-metadata-sroa.ll
@@ -32,11 +32,11 @@
; }
; CHECK: for.body:
-; CHECK-NOT: store i32 %{{.*}}, i32* %{{.*}}, align 4
-; CHECK: store i32 %{{.*}}, i32* %{{.*}}, align 4, !llvm.access.group !1
-; CHECK-NOT: store i32 %{{.*}}, i32* %{{.*}}, align 4
-; CHECK: store i32 %{{.*}}, i32* %{{.*}}, align 4, !llvm.access.group !1
-; CHECK-NOT: store i32 %{{.*}}, i32* %{{.*}}, align 4
+; CHECK-NOT: store i32 %{{.*}}, ptr %{{.*}}, align 4
+; CHECK: store i32 %{{.*}}, ptr %{{.*}}, align 4, !llvm.access.group !1
+; CHECK-NOT: store i32 %{{.*}}, ptr %{{.*}}, align 4
+; CHECK: store i32 %{{.*}}, ptr %{{.*}}, align 4, !llvm.access.group !1
+; CHECK-NOT: store i32 %{{.*}}, ptr %{{.*}}, align 4
; CHECK: br label
; ModuleID = '<stdin>'
@@ -47,11 +47,10 @@ target triple = "x86_64-unknown-linux-gnu"
%class.Complex = type { float, float }
; Function Attrs: norecurse nounwind uwtable
-define void @_Z4testP7Complexl(%class.Complex* nocapture %out, i64 %size) local_unnamed_addr #0 {
+define void @_Z4testP7Complexl(ptr nocapture %out, i64 %size) local_unnamed_addr #0 {
entry:
%t0 = alloca %class.Complex, align 4
%ref.tmp = alloca i64, align 8
- %tmpcast = bitcast i64* %ref.tmp to %class.Complex*
br label %for.cond
for.cond: ; preds = %for.body, %entry
@@ -60,33 +59,28 @@ for.cond: ; preds = %for.body, %entry
br i1 %cmp, label %for.body, label %for.end
for.body: ; preds = %for.cond
- %arrayidx = getelementptr inbounds %class.Complex, %class.Complex* %out, i64 %offset.0
- %real_.i = getelementptr inbounds %class.Complex, %class.Complex* %t0, i64 0, i32 0
- %real_.i.i = getelementptr inbounds %class.Complex, %class.Complex* %arrayidx, i64 0, i32 0
- %0 = load float, float* %real_.i.i, align 4, !llvm.access.group !11
- store float %0, float* %real_.i, align 4, !llvm.access.group !11
- %imaginary_.i = getelementptr inbounds %class.Complex, %class.Complex* %t0, i64 0, i32 1
- %imaginary_.i.i = getelementptr inbounds %class.Complex, %class.Complex* %arrayidx, i64 0, i32 1
- %1 = load float, float* %imaginary_.i.i, align 4, !llvm.access.group !11
- store float %1, float* %imaginary_.i, align 4, !llvm.access.group !11
- %arrayidx1 = getelementptr inbounds %class.Complex, %class.Complex* %out, i64 %offset.0
- %real_.i1 = getelementptr inbounds %class.Complex, %class.Complex* %t0, i64 0, i32 0
- %2 = load float, float* %real_.i1, align 4, !noalias !3, !llvm.access.group !11
- %real_2.i = getelementptr inbounds %class.Complex, %class.Complex* %t0, i64 0, i32 0
- %3 = load float, float* %real_2.i, align 4, !noalias !3, !llvm.access.group !11
+ %arrayidx = getelementptr inbounds %class.Complex, ptr %out, i64 %offset.0
+ %0 = load float, ptr %arrayidx, align 4, !llvm.access.group !11
+ store float %0, ptr %t0, align 4, !llvm.access.group !11
+ %imaginary_.i = getelementptr inbounds %class.Complex, ptr %t0, i64 0, i32 1
+ %imaginary_.i.i = getelementptr inbounds %class.Complex, ptr %arrayidx, i64 0, i32 1
+ %1 = load float, ptr %imaginary_.i.i, align 4, !llvm.access.group !11
+ store float %1, ptr %imaginary_.i, align 4, !llvm.access.group !11
+ %arrayidx1 = getelementptr inbounds %class.Complex, ptr %out, i64 %offset.0
+ %2 = load float, ptr %t0, align 4, !noalias !3, !llvm.access.group !11
+ %3 = load float, ptr %t0, align 4, !noalias !3, !llvm.access.group !11
%add.i = fadd float %2, %3
- %imaginary_.i2 = getelementptr inbounds %class.Complex, %class.Complex* %t0, i64 0, i32 1
- %4 = load float, float* %imaginary_.i2, align 4, !noalias !3, !llvm.access.group !11
- %imaginary_3.i = getelementptr inbounds %class.Complex, %class.Complex* %t0, i64 0, i32 1
- %5 = load float, float* %imaginary_3.i, align 4, !noalias !3, !llvm.access.group !11
+ %imaginary_.i2 = getelementptr inbounds %class.Complex, ptr %t0, i64 0, i32 1
+ %4 = load float, ptr %imaginary_.i2, align 4, !noalias !3, !llvm.access.group !11
+ %imaginary_3.i = getelementptr inbounds %class.Complex, ptr %t0, i64 0, i32 1
+ %5 = load float, ptr %imaginary_3.i, align 4, !noalias !3, !llvm.access.group !11
%add4.i = fadd float %4, %5
- %real_.i.i3 = getelementptr inbounds %class.Complex, %class.Complex* %tmpcast, i64 0, i32 0
- store float %add.i, float* %real_.i.i3, align 4, !alias.scope !3, !llvm.access.group !11
- %imaginary_.i.i4 = getelementptr inbounds %class.Complex, %class.Complex* %tmpcast, i64 0, i32 1
- store float %add4.i, float* %imaginary_.i.i4, align 4, !alias.scope !3, !llvm.access.group !11
- %6 = bitcast %class.Complex* %arrayidx1 to i64*
- %7 = load i64, i64* %ref.tmp, align 8, !llvm.access.group !11
- store i64 %7, i64* %6, align 4, !llvm.access.group !11
+ store float %add.i, ptr %ref.tmp, align 4, !alias.scope !3, !llvm.access.group !11
+ %imaginary_.i.i4 = getelementptr inbounds %class.Complex, ptr %ref.tmp, i64 0, i32 1
+ store float %add4.i, ptr %imaginary_.i.i4, align 4, !alias.scope !3, !llvm.access.group !11
+ %6 = bitcast ptr %arrayidx1 to ptr
+ %7 = load i64, ptr %ref.tmp, align 8, !llvm.access.group !11
+ store i64 %7, ptr %6, align 4, !llvm.access.group !11
%inc = add nsw i64 %offset.0, 1
br label %for.cond, !llvm.loop !1
@@ -95,7 +89,7 @@ for.end: ; preds = %for.cond
}
; Function Attrs: argmemonly nounwind
-declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1) #1
+declare void @llvm.memcpy.p0.p0.i64(ptr nocapture writeonly, ptr nocapture readonly, i64, i1) #1
attributes #0 = { norecurse nounwind uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="all" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { argmemonly nounwind }
diff --git a/llvm/test/Transforms/SROA/non-capturing-call-readonly.ll b/llvm/test/Transforms/SROA/non-capturing-call-readonly.ll
index da89cbf2eb95..a184399febb8 100644
--- a/llvm/test/Transforms/SROA/non-capturing-call-readonly.ll
+++ b/llvm/test/Transforms/SROA/non-capturing-call-readonly.ll
@@ -2,25 +2,25 @@
; RUN: opt < %s -passes=sroa -S | FileCheck %s --check-prefix=CHECK
; RUN: opt < %s -passes=sroa -opaque-pointers -S | FileCheck %s --check-prefix=CHECK-OPAQUE
-define i32 @alloca_used_in_call(i32* %data, i64 %n) {
+define i32 @alloca_used_in_call(ptr %data, i64 %n) {
; CHECK-LABEL: @alloca_used_in_call(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[RETVAL:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 0, i32* [[RETVAL]], align 4
+; CHECK-NEXT: store i32 0, ptr [[RETVAL]], align 4
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[LOOP]] ]
-; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[DATA:%.*]], i64 [[INDVARS_IV]]
-; CHECK-NEXT: [[LD:%.*]] = load i32, i32* [[ARRAYIDX]], align 4
-; CHECK-NEXT: [[RDX:%.*]] = load i32, i32* [[RETVAL]], align 4
+; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[DATA:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT: [[LD:%.*]] = load i32, ptr [[ARRAYIDX]], align 4
+; CHECK-NEXT: [[RDX:%.*]] = load i32, ptr [[RETVAL]], align 4
; CHECK-NEXT: [[RDX_INC:%.*]] = add nsw i32 [[RDX]], [[LD]]
-; CHECK-NEXT: store i32 [[RDX_INC]], i32* [[RETVAL]], align 4
+; CHECK-NEXT: store i32 [[RDX_INC]], ptr [[RETVAL]], align 4
; CHECK-NEXT: [[INDVARS_IV_NEXT]] = add nsw i64 [[INDVARS_IV]], 1
; CHECK-NEXT: [[EXITCOND:%.*]] = icmp ne i64 [[INDVARS_IV_NEXT]], [[N:%.*]]
; CHECK-NEXT: br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT:%.*]]
; CHECK: exit:
-; CHECK-NEXT: [[I0:%.*]] = call i32 @user_of_alloca(i32* [[RETVAL]])
-; CHECK-NEXT: [[I1:%.*]] = load i32, i32* [[RETVAL]], align 4
+; CHECK-NEXT: [[I0:%.*]] = call i32 @user_of_alloca(ptr [[RETVAL]])
+; CHECK-NEXT: [[I1:%.*]] = load i32, ptr [[RETVAL]], align 4
; CHECK-NEXT: ret i32 [[I1]]
;
; CHECK-OPAQUE-LABEL: @alloca_used_in_call(
@@ -45,45 +45,45 @@ define i32 @alloca_used_in_call(i32* %data, i64 %n) {
;
entry:
%retval = alloca i32, align 4
- store i32 0, i32* %retval, align 4
+ store i32 0, ptr %retval, align 4
br label %loop
loop:
%indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %loop ]
- %arrayidx = getelementptr inbounds i32, i32* %data, i64 %indvars.iv
- %ld = load i32, i32* %arrayidx, align 4
- %rdx = load i32, i32* %retval, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %data, i64 %indvars.iv
+ %ld = load i32, ptr %arrayidx, align 4
+ %rdx = load i32, ptr %retval, align 4
%rdx.inc = add nsw i32 %rdx, %ld
- store i32 %rdx.inc, i32* %retval, align 4
+ store i32 %rdx.inc, ptr %retval, align 4
%indvars.iv.next = add nsw i64 %indvars.iv, 1
%exitcond = icmp ne i64 %indvars.iv.next, %n
br i1 %exitcond, label %loop, label %exit
exit:
- %i0 = call i32 @user_of_alloca(i32* %retval)
- %i1 = load i32, i32* %retval, align 4
+ %i0 = call i32 @user_of_alloca(ptr %retval)
+ %i1 = load i32, ptr %retval, align 4
ret i32 %i1
}
-define i32 @alloca_captured_in_call(i32* %data, i64 %n) {
+define i32 @alloca_captured_in_call(ptr %data, i64 %n) {
; CHECK-LABEL: @alloca_captured_in_call(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[RETVAL:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 0, i32* [[RETVAL]], align 4
+; CHECK-NEXT: store i32 0, ptr [[RETVAL]], align 4
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[LOOP]] ]
-; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[DATA:%.*]], i64 [[INDVARS_IV]]
-; CHECK-NEXT: [[LD:%.*]] = load i32, i32* [[ARRAYIDX]], align 4
-; CHECK-NEXT: [[RDX:%.*]] = load i32, i32* [[RETVAL]], align 4
+; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[DATA:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT: [[LD:%.*]] = load i32, ptr [[ARRAYIDX]], align 4
+; CHECK-NEXT: [[RDX:%.*]] = load i32, ptr [[RETVAL]], align 4
; CHECK-NEXT: [[RDX_INC:%.*]] = add nsw i32 [[RDX]], [[LD]]
-; CHECK-NEXT: store i32 [[RDX_INC]], i32* [[RETVAL]], align 4
+; CHECK-NEXT: store i32 [[RDX_INC]], ptr [[RETVAL]], align 4
; CHECK-NEXT: [[INDVARS_IV_NEXT]] = add nsw i64 [[INDVARS_IV]], 1
; CHECK-NEXT: [[EXITCOND:%.*]] = icmp ne i64 [[INDVARS_IV_NEXT]], [[N:%.*]]
; CHECK-NEXT: br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT:%.*]]
; CHECK: exit:
-; CHECK-NEXT: [[I0:%.*]] = call i32 @capture_of_alloca(i32* [[RETVAL]])
-; CHECK-NEXT: [[I1:%.*]] = load i32, i32* [[RETVAL]], align 4
+; CHECK-NEXT: [[I0:%.*]] = call i32 @capture_of_alloca(ptr [[RETVAL]])
+; CHECK-NEXT: [[I1:%.*]] = load i32, ptr [[RETVAL]], align 4
; CHECK-NEXT: ret i32 [[I1]]
;
; CHECK-OPAQUE-LABEL: @alloca_captured_in_call(
@@ -108,45 +108,45 @@ define i32 @alloca_captured_in_call(i32* %data, i64 %n) {
;
entry:
%retval = alloca i32, align 4
- store i32 0, i32* %retval, align 4
+ store i32 0, ptr %retval, align 4
br label %loop
loop:
%indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %loop ]
- %arrayidx = getelementptr inbounds i32, i32* %data, i64 %indvars.iv
- %ld = load i32, i32* %arrayidx, align 4
- %rdx = load i32, i32* %retval, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %data, i64 %indvars.iv
+ %ld = load i32, ptr %arrayidx, align 4
+ %rdx = load i32, ptr %retval, align 4
%rdx.inc = add nsw i32 %rdx, %ld
- store i32 %rdx.inc, i32* %retval, align 4
+ store i32 %rdx.inc, ptr %retval, align 4
%indvars.iv.next = add nsw i64 %indvars.iv, 1
%exitcond = icmp ne i64 %indvars.iv.next, %n
br i1 %exitcond, label %loop, label %exit
exit:
- %i0 = call i32 @capture_of_alloca(i32* %retval)
- %i1 = load i32, i32* %retval, align 4
+ %i0 = call i32 @capture_of_alloca(ptr %retval)
+ %i1 = load i32, ptr %retval, align 4
ret i32 %i1
}
-define i32 @alloca_not_captured_as_per_operand_attr(i32* %data, i64 %n) {
+define i32 @alloca_not_captured_as_per_operand_attr(ptr %data, i64 %n) {
; CHECK-LABEL: @alloca_not_captured_as_per_operand_attr(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[RETVAL:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 0, i32* [[RETVAL]], align 4
+; CHECK-NEXT: store i32 0, ptr [[RETVAL]], align 4
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[LOOP]] ]
-; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[DATA:%.*]], i64 [[INDVARS_IV]]
-; CHECK-NEXT: [[LD:%.*]] = load i32, i32* [[ARRAYIDX]], align 4
-; CHECK-NEXT: [[RDX:%.*]] = load i32, i32* [[RETVAL]], align 4
+; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[DATA:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT: [[LD:%.*]] = load i32, ptr [[ARRAYIDX]], align 4
+; CHECK-NEXT: [[RDX:%.*]] = load i32, ptr [[RETVAL]], align 4
; CHECK-NEXT: [[RDX_INC:%.*]] = add nsw i32 [[RDX]], [[LD]]
-; CHECK-NEXT: store i32 [[RDX_INC]], i32* [[RETVAL]], align 4
+; CHECK-NEXT: store i32 [[RDX_INC]], ptr [[RETVAL]], align 4
; CHECK-NEXT: [[INDVARS_IV_NEXT]] = add nsw i64 [[INDVARS_IV]], 1
; CHECK-NEXT: [[EXITCOND:%.*]] = icmp ne i64 [[INDVARS_IV_NEXT]], [[N:%.*]]
; CHECK-NEXT: br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT:%.*]]
; CHECK: exit:
-; CHECK-NEXT: [[I0:%.*]] = call i32 @capture_of_alloca(i32* nocapture [[RETVAL]])
-; CHECK-NEXT: [[I1:%.*]] = load i32, i32* [[RETVAL]], align 4
+; CHECK-NEXT: [[I0:%.*]] = call i32 @capture_of_alloca(ptr nocapture [[RETVAL]])
+; CHECK-NEXT: [[I1:%.*]] = load i32, ptr [[RETVAL]], align 4
; CHECK-NEXT: ret i32 [[I1]]
;
; CHECK-OPAQUE-LABEL: @alloca_not_captured_as_per_operand_attr(
@@ -171,45 +171,45 @@ define i32 @alloca_not_captured_as_per_operand_attr(i32* %data, i64 %n) {
;
entry:
%retval = alloca i32, align 4
- store i32 0, i32* %retval, align 4
+ store i32 0, ptr %retval, align 4
br label %loop
loop:
%indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %loop ]
- %arrayidx = getelementptr inbounds i32, i32* %data, i64 %indvars.iv
- %ld = load i32, i32* %arrayidx, align 4
- %rdx = load i32, i32* %retval, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %data, i64 %indvars.iv
+ %ld = load i32, ptr %arrayidx, align 4
+ %rdx = load i32, ptr %retval, align 4
%rdx.inc = add nsw i32 %rdx, %ld
- store i32 %rdx.inc, i32* %retval, align 4
+ store i32 %rdx.inc, ptr %retval, align 4
%indvars.iv.next = add nsw i64 %indvars.iv, 1
%exitcond = icmp ne i64 %indvars.iv.next, %n
br i1 %exitcond, label %loop, label %exit
exit:
- %i0 = call i32 @capture_of_alloca(i32* nocapture %retval)
- %i1 = load i32, i32* %retval, align 4
+ %i0 = call i32 @capture_of_alloca(ptr nocapture %retval)
+ %i1 = load i32, ptr %retval, align 4
ret i32 %i1
}
-define i32 @alloca_not_captured_and_readonly_as_per_operand_attr(i32* %data, i64 %n) {
+define i32 @alloca_not_captured_and_readonly_as_per_operand_attr(ptr %data, i64 %n) {
; CHECK-LABEL: @alloca_not_captured_and_readonly_as_per_operand_attr(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[RETVAL:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 0, i32* [[RETVAL]], align 4
+; CHECK-NEXT: store i32 0, ptr [[RETVAL]], align 4
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[LOOP]] ]
-; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[DATA:%.*]], i64 [[INDVARS_IV]]
-; CHECK-NEXT: [[LD:%.*]] = load i32, i32* [[ARRAYIDX]], align 4
-; CHECK-NEXT: [[RDX:%.*]] = load i32, i32* [[RETVAL]], align 4
+; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[DATA:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT: [[LD:%.*]] = load i32, ptr [[ARRAYIDX]], align 4
+; CHECK-NEXT: [[RDX:%.*]] = load i32, ptr [[RETVAL]], align 4
; CHECK-NEXT: [[RDX_INC:%.*]] = add nsw i32 [[RDX]], [[LD]]
-; CHECK-NEXT: store i32 [[RDX_INC]], i32* [[RETVAL]], align 4
+; CHECK-NEXT: store i32 [[RDX_INC]], ptr [[RETVAL]], align 4
; CHECK-NEXT: [[INDVARS_IV_NEXT]] = add nsw i64 [[INDVARS_IV]], 1
; CHECK-NEXT: [[EXITCOND:%.*]] = icmp ne i64 [[INDVARS_IV_NEXT]], [[N:%.*]]
; CHECK-NEXT: br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT:%.*]]
; CHECK: exit:
-; CHECK-NEXT: [[I0:%.*]] = call i32 @capture_of_alloca(i32* nocapture readonly [[RETVAL]])
-; CHECK-NEXT: [[I1:%.*]] = load i32, i32* [[RETVAL]], align 4
+; CHECK-NEXT: [[I0:%.*]] = call i32 @capture_of_alloca(ptr nocapture readonly [[RETVAL]])
+; CHECK-NEXT: [[I1:%.*]] = load i32, ptr [[RETVAL]], align 4
; CHECK-NEXT: ret i32 [[I1]]
;
; CHECK-OPAQUE-LABEL: @alloca_not_captured_and_readonly_as_per_operand_attr(
@@ -234,45 +234,45 @@ define i32 @alloca_not_captured_and_readonly_as_per_operand_attr(i32* %data, i64
;
entry:
%retval = alloca i32, align 4
- store i32 0, i32* %retval, align 4
+ store i32 0, ptr %retval, align 4
br label %loop
loop:
%indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %loop ]
- %arrayidx = getelementptr inbounds i32, i32* %data, i64 %indvars.iv
- %ld = load i32, i32* %arrayidx, align 4
- %rdx = load i32, i32* %retval, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %data, i64 %indvars.iv
+ %ld = load i32, ptr %arrayidx, align 4
+ %rdx = load i32, ptr %retval, align 4
%rdx.inc = add nsw i32 %rdx, %ld
- store i32 %rdx.inc, i32* %retval, align 4
+ store i32 %rdx.inc, ptr %retval, align 4
%indvars.iv.next = add nsw i64 %indvars.iv, 1
%exitcond = icmp ne i64 %indvars.iv.next, %n
br i1 %exitcond, label %loop, label %exit
exit:
- %i0 = call i32 @capture_of_alloca(i32* nocapture readonly %retval)
- %i1 = load i32, i32* %retval, align 4
+ %i0 = call i32 @capture_of_alloca(ptr nocapture readonly %retval)
+ %i1 = load i32, ptr %retval, align 4
ret i32 %i1
}
-define i32 @alloca_not_captured_as_per_operand_attr_and_readonly_as_per_callbase_attr(i32* %data, i64 %n) {
+define i32 @alloca_not_captured_as_per_operand_attr_and_readonly_as_per_callbase_attr(ptr %data, i64 %n) {
; CHECK-LABEL: @alloca_not_captured_as_per_operand_attr_and_readonly_as_per_callbase_attr(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[RETVAL:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 0, i32* [[RETVAL]], align 4
+; CHECK-NEXT: store i32 0, ptr [[RETVAL]], align 4
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[LOOP]] ]
-; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[DATA:%.*]], i64 [[INDVARS_IV]]
-; CHECK-NEXT: [[LD:%.*]] = load i32, i32* [[ARRAYIDX]], align 4
-; CHECK-NEXT: [[RDX:%.*]] = load i32, i32* [[RETVAL]], align 4
+; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[DATA:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT: [[LD:%.*]] = load i32, ptr [[ARRAYIDX]], align 4
+; CHECK-NEXT: [[RDX:%.*]] = load i32, ptr [[RETVAL]], align 4
; CHECK-NEXT: [[RDX_INC:%.*]] = add nsw i32 [[RDX]], [[LD]]
-; CHECK-NEXT: store i32 [[RDX_INC]], i32* [[RETVAL]], align 4
+; CHECK-NEXT: store i32 [[RDX_INC]], ptr [[RETVAL]], align 4
; CHECK-NEXT: [[INDVARS_IV_NEXT]] = add nsw i64 [[INDVARS_IV]], 1
; CHECK-NEXT: [[EXITCOND:%.*]] = icmp ne i64 [[INDVARS_IV_NEXT]], [[N:%.*]]
; CHECK-NEXT: br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT:%.*]]
; CHECK: exit:
-; CHECK-NEXT: [[I0:%.*]] = call i32 @capture_of_alloca(i32* nocapture [[RETVAL]]) #[[ATTR2:[0-9]+]]
-; CHECK-NEXT: [[I1:%.*]] = load i32, i32* [[RETVAL]], align 4
+; CHECK-NEXT: [[I0:%.*]] = call i32 @capture_of_alloca(ptr nocapture [[RETVAL]]) #[[ATTR2:[0-9]+]]
+; CHECK-NEXT: [[I1:%.*]] = load i32, ptr [[RETVAL]], align 4
; CHECK-NEXT: ret i32 [[I1]]
;
; CHECK-OPAQUE-LABEL: @alloca_not_captured_as_per_operand_attr_and_readonly_as_per_callbase_attr(
@@ -297,45 +297,45 @@ define i32 @alloca_not_captured_as_per_operand_attr_and_readonly_as_per_callbase
;
entry:
%retval = alloca i32, align 4
- store i32 0, i32* %retval, align 4
+ store i32 0, ptr %retval, align 4
br label %loop
loop:
%indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %loop ]
- %arrayidx = getelementptr inbounds i32, i32* %data, i64 %indvars.iv
- %ld = load i32, i32* %arrayidx, align 4
- %rdx = load i32, i32* %retval, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %data, i64 %indvars.iv
+ %ld = load i32, ptr %arrayidx, align 4
+ %rdx = load i32, ptr %retval, align 4
%rdx.inc = add nsw i32 %rdx, %ld
- store i32 %rdx.inc, i32* %retval, align 4
+ store i32 %rdx.inc, ptr %retval, align 4
%indvars.iv.next = add nsw i64 %indvars.iv, 1
%exitcond = icmp ne i64 %indvars.iv.next, %n
br i1 %exitcond, label %loop, label %exit
exit:
- %i0 = call i32 @capture_of_alloca(i32* nocapture %retval) readonly
- %i1 = load i32, i32* %retval, align 4
+ %i0 = call i32 @capture_of_alloca(ptr nocapture %retval) readonly
+ %i1 = load i32, ptr %retval, align 4
ret i32 %i1
}
-define i32 @alloca_not_readonly_as_per_operand_attr(i32* %data, i64 %n) {
+define i32 @alloca_not_readonly_as_per_operand_attr(ptr %data, i64 %n) {
; CHECK-LABEL: @alloca_not_readonly_as_per_operand_attr(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[RETVAL:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 0, i32* [[RETVAL]], align 4
+; CHECK-NEXT: store i32 0, ptr [[RETVAL]], align 4
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[LOOP]] ]
-; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[DATA:%.*]], i64 [[INDVARS_IV]]
-; CHECK-NEXT: [[LD:%.*]] = load i32, i32* [[ARRAYIDX]], align 4
-; CHECK-NEXT: [[RDX:%.*]] = load i32, i32* [[RETVAL]], align 4
+; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[DATA:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT: [[LD:%.*]] = load i32, ptr [[ARRAYIDX]], align 4
+; CHECK-NEXT: [[RDX:%.*]] = load i32, ptr [[RETVAL]], align 4
; CHECK-NEXT: [[RDX_INC:%.*]] = add nsw i32 [[RDX]], [[LD]]
-; CHECK-NEXT: store i32 [[RDX_INC]], i32* [[RETVAL]], align 4
+; CHECK-NEXT: store i32 [[RDX_INC]], ptr [[RETVAL]], align 4
; CHECK-NEXT: [[INDVARS_IV_NEXT]] = add nsw i64 [[INDVARS_IV]], 1
; CHECK-NEXT: [[EXITCOND:%.*]] = icmp ne i64 [[INDVARS_IV_NEXT]], [[N:%.*]]
; CHECK-NEXT: br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT:%.*]]
; CHECK: exit:
-; CHECK-NEXT: [[I0:%.*]] = call i32 @capture_of_alloca(i32* readonly [[RETVAL]])
-; CHECK-NEXT: [[I1:%.*]] = load i32, i32* [[RETVAL]], align 4
+; CHECK-NEXT: [[I0:%.*]] = call i32 @capture_of_alloca(ptr readonly [[RETVAL]])
+; CHECK-NEXT: [[I1:%.*]] = load i32, ptr [[RETVAL]], align 4
; CHECK-NEXT: ret i32 [[I1]]
;
; CHECK-OPAQUE-LABEL: @alloca_not_readonly_as_per_operand_attr(
@@ -360,46 +360,45 @@ define i32 @alloca_not_readonly_as_per_operand_attr(i32* %data, i64 %n) {
;
entry:
%retval = alloca i32, align 4
- store i32 0, i32* %retval, align 4
+ store i32 0, ptr %retval, align 4
br label %loop
loop:
%indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %loop ]
- %arrayidx = getelementptr inbounds i32, i32* %data, i64 %indvars.iv
- %ld = load i32, i32* %arrayidx, align 4
- %rdx = load i32, i32* %retval, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %data, i64 %indvars.iv
+ %ld = load i32, ptr %arrayidx, align 4
+ %rdx = load i32, ptr %retval, align 4
%rdx.inc = add nsw i32 %rdx, %ld
- store i32 %rdx.inc, i32* %retval, align 4
+ store i32 %rdx.inc, ptr %retval, align 4
%indvars.iv.next = add nsw i64 %indvars.iv, 1
%exitcond = icmp ne i64 %indvars.iv.next, %n
br i1 %exitcond, label %loop, label %exit
exit:
- %i0 = call i32 @capture_of_alloca(i32* readonly %retval)
- %i1 = load i32, i32* %retval, align 4
+ %i0 = call i32 @capture_of_alloca(ptr readonly %retval)
+ %i1 = load i32, ptr %retval, align 4
ret i32 %i1
}
-define i32 @alloca_with_gep_used_in_call(i32* %data, i64 %n) {
+define i32 @alloca_with_gep_used_in_call(ptr %data, i64 %n) {
; CHECK-LABEL: @alloca_with_gep_used_in_call(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[RETVAL:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 0, i32* [[RETVAL]], align 4
+; CHECK-NEXT: store i32 0, ptr [[RETVAL]], align 4
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[LOOP]] ]
-; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[DATA:%.*]], i64 [[INDVARS_IV]]
-; CHECK-NEXT: [[LD:%.*]] = load i32, i32* [[ARRAYIDX]], align 4
-; CHECK-NEXT: [[RDX:%.*]] = load i32, i32* [[RETVAL]], align 4
+; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[DATA:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT: [[LD:%.*]] = load i32, ptr [[ARRAYIDX]], align 4
+; CHECK-NEXT: [[RDX:%.*]] = load i32, ptr [[RETVAL]], align 4
; CHECK-NEXT: [[RDX_INC:%.*]] = add nsw i32 [[RDX]], [[LD]]
-; CHECK-NEXT: store i32 [[RDX_INC]], i32* [[RETVAL]], align 4
+; CHECK-NEXT: store i32 [[RDX_INC]], ptr [[RETVAL]], align 4
; CHECK-NEXT: [[INDVARS_IV_NEXT]] = add nsw i64 [[INDVARS_IV]], 1
; CHECK-NEXT: [[EXITCOND:%.*]] = icmp ne i64 [[INDVARS_IV_NEXT]], [[N:%.*]]
; CHECK-NEXT: br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT:%.*]]
; CHECK: exit:
-; CHECK-NEXT: [[GEP:%.*]] = getelementptr i32, i32* [[RETVAL]], i32 0
-; CHECK-NEXT: [[I0:%.*]] = call i32 @user_of_alloca(i32* [[GEP]])
-; CHECK-NEXT: [[I1:%.*]] = load i32, i32* [[RETVAL]], align 4
+; CHECK-NEXT: [[I0:%.*]] = call i32 @user_of_alloca(ptr [[RETVAL]])
+; CHECK-NEXT: [[I1:%.*]] = load i32, ptr [[RETVAL]], align 4
; CHECK-NEXT: ret i32 [[I1]]
;
; CHECK-OPAQUE-LABEL: @alloca_with_gep_used_in_call(
@@ -418,53 +417,51 @@ define i32 @alloca_with_gep_used_in_call(i32* %data, i64 %n) {
; CHECK-OPAQUE-NEXT: [[EXITCOND:%.*]] = icmp ne i64 [[INDVARS_IV_NEXT]], [[N:%.*]]
; CHECK-OPAQUE-NEXT: br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT:%.*]]
; CHECK-OPAQUE: exit:
-; CHECK-OPAQUE-NEXT: [[GEP:%.*]] = getelementptr i32, ptr [[RETVAL]], i32 0
-; CHECK-OPAQUE-NEXT: [[I0:%.*]] = call i32 @user_of_alloca(ptr [[GEP]])
+; CHECK-OPAQUE-NEXT: [[I0:%.*]] = call i32 @user_of_alloca(ptr [[RETVAL]])
; CHECK-OPAQUE-NEXT: [[I1:%.*]] = load i32, ptr [[RETVAL]], align 4
; CHECK-OPAQUE-NEXT: ret i32 [[I1]]
;
entry:
%retval = alloca i32, align 4
- store i32 0, i32* %retval, align 4
+ store i32 0, ptr %retval, align 4
br label %loop
loop:
%indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %loop ]
- %arrayidx = getelementptr inbounds i32, i32* %data, i64 %indvars.iv
- %ld = load i32, i32* %arrayidx, align 4
- %rdx = load i32, i32* %retval, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %data, i64 %indvars.iv
+ %ld = load i32, ptr %arrayidx, align 4
+ %rdx = load i32, ptr %retval, align 4
%rdx.inc = add nsw i32 %rdx, %ld
- store i32 %rdx.inc, i32* %retval, align 4
+ store i32 %rdx.inc, ptr %retval, align 4
%indvars.iv.next = add nsw i64 %indvars.iv, 1
%exitcond = icmp ne i64 %indvars.iv.next, %n
br i1 %exitcond, label %loop, label %exit
exit:
- %gep = getelementptr i32, i32* %retval, i32 0
- %i0 = call i32 @user_of_alloca(i32* %gep)
- %i1 = load i32, i32* %retval, align 4
+ %i0 = call i32 @user_of_alloca(ptr %retval)
+ %i1 = load i32, ptr %retval, align 4
ret i32 %i1
}
-define i32 @alloca_captured_second_arg(i32* %data, i64 %n) {
+define i32 @alloca_captured_second_arg(ptr %data, i64 %n) {
; CHECK-LABEL: @alloca_captured_second_arg(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[RETVAL:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 0, i32* [[RETVAL]], align 4
+; CHECK-NEXT: store i32 0, ptr [[RETVAL]], align 4
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[LOOP]] ]
-; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[DATA:%.*]], i64 [[INDVARS_IV]]
-; CHECK-NEXT: [[LD:%.*]] = load i32, i32* [[ARRAYIDX]], align 4
-; CHECK-NEXT: [[RDX:%.*]] = load i32, i32* [[RETVAL]], align 4
+; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[DATA:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT: [[LD:%.*]] = load i32, ptr [[ARRAYIDX]], align 4
+; CHECK-NEXT: [[RDX:%.*]] = load i32, ptr [[RETVAL]], align 4
; CHECK-NEXT: [[RDX_INC:%.*]] = add nsw i32 [[RDX]], [[LD]]
-; CHECK-NEXT: store i32 [[RDX_INC]], i32* [[RETVAL]], align 4
+; CHECK-NEXT: store i32 [[RDX_INC]], ptr [[RETVAL]], align 4
; CHECK-NEXT: [[INDVARS_IV_NEXT]] = add nsw i64 [[INDVARS_IV]], 1
; CHECK-NEXT: [[EXITCOND:%.*]] = icmp ne i64 [[INDVARS_IV_NEXT]], [[N:%.*]]
; CHECK-NEXT: br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT:%.*]]
; CHECK: exit:
-; CHECK-NEXT: [[I0:%.*]] = call i32 @capture_with_multiple_args(i32* [[RETVAL]], i32* [[RETVAL]])
-; CHECK-NEXT: [[I1:%.*]] = load i32, i32* [[RETVAL]], align 4
+; CHECK-NEXT: [[I0:%.*]] = call i32 @capture_with_multiple_args(ptr [[RETVAL]], ptr [[RETVAL]])
+; CHECK-NEXT: [[I1:%.*]] = load i32, ptr [[RETVAL]], align 4
; CHECK-NEXT: ret i32 [[I1]]
;
; CHECK-OPAQUE-LABEL: @alloca_captured_second_arg(
@@ -489,53 +486,53 @@ define i32 @alloca_captured_second_arg(i32* %data, i64 %n) {
;
entry:
%retval = alloca i32, align 4
- store i32 0, i32* %retval, align 4
+ store i32 0, ptr %retval, align 4
br label %loop
loop:
%indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %loop ]
- %arrayidx = getelementptr inbounds i32, i32* %data, i64 %indvars.iv
- %ld = load i32, i32* %arrayidx, align 4
- %rdx = load i32, i32* %retval, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %data, i64 %indvars.iv
+ %ld = load i32, ptr %arrayidx, align 4
+ %rdx = load i32, ptr %retval, align 4
%rdx.inc = add nsw i32 %rdx, %ld
- store i32 %rdx.inc, i32* %retval, align 4
+ store i32 %rdx.inc, ptr %retval, align 4
%indvars.iv.next = add nsw i64 %indvars.iv, 1
%exitcond = icmp ne i64 %indvars.iv.next, %n
br i1 %exitcond, label %loop, label %exit
exit:
- %i0 = call i32 @capture_with_multiple_args(i32* %retval, i32* %retval)
- %i1 = load i32, i32* %retval, align 4
+ %i0 = call i32 @capture_with_multiple_args(ptr %retval, ptr %retval)
+ %i1 = load i32, ptr %retval, align 4
ret i32 %i1
}
-define i32 @alloca_used_in_maybe_throwing_call(i32* %data, i64 %n) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
+define i32 @alloca_used_in_maybe_throwing_call(ptr %data, i64 %n) personality ptr @__gxx_personality_v0 {
; CHECK-LABEL: @alloca_used_in_maybe_throwing_call(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[RETVAL:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 0, i32* [[RETVAL]], align 4
+; CHECK-NEXT: store i32 0, ptr [[RETVAL]], align 4
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[LOOP]] ]
-; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[DATA:%.*]], i64 [[INDVARS_IV]]
-; CHECK-NEXT: [[LD:%.*]] = load i32, i32* [[ARRAYIDX]], align 4
-; CHECK-NEXT: [[RDX:%.*]] = load i32, i32* [[RETVAL]], align 4
+; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[DATA:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT: [[LD:%.*]] = load i32, ptr [[ARRAYIDX]], align 4
+; CHECK-NEXT: [[RDX:%.*]] = load i32, ptr [[RETVAL]], align 4
; CHECK-NEXT: [[RDX_INC:%.*]] = add nsw i32 [[RDX]], [[LD]]
-; CHECK-NEXT: store i32 [[RDX_INC]], i32* [[RETVAL]], align 4
+; CHECK-NEXT: store i32 [[RDX_INC]], ptr [[RETVAL]], align 4
; CHECK-NEXT: [[INDVARS_IV_NEXT]] = add nsw i64 [[INDVARS_IV]], 1
; CHECK-NEXT: [[EXITCOND:%.*]] = icmp ne i64 [[INDVARS_IV_NEXT]], [[N:%.*]]
; CHECK-NEXT: br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT:%.*]]
; CHECK: exit:
-; CHECK-NEXT: [[I0:%.*]] = invoke i32 @user_of_alloca(i32* [[RETVAL]])
+; CHECK-NEXT: [[I0:%.*]] = invoke i32 @user_of_alloca(ptr [[RETVAL]])
; CHECK-NEXT: to label [[CONT:%.*]] unwind label [[UW:%.*]]
; CHECK: cont:
; CHECK-NEXT: br label [[END:%.*]]
; CHECK: uw:
-; CHECK-NEXT: [[I1:%.*]] = landingpad { i8*, i32 }
-; CHECK-NEXT: catch i8* null
+; CHECK-NEXT: [[I1:%.*]] = landingpad { ptr, i32 }
+; CHECK-NEXT: catch ptr null
; CHECK-NEXT: br label [[END]]
; CHECK: end:
-; CHECK-NEXT: [[I2:%.*]] = load i32, i32* [[RETVAL]], align 4
+; CHECK-NEXT: [[I2:%.*]] = load i32, ptr [[RETVAL]], align 4
; CHECK-NEXT: ret i32 [[I2]]
;
; CHECK-OPAQUE-LABEL: @alloca_used_in_maybe_throwing_call(
@@ -568,60 +565,60 @@ define i32 @alloca_used_in_maybe_throwing_call(i32* %data, i64 %n) personality i
;
entry:
%retval = alloca i32, align 4
- store i32 0, i32* %retval, align 4
+ store i32 0, ptr %retval, align 4
br label %loop
loop:
%indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %loop ]
- %arrayidx = getelementptr inbounds i32, i32* %data, i64 %indvars.iv
- %ld = load i32, i32* %arrayidx, align 4
- %rdx = load i32, i32* %retval, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %data, i64 %indvars.iv
+ %ld = load i32, ptr %arrayidx, align 4
+ %rdx = load i32, ptr %retval, align 4
%rdx.inc = add nsw i32 %rdx, %ld
- store i32 %rdx.inc, i32* %retval, align 4
+ store i32 %rdx.inc, ptr %retval, align 4
%indvars.iv.next = add nsw i64 %indvars.iv, 1
%exitcond = icmp ne i64 %indvars.iv.next, %n
br i1 %exitcond, label %loop, label %exit
exit:
- %i0 = invoke i32 @user_of_alloca(i32* %retval) to label %cont unwind label %uw
+ %i0 = invoke i32 @user_of_alloca(ptr %retval) to label %cont unwind label %uw
cont:
br label %end
uw:
- %i1 = landingpad { i8*, i32 } catch i8* null
+ %i1 = landingpad { ptr, i32 } catch ptr null
br label %end
end:
- %i2 = load i32, i32* %retval, align 4
+ %i2 = load i32, ptr %retval, align 4
ret i32 %i2
}
-define i32 @alloca_used_in_maybe_throwing_call_with_same_dests(i32* %data, i64 %n) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
+define i32 @alloca_used_in_maybe_throwing_call_with_same_dests(ptr %data, i64 %n) personality ptr @__gxx_personality_v0 {
; CHECK-LABEL: @alloca_used_in_maybe_throwing_call_with_same_dests(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[RETVAL:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 0, i32* [[RETVAL]], align 4
+; CHECK-NEXT: store i32 0, ptr [[RETVAL]], align 4
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[LOOP]] ]
-; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[DATA:%.*]], i64 [[INDVARS_IV]]
-; CHECK-NEXT: [[LD:%.*]] = load i32, i32* [[ARRAYIDX]], align 4
-; CHECK-NEXT: [[RDX:%.*]] = load i32, i32* [[RETVAL]], align 4
+; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[DATA:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT: [[LD:%.*]] = load i32, ptr [[ARRAYIDX]], align 4
+; CHECK-NEXT: [[RDX:%.*]] = load i32, ptr [[RETVAL]], align 4
; CHECK-NEXT: [[RDX_INC:%.*]] = add nsw i32 [[RDX]], [[LD]]
-; CHECK-NEXT: store i32 [[RDX_INC]], i32* [[RETVAL]], align 4
+; CHECK-NEXT: store i32 [[RDX_INC]], ptr [[RETVAL]], align 4
; CHECK-NEXT: [[INDVARS_IV_NEXT]] = add nsw i64 [[INDVARS_IV]], 1
; CHECK-NEXT: [[EXITCOND:%.*]] = icmp ne i64 [[INDVARS_IV_NEXT]], [[N:%.*]]
; CHECK-NEXT: br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT:%.*]]
; CHECK: exit:
-; CHECK-NEXT: [[I0:%.*]] = invoke i32 @user_of_alloca(i32* [[RETVAL]])
+; CHECK-NEXT: [[I0:%.*]] = invoke i32 @user_of_alloca(ptr [[RETVAL]])
; CHECK-NEXT: to label [[END:%.*]] unwind label [[UW:%.*]]
; CHECK: uw:
-; CHECK-NEXT: [[I1:%.*]] = landingpad { i8*, i32 }
-; CHECK-NEXT: catch i8* null
+; CHECK-NEXT: [[I1:%.*]] = landingpad { ptr, i32 }
+; CHECK-NEXT: catch ptr null
; CHECK-NEXT: br label [[END]]
; CHECK: end:
-; CHECK-NEXT: [[I2:%.*]] = load i32, i32* [[RETVAL]], align 4
+; CHECK-NEXT: [[I2:%.*]] = load i32, ptr [[RETVAL]], align 4
; CHECK-NEXT: ret i32 [[I2]]
;
; CHECK-OPAQUE-LABEL: @alloca_used_in_maybe_throwing_call_with_same_dests(
@@ -652,59 +649,59 @@ define i32 @alloca_used_in_maybe_throwing_call_with_same_dests(i32* %data, i64 %
;
entry:
%retval = alloca i32, align 4
- store i32 0, i32* %retval, align 4
+ store i32 0, ptr %retval, align 4
br label %loop
loop:
%indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %loop ]
- %arrayidx = getelementptr inbounds i32, i32* %data, i64 %indvars.iv
- %ld = load i32, i32* %arrayidx, align 4
- %rdx = load i32, i32* %retval, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %data, i64 %indvars.iv
+ %ld = load i32, ptr %arrayidx, align 4
+ %rdx = load i32, ptr %retval, align 4
%rdx.inc = add nsw i32 %rdx, %ld
- store i32 %rdx.inc, i32* %retval, align 4
+ store i32 %rdx.inc, ptr %retval, align 4
%indvars.iv.next = add nsw i64 %indvars.iv, 1
%exitcond = icmp ne i64 %indvars.iv.next, %n
br i1 %exitcond, label %loop, label %exit
exit:
- %i0 = invoke i32 @user_of_alloca(i32* %retval) to label %end unwind label %uw
+ %i0 = invoke i32 @user_of_alloca(ptr %retval) to label %end unwind label %uw
uw:
- %i1 = landingpad { i8*, i32 } catch i8* null
+ %i1 = landingpad { ptr, i32 } catch ptr null
br label %end
end:
- %i2 = load i32, i32* %retval, align 4
+ %i2 = load i32, ptr %retval, align 4
ret i32 %i2
}
-define [2 x i32] @part_of_alloca_used_in_call(i32* %data, i64 %n) {
+define [2 x i32] @part_of_alloca_used_in_call(ptr %data, i64 %n) {
; CHECK-LABEL: @part_of_alloca_used_in_call(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[RETVAL_FULL:%.*]] = alloca [2 x i32], align 4
-; CHECK-NEXT: [[DOTFCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i32 0, i32 0
-; CHECK-NEXT: store i32 0, i32* [[DOTFCA_0_GEP]], align 4
-; CHECK-NEXT: [[DOTFCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i32 0, i32 1
-; CHECK-NEXT: store i32 0, i32* [[DOTFCA_1_GEP]], align 4
-; CHECK-NEXT: [[RETVAL:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i64 0, i64 1
+; CHECK-NEXT: [[DOTFCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 0
+; CHECK-NEXT: store i32 0, ptr [[DOTFCA_0_GEP]], align 4
+; CHECK-NEXT: [[DOTFCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 1
+; CHECK-NEXT: store i32 0, ptr [[DOTFCA_1_GEP]], align 4
+; CHECK-NEXT: [[RETVAL:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i64 0, i64 1
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[LOOP]] ]
-; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[DATA:%.*]], i64 [[INDVARS_IV]]
-; CHECK-NEXT: [[LD:%.*]] = load i32, i32* [[ARRAYIDX]], align 4
-; CHECK-NEXT: [[RDX:%.*]] = load i32, i32* [[RETVAL]], align 4
+; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[DATA:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT: [[LD:%.*]] = load i32, ptr [[ARRAYIDX]], align 4
+; CHECK-NEXT: [[RDX:%.*]] = load i32, ptr [[RETVAL]], align 4
; CHECK-NEXT: [[RDX_INC:%.*]] = add nsw i32 [[RDX]], [[LD]]
-; CHECK-NEXT: store i32 [[RDX_INC]], i32* [[RETVAL]], align 4
+; CHECK-NEXT: store i32 [[RDX_INC]], ptr [[RETVAL]], align 4
; CHECK-NEXT: [[INDVARS_IV_NEXT]] = add nsw i64 [[INDVARS_IV]], 1
; CHECK-NEXT: [[EXITCOND:%.*]] = icmp ne i64 [[INDVARS_IV_NEXT]], [[N:%.*]]
; CHECK-NEXT: br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT:%.*]]
; CHECK: exit:
-; CHECK-NEXT: [[I0:%.*]] = call i32 @user_of_alloca(i32* [[RETVAL]])
-; CHECK-NEXT: [[I1_FCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i32 0, i32 0
-; CHECK-NEXT: [[I1_FCA_0_LOAD:%.*]] = load i32, i32* [[I1_FCA_0_GEP]], align 4
+; CHECK-NEXT: [[I0:%.*]] = call i32 @user_of_alloca(ptr [[RETVAL]])
+; CHECK-NEXT: [[I1_FCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 0
+; CHECK-NEXT: [[I1_FCA_0_LOAD:%.*]] = load i32, ptr [[I1_FCA_0_GEP]], align 4
; CHECK-NEXT: [[I1_FCA_0_INSERT:%.*]] = insertvalue [2 x i32] poison, i32 [[I1_FCA_0_LOAD]], 0
-; CHECK-NEXT: [[I1_FCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i32 0, i32 1
-; CHECK-NEXT: [[I1_FCA_1_LOAD:%.*]] = load i32, i32* [[I1_FCA_1_GEP]], align 4
+; CHECK-NEXT: [[I1_FCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 1
+; CHECK-NEXT: [[I1_FCA_1_LOAD:%.*]] = load i32, ptr [[I1_FCA_1_GEP]], align 4
; CHECK-NEXT: [[I1_FCA_1_INSERT:%.*]] = insertvalue [2 x i32] [[I1_FCA_0_INSERT]], i32 [[I1_FCA_1_LOAD]], 1
; CHECK-NEXT: ret [2 x i32] [[I1_FCA_1_INSERT]]
;
@@ -739,55 +736,54 @@ define [2 x i32] @part_of_alloca_used_in_call(i32* %data, i64 %n) {
;
entry:
%retval.full = alloca [2 x i32], align 4
- store [2 x i32] zeroinitializer, [2 x i32]* %retval.full, align 4
- %retval = getelementptr inbounds [2 x i32], [2 x i32]* %retval.full, i64 0, i64 1
+ store [2 x i32] zeroinitializer, ptr %retval.full, align 4
+ %retval = getelementptr inbounds [2 x i32], ptr %retval.full, i64 0, i64 1
br label %loop
loop:
%indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %loop ]
- %arrayidx = getelementptr inbounds i32, i32* %data, i64 %indvars.iv
- %ld = load i32, i32* %arrayidx, align 4
- %rdx = load i32, i32* %retval, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %data, i64 %indvars.iv
+ %ld = load i32, ptr %arrayidx, align 4
+ %rdx = load i32, ptr %retval, align 4
%rdx.inc = add nsw i32 %rdx, %ld
- store i32 %rdx.inc, i32* %retval, align 4
+ store i32 %rdx.inc, ptr %retval, align 4
%indvars.iv.next = add nsw i64 %indvars.iv, 1
%exitcond = icmp ne i64 %indvars.iv.next, %n
br i1 %exitcond, label %loop, label %exit
exit:
- %i0 = call i32 @user_of_alloca(i32* %retval)
- %i1 = load [2 x i32], [2 x i32]* %retval.full, align 4
+ %i0 = call i32 @user_of_alloca(ptr %retval)
+ %i1 = load [2 x i32], ptr %retval.full, align 4
ret [2 x i32] %i1
}
-define [2 x i32] @all_parts_of_alloca_used_in_call_with_multiple_args(i32* %data, i64 %n) {
+define [2 x i32] @all_parts_of_alloca_used_in_call_with_multiple_args(ptr %data, i64 %n) {
; CHECK-LABEL: @all_parts_of_alloca_used_in_call_with_multiple_args(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[RETVAL_FULL:%.*]] = alloca [2 x i32], align 4
-; CHECK-NEXT: [[DOTFCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i32 0, i32 0
-; CHECK-NEXT: store i32 0, i32* [[DOTFCA_0_GEP]], align 4
-; CHECK-NEXT: [[DOTFCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i32 0, i32 1
-; CHECK-NEXT: store i32 0, i32* [[DOTFCA_1_GEP]], align 4
-; CHECK-NEXT: [[RETVAL_BASE:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i64 0, i64 0
-; CHECK-NEXT: [[RETVAL:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i64 0, i64 1
+; CHECK-NEXT: [[DOTFCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 0
+; CHECK-NEXT: store i32 0, ptr [[DOTFCA_0_GEP]], align 4
+; CHECK-NEXT: [[DOTFCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 1
+; CHECK-NEXT: store i32 0, ptr [[DOTFCA_1_GEP]], align 4
+; CHECK-NEXT: [[RETVAL:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i64 0, i64 1
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[LOOP]] ]
-; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[DATA:%.*]], i64 [[INDVARS_IV]]
-; CHECK-NEXT: [[LD:%.*]] = load i32, i32* [[ARRAYIDX]], align 4
-; CHECK-NEXT: [[RDX:%.*]] = load i32, i32* [[RETVAL]], align 4
+; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[DATA:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT: [[LD:%.*]] = load i32, ptr [[ARRAYIDX]], align 4
+; CHECK-NEXT: [[RDX:%.*]] = load i32, ptr [[RETVAL]], align 4
; CHECK-NEXT: [[RDX_INC:%.*]] = add nsw i32 [[RDX]], [[LD]]
-; CHECK-NEXT: store i32 [[RDX_INC]], i32* [[RETVAL]], align 4
+; CHECK-NEXT: store i32 [[RDX_INC]], ptr [[RETVAL]], align 4
; CHECK-NEXT: [[INDVARS_IV_NEXT]] = add nsw i64 [[INDVARS_IV]], 1
; CHECK-NEXT: [[EXITCOND:%.*]] = icmp ne i64 [[INDVARS_IV_NEXT]], [[N:%.*]]
; CHECK-NEXT: br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT:%.*]]
; CHECK: exit:
-; CHECK-NEXT: [[I0:%.*]] = call i32 @user_of_alloca_with_multiple_args(i32* [[RETVAL]], i32* [[RETVAL_BASE]])
-; CHECK-NEXT: [[I1_FCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i32 0, i32 0
-; CHECK-NEXT: [[I1_FCA_0_LOAD:%.*]] = load i32, i32* [[I1_FCA_0_GEP]], align 4
+; CHECK-NEXT: [[I0:%.*]] = call i32 @user_of_alloca_with_multiple_args(ptr [[RETVAL]], ptr [[RETVAL_FULL]])
+; CHECK-NEXT: [[I1_FCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 0
+; CHECK-NEXT: [[I1_FCA_0_LOAD:%.*]] = load i32, ptr [[I1_FCA_0_GEP]], align 4
; CHECK-NEXT: [[I1_FCA_0_INSERT:%.*]] = insertvalue [2 x i32] poison, i32 [[I1_FCA_0_LOAD]], 0
-; CHECK-NEXT: [[I1_FCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i32 0, i32 1
-; CHECK-NEXT: [[I1_FCA_1_LOAD:%.*]] = load i32, i32* [[I1_FCA_1_GEP]], align 4
+; CHECK-NEXT: [[I1_FCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 1
+; CHECK-NEXT: [[I1_FCA_1_LOAD:%.*]] = load i32, ptr [[I1_FCA_1_GEP]], align 4
; CHECK-NEXT: [[I1_FCA_1_INSERT:%.*]] = insertvalue [2 x i32] [[I1_FCA_0_INSERT]], i32 [[I1_FCA_1_LOAD]], 1
; CHECK-NEXT: ret [2 x i32] [[I1_FCA_1_INSERT]]
;
@@ -798,7 +794,6 @@ define [2 x i32] @all_parts_of_alloca_used_in_call_with_multiple_args(i32* %data
; CHECK-OPAQUE-NEXT: store i32 0, ptr [[DOTFCA_0_GEP]], align 4
; CHECK-OPAQUE-NEXT: [[DOTFCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 1
; CHECK-OPAQUE-NEXT: store i32 0, ptr [[DOTFCA_1_GEP]], align 4
-; CHECK-OPAQUE-NEXT: [[RETVAL_BASE:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i64 0, i64 0
; CHECK-OPAQUE-NEXT: [[RETVAL:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i64 0, i64 1
; CHECK-OPAQUE-NEXT: br label [[LOOP:%.*]]
; CHECK-OPAQUE: loop:
@@ -812,7 +807,7 @@ define [2 x i32] @all_parts_of_alloca_used_in_call_with_multiple_args(i32* %data
; CHECK-OPAQUE-NEXT: [[EXITCOND:%.*]] = icmp ne i64 [[INDVARS_IV_NEXT]], [[N:%.*]]
; CHECK-OPAQUE-NEXT: br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT:%.*]]
; CHECK-OPAQUE: exit:
-; CHECK-OPAQUE-NEXT: [[I0:%.*]] = call i32 @user_of_alloca_with_multiple_args(ptr [[RETVAL]], ptr [[RETVAL_BASE]])
+; CHECK-OPAQUE-NEXT: [[I0:%.*]] = call i32 @user_of_alloca_with_multiple_args(ptr [[RETVAL]], ptr [[RETVAL_FULL]])
; CHECK-OPAQUE-NEXT: [[I1_FCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 0
; CHECK-OPAQUE-NEXT: [[I1_FCA_0_LOAD:%.*]] = load i32, ptr [[I1_FCA_0_GEP]], align 4
; CHECK-OPAQUE-NEXT: [[I1_FCA_0_INSERT:%.*]] = insertvalue [2 x i32] poison, i32 [[I1_FCA_0_LOAD]], 0
@@ -823,57 +818,55 @@ define [2 x i32] @all_parts_of_alloca_used_in_call_with_multiple_args(i32* %data
;
entry:
%retval.full = alloca [2 x i32], align 4
- store [2 x i32] zeroinitializer, [2 x i32]* %retval.full, align 4
- %retval.base = getelementptr inbounds [2 x i32], [2 x i32]* %retval.full, i64 0, i64 0
- %retval = getelementptr inbounds [2 x i32], [2 x i32]* %retval.full, i64 0, i64 1
+ store [2 x i32] zeroinitializer, ptr %retval.full, align 4
+ %retval = getelementptr inbounds [2 x i32], ptr %retval.full, i64 0, i64 1
br label %loop
loop:
%indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %loop ]
- %arrayidx = getelementptr inbounds i32, i32* %data, i64 %indvars.iv
- %ld = load i32, i32* %arrayidx, align 4
- %rdx = load i32, i32* %retval, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %data, i64 %indvars.iv
+ %ld = load i32, ptr %arrayidx, align 4
+ %rdx = load i32, ptr %retval, align 4
%rdx.inc = add nsw i32 %rdx, %ld
- store i32 %rdx.inc, i32* %retval, align 4
+ store i32 %rdx.inc, ptr %retval, align 4
%indvars.iv.next = add nsw i64 %indvars.iv, 1
%exitcond = icmp ne i64 %indvars.iv.next, %n
br i1 %exitcond, label %loop, label %exit
exit:
- %i0 = call i32 @user_of_alloca_with_multiple_args(i32* %retval, i32* %retval.base)
- %i1 = load [2 x i32], [2 x i32]* %retval.full, align 4
+ %i0 = call i32 @user_of_alloca_with_multiple_args(ptr %retval, ptr %retval.full)
+ %i1 = load [2 x i32], ptr %retval.full, align 4
ret [2 x i32] %i1
}
-define [2 x i32] @all_parts_of_alloca_used_in_call_with_multiple_args_with_memcpy_before_call(i32* %data, i64 %n) {
+define [2 x i32] @all_parts_of_alloca_used_in_call_with_multiple_args_with_memcpy_before_call(ptr %data, i64 %n) {
; CHECK-LABEL: @all_parts_of_alloca_used_in_call_with_multiple_args_with_memcpy_before_call(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[RETVAL_FULL:%.*]] = alloca [2 x i32], align 4
-; CHECK-NEXT: [[DOTFCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i32 0, i32 0
-; CHECK-NEXT: store i32 0, i32* [[DOTFCA_0_GEP]], align 4
-; CHECK-NEXT: [[DOTFCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i32 0, i32 1
-; CHECK-NEXT: store i32 0, i32* [[DOTFCA_1_GEP]], align 4
-; CHECK-NEXT: [[RETVAL_BASE:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i64 0, i64 0
-; CHECK-NEXT: [[RETVAL:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i64 0, i64 1
+; CHECK-NEXT: [[DOTFCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 0
+; CHECK-NEXT: store i32 0, ptr [[DOTFCA_0_GEP]], align 4
+; CHECK-NEXT: [[DOTFCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 1
+; CHECK-NEXT: store i32 0, ptr [[DOTFCA_1_GEP]], align 4
+; CHECK-NEXT: [[RETVAL:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i64 0, i64 1
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[LOOP]] ]
-; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[DATA:%.*]], i64 [[INDVARS_IV]]
-; CHECK-NEXT: [[LD:%.*]] = load i32, i32* [[ARRAYIDX]], align 4
-; CHECK-NEXT: [[RDX:%.*]] = load i32, i32* [[RETVAL]], align 4
+; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[DATA:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT: [[LD:%.*]] = load i32, ptr [[ARRAYIDX]], align 4
+; CHECK-NEXT: [[RDX:%.*]] = load i32, ptr [[RETVAL]], align 4
; CHECK-NEXT: [[RDX_INC:%.*]] = add nsw i32 [[RDX]], [[LD]]
-; CHECK-NEXT: store i32 [[RDX_INC]], i32* [[RETVAL]], align 4
+; CHECK-NEXT: store i32 [[RDX_INC]], ptr [[RETVAL]], align 4
; CHECK-NEXT: [[INDVARS_IV_NEXT]] = add nsw i64 [[INDVARS_IV]], 1
; CHECK-NEXT: [[EXITCOND:%.*]] = icmp ne i64 [[INDVARS_IV_NEXT]], [[N:%.*]]
; CHECK-NEXT: br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT:%.*]]
; CHECK: exit:
-; CHECK-NEXT: call void @llvm.memcpy.p0i32.p0i32.i32(i32* [[RETVAL_BASE]], i32* [[RETVAL]], i32 4, i1 false)
-; CHECK-NEXT: [[I0:%.*]] = call i32 @user_of_alloca_with_multiple_args(i32* [[RETVAL]], i32* [[RETVAL_BASE]])
-; CHECK-NEXT: [[I1_FCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i32 0, i32 0
-; CHECK-NEXT: [[I1_FCA_0_LOAD:%.*]] = load i32, i32* [[I1_FCA_0_GEP]], align 4
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr [[RETVAL_FULL]], ptr [[RETVAL]], i32 4, i1 false)
+; CHECK-NEXT: [[I0:%.*]] = call i32 @user_of_alloca_with_multiple_args(ptr [[RETVAL]], ptr [[RETVAL_FULL]])
+; CHECK-NEXT: [[I1_FCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 0
+; CHECK-NEXT: [[I1_FCA_0_LOAD:%.*]] = load i32, ptr [[I1_FCA_0_GEP]], align 4
; CHECK-NEXT: [[I1_FCA_0_INSERT:%.*]] = insertvalue [2 x i32] poison, i32 [[I1_FCA_0_LOAD]], 0
-; CHECK-NEXT: [[I1_FCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i32 0, i32 1
-; CHECK-NEXT: [[I1_FCA_1_LOAD:%.*]] = load i32, i32* [[I1_FCA_1_GEP]], align 4
+; CHECK-NEXT: [[I1_FCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 1
+; CHECK-NEXT: [[I1_FCA_1_LOAD:%.*]] = load i32, ptr [[I1_FCA_1_GEP]], align 4
; CHECK-NEXT: [[I1_FCA_1_INSERT:%.*]] = insertvalue [2 x i32] [[I1_FCA_0_INSERT]], i32 [[I1_FCA_1_LOAD]], 1
; CHECK-NEXT: ret [2 x i32] [[I1_FCA_1_INSERT]]
;
@@ -884,7 +877,6 @@ define [2 x i32] @all_parts_of_alloca_used_in_call_with_multiple_args_with_memcp
; CHECK-OPAQUE-NEXT: store i32 0, ptr [[DOTFCA_0_GEP]], align 4
; CHECK-OPAQUE-NEXT: [[DOTFCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 1
; CHECK-OPAQUE-NEXT: store i32 0, ptr [[DOTFCA_1_GEP]], align 4
-; CHECK-OPAQUE-NEXT: [[RETVAL_BASE:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i64 0, i64 0
; CHECK-OPAQUE-NEXT: [[RETVAL:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i64 0, i64 1
; CHECK-OPAQUE-NEXT: br label [[LOOP:%.*]]
; CHECK-OPAQUE: loop:
@@ -898,8 +890,8 @@ define [2 x i32] @all_parts_of_alloca_used_in_call_with_multiple_args_with_memcp
; CHECK-OPAQUE-NEXT: [[EXITCOND:%.*]] = icmp ne i64 [[INDVARS_IV_NEXT]], [[N:%.*]]
; CHECK-OPAQUE-NEXT: br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT:%.*]]
; CHECK-OPAQUE: exit:
-; CHECK-OPAQUE-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr [[RETVAL_BASE]], ptr [[RETVAL]], i32 4, i1 false)
-; CHECK-OPAQUE-NEXT: [[I0:%.*]] = call i32 @user_of_alloca_with_multiple_args(ptr [[RETVAL]], ptr [[RETVAL_BASE]])
+; CHECK-OPAQUE-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr [[RETVAL_FULL]], ptr [[RETVAL]], i32 4, i1 false)
+; CHECK-OPAQUE-NEXT: [[I0:%.*]] = call i32 @user_of_alloca_with_multiple_args(ptr [[RETVAL]], ptr [[RETVAL_FULL]])
; CHECK-OPAQUE-NEXT: [[I1_FCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 0
; CHECK-OPAQUE-NEXT: [[I1_FCA_0_LOAD:%.*]] = load i32, ptr [[I1_FCA_0_GEP]], align 4
; CHECK-OPAQUE-NEXT: [[I1_FCA_0_INSERT:%.*]] = insertvalue [2 x i32] poison, i32 [[I1_FCA_0_LOAD]], 0
@@ -910,58 +902,56 @@ define [2 x i32] @all_parts_of_alloca_used_in_call_with_multiple_args_with_memcp
;
entry:
%retval.full = alloca [2 x i32], align 4
- store [2 x i32] zeroinitializer, [2 x i32]* %retval.full, align 4
- %retval.base = getelementptr inbounds [2 x i32], [2 x i32]* %retval.full, i64 0, i64 0
- %retval = getelementptr inbounds [2 x i32], [2 x i32]* %retval.full, i64 0, i64 1
+ store [2 x i32] zeroinitializer, ptr %retval.full, align 4
+ %retval = getelementptr inbounds [2 x i32], ptr %retval.full, i64 0, i64 1
br label %loop
loop:
%indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %loop ]
- %arrayidx = getelementptr inbounds i32, i32* %data, i64 %indvars.iv
- %ld = load i32, i32* %arrayidx, align 4
- %rdx = load i32, i32* %retval, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %data, i64 %indvars.iv
+ %ld = load i32, ptr %arrayidx, align 4
+ %rdx = load i32, ptr %retval, align 4
%rdx.inc = add nsw i32 %rdx, %ld
- store i32 %rdx.inc, i32* %retval, align 4
+ store i32 %rdx.inc, ptr %retval, align 4
%indvars.iv.next = add nsw i64 %indvars.iv, 1
%exitcond = icmp ne i64 %indvars.iv.next, %n
br i1 %exitcond, label %loop, label %exit
exit:
- call void @llvm.memcpy.p0i32.p0i32.i32(i32* %retval.base, i32* %retval, i32 4, i1 false)
- %i0 = call i32 @user_of_alloca_with_multiple_args(i32* %retval, i32* %retval.base)
- %i1 = load [2 x i32], [2 x i32]* %retval.full, align 4
+ call void @llvm.memcpy.p0.p0.i32(ptr %retval.full, ptr %retval, i32 4, i1 false)
+ %i0 = call i32 @user_of_alloca_with_multiple_args(ptr %retval, ptr %retval.full)
+ %i1 = load [2 x i32], ptr %retval.full, align 4
ret [2 x i32] %i1
}
-define [2 x i32] @all_parts_of_alloca_used_in_call_with_multiple_args_with_memcpy_after_call(i32* %data, i64 %n) {
+define [2 x i32] @all_parts_of_alloca_used_in_call_with_multiple_args_with_memcpy_after_call(ptr %data, i64 %n) {
; CHECK-LABEL: @all_parts_of_alloca_used_in_call_with_multiple_args_with_memcpy_after_call(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[RETVAL_FULL:%.*]] = alloca [2 x i32], align 4
-; CHECK-NEXT: [[DOTFCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i32 0, i32 0
-; CHECK-NEXT: store i32 0, i32* [[DOTFCA_0_GEP]], align 4
-; CHECK-NEXT: [[DOTFCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i32 0, i32 1
-; CHECK-NEXT: store i32 0, i32* [[DOTFCA_1_GEP]], align 4
-; CHECK-NEXT: [[RETVAL_BASE:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i64 0, i64 0
-; CHECK-NEXT: [[RETVAL:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i64 0, i64 1
+; CHECK-NEXT: [[DOTFCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 0
+; CHECK-NEXT: store i32 0, ptr [[DOTFCA_0_GEP]], align 4
+; CHECK-NEXT: [[DOTFCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 1
+; CHECK-NEXT: store i32 0, ptr [[DOTFCA_1_GEP]], align 4
+; CHECK-NEXT: [[RETVAL:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i64 0, i64 1
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[LOOP]] ]
-; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[DATA:%.*]], i64 [[INDVARS_IV]]
-; CHECK-NEXT: [[LD:%.*]] = load i32, i32* [[ARRAYIDX]], align 4
-; CHECK-NEXT: [[RDX:%.*]] = load i32, i32* [[RETVAL]], align 4
+; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[DATA:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT: [[LD:%.*]] = load i32, ptr [[ARRAYIDX]], align 4
+; CHECK-NEXT: [[RDX:%.*]] = load i32, ptr [[RETVAL]], align 4
; CHECK-NEXT: [[RDX_INC:%.*]] = add nsw i32 [[RDX]], [[LD]]
-; CHECK-NEXT: store i32 [[RDX_INC]], i32* [[RETVAL]], align 4
+; CHECK-NEXT: store i32 [[RDX_INC]], ptr [[RETVAL]], align 4
; CHECK-NEXT: [[INDVARS_IV_NEXT]] = add nsw i64 [[INDVARS_IV]], 1
; CHECK-NEXT: [[EXITCOND:%.*]] = icmp ne i64 [[INDVARS_IV_NEXT]], [[N:%.*]]
; CHECK-NEXT: br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT:%.*]]
; CHECK: exit:
-; CHECK-NEXT: [[I0:%.*]] = call i32 @user_of_alloca_with_multiple_args(i32* [[RETVAL]], i32* [[RETVAL_BASE]])
-; CHECK-NEXT: call void @llvm.memcpy.p0i32.p0i32.i32(i32* [[RETVAL_BASE]], i32* [[RETVAL]], i32 4, i1 false)
-; CHECK-NEXT: [[I1_FCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i32 0, i32 0
-; CHECK-NEXT: [[I1_FCA_0_LOAD:%.*]] = load i32, i32* [[I1_FCA_0_GEP]], align 4
+; CHECK-NEXT: [[I0:%.*]] = call i32 @user_of_alloca_with_multiple_args(ptr [[RETVAL]], ptr [[RETVAL_FULL]])
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr [[RETVAL_FULL]], ptr [[RETVAL]], i32 4, i1 false)
+; CHECK-NEXT: [[I1_FCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 0
+; CHECK-NEXT: [[I1_FCA_0_LOAD:%.*]] = load i32, ptr [[I1_FCA_0_GEP]], align 4
; CHECK-NEXT: [[I1_FCA_0_INSERT:%.*]] = insertvalue [2 x i32] poison, i32 [[I1_FCA_0_LOAD]], 0
-; CHECK-NEXT: [[I1_FCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i32 0, i32 1
-; CHECK-NEXT: [[I1_FCA_1_LOAD:%.*]] = load i32, i32* [[I1_FCA_1_GEP]], align 4
+; CHECK-NEXT: [[I1_FCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 1
+; CHECK-NEXT: [[I1_FCA_1_LOAD:%.*]] = load i32, ptr [[I1_FCA_1_GEP]], align 4
; CHECK-NEXT: [[I1_FCA_1_INSERT:%.*]] = insertvalue [2 x i32] [[I1_FCA_0_INSERT]], i32 [[I1_FCA_1_LOAD]], 1
; CHECK-NEXT: ret [2 x i32] [[I1_FCA_1_INSERT]]
;
@@ -972,7 +962,6 @@ define [2 x i32] @all_parts_of_alloca_used_in_call_with_multiple_args_with_memcp
; CHECK-OPAQUE-NEXT: store i32 0, ptr [[DOTFCA_0_GEP]], align 4
; CHECK-OPAQUE-NEXT: [[DOTFCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 1
; CHECK-OPAQUE-NEXT: store i32 0, ptr [[DOTFCA_1_GEP]], align 4
-; CHECK-OPAQUE-NEXT: [[RETVAL_BASE:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i64 0, i64 0
; CHECK-OPAQUE-NEXT: [[RETVAL:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i64 0, i64 1
; CHECK-OPAQUE-NEXT: br label [[LOOP:%.*]]
; CHECK-OPAQUE: loop:
@@ -986,8 +975,8 @@ define [2 x i32] @all_parts_of_alloca_used_in_call_with_multiple_args_with_memcp
; CHECK-OPAQUE-NEXT: [[EXITCOND:%.*]] = icmp ne i64 [[INDVARS_IV_NEXT]], [[N:%.*]]
; CHECK-OPAQUE-NEXT: br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT:%.*]]
; CHECK-OPAQUE: exit:
-; CHECK-OPAQUE-NEXT: [[I0:%.*]] = call i32 @user_of_alloca_with_multiple_args(ptr [[RETVAL]], ptr [[RETVAL_BASE]])
-; CHECK-OPAQUE-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr [[RETVAL_BASE]], ptr [[RETVAL]], i32 4, i1 false)
+; CHECK-OPAQUE-NEXT: [[I0:%.*]] = call i32 @user_of_alloca_with_multiple_args(ptr [[RETVAL]], ptr [[RETVAL_FULL]])
+; CHECK-OPAQUE-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr [[RETVAL_FULL]], ptr [[RETVAL]], i32 4, i1 false)
; CHECK-OPAQUE-NEXT: [[I1_FCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 0
; CHECK-OPAQUE-NEXT: [[I1_FCA_0_LOAD:%.*]] = load i32, ptr [[I1_FCA_0_GEP]], align 4
; CHECK-OPAQUE-NEXT: [[I1_FCA_0_INSERT:%.*]] = insertvalue [2 x i32] poison, i32 [[I1_FCA_0_LOAD]], 0
@@ -998,56 +987,55 @@ define [2 x i32] @all_parts_of_alloca_used_in_call_with_multiple_args_with_memcp
;
entry:
%retval.full = alloca [2 x i32], align 4
- store [2 x i32] zeroinitializer, [2 x i32]* %retval.full, align 4
- %retval.base = getelementptr inbounds [2 x i32], [2 x i32]* %retval.full, i64 0, i64 0
- %retval = getelementptr inbounds [2 x i32], [2 x i32]* %retval.full, i64 0, i64 1
+ store [2 x i32] zeroinitializer, ptr %retval.full, align 4
+ %retval = getelementptr inbounds [2 x i32], ptr %retval.full, i64 0, i64 1
br label %loop
loop:
%indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %loop ]
- %arrayidx = getelementptr inbounds i32, i32* %data, i64 %indvars.iv
- %ld = load i32, i32* %arrayidx, align 4
- %rdx = load i32, i32* %retval, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %data, i64 %indvars.iv
+ %ld = load i32, ptr %arrayidx, align 4
+ %rdx = load i32, ptr %retval, align 4
%rdx.inc = add nsw i32 %rdx, %ld
- store i32 %rdx.inc, i32* %retval, align 4
+ store i32 %rdx.inc, ptr %retval, align 4
%indvars.iv.next = add nsw i64 %indvars.iv, 1
%exitcond = icmp ne i64 %indvars.iv.next, %n
br i1 %exitcond, label %loop, label %exit
exit:
- %i0 = call i32 @user_of_alloca_with_multiple_args(i32* %retval, i32* %retval.base)
- call void @llvm.memcpy.p0i32.p0i32.i32(i32* %retval.base, i32* %retval, i32 4, i1 false)
- %i1 = load [2 x i32], [2 x i32]* %retval.full, align 4
+ %i0 = call i32 @user_of_alloca_with_multiple_args(ptr %retval, ptr %retval.full)
+ call void @llvm.memcpy.p0.p0.i32(ptr %retval.full, ptr %retval, i32 4, i1 false)
+ %i1 = load [2 x i32], ptr %retval.full, align 4
ret [2 x i32] %i1
}
-define [2 x i32] @part_of_alloca_used_in_call_with_multiple_args(i32* %data, i64 %n) {
+define [2 x i32] @part_of_alloca_used_in_call_with_multiple_args(ptr %data, i64 %n) {
; CHECK-LABEL: @part_of_alloca_used_in_call_with_multiple_args(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[RETVAL_FULL:%.*]] = alloca [2 x i32], align 4
-; CHECK-NEXT: [[DOTFCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i32 0, i32 0
-; CHECK-NEXT: store i32 0, i32* [[DOTFCA_0_GEP]], align 4
-; CHECK-NEXT: [[DOTFCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i32 0, i32 1
-; CHECK-NEXT: store i32 0, i32* [[DOTFCA_1_GEP]], align 4
-; CHECK-NEXT: [[RETVAL:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i64 0, i64 1
+; CHECK-NEXT: [[DOTFCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 0
+; CHECK-NEXT: store i32 0, ptr [[DOTFCA_0_GEP]], align 4
+; CHECK-NEXT: [[DOTFCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 1
+; CHECK-NEXT: store i32 0, ptr [[DOTFCA_1_GEP]], align 4
+; CHECK-NEXT: [[RETVAL:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i64 0, i64 1
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[LOOP]] ]
-; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[DATA:%.*]], i64 [[INDVARS_IV]]
-; CHECK-NEXT: [[LD:%.*]] = load i32, i32* [[ARRAYIDX]], align 4
-; CHECK-NEXT: [[RDX:%.*]] = load i32, i32* [[RETVAL]], align 4
+; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[DATA:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT: [[LD:%.*]] = load i32, ptr [[ARRAYIDX]], align 4
+; CHECK-NEXT: [[RDX:%.*]] = load i32, ptr [[RETVAL]], align 4
; CHECK-NEXT: [[RDX_INC:%.*]] = add nsw i32 [[RDX]], [[LD]]
-; CHECK-NEXT: store i32 [[RDX_INC]], i32* [[RETVAL]], align 4
+; CHECK-NEXT: store i32 [[RDX_INC]], ptr [[RETVAL]], align 4
; CHECK-NEXT: [[INDVARS_IV_NEXT]] = add nsw i64 [[INDVARS_IV]], 1
; CHECK-NEXT: [[EXITCOND:%.*]] = icmp ne i64 [[INDVARS_IV_NEXT]], [[N:%.*]]
; CHECK-NEXT: br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT:%.*]]
; CHECK: exit:
-; CHECK-NEXT: [[I0:%.*]] = call i32 @user_of_alloca_with_multiple_args(i32* [[RETVAL]], i32* [[RETVAL]])
-; CHECK-NEXT: [[I1_FCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i32 0, i32 0
-; CHECK-NEXT: [[I1_FCA_0_LOAD:%.*]] = load i32, i32* [[I1_FCA_0_GEP]], align 4
+; CHECK-NEXT: [[I0:%.*]] = call i32 @user_of_alloca_with_multiple_args(ptr [[RETVAL]], ptr [[RETVAL]])
+; CHECK-NEXT: [[I1_FCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 0
+; CHECK-NEXT: [[I1_FCA_0_LOAD:%.*]] = load i32, ptr [[I1_FCA_0_GEP]], align 4
; CHECK-NEXT: [[I1_FCA_0_INSERT:%.*]] = insertvalue [2 x i32] poison, i32 [[I1_FCA_0_LOAD]], 0
-; CHECK-NEXT: [[I1_FCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i32 0, i32 1
-; CHECK-NEXT: [[I1_FCA_1_LOAD:%.*]] = load i32, i32* [[I1_FCA_1_GEP]], align 4
+; CHECK-NEXT: [[I1_FCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 1
+; CHECK-NEXT: [[I1_FCA_1_LOAD:%.*]] = load i32, ptr [[I1_FCA_1_GEP]], align 4
; CHECK-NEXT: [[I1_FCA_1_INSERT:%.*]] = insertvalue [2 x i32] [[I1_FCA_0_INSERT]], i32 [[I1_FCA_1_LOAD]], 1
; CHECK-NEXT: ret [2 x i32] [[I1_FCA_1_INSERT]]
;
@@ -1082,59 +1070,57 @@ define [2 x i32] @part_of_alloca_used_in_call_with_multiple_args(i32* %data, i64
;
entry:
%retval.full = alloca [2 x i32], align 4
- store [2 x i32] zeroinitializer, [2 x i32]* %retval.full, align 4
- %retval = getelementptr inbounds [2 x i32], [2 x i32]* %retval.full, i64 0, i64 1
+ store [2 x i32] zeroinitializer, ptr %retval.full, align 4
+ %retval = getelementptr inbounds [2 x i32], ptr %retval.full, i64 0, i64 1
br label %loop
loop:
%indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %loop ]
- %arrayidx = getelementptr inbounds i32, i32* %data, i64 %indvars.iv
- %ld = load i32, i32* %arrayidx, align 4
- %rdx = load i32, i32* %retval, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %data, i64 %indvars.iv
+ %ld = load i32, ptr %arrayidx, align 4
+ %rdx = load i32, ptr %retval, align 4
%rdx.inc = add nsw i32 %rdx, %ld
- store i32 %rdx.inc, i32* %retval, align 4
+ store i32 %rdx.inc, ptr %retval, align 4
%indvars.iv.next = add nsw i64 %indvars.iv, 1
%exitcond = icmp ne i64 %indvars.iv.next, %n
br i1 %exitcond, label %loop, label %exit
exit:
- %i0 = call i32 @user_of_alloca_with_multiple_args(i32* %retval, i32* %retval)
- %i1 = load [2 x i32], [2 x i32]* %retval.full, align 4
+ %i0 = call i32 @user_of_alloca_with_multiple_args(ptr %retval, ptr %retval)
+ %i1 = load [2 x i32], ptr %retval.full, align 4
ret [2 x i32] %i1
}
-define [2 x i32] @all_parts_of_alloca_used_in_calls_with_multiple_args(i32* %data, i64 %n) {
+define [2 x i32] @all_parts_of_alloca_used_in_calls_with_multiple_args(ptr %data, i64 %n) {
; CHECK-LABEL: @all_parts_of_alloca_used_in_calls_with_multiple_args(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[RETVAL_FULL:%.*]] = alloca [2 x i32], align 4
; CHECK-NEXT: [[SOME_ANOTHER_ALLOCA_FULL:%.*]] = alloca [42 x i32], align 4
-; CHECK-NEXT: [[DOTFCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i32 0, i32 0
-; CHECK-NEXT: store i32 0, i32* [[DOTFCA_0_GEP]], align 4
-; CHECK-NEXT: [[DOTFCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i32 0, i32 1
-; CHECK-NEXT: store i32 0, i32* [[DOTFCA_1_GEP]], align 4
-; CHECK-NEXT: [[RETVAL_BASE:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i64 0, i64 0
-; CHECK-NEXT: [[RETVAL:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i64 0, i64 1
-; CHECK-NEXT: [[SOME_ANOTHER_ALLOCA:%.*]] = getelementptr inbounds [42 x i32], [42 x i32]* [[SOME_ANOTHER_ALLOCA_FULL]], i64 0, i64 0
+; CHECK-NEXT: [[DOTFCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 0
+; CHECK-NEXT: store i32 0, ptr [[DOTFCA_0_GEP]], align 4
+; CHECK-NEXT: [[DOTFCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 1
+; CHECK-NEXT: store i32 0, ptr [[DOTFCA_1_GEP]], align 4
+; CHECK-NEXT: [[RETVAL:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i64 0, i64 1
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[LOOP]] ]
-; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[DATA:%.*]], i64 [[INDVARS_IV]]
-; CHECK-NEXT: [[LD:%.*]] = load i32, i32* [[ARRAYIDX]], align 4
-; CHECK-NEXT: [[RDX:%.*]] = load i32, i32* [[RETVAL]], align 4
+; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[DATA:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT: [[LD:%.*]] = load i32, ptr [[ARRAYIDX]], align 4
+; CHECK-NEXT: [[RDX:%.*]] = load i32, ptr [[RETVAL]], align 4
; CHECK-NEXT: [[RDX_INC:%.*]] = add nsw i32 [[RDX]], [[LD]]
-; CHECK-NEXT: store i32 [[RDX_INC]], i32* [[RETVAL]], align 4
+; CHECK-NEXT: store i32 [[RDX_INC]], ptr [[RETVAL]], align 4
; CHECK-NEXT: [[INDVARS_IV_NEXT]] = add nsw i64 [[INDVARS_IV]], 1
; CHECK-NEXT: [[EXITCOND:%.*]] = icmp ne i64 [[INDVARS_IV_NEXT]], [[N:%.*]]
; CHECK-NEXT: br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT:%.*]]
; CHECK: exit:
-; CHECK-NEXT: [[I0:%.*]] = call i32 @user_of_alloca_with_multiple_args(i32* [[RETVAL]], i32* [[RETVAL_BASE]])
-; CHECK-NEXT: [[I1:%.*]] = call i32 @user_of_alloca_with_multiple_args(i32* [[RETVAL_BASE]], i32* [[RETVAL]])
-; CHECK-NEXT: [[I2:%.*]] = call i32 @capture_of_alloca(i32* [[SOME_ANOTHER_ALLOCA]])
-; CHECK-NEXT: [[I3_FCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i32 0, i32 0
-; CHECK-NEXT: [[I3_FCA_0_LOAD:%.*]] = load i32, i32* [[I3_FCA_0_GEP]], align 4
+; CHECK-NEXT: [[I0:%.*]] = call i32 @user_of_alloca_with_multiple_args(ptr [[RETVAL]], ptr [[RETVAL_FULL]])
+; CHECK-NEXT: [[I1:%.*]] = call i32 @user_of_alloca_with_multiple_args(ptr [[RETVAL_FULL]], ptr [[RETVAL]])
+; CHECK-NEXT: [[I2:%.*]] = call i32 @capture_of_alloca(ptr [[SOME_ANOTHER_ALLOCA_FULL]])
+; CHECK-NEXT: [[I3_FCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 0
+; CHECK-NEXT: [[I3_FCA_0_LOAD:%.*]] = load i32, ptr [[I3_FCA_0_GEP]], align 4
; CHECK-NEXT: [[I3_FCA_0_INSERT:%.*]] = insertvalue [2 x i32] poison, i32 [[I3_FCA_0_LOAD]], 0
-; CHECK-NEXT: [[I3_FCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i32 0, i32 1
-; CHECK-NEXT: [[I3_FCA_1_LOAD:%.*]] = load i32, i32* [[I3_FCA_1_GEP]], align 4
+; CHECK-NEXT: [[I3_FCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 1
+; CHECK-NEXT: [[I3_FCA_1_LOAD:%.*]] = load i32, ptr [[I3_FCA_1_GEP]], align 4
; CHECK-NEXT: [[I3_FCA_1_INSERT:%.*]] = insertvalue [2 x i32] [[I3_FCA_0_INSERT]], i32 [[I3_FCA_1_LOAD]], 1
; CHECK-NEXT: ret [2 x i32] [[I3_FCA_1_INSERT]]
;
@@ -1146,9 +1132,7 @@ define [2 x i32] @all_parts_of_alloca_used_in_calls_with_multiple_args(i32* %dat
; CHECK-OPAQUE-NEXT: store i32 0, ptr [[DOTFCA_0_GEP]], align 4
; CHECK-OPAQUE-NEXT: [[DOTFCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 1
; CHECK-OPAQUE-NEXT: store i32 0, ptr [[DOTFCA_1_GEP]], align 4
-; CHECK-OPAQUE-NEXT: [[RETVAL_BASE:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i64 0, i64 0
; CHECK-OPAQUE-NEXT: [[RETVAL:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i64 0, i64 1
-; CHECK-OPAQUE-NEXT: [[SOME_ANOTHER_ALLOCA:%.*]] = getelementptr inbounds [42 x i32], ptr [[SOME_ANOTHER_ALLOCA_FULL]], i64 0, i64 0
; CHECK-OPAQUE-NEXT: br label [[LOOP:%.*]]
; CHECK-OPAQUE: loop:
; CHECK-OPAQUE-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[LOOP]] ]
@@ -1161,9 +1145,9 @@ define [2 x i32] @all_parts_of_alloca_used_in_calls_with_multiple_args(i32* %dat
; CHECK-OPAQUE-NEXT: [[EXITCOND:%.*]] = icmp ne i64 [[INDVARS_IV_NEXT]], [[N:%.*]]
; CHECK-OPAQUE-NEXT: br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT:%.*]]
; CHECK-OPAQUE: exit:
-; CHECK-OPAQUE-NEXT: [[I0:%.*]] = call i32 @user_of_alloca_with_multiple_args(ptr [[RETVAL]], ptr [[RETVAL_BASE]])
-; CHECK-OPAQUE-NEXT: [[I1:%.*]] = call i32 @user_of_alloca_with_multiple_args(ptr [[RETVAL_BASE]], ptr [[RETVAL]])
-; CHECK-OPAQUE-NEXT: [[I2:%.*]] = call i32 @capture_of_alloca(ptr [[SOME_ANOTHER_ALLOCA]])
+; CHECK-OPAQUE-NEXT: [[I0:%.*]] = call i32 @user_of_alloca_with_multiple_args(ptr [[RETVAL]], ptr [[RETVAL_FULL]])
+; CHECK-OPAQUE-NEXT: [[I1:%.*]] = call i32 @user_of_alloca_with_multiple_args(ptr [[RETVAL_FULL]], ptr [[RETVAL]])
+; CHECK-OPAQUE-NEXT: [[I2:%.*]] = call i32 @capture_of_alloca(ptr [[SOME_ANOTHER_ALLOCA_FULL]])
; CHECK-OPAQUE-NEXT: [[I3_FCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 0
; CHECK-OPAQUE-NEXT: [[I3_FCA_0_LOAD:%.*]] = load i32, ptr [[I3_FCA_0_GEP]], align 4
; CHECK-OPAQUE-NEXT: [[I3_FCA_0_INSERT:%.*]] = insertvalue [2 x i32] poison, i32 [[I3_FCA_0_LOAD]], 0
@@ -1175,37 +1159,35 @@ define [2 x i32] @all_parts_of_alloca_used_in_calls_with_multiple_args(i32* %dat
entry:
%retval.full = alloca [2 x i32], align 4
%some.another.alloca.full = alloca [42 x i32], align 4
- store [2 x i32] zeroinitializer, [2 x i32]* %retval.full, align 4
- %retval.base = getelementptr inbounds [2 x i32], [2 x i32]* %retval.full, i64 0, i64 0
- %retval = getelementptr inbounds [2 x i32], [2 x i32]* %retval.full, i64 0, i64 1
- %some.another.alloca = getelementptr inbounds [42 x i32], [42 x i32]* %some.another.alloca.full, i64 0, i64 0
+ store [2 x i32] zeroinitializer, ptr %retval.full, align 4
+ %retval = getelementptr inbounds [2 x i32], ptr %retval.full, i64 0, i64 1
br label %loop
loop:
%indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %loop ]
- %arrayidx = getelementptr inbounds i32, i32* %data, i64 %indvars.iv
- %ld = load i32, i32* %arrayidx, align 4
- %rdx = load i32, i32* %retval, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %data, i64 %indvars.iv
+ %ld = load i32, ptr %arrayidx, align 4
+ %rdx = load i32, ptr %retval, align 4
%rdx.inc = add nsw i32 %rdx, %ld
- store i32 %rdx.inc, i32* %retval, align 4
+ store i32 %rdx.inc, ptr %retval, align 4
%indvars.iv.next = add nsw i64 %indvars.iv, 1
%exitcond = icmp ne i64 %indvars.iv.next, %n
br i1 %exitcond, label %loop, label %exit
exit:
- %i0 = call i32 @user_of_alloca_with_multiple_args(i32* %retval, i32* %retval.base)
- %i1 = call i32 @user_of_alloca_with_multiple_args(i32* %retval.base, i32* %retval)
- %i2 = call i32 @capture_of_alloca(i32* %some.another.alloca)
- %i3 = load [2 x i32], [2 x i32]* %retval.full, align 4
+ %i0 = call i32 @user_of_alloca_with_multiple_args(ptr %retval, ptr %retval.full)
+ %i1 = call i32 @user_of_alloca_with_multiple_args(ptr %retval.full, ptr %retval)
+ %i2 = call i32 @capture_of_alloca(ptr %some.another.alloca.full)
+ %i3 = load [2 x i32], ptr %retval.full, align 4
ret [2 x i32] %i3
}
-define i32 @all_uses_of_alloca_are_calls(i32* %data, i64 %n) {
+define i32 @all_uses_of_alloca_are_calls(ptr %data, i64 %n) {
; CHECK-LABEL: @all_uses_of_alloca_are_calls(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[RETVAL:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[TMP0:%.*]] = call i32 @user_of_alloca(i32* [[RETVAL]])
-; CHECK-NEXT: [[TMP1:%.*]] = call i32 @user_of_alloca(i32* [[RETVAL]])
+; CHECK-NEXT: [[TMP0:%.*]] = call i32 @user_of_alloca(ptr [[RETVAL]])
+; CHECK-NEXT: [[TMP1:%.*]] = call i32 @user_of_alloca(ptr [[RETVAL]])
; CHECK-NEXT: ret i32 0
;
; CHECK-OPAQUE-LABEL: @all_uses_of_alloca_are_calls(
@@ -1217,26 +1199,25 @@ define i32 @all_uses_of_alloca_are_calls(i32* %data, i64 %n) {
;
entry:
%retval = alloca i32, align 4
- call i32 @user_of_alloca(i32* %retval)
- call i32 @user_of_alloca(i32* %retval)
+ call i32 @user_of_alloca(ptr %retval)
+ call i32 @user_of_alloca(ptr %retval)
ret i32 0
}
-declare void @llvm.lifetime.start.p0i8(i64 immarg, i8*)
+declare void @llvm.lifetime.start.p0(i64 immarg, ptr)
define i64 @do_schedule_instrs_for_dce_after_fixups() {
; CHECK-LABEL: @do_schedule_instrs_for_dce_after_fixups(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[C:%.*]] = alloca i64, align 2
-; CHECK-NEXT: [[TMP0:%.*]] = bitcast i64* [[C]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 1, i8* [[TMP0]])
-; CHECK-NEXT: store i64 0, i64* [[C]], align 4
-; CHECK-NEXT: [[ARRAYDECAY:%.*]] = bitcast i64* [[C]] to i32*
+; CHECK-NEXT: [[TMP0:%.*]] = bitcast ptr [[C]] to ptr
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 1, ptr [[TMP0]])
+; CHECK-NEXT: store i64 0, ptr [[C]], align 4
; CHECK-NEXT: br label [[IF_END:%.*]]
; CHECK: if.end:
-; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds i32, i32* [[ARRAYDECAY]], i64 1
-; CHECK-NEXT: [[TMP1:%.*]] = call i32 @user_of_alloca(i32* [[ADD_PTR]])
-; CHECK-NEXT: [[LD:%.*]] = load i64, i64* [[C]], align 4
+; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds i32, ptr [[C]], i64 1
+; CHECK-NEXT: [[TMP1:%.*]] = call i32 @user_of_alloca(ptr [[ADD_PTR]])
+; CHECK-NEXT: [[LD:%.*]] = load i64, ptr [[C]], align 4
; CHECK-NEXT: ret i64 [[LD]]
;
; CHECK-OPAQUE-LABEL: @do_schedule_instrs_for_dce_after_fixups(
@@ -1245,26 +1226,24 @@ define i64 @do_schedule_instrs_for_dce_after_fixups() {
; CHECK-OPAQUE-NEXT: [[TMP0:%.*]] = bitcast ptr [[C]] to ptr
; CHECK-OPAQUE-NEXT: call void @llvm.lifetime.start.p0(i64 1, ptr [[TMP0]])
; CHECK-OPAQUE-NEXT: store i64 0, ptr [[C]], align 4
-; CHECK-OPAQUE-NEXT: [[ARRAYDECAY:%.*]] = bitcast ptr [[C]] to ptr
; CHECK-OPAQUE-NEXT: br label [[IF_END:%.*]]
; CHECK-OPAQUE: if.end:
-; CHECK-OPAQUE-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds i32, ptr [[ARRAYDECAY]], i64 1
+; CHECK-OPAQUE-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds i32, ptr [[C]], i64 1
; CHECK-OPAQUE-NEXT: [[TMP1:%.*]] = call i32 @user_of_alloca(ptr [[ADD_PTR]])
; CHECK-OPAQUE-NEXT: [[LD:%.*]] = load i64, ptr [[C]], align 4
; CHECK-OPAQUE-NEXT: ret i64 [[LD]]
;
entry:
%c = alloca i64, align 2
- %0 = bitcast i64* %c to i8*
- call void @llvm.lifetime.start.p0i8(i64 1, i8* %0)
- store i64 0, i64* %c
- %arraydecay = bitcast i64* %c to i32*
+ %0 = bitcast ptr %c to ptr
+ call void @llvm.lifetime.start.p0(i64 1, ptr %0)
+ store i64 0, ptr %c
br label %if.end
if.end: ; preds = %entry
- %add.ptr = getelementptr inbounds i32, i32* %arraydecay, i64 1
- call i32 @user_of_alloca(i32* %add.ptr)
- %ld = load i64, i64* %c
+ %add.ptr = getelementptr inbounds i32, ptr %c, i64 1
+ call i32 @user_of_alloca(ptr %add.ptr)
+ %ld = load i64, ptr %c
ret i64 %ld
}
@@ -1272,8 +1251,8 @@ define void @dont_transform_store_only() {
; CHECK-LABEL: @dont_transform_store_only(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca i8, align 1
-; CHECK-NEXT: store i8 0, i8* [[A]], align 1
-; CHECK-NEXT: call void @byte_user_of_alloca(i8* [[A]])
+; CHECK-NEXT: store i8 0, ptr [[A]], align 1
+; CHECK-NEXT: call void @byte_user_of_alloca(ptr [[A]])
; CHECK-NEXT: ret void
;
; CHECK-OPAQUE-LABEL: @dont_transform_store_only(
@@ -1285,16 +1264,16 @@ define void @dont_transform_store_only() {
;
entry:
%a = alloca i8
- store i8 0, i8* %a
- call void @byte_user_of_alloca(i8* %a)
+ store i8 0, ptr %a
+ call void @byte_user_of_alloca(ptr %a)
ret void
}
define i8 @dont_transform_load_only() {
; CHECK-LABEL: @dont_transform_load_only(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca i8, align 1
-; CHECK-NEXT: call void @byte_user_of_alloca(i8* [[A]])
-; CHECK-NEXT: [[R:%.*]] = load i8, i8* [[A]], align 1
+; CHECK-NEXT: call void @byte_user_of_alloca(ptr [[A]])
+; CHECK-NEXT: [[R:%.*]] = load i8, ptr [[A]], align 1
; CHECK-NEXT: ret i8 [[R]]
;
; CHECK-OPAQUE-LABEL: @dont_transform_load_only(
@@ -1306,17 +1285,17 @@ define i8 @dont_transform_load_only() {
;
entry:
%a = alloca i8
- call void @byte_user_of_alloca(i8* %a)
- %r = load i8, i8* %a
+ call void @byte_user_of_alloca(ptr %a)
+ %r = load i8, ptr %a
ret i8 %r
}
define i8 @transform_load_and_store() {
; CHECK-LABEL: @transform_load_and_store(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca i8, align 1
-; CHECK-NEXT: store i8 0, i8* [[A]], align 1
-; CHECK-NEXT: call void @byte_user_of_alloca(i8* [[A]])
-; CHECK-NEXT: [[R:%.*]] = load i8, i8* [[A]], align 1
+; CHECK-NEXT: store i8 0, ptr [[A]], align 1
+; CHECK-NEXT: call void @byte_user_of_alloca(ptr [[A]])
+; CHECK-NEXT: [[R:%.*]] = load i8, ptr [[A]], align 1
; CHECK-NEXT: ret i8 [[R]]
;
; CHECK-OPAQUE-LABEL: @transform_load_and_store(
@@ -1329,30 +1308,29 @@ define i8 @transform_load_and_store() {
;
entry:
%a = alloca i8
- store i8 0, i8* %a
- call void @byte_user_of_alloca(i8* %a)
- %r = load i8, i8* %a
+ store i8 0, ptr %a
+ call void @byte_user_of_alloca(ptr %a)
+ %r = load i8, ptr %a
ret i8 %r
}
-define [2 x i32] @select_of_ptrs(i32* %data, i1 %c, i32 %v) {
+define [2 x i32] @select_of_ptrs(ptr %data, i1 %c, i32 %v) {
; CHECK-LABEL: @select_of_ptrs(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[RETVAL_FULL:%.*]] = alloca [2 x i32], align 4
-; CHECK-NEXT: [[DOTFCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i32 0, i32 0
-; CHECK-NEXT: store i32 0, i32* [[DOTFCA_0_GEP]], align 4
-; CHECK-NEXT: [[DOTFCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i32 0, i32 1
-; CHECK-NEXT: store i32 0, i32* [[DOTFCA_1_GEP]], align 4
-; CHECK-NEXT: [[RETVAL_BASE:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i64 0, i64 0
-; CHECK-NEXT: [[RETVAL:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i64 0, i64 1
-; CHECK-NEXT: [[PTR:%.*]] = select i1 [[C:%.*]], i32* [[RETVAL_BASE]], i32* [[RETVAL]]
-; CHECK-NEXT: store i32 [[V:%.*]], i32* [[PTR]], align 4
-; CHECK-NEXT: [[I0:%.*]] = call i32 @user_of_alloca(i32* [[RETVAL_BASE]])
-; CHECK-NEXT: [[I1_FCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i32 0, i32 0
-; CHECK-NEXT: [[I1_FCA_0_LOAD:%.*]] = load i32, i32* [[I1_FCA_0_GEP]], align 4
+; CHECK-NEXT: [[DOTFCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 0
+; CHECK-NEXT: store i32 0, ptr [[DOTFCA_0_GEP]], align 4
+; CHECK-NEXT: [[DOTFCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 1
+; CHECK-NEXT: store i32 0, ptr [[DOTFCA_1_GEP]], align 4
+; CHECK-NEXT: [[RETVAL:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i64 0, i64 1
+; CHECK-NEXT: [[PTR:%.*]] = select i1 [[C:%.*]], ptr [[RETVAL_FULL]], ptr [[RETVAL]]
+; CHECK-NEXT: store i32 [[V:%.*]], ptr [[PTR]], align 4
+; CHECK-NEXT: [[I0:%.*]] = call i32 @user_of_alloca(ptr [[RETVAL_FULL]])
+; CHECK-NEXT: [[I1_FCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 0
+; CHECK-NEXT: [[I1_FCA_0_LOAD:%.*]] = load i32, ptr [[I1_FCA_0_GEP]], align 4
; CHECK-NEXT: [[I1_FCA_0_INSERT:%.*]] = insertvalue [2 x i32] poison, i32 [[I1_FCA_0_LOAD]], 0
-; CHECK-NEXT: [[I1_FCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RETVAL_FULL]], i32 0, i32 1
-; CHECK-NEXT: [[I1_FCA_1_LOAD:%.*]] = load i32, i32* [[I1_FCA_1_GEP]], align 4
+; CHECK-NEXT: [[I1_FCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 1
+; CHECK-NEXT: [[I1_FCA_1_LOAD:%.*]] = load i32, ptr [[I1_FCA_1_GEP]], align 4
; CHECK-NEXT: [[I1_FCA_1_INSERT:%.*]] = insertvalue [2 x i32] [[I1_FCA_0_INSERT]], i32 [[I1_FCA_1_LOAD]], 1
; CHECK-NEXT: ret [2 x i32] [[I1_FCA_1_INSERT]]
;
@@ -1363,11 +1341,10 @@ define [2 x i32] @select_of_ptrs(i32* %data, i1 %c, i32 %v) {
; CHECK-OPAQUE-NEXT: store i32 0, ptr [[DOTFCA_0_GEP]], align 4
; CHECK-OPAQUE-NEXT: [[DOTFCA_1_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 1
; CHECK-OPAQUE-NEXT: store i32 0, ptr [[DOTFCA_1_GEP]], align 4
-; CHECK-OPAQUE-NEXT: [[RETVAL_BASE:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i64 0, i64 0
; CHECK-OPAQUE-NEXT: [[RETVAL:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i64 0, i64 1
-; CHECK-OPAQUE-NEXT: [[PTR:%.*]] = select i1 [[C:%.*]], ptr [[RETVAL_BASE]], ptr [[RETVAL]]
+; CHECK-OPAQUE-NEXT: [[PTR:%.*]] = select i1 [[C:%.*]], ptr [[RETVAL_FULL]], ptr [[RETVAL]]
; CHECK-OPAQUE-NEXT: store i32 [[V:%.*]], ptr [[PTR]], align 4
-; CHECK-OPAQUE-NEXT: [[I0:%.*]] = call i32 @user_of_alloca(ptr [[RETVAL_BASE]])
+; CHECK-OPAQUE-NEXT: [[I0:%.*]] = call i32 @user_of_alloca(ptr [[RETVAL_FULL]])
; CHECK-OPAQUE-NEXT: [[I1_FCA_0_GEP:%.*]] = getelementptr inbounds [2 x i32], ptr [[RETVAL_FULL]], i32 0, i32 0
; CHECK-OPAQUE-NEXT: [[I1_FCA_0_LOAD:%.*]] = load i32, ptr [[I1_FCA_0_GEP]], align 4
; CHECK-OPAQUE-NEXT: [[I1_FCA_0_INSERT:%.*]] = insertvalue [2 x i32] poison, i32 [[I1_FCA_0_LOAD]], 0
@@ -1378,23 +1355,22 @@ define [2 x i32] @select_of_ptrs(i32* %data, i1 %c, i32 %v) {
;
entry:
%retval.full = alloca [2 x i32], align 4
- store [2 x i32] zeroinitializer, [2 x i32]* %retval.full, align 4
- %retval.base = getelementptr inbounds [2 x i32], [2 x i32]* %retval.full, i64 0, i64 0
- %retval = getelementptr inbounds [2 x i32], [2 x i32]* %retval.full, i64 0, i64 1
- %ptr = select i1 %c, i32* %retval.base, i32* %retval
- store i32 %v, i32* %ptr
- %i0 = call i32 @user_of_alloca(i32* %retval.base)
- %i1 = load [2 x i32], [2 x i32]* %retval.full, align 4
+ store [2 x i32] zeroinitializer, ptr %retval.full, align 4
+ %retval = getelementptr inbounds [2 x i32], ptr %retval.full, i64 0, i64 1
+ %ptr = select i1 %c, ptr %retval.full, ptr %retval
+ store i32 %v, ptr %ptr
+ %i0 = call i32 @user_of_alloca(ptr %retval.full)
+ %i1 = load [2 x i32], ptr %retval.full, align 4
ret [2 x i32] %i1
}
-declare dso_local i32 @user_of_alloca(i32* nocapture readonly)
-declare dso_local i32 @user_of_alloca_with_multiple_args(i32* nocapture readonly, i32* nocapture readonly)
-declare dso_local i32 @capture_of_alloca(i32 *)
-declare dso_local i32 @capture_with_multiple_args(i32* nocapture readonly, i32*)
+declare dso_local i32 @user_of_alloca(ptr nocapture readonly)
+declare dso_local i32 @user_of_alloca_with_multiple_args(ptr nocapture readonly, ptr nocapture readonly)
+declare dso_local i32 @capture_of_alloca(ptr)
+declare dso_local i32 @capture_with_multiple_args(ptr nocapture readonly, ptr)
-declare dso_local void @byte_user_of_alloca(i8* nocapture readonly)
+declare dso_local void @byte_user_of_alloca(ptr nocapture readonly)
declare dso_local i32 @__gxx_personality_v0(...)
-declare void @llvm.memcpy.p0i32.p0i32.i32(i32*, i32*, i32, i1)
+declare void @llvm.memcpy.p0.p0.i32(ptr, ptr, i32, i1)
diff --git a/llvm/test/Transforms/SROA/non-integral-pointers.ll b/llvm/test/Transforms/SROA/non-integral-pointers.ll
index 6815b74d55f2..75919f455dc3 100644
--- a/llvm/test/Transforms/SROA/non-integral-pointers.ll
+++ b/llvm/test/Transforms/SROA/non-integral-pointers.ll
@@ -14,89 +14,85 @@ define void @f0(i1 %alwaysFalse, i64 %val) {
; CHECK-NOT: ptrtoint
entry:
%loc = alloca i64
- store i64 %val, i64* %loc
+ store i64 %val, ptr %loc
br i1 %alwaysFalse, label %neverTaken, label %alwaysTaken
neverTaken:
- %loc.bc = bitcast i64* %loc to i8 addrspace(4)**
- %ptr = load i8 addrspace(4)*, i8 addrspace(4)** %loc.bc
- store i8 5, i8 addrspace(4)* %ptr
+ %ptr = load ptr addrspace(4), ptr %loc
+ store i8 5, ptr addrspace(4) %ptr
ret void
alwaysTaken:
ret void
}
-define i64 @f1(i1 %alwaysFalse, i8 addrspace(4)* %val) {
+define i64 @f1(i1 %alwaysFalse, ptr addrspace(4) %val) {
; CHECK-LABEL: @f1(
; CHECK-NOT: inttoptr
; CHECK-NOT: ptrtoint
entry:
- %loc = alloca i8 addrspace(4)*
- store i8 addrspace(4)* %val, i8 addrspace(4)** %loc
+ %loc = alloca ptr addrspace(4)
+ store ptr addrspace(4) %val, ptr %loc
br i1 %alwaysFalse, label %neverTaken, label %alwaysTaken
neverTaken:
- %loc.bc = bitcast i8 addrspace(4)** %loc to i64*
- %int = load i64, i64* %loc.bc
+ %int = load i64, ptr %loc
ret i64 %int
alwaysTaken:
ret i64 42
}
-define i64 addrspace(4)* @memset(i1 %alwaysFalse) {
+define ptr addrspace(4) @memset(i1 %alwaysFalse) {
; CHECK-LABEL: @memset(
; CHECK-NOT: inttoptr
; CHECK-NOT: ptrtoint
entry:
- %x = alloca i64 addrspace(4)*
- %cast.0 = bitcast i64 addrspace(4)** %x to i8*
- call void @llvm.memset.p0i8.i64(i8* align 8 %cast.0, i8 5, i64 16, i1 false)
+ %x = alloca ptr addrspace(4)
+ call void @llvm.memset.p0.i64(ptr align 8 %x, i8 5, i64 16, i1 false)
br i1 %alwaysFalse, label %neverTaken, label %alwaysTaken
neverTaken:
- %x.field.ld.0 = load i64 addrspace(4)*, i64 addrspace(4)** %x
- ret i64 addrspace(4)* %x.field.ld.0
+ %x.field.ld.0 = load ptr addrspace(4), ptr %x
+ ret ptr addrspace(4) %x.field.ld.0
alwaysTaken:
- ret i64 addrspace(4)* null
+ ret ptr addrspace(4) null
}
;; TODO: This one demonstrates a missed oppurtunity. The only known bit
;; pattern for a non-integral bit pattern is that null is zero. As such
;; we could do SROA and replace the memset w/a null store. This will
;; usually be gotten by instcombine.
-define i64 addrspace(4)* @memset_null(i1 %alwaysFalse) {
+define ptr addrspace(4) @memset_null(i1 %alwaysFalse) {
; CHECK-LABEL: @memset_null(
; CHECK-NOT: inttoptr
; CHECK-NOT: ptrtoint
entry:
- %x = alloca i64 addrspace(4)*
- %cast.0 = bitcast i64 addrspace(4)** %x to i8*
- call void @llvm.memset.p0i8.i64(i8* align 8 %cast.0, i8 0, i64 16, i1 false)
+ %x = alloca ptr addrspace(4)
+ call void @llvm.memset.p0.i64(ptr align 8 %x, i8 0, i64 16, i1 false)
br i1 %alwaysFalse, label %neverTaken, label %alwaysTaken
neverTaken:
- %x.field.ld.0 = load i64 addrspace(4)*, i64 addrspace(4)** %x
- ret i64 addrspace(4)* %x.field.ld.0
+ %x.field.ld.0 = load ptr addrspace(4), ptr %x
+ ret ptr addrspace(4) %x.field.ld.0
alwaysTaken:
- ret i64 addrspace(4)* null
+ ret ptr addrspace(4) null
}
-%union.anon = type { i32* }
+%union.anon = type { ptr }
; CHECK-LABEL: @f2(
; CHECK-NOT: ptr2int
; CHECK-NOT: int2ptr
-define i8 *@f2(i8 addrspace(4)* %p) {
+define ptr at f2(ptr addrspace(4) %p) {
%1 = alloca %union.anon, align 8
- %2 = bitcast %union.anon* %1 to i8 addrspace(4)**
- store i8 addrspace(4)* %p, i8 addrspace(4)** %2, align 8
- %3 = bitcast %union.anon* %1 to i8**
- %4 = load i8*, i8** %3, align 8
- ret i8* %4
+ %2 = bitcast ptr %1 to ptr
+ store ptr addrspace(4) %p, ptr %2, align 8
+ %3 = bitcast ptr %1 to ptr
+ %4 = load ptr, ptr %3, align 8
+ ret ptr %4
}
-declare void @llvm.memset.p0i8.i64(i8*, i8, i64, i1)
+declare void @llvm.memset.p0.i64(ptr, i8, i64, i1)
diff --git a/llvm/test/Transforms/SROA/phi-and-select.ll b/llvm/test/Transforms/SROA/phi-and-select.ll
index ab7398df58cf..255fe341f324 100644
--- a/llvm/test/Transforms/SROA/phi-and-select.ll
+++ b/llvm/test/Transforms/SROA/phi-and-select.ll
@@ -16,12 +16,11 @@ define i32 @test1() {
entry:
%a = alloca [2 x i32]
- %a0 = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 0
- %a1 = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 1
- store i32 0, i32* %a0
- store i32 1, i32* %a1
- %v0 = load i32, i32* %a0
- %v1 = load i32, i32* %a1
+ %a1 = getelementptr [2 x i32], ptr %a, i64 0, i32 1
+ store i32 0, ptr %a
+ store i32 1, ptr %a1
+ %v0 = load i32, ptr %a
+ %v1 = load i32, ptr %a1
%cond = icmp sle i32 %v0, %v1
br i1 %cond, label %then, label %exit
@@ -30,9 +29,9 @@ then:
br label %exit
exit:
- %phi = phi i32* [ %a1, %then ], [ %a0, %entry ]
+ %phi = phi ptr [ %a1, %then ], [ %a, %entry ]
- %result = load i32, i32* %phi
+ %result = load i32, ptr %phi
ret i32 %result
}
@@ -46,17 +45,16 @@ define i32 @test2() {
entry:
%a = alloca [2 x i32]
- %a0 = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 0
- %a1 = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 1
- store i32 0, i32* %a0
- store i32 1, i32* %a1
- %v0 = load i32, i32* %a0
- %v1 = load i32, i32* %a1
+ %a1 = getelementptr [2 x i32], ptr %a, i64 0, i32 1
+ store i32 0, ptr %a
+ store i32 1, ptr %a1
+ %v0 = load i32, ptr %a
+ %v1 = load i32, ptr %a1
%cond = icmp sle i32 %v0, %v1
- %select = select i1 %cond, i32* %a1, i32* %a0
+ %select = select i1 %cond, ptr %a1, ptr %a
- %result = load i32, i32* %select
+ %result = load i32, ptr %select
ret i32 %result
}
@@ -71,16 +69,14 @@ define float @test2_bitcast() {
;
entry:
%a = alloca [2 x i32]
- %a0 = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 0
- %a1 = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 1
- store i32 0, i32* %a0
- store i32 1, i32* %a1
- %v0 = load i32, i32* %a0
- %v1 = load i32, i32* %a1
+ %a1 = getelementptr [2 x i32], ptr %a, i64 0, i32 1
+ store i32 0, ptr %a
+ store i32 1, ptr %a1
+ %v0 = load i32, ptr %a
+ %v1 = load i32, ptr %a1
%cond = icmp sle i32 %v0, %v1
- %select = select i1 %cond, i32* %a1, i32* %a0
- %select.bc = bitcast i32* %select to float*
- %result = load float, float* %select.bc
+ %select = select i1 %cond, ptr %a1, ptr %a
+ %result = load float, ptr %select
ret float %result
}
@@ -89,28 +85,27 @@ define i32 @test2_addrspacecast() {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A_SROA_0:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[A_SROA_3:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 0, i32* [[A_SROA_0]], align 4
-; CHECK-NEXT: store i32 1, i32* [[A_SROA_3]], align 4
-; CHECK-NEXT: [[A_SROA_0_0_A_SROA_0_0_V0:%.*]] = load i32, i32* [[A_SROA_0]], align 4
-; CHECK-NEXT: [[A_SROA_3_0_A_SROA_3_4_V1:%.*]] = load i32, i32* [[A_SROA_3]], align 4
+; CHECK-NEXT: store i32 0, ptr [[A_SROA_0]], align 4
+; CHECK-NEXT: store i32 1, ptr [[A_SROA_3]], align 4
+; CHECK-NEXT: [[A_SROA_0_0_A_SROA_0_0_V0:%.*]] = load i32, ptr [[A_SROA_0]], align 4
+; CHECK-NEXT: [[A_SROA_3_0_A_SROA_3_4_V1:%.*]] = load i32, ptr [[A_SROA_3]], align 4
; CHECK-NEXT: [[COND:%.*]] = icmp sle i32 [[A_SROA_0_0_A_SROA_0_0_V0]], [[A_SROA_3_0_A_SROA_3_4_V1]]
-; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], i32* [[A_SROA_3]], i32* [[A_SROA_0]]
-; CHECK-NEXT: [[SELECT_ASC:%.*]] = addrspacecast i32* [[SELECT]] to i32 addrspace(1)*
-; CHECK-NEXT: [[RESULT:%.*]] = load i32, i32 addrspace(1)* [[SELECT_ASC]], align 4
+; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], ptr [[A_SROA_3]], ptr [[A_SROA_0]]
+; CHECK-NEXT: [[SELECT_ASC:%.*]] = addrspacecast ptr [[SELECT]] to ptr addrspace(1)
+; CHECK-NEXT: [[RESULT:%.*]] = load i32, ptr addrspace(1) [[SELECT_ASC]], align 4
; CHECK-NEXT: ret i32 [[RESULT]]
;
entry:
%a = alloca [2 x i32]
- %a0 = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 0
- %a1 = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 1
- store i32 0, i32* %a0
- store i32 1, i32* %a1
- %v0 = load i32, i32* %a0
- %v1 = load i32, i32* %a1
+ %a1 = getelementptr [2 x i32], ptr %a, i64 0, i32 1
+ store i32 0, ptr %a
+ store i32 1, ptr %a1
+ %v0 = load i32, ptr %a
+ %v1 = load i32, ptr %a1
%cond = icmp sle i32 %v0, %v1
- %select = select i1 %cond, i32* %a1, i32* %a0
- %select.asc = addrspacecast i32* %select to i32 addrspace(1)*
- %result = load i32, i32 addrspace(1)* %select.asc
+ %select = select i1 %cond, ptr %a1, ptr %a
+ %select.asc = addrspacecast ptr %select to ptr addrspace(1)
+ %result = load i32, ptr addrspace(1) %select.asc
ret i32 %result
}
@@ -152,12 +147,10 @@ entry:
; Note that we build redundant GEPs here to ensure that having
diff erent GEPs
; into the same alloca partation continues to work with PHI speculation. This
; was the underlying cause of PR13926.
- %a0 = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 0
- %a0b = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 0
- %a1 = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 1
- %a1b = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 1
- store i32 0, i32* %a0
- store i32 1, i32* %a1
+ %a1 = getelementptr [2 x i32], ptr %a, i64 0, i32 1
+ %a1b = getelementptr [2 x i32], ptr %a, i64 0, i32 1
+ store i32 0, ptr %a
+ store i32 1, ptr %a1
switch i32 %x, label %bb0 [ i32 1, label %bb1
i32 2, label %bb2
@@ -185,10 +178,10 @@ bb7:
br label %exit
exit:
- %phi = phi i32* [ %a1, %bb0 ], [ %a0, %bb1 ], [ %a0, %bb2 ], [ %a1, %bb3 ],
- [ %a1b, %bb4 ], [ %a0b, %bb5 ], [ %a0b, %bb6 ], [ %a1b, %bb7 ]
+ %phi = phi ptr [ %a1, %bb0 ], [ %a, %bb1 ], [ %a, %bb2 ], [ %a1, %bb3 ],
+ [ %a1b, %bb4 ], [ %a, %bb5 ], [ %a, %bb6 ], [ %a1b, %bb7 ]
- %result = load i32, i32* %phi
+ %result = load i32, ptr %phi
ret i32 %result
}
@@ -200,21 +193,20 @@ define i32 @test4() {
entry:
%a = alloca [2 x i32]
- %a0 = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 0
- %a1 = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 1
- store i32 0, i32* %a0
- store i32 1, i32* %a1
- %v0 = load i32, i32* %a0
- %v1 = load i32, i32* %a1
+ %a1 = getelementptr [2 x i32], ptr %a, i64 0, i32 1
+ store i32 0, ptr %a
+ store i32 1, ptr %a1
+ %v0 = load i32, ptr %a
+ %v1 = load i32, ptr %a1
%cond = icmp sle i32 %v0, %v1
- %select = select i1 %cond, i32* %a0, i32* %a0
+ %select = select i1 %cond, ptr %a, ptr %a
- %result = load i32, i32* %select
+ %result = load i32, ptr %select
ret i32 %result
}
-define i32 @test5(i32* %b) {
+define i32 @test5(ptr %b) {
; CHECK-LABEL: @test5(
; CHECK-NEXT: entry:
; CHECK-NEXT: ret i32 1
@@ -222,45 +214,45 @@ define i32 @test5(i32* %b) {
entry:
%a = alloca [2 x i32]
- %a1 = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 1
- store i32 1, i32* %a1
+ %a1 = getelementptr [2 x i32], ptr %a, i64 0, i32 1
+ store i32 1, ptr %a1
- %select = select i1 true, i32* %a1, i32* %b
+ %select = select i1 true, ptr %a1, ptr %b
- %result = load i32, i32* %select
+ %result = load i32, ptr %select
ret i32 %result
}
-declare void @f(i32*, i32*)
+declare void @f(ptr, ptr)
-define i32 @test6(i32* %b) {
+define i32 @test6(ptr %b) {
; CHECK-LABEL: @test6(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[SELECT2:%.*]] = select i1 false, i32* poison, i32* [[B:%.*]]
-; CHECK-NEXT: [[SELECT3:%.*]] = select i1 false, i32* poison, i32* [[B]]
-; CHECK-NEXT: call void @f(i32* [[SELECT2]], i32* [[SELECT3]])
+; CHECK-NEXT: [[SELECT2:%.*]] = select i1 false, ptr poison, ptr [[B:%.*]]
+; CHECK-NEXT: [[SELECT3:%.*]] = select i1 false, ptr poison, ptr [[B]]
+; CHECK-NEXT: call void @f(ptr [[SELECT2]], ptr [[SELECT3]])
; CHECK-NEXT: ret i32 1
;
entry:
%a = alloca [2 x i32]
%c = alloca i32
- %a1 = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 1
- store i32 1, i32* %a1
+ %a1 = getelementptr [2 x i32], ptr %a, i64 0, i32 1
+ store i32 1, ptr %a1
- %select = select i1 true, i32* %a1, i32* %b
- %select2 = select i1 false, i32* %a1, i32* %b
- %select3 = select i1 false, i32* %c, i32* %b
+ %select = select i1 true, ptr %a1, ptr %b
+ %select2 = select i1 false, ptr %a1, ptr %b
+ %select3 = select i1 false, ptr %c, ptr %b
; Note, this would potentially escape the alloca pointer except for the
; constant folding of the select.
- call void @f(i32* %select2, i32* %select3)
+ call void @f(ptr %select2, ptr %select3)
- %result = load i32, i32* %select
+ %result = load i32, ptr %select
- %dead = load i32, i32* %c
+ %dead = load i32, ptr %c
ret i32 %result
}
@@ -272,7 +264,7 @@ define i32 @test7(i1 %c1) {
; CHECK: good:
; CHECK-NEXT: br label [[EXIT:%.*]]
; CHECK: bad:
-; CHECK-NEXT: [[P_SROA_SPECULATE_LOAD_BAD:%.*]] = load i32, i32* poison, align 4
+; CHECK-NEXT: [[P_SROA_SPECULATE_LOAD_BAD:%.*]] = load i32, ptr poison, align 4
; CHECK-NEXT: br label [[EXIT]]
; CHECK: exit:
; CHECK-NEXT: [[P_SROA_SPECULATED:%.*]] = phi i32 [ 0, [[GOOD]] ], [ [[P_SROA_SPECULATE_LOAD_BAD]], [[BAD]] ]
@@ -284,22 +276,21 @@ entry:
br i1 %c1, label %good, label %bad
good:
- %Y1 = getelementptr i32, i32* %X, i64 0
- store i32 0, i32* %Y1
+ store i32 0, ptr %X
br label %exit
bad:
- %Y2 = getelementptr i32, i32* %X, i64 1
- store i32 0, i32* %Y2
+ %Y2 = getelementptr i32, ptr %X, i64 1
+ store i32 0, ptr %Y2
br label %exit
exit:
- %P = phi i32* [ %Y1, %good ], [ %Y2, %bad ]
- %Z2 = load i32, i32* %P
+ %P = phi ptr [ %X, %good ], [ %Y2, %bad ]
+ %Z2 = load i32, ptr %P
ret i32 %Z2
}
-define i32 @test8(i32 %b, i32* %ptr) {
+define i32 @test8(i32 %b, ptr %ptr) {
; Ensure that we rewrite allocas to the used type when that use is hidden by
; a PHI that can be speculated.
; CHECK-LABEL: @test8(
@@ -307,7 +298,7 @@ define i32 @test8(i32 %b, i32* %ptr) {
; CHECK-NEXT: [[TEST:%.*]] = icmp ne i32 [[B:%.*]], 0
; CHECK-NEXT: br i1 [[TEST]], label [[THEN:%.*]], label [[ELSE:%.*]]
; CHECK: then:
-; CHECK-NEXT: [[PHI_SROA_SPECULATE_LOAD_THEN:%.*]] = load i32, i32* [[PTR:%.*]], align 4
+; CHECK-NEXT: [[PHI_SROA_SPECULATE_LOAD_THEN:%.*]] = load i32, ptr [[PTR:%.*]], align 4
; CHECK-NEXT: br label [[EXIT:%.*]]
; CHECK: else:
; CHECK-NEXT: br label [[EXIT]]
@@ -325,52 +316,49 @@ then:
br label %exit
else:
- %bitcast = bitcast float* %f to i32*
br label %exit
exit:
- %phi = phi i32* [ %bitcast, %else ], [ %ptr, %then ]
- %loaded = load i32, i32* %phi, align 4
+ %phi = phi ptr [ %f, %else ], [ %ptr, %then ]
+ %loaded = load i32, ptr %phi, align 4
ret i32 %loaded
}
-define i32 @test9(i32 %b, i32* %ptr) {
+define i32 @test9(i32 %b, ptr %ptr) {
; Same as @test8 but for a select rather than a PHI node.
; CHECK-LABEL: @test9(
; CHECK-NEXT: entry:
-; CHECK-NEXT: store i32 0, i32* [[PTR:%.*]], align 4
+; CHECK-NEXT: store i32 0, ptr [[PTR:%.*]], align 4
; CHECK-NEXT: [[TEST:%.*]] = icmp ne i32 [[B:%.*]], 0
-; CHECK-NEXT: [[LOADED_SROA_SPECULATE_LOAD_FALSE:%.*]] = load i32, i32* [[PTR]], align 4
+; CHECK-NEXT: [[LOADED_SROA_SPECULATE_LOAD_FALSE:%.*]] = load i32, ptr [[PTR]], align 4
; CHECK-NEXT: [[LOADED_SROA_SPECULATED:%.*]] = select i1 [[TEST]], i32 undef, i32 [[LOADED_SROA_SPECULATE_LOAD_FALSE]]
; CHECK-NEXT: ret i32 [[LOADED_SROA_SPECULATED]]
;
entry:
%f = alloca float
- store i32 0, i32* %ptr
+ store i32 0, ptr %ptr
%test = icmp ne i32 %b, 0
- %bitcast = bitcast float* %f to i32*
- %select = select i1 %test, i32* %bitcast, i32* %ptr
- %loaded = load i32, i32* %select, align 4
+ %select = select i1 %test, ptr %f, ptr %ptr
+ %loaded = load i32, ptr %select, align 4
ret i32 %loaded
}
-define float @test10(i32 %b, float* %ptr) {
+define float @test10(i32 %b, ptr %ptr) {
; Don't try to promote allocas which are not elligible for it even after
; rewriting due to the necessity of inserting bitcasts when speculating a PHI
; node.
; CHECK-LABEL: @test10(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[F:%.*]] = alloca double, align 8
-; CHECK-NEXT: store double 0.000000e+00, double* [[F]], align 8
+; CHECK-NEXT: store double 0.000000e+00, ptr [[F]], align 8
; CHECK-NEXT: [[TEST:%.*]] = icmp ne i32 [[B:%.*]], 0
; CHECK-NEXT: br i1 [[TEST]], label [[THEN:%.*]], label [[ELSE:%.*]]
; CHECK: then:
-; CHECK-NEXT: [[PHI_SROA_SPECULATE_LOAD_THEN:%.*]] = load float, float* [[PTR:%.*]], align 4
+; CHECK-NEXT: [[PHI_SROA_SPECULATE_LOAD_THEN:%.*]] = load float, ptr [[PTR:%.*]], align 4
; CHECK-NEXT: br label [[EXIT:%.*]]
; CHECK: else:
-; CHECK-NEXT: [[F_0_F_0_BITCAST_SROA_CAST:%.*]] = bitcast double* [[F]] to float*
-; CHECK-NEXT: [[F_0_PHI_SROA_SPECULATE_LOAD_ELSE:%.*]] = load float, float* [[F_0_F_0_BITCAST_SROA_CAST]], align 8
+; CHECK-NEXT: [[F_0_PHI_SROA_SPECULATE_LOAD_ELSE:%.*]] = load float, ptr [[F]], align 8
; CHECK-NEXT: br label [[EXIT]]
; CHECK: exit:
; CHECK-NEXT: [[PHI_SROA_SPECULATED:%.*]] = phi float [ [[F_0_PHI_SROA_SPECULATE_LOAD_ELSE]], [[ELSE]] ], [ [[PHI_SROA_SPECULATE_LOAD_THEN]], [[THEN]] ]
@@ -379,7 +367,7 @@ define float @test10(i32 %b, float* %ptr) {
entry:
%f = alloca double
- store double 0.0, double* %f
+ store double 0.0, ptr %f
%test = icmp ne i32 %b, 0
br i1 %test, label %then, label %else
@@ -387,42 +375,39 @@ then:
br label %exit
else:
- %bitcast = bitcast double* %f to float*
br label %exit
exit:
- %phi = phi float* [ %bitcast, %else ], [ %ptr, %then ]
- %loaded = load float, float* %phi, align 4
+ %phi = phi ptr [ %f, %else ], [ %ptr, %then ]
+ %loaded = load float, ptr %phi, align 4
ret float %loaded
}
-define float @test11(i32 %b, float* %ptr) {
+define float @test11(i32 %b, ptr %ptr) {
; Same as @test10 but for a select rather than a PHI node.
; CHECK-LABEL: @test11(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[F:%.*]] = alloca double, align 8
-; CHECK-NEXT: store double 0.000000e+00, double* [[F]], align 8
-; CHECK-NEXT: store float 0.000000e+00, float* [[PTR:%.*]], align 4
+; CHECK-NEXT: store double 0.000000e+00, ptr [[F]], align 8
+; CHECK-NEXT: store float 0.000000e+00, ptr [[PTR:%.*]], align 4
; CHECK-NEXT: [[TEST:%.*]] = icmp ne i32 [[B:%.*]], 0
-; CHECK-NEXT: [[F_0_F_0_BITCAST_SROA_CAST:%.*]] = bitcast double* [[F]] to float*
-; CHECK-NEXT: [[F_0_LOADED_SROA_SPECULATE_LOAD_TRUE:%.*]] = load float, float* [[F_0_F_0_BITCAST_SROA_CAST]], align 8
-; CHECK-NEXT: [[LOADED_SROA_SPECULATE_LOAD_FALSE:%.*]] = load float, float* [[PTR]], align 4
+; CHECK-NEXT: [[F_0_LOADED_SROA_SPECULATE_LOAD_TRUE:%.*]] = load float, ptr [[F]], align 8
+; CHECK-NEXT: [[LOADED_SROA_SPECULATE_LOAD_FALSE:%.*]] = load float, ptr [[PTR]], align 4
; CHECK-NEXT: [[LOADED_SROA_SPECULATED:%.*]] = select i1 [[TEST]], float [[F_0_LOADED_SROA_SPECULATE_LOAD_TRUE]], float [[LOADED_SROA_SPECULATE_LOAD_FALSE]]
; CHECK-NEXT: ret float [[LOADED_SROA_SPECULATED]]
;
entry:
%f = alloca double
- store double 0.0, double* %f
- store float 0.0, float* %ptr
+ store double 0.0, ptr %f
+ store float 0.0, ptr %ptr
%test = icmp ne i32 %b, 0
- %bitcast = bitcast double* %f to float*
- %select = select i1 %test, float* %bitcast, float* %ptr
- %loaded = load float, float* %select, align 4
+ %select = select i1 %test, ptr %f, ptr %ptr
+ %loaded = load float, ptr %select, align 4
ret float %loaded
}
-define i32 @test12(i32 %x, i32* %p, i1 %c1) {
+define i32 @test12(i32 %x, ptr %p, i1 %c1) {
; Ensure we don't crash or fail to nuke dead selects of allocas if no load is
; never found.
; CHECK-LABEL: @test12(
@@ -432,13 +417,13 @@ define i32 @test12(i32 %x, i32* %p, i1 %c1) {
entry:
%a = alloca i32
- store i32 %x, i32* %a
- %dead = select i1 %c1, i32* %a, i32* %p
- %load = load i32, i32* %a
+ store i32 %x, ptr %a
+ %dead = select i1 %c1, ptr %a, ptr %p
+ %load = load i32, ptr %a
ret i32 %load
}
-define i32 @test13(i32 %x, i32* %p, i1 %c1) {
+define i32 @test13(i32 %x, ptr %p, i1 %c1) {
; Ensure we don't crash or fail to nuke dead phis of allocas if no load is ever
; found.
; CHECK-LABEL: @test13(
@@ -452,19 +437,19 @@ define i32 @test13(i32 %x, i32* %p, i1 %c1) {
entry:
%a = alloca i32
- store i32 %x, i32* %a
+ store i32 %x, ptr %a
br label %loop
loop:
- %phi = phi i32* [ %p, %entry ], [ %a, %loop ]
+ %phi = phi ptr [ %p, %entry ], [ %a, %loop ]
br i1 %c1, label %loop, label %exit
exit:
- %load = load i32, i32* %a
+ %load = load i32, ptr %a
ret i32 %load
}
-define i32 @test14(i1 %b1, i1 %b2, i32* %ptr) {
+define i32 @test14(i1 %b1, i1 %b2, ptr %ptr) {
; Check for problems when there are both selects and phis and one is
; speculatable toward promotion but the other is not. That should block all of
; the speculation.
@@ -472,20 +457,20 @@ define i32 @test14(i1 %b1, i1 %b2, i32* %ptr) {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[F:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[G:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 0, i32* [[F]], align 4
-; CHECK-NEXT: store i32 0, i32* [[G]], align 4
-; CHECK-NEXT: [[F_SELECT:%.*]] = select i1 [[B1:%.*]], i32* [[F]], i32* [[PTR:%.*]]
+; CHECK-NEXT: store i32 0, ptr [[F]], align 4
+; CHECK-NEXT: store i32 0, ptr [[G]], align 4
+; CHECK-NEXT: [[F_SELECT:%.*]] = select i1 [[B1:%.*]], ptr [[F]], ptr [[PTR:%.*]]
; CHECK-NEXT: br i1 [[B2:%.*]], label [[THEN:%.*]], label [[ELSE:%.*]]
; CHECK: then:
; CHECK-NEXT: br label [[EXIT:%.*]]
; CHECK: else:
; CHECK-NEXT: br label [[EXIT]]
; CHECK: exit:
-; CHECK-NEXT: [[F_PHI:%.*]] = phi i32* [ [[F]], [[THEN]] ], [ [[F_SELECT]], [[ELSE]] ]
-; CHECK-NEXT: [[G_PHI:%.*]] = phi i32* [ [[G]], [[THEN]] ], [ [[PTR]], [[ELSE]] ]
-; CHECK-NEXT: [[F_LOADED:%.*]] = load i32, i32* [[F_PHI]], align 4
-; CHECK-NEXT: [[G_SELECT:%.*]] = select i1 [[B1]], i32* [[G]], i32* [[G_PHI]]
-; CHECK-NEXT: [[G_LOADED:%.*]] = load i32, i32* [[G_SELECT]], align 4
+; CHECK-NEXT: [[F_PHI:%.*]] = phi ptr [ [[F]], [[THEN]] ], [ [[F_SELECT]], [[ELSE]] ]
+; CHECK-NEXT: [[G_PHI:%.*]] = phi ptr [ [[G]], [[THEN]] ], [ [[PTR]], [[ELSE]] ]
+; CHECK-NEXT: [[F_LOADED:%.*]] = load i32, ptr [[F_PHI]], align 4
+; CHECK-NEXT: [[G_SELECT:%.*]] = select i1 [[B1]], ptr [[G]], ptr [[G_PHI]]
+; CHECK-NEXT: [[G_LOADED:%.*]] = load i32, ptr [[G_SELECT]], align 4
; CHECK-NEXT: [[RESULT:%.*]] = add i32 [[F_LOADED]], [[G_LOADED]]
; CHECK-NEXT: ret i32 [[RESULT]]
;
@@ -493,9 +478,9 @@ define i32 @test14(i1 %b1, i1 %b2, i32* %ptr) {
entry:
%f = alloca i32
%g = alloca i32
- store i32 0, i32* %f
- store i32 0, i32* %g
- %f.select = select i1 %b1, i32* %f, i32* %ptr
+ store i32 0, ptr %f
+ store i32 0, ptr %g
+ %f.select = select i1 %b1, ptr %f, ptr %ptr
br i1 %b2, label %then, label %else
then:
@@ -505,11 +490,11 @@ else:
br label %exit
exit:
- %f.phi = phi i32* [ %f, %then ], [ %f.select, %else ]
- %g.phi = phi i32* [ %g, %then ], [ %ptr, %else ]
- %f.loaded = load i32, i32* %f.phi
- %g.select = select i1 %b1, i32* %g, i32* %g.phi
- %g.loaded = load i32, i32* %g.select
+ %f.phi = phi ptr [ %f, %then ], [ %f.select, %else ]
+ %g.phi = phi ptr [ %g, %then ], [ %ptr, %else ]
+ %f.loaded = load i32, ptr %f.phi
+ %g.select = select i1 %b1, ptr %g, ptr %g.phi
+ %g.loaded = load i32, ptr %g.select
%result = add i32 %f.loaded, %g.loaded
ret i32 %result
}
@@ -525,24 +510,24 @@ define void @PR13905(i1 %c1, i1 %c2, i1 %c3) {
; CHECK: loop2:
; CHECK-NEXT: br i1 [[C3:%.*]], label [[LOOP1]], label [[EXIT]]
; CHECK: exit:
-; CHECK-NEXT: [[PHI2:%.*]] = phi i32* [ poison, [[LOOP2]] ], [ null, [[ENTRY:%.*]] ]
+; CHECK-NEXT: [[PHI2:%.*]] = phi ptr [ poison, [[LOOP2]] ], [ null, [[ENTRY:%.*]] ]
; CHECK-NEXT: ret void
;
entry:
%h = alloca i32
- store i32 0, i32* %h
+ store i32 0, ptr %h
br i1 %c1, label %loop1, label %exit
loop1:
- %phi1 = phi i32* [ null, %entry ], [ %h, %loop1 ], [ %h, %loop2 ]
+ %phi1 = phi ptr [ null, %entry ], [ %h, %loop1 ], [ %h, %loop2 ]
br i1 %c2, label %loop1, label %loop2
loop2:
br i1 %c3, label %loop1, label %exit
exit:
- %phi2 = phi i32* [ %phi1, %loop2 ], [ null, %entry ]
+ %phi2 = phi ptr [ %phi1, %loop2 ], [ null, %entry ]
ret void
}
@@ -561,15 +546,15 @@ define i32 @PR13906(i1 %c1, i1 %c2) {
entry:
%c = alloca i32
- store i32 0, i32* %c
+ store i32 0, ptr %c
br label %for.cond
for.cond:
- %d.0 = phi i32* [ poison, %entry ], [ %c, %if.then ], [ %d.0, %for.cond ]
+ %d.0 = phi ptr [ poison, %entry ], [ %c, %if.then ], [ %d.0, %for.cond ]
br i1 %c1, label %if.then, label %for.cond
if.then:
- %tmpcast.d.0 = select i1 %c2, i32* %c, i32* %d.0
+ %tmpcast.d.0 = select i1 %c2, ptr %c, ptr %d.0
br label %for.cond
}
@@ -594,21 +579,20 @@ define i64 @PR14132(i1 %flag) {
entry:
%a = alloca i64, align 8
%b = alloca i8, align 8
- %ptr = alloca i64*, align 8
+ %ptr = alloca ptr, align 8
- %ptr.cast = bitcast i64** %ptr to i8**
- store i64 0, i64* %a, align 8
- store i8 1, i8* %b, align 8
- store i64* %a, i64** %ptr, align 8
+ store i64 0, ptr %a, align 8
+ store i8 1, ptr %b, align 8
+ store ptr %a, ptr %ptr, align 8
br i1 %flag, label %if.then, label %if.end
if.then:
- store i8* %b, i8** %ptr.cast, align 8
+ store ptr %b, ptr %ptr, align 8
br label %if.end
if.end:
- %tmp = load i64*, i64** %ptr, align 8
- %result = load i64, i64* %tmp, align 8
+ %tmp = load ptr, ptr %ptr, align 8
+ %result = load i64, ptr %tmp, align 8
ret i64 %result
}
@@ -636,22 +620,19 @@ define float @PR16687(i64 %x, i1 %flag) {
entry:
%a = alloca i64, align 8
- store i64 %x, i64* %a
+ store i64 %x, ptr %a
br i1 %flag, label %then, label %else
then:
- %a.f = bitcast i64* %a to float*
br label %end
else:
- %a.raw = bitcast i64* %a to i8*
- %a.raw.4 = getelementptr i8, i8* %a.raw, i64 4
- %a.raw.4.f = bitcast i8* %a.raw.4 to float*
+ %a.raw.4 = getelementptr i8, ptr %a, i64 4
br label %end
end:
- %a.phi.f = phi float* [ %a.f, %then ], [ %a.raw.4.f, %else ]
- %f = load float, float* %a.phi.f
+ %a.phi.f = phi ptr [ %a, %then ], [ %a.raw.4, %else ]
+ %f = load float, ptr %a.phi.f
ret float %f
}
@@ -661,7 +642,7 @@ end:
; %0 = slice
; %1 = slice
; %2 = phi(%0, %1) // == slice
-define float @simplify_phi_nodes_that_equal_slice(i1 %cond, float* %temp) {
+define float @simplify_phi_nodes_that_equal_slice(i1 %cond, ptr %temp) {
; CHECK-LABEL: @simplify_phi_nodes_that_equal_slice(
; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[COND:%.*]], label [[THEN:%.*]], label [[ELSE:%.*]]
@@ -671,7 +652,7 @@ define float @simplify_phi_nodes_that_equal_slice(i1 %cond, float* %temp) {
; CHECK-NEXT: br label [[MERGE]]
; CHECK: merge:
; CHECK-NEXT: [[ARR_SROA_0_0:%.*]] = phi float [ 1.000000e+00, [[THEN]] ], [ 2.000000e+00, [[ELSE]] ]
-; CHECK-NEXT: store float 0.000000e+00, float* [[TEMP:%.*]], align 4
+; CHECK-NEXT: store float 0.000000e+00, ptr [[TEMP:%.*]], align 4
; CHECK-NEXT: ret float [[ARR_SROA_0_0]]
;
entry:
@@ -679,19 +660,19 @@ entry:
br i1 %cond, label %then, label %else
then:
- %0 = getelementptr inbounds [4 x float], [4 x float]* %arr, i64 0, i64 3
- store float 1.000000e+00, float* %0, align 4
+ %0 = getelementptr inbounds [4 x float], ptr %arr, i64 0, i64 3
+ store float 1.000000e+00, ptr %0, align 4
br label %merge
else:
- %1 = getelementptr inbounds [4 x float], [4 x float]* %arr, i64 0, i64 3
- store float 2.000000e+00, float* %1, align 4
+ %1 = getelementptr inbounds [4 x float], ptr %arr, i64 0, i64 3
+ store float 2.000000e+00, ptr %1, align 4
br label %merge
merge:
- %2 = phi float* [ %0, %then ], [ %1, %else ]
- store float 0.000000e+00, float* %temp, align 4
- %3 = load float, float* %2, align 4
+ %2 = phi ptr [ %0, %then ], [ %1, %else ]
+ store float 0.000000e+00, ptr %temp, align 4
+ %3 = load float, ptr %2, align 4
ret float %3
}
@@ -701,7 +682,7 @@ merge:
; %1 = phi(%0) // == slice
; %2 = slice
; %3 = phi(%1, %2) // == slice
-define float @simplify_phi_nodes_that_equal_slice_2(i1 %cond, float* %temp) {
+define float @simplify_phi_nodes_that_equal_slice_2(i1 %cond, ptr %temp) {
; CHECK-LABEL: @simplify_phi_nodes_that_equal_slice_2(
; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[COND:%.*]], label [[THEN:%.*]], label [[ELSE:%.*]]
@@ -713,7 +694,7 @@ define float @simplify_phi_nodes_that_equal_slice_2(i1 %cond, float* %temp) {
; CHECK-NEXT: br label [[MERGE]]
; CHECK: merge:
; CHECK-NEXT: [[ARR_SROA_0_0:%.*]] = phi float [ 2.000000e+00, [[THEN2]] ], [ 3.000000e+00, [[ELSE]] ]
-; CHECK-NEXT: store float 0.000000e+00, float* [[TEMP:%.*]], align 4
+; CHECK-NEXT: store float 0.000000e+00, ptr [[TEMP:%.*]], align 4
; CHECK-NEXT: ret float [[ARR_SROA_0_0]]
;
entry:
@@ -721,24 +702,24 @@ entry:
br i1 %cond, label %then, label %else
then:
- %0 = getelementptr inbounds [4 x float], [4 x float]* %arr, i64 0, i64 3
- store float 1.000000e+00, float* %0, align 4
+ %0 = getelementptr inbounds [4 x float], ptr %arr, i64 0, i64 3
+ store float 1.000000e+00, ptr %0, align 4
br label %then2
then2:
- %1 = phi float* [ %0, %then ]
- store float 2.000000e+00, float* %1, align 4
+ %1 = phi ptr [ %0, %then ]
+ store float 2.000000e+00, ptr %1, align 4
br label %merge
else:
- %2 = getelementptr inbounds [4 x float], [4 x float]* %arr, i64 0, i64 3
- store float 3.000000e+00, float* %2, align 4
+ %2 = getelementptr inbounds [4 x float], ptr %arr, i64 0, i64 3
+ store float 3.000000e+00, ptr %2, align 4
br label %merge
merge:
- %3 = phi float* [ %1, %then2 ], [ %2, %else ]
- store float 0.000000e+00, float* %temp, align 4
- %4 = load float, float* %3, align 4
+ %3 = phi ptr [ %1, %then2 ], [ %2, %else ]
+ store float 0.000000e+00, ptr %temp, align 4
+ %4 = load float, ptr %3, align 4
ret float %4
}
@@ -749,7 +730,7 @@ merge:
; when the incoming pointer is itself from a PHI node. We would previously
; insert a bitcast instruction *before* a PHI, producing an invalid module;
; make sure we insert *after* the first non-PHI instruction.
-define void @PR20822(i1 %c1, i1 %c2, %struct.S* %ptr) {
+define void @PR20822(i1 %c1, i1 %c2, ptr %ptr) {
; CHECK-LABEL: @PR20822(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[F_SROA_0:%.*]] = alloca i32, align 4
@@ -758,14 +739,13 @@ define void @PR20822(i1 %c1, i1 %c2, %struct.S* %ptr) {
; CHECK-NEXT: br label [[IF_END]]
; CHECK: if.end:
; CHECK-NEXT: [[TMP0:%.*]] = phi i32 [ poison, [[ENTRY:%.*]] ], [ poison, [[FOR_COND]] ]
-; CHECK-NEXT: [[F_SROA_0_0_F2_SROA_CAST1:%.*]] = bitcast i32* [[F_SROA_0]] to %struct.S*
; CHECK-NEXT: br i1 [[C2:%.*]], label [[IF_THEN5:%.*]], label [[IF_THEN2:%.*]]
; CHECK: if.then2:
; CHECK-NEXT: br label [[IF_THEN5]]
; CHECK: if.then5:
-; CHECK-NEXT: [[F1:%.*]] = phi %struct.S* [ [[PTR:%.*]], [[IF_THEN2]] ], [ [[F_SROA_0_0_F2_SROA_CAST1]], [[IF_END]] ]
-; CHECK-NEXT: [[DOTFCA_0_GEP:%.*]] = getelementptr inbounds [[STRUCT_S:%.*]], %struct.S* [[F1]], i32 0, i32 0
-; CHECK-NEXT: store i32 0, i32* [[DOTFCA_0_GEP]], align 4
+; CHECK-NEXT: [[F1:%.*]] = phi ptr [ [[PTR:%.*]], [[IF_THEN2]] ], [ [[F_SROA_0]], [[IF_END]] ]
+; CHECK-NEXT: [[DOTFCA_0_GEP:%.*]] = getelementptr inbounds [[STRUCT_S:%.*]], ptr [[F1]], i32 0, i32 0
+; CHECK-NEXT: store i32 0, ptr [[DOTFCA_0_GEP]], align 4
; CHECK-NEXT: ret void
;
entry:
@@ -776,7 +756,7 @@ for.cond: ; preds = %for.cond, %entry
br label %if.end
if.end: ; preds = %for.cond, %entry
- %f2 = phi %struct.S* [ %f, %entry ], [ %f, %for.cond ]
+ %f2 = phi ptr [ %f, %entry ], [ %f, %for.cond ]
phi i32 [ poison, %entry ], [ poison, %for.cond ]
br i1 %c2, label %if.then5, label %if.then2
@@ -784,47 +764,40 @@ if.then2: ; preds = %if.end
br label %if.then5
if.then5: ; preds = %if.then2, %if.end
- %f1 = phi %struct.S* [ %ptr, %if.then2 ], [ %f2, %if.end ]
- store %struct.S zeroinitializer, %struct.S* %f1, align 4
+ %f1 = phi ptr [ %ptr, %if.then2 ], [ %f2, %if.end ]
+ store %struct.S zeroinitializer, ptr %f1, align 4
ret void
}
-define i32 @phi_align(i32* %z) {
+define i32 @phi_align(ptr %z) {
; CHECK-LABEL: @phi_align(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A_SROA_0:%.*]] = alloca [7 x i8], align 1
-; CHECK-NEXT: [[A_SROA_0_3_A1_SROA_IDX:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_0]], i64 0, i64 3
-; CHECK-NEXT: [[A_SROA_0_3_A1_SROA_CAST:%.*]] = bitcast i8* [[A_SROA_0_3_A1_SROA_IDX]] to i32*
-; CHECK-NEXT: [[A_SROA_0_0_A0_SROA_CAST:%.*]] = bitcast [7 x i8]* [[A_SROA_0]] to i32*
-; CHECK-NEXT: store i32 0, i32* [[A_SROA_0_0_A0_SROA_CAST]], align 1
-; CHECK-NEXT: [[A_SROA_0_3_A1_SROA_IDX7:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_0]], i64 0, i64 3
-; CHECK-NEXT: [[A_SROA_0_3_A1_SROA_CAST8:%.*]] = bitcast i8* [[A_SROA_0_3_A1_SROA_IDX7]] to i32*
-; CHECK-NEXT: store i32 1, i32* [[A_SROA_0_3_A1_SROA_CAST8]], align 1
-; CHECK-NEXT: [[A_SROA_0_0_A0_SROA_CAST6:%.*]] = bitcast [7 x i8]* [[A_SROA_0]] to i32*
-; CHECK-NEXT: [[A_SROA_0_0_A_SROA_0_1_V0:%.*]] = load i32, i32* [[A_SROA_0_0_A0_SROA_CAST6]], align 1
-; CHECK-NEXT: [[A_SROA_0_3_A1_SROA_IDX9:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_0]], i64 0, i64 3
-; CHECK-NEXT: [[A_SROA_0_3_A1_SROA_CAST10:%.*]] = bitcast i8* [[A_SROA_0_3_A1_SROA_IDX9]] to i32*
-; CHECK-NEXT: [[A_SROA_0_3_A_SROA_0_4_V1:%.*]] = load i32, i32* [[A_SROA_0_3_A1_SROA_CAST10]], align 1
+; CHECK-NEXT: [[A_SROA_0_3_A1X_SROA_IDX:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_0]], i64 3
+; CHECK-NEXT: store i32 0, ptr [[A_SROA_0]], align 1
+; CHECK-NEXT: [[A_SROA_0_3_A1X_SROA_IDX3:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_0]], i64 3
+; CHECK-NEXT: store i32 1, ptr [[A_SROA_0_3_A1X_SROA_IDX3]], align 1
+; CHECK-NEXT: [[A_SROA_0_0_A_SROA_0_1_V0:%.*]] = load i32, ptr [[A_SROA_0]], align 1
+; CHECK-NEXT: [[A_SROA_0_3_A1X_SROA_IDX4:%.*]] = getelementptr inbounds i8, ptr [[A_SROA_0]], i64 3
+; CHECK-NEXT: [[A_SROA_0_3_A_SROA_0_4_V1:%.*]] = load i32, ptr [[A_SROA_0_3_A1X_SROA_IDX4]], align 1
; CHECK-NEXT: [[COND:%.*]] = icmp sle i32 [[A_SROA_0_0_A_SROA_0_1_V0]], [[A_SROA_0_3_A_SROA_0_4_V1]]
; CHECK-NEXT: br i1 [[COND]], label [[THEN:%.*]], label [[EXIT:%.*]]
; CHECK: then:
; CHECK-NEXT: br label [[EXIT]]
; CHECK: exit:
-; CHECK-NEXT: [[PHI:%.*]] = phi i32* [ [[A_SROA_0_3_A1_SROA_CAST]], [[THEN]] ], [ [[Z:%.*]], [[ENTRY:%.*]] ]
-; CHECK-NEXT: [[RESULT:%.*]] = load i32, i32* [[PHI]], align 1
+; CHECK-NEXT: [[PHI:%.*]] = phi ptr [ [[A_SROA_0_3_A1X_SROA_IDX]], [[THEN]] ], [ [[Z:%.*]], [[ENTRY:%.*]] ]
+; CHECK-NEXT: [[RESULT:%.*]] = load i32, ptr [[PHI]], align 1
; CHECK-NEXT: ret i32 [[RESULT]]
;
entry:
%a = alloca [8 x i8], align 8
- %a0x = getelementptr [8 x i8], [8 x i8]* %a, i64 0, i32 1
- %a0 = bitcast i8* %a0x to i32*
- %a1x = getelementptr [8 x i8], [8 x i8]* %a, i64 0, i32 4
- %a1 = bitcast i8* %a1x to i32*
- store i32 0, i32* %a0, align 1
- store i32 1, i32* %a1, align 4
- %v0 = load i32, i32* %a0, align 1
- %v1 = load i32, i32* %a1, align 4
+ %a0x = getelementptr [8 x i8], ptr %a, i64 0, i32 1
+ %a1x = getelementptr [8 x i8], ptr %a, i64 0, i32 4
+ store i32 0, ptr %a0x, align 1
+ store i32 1, ptr %a1x, align 4
+ %v0 = load i32, ptr %a0x, align 1
+ %v1 = load i32, ptr %a1x, align 4
%cond = icmp sle i32 %v0, %v1
br i1 %cond, label %then, label %exit
@@ -832,25 +805,25 @@ then:
br label %exit
exit:
- %phi = phi i32* [ %a1, %then ], [ %z, %entry ]
- %result = load i32, i32* %phi, align 4
+ %phi = phi ptr [ %a1x, %then ], [ %z, %entry ]
+ %result = load i32, ptr %phi, align 4
ret i32 %result
}
; Don't speculate a load based on an earlier volatile operation.
-define i8 @volatile_select(i8* %p, i1 %b) {
+define i8 @volatile_select(ptr %p, i1 %b) {
; CHECK-LABEL: @volatile_select(
; CHECK-NEXT: [[P2:%.*]] = alloca i8, align 1
-; CHECK-NEXT: store i8 0, i8* [[P2]], align 1
-; CHECK-NEXT: store volatile i8 0, i8* [[P:%.*]], align 1
-; CHECK-NEXT: [[PX:%.*]] = select i1 [[B:%.*]], i8* [[P]], i8* [[P2]]
-; CHECK-NEXT: [[V2:%.*]] = load i8, i8* [[PX]], align 1
+; CHECK-NEXT: store i8 0, ptr [[P2]], align 1
+; CHECK-NEXT: store volatile i8 0, ptr [[P:%.*]], align 1
+; CHECK-NEXT: [[PX:%.*]] = select i1 [[B:%.*]], ptr [[P]], ptr [[P2]]
+; CHECK-NEXT: [[V2:%.*]] = load i8, ptr [[PX]], align 1
; CHECK-NEXT: ret i8 [[V2]]
;
%p2 = alloca i8
- store i8 0, i8* %p2
- store volatile i8 0, i8* %p
- %px = select i1 %b, i8* %p, i8* %p2
- %v2 = load i8, i8* %px
+ store i8 0, ptr %p2
+ store volatile i8 0, ptr %p
+ %px = select i1 %b, ptr %p, ptr %p2
+ %v2 = load i8, ptr %px
ret i8 %v2
}
diff --git a/llvm/test/Transforms/SROA/phi-catchswitch.ll b/llvm/test/Transforms/SROA/phi-catchswitch.ll
index 5ba454c328db..751e2475f220 100644
--- a/llvm/test/Transforms/SROA/phi-catchswitch.ll
+++ b/llvm/test/Transforms/SROA/phi-catchswitch.ll
@@ -10,11 +10,10 @@ declare void @foo()
; Tests if the SROA pass correctly bails out on rewriting PHIs in a catchswitch
; BB.
; CHECK-LABEL: @test_phi_catchswitch
-define void @test_phi_catchswitch() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
+define void @test_phi_catchswitch() personality ptr @__gxx_wasm_personality_v0 {
entry:
; CHECK: alloca
%tmp = alloca %struct.foo, align 4
- %tmp2 = getelementptr inbounds %struct.foo, %struct.foo* %tmp, i32 0, i32 0
invoke void @foo()
to label %bb3 unwind label %bb10
@@ -27,19 +26,19 @@ catch.dispatch: ; preds = %bb3
; non-PHI instruction in this BB by calling getFirstInsertionPt(), which is
; not possible in a catchswitch BB. This test checks if we correctly bail out
; on these cases.
- %tmp5 = phi i32* [ %tmp2, %bb3 ]
+ %tmp5 = phi ptr [ %tmp, %bb3 ]
%tmp6 = catchswitch within none [label %catch.start] unwind label %bb10
catch.start: ; preds = %catch.dispatch
- %tmp8 = catchpad within %tmp6 [i8* null]
+ %tmp8 = catchpad within %tmp6 [ptr null]
unreachable
bb9: ; preds = %bb3
unreachable
bb10: ; preds = %catch.dispatch, %entry
- %tmp11 = phi i32* [ %tmp2, %entry ], [ %tmp5, %catch.dispatch ]
+ %tmp11 = phi ptr [ %tmp, %entry ], [ %tmp5, %catch.dispatch ]
%tmp12 = cleanuppad within none []
- store i32 0, i32* %tmp11, align 4
+ store i32 0, ptr %tmp11, align 4
unreachable
}
diff --git a/llvm/test/Transforms/SROA/phi-gep.ll b/llvm/test/Transforms/SROA/phi-gep.ll
index 7b3ad1868f72..8ac3a183f206 100644
--- a/llvm/test/Transforms/SROA/phi-gep.ll
+++ b/llvm/test/Transforms/SROA/phi-gep.ll
@@ -16,19 +16,19 @@ define i32 @test_sroa_phi_gep(i1 %cond) {
entry:
%a = alloca %pair, align 4
%b = alloca %pair, align 4
- %gep_a = getelementptr inbounds %pair, %pair* %a, i32 0, i32 1
- %gep_b = getelementptr inbounds %pair, %pair* %b, i32 0, i32 1
- store i32 1, i32* %gep_a, align 4
- store i32 2, i32* %gep_b, align 4
+ %gep_a = getelementptr inbounds %pair, ptr %a, i32 0, i32 1
+ %gep_b = getelementptr inbounds %pair, ptr %b, i32 0, i32 1
+ store i32 1, ptr %gep_a, align 4
+ store i32 2, ptr %gep_b, align 4
br i1 %cond, label %if.then, label %end
if.then:
br label %end
end:
- %phi = phi %pair* [ %a, %entry], [ %b, %if.then ]
- %gep = getelementptr inbounds %pair, %pair* %phi, i32 0, i32 1
- %load = load i32, i32* %gep, align 4
+ %phi = phi ptr [ %a, %entry], [ %b, %if.then ]
+ %gep = getelementptr inbounds %pair, ptr %phi, i32 0, i32 1
+ %load = load i32, ptr %gep, align 4
ret i32 %load
}
@@ -45,19 +45,19 @@ define i32 @test_sroa_phi_gep_non_inbound(i1 %cond) {
entry:
%a = alloca %pair, align 4
%b = alloca %pair, align 4
- %gep_a = getelementptr %pair, %pair* %a, i32 0, i32 1
- %gep_b = getelementptr %pair, %pair* %b, i32 0, i32 1
- store i32 1, i32* %gep_a, align 4
- store i32 2, i32* %gep_b, align 4
+ %gep_a = getelementptr %pair, ptr %a, i32 0, i32 1
+ %gep_b = getelementptr %pair, ptr %b, i32 0, i32 1
+ store i32 1, ptr %gep_a, align 4
+ store i32 2, ptr %gep_b, align 4
br i1 %cond, label %if.then, label %end
if.then:
br label %end
end:
- %phi = phi %pair* [ %a, %entry], [ %b, %if.then ]
- %gep = getelementptr %pair, %pair* %phi, i32 0, i32 1
- %load = load i32, i32* %gep, align 4
+ %phi = phi ptr [ %a, %entry], [ %b, %if.then ]
+ %gep = getelementptr %pair, ptr %phi, i32 0, i32 1
+ %load = load i32, ptr %gep, align 4
ret i32 %load
}
@@ -69,9 +69,9 @@ define i32 @test_sroa_phi_gep_poison(i1 %cond) {
; CHECK: if.then:
; CHECK-NEXT: br label [[END]]
; CHECK: end:
-; CHECK-NEXT: [[PHI:%.*]] = phi %pair* [ [[A]], [[ENTRY:%.*]] ], [ poison, [[IF_THEN]] ]
-; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds [[PAIR]], %pair* [[PHI]], i32 0, i32 1
-; CHECK-NEXT: [[LOAD:%.*]] = load i32, i32* [[GEP]], align 4
+; CHECK-NEXT: [[PHI:%.*]] = phi ptr [ [[A]], [[ENTRY:%.*]] ], [ poison, [[IF_THEN]] ]
+; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds [[PAIR]], ptr [[PHI]], i32 0, i32 1
+; CHECK-NEXT: [[LOAD:%.*]] = load i32, ptr [[GEP]], align 4
; CHECK-NEXT: ret i32 [[LOAD]]
;
entry:
@@ -82,9 +82,9 @@ if.then:
br label %end
end:
- %phi = phi %pair* [ %a, %entry], [ poison, %if.then ]
- %gep = getelementptr inbounds %pair, %pair* %phi, i32 0, i32 1
- %load = load i32, i32* %gep, align 4
+ %phi = phi ptr [ %a, %entry], [ poison, %if.then ]
+ %gep = getelementptr inbounds %pair, ptr %phi, i32 0, i32 1
+ %load = load i32, ptr %gep, align 4
ret i32 %load
}
@@ -94,30 +94,30 @@ define i32 @test_sroa_phi_gep_global(i1 %cond) {
; CHECK-LABEL: @test_sroa_phi_gep_global(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca [[PAIR:%.*]], align 4
-; CHECK-NEXT: [[GEP_A:%.*]] = getelementptr inbounds [[PAIR]], %pair* [[A]], i32 0, i32 1
-; CHECK-NEXT: store i32 1, i32* [[GEP_A]], align 4
+; CHECK-NEXT: [[GEP_A:%.*]] = getelementptr inbounds [[PAIR]], ptr [[A]], i32 0, i32 1
+; CHECK-NEXT: store i32 1, ptr [[GEP_A]], align 4
; CHECK-NEXT: br i1 [[COND:%.*]], label [[IF_THEN:%.*]], label [[END:%.*]]
; CHECK: if.then:
; CHECK-NEXT: br label [[END]]
; CHECK: end:
-; CHECK-NEXT: [[PHI:%.*]] = phi %pair* [ [[A]], [[ENTRY:%.*]] ], [ @g, [[IF_THEN]] ]
-; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds [[PAIR]], %pair* [[PHI]], i32 0, i32 1
-; CHECK-NEXT: [[LOAD:%.*]] = load i32, i32* [[GEP]], align 4
+; CHECK-NEXT: [[PHI:%.*]] = phi ptr [ [[A]], [[ENTRY:%.*]] ], [ @g, [[IF_THEN]] ]
+; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds [[PAIR]], ptr [[PHI]], i32 0, i32 1
+; CHECK-NEXT: [[LOAD:%.*]] = load i32, ptr [[GEP]], align 4
; CHECK-NEXT: ret i32 [[LOAD]]
;
entry:
%a = alloca %pair, align 4
- %gep_a = getelementptr inbounds %pair, %pair* %a, i32 0, i32 1
- store i32 1, i32* %gep_a, align 4
+ %gep_a = getelementptr inbounds %pair, ptr %a, i32 0, i32 1
+ store i32 1, ptr %gep_a, align 4
br i1 %cond, label %if.then, label %end
if.then:
br label %end
end:
- %phi = phi %pair* [ %a, %entry], [ @g, %if.then ]
- %gep = getelementptr inbounds %pair, %pair* %phi, i32 0, i32 1
- %load = load i32, i32* %gep, align 4
+ %phi = phi ptr [ %a, %entry], [ @g, %if.then ]
+ %gep = getelementptr inbounds %pair, ptr %phi, i32 0, i32 1
+ %load = load i32, ptr %gep, align 4
ret i32 %load
}
@@ -137,10 +137,10 @@ define i32 @test_sroa_phi_gep_arg_phi_inspt(i1 %cond) {
entry:
%a = alloca %pair, align 4
%b = alloca %pair, align 4
- %gep_a = getelementptr inbounds %pair, %pair* %a, i32 0, i32 1
- %gep_b = getelementptr inbounds %pair, %pair* %b, i32 0, i32 1
- store i32 1, i32* %gep_a, align 4
- store i32 2, i32* %gep_b, align 4
+ %gep_a = getelementptr inbounds %pair, ptr %a, i32 0, i32 1
+ %gep_b = getelementptr inbounds %pair, ptr %b, i32 0, i32 1
+ store i32 1, ptr %gep_a, align 4
+ store i32 2, ptr %gep_b, align 4
br i1 %cond, label %for, label %end
for:
@@ -150,9 +150,9 @@ for:
br i1 %loop.cond, label %for, label %end
end:
- %phi = phi %pair* [ %a, %entry], [ %b, %for ]
- %gep = getelementptr inbounds %pair, %pair* %phi, i32 0, i32 1
- %load = load i32, i32* %gep, align 4
+ %phi = phi ptr [ %a, %entry], [ %b, %for ]
+ %gep = getelementptr inbounds %pair, ptr %phi, i32 0, i32 1
+ %load = load i32, ptr %gep, align 4
ret i32 %load
}
@@ -161,43 +161,43 @@ define i32 @test_sroa_phi_gep_phi_inspt(i1 %cond) {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca [[PAIR:%.*]], align 4
; CHECK-NEXT: [[B:%.*]] = alloca [[PAIR]], align 4
-; CHECK-NEXT: [[GEP_A:%.*]] = getelementptr inbounds [[PAIR]], %pair* [[A]], i32 0, i32 1
-; CHECK-NEXT: [[GEP_B:%.*]] = getelementptr inbounds [[PAIR]], %pair* [[B]], i32 0, i32 1
-; CHECK-NEXT: store i32 1, i32* [[GEP_A]], align 4
-; CHECK-NEXT: store i32 2, i32* [[GEP_B]], align 4
+; CHECK-NEXT: [[GEP_A:%.*]] = getelementptr inbounds [[PAIR]], ptr [[A]], i32 0, i32 1
+; CHECK-NEXT: [[GEP_B:%.*]] = getelementptr inbounds [[PAIR]], ptr [[B]], i32 0, i32 1
+; CHECK-NEXT: store i32 1, ptr [[GEP_A]], align 4
+; CHECK-NEXT: store i32 2, ptr [[GEP_B]], align 4
; CHECK-NEXT: br i1 [[COND:%.*]], label [[FOR:%.*]], label [[END:%.*]]
; CHECK: for:
-; CHECK-NEXT: [[PHI_IN:%.*]] = phi %pair* [ null, [[ENTRY:%.*]] ], [ [[B]], [[FOR]] ]
+; CHECK-NEXT: [[PHI_IN:%.*]] = phi ptr [ null, [[ENTRY:%.*]] ], [ [[B]], [[FOR]] ]
; CHECK-NEXT: [[PHI_INSPT:%.*]] = phi i32 [ 0, [[ENTRY]] ], [ [[I:%.*]], [[FOR]] ]
; CHECK-NEXT: [[I]] = add i32 [[PHI_INSPT]], 1
; CHECK-NEXT: [[LOOP_COND:%.*]] = icmp ult i32 [[I]], 10
; CHECK-NEXT: br i1 [[LOOP_COND]], label [[FOR]], label [[END]]
; CHECK: end:
-; CHECK-NEXT: [[PHI:%.*]] = phi %pair* [ [[A]], [[ENTRY]] ], [ [[PHI_IN]], [[FOR]] ]
-; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds [[PAIR]], %pair* [[PHI]], i32 0, i32 1
-; CHECK-NEXT: [[LOAD:%.*]] = load i32, i32* [[GEP]], align 4
+; CHECK-NEXT: [[PHI:%.*]] = phi ptr [ [[A]], [[ENTRY]] ], [ [[PHI_IN]], [[FOR]] ]
+; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds [[PAIR]], ptr [[PHI]], i32 0, i32 1
+; CHECK-NEXT: [[LOAD:%.*]] = load i32, ptr [[GEP]], align 4
; CHECK-NEXT: ret i32 [[LOAD]]
;
entry:
%a = alloca %pair, align 4
%b = alloca %pair, align 4
- %gep_a = getelementptr inbounds %pair, %pair* %a, i32 0, i32 1
- %gep_b = getelementptr inbounds %pair, %pair* %b, i32 0, i32 1
- store i32 1, i32* %gep_a, align 4
- store i32 2, i32* %gep_b, align 4
+ %gep_a = getelementptr inbounds %pair, ptr %a, i32 0, i32 1
+ %gep_b = getelementptr inbounds %pair, ptr %b, i32 0, i32 1
+ store i32 1, ptr %gep_a, align 4
+ store i32 2, ptr %gep_b, align 4
br i1 %cond, label %for, label %end
for:
- %phi_in = phi %pair * [ null, %entry ], [ %b, %for ]
+ %phi_in = phi ptr [ null, %entry ], [ %b, %for ]
%phi_inspt = phi i32 [ 0, %entry ], [ %i, %for ]
%i = add i32 %phi_inspt, 1
%loop.cond = icmp ult i32 %i, 10
br i1 %loop.cond, label %for, label %end
end:
- %phi = phi %pair* [ %a, %entry], [ %phi_in, %for ]
- %gep = getelementptr inbounds %pair, %pair* %phi, i32 0, i32 1
- %load = load i32, i32* %gep, align 4
+ %phi = phi ptr [ %a, %entry], [ %phi_in, %for ]
+ %gep = getelementptr inbounds %pair, ptr %phi, i32 0, i32 1
+ %load = load i32, ptr %gep, align 4
ret i32 %load
}
@@ -208,51 +208,51 @@ define i32 @test_sroa_gep_phi_gep(i1 %cond) {
; CHECK-NEXT: br i1 [[COND:%.*]], label [[FOR:%.*]], label [[END:%.*]]
; CHECK: for:
; CHECK-NEXT: [[PHI_I:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[I:%.*]], [[FOR]] ]
-; CHECK-NEXT: [[PHI:%.*]] = phi i32* [ [[A_SROA_0]], [[ENTRY]] ], [ [[GEP_FOR:%.*]], [[FOR]] ]
+; CHECK-NEXT: [[PHI:%.*]] = phi ptr [ [[A_SROA_0]], [[ENTRY]] ], [ [[GEP_FOR:%.*]], [[FOR]] ]
; CHECK-NEXT: [[I]] = add i32 [[PHI_I]], 1
-; CHECK-NEXT: [[GEP_FOR]] = getelementptr inbounds i32, i32* [[PHI]], i32 0
+; CHECK-NEXT: [[GEP_FOR]] = getelementptr inbounds i32, ptr [[PHI]], i32 0
; CHECK-NEXT: [[LOOP_COND:%.*]] = icmp ult i32 [[I]], 10
; CHECK-NEXT: br i1 [[LOOP_COND]], label [[FOR]], label [[END]]
; CHECK: end:
-; CHECK-NEXT: [[PHI_END:%.*]] = phi i32* [ [[A_SROA_0]], [[ENTRY]] ], [ [[PHI]], [[FOR]] ]
-; CHECK-NEXT: [[LOAD:%.*]] = load i32, i32* [[PHI_END]], align 4
+; CHECK-NEXT: [[PHI_END:%.*]] = phi ptr [ [[A_SROA_0]], [[ENTRY]] ], [ [[PHI]], [[FOR]] ]
+; CHECK-NEXT: [[LOAD:%.*]] = load i32, ptr [[PHI_END]], align 4
; CHECK-NEXT: ret i32 [[LOAD]]
;
entry:
%a = alloca %pair, align 4
- %gep_a = getelementptr inbounds %pair, %pair* %a, i32 0, i32 1
+ %gep_a = getelementptr inbounds %pair, ptr %a, i32 0, i32 1
br i1 %cond, label %for, label %end
for:
%phi_i = phi i32 [ 0, %entry ], [ %i, %for ]
- %phi = phi i32* [ %gep_a, %entry], [ %gep_for, %for ]
+ %phi = phi ptr [ %gep_a, %entry], [ %gep_for, %for ]
%i = add i32 %phi_i, 1
%gep_for = getelementptr inbounds i32, i32* %phi, i32 0
%loop.cond = icmp ult i32 %i, 10
br i1 %loop.cond, label %for, label %end
end:
- %phi_end = phi i32* [ %gep_a, %entry], [ %phi, %for ]
- %load = load i32, i32* %phi_end, align 4
+ %phi_end = phi ptr [ %gep_a, %entry], [ %phi, %for ]
+ %load = load i32, ptr %phi_end, align 4
ret i32 %load
}
-define i32 @test_sroa_invoke_phi_gep(i1 %cond) personality i32 (...)* @__gxx_personality_v0 {
+define i32 @test_sroa_invoke_phi_gep(i1 %cond) personality ptr @__gxx_personality_v0 {
; CHECK-LABEL: @test_sroa_invoke_phi_gep(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca [[PAIR:%.*]], align 4
; CHECK-NEXT: br i1 [[COND:%.*]], label [[CALL:%.*]], label [[END:%.*]]
; CHECK: call:
-; CHECK-NEXT: [[B:%.*]] = invoke %pair* @foo()
+; CHECK-NEXT: [[B:%.*]] = invoke ptr @foo()
; CHECK-NEXT: to label [[END]] unwind label [[INVOKE_CATCH:%.*]]
; CHECK: end:
-; CHECK-NEXT: [[PHI:%.*]] = phi %pair* [ [[A]], [[ENTRY:%.*]] ], [ [[B]], [[CALL]] ]
-; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds [[PAIR]], %pair* [[PHI]], i32 0, i32 1
-; CHECK-NEXT: [[LOAD:%.*]] = load i32, i32* [[GEP]], align 4
+; CHECK-NEXT: [[PHI:%.*]] = phi ptr [ [[A]], [[ENTRY:%.*]] ], [ [[B]], [[CALL]] ]
+; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds [[PAIR]], ptr [[PHI]], i32 0, i32 1
+; CHECK-NEXT: [[LOAD:%.*]] = load i32, ptr [[GEP]], align 4
; CHECK-NEXT: ret i32 [[LOAD]]
; CHECK: invoke_catch:
-; CHECK-NEXT: [[RES:%.*]] = landingpad { i8*, i32 }
-; CHECK-NEXT: catch i8* null
+; CHECK-NEXT: [[RES:%.*]] = landingpad { ptr, i32 }
+; CHECK-NEXT: catch ptr null
; CHECK-NEXT: ret i32 0
;
entry:
@@ -260,18 +260,18 @@ entry:
br i1 %cond, label %call, label %end
call:
- %b = invoke %pair* @foo()
+ %b = invoke ptr @foo()
to label %end unwind label %invoke_catch
end:
- %phi = phi %pair* [ %a, %entry], [ %b, %call ]
- %gep = getelementptr inbounds %pair, %pair* %phi, i32 0, i32 1
- %load = load i32, i32* %gep, align 4
+ %phi = phi ptr [ %a, %entry], [ %b, %call ]
+ %gep = getelementptr inbounds %pair, ptr %phi, i32 0, i32 1
+ %load = load i32, ptr %gep, align 4
ret i32 %load
invoke_catch:
- %res = landingpad { i8*, i32 }
- catch i8* null
+ %res = landingpad { ptr, i32 }
+ catch ptr null
ret i32 0
}
@@ -280,49 +280,49 @@ define i32 @test_sroa_phi_gep_nonconst_idx(i1 %cond, i32 %idx) {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca [[PAIR:%.*]], align 4
; CHECK-NEXT: [[B:%.*]] = alloca [[PAIR]], align 4
-; CHECK-NEXT: [[GEP_A:%.*]] = getelementptr inbounds [[PAIR]], %pair* [[A]], i32 0, i32 1
-; CHECK-NEXT: [[GEP_B:%.*]] = getelementptr inbounds [[PAIR]], %pair* [[B]], i32 0, i32 1
-; CHECK-NEXT: store i32 1, i32* [[GEP_A]], align 4
-; CHECK-NEXT: store i32 2, i32* [[GEP_B]], align 4
+; CHECK-NEXT: [[GEP_A:%.*]] = getelementptr inbounds [[PAIR]], ptr [[A]], i32 0, i32 1
+; CHECK-NEXT: [[GEP_B:%.*]] = getelementptr inbounds [[PAIR]], ptr [[B]], i32 0, i32 1
+; CHECK-NEXT: store i32 1, ptr [[GEP_A]], align 4
+; CHECK-NEXT: store i32 2, ptr [[GEP_B]], align 4
; CHECK-NEXT: br i1 [[COND:%.*]], label [[IF_THEN:%.*]], label [[END:%.*]]
; CHECK: if.then:
; CHECK-NEXT: br label [[END]]
; CHECK: end:
-; CHECK-NEXT: [[PHI:%.*]] = phi %pair* [ [[A]], [[ENTRY:%.*]] ], [ [[B]], [[IF_THEN]] ]
-; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds [[PAIR]], %pair* [[PHI]], i32 [[IDX:%.*]], i32 1
-; CHECK-NEXT: [[LOAD:%.*]] = load i32, i32* [[GEP]], align 4
+; CHECK-NEXT: [[PHI:%.*]] = phi ptr [ [[A]], [[ENTRY:%.*]] ], [ [[B]], [[IF_THEN]] ]
+; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds [[PAIR]], ptr [[PHI]], i32 [[IDX:%.*]], i32 1
+; CHECK-NEXT: [[LOAD:%.*]] = load i32, ptr [[GEP]], align 4
; CHECK-NEXT: ret i32 [[LOAD]]
;
entry:
%a = alloca %pair, align 4
%b = alloca %pair, align 4
- %gep_a = getelementptr inbounds %pair, %pair* %a, i32 0, i32 1
- %gep_b = getelementptr inbounds %pair, %pair* %b, i32 0, i32 1
- store i32 1, i32* %gep_a, align 4
- store i32 2, i32* %gep_b, align 4
+ %gep_a = getelementptr inbounds %pair, ptr %a, i32 0, i32 1
+ %gep_b = getelementptr inbounds %pair, ptr %b, i32 0, i32 1
+ store i32 1, ptr %gep_a, align 4
+ store i32 2, ptr %gep_b, align 4
br i1 %cond, label %if.then, label %end
if.then:
br label %end
end:
- %phi = phi %pair* [ %a, %entry], [ %b, %if.then ]
- %gep = getelementptr inbounds %pair, %pair* %phi, i32 %idx, i32 1
- %load = load i32, i32* %gep, align 4
+ %phi = phi ptr [ %a, %entry], [ %b, %if.then ]
+ %gep = getelementptr inbounds %pair, ptr %phi, i32 %idx, i32 1
+ %load = load i32, ptr %gep, align 4
ret i32 %load
}
-define void @test_sroa_gep_phi_select_other_block(i1 %c1, i1 %c2, %pair* %ptr) {
+define void @test_sroa_gep_phi_select_other_block(i1 %c1, i1 %c2, ptr %ptr) {
; CHECK-LABEL: @test_sroa_gep_phi_select_other_block(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[ALLOCA:%.*]] = alloca [[PAIR:%.*]], align 8
; CHECK-NEXT: br label [[WHILE_BODY:%.*]]
; CHECK: while.body:
-; CHECK-NEXT: [[PHI:%.*]] = phi %pair* [ [[ALLOCA]], [[ENTRY:%.*]] ], [ [[SELECT:%.*]], [[WHILE_BODY]] ]
-; CHECK-NEXT: [[SELECT]] = select i1 [[C1:%.*]], %pair* [[PHI]], %pair* [[PTR:%.*]]
+; CHECK-NEXT: [[PHI:%.*]] = phi ptr [ [[ALLOCA]], [[ENTRY:%.*]] ], [ [[SELECT:%.*]], [[WHILE_BODY]] ]
+; CHECK-NEXT: [[SELECT]] = select i1 [[C1:%.*]], ptr [[PHI]], ptr [[PTR:%.*]]
; CHECK-NEXT: br i1 [[C2:%.*]], label [[EXIT:%.*]], label [[WHILE_BODY]]
; CHECK: exit:
-; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds [[PAIR]], %pair* [[PHI]], i64 1
+; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds [[PAIR]], ptr [[PHI]], i64 1
; CHECK-NEXT: unreachable
;
entry:
@@ -330,26 +330,26 @@ entry:
br label %while.body
while.body:
- %phi = phi %pair* [ %alloca, %entry ], [ %select, %while.body ]
- %select = select i1 %c1, %pair* %phi, %pair* %ptr
+ %phi = phi ptr [ %alloca, %entry ], [ %select, %while.body ]
+ %select = select i1 %c1, ptr %phi, ptr %ptr
br i1 %c2, label %exit, label %while.body
exit:
- %gep = getelementptr inbounds %pair, %pair* %phi, i64 1
+ %gep = getelementptr inbounds %pair, ptr %phi, i64 1
unreachable
}
-define void @test_sroa_gep_phi_select_same_block(i1 %c1, i1 %c2, %pair* %ptr) {
+define void @test_sroa_gep_phi_select_same_block(i1 %c1, i1 %c2, ptr %ptr) {
; CHECK-LABEL: @test_sroa_gep_phi_select_same_block(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[ALLOCA:%.*]] = alloca [[PAIR:%.*]], align 8
; CHECK-NEXT: br label [[WHILE_BODY:%.*]]
; CHECK: while.body:
-; CHECK-NEXT: [[PHI:%.*]] = phi %pair* [ [[ALLOCA]], [[ENTRY:%.*]] ], [ [[SELECT:%.*]], [[WHILE_BODY]] ]
-; CHECK-NEXT: [[SELECT]] = select i1 [[C1:%.*]], %pair* [[PHI]], %pair* [[PTR:%.*]]
-; CHECK-NEXT: [[PHI_SROA_GEP:%.*]] = getelementptr inbounds [[PAIR]], %pair* [[PHI]], i64 1
-; CHECK-NEXT: [[PTR_SROA_GEP:%.*]] = getelementptr inbounds [[PAIR]], %pair* [[PTR]], i64 1
-; CHECK-NEXT: [[SELECT_SROA_SEL:%.*]] = select i1 [[C1]], %pair* [[PHI_SROA_GEP]], %pair* [[PTR_SROA_GEP]]
+; CHECK-NEXT: [[PHI:%.*]] = phi ptr [ [[ALLOCA]], [[ENTRY:%.*]] ], [ [[SELECT:%.*]], [[WHILE_BODY]] ]
+; CHECK-NEXT: [[SELECT]] = select i1 [[C1:%.*]], ptr [[PHI]], ptr [[PTR:%.*]]
+; CHECK-NEXT: [[PHI_SROA_GEP:%.*]] = getelementptr inbounds [[PAIR]], ptr [[PHI]], i64 1
+; CHECK-NEXT: [[PTR_SROA_GEP:%.*]] = getelementptr inbounds [[PAIR]], ptr [[PTR]], i64 1
+; CHECK-NEXT: [[SELECT_SROA_SEL:%.*]] = select i1 [[C1]], ptr [[PHI_SROA_GEP]], ptr [[PTR_SROA_GEP]]
; CHECK-NEXT: br i1 [[C2:%.*]], label [[EXIT:%.*]], label [[WHILE_BODY]]
; CHECK: exit:
; CHECK-NEXT: ret void
@@ -359,9 +359,9 @@ entry:
br label %while.body
while.body:
- %phi = phi %pair* [ %alloca, %entry ], [ %select, %while.body ]
- %select = select i1 %c1, %pair* %phi, %pair* %ptr
- %gep = getelementptr inbounds %pair, %pair* %select, i64 1
+ %phi = phi ptr [ %alloca, %entry ], [ %select, %while.body ]
+ %select = select i1 %c1, ptr %phi, ptr %ptr
+ %gep = getelementptr inbounds %pair, ptr %select, i64 1
br i1 %c2, label %exit, label %while.body
exit:
@@ -372,62 +372,49 @@ define i32 @test_sroa_gep_cast_phi_gep(i1 %cond) {
; CHECK-LABEL: @test_sroa_gep_cast_phi_gep(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A_SROA_0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[A_SROA_0_0_GEP_A_CAST_TO_FLOAT_SROA_CAST:%.*]] = bitcast i32* [[A_SROA_0]] to float*
-; CHECK-NEXT: [[A_SROA_0_0_GEP_A_CAST_TO_FLOAT_SROA_CAST2:%.*]] = bitcast i32* [[A_SROA_0]] to float*
-; CHECK-NEXT: [[A_SROA_0_0_GEP_SROA_CAST:%.*]] = bitcast i32* [[A_SROA_0]] to float*
-; CHECK-NEXT: store i32 1065353216, i32* [[A_SROA_0]], align 4
+; CHECK-NEXT: store i32 1065353216, ptr [[A_SROA_0]], align 4
; CHECK-NEXT: br i1 [[COND:%.*]], label [[FOR:%.*]], label [[END:%.*]]
; CHECK: for:
; CHECK-NEXT: [[PHI_I:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[I:%.*]], [[FOR]] ]
-; CHECK-NEXT: [[PHI:%.*]] = phi float* [ [[A_SROA_0_0_GEP_A_CAST_TO_FLOAT_SROA_CAST]], [[ENTRY]] ], [ [[GEP_FOR_CAST_TO_FLOAT:%.*]], [[FOR]] ]
-; CHECK-NEXT: [[PHI_SROA_PHI:%.*]] = phi float* [ [[A_SROA_0_0_GEP_SROA_CAST]], [[ENTRY]] ], [ [[GEP_FOR_CAST_TO_FLOAT_SROA_GEP:%.*]], [[FOR]] ]
+; CHECK-NEXT: [[PHI:%.*]] = phi ptr [ [[A_SROA_0]], [[ENTRY]] ], [ [[GEP_FOR:%.*]], [[FOR]] ]
; CHECK-NEXT: [[I]] = add i32 [[PHI_I]], 1
-; CHECK-NEXT: [[GEP_FOR_CAST:%.*]] = bitcast float* [[PHI_SROA_PHI]] to i32*
-; CHECK-NEXT: [[GEP_FOR_CAST_TO_FLOAT]] = bitcast i32* [[GEP_FOR_CAST]] to float*
-; CHECK-NEXT: [[GEP_FOR_CAST_TO_FLOAT_SROA_GEP]] = getelementptr inbounds float, float* [[GEP_FOR_CAST_TO_FLOAT]], i32 0
+; CHECK-NEXT: [[GEP_FOR]] = getelementptr inbounds float, ptr [[PHI]], i32 0
; CHECK-NEXT: [[LOOP_COND:%.*]] = icmp ult i32 [[I]], 10
; CHECK-NEXT: br i1 [[LOOP_COND]], label [[FOR]], label [[END]]
; CHECK: end:
-; CHECK-NEXT: [[PHI_END:%.*]] = phi float* [ [[A_SROA_0_0_GEP_A_CAST_TO_FLOAT_SROA_CAST2]], [[ENTRY]] ], [ [[PHI]], [[FOR]] ]
-; CHECK-NEXT: [[PHI_END_1:%.*]] = bitcast float* [[PHI_END]] to i32*
-; CHECK-NEXT: [[LOAD:%.*]] = load i32, i32* [[PHI_END_1]], align 4
+; CHECK-NEXT: [[PHI_END:%.*]] = phi ptr [ [[A_SROA_0]], [[ENTRY]] ], [ [[PHI]], [[FOR]] ]
+; CHECK-NEXT: [[LOAD:%.*]] = load i32, ptr [[PHI_END]], align 4
; CHECK-NEXT: ret i32 [[LOAD]]
;
entry:
%a = alloca %pair, align 4
- %gep_a = getelementptr inbounds %pair, %pair* %a, i32 0, i32 1
- %gep_a_cast_to_float = bitcast i32* %gep_a to float*
- store float 1.0, float* %gep_a_cast_to_float, align 4
+ %gep_a = getelementptr inbounds %pair, ptr %a, i32 0, i32 1
+ store float 1.0, ptr %gep_a, align 4
br i1 %cond, label %for, label %end
for:
%phi_i = phi i32 [ 0, %entry ], [ %i, %for ]
- %phi = phi float* [ %gep_a_cast_to_float, %entry], [ %gep_for_cast_to_float, %for ]
+ %phi = phi ptr [ %gep_a, %entry], [ %gep_for, %for ]
%i = add i32 %phi_i, 1
%gep_for = getelementptr inbounds float, float* %phi, i32 0
- %gep_for_cast = bitcast float* %gep_for to i32*
- %gep_for_cast_to_float = bitcast i32* %gep_for_cast to float*
%loop.cond = icmp ult i32 %i, 10
br i1 %loop.cond, label %for, label %end
end:
- %phi_end = phi float* [ %gep_a_cast_to_float, %entry], [ %phi, %for ]
- %phi_end.1 = bitcast float* %phi_end to i32*
- %load = load i32, i32* %phi_end.1, align 4
+ %phi_end = phi ptr [ %gep_a, %entry], [ %phi, %for ]
+ %load = load i32, ptr %phi_end, align 4
ret i32 %load
}
define void @unreachable_term(i1 %c1) {
; CHECK-LABEL: @unreachable_term(
; CHECK-NEXT: [[A_SROA_0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[A_SROA_0_0_A_SROA_CAST1:%.*]] = bitcast i32* [[A_SROA_0]] to [3 x i32]*
; CHECK-NEXT: unreachable
; CHECK: bb1:
; CHECK-NEXT: br label [[BB1_I:%.*]]
; CHECK: bb1.i:
-; CHECK-NEXT: [[PHI:%.*]] = phi [3 x i32]* [ [[A_SROA_0_0_A_SROA_CAST1]], [[BB1:%.*]] ], [ null, [[BB1_I]] ]
-; CHECK-NEXT: [[GEP:%.*]] = getelementptr [3 x i32], [3 x i32]* [[PHI]], i64 0, i64 0
-; CHECK-NEXT: store i32 0, i32* [[GEP]], align 1
+; CHECK-NEXT: [[PHI:%.*]] = phi ptr [ [[A_SROA_0]], [[BB1:%.*]] ], [ null, [[BB1_I]] ]
+; CHECK-NEXT: store i32 0, ptr [[PHI]], align 1
; CHECK-NEXT: br i1 [[C1:%.*]], label [[BB1_I]], label [[EXIT:%.*]]
; CHECK: exit:
; CHECK-NEXT: br label [[BB2:%.*]]
@@ -441,9 +428,8 @@ bb1:
br label %bb1.i
bb1.i:
- %phi = phi [3 x i32]* [ %a, %bb1 ], [ null, %bb1.i ]
- %gep = getelementptr [3 x i32], [3 x i32]* %phi, i64 0, i64 0
- store i32 0, i32* %gep, align 1
+ %phi = phi ptr [ %a, %bb1 ], [ null, %bb1.i ]
+ store i32 0, ptr %phi, align 1
br i1 %c1, label %bb1.i, label %exit
exit:
@@ -465,18 +451,15 @@ define void @constant_value_phi(i1 %c1) {
entry:
%s1 = alloca [3 x i16]
%s = alloca [3 x i16]
- %cast = bitcast [3 x i16]* %s1 to i16*
br label %land.lhs.true.i
land.lhs.true.i: ; preds = %entry
br i1 %c1, label %cond.end.i, label %cond.end.i
cond.end.i: ; preds = %land.lhs.true.i, %land.lhs.true.i
- %.pre-phi1 = phi i16* [ %cast, %land.lhs.true.i ], [ %cast, %land.lhs.true.i ]
- %cast2 = bitcast [3 x i16]* %s to i16*
- call void @llvm.memcpy.p0i16.p0i16.i64(i16* %.pre-phi1, i16* %cast2, i64 3, i1 false)
- %gep = getelementptr inbounds [3 x i16], [3 x i16]* %s, i32 0, i32 0
- %load = load i16, i16* %gep
+ %.pre-phi1 = phi ptr [ %s1, %land.lhs.true.i ], [ %s1, %land.lhs.true.i ]
+ call void @llvm.memcpy.p0.p0.i64(ptr %.pre-phi1, ptr %s, i64 3, i1 false)
+ %load = load i16, ptr %s
unreachable
}
@@ -514,14 +497,14 @@ bb.3: ; preds = %bb.1
br label %bb.4
bb.4: ; preds = %bb.1, %bb.1, %bb.3, %bb.2
- %phi = phi %pair* [ %a, %bb.3 ], [ %a, %bb.2 ], [ %b, %bb.1 ], [ %b, %bb.1 ]
- %gep = getelementptr inbounds %pair, %pair* %phi, i32 0, i32 1
- %load = load i32, i32* %gep, align 4
+ %phi = phi ptr [ %a, %bb.3 ], [ %a, %bb.2 ], [ %b, %bb.1 ], [ %b, %bb.1 ]
+ %gep = getelementptr inbounds %pair, ptr %phi, i32 0, i32 1
+ %load = load i32, ptr %gep, align 4
ret i32 %load
}
-declare %pair* @foo()
+declare ptr @foo()
declare i32 @__gxx_personality_v0(...)
-declare void @llvm.memcpy.p0i16.p0i16.i64(i16* noalias nocapture writeonly, i16* noalias nocapture readonly, i64, i1 immarg)
+declare void @llvm.memcpy.p0.p0.i64(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i64, i1 immarg)
diff --git a/llvm/test/Transforms/SROA/phi-with-duplicate-pred.ll b/llvm/test/Transforms/SROA/phi-with-duplicate-pred.ll
index 9d0264faee17..2361a50937fe 100644
--- a/llvm/test/Transforms/SROA/phi-with-duplicate-pred.ll
+++ b/llvm/test/Transforms/SROA/phi-with-duplicate-pred.ll
@@ -13,7 +13,7 @@ define void @f2(i1 %c1) {
; CHECK: if.then:
; CHECK-NEXT: br label [[CLEANUP:%.*]]
; CHECK: cleanup:
-; CHECK-NEXT: [[G_0_SROA_SPECULATE_LOAD_CLEANUP:%.*]] = load i16, i16* @a, align 1
+; CHECK-NEXT: [[G_0_SROA_SPECULATE_LOAD_CLEANUP:%.*]] = load i16, ptr @a, align 1
; CHECK-NEXT: switch i32 2, label [[CLEANUP7:%.*]] [
; CHECK-NEXT: i32 0, label [[LBL1:%.*]]
; CHECK-NEXT: i32 2, label [[LBL1]]
@@ -43,8 +43,8 @@ if.else: ; preds = %entry
br label %lbl1
lbl1: ; preds = %if.else, %cleanup, %cleanup
- %g.0 = phi i16* [ @a, %cleanup ], [ @a, %cleanup ], [ %e, %if.else ]
- %0 = load i16, i16* %g.0, align 1
+ %g.0 = phi ptr [ @a, %cleanup ], [ @a, %cleanup ], [ %e, %if.else ]
+ %0 = load i16, ptr %g.0, align 1
unreachable
cleanup7: ; preds = %cleanup
@@ -66,10 +66,10 @@ define void @f3(i1 %c1) {
; CHECK: if.else:
; CHECK-NEXT: br label [[LBL1]]
; CHECK: lbl1:
-; CHECK-NEXT: [[G_0:%.*]] = phi i16* [ @a, [[CLEANUP]] ], [ @a, [[CLEANUP]] ], [ [[E]], [[IF_ELSE]] ]
+; CHECK-NEXT: [[G_0:%.*]] = phi ptr [ @a, [[CLEANUP]] ], [ @a, [[CLEANUP]] ], [ [[E]], [[IF_ELSE]] ]
; CHECK-NEXT: br label [[FINAL:%.*]]
; CHECK: final:
-; CHECK-NEXT: [[TMP0:%.*]] = load i16, i16* [[G_0]], align 1
+; CHECK-NEXT: [[TMP0:%.*]] = load i16, ptr [[G_0]], align 1
; CHECK-NEXT: unreachable
; CHECK: cleanup7:
; CHECK-NEXT: ret void
@@ -91,11 +91,11 @@ if.else: ; preds = %entry
br label %lbl1
lbl1: ; preds = %if.else, %cleanup, %cleanup
- %g.0 = phi i16* [ @a, %cleanup ], [ @a, %cleanup ], [ %e, %if.else ]
+ %g.0 = phi ptr [ @a, %cleanup ], [ @a, %cleanup ], [ %e, %if.else ]
br label %final
final:
- %0 = load i16, i16* %g.0, align 1
+ %0 = load i16, ptr %g.0, align 1
unreachable
cleanup7: ; preds = %cleanup
@@ -117,11 +117,11 @@ define void @f4(i1 %c1) {
; CHECK: if.else:
; CHECK-NEXT: br label [[LBL1]]
; CHECK: lbl1:
-; CHECK-NEXT: [[G_0:%.*]] = phi i16* [ @a, [[CLEANUP]] ], [ @a, [[CLEANUP]] ], [ [[E]], [[IF_ELSE]] ]
+; CHECK-NEXT: [[G_0:%.*]] = phi ptr [ @a, [[CLEANUP]] ], [ @a, [[CLEANUP]] ], [ [[E]], [[IF_ELSE]] ]
; CHECK-NEXT: br label [[FINAL:%.*]]
; CHECK: final:
; CHECK-NEXT: call void @maybe_writes()
-; CHECK-NEXT: [[TMP0:%.*]] = load i16, i16* [[G_0]], align 1
+; CHECK-NEXT: [[TMP0:%.*]] = load i16, ptr [[G_0]], align 1
; CHECK-NEXT: unreachable
; CHECK: cleanup7:
; CHECK-NEXT: ret void
@@ -143,12 +143,12 @@ if.else: ; preds = %entry
br label %lbl1
lbl1: ; preds = %if.else, %cleanup, %cleanup
- %g.0 = phi i16* [ @a, %cleanup ], [ @a, %cleanup ], [ %e, %if.else ]
+ %g.0 = phi ptr [ @a, %cleanup ], [ @a, %cleanup ], [ %e, %if.else ]
br label %final
final:
call void @maybe_writes()
- %0 = load i16, i16* %g.0, align 1
+ %0 = load i16, ptr %g.0, align 1
unreachable
cleanup7: ; preds = %cleanup
@@ -170,10 +170,10 @@ define void @f5(i1 %c1, i1 %c2) {
; CHECK: if.else:
; CHECK-NEXT: br label [[LBL1]]
; CHECK: lbl1:
-; CHECK-NEXT: [[G_0:%.*]] = phi i16* [ @a, [[CLEANUP]] ], [ @a, [[CLEANUP]] ], [ [[E]], [[IF_ELSE]] ]
+; CHECK-NEXT: [[G_0:%.*]] = phi ptr [ @a, [[CLEANUP]] ], [ @a, [[CLEANUP]] ], [ [[E]], [[IF_ELSE]] ]
; CHECK-NEXT: br i1 [[C2:%.*]], label [[FINAL:%.*]], label [[CLEANUP7]]
; CHECK: final:
-; CHECK-NEXT: [[TMP0:%.*]] = load i16, i16* [[G_0]], align 1
+; CHECK-NEXT: [[TMP0:%.*]] = load i16, ptr [[G_0]], align 1
; CHECK-NEXT: unreachable
; CHECK: cleanup7:
; CHECK-NEXT: ret void
@@ -195,11 +195,11 @@ if.else: ; preds = %entry
br label %lbl1
lbl1: ; preds = %if.else, %cleanup, %cleanup
- %g.0 = phi i16* [ @a, %cleanup ], [ @a, %cleanup ], [ %e, %if.else ]
+ %g.0 = phi ptr [ @a, %cleanup ], [ @a, %cleanup ], [ %e, %if.else ]
br i1 %c2, label %final, label %cleanup7
final:
- %0 = load i16, i16* %g.0, align 1
+ %0 = load i16, ptr %g.0, align 1
unreachable
cleanup7: ; preds = %cleanup
@@ -221,13 +221,13 @@ define void @f6(i1 %c1) {
; CHECK: if.else:
; CHECK-NEXT: br label [[LBL1]]
; CHECK: lbl1:
-; CHECK-NEXT: [[G_0:%.*]] = phi i16* [ @a, [[CLEANUP]] ], [ @a, [[CLEANUP]] ], [ [[E]], [[IF_ELSE]] ]
+; CHECK-NEXT: [[G_0:%.*]] = phi ptr [ @a, [[CLEANUP]] ], [ @a, [[CLEANUP]] ], [ [[E]], [[IF_ELSE]] ]
; CHECK-NEXT: br label [[FINAL:%.*]]
; CHECK: unreachable_pred:
; CHECK-NEXT: br label [[FINAL]]
; CHECK: final:
; CHECK-NEXT: call void @maybe_writes()
-; CHECK-NEXT: [[TMP0:%.*]] = load i16, i16* [[G_0]], align 1
+; CHECK-NEXT: [[TMP0:%.*]] = load i16, ptr [[G_0]], align 1
; CHECK-NEXT: unreachable
; CHECK: cleanup7:
; CHECK-NEXT: ret void
@@ -249,7 +249,7 @@ if.else: ; preds = %entry
br label %lbl1
lbl1: ; preds = %if.else, %cleanup, %cleanup
- %g.0 = phi i16* [ @a, %cleanup ], [ @a, %cleanup ], [ %e, %if.else ]
+ %g.0 = phi ptr [ @a, %cleanup ], [ @a, %cleanup ], [ %e, %if.else ]
br label %final
unreachable_pred:
@@ -257,7 +257,7 @@ unreachable_pred:
final:
call void @maybe_writes()
- %0 = load i16, i16* %g.0, align 1
+ %0 = load i16, ptr %g.0, align 1
unreachable
cleanup7: ; preds = %cleanup
diff --git a/llvm/test/Transforms/SROA/pointer-offset-size.ll b/llvm/test/Transforms/SROA/pointer-offset-size.ll
index 6bb241b22ee0..8968c8ca610c 100644
--- a/llvm/test/Transforms/SROA/pointer-offset-size.ll
+++ b/llvm/test/Transforms/SROA/pointer-offset-size.ll
@@ -5,25 +5,22 @@ target datalayout = "e-p:64:64:64:32"
%struct.test = type { %struct.basic, %struct.basic }
%struct.basic = type { i16, i8 }
-define i16 @test(%struct.test* %ts2.i) {
+define i16 @test(ptr %ts2.i) {
; CHECK-LABEL: @test(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[S_SROA_0:%.*]] = alloca [3 x i8], align 8
-; CHECK-NEXT: [[S_SROA_0_0__SROA_CAST:%.*]] = bitcast %struct.test* [[TS2_I:%.*]] to i8*
-; CHECK-NEXT: [[S_SROA_0_0__SROA_IDX:%.*]] = getelementptr inbounds [3 x i8], [3 x i8]* [[S_SROA_0]], i32 0, i32 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[S_SROA_0_0__SROA_CAST]], i8* align 8 [[S_SROA_0_0__SROA_IDX]], i32 3, i1 false)
-; CHECK-NEXT: [[X1_I_I:%.*]] = getelementptr inbounds [[STRUCT_TEST:%.*]], %struct.test* [[TS2_I]], i32 0, i32 0, i32 0
-; CHECK-NEXT: [[TMP0:%.*]] = load i16, i16* [[X1_I_I]], align 2
-; CHECK-NEXT: ret i16 [[TMP0]]
+; CHECK-NEXT: [[TMP0:%.*]] = bitcast ptr [[TS2_I:%.*]] to ptr
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[TMP0]], ptr align 8 [[S_SROA_0]], i32 3, i1 false)
+; CHECK-NEXT: [[TMP1:%.*]] = load i16, ptr [[TS2_I]], align 2
+; CHECK-NEXT: ret i16 [[TMP1]]
;
entry:
%s = alloca %struct.test
- %0 = bitcast %struct.test* %ts2.i to i8*
- %1 = bitcast %struct.test* %s to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %0, i8* %1, i32 3, i1 false)
- %x1.i.i = getelementptr inbounds %struct.test, %struct.test* %ts2.i, i32 0, i32 0, i32 0
- %2 = load i16, i16* %x1.i.i
+ %0 = bitcast ptr %ts2.i to ptr
+ %1 = bitcast ptr %s to ptr
+ call void @llvm.memcpy.p0.p0.i32(ptr %0, ptr %1, i32 3, i1 false)
+ %2 = load i16, ptr %ts2.i
ret i16 %2
}
-declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture writeonly, i8* nocapture readonly, i32, i1)
+declare void @llvm.memcpy.p0.p0.i32(ptr nocapture writeonly, ptr nocapture readonly, i32, i1)
diff --git a/llvm/test/Transforms/SROA/ppcf128-no-fold.ll b/llvm/test/Transforms/SROA/ppcf128-no-fold.ll
index 9bd90e734029..c991c0d679aa 100644
--- a/llvm/test/Transforms/SROA/ppcf128-no-fold.ll
+++ b/llvm/test/Transforms/SROA/ppcf128-no-fold.ll
@@ -3,24 +3,20 @@ target datalayout = "E-m:e-i64:64-n32:64"
target triple = "powerpc64-unknown-linux-gnu"
%struct.ld2 = type { [2 x ppc_fp128] }
-declare void @bar(i8*, [2 x i128])
+declare void @bar(ptr, [2 x i128])
-define void @foo(i8* %v) #0 {
+define void @foo(ptr %v) #0 {
entry:
- %v.addr = alloca i8*, align 8
+ %v.addr = alloca ptr, align 8
%z = alloca %struct.ld2, align 16
- store i8* %v, i8** %v.addr, align 8
- %dat = getelementptr inbounds %struct.ld2, %struct.ld2* %z, i32 0, i32 0
- %arrayidx = getelementptr inbounds [2 x ppc_fp128], [2 x ppc_fp128]* %dat, i32 0, i64 0
- store ppc_fp128 0xM403B0000000000000000000000000000, ppc_fp128* %arrayidx, align 16
- %dat1 = getelementptr inbounds %struct.ld2, %struct.ld2* %z, i32 0, i32 0
- %arrayidx2 = getelementptr inbounds [2 x ppc_fp128], [2 x ppc_fp128]* %dat1, i32 0, i64 1
- store ppc_fp128 0xM4093B400000000000000000000000000, ppc_fp128* %arrayidx2, align 16
- %0 = load i8*, i8** %v.addr, align 8
- %coerce.dive = getelementptr %struct.ld2, %struct.ld2* %z, i32 0, i32 0
- %1 = bitcast [2 x ppc_fp128]* %coerce.dive to [2 x i128]*
- %2 = load [2 x i128], [2 x i128]* %1, align 1
- call void @bar(i8* %0, [2 x i128] %2)
+ store ptr %v, ptr %v.addr, align 8
+ store ppc_fp128 0xM403B0000000000000000000000000000, ptr %z, align 16
+ %arrayidx2 = getelementptr inbounds [2 x ppc_fp128], ptr %z, i32 0, i64 1
+ store ppc_fp128 0xM4093B400000000000000000000000000, ptr %arrayidx2, align 16
+ %0 = load ptr, ptr %v.addr, align 8
+ %1 = bitcast ptr %z to ptr
+ %2 = load [2 x i128], ptr %1, align 1
+ call void @bar(ptr %0, [2 x i128] %2)
ret void
}
@@ -29,7 +25,7 @@ entry:
; CHECK-NOT: i128 4653260752096854016
; CHECK-DAG: bitcast ppc_fp128 0xM403B0000000000000000000000000000 to i128
; CHECK-DAG: bitcast ppc_fp128 0xM4093B400000000000000000000000000 to i128
-; CHECK: call void @bar(i8* %v, [2 x i128]
+; CHECK: call void @bar(ptr %v, [2 x i128]
; CHECK: ret void
attributes #0 = { nounwind }
diff --git a/llvm/test/Transforms/SROA/pr26972.ll b/llvm/test/Transforms/SROA/pr26972.ll
index 46bf8f09357d..bb6f4a779b99 100644
--- a/llvm/test/Transforms/SROA/pr26972.ll
+++ b/llvm/test/Transforms/SROA/pr26972.ll
@@ -9,9 +9,8 @@ target triple = "x86_64-pc-linux"
; CHECK-NEXT: ret void
define void @fn1() {
%a = alloca [1073741825 x i32], align 16
- %t0 = bitcast [1073741825 x i32]* %a to i8*
- call void @llvm.lifetime.end.p0i8(i64 4294967300, i8* %t0)
+ call void @llvm.lifetime.end.p0(i64 4294967300, ptr %a)
ret void
}
-declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
+declare void @llvm.lifetime.end.p0(i64, ptr nocapture)
diff --git a/llvm/test/Transforms/SROA/pr37267.ll b/llvm/test/Transforms/SROA/pr37267.ll
index ee583c4218db..633ffcccc698 100644
--- a/llvm/test/Transforms/SROA/pr37267.ll
+++ b/llvm/test/Transforms/SROA/pr37267.ll
@@ -24,19 +24,17 @@ bb1:
%a.3 = alloca [6 x i16], align 1
; slice 1: [2,6)
- %_tmp3 = getelementptr inbounds [6 x i16], [6 x i16]* %a.3, i16 0, i16 1
- %_tmp5 = bitcast i16* %_tmp3 to i32*
- store i32 131074, i32* %_tmp5, align 1
+ %_tmp3 = getelementptr inbounds [6 x i16], ptr %a.3, i16 0, i16 1
+ store i32 131074, ptr %_tmp3, align 1
; slice 2: [8,12)
- %_tmp8 = getelementptr inbounds [6 x i16], [6 x i16]* %a.3, i16 0, i16 4
- %_tmp10 = bitcast i16* %_tmp8 to i32*
- store i32 131074, i32* %_tmp10, align 1
+ %_tmp8 = getelementptr inbounds [6 x i16], ptr %a.3, i16 0, i16 4
+ store i32 131074, ptr %_tmp8, align 1
; slice 3: [8,10)
- %_tmp12 = getelementptr inbounds [6 x i16], [6 x i16]* %a.3, i16 0, i16 4
- %_tmp13 = load i16, i16* %_tmp12, align 1
+ %_tmp12 = getelementptr inbounds [6 x i16], ptr %a.3, i16 0, i16 4
+ %_tmp13 = load i16, ptr %_tmp12, align 1
; slice 4: [2,4)
- %_tmp15 = getelementptr inbounds [6 x i16], [6 x i16]* %a.3, i16 0, i16 1
- %_tmp16 = load i16, i16* %_tmp15, align 1
+ %_tmp15 = getelementptr inbounds [6 x i16], ptr %a.3, i16 0, i16 1
+ %_tmp16 = load i16, ptr %_tmp15, align 1
%rc = add i16 %_tmp13, %_tmp16
ret i16 %rc
@@ -67,19 +65,17 @@ bb1:
%a.3 = alloca [6 x i16], align 1
; slice 1: [2,6)
- %_tmp3 = getelementptr inbounds [6 x i16], [6 x i16]* %a.3, i16 0, i16 1
- %_tmp5 = bitcast i16* %_tmp3 to i32*
- %_tmp6 = load i32, i32* %_tmp5, align 1
+ %_tmp3 = getelementptr inbounds [6 x i16], ptr %a.3, i16 0, i16 1
+ %_tmp6 = load i32, ptr %_tmp3, align 1
; slice 2: [8,12)
- %_tmp8 = getelementptr inbounds [6 x i16], [6 x i16]* %a.3, i16 0, i16 4
- %_tmp10 = bitcast i16* %_tmp8 to i32*
- store i32 131074, i32* %_tmp10, align 1
+ %_tmp8 = getelementptr inbounds [6 x i16], ptr %a.3, i16 0, i16 4
+ store i32 131074, ptr %_tmp8, align 1
; slice 3: [8,10)
- %_tmp12 = getelementptr inbounds [6 x i16], [6 x i16]* %a.3, i16 0, i16 4
- %_tmp13 = load i16, i16* %_tmp12, align 1
+ %_tmp12 = getelementptr inbounds [6 x i16], ptr %a.3, i16 0, i16 4
+ %_tmp13 = load i16, ptr %_tmp12, align 1
; slice 4: [2,4)
- %_tmp15 = getelementptr inbounds [6 x i16], [6 x i16]* %a.3, i16 0, i16 1
- %_tmp16 = load i16, i16* %_tmp15, align 1
+ %_tmp15 = getelementptr inbounds [6 x i16], ptr %a.3, i16 0, i16 1
+ %_tmp16 = load i16, ptr %_tmp15, align 1
%rc = add i16 %_tmp13, %_tmp16
ret i16 %rc
diff --git a/llvm/test/Transforms/SROA/preserve-nonnull.ll b/llvm/test/Transforms/SROA/preserve-nonnull.ll
index 81b23cb93dc4..effb0852ffbb 100644
--- a/llvm/test/Transforms/SROA/preserve-nonnull.ll
+++ b/llvm/test/Transforms/SROA/preserve-nonnull.ll
@@ -3,43 +3,37 @@
; Make sure that SROA doesn't lose nonnull metadata
; on loads from allocas that get optimized out.
-declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1)
+declare void @llvm.memcpy.p0.p0.i64(ptr nocapture writeonly, ptr nocapture readonly, i64, i1)
; Check that we do basic propagation of nonnull when rewriting.
-define i8* @propagate_nonnull(i32* %v) {
-; CHECK-LABEL: define i8* @propagate_nonnull(
+define ptr @propagate_nonnull(ptr %v) {
+; CHECK-LABEL: define ptr @propagate_nonnull(
; CHECK-NEXT: entry:
-; CHECK-NEXT: %[[A:.*]] = alloca i8*
-; CHECK-NEXT: %[[V_CAST:.*]] = bitcast i32* %v to i8*
-; CHECK-NEXT: store i8* %[[V_CAST]], i8** %[[A]]
-; CHECK-NEXT: %[[LOAD:.*]] = load volatile i8*, i8** %[[A]], align 8, !nonnull !0
-; CHECK-NEXT: ret i8* %[[LOAD]]
+; CHECK-NEXT: %[[A:.*]] = alloca ptr
+; CHECK-NEXT: store ptr %v, ptr %[[A]]
+; CHECK-NEXT: %[[LOAD:.*]] = load volatile ptr, ptr %[[A]], align 8, !nonnull !0
+; CHECK-NEXT: ret ptr %[[LOAD]]
entry:
- %a = alloca [2 x i8*]
- %a.gep0 = getelementptr [2 x i8*], [2 x i8*]* %a, i32 0, i32 0
- %a.gep1 = getelementptr [2 x i8*], [2 x i8*]* %a, i32 0, i32 1
- %a.gep0.cast = bitcast i8** %a.gep0 to i32**
- %a.gep1.cast = bitcast i8** %a.gep1 to i32**
- store i32* %v, i32** %a.gep1.cast
- store i32* null, i32** %a.gep0.cast
- %load = load volatile i8*, i8** %a.gep1, !nonnull !0
- ret i8* %load
+ %a = alloca [2 x ptr]
+ %a.gep1 = getelementptr [2 x ptr], ptr %a, i32 0, i32 1
+ store ptr %v, ptr %a.gep1
+ store ptr null, ptr %a
+ %load = load volatile ptr, ptr %a.gep1, !nonnull !0
+ ret ptr %load
}
-define float* @turn_nonnull_into_assume(float** %arg) {
-; CHECK-LABEL: define float* @turn_nonnull_into_assume(
+define ptr @turn_nonnull_into_assume(ptr %arg) {
+; CHECK-LABEL: define ptr @turn_nonnull_into_assume(
; CHECK-NEXT: entry:
-; CHECK-NEXT: %[[RETURN:.*]] = load float*, float** %arg, align 8
-; CHECK-NEXT: %[[ASSUME:.*]] = icmp ne float* %[[RETURN]], null
+; CHECK-NEXT: %[[RETURN:.*]] = load ptr, ptr %arg, align 8
+; CHECK-NEXT: %[[ASSUME:.*]] = icmp ne ptr %[[RETURN]], null
; CHECK-NEXT: call void @llvm.assume(i1 %[[ASSUME]])
-; CHECK-NEXT: ret float* %[[RETURN]]
+; CHECK-NEXT: ret ptr %[[RETURN]]
entry:
- %buf = alloca float*
- %_arg_i8 = bitcast float** %arg to i8*
- %_buf_i8 = bitcast float** %buf to i8*
- call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %_buf_i8, i8* align 8 %_arg_i8, i64 8, i1 false)
- %ret = load float*, float** %buf, align 8, !nonnull !0
- ret float* %ret
+ %buf = alloca ptr
+ call void @llvm.memcpy.p0.p0.i64(ptr align 8 %buf, ptr align 8 %arg, i64 8, i1 false)
+ %ret = load ptr, ptr %buf, align 8, !nonnull !0
+ ret ptr %ret
}
; Make sure we properly handle the !nonnull attribute when we convert
@@ -48,43 +42,37 @@ entry:
; should propagate the !nonnull metadata to range metadata. The irony is, it
; *does* initially, but then we lose that !range metadata before we finish
; SROA.
-define i8* @propagate_nonnull_to_int() {
-; CHECK-LABEL: define i8* @propagate_nonnull_to_int(
+define ptr @propagate_nonnull_to_int() {
+; CHECK-LABEL: define ptr @propagate_nonnull_to_int(
; CHECK-NEXT: entry:
-; CHECK-NEXT: %[[A:.*]] = alloca i8*
-; CHECK-NEXT: store i8* inttoptr (i64 42 to i8*), i8** %[[A]]
-; CHECK-NEXT: %[[LOAD:.*]] = load volatile i8*, i8** %[[A]]
-; CHECK-NEXT: ret i8* %[[LOAD]]
+; CHECK-NEXT: %[[A:.*]] = alloca ptr
+; CHECK-NEXT: store ptr inttoptr (i64 42 to ptr), ptr %[[A]]
+; CHECK-NEXT: %[[LOAD:.*]] = load volatile ptr, ptr %[[A]]
+; CHECK-NEXT: ret ptr %[[LOAD]]
entry:
- %a = alloca [2 x i8*]
- %a.gep0 = getelementptr [2 x i8*], [2 x i8*]* %a, i32 0, i32 0
- %a.gep1 = getelementptr [2 x i8*], [2 x i8*]* %a, i32 0, i32 1
- %a.gep0.cast = bitcast i8** %a.gep0 to i64*
- %a.gep1.cast = bitcast i8** %a.gep1 to i64*
- store i64 42, i64* %a.gep1.cast
- store i64 0, i64* %a.gep0.cast
- %load = load volatile i8*, i8** %a.gep1, !nonnull !0
- ret i8* %load
+ %a = alloca [2 x ptr]
+ %a.gep1 = getelementptr [2 x ptr], ptr %a, i32 0, i32 1
+ store i64 42, ptr %a.gep1
+ store i64 0, ptr %a
+ %load = load volatile ptr, ptr %a.gep1, !nonnull !0
+ ret ptr %load
}
; Make sure we properly handle the !nonnull attribute when we convert
; a pointer load to an integer load and immediately promote it to an SSA
; register. This can fail in interesting ways due to the rewrite iteration of
; SROA, resulting in PR32902.
-define i8* @propagate_nonnull_to_int_and_promote() {
-; CHECK-LABEL: define i8* @propagate_nonnull_to_int_and_promote(
+define ptr @propagate_nonnull_to_int_and_promote() {
+; CHECK-LABEL: define ptr @propagate_nonnull_to_int_and_promote(
; CHECK-NEXT: entry:
-; CHECK-NEXT: ret i8* inttoptr (i64 42 to i8*)
+; CHECK-NEXT: ret ptr inttoptr (i64 42 to ptr)
entry:
- %a = alloca [2 x i8*], align 8
- %a.gep0 = getelementptr [2 x i8*], [2 x i8*]* %a, i32 0, i32 0
- %a.gep1 = getelementptr [2 x i8*], [2 x i8*]* %a, i32 0, i32 1
- %a.gep0.cast = bitcast i8** %a.gep0 to i64*
- %a.gep1.cast = bitcast i8** %a.gep1 to i64*
- store i64 42, i64* %a.gep1.cast
- store i64 0, i64* %a.gep0.cast
- %load = load i8*, i8** %a.gep1, align 8, !nonnull !0
- ret i8* %load
+ %a = alloca [2 x ptr], align 8
+ %a.gep1 = getelementptr [2 x ptr], ptr %a, i32 0, i32 1
+ store i64 42, ptr %a.gep1
+ store i64 0, ptr %a
+ %load = load ptr, ptr %a.gep1, align 8, !nonnull !0
+ ret ptr %load
}
!0 = !{}
diff --git a/llvm/test/Transforms/SROA/scalable-vectors.ll b/llvm/test/Transforms/SROA/scalable-vectors.ll
index 6fd651f775b4..a6a57fa408a3 100644
--- a/llvm/test/Transforms/SROA/scalable-vectors.ll
+++ b/llvm/test/Transforms/SROA/scalable-vectors.ll
@@ -9,8 +9,8 @@ define <vscale x 16 x i1> @alloca_nxv16i1(<vscale x 16 x i1> %pg) {
; CHECK-NEXT: ret <vscale x 16 x i1> [[PG:%.*]]
;
%pg.addr = alloca <vscale x 16 x i1>
- store <vscale x 16 x i1> %pg, <vscale x 16 x i1>* %pg.addr
- %1 = load <vscale x 16 x i1>, <vscale x 16 x i1>* %pg.addr
+ store <vscale x 16 x i1> %pg, ptr %pg.addr
+ %1 = load <vscale x 16 x i1>, ptr %pg.addr
ret <vscale x 16 x i1> %1
}
@@ -19,8 +19,8 @@ define <vscale x 16 x i8> @alloca_nxv16i8(<vscale x 16 x i8> %vec) {
; CHECK-NEXT: ret <vscale x 16 x i8> [[VEC:%.*]]
;
%vec.addr = alloca <vscale x 16 x i8>
- store <vscale x 16 x i8> %vec, <vscale x 16 x i8>* %vec.addr
- %1 = load <vscale x 16 x i8>, <vscale x 16 x i8>* %vec.addr
+ store <vscale x 16 x i8> %vec, ptr %vec.addr
+ %1 = load <vscale x 16 x i8>, ptr %vec.addr
ret <vscale x 16 x i8> %1
}
@@ -29,13 +29,13 @@ define <vscale x 16 x i8> @alloca_nxv16i8(<vscale x 16 x i8> %vec) {
define <vscale x 16 x i8> @unpromotable_alloca(<vscale x 16 x i8> %vec) {
; CHECK-LABEL: @unpromotable_alloca(
; CHECK-NEXT: [[VEC_ADDR:%.*]] = alloca <vscale x 16 x i8>, align 16
-; CHECK-NEXT: store volatile <vscale x 16 x i8> [[VEC:%.*]], <vscale x 16 x i8>* [[VEC_ADDR]], align 16
-; CHECK-NEXT: [[TMP1:%.*]] = load volatile <vscale x 16 x i8>, <vscale x 16 x i8>* [[VEC_ADDR]], align 16
+; CHECK-NEXT: store volatile <vscale x 16 x i8> [[VEC:%.*]], ptr [[VEC_ADDR]], align 16
+; CHECK-NEXT: [[TMP1:%.*]] = load volatile <vscale x 16 x i8>, ptr [[VEC_ADDR]], align 16
; CHECK-NEXT: ret <vscale x 16 x i8> [[TMP1]]
;
%vec.addr = alloca <vscale x 16 x i8>
- store volatile <vscale x 16 x i8> %vec, <vscale x 16 x i8>* %vec.addr
- %1 = load volatile <vscale x 16 x i8>, <vscale x 16 x i8>* %vec.addr
+ store volatile <vscale x 16 x i8> %vec, ptr %vec.addr
+ %1 = load volatile <vscale x 16 x i8>, ptr %vec.addr
ret <vscale x 16 x i8> %1
}
@@ -45,24 +45,24 @@ define <vscale x 4 x i32> @cast_alloca_to_svint32_t(<vscale x 4 x i32> %type.coe
; CHECK-LABEL: @cast_alloca_to_svint32_t(
; CHECK-NEXT: [[TYPE:%.*]] = alloca <16 x i32>, align 64
; CHECK-NEXT: [[TYPE_ADDR:%.*]] = alloca <16 x i32>, align 64
-; CHECK-NEXT: [[TMP1:%.*]] = bitcast <16 x i32>* [[TYPE]] to <vscale x 4 x i32>*
-; CHECK-NEXT: store <vscale x 4 x i32> [[TYPE_COERCE:%.*]], <vscale x 4 x i32>* [[TMP1]], align 16
-; CHECK-NEXT: [[TYPE1:%.*]] = load <16 x i32>, <16 x i32>* [[TYPE]], align 64
-; CHECK-NEXT: store <16 x i32> [[TYPE1]], <16 x i32>* [[TYPE_ADDR]], align 64
-; CHECK-NEXT: [[TMP2:%.*]] = load <16 x i32>, <16 x i32>* [[TYPE_ADDR]], align 64
-; CHECK-NEXT: [[TMP3:%.*]] = bitcast <16 x i32>* [[TYPE_ADDR]] to <vscale x 4 x i32>*
-; CHECK-NEXT: [[TMP4:%.*]] = load <vscale x 4 x i32>, <vscale x 4 x i32>* [[TMP3]], align 16
+; CHECK-NEXT: [[TMP1:%.*]] = bitcast ptr [[TYPE]] to ptr
+; CHECK-NEXT: store <vscale x 4 x i32> [[TYPE_COERCE:%.*]], ptr [[TMP1]], align 16
+; CHECK-NEXT: [[TYPE1:%.*]] = load <16 x i32>, ptr [[TYPE]], align 64
+; CHECK-NEXT: store <16 x i32> [[TYPE1]], ptr [[TYPE_ADDR]], align 64
+; CHECK-NEXT: [[TMP2:%.*]] = load <16 x i32>, ptr [[TYPE_ADDR]], align 64
+; CHECK-NEXT: [[TMP3:%.*]] = bitcast ptr [[TYPE_ADDR]] to ptr
+; CHECK-NEXT: [[TMP4:%.*]] = load <vscale x 4 x i32>, ptr [[TMP3]], align 16
; CHECK-NEXT: ret <vscale x 4 x i32> [[TMP4]]
;
%type = alloca <16 x i32>
%type.addr = alloca <16 x i32>
- %1 = bitcast <16 x i32>* %type to <vscale x 4 x i32>*
- store <vscale x 4 x i32> %type.coerce, <vscale x 4 x i32>* %1
- %type1 = load <16 x i32>, <16 x i32>* %type
- store <16 x i32> %type1, <16 x i32>* %type.addr
- %2 = load <16 x i32>, <16 x i32>* %type.addr
- %3 = bitcast <16 x i32>* %type.addr to <vscale x 4 x i32>*
- %4 = load <vscale x 4 x i32>, <vscale x 4 x i32>* %3
+ %1 = bitcast ptr %type to ptr
+ store <vscale x 4 x i32> %type.coerce, ptr %1
+ %type1 = load <16 x i32>, ptr %type
+ store <16 x i32> %type1, ptr %type.addr
+ %2 = load <16 x i32>, ptr %type.addr
+ %3 = bitcast ptr %type.addr to ptr
+ %4 = load <vscale x 4 x i32>, ptr %3
ret <vscale x 4 x i32> %4
}
@@ -71,18 +71,18 @@ define <vscale x 4 x i32> @cast_alloca_to_svint32_t(<vscale x 4 x i32> %type.coe
define <vscale x 4 x i32> @cast_alloca_from_svint32_t() {
; CHECK-LABEL: @cast_alloca_from_svint32_t(
; CHECK-NEXT: [[RETVAL_COERCE:%.*]] = alloca <vscale x 4 x i32>, align 16
-; CHECK-NEXT: [[RETVAL_0__SROA_CAST:%.*]] = bitcast <vscale x 4 x i32>* [[RETVAL_COERCE]] to <16 x i32>*
-; CHECK-NEXT: store <16 x i32> undef, <16 x i32>* [[RETVAL_0__SROA_CAST]], align 16
-; CHECK-NEXT: [[TMP1:%.*]] = load <vscale x 4 x i32>, <vscale x 4 x i32>* [[RETVAL_COERCE]], align 16
-; CHECK-NEXT: ret <vscale x 4 x i32> [[TMP1]]
+; CHECK-NEXT: [[TMP1:%.*]] = bitcast ptr [[RETVAL_COERCE]] to ptr
+; CHECK-NEXT: store <16 x i32> undef, ptr [[TMP1]], align 16
+; CHECK-NEXT: [[TMP2:%.*]] = load <vscale x 4 x i32>, ptr [[RETVAL_COERCE]], align 16
+; CHECK-NEXT: ret <vscale x 4 x i32> [[TMP2]]
;
%retval = alloca <16 x i32>
%retval.coerce = alloca <vscale x 4 x i32>
- %1 = bitcast <vscale x 4 x i32>* %retval.coerce to i8*
- %2 = bitcast <16 x i32>* %retval to i8*
- call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %1, i8* align 16 %2, i64 64, i1 false)
- %3 = load <vscale x 4 x i32>, <vscale x 4 x i32>* %retval.coerce
+ %1 = bitcast ptr %retval.coerce to ptr
+ %2 = bitcast ptr %retval to ptr
+ call void @llvm.memcpy.p0.p0.i64(ptr align 16 %1, ptr align 16 %2, i64 64, i1 false)
+ %3 = load <vscale x 4 x i32>, ptr %retval.coerce
ret <vscale x 4 x i32> %3
}
-declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) nounwind
+declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1) nounwind
diff --git a/llvm/test/Transforms/SROA/select-gep.ll b/llvm/test/Transforms/SROA/select-gep.ll
index 91f497daf4a1..4309ad1405f6 100644
--- a/llvm/test/Transforms/SROA/select-gep.ll
+++ b/llvm/test/Transforms/SROA/select-gep.ll
@@ -12,13 +12,13 @@ define i32 @test_sroa_select_gep(i1 %cond) {
bb:
%a = alloca %pair, align 4
%b = alloca %pair, align 4
- %gep_a = getelementptr inbounds %pair, %pair* %a, i32 0, i32 1
- %gep_b = getelementptr inbounds %pair, %pair* %b, i32 0, i32 1
- store i32 1, i32* %gep_a, align 4
- store i32 2, i32* %gep_b, align 4
- %select = select i1 %cond, %pair* %a, %pair* %b
- %gep = getelementptr inbounds %pair, %pair* %select, i32 0, i32 1
- %load = load i32, i32* %gep, align 4
+ %gep_a = getelementptr inbounds %pair, ptr %a, i32 0, i32 1
+ %gep_b = getelementptr inbounds %pair, ptr %b, i32 0, i32 1
+ store i32 1, ptr %gep_a, align 4
+ store i32 2, ptr %gep_b, align 4
+ %select = select i1 %cond, ptr %a, ptr %b
+ %gep = getelementptr inbounds %pair, ptr %select, i32 0, i32 1
+ %load = load i32, ptr %gep, align 4
ret i32 %load
}
@@ -31,13 +31,13 @@ define i32 @test_sroa_select_gep_non_inbound(i1 %cond) {
bb:
%a = alloca %pair, align 4
%b = alloca %pair, align 4
- %gep_a = getelementptr %pair, %pair* %a, i32 0, i32 1
- %gep_b = getelementptr %pair, %pair* %b, i32 0, i32 1
- store i32 1, i32* %gep_a, align 4
- store i32 2, i32* %gep_b, align 4
- %select = select i1 %cond, %pair* %a, %pair* %b
- %gep = getelementptr %pair, %pair* %select, i32 0, i32 1
- %load = load i32, i32* %gep, align 4
+ %gep_a = getelementptr %pair, ptr %a, i32 0, i32 1
+ %gep_b = getelementptr %pair, ptr %b, i32 0, i32 1
+ store i32 1, ptr %gep_a, align 4
+ store i32 2, ptr %gep_b, align 4
+ %select = select i1 %cond, ptr %a, ptr %b
+ %gep = getelementptr %pair, ptr %select, i32 0, i32 1
+ %load = load i32, ptr %gep, align 4
ret i32 %load
}
@@ -48,33 +48,30 @@ define i32 @test_sroa_select_gep_volatile_load(i1 %cond) {
; CHECK-NEXT: [[A_SROA_2:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B_SROA_0:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B_SROA_2:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 11, i32* [[A_SROA_0]], align 4
-; CHECK-NEXT: store i32 12, i32* [[B_SROA_0]], align 4
-; CHECK-NEXT: store i32 21, i32* [[A_SROA_2]], align 4
-; CHECK-NEXT: store i32 22, i32* [[B_SROA_2]], align 4
-; CHECK-NEXT: [[SELECT_SROA_SEL:%.*]] = select i1 [[COND:%.*]], i32* [[A_SROA_0]], i32* [[B_SROA_0]]
-; CHECK-NEXT: [[LOAD1:%.*]] = load volatile i32, i32* [[SELECT_SROA_SEL]], align 4
-; CHECK-NEXT: [[SELECT_SROA_SEL3:%.*]] = select i1 [[COND]], i32* [[A_SROA_2]], i32* [[B_SROA_2]]
-; CHECK-NEXT: [[LOAD2:%.*]] = load volatile i32, i32* [[SELECT_SROA_SEL3]], align 4
+; CHECK-NEXT: store i32 11, ptr [[A_SROA_0]], align 4
+; CHECK-NEXT: store i32 12, ptr [[B_SROA_0]], align 4
+; CHECK-NEXT: store i32 21, ptr [[A_SROA_2]], align 4
+; CHECK-NEXT: store i32 22, ptr [[B_SROA_2]], align 4
+; CHECK-NEXT: [[SELECT_SROA_SEL:%.*]] = select i1 [[COND:%.*]], ptr [[A_SROA_0]], ptr [[B_SROA_0]]
+; CHECK-NEXT: [[LOAD1:%.*]] = load volatile i32, ptr [[SELECT_SROA_SEL]], align 4
+; CHECK-NEXT: [[SELECT_SROA_SEL3:%.*]] = select i1 [[COND]], ptr [[A_SROA_2]], ptr [[B_SROA_2]]
+; CHECK-NEXT: [[LOAD2:%.*]] = load volatile i32, ptr [[SELECT_SROA_SEL3]], align 4
; CHECK-NEXT: [[ADD:%.*]] = add i32 [[LOAD1]], [[LOAD2]]
; CHECK-NEXT: ret i32 [[ADD]]
;
bb:
%a = alloca %pair, align 4
%b = alloca %pair, align 4
- %gep_a0 = getelementptr inbounds %pair, %pair* %a, i32 0, i32 0
- %gep_b0 = getelementptr inbounds %pair, %pair* %b, i32 0, i32 0
- store i32 11, i32* %gep_a0, align 4
- store i32 12, i32* %gep_b0, align 4
- %gep_a1 = getelementptr inbounds %pair, %pair* %a, i32 0, i32 1
- %gep_b1 = getelementptr inbounds %pair, %pair* %b, i32 0, i32 1
- store i32 21, i32* %gep_a1, align 4
- store i32 22, i32* %gep_b1, align 4
- %select = select i1 %cond, %pair* %a, %pair* %b
- %gep1 = getelementptr inbounds %pair, %pair* %select, i32 0, i32 0
- %load1 = load volatile i32, i32* %gep1, align 4
- %gep2 = getelementptr inbounds %pair, %pair* %select, i32 0, i32 1
- %load2 = load volatile i32, i32* %gep2, align 4
+ store i32 11, ptr %a, align 4
+ store i32 12, ptr %b, align 4
+ %gep_a1 = getelementptr inbounds %pair, ptr %a, i32 0, i32 1
+ %gep_b1 = getelementptr inbounds %pair, ptr %b, i32 0, i32 1
+ store i32 21, ptr %gep_a1, align 4
+ store i32 22, ptr %gep_b1, align 4
+ %select = select i1 %cond, ptr %a, ptr %b
+ %load1 = load volatile i32, ptr %select, align 4
+ %gep2 = getelementptr inbounds %pair, ptr %select, i32 0, i32 1
+ %load2 = load volatile i32, ptr %gep2, align 4
%add = add i32 %load1, %load2
ret i32 %add
}
@@ -83,15 +80,15 @@ define i32 @test_sroa_select_gep_poison(i1 %cond) {
; CHECK-LABEL: @test_sroa_select_gep_poison(
; CHECK-NEXT: bb:
; CHECK-NEXT: [[A_SROA_0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[SELECT_SROA_SEL:%.*]] = select i1 [[COND:%.*]], i32* [[A_SROA_0]], i32* poison
-; CHECK-NEXT: [[LOAD:%.*]] = load i32, i32* [[SELECT_SROA_SEL]], align 4
+; CHECK-NEXT: [[SELECT_SROA_SEL:%.*]] = select i1 [[COND:%.*]], ptr [[A_SROA_0]], ptr poison
+; CHECK-NEXT: [[LOAD:%.*]] = load i32, ptr [[SELECT_SROA_SEL]], align 4
; CHECK-NEXT: ret i32 [[LOAD]]
;
bb:
%a = alloca %pair, align 4
- %select = select i1 %cond, %pair* %a, %pair* poison
- %gep = getelementptr inbounds %pair, %pair* %select, i32 0, i32 1
- %load = load i32, i32* %gep, align 4
+ %select = select i1 %cond, ptr %a, ptr poison
+ %gep = getelementptr inbounds %pair, ptr %select, i32 0, i32 1
+ %load = load i32, ptr %gep, align 4
ret i32 %load
}
@@ -100,24 +97,23 @@ define i32 @test_sroa_gep_select_gep(i1 %cond) {
; CHECK-NEXT: bb:
; CHECK-NEXT: [[A_SROA_0:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B_SROA_0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 1, i32* [[A_SROA_0]], align 4
-; CHECK-NEXT: store i32 2, i32* [[B_SROA_0]], align 4
-; CHECK-NEXT: [[SELECT_SROA_SEL:%.*]] = select i1 [[COND:%.*]], i32* [[A_SROA_0]], i32* [[B_SROA_0]]
-; CHECK-NEXT: [[SELECT2:%.*]] = select i1 [[COND]], i32* [[SELECT_SROA_SEL]], i32* [[A_SROA_0]]
-; CHECK-NEXT: [[LOAD:%.*]] = load i32, i32* [[SELECT2]], align 4
+; CHECK-NEXT: store i32 1, ptr [[A_SROA_0]], align 4
+; CHECK-NEXT: store i32 2, ptr [[B_SROA_0]], align 4
+; CHECK-NEXT: [[SELECT_SROA_SEL:%.*]] = select i1 [[COND:%.*]], ptr [[A_SROA_0]], ptr [[B_SROA_0]]
+; CHECK-NEXT: [[SELECT2:%.*]] = select i1 [[COND]], ptr [[SELECT_SROA_SEL]], ptr [[A_SROA_0]]
+; CHECK-NEXT: [[LOAD:%.*]] = load i32, ptr [[SELECT2]], align 4
; CHECK-NEXT: ret i32 [[LOAD]]
;
bb:
%a = alloca %pair, align 4
%b = alloca %pair, align 4
- %gep_a = getelementptr inbounds %pair, %pair* %a, i32 0, i32 1
- %gep_b = getelementptr inbounds %pair, %pair* %b, i32 0, i32 1
- store i32 1, i32* %gep_a, align 4
- store i32 2, i32* %gep_b, align 4
- %select = select i1 %cond, i32* %gep_a, i32* %gep_b
- %gep = getelementptr inbounds i32, i32* %select, i32 0
- %select2 = select i1 %cond, i32* %gep, i32* %gep_a
- %load = load i32, i32* %select2, align 4
+ %gep_a = getelementptr inbounds %pair, ptr %a, i32 0, i32 1
+ %gep_b = getelementptr inbounds %pair, ptr %b, i32 0, i32 1
+ store i32 1, ptr %gep_a, align 4
+ store i32 2, ptr %gep_b, align 4
+ %select = select i1 %cond, ptr %gep_a, ptr %gep_b
+ %select2 = select i1 %cond, ptr %select, ptr %gep_a
+ %load = load i32, ptr %select2, align 4
ret i32 %load
}
@@ -126,24 +122,24 @@ define i32 @test_sroa_gep_select_gep_nonconst_idx(i1 %cond, i32 %idx) {
; CHECK-NEXT: bb:
; CHECK-NEXT: [[A:%.*]] = alloca [[PAIR:%.*]], align 4
; CHECK-NEXT: [[B:%.*]] = alloca [[PAIR]], align 4
-; CHECK-NEXT: [[GEP_A:%.*]] = getelementptr inbounds [[PAIR]], %pair* [[A]], i32 0, i32 1
-; CHECK-NEXT: [[GEP_B:%.*]] = getelementptr inbounds [[PAIR]], %pair* [[B]], i32 0, i32 1
-; CHECK-NEXT: store i32 1, i32* [[GEP_A]], align 4
-; CHECK-NEXT: store i32 2, i32* [[GEP_B]], align 4
-; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND:%.*]], %pair* [[A]], %pair* [[B]]
-; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds [[PAIR]], %pair* [[SELECT]], i32 [[IDX:%.*]], i32 1
-; CHECK-NEXT: [[LOAD:%.*]] = load i32, i32* [[GEP]], align 4
+; CHECK-NEXT: [[GEP_A:%.*]] = getelementptr inbounds [[PAIR]], ptr [[A]], i32 0, i32 1
+; CHECK-NEXT: [[GEP_B:%.*]] = getelementptr inbounds [[PAIR]], ptr [[B]], i32 0, i32 1
+; CHECK-NEXT: store i32 1, ptr [[GEP_A]], align 4
+; CHECK-NEXT: store i32 2, ptr [[GEP_B]], align 4
+; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND:%.*]], ptr [[A]], ptr [[B]]
+; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds [[PAIR]], ptr [[SELECT]], i32 [[IDX:%.*]], i32 1
+; CHECK-NEXT: [[LOAD:%.*]] = load i32, ptr [[GEP]], align 4
; CHECK-NEXT: ret i32 [[LOAD]]
;
bb:
%a = alloca %pair, align 4
%b = alloca %pair, align 4
- %gep_a = getelementptr inbounds %pair, %pair* %a, i32 0, i32 1
- %gep_b = getelementptr inbounds %pair, %pair* %b, i32 0, i32 1
- store i32 1, i32* %gep_a, align 4
- store i32 2, i32* %gep_b, align 4
- %select = select i1 %cond, %pair* %a, %pair* %b
- %gep = getelementptr inbounds %pair, %pair* %select, i32 %idx, i32 1
- %load = load i32, i32* %gep, align 4
+ %gep_a = getelementptr inbounds %pair, ptr %a, i32 0, i32 1
+ %gep_b = getelementptr inbounds %pair, ptr %b, i32 0, i32 1
+ store i32 1, ptr %gep_a, align 4
+ store i32 2, ptr %gep_b, align 4
+ %select = select i1 %cond, ptr %a, ptr %b
+ %gep = getelementptr inbounds %pair, ptr %select, i32 %idx, i32 1
+ %load = load i32, ptr %gep, align 4
ret i32 %load
}
diff --git a/llvm/test/Transforms/SROA/select-load.ll b/llvm/test/Transforms/SROA/select-load.ll
index a670b4740aa3..e6d29b029186 100644
--- a/llvm/test/Transforms/SROA/select-load.ll
+++ b/llvm/test/Transforms/SROA/select-load.ll
@@ -21,48 +21,40 @@ define <2 x i16> @test_load_bitcast_select(i1 %cond1, i1 %cond2) {
entry:
%true = alloca half, align 2
%false = alloca half, align 2
- store half 0xHFFFF, half* %true, align 2
- store half 0xH0000, half* %false, align 2
- %false.cast = bitcast half* %false to %st.half*
- %true.cast = bitcast half* %true to %st.half*
- %sel1 = select i1 %cond1, %st.half* %true.cast, %st.half* %false.cast
- %cast1 = bitcast %st.half* %sel1 to i16*
- %ld1 = load i16, i16* %cast1, align 2
+ store half 0xHFFFF, ptr %true, align 2
+ store half 0xH0000, ptr %false, align 2
+ %sel1 = select i1 %cond1, ptr %true, ptr %false
+ %ld1 = load i16, ptr %sel1, align 2
%v1 = insertelement <2 x i16> poison, i16 %ld1, i32 0
- %sel2 = select i1 %cond2, %st.half* %true.cast, %st.half* %false.cast
- %cast2 = bitcast %st.half* %sel2 to i16*
- %ld2 = load i16, i16* %cast2, align 2
+ %sel2 = select i1 %cond2, ptr %true, ptr %false
+ %ld2 = load i16, ptr %sel2, align 2
%v2 = insertelement <2 x i16> %v1, i16 %ld2, i32 1
ret <2 x i16> %v2
}
-%st.args = type { i32, i32* }
+%st.args = type { i32, ptr }
; A bitcasted load and a direct load of select.
define void @test_multiple_loads_select(i1 %cmp){
; CHECK-LABEL: @test_multiple_loads_select(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[TMP0:%.*]] = bitcast i32* undef to i8*
-; CHECK-NEXT: [[TMP1:%.*]] = bitcast i32* undef to i8*
-; CHECK-NEXT: [[ADDR_I8_SROA_SPECULATED:%.*]] = select i1 [[CMP:%.*]], i8* [[TMP0]], i8* [[TMP1]]
-; CHECK-NEXT: call void @foo_i8(i8* [[ADDR_I8_SROA_SPECULATED]])
-; CHECK-NEXT: [[ADDR_I32_SROA_SPECULATED:%.*]] = select i1 [[CMP]], i32* undef, i32* undef
-; CHECK-NEXT: call void @foo_i32(i32* [[ADDR_I32_SROA_SPECULATED]])
+; CHECK-NEXT: [[ADDR_I8_SROA_SPECULATED:%.*]] = select i1 [[CMP:%.*]], ptr undef, ptr undef
+; CHECK-NEXT: call void @foo_i8(ptr [[ADDR_I8_SROA_SPECULATED]])
+; CHECK-NEXT: [[ADDR_I32_SROA_SPECULATED:%.*]] = select i1 [[CMP]], ptr undef, ptr undef
+; CHECK-NEXT: call void @foo_i32(ptr [[ADDR_I32_SROA_SPECULATED]])
; CHECK-NEXT: ret void
;
entry:
%args = alloca [2 x %st.args], align 16
- %arr0 = getelementptr inbounds [2 x %st.args], [2 x %st.args]* %args, i64 0, i64 0
- %arr1 = getelementptr inbounds [2 x %st.args], [2 x %st.args]* %args, i64 0, i64 1
- %sel = select i1 %cmp, %st.args* %arr1, %st.args* %arr0
- %addr = getelementptr inbounds %st.args, %st.args* %sel, i64 0, i32 1
- %bcast.i8 = bitcast i32** %addr to i8**
- %addr.i8 = load i8*, i8** %bcast.i8, align 8
- call void @foo_i8(i8* %addr.i8)
- %addr.i32 = load i32*, i32** %addr, align 8
- call void @foo_i32 (i32* %addr.i32)
+ %arr1 = getelementptr inbounds [2 x %st.args], ptr %args, i64 0, i64 1
+ %sel = select i1 %cmp, ptr %arr1, ptr %args
+ %addr = getelementptr inbounds %st.args, ptr %sel, i64 0, i32 1
+ %addr.i8 = load ptr, ptr %addr, align 8
+ call void @foo_i8(ptr %addr.i8)
+ %addr.i32 = load ptr, ptr %addr, align 8
+ call void @foo_i32 (ptr %addr.i32)
ret void
}
-declare void @foo_i8(i8*)
-declare void @foo_i32(i32*)
+declare void @foo_i8(ptr)
+declare void @foo_i32(ptr)
diff --git a/llvm/test/Transforms/SROA/slice-order-independence.ll b/llvm/test/Transforms/SROA/slice-order-independence.ll
index 2e06e5dd1f77..6d7074f202df 100644
--- a/llvm/test/Transforms/SROA/slice-order-independence.ll
+++ b/llvm/test/Transforms/SROA/slice-order-independence.ll
@@ -1,37 +1,33 @@
; RUN: opt < %s -passes=sroa -S | FileCheck %s
target datalayout = "e-p:64:64:64-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
-declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i1) nounwind
+declare void @llvm.memcpy.p0.p0.i32(ptr nocapture, ptr nocapture, i32, i1) nounwind
; Check that the chosen type for a split is independent from the order of
; slices even in case of types that are skipped because their width is not a
; byte width multiple
-define void @skipped_inttype_first({ i16*, i32 }*) {
+define void @skipped_inttype_first(ptr) {
; CHECK-LABEL: @skipped_inttype_first
-; CHECK: alloca i8*
- %arg = alloca { i16*, i32 }, align 8
- %2 = bitcast { i16*, i32 }* %0 to i8*
- %3 = bitcast { i16*, i32 }* %arg to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %3, i8* align 8 %2, i32 16, i1 false)
- %b = getelementptr inbounds { i16*, i32 }, { i16*, i32 }* %arg, i64 0, i32 0
- %pb0 = bitcast i16** %b to i63*
- %b0 = load i63, i63* %pb0
- %pb1 = bitcast i16** %b to i8**
- %b1 = load i8*, i8** %pb1
+; CHECK: alloca ptr
+ %arg = alloca { ptr, i32 }, align 8
+ %2 = bitcast ptr %0 to ptr
+ %3 = bitcast ptr %arg to ptr
+ call void @llvm.memcpy.p0.p0.i32(ptr align 8 %3, ptr align 8 %2, i32 16, i1 false)
+ %b = getelementptr inbounds { ptr, i32 }, ptr %arg, i64 0, i32 0
+ %b0 = load i63, ptr %b
+ %b1 = load ptr, ptr %b
ret void
}
-define void @skipped_inttype_last({ i16*, i32 }*) {
+define void @skipped_inttype_last(ptr) {
; CHECK-LABEL: @skipped_inttype_last
-; CHECK: alloca i8*
- %arg = alloca { i16*, i32 }, align 8
- %2 = bitcast { i16*, i32 }* %0 to i8*
- %3 = bitcast { i16*, i32 }* %arg to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %3, i8* align 8 %2, i32 16, i1 false)
- %b = getelementptr inbounds { i16*, i32 }, { i16*, i32 }* %arg, i64 0, i32 0
- %pb1 = bitcast i16** %b to i8**
- %b1 = load i8*, i8** %pb1
- %pb0 = bitcast i16** %b to i63*
- %b0 = load i63, i63* %pb0
+; CHECK: alloca ptr
+ %arg = alloca { ptr, i32 }, align 8
+ %2 = bitcast ptr %0 to ptr
+ %3 = bitcast ptr %arg to ptr
+ call void @llvm.memcpy.p0.p0.i32(ptr align 8 %3, ptr align 8 %2, i32 16, i1 false)
+ %b = getelementptr inbounds { ptr, i32 }, ptr %arg, i64 0, i32 0
+ %b1 = load ptr, ptr %b
+ %b0 = load i63, ptr %b
ret void
}
diff --git a/llvm/test/Transforms/SROA/slice-width.ll b/llvm/test/Transforms/SROA/slice-width.ll
index bcdac4b1b4d4..96ba23f338fc 100644
--- a/llvm/test/Transforms/SROA/slice-width.ll
+++ b/llvm/test/Transforms/SROA/slice-width.ll
@@ -2,38 +2,36 @@
; RUN: opt < %s -passes=sroa -S | FileCheck %s
target datalayout = "e-p:64:64:64-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-f80:128-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
-declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i1) nounwind
-declare void @llvm.memset.p0i8.i32(i8* nocapture, i8, i32, i1) nounwind
-declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i1) nounwind
+declare void @llvm.memcpy.p0.p0.i32(ptr nocapture, ptr nocapture, i32, i1) nounwind
+declare void @llvm.memset.p0.i32(ptr nocapture, i8, i32, i1) nounwind
+declare void @llvm.memset.p0.i64(ptr nocapture, i8, i64, i1) nounwind
; This tests that allocas are not split into slices that are not byte width multiple
define void @no_split_on_non_byte_width(i32) {
; CHECK-LABEL: @no_split_on_non_byte_width(
; CHECK-NEXT: [[ARG_SROA_0:%.*]] = alloca i8, align 8
; CHECK-NEXT: [[ARG_SROA_0_0_EXTRACT_TRUNC:%.*]] = trunc i32 [[TMP0:%.*]] to i8
-; CHECK-NEXT: store i8 [[ARG_SROA_0_0_EXTRACT_TRUNC]], i8* [[ARG_SROA_0]], align 8
+; CHECK-NEXT: store i8 [[ARG_SROA_0_0_EXTRACT_TRUNC]], ptr [[ARG_SROA_0]], align 8
; CHECK-NEXT: [[ARG_SROA_3_0_EXTRACT_SHIFT:%.*]] = lshr i32 [[TMP0]], 8
; CHECK-NEXT: [[ARG_SROA_3_0_EXTRACT_TRUNC:%.*]] = trunc i32 [[ARG_SROA_3_0_EXTRACT_SHIFT]] to i24
; CHECK-NEXT: br label [[LOAD_I32:%.*]]
; CHECK: load_i32:
-; CHECK-NEXT: [[ARG_SROA_0_0_ARG_SROA_0_0_R01:%.*]] = load i8, i8* [[ARG_SROA_0]], align 8
+; CHECK-NEXT: [[ARG_SROA_0_0_ARG_SROA_0_0_R01:%.*]] = load i8, ptr [[ARG_SROA_0]], align 8
; CHECK-NEXT: br label [[LOAD_I1:%.*]]
; CHECK: load_i1:
-; CHECK-NEXT: [[ARG_SROA_0_0_P1_SROA_CAST4:%.*]] = bitcast i8* [[ARG_SROA_0]] to i1*
-; CHECK-NEXT: [[ARG_SROA_0_0_ARG_SROA_0_0_T1:%.*]] = load i1, i1* [[ARG_SROA_0_0_P1_SROA_CAST4]], align 8
+; CHECK-NEXT: [[ARG_SROA_0_0_ARG_SROA_0_0_T1:%.*]] = load i1, ptr [[ARG_SROA_0]], align 8
; CHECK-NEXT: ret void
;
%arg = alloca i32 , align 8
- store i32 %0, i32* %arg
+ store i32 %0, ptr %arg
br label %load_i32
load_i32:
- %r0 = load i32, i32* %arg
+ %r0 = load i32, ptr %arg
br label %load_i1
load_i1:
- %p1 = bitcast i32* %arg to i1*
- %t1 = load i1, i1* %p1
+ %t1 = load i1, ptr %arg
ret void
}
@@ -49,87 +47,81 @@ load_i1:
define void @memcpy_fp80_padding() {
; CHECK-LABEL: @memcpy_fp80_padding(
; CHECK-NEXT: [[X_SROA_0:%.*]] = alloca x86_fp80, align 16
-; CHECK-NEXT: [[X_SROA_0_0_X_I8_SROA_CAST:%.*]] = bitcast x86_fp80* [[X_SROA_0]] to i8*
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 [[X_SROA_0_0_X_I8_SROA_CAST]], i8* align 16 bitcast (%union.Foo* @foo_copy_source to i8*), i32 16, i1 false)
-; CHECK-NEXT: [[X_SROA_1_0_COPYLOAD:%.*]] = load i64, i64* getelementptr inbounds ([[UNION_FOO:%.*]], %union.Foo* @foo_copy_source, i64 0, i32 1), align 16
-; CHECK-NEXT: [[X_SROA_2_0_COPYLOAD:%.*]] = load i64, i64* getelementptr inbounds ([[UNION_FOO]], %union.Foo* @foo_copy_source, i64 0, i32 2), align 8
-; CHECK-NEXT: store i64 [[X_SROA_1_0_COPYLOAD]], i64* @i64_sink, align 4
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 16 [[X_SROA_0]], ptr align 16 @foo_copy_source, i32 16, i1 false)
+; CHECK-NEXT: [[X_SROA_1_0_COPYLOAD:%.*]] = load i64, ptr getelementptr inbounds (i8, ptr @foo_copy_source, i64 16), align 16
+; CHECK-NEXT: [[X_SROA_2_0_COPYLOAD:%.*]] = load i64, ptr getelementptr inbounds (i8, ptr @foo_copy_source, i64 24), align 8
+; CHECK-NEXT: store i64 [[X_SROA_1_0_COPYLOAD]], ptr @i64_sink, align 4
; CHECK-NEXT: ret void
;
%x = alloca %union.Foo
; Copy from a global.
- %x_i8 = bitcast %union.Foo* %x to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %x_i8, i8* align 16 bitcast (%union.Foo* @foo_copy_source to i8*), i32 32, i1 false)
+ call void @llvm.memcpy.p0.p0.i32(ptr align 16 %x, ptr align 16 @foo_copy_source, i32 32, i1 false)
; Access a slice of the alloca to trigger SROA.
- %mid_p = getelementptr %union.Foo, %union.Foo* %x, i32 0, i32 1
- %elt = load i64, i64* %mid_p
- store i64 %elt, i64* @i64_sink
+ %mid_p = getelementptr %union.Foo, ptr %x, i32 0, i32 1
+ %elt = load i64, ptr %mid_p
+ store i64 %elt, ptr @i64_sink
ret void
}
define void @memset_fp80_padding() {
; CHECK-LABEL: @memset_fp80_padding(
; CHECK-NEXT: [[X_SROA_0:%.*]] = alloca x86_fp80, align 16
-; CHECK-NEXT: [[X_SROA_0_0_X_I8_SROA_CAST1:%.*]] = bitcast x86_fp80* [[X_SROA_0]] to i8*
-; CHECK-NEXT: call void @llvm.memset.p0i8.i32(i8* align 16 [[X_SROA_0_0_X_I8_SROA_CAST1]], i8 -1, i32 16, i1 false)
-; CHECK-NEXT: store i64 -1, i64* @i64_sink, align 4
+; CHECK-NEXT: call void @llvm.memset.p0.i32(ptr align 16 [[X_SROA_0]], i8 -1, i32 16, i1 false)
+; CHECK-NEXT: store i64 -1, ptr @i64_sink, align 4
; CHECK-NEXT: ret void
;
%x = alloca %union.Foo
; Set to all ones.
- %x_i8 = bitcast %union.Foo* %x to i8*
- call void @llvm.memset.p0i8.i32(i8* align 16 %x_i8, i8 -1, i32 32, i1 false)
+ call void @llvm.memset.p0.i32(ptr align 16 %x, i8 -1, i32 32, i1 false)
; Access a slice of the alloca to trigger SROA.
- %mid_p = getelementptr %union.Foo, %union.Foo* %x, i32 0, i32 1
- %elt = load i64, i64* %mid_p
- store i64 %elt, i64* @i64_sink
+ %mid_p = getelementptr %union.Foo, ptr %x, i32 0, i32 1
+ %elt = load i64, ptr %mid_p
+ store i64 %elt, ptr @i64_sink
ret void
}
%S.vec3float = type { float, float, float }
%U.vec3float = type { <4 x float> }
-declare i32 @memcpy_vec3float_helper(%S.vec3float*)
+declare i32 @memcpy_vec3float_helper(ptr)
; PR18726: Check that SROA does not rewrite a 12-byte memcpy into a 16-byte
; vector store, hence accidentally putting gibberish onto the stack.
-define i32 @memcpy_vec3float_widening(%S.vec3float* %x) {
+define i32 @memcpy_vec3float_widening(ptr %x) {
; CHECK-LABEL: @memcpy_vec3float_widening(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[TMP1_SROA_0_0_TMP1_SROA_0_0__SROA_CAST_SROA_CAST:%.*]] = bitcast %S.vec3float* [[X:%.*]] to <3 x float>*
-; CHECK-NEXT: [[TMP1_SROA_0_0_COPYLOAD:%.*]] = load <3 x float>, <3 x float>* [[TMP1_SROA_0_0_TMP1_SROA_0_0__SROA_CAST_SROA_CAST]], align 4
+; CHECK-NEXT: [[TMP0:%.*]] = bitcast ptr [[X:%.*]] to ptr
+; CHECK-NEXT: [[TMP1_SROA_0_0_COPYLOAD:%.*]] = load <3 x float>, ptr [[TMP0]], align 4
; CHECK-NEXT: [[TMP1_SROA_0_0_VEC_EXPAND:%.*]] = shufflevector <3 x float> [[TMP1_SROA_0_0_COPYLOAD]], <3 x float> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 undef>
; CHECK-NEXT: [[TMP1_SROA_0_0_VECBLEND:%.*]] = select <4 x i1> <i1 true, i1 true, i1 true, i1 false>, <4 x float> [[TMP1_SROA_0_0_VEC_EXPAND]], <4 x float> undef
; CHECK-NEXT: [[TMP2:%.*]] = alloca [[S_VEC3FLOAT:%.*]], align 4
-; CHECK-NEXT: [[TMP1_SROA_0_0_TMP1_SROA_0_0__SROA_CAST2_SROA_CAST:%.*]] = bitcast %S.vec3float* [[TMP2]] to <3 x float>*
+; CHECK-NEXT: [[TMP1:%.*]] = bitcast ptr [[TMP2]] to ptr
; CHECK-NEXT: [[TMP1_SROA_0_0_VEC_EXTRACT:%.*]] = shufflevector <4 x float> [[TMP1_SROA_0_0_VECBLEND]], <4 x float> poison, <3 x i32> <i32 0, i32 1, i32 2>
-; CHECK-NEXT: store <3 x float> [[TMP1_SROA_0_0_VEC_EXTRACT]], <3 x float>* [[TMP1_SROA_0_0_TMP1_SROA_0_0__SROA_CAST2_SROA_CAST]], align 4
-; CHECK-NEXT: [[RESULT:%.*]] = call i32 @memcpy_vec3float_helper(%S.vec3float* [[TMP2]])
+; CHECK-NEXT: store <3 x float> [[TMP1_SROA_0_0_VEC_EXTRACT]], ptr [[TMP1]], align 4
+; CHECK-NEXT: [[RESULT:%.*]] = call i32 @memcpy_vec3float_helper(ptr [[TMP2]])
; CHECK-NEXT: ret i32 [[RESULT]]
;
entry:
; Create a temporary variable %tmp1 and copy %x[0] into it
%tmp1 = alloca %S.vec3float, align 4
- %0 = bitcast %S.vec3float* %tmp1 to i8*
- %1 = bitcast %S.vec3float* %x to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %0, i8* align 4 %1, i32 12, i1 false)
+ %0 = bitcast ptr %tmp1 to ptr
+ %1 = bitcast ptr %x to ptr
+ call void @llvm.memcpy.p0.p0.i32(ptr align 4 %0, ptr align 4 %1, i32 12, i1 false)
; The following block does nothing; but appears to confuse SROA
- %unused1 = bitcast %S.vec3float* %tmp1 to %U.vec3float*
- %unused2 = getelementptr inbounds %U.vec3float, %U.vec3float* %unused1, i32 0, i32 0
- %unused3 = load <4 x float>, <4 x float>* %unused2, align 1
+ %unused3 = load <4 x float>, ptr %tmp1, align 1
; Create a second temporary and copy %tmp1 into it
%tmp2 = alloca %S.vec3float, align 4
- %2 = bitcast %S.vec3float* %tmp2 to i8*
- %3 = bitcast %S.vec3float* %tmp1 to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %2, i8* align 4 %3, i32 12, i1 false)
+ %2 = bitcast ptr %tmp2 to ptr
+ %3 = bitcast ptr %tmp1 to ptr
+ call void @llvm.memcpy.p0.p0.i32(ptr align 4 %2, ptr align 4 %3, i32 12, i1 false)
- %result = call i32 @memcpy_vec3float_helper(%S.vec3float* %tmp2)
+ %result = call i32 @memcpy_vec3float_helper(ptr %tmp2)
ret i32 %result
}
@@ -138,11 +130,11 @@ entry:
define void @PR50888() {
; CHECK-LABEL: @PR50888(
; CHECK-NEXT: [[ARRAY:%.*]] = alloca i8, align 1
-; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* align 1 [[ARRAY]], i8 0, i64 ptrtoint (void ()* @PR50888 to i64), i1 false)
+; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 1 [[ARRAY]], i8 0, i64 ptrtoint (ptr @PR50888 to i64), i1 false)
; CHECK-NEXT: ret void
;
%array = alloca i8
- call void @llvm.memset.p0i8.i64(i8* align 16 %array, i8 0, i64 ptrtoint (void ()* @PR50888 to i64), i1 false)
+ call void @llvm.memset.p0.i64(ptr align 16 %array, i8 0, i64 ptrtoint (ptr @PR50888 to i64), i1 false)
ret void
}
@@ -151,26 +143,23 @@ define void @PR50888() {
define void @PR50910() {
; CHECK-LABEL: @PR50910(
; CHECK-NEXT: [[T1:%.*]] = alloca i8, i64 1, align 8
-; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* align 8 [[T1]], i8 0, i64 1, i1 false)
+; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 8 [[T1]], i8 0, i64 1, i1 false)
; CHECK-NEXT: ret void
;
%t1 = alloca i8, i64 1, align 8
- call void @llvm.memset.p0i8.i64(i8* align 8 %t1, i8 0, i64 4294967296, i1 false)
+ call void @llvm.memset.p0.i64(ptr align 8 %t1, i8 0, i64 4294967296, i1 false)
ret void
}
define i1 @presplit_overlarge_load() {
; CHECK-LABEL: @presplit_overlarge_load(
; CHECK-NEXT: [[A_SROA_0:%.*]] = alloca i8, align 2
-; CHECK-NEXT: [[A_SROA_0_0_A_SROA_0_0_L11:%.*]] = load i8, i8* [[A_SROA_0]], align 2
-; CHECK-NEXT: [[A_SROA_0_0_A_1_SROA_CAST3:%.*]] = bitcast i8* [[A_SROA_0]] to i1*
-; CHECK-NEXT: [[A_SROA_0_0_A_SROA_0_0_L2:%.*]] = load i1, i1* [[A_SROA_0_0_A_1_SROA_CAST3]], align 2
+; CHECK-NEXT: [[A_SROA_0_0_A_SROA_0_0_L11:%.*]] = load i8, ptr [[A_SROA_0]], align 2
+; CHECK-NEXT: [[A_SROA_0_0_A_SROA_0_0_L2:%.*]] = load i1, ptr [[A_SROA_0]], align 2
; CHECK-NEXT: ret i1 [[A_SROA_0_0_A_SROA_0_0_L2]]
;
%A = alloca i16
- %A.32 = bitcast i16* %A to i32*
- %A.1 = bitcast i16* %A to i1*
- %L1 = load i32, i32* %A.32
- %L2 = load i1, i1* %A.1
+ %L1 = load i32, ptr %A
+ %L2 = load i1, ptr %A
ret i1 %L2
}
diff --git a/llvm/test/Transforms/SROA/std-clamp.ll b/llvm/test/Transforms/SROA/std-clamp.ll
index a904a32191f9..b95030245bf2 100644
--- a/llvm/test/Transforms/SROA/std-clamp.ll
+++ b/llvm/test/Transforms/SROA/std-clamp.ll
@@ -7,10 +7,10 @@ define float @_Z8stdclampfff(float %x, float %lo, float %hi) {
; CHECK-LABEL: @_Z8stdclampfff(
; CHECK-NEXT: bb:
; CHECK-NEXT: [[I4:%.*]] = alloca float, align 4
-; CHECK-NEXT: store float [[HI:%.*]], float* [[I4]], align 4
+; CHECK-NEXT: store float [[HI:%.*]], ptr [[I4]], align 4
; CHECK-NEXT: [[I5:%.*]] = fcmp fast olt float [[X:%.*]], [[LO:%.*]]
; CHECK-NEXT: [[I6:%.*]] = fcmp fast olt float [[HI]], [[X]]
-; CHECK-NEXT: [[I9_SROA_SPECULATE_LOAD_FALSE_SROA_SPECULATE_LOAD_TRUE:%.*]] = load float, float* [[I4]], align 4
+; CHECK-NEXT: [[I9_SROA_SPECULATE_LOAD_FALSE_SROA_SPECULATE_LOAD_TRUE:%.*]] = load float, ptr [[I4]], align 4
; CHECK-NEXT: [[I9_SROA_SPECULATE_LOAD_FALSE_SROA_SPECULATED:%.*]] = select i1 [[I6]], float [[I9_SROA_SPECULATE_LOAD_FALSE_SROA_SPECULATE_LOAD_TRUE]], float [[X]]
; CHECK-NEXT: [[I9_SROA_SPECULATED:%.*]] = select i1 [[I5]], float [[LO]], float [[I9_SROA_SPECULATE_LOAD_FALSE_SROA_SPECULATED]]
; CHECK-NEXT: ret float [[I9_SROA_SPECULATED]]
@@ -19,13 +19,13 @@ bb:
%i = alloca float, align 4
%i3 = alloca float, align 4
%i4 = alloca float, align 4
- store float %x, float* %i, align 4
- store float %lo, float* %i3, align 4
- store float %hi, float* %i4, align 4
+ store float %x, ptr %i, align 4
+ store float %lo, ptr %i3, align 4
+ store float %hi, ptr %i4, align 4
%i5 = fcmp fast olt float %x, %lo
%i6 = fcmp fast olt float %hi, %x
- %i7 = select i1 %i6, float* %i4, float* %i
- %i8 = select i1 %i5, float* %i3, float* %i7
- %i9 = load float, float* %i8, align 4
+ %i7 = select i1 %i6, ptr %i4, ptr %i
+ %i8 = select i1 %i5, ptr %i3, ptr %i7
+ %i9 = load float, ptr %i8, align 4
ret float %i9
}
diff --git a/llvm/test/Transforms/SROA/tbaa-struct.ll b/llvm/test/Transforms/SROA/tbaa-struct.ll
index 67cc62931089..3e9332c5b11c 100644
--- a/llvm/test/Transforms/SROA/tbaa-struct.ll
+++ b/llvm/test/Transforms/SROA/tbaa-struct.ll
@@ -4,23 +4,19 @@
; SROA should keep `!tbaa.struct` metadata
%vector = type { float, float }
-declare void @llvm.memcpy.p0i8.p0i8.i64(i8* writeonly, i8* readonly, i64, i1 immarg)
-declare <2 x float> @foo(%vector* %0)
+declare void @llvm.memcpy.p0.p0.i64(ptr writeonly, ptr readonly, i64, i1 immarg)
+declare <2 x float> @foo(ptr %0)
-define void @bar(%vector* %y2) {
+define void @bar(ptr %y2) {
; CHECK-LABEL: @bar(
-; CHECK-NEXT: [[X14:%.*]] = call <2 x float> @foo(%vector* [[Y2:%.*]])
-; CHECK-NEXT: [[X7_SROA_0_0_X18_SROA_CAST:%.*]] = bitcast %vector* [[Y2]] to <2 x float>*
-; CHECK-NEXT: store <2 x float> [[X14]], <2 x float>* [[X7_SROA_0_0_X18_SROA_CAST]], align 4, !tbaa.struct !0
+; CHECK-NEXT: [[X14:%.*]] = call <2 x float> @foo(ptr [[Y2:%.*]])
+; CHECK-NEXT: store <2 x float> [[X14]], ptr [[Y2]], align 4, !tbaa.struct !0
; CHECK-NEXT: ret void
;
%x7 = alloca %vector
- %x14 = call <2 x float> @foo(%vector* %y2)
- %x15 = bitcast %vector* %x7 to <2 x float>*
- store <2 x float> %x14, <2 x float>* %x15
- %x19 = bitcast %vector* %x7 to i8*
- %x18 = bitcast %vector* %y2 to i8*
- call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %x18, i8* align 4 %x19, i64 8, i1 false), !tbaa.struct !10
+ %x14 = call <2 x float> @foo(ptr %y2)
+ store <2 x float> %x14, ptr %x7
+ call void @llvm.memcpy.p0.p0.i64(ptr align 4 %y2, ptr align 4 %x7, i64 8, i1 false), !tbaa.struct !10
ret void
}
diff --git a/llvm/test/Transforms/SROA/tbaa-struct2.ll b/llvm/test/Transforms/SROA/tbaa-struct2.ll
index b2843f0383b1..708e4c9e9e1d 100644
--- a/llvm/test/Transforms/SROA/tbaa-struct2.ll
+++ b/llvm/test/Transforms/SROA/tbaa-struct2.ll
@@ -3,18 +3,15 @@
; SROA should correctly offset `!tbaa.struct` metadata
%struct.Wishart = type { double, i32 }
-declare void @llvm.memcpy.p0i8.p0i8.i64(i8* writeonly, i8* readonly, i64, i1 immarg)
+declare void @llvm.memcpy.p0.p0.i64(ptr writeonly, ptr readonly, i64, i1 immarg)
declare double @subcall(double %g, i32 %m)
-define double @bar(%struct.Wishart* %wishart) {
+define double @bar(ptr %wishart) {
%tmp = alloca %struct.Wishart, align 8
- %tmpaddr = bitcast %struct.Wishart* %tmp to i8*
- %waddr = bitcast %struct.Wishart* %wishart to i8*
- call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %tmpaddr, i8* align 8 %waddr, i64 16, i1 false), !tbaa.struct !2
- %gamma = getelementptr inbounds %struct.Wishart, %struct.Wishart* %tmp, i32 0, i32 0
- %lg = load double, double* %gamma, align 8, !tbaa !4
- %m = getelementptr inbounds %struct.Wishart, %struct.Wishart* %tmp, i32 0, i32 1
- %lm = load i32, i32* %m, align 8, !tbaa !8
+ call void @llvm.memcpy.p0.p0.i64(ptr align 8 %tmp, ptr align 8 %wishart, i64 16, i1 false), !tbaa.struct !2
+ %lg = load double, ptr %tmp, align 8, !tbaa !4
+ %m = getelementptr inbounds %struct.Wishart, ptr %tmp, i32 0, i32 1
+ %lm = load i32, ptr %m, align 8, !tbaa !8
%call = call double @subcall(double %lg, i32 %lm)
ret double %call
}
@@ -27,16 +24,13 @@ define double @bar(%struct.Wishart* %wishart) {
!7 = !{!8, !8, i64 0}
!8 = !{!"int", !5, i64 0}
-; CHECK: define double @bar(%struct.Wishart* %wishart) {
+; CHECK: define double @bar(ptr %wishart) {
; CHECK-NEXT: %tmp.sroa.3 = alloca [4 x i8], align 4
-; CHECK-NEXT: %tmp.sroa.0.0.waddr.sroa_idx = getelementptr inbounds %struct.Wishart, %struct.Wishart* %wishart, i64 0, i32 0
-; CHECK-NEXT: %tmp.sroa.0.0.copyload = load double, double* %tmp.sroa.0.0.waddr.sroa_idx, align 8, !tbaa.struct !0
-; CHECK-NEXT: %tmp.sroa.2.0.waddr.sroa_idx1 = getelementptr inbounds %struct.Wishart, %struct.Wishart* %wishart, i64 0, i32 1
-; CHECK-NEXT: %tmp.sroa.2.0.copyload = load i32, i32* %tmp.sroa.2.0.waddr.sroa_idx1, align 8, !tbaa.struct !7
-; CHECK-NEXT: %tmp.sroa.3.0.waddr.sroa_raw_cast = bitcast %struct.Wishart* %wishart to i8*
-; CHECK-NEXT: %tmp.sroa.3.0.waddr.sroa_raw_idx = getelementptr inbounds i8, i8* %tmp.sroa.3.0.waddr.sroa_raw_cast, i64 12
-; CHECK-NEXT: %[[sroa_idx:.+]] = getelementptr inbounds [4 x i8], [4 x i8]* %tmp.sroa.3, i64 0, i64 0
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %[[sroa_idx]], i8* align 4 %tmp.sroa.3.0.waddr.sroa_raw_idx, i64 4, i1 false), !tbaa.struct !8
+; CHECK-NEXT: %tmp.sroa.0.0.copyload = load double, ptr %wishart, align 8, !tbaa.struct !0
+; CHECK-NEXT: %tmp.sroa.2.0.wishart.sroa_idx = getelementptr inbounds i8, ptr %wishart, i64 8
+; CHECK-NEXT: %tmp.sroa.2.0.copyload = load i32, ptr %tmp.sroa.2.0.wishart.sroa_idx, align 8, !tbaa.struct !7
+; CHECK-NEXT: %tmp.sroa.3.0.wishart.sroa_idx = getelementptr inbounds i8, ptr %wishart, i64 12
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 4 %tmp.sroa.3, ptr align 4 %tmp.sroa.3.0.wishart.sroa_idx, i64 4, i1 false), !tbaa.struct !8
; CHECK-NEXT: %call = call double @subcall(double %tmp.sroa.0.0.copyload, i32 %tmp.sroa.2.0.copyload)
; CHECK-NEXT: ret double %call
; CHECK-NEXT: }
diff --git a/llvm/test/Transforms/SROA/tbaa-subload.ll b/llvm/test/Transforms/SROA/tbaa-subload.ll
index 9c415026082a..c43b78f99390 100644
--- a/llvm/test/Transforms/SROA/tbaa-subload.ll
+++ b/llvm/test/Transforms/SROA/tbaa-subload.ll
@@ -10,23 +10,23 @@ define void @caller() {
; CHECK-LABEL: @caller(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[AGG:%.*]] = alloca [[CLASS_ANON:%.*]], align 8
-; CHECK-NEXT: [[OFF:%.*]] = getelementptr inbounds [[CLASS_ANON]], %class.anon* [[AGG]], i32 0, i32 2
-; CHECK-NEXT: [[DOTFCA_0_GEP:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[OFF]], i32 0, i32 0
-; CHECK-NEXT: store i64 1, i64* [[DOTFCA_0_GEP]], align 8, !tbaa [[TBAA0:![0-9]+]]
-; CHECK-NEXT: [[DOTFCA_1_GEP:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[OFF]], i32 0, i32 1
-; CHECK-NEXT: store i64 2, i64* [[DOTFCA_1_GEP]], align 8, !tbaa [[TBAA0]]
-; CHECK-NEXT: call void @use(%class.anon* [[AGG]])
+; CHECK-NEXT: [[OFF:%.*]] = getelementptr inbounds [[CLASS_ANON]], ptr [[AGG]], i32 0, i32 2
+; CHECK-NEXT: [[DOTFCA_0_GEP:%.*]] = getelementptr inbounds { i64, i64 }, ptr [[OFF]], i32 0, i32 0
+; CHECK-NEXT: store i64 1, ptr [[DOTFCA_0_GEP]], align 8, !tbaa [[TBAA0:![0-9]+]]
+; CHECK-NEXT: [[DOTFCA_1_GEP:%.*]] = getelementptr inbounds { i64, i64 }, ptr [[OFF]], i32 0, i32 1
+; CHECK-NEXT: store i64 2, ptr [[DOTFCA_1_GEP]], align 8, !tbaa [[TBAA0]]
+; CHECK-NEXT: call void @use(ptr [[AGG]])
; CHECK-NEXT: ret void
;
entry:
%agg = alloca %class.anon, align 8
- %off = getelementptr inbounds %class.anon, %class.anon* %agg, i32 0, i32 2
- store { i64, i64 } { i64 1, i64 2 }, { i64, i64 }* %off, align 8, !tbaa !7
- call void @use(%class.anon* %agg)
+ %off = getelementptr inbounds %class.anon, ptr %agg, i32 0, i32 2
+ store { i64, i64 } { i64 1, i64 2 }, ptr %off, align 8, !tbaa !7
+ call void @use(ptr %agg)
ret void
}
-declare void @use(%class.anon* %this)
+declare void @use(ptr %this)
!3 = !{!"omnipotent char", !4, i64 0}
!4 = !{!"Simple C++ TBAA"}
diff --git a/llvm/test/Transforms/SROA/vector-conversion.ll b/llvm/test/Transforms/SROA/vector-conversion.ll
index ae3e4dc52030..386a196319f8 100644
--- a/llvm/test/Transforms/SROA/vector-conversion.ll
+++ b/llvm/test/Transforms/SROA/vector-conversion.ll
@@ -1,48 +1,45 @@
; RUN: opt < %s -passes=sroa -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
-define <4 x i64> @vector_ptrtoint({<2 x i32*>, <2 x i32*>} %x) {
+define <4 x i64> @vector_ptrtoint({<2 x ptr>, <2 x ptr>} %x) {
; CHECK-LABEL: @vector_ptrtoint
- %a = alloca {<2 x i32*>, <2 x i32*>}
+ %a = alloca {<2 x ptr>, <2 x ptr>}
; CHECK-NOT: alloca
- store {<2 x i32*>, <2 x i32*>} %x, {<2 x i32*>, <2 x i32*>}* %a
+ store {<2 x ptr>, <2 x ptr>} %x, ptr %a
; CHECK-NOT: store
- %cast = bitcast {<2 x i32*>, <2 x i32*>}* %a to <4 x i64>*
- %vec = load <4 x i64>, <4 x i64>* %cast
+ %vec = load <4 x i64>, ptr %a
; CHECK-NOT: load
; CHECK: ptrtoint
ret <4 x i64> %vec
}
-define <4 x i32*> @vector_inttoptr({<2 x i64>, <2 x i64>} %x) {
+define <4 x ptr> @vector_inttoptr({<2 x i64>, <2 x i64>} %x) {
; CHECK-LABEL: @vector_inttoptr
%a = alloca {<2 x i64>, <2 x i64>}
; CHECK-NOT: alloca
- store {<2 x i64>, <2 x i64>} %x, {<2 x i64>, <2 x i64>}* %a
+ store {<2 x i64>, <2 x i64>} %x, ptr %a
; CHECK-NOT: store
- %cast = bitcast {<2 x i64>, <2 x i64>}* %a to <4 x i32*>*
- %vec = load <4 x i32*>, <4 x i32*>* %cast
+ %vec = load <4 x ptr>, ptr %a
; CHECK-NOT: load
; CHECK: inttoptr
- ret <4 x i32*> %vec
+ ret <4 x ptr> %vec
}
-define <2 x i64> @vector_ptrtointbitcast({<1 x i32*>, <1 x i32*>} %x) {
+define <2 x i64> @vector_ptrtointbitcast({<1 x ptr>, <1 x ptr>} %x) {
; CHECK-LABEL: @vector_ptrtointbitcast(
- %a = alloca {<1 x i32*>, <1 x i32*>}
+ %a = alloca {<1 x ptr>, <1 x ptr>}
; CHECK-NOT: alloca
- store {<1 x i32*>, <1 x i32*>} %x, {<1 x i32*>, <1 x i32*>}* %a
+ store {<1 x ptr>, <1 x ptr>} %x, ptr %a
; CHECK-NOT: store
- %cast = bitcast {<1 x i32*>, <1 x i32*>}* %a to <2 x i64>*
- %vec = load <2 x i64>, <2 x i64>* %cast
+ %vec = load <2 x i64>, ptr %a
; CHECK-NOT: load
; CHECK: ptrtoint
; CHECK: bitcast
@@ -52,35 +49,33 @@ define <2 x i64> @vector_ptrtointbitcast({<1 x i32*>, <1 x i32*>} %x) {
ret <2 x i64> %vec
}
-define <2 x i8*> @vector_inttoptrbitcast_vector({<16 x i8>, <16 x i8>} %x) {
+define <2 x ptr> @vector_inttoptrbitcast_vector({<16 x i8>, <16 x i8>} %x) {
; CHECK-LABEL: @vector_inttoptrbitcast_vector(
%a = alloca {<16 x i8>, <16 x i8>}
; CHECK-NOT: alloca
- store {<16 x i8>, <16 x i8>} %x, {<16 x i8>, <16 x i8>}* %a
+ store {<16 x i8>, <16 x i8>} %x, ptr %a
; CHECK-NOT: store
- %cast = bitcast {<16 x i8>, <16 x i8>}* %a to <2 x i8*>*
- %vec = load <2 x i8*>, <2 x i8*>* %cast
+ %vec = load <2 x ptr>, ptr %a
; CHECK-NOT: load
; CHECK: extractvalue
; CHECK: extractvalue
; CHECK: bitcast
; CHECK: inttoptr
- ret <2 x i8*> %vec
+ ret <2 x ptr> %vec
}
-define <16 x i8> @vector_ptrtointbitcast_vector({<2 x i8*>, <2 x i8*>} %x) {
+define <16 x i8> @vector_ptrtointbitcast_vector({<2 x ptr>, <2 x ptr>} %x) {
; CHECK-LABEL: @vector_ptrtointbitcast_vector(
- %a = alloca {<2 x i8*>, <2 x i8*>}
+ %a = alloca {<2 x ptr>, <2 x ptr>}
; CHECK-NOT: alloca
- store {<2 x i8*>, <2 x i8*>} %x, {<2 x i8*>, <2 x i8*>}* %a
+ store {<2 x ptr>, <2 x ptr>} %x, ptr %a
; CHECK-NOT: store
- %cast = bitcast {<2 x i8*>, <2 x i8*>}* %a to <16 x i8>*
- %vec = load <16 x i8>, <16 x i8>* %cast
+ %vec = load <16 x i8>, ptr %a
; CHECK-NOT: load
; CHECK: extractvalue
; CHECK: ptrtoint
diff --git a/llvm/test/Transforms/SROA/vector-lifetime-intrinsic.ll b/llvm/test/Transforms/SROA/vector-lifetime-intrinsic.ll
index b948a7740902..13ad8f7380c9 100644
--- a/llvm/test/Transforms/SROA/vector-lifetime-intrinsic.ll
+++ b/llvm/test/Transforms/SROA/vector-lifetime-intrinsic.ll
@@ -3,10 +3,10 @@
target datalayout = "e-p:64:32-i64:32-v32:32-n32-S64"
; Function Attrs: nounwind
-declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #0
+declare void @llvm.lifetime.start.p0(i64, ptr nocapture) #0
; Function Attrs: nounwind
-declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #0
+declare void @llvm.lifetime.end.p0(i64, ptr nocapture) #0
; CHECK: @wombat
; CHECK-NOT: alloca
@@ -14,13 +14,10 @@ declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #0
define void @wombat(<4 x float> %arg1) {
bb:
%tmp = alloca <4 x float>, align 16
- %tmp8 = bitcast <4 x float>* %tmp to i8*
- call void @llvm.lifetime.start.p0i8(i64 16, i8* %tmp8)
- store <4 x float> %arg1, <4 x float>* %tmp, align 16
- %tmp17 = bitcast <4 x float>* %tmp to <3 x float>*
- %tmp18 = load <3 x float>, <3 x float>* %tmp17
- %tmp20 = bitcast <4 x float>* %tmp to i8*
- call void @llvm.lifetime.end.p0i8(i64 16, i8* %tmp20)
+ call void @llvm.lifetime.start.p0(i64 16, ptr %tmp)
+ store <4 x float> %arg1, ptr %tmp, align 16
+ %tmp18 = load <3 x float>, ptr %tmp
+ call void @llvm.lifetime.end.p0(i64 16, ptr %tmp)
call void @wombat3(<3 x float> %tmp18)
ret void
}
diff --git a/llvm/test/Transforms/SROA/vector-promotion-
diff erent-size.ll b/llvm/test/Transforms/SROA/vector-promotion-
diff erent-size.ll
index 9c18a49164e2..d31ed11ac4b8 100644
--- a/llvm/test/Transforms/SROA/vector-promotion-
diff erent-size.ll
+++ b/llvm/test/Transforms/SROA/vector-promotion-
diff erent-size.ll
@@ -5,31 +5,27 @@ target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f3
define <4 x i1> @vector_bitcast() {
; CHECK-LABEL: @vector_bitcast(
; CHECK-NEXT: [[A:%.*]] = alloca <3 x i1>, align 1
-; CHECK-NEXT: store <3 x i1> <i1 true, i1 false, i1 true>, <3 x i1>* [[A]], align 1
-; CHECK-NEXT: [[A_0_CAST_SROA_CAST:%.*]] = bitcast <3 x i1>* [[A]] to <4 x i1>*
-; CHECK-NEXT: [[A_0_VEC:%.*]] = load <4 x i1>, <4 x i1>* [[A_0_CAST_SROA_CAST]], align 1
+; CHECK-NEXT: store <3 x i1> <i1 true, i1 false, i1 true>, ptr [[A]], align 1
+; CHECK-NEXT: [[A_0_VEC:%.*]] = load <4 x i1>, ptr [[A]], align 1
; CHECK-NEXT: ret <4 x i1> [[A_0_VEC]]
;
%a = alloca <3 x i1>
- store <3 x i1> <i1 1,i1 0,i1 1>, <3 x i1>* %a
- %cast = bitcast <3 x i1>* %a to <4 x i1>*
- %vec = load <4 x i1>, <4 x i1>* %cast
+ store <3 x i1> <i1 1,i1 0,i1 1>, ptr %a
+ %vec = load <4 x i1>, ptr %a
ret <4 x i1> %vec
}
define <64 x i16> @vector_bitcast_2(<32 x i16> %v) {
; CHECK-LABEL: @vector_bitcast_2(
; CHECK-NEXT: [[P:%.*]] = alloca <32 x i16>, align 64
-; CHECK-NEXT: store <32 x i16> [[V:%.*]], <32 x i16>* [[P]], align 64
-; CHECK-NEXT: [[P_0_Q_SROA_CAST:%.*]] = bitcast <32 x i16>* [[P]] to <64 x i16>*
-; CHECK-NEXT: [[P_0_LOAD:%.*]] = load <64 x i16>, <64 x i16>* [[P_0_Q_SROA_CAST]], align 64
+; CHECK-NEXT: store <32 x i16> [[V:%.*]], ptr [[P]], align 64
+; CHECK-NEXT: [[P_0_LOAD:%.*]] = load <64 x i16>, ptr [[P]], align 64
; CHECK-NEXT: ret <64 x i16> [[P_0_LOAD]]
;
%p = alloca <32 x i16>
- store <32 x i16> %v, <32 x i16>* %p
- %q = bitcast <32 x i16>* %p to <64 x i16>*
- %load = load <64 x i16>, <64 x i16>* %q
+ store <32 x i16> %v, ptr %p
+ %load = load <64 x i16>, ptr %p
ret <64 x i16> %load
}
diff --git a/llvm/test/Transforms/SROA/vector-promotion.ll b/llvm/test/Transforms/SROA/vector-promotion.ll
index c1e7cd6aa8aa..aed0d50e0fcc 100644
--- a/llvm/test/Transforms/SROA/vector-promotion.ll
+++ b/llvm/test/Transforms/SROA/vector-promotion.ll
@@ -17,17 +17,16 @@ define i32 @test1(<4 x i32> %x, <4 x i32> %y) {
entry:
%a = alloca [2 x <4 x i32>]
- %a.x = getelementptr inbounds [2 x <4 x i32>], [2 x <4 x i32>]* %a, i64 0, i64 0
- store <4 x i32> %x, <4 x i32>* %a.x
- %a.y = getelementptr inbounds [2 x <4 x i32>], [2 x <4 x i32>]* %a, i64 0, i64 1
- store <4 x i32> %y, <4 x i32>* %a.y
-
- %a.tmp1 = getelementptr inbounds [2 x <4 x i32>], [2 x <4 x i32>]* %a, i64 0, i64 0, i64 2
- %tmp1 = load i32, i32* %a.tmp1
- %a.tmp2 = getelementptr inbounds [2 x <4 x i32>], [2 x <4 x i32>]* %a, i64 0, i64 1, i64 3
- %tmp2 = load i32, i32* %a.tmp2
- %a.tmp3 = getelementptr inbounds [2 x <4 x i32>], [2 x <4 x i32>]* %a, i64 0, i64 1, i64 0
- %tmp3 = load i32, i32* %a.tmp3
+ store <4 x i32> %x, ptr %a
+ %a.y = getelementptr inbounds [2 x <4 x i32>], ptr %a, i64 0, i64 1
+ store <4 x i32> %y, ptr %a.y
+
+ %a.tmp1 = getelementptr inbounds [2 x <4 x i32>], ptr %a, i64 0, i64 0, i64 2
+ %tmp1 = load i32, ptr %a.tmp1
+ %a.tmp2 = getelementptr inbounds [2 x <4 x i32>], ptr %a, i64 0, i64 1, i64 3
+ %tmp2 = load i32, ptr %a.tmp2
+ %a.tmp3 = getelementptr inbounds [2 x <4 x i32>], ptr %a, i64 0, i64 1, i64 0
+ %tmp3 = load i32, ptr %a.tmp3
%tmp4 = add i32 %tmp1, %tmp2
%tmp5 = add i32 %tmp3, %tmp4
@@ -48,18 +47,16 @@ define i32 @test2(<4 x i32> %x, <4 x i32> %y) {
entry:
%a = alloca [2 x <4 x i32>]
- %a.x = getelementptr inbounds [2 x <4 x i32>], [2 x <4 x i32>]* %a, i64 0, i64 0
- store <4 x i32> %x, <4 x i32>* %a.x
- %a.y = getelementptr inbounds [2 x <4 x i32>], [2 x <4 x i32>]* %a, i64 0, i64 1
- store <4 x i32> %y, <4 x i32>* %a.y
-
- %a.tmp1 = getelementptr inbounds [2 x <4 x i32>], [2 x <4 x i32>]* %a, i64 0, i64 0, i64 2
- %tmp1 = load i32, i32* %a.tmp1
- %a.tmp2 = getelementptr inbounds [2 x <4 x i32>], [2 x <4 x i32>]* %a, i64 0, i64 1, i64 3
- %tmp2 = load i32, i32* %a.tmp2
- %a.tmp3 = getelementptr inbounds [2 x <4 x i32>], [2 x <4 x i32>]* %a, i64 0, i64 1, i64 0
- %a.tmp3.cast = bitcast i32* %a.tmp3 to <2 x i32>*
- %tmp3.vec = load <2 x i32>, <2 x i32>* %a.tmp3.cast
+ store <4 x i32> %x, ptr %a
+ %a.y = getelementptr inbounds [2 x <4 x i32>], ptr %a, i64 0, i64 1
+ store <4 x i32> %y, ptr %a.y
+
+ %a.tmp1 = getelementptr inbounds [2 x <4 x i32>], ptr %a, i64 0, i64 0, i64 2
+ %tmp1 = load i32, ptr %a.tmp1
+ %a.tmp2 = getelementptr inbounds [2 x <4 x i32>], ptr %a, i64 0, i64 1, i64 3
+ %tmp2 = load i32, ptr %a.tmp2
+ %a.tmp3 = getelementptr inbounds [2 x <4 x i32>], ptr %a, i64 0, i64 1, i64 0
+ %tmp3.vec = load <2 x i32>, ptr %a.tmp3
%tmp3 = extractelement <2 x i32> %tmp3.vec, i32 0
%tmp4 = add i32 %tmp1, %tmp2
@@ -81,34 +78,31 @@ define i32 @test3(<4 x i32> %x, <4 x i32> %y) {
entry:
%a = alloca [2 x <4 x i32>]
- %a.x = getelementptr inbounds [2 x <4 x i32>], [2 x <4 x i32>]* %a, i64 0, i64 0
- store <4 x i32> %x, <4 x i32>* %a.x
- %a.y = getelementptr inbounds [2 x <4 x i32>], [2 x <4 x i32>]* %a, i64 0, i64 1
- store <4 x i32> %y, <4 x i32>* %a.y
+ store <4 x i32> %x, ptr %a
+ %a.y = getelementptr inbounds [2 x <4 x i32>], ptr %a, i64 0, i64 1
+ store <4 x i32> %y, ptr %a.y
- %a.y.cast = bitcast <4 x i32>* %a.y to i8*
- call void @llvm.memset.p0i8.i32(i8* %a.y.cast, i8 0, i32 16, i1 false)
+ call void @llvm.memset.p0.i32(ptr %a.y, i8 0, i32 16, i1 false)
- %a.tmp1 = getelementptr inbounds [2 x <4 x i32>], [2 x <4 x i32>]* %a, i64 0, i64 0, i64 2
- %a.tmp1.cast = bitcast i32* %a.tmp1 to i8*
- call void @llvm.memset.p0i8.i32(i8* %a.tmp1.cast, i8 -1, i32 4, i1 false)
- %tmp1 = load i32, i32* %a.tmp1
- %a.tmp2 = getelementptr inbounds [2 x <4 x i32>], [2 x <4 x i32>]* %a, i64 0, i64 1, i64 3
- %tmp2 = load i32, i32* %a.tmp2
- %a.tmp3 = getelementptr inbounds [2 x <4 x i32>], [2 x <4 x i32>]* %a, i64 0, i64 1, i64 0
- %tmp3 = load i32, i32* %a.tmp3
+ %a.tmp1 = getelementptr inbounds [2 x <4 x i32>], ptr %a, i64 0, i64 0, i64 2
+ call void @llvm.memset.p0.i32(ptr %a.tmp1, i8 -1, i32 4, i1 false)
+ %tmp1 = load i32, ptr %a.tmp1
+ %a.tmp2 = getelementptr inbounds [2 x <4 x i32>], ptr %a, i64 0, i64 1, i64 3
+ %tmp2 = load i32, ptr %a.tmp2
+ %a.tmp3 = getelementptr inbounds [2 x <4 x i32>], ptr %a, i64 0, i64 1, i64 0
+ %tmp3 = load i32, ptr %a.tmp3
%tmp4 = add i32 %tmp1, %tmp2
%tmp5 = add i32 %tmp3, %tmp4
ret i32 %tmp5
}
-define i32 @test4(<4 x i32> %x, <4 x i32> %y, <4 x i32>* %z) {
+define i32 @test4(<4 x i32> %x, <4 x i32> %y, ptr %z) {
; CHECK-LABEL: @test4(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[A_SROA_3_16_COPYLOAD:%.*]] = load <4 x i32>, <4 x i32>* [[Z:%.*]], align 1
-; CHECK-NEXT: [[A_SROA_0_8_Z_TMP1_CAST_SROA_IDX:%.*]] = getelementptr inbounds <4 x i32>, <4 x i32>* [[Z]], i64 0, i64 2
-; CHECK-NEXT: [[A_SROA_0_8_COPYLOAD:%.*]] = load i32, i32* [[A_SROA_0_8_Z_TMP1_CAST_SROA_IDX]], align 1
+; CHECK-NEXT: [[A_SROA_3_16_COPYLOAD:%.*]] = load <4 x i32>, ptr [[Z:%.*]], align 1
+; CHECK-NEXT: [[Z_TMP1:%.*]] = getelementptr inbounds <4 x i32>, ptr [[Z]], i64 0, i64 2
+; CHECK-NEXT: [[A_SROA_0_8_COPYLOAD:%.*]] = load i32, ptr [[Z_TMP1]], align 1
; CHECK-NEXT: [[A_SROA_0_8_VEC_INSERT:%.*]] = insertelement <4 x i32> [[X:%.*]], i32 [[A_SROA_0_8_COPYLOAD]], i32 2
; CHECK-NEXT: [[A_SROA_0_8_VEC_EXTRACT:%.*]] = extractelement <4 x i32> [[A_SROA_0_8_VEC_INSERT]], i32 2
; CHECK-NEXT: [[A_SROA_3_28_VEC_EXTRACT:%.*]] = extractelement <4 x i32> [[A_SROA_3_16_COPYLOAD]], i32 3
@@ -120,40 +114,35 @@ define i32 @test4(<4 x i32> %x, <4 x i32> %y, <4 x i32>* %z) {
entry:
%a = alloca [2 x <4 x i32>]
- %a.x = getelementptr inbounds [2 x <4 x i32>], [2 x <4 x i32>]* %a, i64 0, i64 0
- store <4 x i32> %x, <4 x i32>* %a.x
- %a.y = getelementptr inbounds [2 x <4 x i32>], [2 x <4 x i32>]* %a, i64 0, i64 1
- store <4 x i32> %y, <4 x i32>* %a.y
-
- %a.y.cast = bitcast <4 x i32>* %a.y to i8*
- %z.cast = bitcast <4 x i32>* %z to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %a.y.cast, i8* %z.cast, i32 16, i1 false)
-
- %a.tmp1 = getelementptr inbounds [2 x <4 x i32>], [2 x <4 x i32>]* %a, i64 0, i64 0, i64 2
- %a.tmp1.cast = bitcast i32* %a.tmp1 to i8*
- %z.tmp1 = getelementptr inbounds <4 x i32>, <4 x i32>* %z, i64 0, i64 2
- %z.tmp1.cast = bitcast i32* %z.tmp1 to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %a.tmp1.cast, i8* %z.tmp1.cast, i32 4, i1 false)
- %tmp1 = load i32, i32* %a.tmp1
- %a.tmp2 = getelementptr inbounds [2 x <4 x i32>], [2 x <4 x i32>]* %a, i64 0, i64 1, i64 3
- %tmp2 = load i32, i32* %a.tmp2
- %a.tmp3 = getelementptr inbounds [2 x <4 x i32>], [2 x <4 x i32>]* %a, i64 0, i64 1, i64 0
- %tmp3 = load i32, i32* %a.tmp3
+ store <4 x i32> %x, ptr %a
+ %a.y = getelementptr inbounds [2 x <4 x i32>], ptr %a, i64 0, i64 1
+ store <4 x i32> %y, ptr %a.y
+
+ call void @llvm.memcpy.p0.p0.i32(ptr %a.y, ptr %z, i32 16, i1 false)
+
+ %a.tmp1 = getelementptr inbounds [2 x <4 x i32>], ptr %a, i64 0, i64 0, i64 2
+ %z.tmp1 = getelementptr inbounds <4 x i32>, ptr %z, i64 0, i64 2
+ call void @llvm.memcpy.p0.p0.i32(ptr %a.tmp1, ptr %z.tmp1, i32 4, i1 false)
+ %tmp1 = load i32, ptr %a.tmp1
+ %a.tmp2 = getelementptr inbounds [2 x <4 x i32>], ptr %a, i64 0, i64 1, i64 3
+ %tmp2 = load i32, ptr %a.tmp2
+ %a.tmp3 = getelementptr inbounds [2 x <4 x i32>], ptr %a, i64 0, i64 1, i64 0
+ %tmp3 = load i32, ptr %a.tmp3
%tmp4 = add i32 %tmp1, %tmp2
%tmp5 = add i32 %tmp3, %tmp4
ret i32 %tmp5
}
-declare void @llvm.memcpy.p0i8.p1i8.i32(i8* nocapture, i8 addrspace(1)* nocapture, i32, i1) nounwind
+declare void @llvm.memcpy.p0.p1.i32(ptr nocapture, ptr addrspace(1) nocapture, i32, i1) nounwind
; Same as test4 with a
diff erent sized address space pointer source.
-define i32 @test4_as1(<4 x i32> %x, <4 x i32> %y, <4 x i32> addrspace(1)* %z) {
+define i32 @test4_as1(<4 x i32> %x, <4 x i32> %y, ptr addrspace(1) %z) {
; CHECK-LABEL: @test4_as1(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[A_SROA_3_16_COPYLOAD:%.*]] = load <4 x i32>, <4 x i32> addrspace(1)* [[Z:%.*]], align 1
-; CHECK-NEXT: [[A_SROA_0_8_Z_TMP1_CAST_SROA_IDX:%.*]] = getelementptr inbounds <4 x i32>, <4 x i32> addrspace(1)* [[Z]], i64 0, i64 2
-; CHECK-NEXT: [[A_SROA_0_8_COPYLOAD:%.*]] = load i32, i32 addrspace(1)* [[A_SROA_0_8_Z_TMP1_CAST_SROA_IDX]], align 1
+; CHECK-NEXT: [[A_SROA_3_16_COPYLOAD:%.*]] = load <4 x i32>, ptr addrspace(1) [[Z:%.*]], align 1
+; CHECK-NEXT: [[Z_TMP1:%.*]] = getelementptr inbounds <4 x i32>, ptr addrspace(1) [[Z]], i16 0, i16 2
+; CHECK-NEXT: [[A_SROA_0_8_COPYLOAD:%.*]] = load i32, ptr addrspace(1) [[Z_TMP1]], align 1
; CHECK-NEXT: [[A_SROA_0_8_VEC_INSERT:%.*]] = insertelement <4 x i32> [[X:%.*]], i32 [[A_SROA_0_8_COPYLOAD]], i32 2
; CHECK-NEXT: [[A_SROA_0_8_VEC_EXTRACT:%.*]] = extractelement <4 x i32> [[A_SROA_0_8_VEC_INSERT]], i32 2
; CHECK-NEXT: [[A_SROA_3_28_VEC_EXTRACT:%.*]] = extractelement <4 x i32> [[A_SROA_3_16_COPYLOAD]], i32 3
@@ -165,37 +154,32 @@ define i32 @test4_as1(<4 x i32> %x, <4 x i32> %y, <4 x i32> addrspace(1)* %z) {
entry:
%a = alloca [2 x <4 x i32>]
- %a.x = getelementptr inbounds [2 x <4 x i32>], [2 x <4 x i32>]* %a, i64 0, i64 0
- store <4 x i32> %x, <4 x i32>* %a.x
- %a.y = getelementptr inbounds [2 x <4 x i32>], [2 x <4 x i32>]* %a, i64 0, i64 1
- store <4 x i32> %y, <4 x i32>* %a.y
-
- %a.y.cast = bitcast <4 x i32>* %a.y to i8*
- %z.cast = bitcast <4 x i32> addrspace(1)* %z to i8 addrspace(1)*
- call void @llvm.memcpy.p0i8.p1i8.i32(i8* %a.y.cast, i8 addrspace(1)* %z.cast, i32 16, i1 false)
-
- %a.tmp1 = getelementptr inbounds [2 x <4 x i32>], [2 x <4 x i32>]* %a, i64 0, i64 0, i64 2
- %a.tmp1.cast = bitcast i32* %a.tmp1 to i8*
- %z.tmp1 = getelementptr inbounds <4 x i32>, <4 x i32> addrspace(1)* %z, i16 0, i16 2
- %z.tmp1.cast = bitcast i32 addrspace(1)* %z.tmp1 to i8 addrspace(1)*
- call void @llvm.memcpy.p0i8.p1i8.i32(i8* %a.tmp1.cast, i8 addrspace(1)* %z.tmp1.cast, i32 4, i1 false)
- %tmp1 = load i32, i32* %a.tmp1
- %a.tmp2 = getelementptr inbounds [2 x <4 x i32>], [2 x <4 x i32>]* %a, i64 0, i64 1, i64 3
- %tmp2 = load i32, i32* %a.tmp2
- %a.tmp3 = getelementptr inbounds [2 x <4 x i32>], [2 x <4 x i32>]* %a, i64 0, i64 1, i64 0
- %tmp3 = load i32, i32* %a.tmp3
+ store <4 x i32> %x, ptr %a
+ %a.y = getelementptr inbounds [2 x <4 x i32>], ptr %a, i64 0, i64 1
+ store <4 x i32> %y, ptr %a.y
+
+ call void @llvm.memcpy.p0.p1.i32(ptr %a.y, ptr addrspace(1) %z, i32 16, i1 false)
+
+ %a.tmp1 = getelementptr inbounds [2 x <4 x i32>], ptr %a, i64 0, i64 0, i64 2
+ %z.tmp1 = getelementptr inbounds <4 x i32>, ptr addrspace(1) %z, i16 0, i16 2
+ call void @llvm.memcpy.p0.p1.i32(ptr %a.tmp1, ptr addrspace(1) %z.tmp1, i32 4, i1 false)
+ %tmp1 = load i32, ptr %a.tmp1
+ %a.tmp2 = getelementptr inbounds [2 x <4 x i32>], ptr %a, i64 0, i64 1, i64 3
+ %tmp2 = load i32, ptr %a.tmp2
+ %a.tmp3 = getelementptr inbounds [2 x <4 x i32>], ptr %a, i64 0, i64 1, i64 0
+ %tmp3 = load i32, ptr %a.tmp3
%tmp4 = add i32 %tmp1, %tmp2
%tmp5 = add i32 %tmp3, %tmp4
ret i32 %tmp5
}
-define i32 @test5(<4 x i32> %x, <4 x i32> %y, <4 x i32>* %z) {
+define i32 @test5(<4 x i32> %x, <4 x i32> %y, ptr %z) {
; CHECK-LABEL: @test5(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[A_SROA_0_8_A_SROA_0_8_Z_TMP1_CAST_SROA_CAST_SROA_IDX:%.*]] = getelementptr inbounds <4 x i32>, <4 x i32>* [[Z:%.*]], i64 0, i64 2
-; CHECK-NEXT: [[A_SROA_0_8_VEC_EXTRACT2:%.*]] = extractelement <4 x i32> [[Y:%.*]], i32 2
-; CHECK-NEXT: store i32 [[A_SROA_0_8_VEC_EXTRACT2]], i32* [[A_SROA_0_8_A_SROA_0_8_Z_TMP1_CAST_SROA_CAST_SROA_IDX]], align 1
+; CHECK-NEXT: [[Z_TMP1:%.*]] = getelementptr inbounds <4 x i32>, ptr [[Z:%.*]], i64 0, i64 2
+; CHECK-NEXT: [[A_SROA_0_8_VEC_EXTRACT3:%.*]] = extractelement <4 x i32> [[Y:%.*]], i32 2
+; CHECK-NEXT: store i32 [[A_SROA_0_8_VEC_EXTRACT3]], ptr [[Z_TMP1]], align 1
; CHECK-NEXT: [[A_SROA_0_8_VEC_EXTRACT:%.*]] = extractelement <4 x i32> [[Y]], i32 2
; CHECK-NEXT: [[A_SROA_4_12_VEC_EXTRACT:%.*]] = extractelement <4 x i32> [[Y]], i32 3
; CHECK-NEXT: [[A_SROA_4_0_VEC_EXTRACT:%.*]] = extractelement <4 x i32> [[Y]], i32 0
@@ -208,54 +192,49 @@ define i32 @test5(<4 x i32> %x, <4 x i32> %y, <4 x i32>* %z) {
entry:
%a = alloca [2 x <4 x i32>]
- %a.x = getelementptr inbounds [2 x <4 x i32>], [2 x <4 x i32>]* %a, i64 0, i64 0
- store <4 x i32> %x, <4 x i32>* %a.x
- %a.y = getelementptr inbounds [2 x <4 x i32>], [2 x <4 x i32>]* %a, i64 0, i64 1
- store <4 x i32> %y, <4 x i32>* %a.y
-
- %a.y.cast = bitcast <4 x i32>* %a.y to i8*
- %a.x.cast = bitcast <4 x i32>* %a.x to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %a.x.cast, i8* %a.y.cast, i32 16, i1 false)
-
- %a.tmp1 = getelementptr inbounds [2 x <4 x i32>], [2 x <4 x i32>]* %a, i64 0, i64 0, i64 2
- %a.tmp1.cast = bitcast i32* %a.tmp1 to i8*
- %z.tmp1 = getelementptr inbounds <4 x i32>, <4 x i32>* %z, i64 0, i64 2
- %z.tmp1.cast = bitcast i32* %z.tmp1 to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %z.tmp1.cast, i8* %a.tmp1.cast, i32 4, i1 false)
- %tmp1 = load i32, i32* %a.tmp1
- %a.tmp2 = getelementptr inbounds [2 x <4 x i32>], [2 x <4 x i32>]* %a, i64 0, i64 1, i64 3
- %tmp2 = load i32, i32* %a.tmp2
- %a.tmp3 = getelementptr inbounds [2 x <4 x i32>], [2 x <4 x i32>]* %a, i64 0, i64 1, i64 0
- %tmp3 = load i32, i32* %a.tmp3
+ store <4 x i32> %x, ptr %a
+ %a.y = getelementptr inbounds [2 x <4 x i32>], ptr %a, i64 0, i64 1
+ store <4 x i32> %y, ptr %a.y
+
+ call void @llvm.memcpy.p0.p0.i32(ptr %a, ptr %a.y, i32 16, i1 false)
+
+ %a.tmp1 = getelementptr inbounds [2 x <4 x i32>], ptr %a, i64 0, i64 0, i64 2
+ %z.tmp1 = getelementptr inbounds <4 x i32>, ptr %z, i64 0, i64 2
+ call void @llvm.memcpy.p0.p0.i32(ptr %z.tmp1, ptr %a.tmp1, i32 4, i1 false)
+ %tmp1 = load i32, ptr %a.tmp1
+ %a.tmp2 = getelementptr inbounds [2 x <4 x i32>], ptr %a, i64 0, i64 1, i64 3
+ %tmp2 = load i32, ptr %a.tmp2
+ %a.tmp3 = getelementptr inbounds [2 x <4 x i32>], ptr %a, i64 0, i64 1, i64 0
+ %tmp3 = load i32, ptr %a.tmp3
%tmp4 = add i32 %tmp1, %tmp2
%tmp5 = add i32 %tmp3, %tmp4
ret i32 %tmp5
}
-declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i1) nounwind
-declare void @llvm.memset.p0i8.i32(i8* nocapture, i8, i32, i1) nounwind
+declare void @llvm.memcpy.p0.p0.i32(ptr nocapture, ptr nocapture, i32, i1) nounwind
+declare void @llvm.memset.p0.i32(ptr nocapture, i8, i32, i1) nounwind
define i64 @test6(<4 x i64> %x, <4 x i64> %y, i64 %n) {
; CHECK-LABEL: @test6(
; CHECK-NEXT: [[TMP:%.*]] = alloca { <4 x i64>, <4 x i64> }, align 32
-; CHECK-NEXT: [[P0:%.*]] = getelementptr inbounds { <4 x i64>, <4 x i64> }, { <4 x i64>, <4 x i64> }* [[TMP]], i32 0, i32 0
-; CHECK-NEXT: store <4 x i64> [[X:%.*]], <4 x i64>* [[P0]], align 32
-; CHECK-NEXT: [[P1:%.*]] = getelementptr inbounds { <4 x i64>, <4 x i64> }, { <4 x i64>, <4 x i64> }* [[TMP]], i32 0, i32 1
-; CHECK-NEXT: store <4 x i64> [[Y:%.*]], <4 x i64>* [[P1]], align 32
-; CHECK-NEXT: [[ADDR:%.*]] = getelementptr inbounds { <4 x i64>, <4 x i64> }, { <4 x i64>, <4 x i64> }* [[TMP]], i32 0, i32 0, i64 [[N:%.*]]
-; CHECK-NEXT: [[RES:%.*]] = load i64, i64* [[ADDR]], align 4
+; CHECK-NEXT: [[P0:%.*]] = getelementptr inbounds { <4 x i64>, <4 x i64> }, ptr [[TMP]], i32 0, i32 0
+; CHECK-NEXT: store <4 x i64> [[X:%.*]], ptr [[P0]], align 32
+; CHECK-NEXT: [[P1:%.*]] = getelementptr inbounds { <4 x i64>, <4 x i64> }, ptr [[TMP]], i32 0, i32 1
+; CHECK-NEXT: store <4 x i64> [[Y:%.*]], ptr [[P1]], align 32
+; CHECK-NEXT: [[ADDR:%.*]] = getelementptr inbounds { <4 x i64>, <4 x i64> }, ptr [[TMP]], i32 0, i32 0, i64 [[N:%.*]]
+; CHECK-NEXT: [[RES:%.*]] = load i64, ptr [[ADDR]], align 4
; CHECK-NEXT: ret i64 [[RES]]
;
; The old scalarrepl pass would wrongly drop the store to the second alloca.
; PR13254
%tmp = alloca { <4 x i64>, <4 x i64> }
- %p0 = getelementptr inbounds { <4 x i64>, <4 x i64> }, { <4 x i64>, <4 x i64> }* %tmp, i32 0, i32 0
- store <4 x i64> %x, <4 x i64>* %p0
- %p1 = getelementptr inbounds { <4 x i64>, <4 x i64> }, { <4 x i64>, <4 x i64> }* %tmp, i32 0, i32 1
- store <4 x i64> %y, <4 x i64>* %p1
- %addr = getelementptr inbounds { <4 x i64>, <4 x i64> }, { <4 x i64>, <4 x i64> }* %tmp, i32 0, i32 0, i64 %n
- %res = load i64, i64* %addr, align 4
+ %p0 = getelementptr inbounds { <4 x i64>, <4 x i64> }, ptr %tmp, i32 0, i32 0
+ store <4 x i64> %x, ptr %p0
+ %p1 = getelementptr inbounds { <4 x i64>, <4 x i64> }, ptr %tmp, i32 0, i32 1
+ store <4 x i64> %y, ptr %p1
+ %addr = getelementptr inbounds { <4 x i64>, <4 x i64> }, ptr %tmp, i32 0, i32 0, i64 %n
+ %res = load i64, ptr %addr, align 4
ret i64 %res
}
@@ -271,22 +250,18 @@ define <4 x i32> @test_subvec_store() {
entry:
%a = alloca <4 x i32>
- %a.gep0 = getelementptr <4 x i32>, <4 x i32>* %a, i32 0, i32 0
- %a.cast0 = bitcast i32* %a.gep0 to <2 x i32>*
- store <2 x i32> <i32 0, i32 0>, <2 x i32>* %a.cast0
+ store <2 x i32> <i32 0, i32 0>, ptr %a
- %a.gep1 = getelementptr <4 x i32>, <4 x i32>* %a, i32 0, i32 1
- %a.cast1 = bitcast i32* %a.gep1 to <2 x i32>*
- store <2 x i32> <i32 1, i32 1>, <2 x i32>* %a.cast1
+ %a.gep1 = getelementptr <4 x i32>, ptr %a, i32 0, i32 1
+ store <2 x i32> <i32 1, i32 1>, ptr %a.gep1
- %a.gep2 = getelementptr <4 x i32>, <4 x i32>* %a, i32 0, i32 2
- %a.cast2 = bitcast i32* %a.gep2 to <2 x i32>*
- store <2 x i32> <i32 2, i32 2>, <2 x i32>* %a.cast2
+ %a.gep2 = getelementptr <4 x i32>, ptr %a, i32 0, i32 2
+ store <2 x i32> <i32 2, i32 2>, ptr %a.gep2
- %a.gep3 = getelementptr <4 x i32>, <4 x i32>* %a, i32 0, i32 3
- store i32 3, i32* %a.gep3
+ %a.gep3 = getelementptr <4 x i32>, ptr %a, i32 0, i32 3
+ store i32 3, ptr %a.gep3
- %ret = load <4 x i32>, <4 x i32>* %a
+ %ret = load <4 x i32>, ptr %a
ret <4 x i32> %ret
}
@@ -303,19 +278,15 @@ define <4 x i32> @test_subvec_load() {
;
entry:
%a = alloca <4 x i32>
- store <4 x i32> <i32 0, i32 1, i32 2, i32 3>, <4 x i32>* %a
+ store <4 x i32> <i32 0, i32 1, i32 2, i32 3>, ptr %a
- %a.gep0 = getelementptr <4 x i32>, <4 x i32>* %a, i32 0, i32 0
- %a.cast0 = bitcast i32* %a.gep0 to <2 x i32>*
- %first = load <2 x i32>, <2 x i32>* %a.cast0
+ %first = load <2 x i32>, ptr %a
- %a.gep1 = getelementptr <4 x i32>, <4 x i32>* %a, i32 0, i32 1
- %a.cast1 = bitcast i32* %a.gep1 to <2 x i32>*
- %second = load <2 x i32>, <2 x i32>* %a.cast1
+ %a.gep1 = getelementptr <4 x i32>, ptr %a, i32 0, i32 1
+ %second = load <2 x i32>, ptr %a.gep1
- %a.gep2 = getelementptr <4 x i32>, <4 x i32>* %a, i32 0, i32 2
- %a.cast2 = bitcast i32* %a.gep2 to <2 x i32>*
- %third = load <2 x i32>, <2 x i32>* %a.cast2
+ %a.gep2 = getelementptr <4 x i32>, ptr %a, i32 0, i32 2
+ %third = load <2 x i32>, ptr %a.gep2
%tmp = shufflevector <2 x i32> %first, <2 x i32> %second, <2 x i32> <i32 0, i32 2>
%ret = shufflevector <2 x i32> %tmp, <2 x i32> %third, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
@@ -323,7 +294,6 @@ entry:
ret <4 x i32> %ret
}
-declare void @llvm.memset.p0i32.i32(i32* nocapture, i32, i32, i1) nounwind
define <4 x float> @test_subvec_memset() {
; CHECK-LABEL: @test_subvec_memset(
@@ -337,72 +307,57 @@ define <4 x float> @test_subvec_memset() {
entry:
%a = alloca <4 x float>
- %a.gep0 = getelementptr <4 x float>, <4 x float>* %a, i32 0, i32 0
- %a.cast0 = bitcast float* %a.gep0 to i8*
- call void @llvm.memset.p0i8.i32(i8* %a.cast0, i8 0, i32 8, i1 false)
+ call void @llvm.memset.p0.i32(ptr %a, i8 0, i32 8, i1 false)
- %a.gep1 = getelementptr <4 x float>, <4 x float>* %a, i32 0, i32 1
- %a.cast1 = bitcast float* %a.gep1 to i8*
- call void @llvm.memset.p0i8.i32(i8* %a.cast1, i8 1, i32 8, i1 false)
+ %a.gep1 = getelementptr <4 x float>, ptr %a, i32 0, i32 1
+ call void @llvm.memset.p0.i32(ptr %a.gep1, i8 1, i32 8, i1 false)
- %a.gep2 = getelementptr <4 x float>, <4 x float>* %a, i32 0, i32 2
- %a.cast2 = bitcast float* %a.gep2 to i8*
- call void @llvm.memset.p0i8.i32(i8* %a.cast2, i8 3, i32 8, i1 false)
+ %a.gep2 = getelementptr <4 x float>, ptr %a, i32 0, i32 2
+ call void @llvm.memset.p0.i32(ptr %a.gep2, i8 3, i32 8, i1 false)
- %a.gep3 = getelementptr <4 x float>, <4 x float>* %a, i32 0, i32 3
- %a.cast3 = bitcast float* %a.gep3 to i8*
- call void @llvm.memset.p0i8.i32(i8* %a.cast3, i8 7, i32 4, i1 false)
+ %a.gep3 = getelementptr <4 x float>, ptr %a, i32 0, i32 3
+ call void @llvm.memset.p0.i32(ptr %a.gep3, i8 7, i32 4, i1 false)
- %ret = load <4 x float>, <4 x float>* %a
+ %ret = load <4 x float>, ptr %a
ret <4 x float> %ret
}
-define <4 x float> @test_subvec_memcpy(i8* %x, i8* %y, i8* %z, i8* %f, i8* %out) {
+define <4 x float> @test_subvec_memcpy(ptr %x, ptr %y, ptr %z, ptr %f, ptr %out) {
; CHECK-LABEL: @test_subvec_memcpy(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[A_0_X_SROA_CAST:%.*]] = bitcast i8* [[X:%.*]] to <2 x float>*
-; CHECK-NEXT: [[A_0_COPYLOAD:%.*]] = load <2 x float>, <2 x float>* [[A_0_X_SROA_CAST]], align 1
+; CHECK-NEXT: [[A_0_COPYLOAD:%.*]] = load <2 x float>, ptr [[X:%.*]], align 1
; CHECK-NEXT: [[A_0_VEC_EXPAND:%.*]] = shufflevector <2 x float> [[A_0_COPYLOAD]], <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
; CHECK-NEXT: [[A_0_VECBLEND:%.*]] = select <4 x i1> <i1 true, i1 true, i1 false, i1 false>, <4 x float> [[A_0_VEC_EXPAND]], <4 x float> undef
-; CHECK-NEXT: [[A_4_Y_SROA_CAST:%.*]] = bitcast i8* [[Y:%.*]] to <2 x float>*
-; CHECK-NEXT: [[A_4_COPYLOAD:%.*]] = load <2 x float>, <2 x float>* [[A_4_Y_SROA_CAST]], align 1
+; CHECK-NEXT: [[A_4_COPYLOAD:%.*]] = load <2 x float>, ptr [[Y:%.*]], align 1
; CHECK-NEXT: [[A_4_VEC_EXPAND:%.*]] = shufflevector <2 x float> [[A_4_COPYLOAD]], <2 x float> poison, <4 x i32> <i32 undef, i32 0, i32 1, i32 undef>
; CHECK-NEXT: [[A_4_VECBLEND:%.*]] = select <4 x i1> <i1 false, i1 true, i1 true, i1 false>, <4 x float> [[A_4_VEC_EXPAND]], <4 x float> [[A_0_VECBLEND]]
-; CHECK-NEXT: [[A_8_Z_SROA_CAST:%.*]] = bitcast i8* [[Z:%.*]] to <2 x float>*
-; CHECK-NEXT: [[A_8_COPYLOAD:%.*]] = load <2 x float>, <2 x float>* [[A_8_Z_SROA_CAST]], align 1
+; CHECK-NEXT: [[A_8_COPYLOAD:%.*]] = load <2 x float>, ptr [[Z:%.*]], align 1
; CHECK-NEXT: [[A_8_VEC_EXPAND:%.*]] = shufflevector <2 x float> [[A_8_COPYLOAD]], <2 x float> poison, <4 x i32> <i32 undef, i32 undef, i32 0, i32 1>
; CHECK-NEXT: [[A_8_VECBLEND:%.*]] = select <4 x i1> <i1 false, i1 false, i1 true, i1 true>, <4 x float> [[A_8_VEC_EXPAND]], <4 x float> [[A_4_VECBLEND]]
-; CHECK-NEXT: [[A_12_F_SROA_CAST:%.*]] = bitcast i8* [[F:%.*]] to float*
-; CHECK-NEXT: [[A_12_COPYLOAD:%.*]] = load float, float* [[A_12_F_SROA_CAST]], align 1
+; CHECK-NEXT: [[A_12_COPYLOAD:%.*]] = load float, ptr [[F:%.*]], align 1
; CHECK-NEXT: [[A_12_VEC_INSERT:%.*]] = insertelement <4 x float> [[A_8_VECBLEND]], float [[A_12_COPYLOAD]], i32 3
-; CHECK-NEXT: [[A_8_OUT_SROA_CAST:%.*]] = bitcast i8* [[OUT:%.*]] to <2 x float>*
; CHECK-NEXT: [[A_8_VEC_EXTRACT:%.*]] = shufflevector <4 x float> [[A_12_VEC_INSERT]], <4 x float> poison, <2 x i32> <i32 2, i32 3>
-; CHECK-NEXT: store <2 x float> [[A_8_VEC_EXTRACT]], <2 x float>* [[A_8_OUT_SROA_CAST]], align 1
+; CHECK-NEXT: store <2 x float> [[A_8_VEC_EXTRACT]], ptr [[OUT:%.*]], align 1
; CHECK-NEXT: ret <4 x float> [[A_12_VEC_INSERT]]
;
entry:
%a = alloca <4 x float>
- %a.gep0 = getelementptr <4 x float>, <4 x float>* %a, i32 0, i32 0
- %a.cast0 = bitcast float* %a.gep0 to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %a.cast0, i8* %x, i32 8, i1 false)
+ call void @llvm.memcpy.p0.p0.i32(ptr %a, ptr %x, i32 8, i1 false)
- %a.gep1 = getelementptr <4 x float>, <4 x float>* %a, i32 0, i32 1
- %a.cast1 = bitcast float* %a.gep1 to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %a.cast1, i8* %y, i32 8, i1 false)
+ %a.gep1 = getelementptr <4 x float>, ptr %a, i32 0, i32 1
+ call void @llvm.memcpy.p0.p0.i32(ptr %a.gep1, ptr %y, i32 8, i1 false)
- %a.gep2 = getelementptr <4 x float>, <4 x float>* %a, i32 0, i32 2
- %a.cast2 = bitcast float* %a.gep2 to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %a.cast2, i8* %z, i32 8, i1 false)
+ %a.gep2 = getelementptr <4 x float>, ptr %a, i32 0, i32 2
+ call void @llvm.memcpy.p0.p0.i32(ptr %a.gep2, ptr %z, i32 8, i1 false)
- %a.gep3 = getelementptr <4 x float>, <4 x float>* %a, i32 0, i32 3
- %a.cast3 = bitcast float* %a.gep3 to i8*
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %a.cast3, i8* %f, i32 4, i1 false)
+ %a.gep3 = getelementptr <4 x float>, ptr %a, i32 0, i32 3
+ call void @llvm.memcpy.p0.p0.i32(ptr %a.gep3, ptr %f, i32 4, i1 false)
- call void @llvm.memcpy.p0i8.p0i8.i32(i8* %out, i8* %a.cast2, i32 8, i1 false)
+ call void @llvm.memcpy.p0.p0.i32(ptr %out, ptr %a.gep2, i32 8, i1 false)
- %ret = load <4 x float>, <4 x float>* %a
+ %ret = load <4 x float>, ptr %a
ret <4 x float> %ret
}
@@ -425,9 +380,8 @@ define i32 @PR14212(<3 x i8> %val) {
entry:
%retval = alloca <3 x i8>, align 4
- store <3 x i8> %val, <3 x i8>* %retval, align 4
- %cast = bitcast <3 x i8>* %retval to i32*
- %load = load i32, i32* %cast, align 4
+ store <3 x i8> %val, ptr %retval, align 4
+ %load = load i32, ptr %retval, align 4
ret i32 %load
}
@@ -446,10 +400,9 @@ define <2 x i8> @PR14349.1(i32 %x) {
entry:
%a = alloca i32
- store i32 %x, i32* %a
+ store i32 %x, ptr %a
- %cast = bitcast i32* %a to <2 x i8>*
- %vec = load <2 x i8>, <2 x i8>* %cast
+ %vec = load <2 x i8>, ptr %a
ret <2 x i8> %vec
}
@@ -473,10 +426,9 @@ define i32 @PR14349.2(<2 x i8> %x) {
entry:
%a = alloca i32
- %cast = bitcast i32* %a to <2 x i8>*
- store <2 x i8> %x, <2 x i8>* %cast
+ store <2 x i8> %x, ptr %a
- %int = load i32, i32* %a
+ %int = load i32, ptr %a
ret i32 %int
}
@@ -494,19 +446,17 @@ define i32 @test7(<2 x i32> %x, <2 x i32> %y) {
;
entry:
%a = alloca [2 x i64]
- %a.cast = bitcast [2 x i64]* %a to [2 x <2 x i32>]*
- %a.x = getelementptr inbounds [2 x <2 x i32>], [2 x <2 x i32>]* %a.cast, i64 0, i64 0
- store <2 x i32> %x, <2 x i32>* %a.x
- %a.y = getelementptr inbounds [2 x <2 x i32>], [2 x <2 x i32>]* %a.cast, i64 0, i64 1
- store <2 x i32> %y, <2 x i32>* %a.y
+ store <2 x i32> %x, ptr %a
+ %a.y = getelementptr inbounds [2 x <2 x i32>], ptr %a, i64 0, i64 1
+ store <2 x i32> %y, ptr %a.y
- %a.tmp1 = getelementptr inbounds [2 x <2 x i32>], [2 x <2 x i32>]* %a.cast, i64 0, i64 0, i64 1
- %tmp1 = load i32, i32* %a.tmp1
- %a.tmp2 = getelementptr inbounds [2 x <2 x i32>], [2 x <2 x i32>]* %a.cast, i64 0, i64 1, i64 1
- %tmp2 = load i32, i32* %a.tmp2
- %a.tmp3 = getelementptr inbounds [2 x <2 x i32>], [2 x <2 x i32>]* %a.cast, i64 0, i64 1, i64 0
- %tmp3 = load i32, i32* %a.tmp3
+ %a.tmp1 = getelementptr inbounds [2 x <2 x i32>], ptr %a, i64 0, i64 0, i64 1
+ %tmp1 = load i32, ptr %a.tmp1
+ %a.tmp2 = getelementptr inbounds [2 x <2 x i32>], ptr %a, i64 0, i64 1, i64 1
+ %tmp2 = load i32, ptr %a.tmp2
+ %a.tmp3 = getelementptr inbounds [2 x <2 x i32>], ptr %a, i64 0, i64 1, i64 0
+ %tmp3 = load i32, ptr %a.tmp3
%tmp4 = add i32 %tmp1, %tmp2
%tmp5 = add i32 %tmp3, %tmp4
@@ -525,14 +475,12 @@ define i32 @test8(<2 x i32> %x) {
;
entry:
%a = alloca i64
- %a.vec = bitcast i64* %a to <2 x i32>*
- %a.i32 = bitcast i64* %a to i32*
- store <2 x i32> %x, <2 x i32>* %a.vec
+ store <2 x i32> %x, ptr %a
- %tmp1 = load i32, i32* %a.i32
- %a.tmp2 = getelementptr inbounds i32, i32* %a.i32, i64 1
- %tmp2 = load i32, i32* %a.tmp2
+ %tmp1 = load i32, ptr %a
+ %a.tmp2 = getelementptr inbounds i32, ptr %a, i64 1
+ %tmp2 = load i32, ptr %a.tmp2
%tmp4 = add i32 %tmp1, %tmp2
ret i32 %tmp4
@@ -549,14 +497,12 @@ define <2 x i32> @test9(i32 %x, i32 %y) {
;
entry:
%a = alloca i64
- %a.vec = bitcast i64* %a to <2 x i32>*
- %a.i32 = bitcast i64* %a to i32*
- store i32 %x, i32* %a.i32
- %a.tmp2 = getelementptr inbounds i32, i32* %a.i32, i64 1
- store i32 %y, i32* %a.tmp2
+ store i32 %x, ptr %a
+ %a.tmp2 = getelementptr inbounds i32, ptr %a, i64 1
+ store i32 %y, ptr %a.tmp2
- %result = load <2 x i32>, <2 x i32>* %a.vec
+ %result = load <2 x i32>, ptr %a
ret <2 x i32> %result
}
@@ -572,15 +518,12 @@ define <2 x i32> @test10(<4 x i16> %x, i32 %y) {
;
entry:
%a = alloca i64
- %a.vec1 = bitcast i64* %a to <2 x i32>*
- %a.vec2 = bitcast i64* %a to <4 x i16>*
- %a.i32 = bitcast i64* %a to i32*
- store <4 x i16> %x, <4 x i16>* %a.vec2
- %a.tmp2 = getelementptr inbounds i32, i32* %a.i32, i64 1
- store i32 %y, i32* %a.tmp2
+ store <4 x i16> %x, ptr %a
+ %a.tmp2 = getelementptr inbounds i32, ptr %a, i64 1
+ store i32 %y, ptr %a.tmp2
- %result = load <2 x i32>, <2 x i32>* %a.vec1
+ %result = load <2 x i32>, ptr %a
ret <2 x i32> %result
}
@@ -599,15 +542,12 @@ define <2 x float> @test11(<4 x i16> %x, i32 %y) {
;
entry:
%a = alloca i64
- %a.vec1 = bitcast i64* %a to <2 x float>*
- %a.vec2 = bitcast i64* %a to <4 x i16>*
- %a.i32 = bitcast i64* %a to i32*
- store <4 x i16> %x, <4 x i16>* %a.vec2
- %a.tmp2 = getelementptr inbounds i32, i32* %a.i32, i64 1
- store i32 %y, i32* %a.tmp2
+ store <4 x i16> %x, ptr %a
+ %a.tmp2 = getelementptr inbounds i32, ptr %a, i64 1
+ store i32 %y, ptr %a.tmp2
- %result = load <2 x float>, <2 x float>* %a.vec1
+ %result = load <2 x float>, ptr %a
ret <2 x float> %result
}
@@ -619,12 +559,9 @@ define <4 x float> @test12(<4 x i32> %val) {
;
%a = alloca <3 x i32>, align 16
- %cast1 = bitcast <3 x i32>* %a to <4 x i32>*
- store <4 x i32> %val, <4 x i32>* %cast1, align 16
+ store <4 x i32> %val, ptr %a, align 16
- %cast2 = bitcast <3 x i32>* %a to <3 x float>*
- %cast3 = bitcast <3 x float>* %cast2 to <4 x float>*
- %vec = load <4 x float>, <4 x float>* %cast3
+ %vec = load <4 x float>, ptr %a
ret <4 x float> %vec
}
diff --git a/llvm/test/Transforms/SROA/vectors-of-pointers.ll b/llvm/test/Transforms/SROA/vectors-of-pointers.ll
index a746f8bbbc0c..19f832a2189c 100644
--- a/llvm/test/Transforms/SROA/vectors-of-pointers.ll
+++ b/llvm/test/Transforms/SROA/vectors-of-pointers.ll
@@ -7,7 +7,7 @@ target triple = "x86_64-apple-macosx10.8.0"
define void @foo(i1 %c1, i1 %c2) {
entry:
- %Args.i = alloca <2 x i32*>, align 16
+ %Args.i = alloca <2 x ptr>, align 16
br i1 %c1, label %bb0.exit158, label %if.then.i.i.i.i.i138
if.then.i.i.i.i.i138:
@@ -20,6 +20,6 @@ if.then.i.i.i.i.i237:
unreachable
bb0.exit257:
- %0 = load <2 x i32*>, <2 x i32*>* %Args.i, align 16
+ %0 = load <2 x ptr>, ptr %Args.i, align 16
ret void
}
More information about the llvm-commits
mailing list