254 changes: 127 additions & 127 deletions llvm/test/Transforms/LoopVectorize/AArch64/sve-interleaved-accesses.ll
View file

Large diffs are not rendered by default.

4 changes: 2 additions & 2 deletions llvm/test/Transforms/LoopVectorize/consecutive-ptr-uniforms.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -210,7 +210,7 @@ for.end:
; INTER: getelementptr inbounds %pair, ptr %p, i64 %[[I3]], i32 0
; INTER: br i1 {{.*}}, label %middle.block, label %vector.body
;
define void @predicated_store(%pair *%p, i32 %x, i64 %n) {
define void @predicated_store(ptr %p, i32 %x, i64 %n) {
entry:
br label %for.body

Expand Down Expand Up @@ -459,7 +459,7 @@ for.end:
; INTER-NEXT: [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 4
; INTER: br i1 {{.*}}, label %middle.block, label %vector.body
;
define void @pointer_operand_geps_with_different_indexed_types(i64* %A, i8* %B, i64 %n) {
define void @pointer_operand_geps_with_different_indexed_types(ptr %A, ptr %B, i64 %n) {
entry:
br label %for.body

Expand Down
2 changes: 1 addition & 1 deletion llvm/test/Transforms/LoopVectorize/lcssa-crashes.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -104,7 +104,7 @@ while.body:
%pos.337 = phi i32 [ %inc46, %while.body ], [ %add41, %entry ]
%inc46 = add i32 %pos.337, 1
%arrayidx48 = getelementptr inbounds [1024 x i8], ptr undef, i64 0, i64 %idxprom4738
store i8 0, i8* %arrayidx48, align 1
store i8 0, ptr %arrayidx48, align 1
%and43 = and i32 %inc46, 3
%cmp44 = icmp eq i32 %and43, 0
%idxprom47 = zext i32 %inc46 to i64
Expand Down
2 changes: 1 addition & 1 deletion llvm/test/Transforms/LoopVectorize/runtime-checks-difference.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3,7 +3,7 @@

target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"

define void @same_step_and_size(ptr %a, i32* %b, i64 %n) {
define void @same_step_and_size(ptr %a, ptr %b, i64 %n) {
; CHECK-LABEL: @same_step_and_size(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A2:%.*]] = ptrtoint ptr [[A:%.*]] to i64
Expand Down
4 changes: 2 additions & 2 deletions llvm/test/Transforms/MemCpyOpt/vscale-crashes.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -79,7 +79,7 @@ define void @callslotoptzn(<vscale x 4 x float> %val, ptr %out) {
%alloc = alloca <vscale x 4 x float>, align 16
%idx = tail call <vscale x 4 x i32> @llvm.experimental.stepvector.nxv4i32()
%stride = getelementptr inbounds float, ptr %alloc, <vscale x 4 x i32> %idx
call void @llvm.masked.scatter.nxv4f32.nxv4p0f32(<vscale x 4 x float> %val, <vscale x 4 x ptr> %stride, i32 4, <vscale x 4 x i1> shufflevector (<vscale x 4 x i1> insertelement (<vscale x 4 x i1> poison, i1 true, i32 0), <vscale x 4 x i1> poison, <vscale x 4 x i32> zeroinitializer))
call void @llvm.masked.scatter.nxv4f32.nxv4p0(<vscale x 4 x float> %val, <vscale x 4 x ptr> %stride, i32 4, <vscale x 4 x i1> shufflevector (<vscale x 4 x i1> insertelement (<vscale x 4 x i1> poison, i1 true, i32 0), <vscale x 4 x i1> poison, <vscale x 4 x i32> zeroinitializer))
%li = load <vscale x 4 x float>, ptr %alloc, align 4
store <vscale x 4 x float> %li, ptr %out, align 4
ret void
Expand Down Expand Up @@ -124,4 +124,4 @@ define void @memmove_agg2(ptr %a, ptr %b) {
}

declare <vscale x 4 x i32> @llvm.experimental.stepvector.nxv4i32()
declare void @llvm.masked.scatter.nxv4f32.nxv4p0f32(<vscale x 4 x float> , <vscale x 4 x ptr> , i32, <vscale x 4 x i1>)
declare void @llvm.masked.scatter.nxv4f32.nxv4p0(<vscale x 4 x float> , <vscale x 4 x ptr> , i32, <vscale x 4 x i1>)
38 changes: 19 additions & 19 deletions llvm/test/Transforms/MoveAutoInit/clobber.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -45,25 +45,25 @@ define i32 @foo(i32 noundef %0, i32 noundef %1, i32 noundef %2) #0 {

%4 = alloca [100 x i8], align 16
%5 = alloca [2 x i8], align 1
%6 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 0
call void @llvm.lifetime.start.p0i8(i64 100, i8* nonnull %6) #3
%6 = getelementptr inbounds [100 x i8], ptr %4, i64 0, i64 0
call void @llvm.lifetime.start.p0(i64 100, ptr nonnull %6) #3
; This memset must move.
call void @llvm.memset.p0i8.i64(i8* noundef nonnull align 16 dereferenceable(100) %6, i8 -86, i64 100, i1 false), !annotation !0
%7 = getelementptr inbounds [2 x i8], [2 x i8]* %5, i64 0, i64 0
call void @llvm.lifetime.start.p0i8(i64 2, i8* nonnull %7) #3
call void @llvm.memset.p0.i64(ptr noundef nonnull align 16 dereferenceable(100) %6, i8 -86, i64 100, i1 false), !annotation !0
%7 = getelementptr inbounds [2 x i8], ptr %5, i64 0, i64 0
call void @llvm.lifetime.start.p0(i64 2, ptr nonnull %7) #3
; This store must move.
store i8 -86, i8* %7, align 1, !annotation !0
%8 = getelementptr inbounds [2 x i8], [2 x i8]* %5, i64 0, i64 1
store i8 -86, ptr %7, align 1, !annotation !0
%8 = getelementptr inbounds [2 x i8], ptr %5, i64 0, i64 1
; This store must move.
store i8 -86, i8* %8, align 1, !annotation !0
store i8 -86, ptr %8, align 1, !annotation !0
%9 = icmp eq i32 %1, 0
br i1 %9, label %15, label %10

10:
%11 = sext i32 %0 to i64
%12 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %11
store i8 12, i8* %12, align 1
%13 = load i8, i8* %6, align 16
%12 = getelementptr inbounds [100 x i8], ptr %4, i64 0, i64 %11
store i8 12, ptr %12, align 1
%13 = load i8, ptr %6, align 16
%14 = sext i8 %13 to i32
br label %22

Expand All @@ -73,24 +73,24 @@ define i32 @foo(i32 noundef %0, i32 noundef %1, i32 noundef %2) #0 {

17:
%18 = sext i32 %0 to i64
%19 = getelementptr inbounds [2 x i8], [2 x i8]* %5, i64 0, i64 %18
store i8 12, i8* %19, align 1
%20 = load i8, i8* %7, align 1
%19 = getelementptr inbounds [2 x i8], ptr %5, i64 0, i64 %18
store i8 12, ptr %19, align 1
%20 = load i8, ptr %7, align 1
%21 = sext i8 %20 to i32
br label %22

22:
%23 = phi i32 [ %14, %10 ], [ %21, %17 ], [ 0, %15 ]
call void @llvm.lifetime.end.p0i8(i64 2, i8* nonnull %7) #3
call void @llvm.lifetime.end.p0i8(i64 100, i8* nonnull %6) #3
call void @llvm.lifetime.end.p0(i64 2, ptr nonnull %7) #3
call void @llvm.lifetime.end.p0(i64 100, ptr nonnull %6) #3
ret i32 %23
}

declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture) #1
declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #1

declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1 immarg) #2
declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1 immarg) #2

declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture) #1
declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #1

attributes #0 = { mustprogress nofree nosync nounwind readnone uwtable willreturn }
attributes #1 = { argmemonly mustprogress nofree nosync nounwind willreturn }
Expand Down
2 changes: 1 addition & 1 deletion llvm/test/Transforms/NewGVN/flags-simplify.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -52,7 +52,7 @@ define i64 @lshr_lsh_nuw(i64 %tmp) {
;
entry:
%conv3 = shl nuw i64 %tmp, 32
store i64 %conv3, i64* @f, align 8
store i64 %conv3, ptr @f, align 8
%sext = shl i64 %tmp, 32
%lshr = lshr i64 %sext, 32
ret i64 %lshr
Expand Down
2 changes: 1 addition & 1 deletion llvm/test/Transforms/NewGVN/no_speculative_loads_with_asan.ll
View file
Original file line number Diff line number Diff line change
@@ -1,7 +1,7 @@
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -passes=newgvn -S %s | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
declare noalias i8* @_Znam(i64) #1
declare noalias ptr @_Znam(i64) #1

define i32 @TestNoAsan() {
; CHECK-LABEL: @TestNoAsan(
Expand Down
4 changes: 2 additions & 2 deletions llvm/test/Transforms/NewGVN/pr17732.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -13,10 +13,10 @@ target triple = "x86_64-unknown-linux-gnu"

define i32 @main() {
entry:
tail call void @llvm.memcpy.p0.p0.i64(ptr align 4 @array_with_zeroinit, ptr align 4 getelementptr inbounds ({ [2 x i8], i32, i8, [3 x i8] }, ptr @main.obj_with_array, i64 0, i32 0, i64 0), i64 12, i1 false)
tail call void @llvm.memcpy.p0.p0.i64(ptr align 4 @array_with_zeroinit, ptr align 4 @main.obj_with_array, i64 12, i1 false)
%0 = load i8, ptr getelementptr inbounds (%struct.with_array, ptr @array_with_zeroinit, i64 0, i32 2), align 4

tail call void @llvm.memcpy.p0.p0.i64(ptr align 4 @vector_with_zeroinit, ptr align 4 getelementptr inbounds ({ <2 x i8>, i32, i8, [3 x i8] }, ptr @main.obj_with_vector, i64 0, i32 0, i64 0), i64 12, i1 false)
tail call void @llvm.memcpy.p0.p0.i64(ptr align 4 @vector_with_zeroinit, ptr align 4 @main.obj_with_vector, i64 12, i1 false)
%1 = load i8, ptr getelementptr inbounds (%struct.with_vector, ptr @vector_with_zeroinit, i64 0, i32 2), align 4
%conv0 = sext i8 %0 to i32
%conv1 = sext i8 %1 to i32
Expand Down
16 changes: 8 additions & 8 deletions llvm/test/Transforms/NewGVN/unreachable_block_infinite_loop.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -17,13 +17,13 @@ entry:
br label %bb0

bb1:
%ptr1 = ptrtoint i32* %ptr2 to i64
%ptr2 = inttoptr i64 %ptr1 to i32*
%ptr1 = ptrtoint ptr %ptr2 to i64
%ptr2 = inttoptr i64 %ptr1 to ptr
br i1 undef, label %bb0, label %bb1

bb0:
%phi = phi i32* [ undef, %entry ], [ %ptr2, %bb1 ]
%load = load i32, i32* %phi
%phi = phi ptr [ undef, %entry ], [ %ptr2, %bb1 ]
%load = load i32, ptr %phi
ret i32 %load
}

Expand All @@ -32,12 +32,12 @@ entry:
br label %bb0

bb1:
%ptr1 = getelementptr i32, i32* %ptr2, i32 0
%ptr2 = getelementptr i32, i32* %ptr1, i32 0
%ptr1 = getelementptr i32, ptr %ptr2, i32 0
%ptr2 = getelementptr i32, ptr %ptr1, i32 0
br i1 undef, label %bb0, label %bb1

bb0:
%phi = phi i32* [ undef, %entry ], [ %ptr2, %bb1 ]
%load = load i32, i32* %phi
%phi = phi ptr [ undef, %entry ], [ %ptr2, %bb1 ]
%load = load i32, ptr %phi
ret i32 %load
}
18 changes: 9 additions & 9 deletions llvm/test/Transforms/PGOProfile/coverage.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -81,8 +81,8 @@ entry:
; ENTRY: call void @llvm.instrprof.cover({{.*}})
%a.addr = alloca i32, align 4
%i = alloca i32, align 4
store i32 %a, i32* %a.addr, align 4
%0 = load i32, i32* %a.addr, align 4
store i32 %a, ptr %a.addr, align 4
%0 = load i32, ptr %a.addr, align 4
%rem = srem i32 %0, 2
%cmp = icmp eq i32 %rem, 0
br i1 %cmp, label %if.then, label %if.else
Expand All @@ -100,20 +100,20 @@ if.else: ; preds = %entry

; CHECK-LABEL: if.end:
if.end: ; preds = %if.else, %if.then
store i32 1, i32* %i, align 4
store i32 1, ptr %i, align 4
br label %for.cond

; CHECK-LABEL: for.cond:
for.cond: ; preds = %for.inc, %if.end
%1 = load i32, i32* %i, align 4
%2 = load i32, i32* %a.addr, align 4
%1 = load i32, ptr %i, align 4
%2 = load i32, ptr %a.addr, align 4
%cmp1 = icmp slt i32 %1, %2
br i1 %cmp1, label %for.body, label %for.end
; USE: br i1 %cmp1, label %for.body, label %for.end, !prof ![[WEIGHTS1]]

; CHECK-LABEL: for.body:
for.body: ; preds = %for.cond
%3 = load i32, i32* %a.addr, align 4
%3 = load i32, ptr %a.addr, align 4
%rem2 = srem i32 %3, 3
%cmp3 = icmp eq i32 %rem2, 0
br i1 %cmp3, label %if.then4, label %if.else5
Expand All @@ -126,7 +126,7 @@ if.then4: ; preds = %for.body

; CHECK-LABEL: if.else5:
if.else5: ; preds = %for.body
%4 = load i32, i32* %a.addr, align 4
%4 = load i32, ptr %a.addr, align 4
%rem6 = srem i32 %4, 1001
%cmp7 = icmp eq i32 %rem6, 0
br i1 %cmp7, label %if.then8, label %if.end9
Expand All @@ -148,9 +148,9 @@ if.end10: ; preds = %if.end9, %if.then4

; CHECK-LABEL: for.inc:
for.inc: ; preds = %if.end10
%5 = load i32, i32* %i, align 4
%5 = load i32, ptr %i, align 4
%inc = add nsw i32 %5, 1
store i32 %inc, i32* %i, align 4
store i32 %inc, ptr %i, align 4
br label %for.cond

; CHECK-LABEL: for.end:
Expand Down
120 changes: 60 additions & 60 deletions llvm/test/Transforms/SLPVectorizer/AArch64/slp-abs.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -18,12 +18,12 @@ define void @abs_v2i64() {
;

entry:
%a0 = load i64, i64* getelementptr inbounds (i64, ptr @a, i64 0), align 8
%a1 = load i64, i64* getelementptr inbounds (i64, ptr @a, i64 1), align 8
%a0 = load i64, ptr @a, align 8
%a1 = load i64, ptr getelementptr inbounds (i64, ptr @a, i64 1), align 8
%r0 = call i64 @llvm.abs.i64(i64 %a0, i1 false)
%r1 = call i64 @llvm.abs.i64(i64 %a1, i1 false)
store i64 %r0, i64* getelementptr inbounds (i64, ptr @a, i64 0), align 8
store i64 %r1, i64* getelementptr inbounds (i64, ptr @a, i64 1), align 8
store i64 %r0, ptr @a, align 8
store i64 %r1, ptr getelementptr inbounds (i64, ptr @a, i64 1), align 8
ret void
}

Expand All @@ -37,18 +37,18 @@ define void @abs_v4i32() {
;

entry:
%a0 = load i32, i32* getelementptr inbounds (i32, ptr @a, i64 0), align 8
%a1 = load i32, i32* getelementptr inbounds (i32, ptr @a, i64 1), align 8
%a2 = load i32, i32* getelementptr inbounds (i32, ptr @a, i64 2), align 8
%a3 = load i32, i32* getelementptr inbounds (i32, ptr @a, i64 3), align 8
%a0 = load i32, ptr @a, align 8
%a1 = load i32, ptr getelementptr inbounds (i32, ptr @a, i64 1), align 8
%a2 = load i32, ptr getelementptr inbounds (i32, ptr @a, i64 2), align 8
%a3 = load i32, ptr getelementptr inbounds (i32, ptr @a, i64 3), align 8
%r0 = call i32 @llvm.abs.i32(i32 %a0, i1 false)
%r1 = call i32 @llvm.abs.i32(i32 %a1, i1 false)
%r2 = call i32 @llvm.abs.i32(i32 %a2, i1 false)
%r3 = call i32 @llvm.abs.i32(i32 %a3, i1 false)
store i32 %r0, i32* getelementptr inbounds (i32, ptr @a, i64 0), align 8
store i32 %r1, i32* getelementptr inbounds (i32, ptr @a, i64 1), align 8
store i32 %r2, i32* getelementptr inbounds (i32, ptr @a, i64 2), align 8
store i32 %r3, i32* getelementptr inbounds (i32, ptr @a, i64 3), align 8
store i32 %r0, ptr @a, align 8
store i32 %r1, ptr getelementptr inbounds (i32, ptr @a, i64 1), align 8
store i32 %r2, ptr getelementptr inbounds (i32, ptr @a, i64 2), align 8
store i32 %r3, ptr getelementptr inbounds (i32, ptr @a, i64 3), align 8
ret void
}

Expand All @@ -62,14 +62,14 @@ define void @abs_v8i16() {
;

entry:
%a0 = load i16, i16* getelementptr inbounds (i16, ptr @a, i64 0), align 8
%a1 = load i16, i16* getelementptr inbounds (i16, ptr @a, i64 1), align 8
%a2 = load i16, i16* getelementptr inbounds (i16, ptr @a, i64 2), align 8
%a3 = load i16, i16* getelementptr inbounds (i16, ptr @a, i64 3), align 8
%a4 = load i16, i16* getelementptr inbounds (i16, ptr @a, i64 4), align 8
%a5 = load i16, i16* getelementptr inbounds (i16, ptr @a, i64 5), align 8
%a6 = load i16, i16* getelementptr inbounds (i16, ptr @a, i64 6), align 8
%a7 = load i16, i16* getelementptr inbounds (i16, ptr @a, i64 7), align 8
%a0 = load i16, ptr @a, align 8
%a1 = load i16, ptr getelementptr inbounds (i16, ptr @a, i64 1), align 8
%a2 = load i16, ptr getelementptr inbounds (i16, ptr @a, i64 2), align 8
%a3 = load i16, ptr getelementptr inbounds (i16, ptr @a, i64 3), align 8
%a4 = load i16, ptr getelementptr inbounds (i16, ptr @a, i64 4), align 8
%a5 = load i16, ptr getelementptr inbounds (i16, ptr @a, i64 5), align 8
%a6 = load i16, ptr getelementptr inbounds (i16, ptr @a, i64 6), align 8
%a7 = load i16, ptr getelementptr inbounds (i16, ptr @a, i64 7), align 8
%r0 = call i16 @llvm.abs.i16(i16 %a0, i1 false)
%r1 = call i16 @llvm.abs.i16(i16 %a1, i1 false)
%r2 = call i16 @llvm.abs.i16(i16 %a2, i1 false)
Expand All @@ -78,14 +78,14 @@ entry:
%r5 = call i16 @llvm.abs.i16(i16 %a5, i1 false)
%r6 = call i16 @llvm.abs.i16(i16 %a6, i1 false)
%r7 = call i16 @llvm.abs.i16(i16 %a7, i1 false)
store i16 %r0, i16* getelementptr inbounds (i16, ptr @a, i64 0), align 8
store i16 %r1, i16* getelementptr inbounds (i16, ptr @a, i64 1), align 8
store i16 %r2, i16* getelementptr inbounds (i16, ptr @a, i64 2), align 8
store i16 %r3, i16* getelementptr inbounds (i16, ptr @a, i64 3), align 8
store i16 %r4, i16* getelementptr inbounds (i16, ptr @a, i64 4), align 8
store i16 %r5, i16* getelementptr inbounds (i16, ptr @a, i64 5), align 8
store i16 %r6, i16* getelementptr inbounds (i16, ptr @a, i64 6), align 8
store i16 %r7, i16* getelementptr inbounds (i16, ptr @a, i64 7), align 8
store i16 %r0, ptr @a, align 8
store i16 %r1, ptr getelementptr inbounds (i16, ptr @a, i64 1), align 8
store i16 %r2, ptr getelementptr inbounds (i16, ptr @a, i64 2), align 8
store i16 %r3, ptr getelementptr inbounds (i16, ptr @a, i64 3), align 8
store i16 %r4, ptr getelementptr inbounds (i16, ptr @a, i64 4), align 8
store i16 %r5, ptr getelementptr inbounds (i16, ptr @a, i64 5), align 8
store i16 %r6, ptr getelementptr inbounds (i16, ptr @a, i64 6), align 8
store i16 %r7, ptr getelementptr inbounds (i16, ptr @a, i64 7), align 8
ret void
}

Expand All @@ -99,22 +99,22 @@ define void @abs_v16i8() {
;

entry:
%a0 = load i8, i8* getelementptr inbounds (i8, ptr @a, i64 0), align 8
%a1 = load i8, i8* getelementptr inbounds (i8, ptr @a, i64 1), align 8
%a2 = load i8, i8* getelementptr inbounds (i8, ptr @a, i64 2), align 8
%a3 = load i8, i8* getelementptr inbounds (i8, ptr @a, i64 3), align 8
%a4 = load i8, i8* getelementptr inbounds (i8, ptr @a, i64 4), align 8
%a5 = load i8, i8* getelementptr inbounds (i8, ptr @a, i64 5), align 8
%a6 = load i8, i8* getelementptr inbounds (i8, ptr @a, i64 6), align 8
%a7 = load i8, i8* getelementptr inbounds (i8, ptr @a, i64 7), align 8
%a8 = load i8, i8* getelementptr inbounds (i8, ptr @a, i64 8), align 8
%a9 = load i8, i8* getelementptr inbounds (i8, ptr @a, i64 9), align 8
%a10 = load i8, i8* getelementptr inbounds (i8, ptr @a, i64 10), align 8
%a11 = load i8, i8* getelementptr inbounds (i8, ptr @a, i64 11), align 8
%a12 = load i8, i8* getelementptr inbounds (i8, ptr @a, i64 12), align 8
%a13 = load i8, i8* getelementptr inbounds (i8, ptr @a, i64 13), align 8
%a14 = load i8, i8* getelementptr inbounds (i8, ptr @a, i64 14), align 8
%a15 = load i8, i8* getelementptr inbounds (i8, ptr @a, i64 15), align 8
%a0 = load i8, ptr @a, align 8
%a1 = load i8, ptr getelementptr inbounds (i8, ptr @a, i64 1), align 8
%a2 = load i8, ptr getelementptr inbounds (i8, ptr @a, i64 2), align 8
%a3 = load i8, ptr getelementptr inbounds (i8, ptr @a, i64 3), align 8
%a4 = load i8, ptr getelementptr inbounds (i8, ptr @a, i64 4), align 8
%a5 = load i8, ptr getelementptr inbounds (i8, ptr @a, i64 5), align 8
%a6 = load i8, ptr getelementptr inbounds (i8, ptr @a, i64 6), align 8
%a7 = load i8, ptr getelementptr inbounds (i8, ptr @a, i64 7), align 8
%a8 = load i8, ptr getelementptr inbounds (i8, ptr @a, i64 8), align 8
%a9 = load i8, ptr getelementptr inbounds (i8, ptr @a, i64 9), align 8
%a10 = load i8, ptr getelementptr inbounds (i8, ptr @a, i64 10), align 8
%a11 = load i8, ptr getelementptr inbounds (i8, ptr @a, i64 11), align 8
%a12 = load i8, ptr getelementptr inbounds (i8, ptr @a, i64 12), align 8
%a13 = load i8, ptr getelementptr inbounds (i8, ptr @a, i64 13), align 8
%a14 = load i8, ptr getelementptr inbounds (i8, ptr @a, i64 14), align 8
%a15 = load i8, ptr getelementptr inbounds (i8, ptr @a, i64 15), align 8
%r0 = call i8 @llvm.abs.i8(i8 %a0, i1 false)
%r1 = call i8 @llvm.abs.i8(i8 %a1, i1 false)
%r2 = call i8 @llvm.abs.i8(i8 %a2, i1 false)
Expand All @@ -131,21 +131,21 @@ entry:
%r13 = call i8 @llvm.abs.i8(i8 %a13, i1 false)
%r14 = call i8 @llvm.abs.i8(i8 %a14, i1 false)
%r15 = call i8 @llvm.abs.i8(i8 %a15, i1 false)
store i8 %r0, i8* getelementptr inbounds (i8, ptr @a, i64 0), align 8
store i8 %r1, i8* getelementptr inbounds (i8, ptr @a, i64 1), align 8
store i8 %r2, i8* getelementptr inbounds (i8, ptr @a, i64 2), align 8
store i8 %r3, i8* getelementptr inbounds (i8, ptr @a, i64 3), align 8
store i8 %r4, i8* getelementptr inbounds (i8, ptr @a, i64 4), align 8
store i8 %r5, i8* getelementptr inbounds (i8, ptr @a, i64 5), align 8
store i8 %r6, i8* getelementptr inbounds (i8, ptr @a, i64 6), align 8
store i8 %r7, i8* getelementptr inbounds (i8, ptr @a, i64 7), align 8
store i8 %r8, i8* getelementptr inbounds (i8, ptr @a, i64 8), align 8
store i8 %r9, i8* getelementptr inbounds (i8, ptr @a, i64 9), align 8
store i8 %r10, i8* getelementptr inbounds (i8, ptr @a, i64 10), align 8
store i8 %r11, i8* getelementptr inbounds (i8, ptr @a, i64 11), align 8
store i8 %r12, i8* getelementptr inbounds (i8, ptr @a, i64 12), align 8
store i8 %r13, i8* getelementptr inbounds (i8, ptr @a, i64 13), align 8
store i8 %r14, i8* getelementptr inbounds (i8, ptr @a, i64 14), align 8
store i8 %r15, i8* getelementptr inbounds (i8, ptr @a, i64 15), align 8
store i8 %r0, ptr @a, align 8
store i8 %r1, ptr getelementptr inbounds (i8, ptr @a, i64 1), align 8
store i8 %r2, ptr getelementptr inbounds (i8, ptr @a, i64 2), align 8
store i8 %r3, ptr getelementptr inbounds (i8, ptr @a, i64 3), align 8
store i8 %r4, ptr getelementptr inbounds (i8, ptr @a, i64 4), align 8
store i8 %r5, ptr getelementptr inbounds (i8, ptr @a, i64 5), align 8
store i8 %r6, ptr getelementptr inbounds (i8, ptr @a, i64 6), align 8
store i8 %r7, ptr getelementptr inbounds (i8, ptr @a, i64 7), align 8
store i8 %r8, ptr getelementptr inbounds (i8, ptr @a, i64 8), align 8
store i8 %r9, ptr getelementptr inbounds (i8, ptr @a, i64 9), align 8
store i8 %r10, ptr getelementptr inbounds (i8, ptr @a, i64 10), align 8
store i8 %r11, ptr getelementptr inbounds (i8, ptr @a, i64 11), align 8
store i8 %r12, ptr getelementptr inbounds (i8, ptr @a, i64 12), align 8
store i8 %r13, ptr getelementptr inbounds (i8, ptr @a, i64 13), align 8
store i8 %r14, ptr getelementptr inbounds (i8, ptr @a, i64 14), align 8
store i8 %r15, ptr getelementptr inbounds (i8, ptr @a, i64 15), align 8
ret void
}
256 changes: 128 additions & 128 deletions llvm/test/Transforms/SLPVectorizer/RISCV/reductions.ll
View file

Large diffs are not rendered by default.

392 changes: 196 additions & 196 deletions llvm/test/Transforms/SLPVectorizer/RISCV/strided-loads-vectorized.ll
View file

Large diffs are not rendered by default.

2 changes: 1 addition & 1 deletion llvm/test/Transforms/SLPVectorizer/X86/arith-fshl-rot.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -153,7 +153,7 @@ define void @fshl_v8i64() {
%r5 = call i64 @llvm.fshl.i64(i64 %a5, i64 %a5, i64 %b5)
%r6 = call i64 @llvm.fshl.i64(i64 %a6, i64 %a6, i64 %b6)
%r7 = call i64 @llvm.fshl.i64(i64 %a7, i64 %a7, i64 %b7)
store i64 %r0, ptr getelementptr inbounds ([8 x i64], ptr @d64, i32 0, i64 0), align 8
store i64 %r0, ptr @d64, align 8
store i64 %r1, ptr getelementptr inbounds ([8 x i64], ptr @d64, i32 0, i64 1), align 8
store i64 %r2, ptr getelementptr inbounds ([8 x i64], ptr @d64, i32 0, i64 2), align 8
store i64 %r3, ptr getelementptr inbounds ([8 x i64], ptr @d64, i32 0, i64 3), align 8
Expand Down
2 changes: 1 addition & 1 deletion llvm/test/Transforms/SLPVectorizer/X86/arith-fshl.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -162,7 +162,7 @@ define void @fshl_v8i64() {
%r5 = call i64 @llvm.fshl.i64(i64 %a5, i64 %b5, i64 %c5)
%r6 = call i64 @llvm.fshl.i64(i64 %a6, i64 %b6, i64 %c6)
%r7 = call i64 @llvm.fshl.i64(i64 %a7, i64 %b7, i64 %c7)
store i64 %r0, ptr getelementptr inbounds ([8 x i64], ptr @d64, i32 0, i64 0), align 8
store i64 %r0, ptr @d64, align 8
store i64 %r1, ptr getelementptr inbounds ([8 x i64], ptr @d64, i32 0, i64 1), align 8
store i64 %r2, ptr getelementptr inbounds ([8 x i64], ptr @d64, i32 0, i64 2), align 8
store i64 %r3, ptr getelementptr inbounds ([8 x i64], ptr @d64, i32 0, i64 3), align 8
Expand Down
2 changes: 1 addition & 1 deletion llvm/test/Transforms/SLPVectorizer/X86/arith-fshr-rot.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -153,7 +153,7 @@ define void @fshr_v8i64() {
%r5 = call i64 @llvm.fshr.i64(i64 %a5, i64 %a5, i64 %b5)
%r6 = call i64 @llvm.fshr.i64(i64 %a6, i64 %a6, i64 %b6)
%r7 = call i64 @llvm.fshr.i64(i64 %a7, i64 %a7, i64 %b7)
store i64 %r0, ptr getelementptr inbounds ([8 x i64], ptr @d64, i32 0, i64 0), align 8
store i64 %r0, ptr @d64, align 8
store i64 %r1, ptr getelementptr inbounds ([8 x i64], ptr @d64, i32 0, i64 1), align 8
store i64 %r2, ptr getelementptr inbounds ([8 x i64], ptr @d64, i32 0, i64 2), align 8
store i64 %r3, ptr getelementptr inbounds ([8 x i64], ptr @d64, i32 0, i64 3), align 8
Expand Down
2 changes: 1 addition & 1 deletion llvm/test/Transforms/SLPVectorizer/X86/arith-fshr.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -162,7 +162,7 @@ define void @fshr_v8i64() {
%r5 = call i64 @llvm.fshr.i64(i64 %a5, i64 %b5, i64 %c5)
%r6 = call i64 @llvm.fshr.i64(i64 %a6, i64 %b6, i64 %c6)
%r7 = call i64 @llvm.fshr.i64(i64 %a7, i64 %b7, i64 %c7)
store i64 %r0, ptr getelementptr inbounds ([8 x i64], ptr @d64, i32 0, i64 0), align 8
store i64 %r0, ptr @d64, align 8
store i64 %r1, ptr getelementptr inbounds ([8 x i64], ptr @d64, i32 0, i64 1), align 8
store i64 %r2, ptr getelementptr inbounds ([8 x i64], ptr @d64, i32 0, i64 2), align 8
store i64 %r3, ptr getelementptr inbounds ([8 x i64], ptr @d64, i32 0, i64 3), align 8
Expand Down
4 changes: 2 additions & 2 deletions llvm/test/Transforms/SLPVectorizer/X86/horizontal.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1135,7 +1135,7 @@ define float @fadd_v4f32_fmf(ptr %p) {
; CHECK-NEXT: [[TMP2:%.*]] = call reassoc nsz float @llvm.vector.reduce.fadd.v4f32(float -0.000000e+00, <4 x float> [[TMP1]])
; CHECK-NEXT: ret float [[TMP2]]
;
%p1 = getelementptr inbounds float, float* %p, i64 1
%p1 = getelementptr inbounds float, ptr %p, i64 1
%p2 = getelementptr inbounds float, ptr %p, i64 2
%p3 = getelementptr inbounds float, ptr %p, i64 3
%t0 = load float, ptr %p, align 4
Expand All @@ -1158,7 +1158,7 @@ define float @fadd_v4f32_fmf_intersect(ptr %p) {
; CHECK-NEXT: [[TMP2:%.*]] = call reassoc ninf nsz float @llvm.vector.reduce.fadd.v4f32(float -0.000000e+00, <4 x float> [[TMP1]])
; CHECK-NEXT: ret float [[TMP2]]
;
%p1 = getelementptr inbounds float, float* %p, i64 1
%p1 = getelementptr inbounds float, ptr %p, i64 1
%p2 = getelementptr inbounds float, ptr %p, i64 2
%p3 = getelementptr inbounds float, ptr %p, i64 3
%t0 = load float, ptr %p, align 4
Expand Down
20 changes: 10 additions & 10 deletions llvm/test/Transforms/SLPVectorizer/X86/opaque-ptr.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -50,7 +50,7 @@ define void @test(ptr %r, ptr %p, ptr %q) #0 {
ret void
}

define void @test2(i64* %a, i64* %b) {
define void @test2(ptr %a, ptr %b) {
; CHECK-LABEL: @test2(
; CHECK-NEXT: [[A1:%.*]] = getelementptr inbounds i64, ptr [[A:%.*]], i64 1
; CHECK-NEXT: [[A2:%.*]] = getelementptr inbounds i64, ptr [[A]], i64 2
Expand All @@ -65,16 +65,16 @@ define void @test2(i64* %a, i64* %b) {
; CHECK-NEXT: store i64 [[ADD2]], ptr [[A2]], align 8
; CHECK-NEXT: ret void
;
%a1 = getelementptr inbounds i64, i64* %a, i64 1
%a2 = getelementptr inbounds i64, i64* %a, i64 2
%i1 = ptrtoint i64* %a1 to i64
%b3 = getelementptr inbounds i64, i64* %b, i64 3
%i2 = ptrtoint i64* %b3 to i64
%v1 = load i64, i64* %a1, align 8
%v2 = load i64, i64* %a2, align 8
%a1 = getelementptr inbounds i64, ptr %a, i64 1
%a2 = getelementptr inbounds i64, ptr %a, i64 2
%i1 = ptrtoint ptr %a1 to i64
%b3 = getelementptr inbounds i64, ptr %b, i64 3
%i2 = ptrtoint ptr %b3 to i64
%v1 = load i64, ptr %a1, align 8
%v2 = load i64, ptr %a2, align 8
%add1 = add i64 %i1, %v1
%add2 = add i64 %i2, %v2
store i64 %add1, i64* %a1, align 8
store i64 %add2, i64* %a2, align 8
store i64 %add1, ptr %a1, align 8
store i64 %add2, ptr %a2, align 8
ret void
}
6 changes: 3 additions & 3 deletions llvm/test/Transforms/SLPVectorizer/X86/stackrestore-dependence.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -26,7 +26,7 @@ define void @stackrestore1(ptr %out) {
%val1 = load float, ptr %addr1, align 4
%val2 = load float, ptr %addr2, align 4
%val3 = load float, ptr %addr3, align 4
call void @llvm.stackrestore(i8* %stack)
call void @llvm.stackrestore(ptr %stack)
%outaddr2 = getelementptr inbounds float, ptr %out, i64 2
store float %val0, ptr %outaddr2, align 4
%outaddr3 = getelementptr inbounds float, ptr %out, i64 3
Expand All @@ -37,5 +37,5 @@ define void @stackrestore1(ptr %out) {
ret void
}

declare i8* @llvm.stacksave()
declare void @llvm.stackrestore(i8*)
declare ptr @llvm.stacksave()
declare void @llvm.stackrestore(ptr)
2 changes: 1 addition & 1 deletion llvm/test/Transforms/SROA/invariant-group.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -155,7 +155,7 @@ define void @partial_promotion_of_alloca() {
ret void
}

declare void @use(i32*)
declare void @use(ptr)

!0 = !{}
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
Expand Down
4 changes: 2 additions & 2 deletions llvm/test/Transforms/SROA/phi-gep.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -228,7 +228,7 @@ for:
%phi_i = phi i32 [ 0, %entry ], [ %i, %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
%gep_for = getelementptr inbounds i32, ptr %phi, i32 0
%loop.cond = icmp ult i32 %i, 10
br i1 %loop.cond, label %for, label %end

Expand Down Expand Up @@ -397,7 +397,7 @@ for:
%phi_i = phi i32 [ 0, %entry ], [ %i, %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 = getelementptr inbounds float, ptr %phi, i32 0
%loop.cond = icmp ult i32 %i, 10
br i1 %loop.cond, label %for, label %end

Expand Down
4 changes: 2 additions & 2 deletions llvm/test/Transforms/SROA/scalable-vector-struct.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -16,8 +16,8 @@ define %struct.test @alloca(<vscale x 1 x i32> %x, <vscale x 1 x i32> %y) {
%addr = alloca %struct.test, align 4
%agg0 = insertvalue %struct.test undef, <vscale x 1 x i32> %x, 0
%agg1 = insertvalue %struct.test %agg0, <vscale x 1 x i32> %y, 1
store %struct.test %agg1, %struct.test* %addr, align 4
%val = load %struct.test, %struct.test* %addr, align 4
store %struct.test %agg1, ptr %addr, align 4
%val = load %struct.test, ptr %addr, align 4
ret %struct.test %val
}

Expand Down
34 changes: 17 additions & 17 deletions llvm/test/Transforms/SROA/sroa-common-type-fail-promotion.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -29,7 +29,7 @@ define amdgpu_kernel void @test_zeroinit() #0 {
entry:
%b_blockwise_copy = alloca %"struct.b", align 16
store <8 x half> zeroinitializer, ptr %b_blockwise_copy, align 16
%data = load <4 x float>, <4 x float>* undef
%data = load <4 x float>, ptr undef
store <4 x float> %data, ptr %b_blockwise_copy, align 16
br label %bb

Expand Down Expand Up @@ -60,7 +60,7 @@ define amdgpu_kernel void @test_memset() #0 {
entry:
%b_blockwise_copy = alloca %"struct.b", align 16
call void @llvm.memset.p0.i64(ptr align 16 %b_blockwise_copy, i8 0, i64 16, i1 false)
%data = load <4 x float>, <4 x float>* undef
%data = load <4 x float>, ptr undef
store <4 x float> %data, ptr %b_blockwise_copy, align 16
br label %bb

Expand Down Expand Up @@ -91,7 +91,7 @@ define amdgpu_kernel void @vector_type_alloca() #0 {
entry:
%b_blockwise_copy = alloca <8 x half>, align 16
store <8 x half> zeroinitializer, ptr %b_blockwise_copy, align 16
%data = load <4 x float>, <4 x float>* undef
%data = load <4 x float>, ptr undef
store <4 x float> %data, ptr %b_blockwise_copy, align 16
br label %bb

Expand Down Expand Up @@ -122,7 +122,7 @@ define amdgpu_kernel void @test_struct_contain_multiple_types1() #0 {
entry:
%b_blockwise_copy = alloca %"struct.c", align 16
store <8 x half> zeroinitializer, ptr %b_blockwise_copy, align 16
%data = load <4 x float>, <4 x float>* undef
%data = load <4 x float>, ptr undef
store <4 x float> %data, ptr %b_blockwise_copy, align 16
br label %bb

Expand Down Expand Up @@ -158,11 +158,11 @@ define amdgpu_kernel void @test_struct_contain_multiple_types2() #0 {
entry:
%b_blockwise_copy = alloca %"struct.d", align 16
call void @llvm.memset.p0.i32(ptr align 16 %b_blockwise_copy, i8 0, i32 16, i1 false)
%data1 = load [4 x i32], [4 x i32]* undef
%data1 = load [4 x i32], ptr undef
store [4 x i32] %data1, ptr %b_blockwise_copy, align 16
%data2_gep = getelementptr inbounds i8, ptr %b_blockwise_copy, i64 16
store <8 x half> zeroinitializer, ptr %data2_gep, align 16
%data2 = load <4 x float>, <4 x float>* undef
%data2 = load <4 x float>, ptr undef
store <4 x float> %data2, ptr %data2_gep, align 16
br label %bb

Expand Down Expand Up @@ -196,9 +196,9 @@ entry:
store <8 x half> zeroinitializer, ptr %b_blockwise_copy, align 16
%0 = getelementptr inbounds i8, ptr %b_blockwise_copy, i64 16
store <8 x half> zeroinitializer, ptr %0, align 16
%data0 = load <4 x float>, <4 x float>* undef
%data0 = load <4 x float>, ptr undef
store <4 x float> %data0, ptr %b_blockwise_copy, align 16
%data1 = load <4 x float>, <4 x float>* undef
%data1 = load <4 x float>, ptr undef
store <4 x float> %data1, ptr %0, align 16
br label %bb

Expand Down Expand Up @@ -226,9 +226,9 @@ define amdgpu_kernel void @test_struct_array_vector_i16() #0 {
entry:
%b_blockwise_copy = alloca %"struct.f", align 16
call void @llvm.memset.p0.i32(ptr align 16 %b_blockwise_copy, i8 0, i32 32, i1 false)
%data = load <4 x i32>, <4 x i32>* undef
%data = load <4 x i32>, ptr undef
store <4 x i32> %data, ptr %b_blockwise_copy, align 16
%data2 = load <4 x i32>, <4 x i32>* undef
%data2 = load <4 x i32>, ptr undef
%data2_gep = getelementptr inbounds i8, ptr %b_blockwise_copy, i64 16
store <4 x i32> %data2, ptr %data2_gep, align 16
br label %bb
Expand Down Expand Up @@ -269,7 +269,7 @@ define amdgpu_kernel void @test_half_array() #0 {
entry:
%b_blockwise_copy = alloca [8 x half], align 16
call void @llvm.memset.p0.i32(ptr align 16 %b_blockwise_copy, i8 0, i32 16, i1 false)
%data = load [4 x float], [4 x float]* undef
%data = load [4 x float], ptr undef
store [4 x float] %data, ptr %b_blockwise_copy, align 16
br label %bb

Expand Down Expand Up @@ -302,7 +302,7 @@ define amdgpu_kernel void @test_array_vector() #0 {
entry:
%b_blockwise_copy = alloca %"array.a", align 16
call void @llvm.memset.p0.i32(ptr align 16 %b_blockwise_copy, i8 0, i32 32, i1 false)
%data = load <4 x float>, <4 x float>* undef
%data = load <4 x float>, ptr undef
store <4 x float> %data, ptr %b_blockwise_copy, align 16
br label %bb

Expand Down Expand Up @@ -335,7 +335,7 @@ define amdgpu_kernel void @test_array_vector2() #0 {
entry:
%b_blockwise_copy = alloca %"array.b", align 16
call void @llvm.memset.p0.i32(ptr align 16 %b_blockwise_copy, i8 0, i32 32, i1 false)
%data = load <4 x float>, <4 x float>* undef
%data = load <4 x float>, ptr undef
store <4 x float> %data, ptr %b_blockwise_copy, align 16
br label %bb

Expand Down Expand Up @@ -388,10 +388,10 @@ define amdgpu_kernel void @test_array_vector_no_vector_common_type() #0 {
entry:
%b_blockwise_copy = alloca %"array.a", align 16
call void @llvm.memset.p0.i32(ptr align 16 %b_blockwise_copy, i8 0, i32 32, i1 false)
%data1 = load float, float* undef
%data2 = load float, float* undef
%data3 = load float, float* undef
%data4 = load float, float* undef
%data1 = load float, ptr undef
%data2 = load float, ptr undef
%data3 = load float, ptr undef
%data4 = load float, ptr undef
store float %data1, ptr %b_blockwise_copy, align 16
%data_ptr1 = getelementptr inbounds i8, ptr %b_blockwise_copy, i64 4
store float %data2, ptr %data_ptr1, align 16
Expand Down
4 changes: 2 additions & 2 deletions llvm/test/Transforms/SROA/vector-promotion.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -966,8 +966,8 @@ define i32 @test14(<2 x i64> %x) {
;
entry:
%x.addr = alloca <2 x i64>, align 16
store <2 x i64> %x, <2 x i64>* %x.addr, align 16
%x.cast = bitcast <2 x i64>* %x.addr to i32*
store <2 x i64> %x, ptr %x.addr, align 16
%x.cast = bitcast ptr %x.addr to ptr
%a = load i32, ptr %x.cast
%x.tmp2 = getelementptr inbounds i32, ptr %x.cast, i64 1
%b = load i32, ptr %x.tmp2
Expand Down
8 changes: 4 additions & 4 deletions ...rms/ScalarizeMaskedMemIntrin/AArch64/streaming-compatible-expand-masked-gather-scatter.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -27,7 +27,7 @@ define <2 x i32> @scalarize_v2i32(<2 x ptr> %p, <2 x i1> %mask, <2 x i32> %passt
; CHECK-NEXT: [[RES_PHI_ELSE3:%.*]] = phi <2 x i32> [ [[RES1]], [[COND_LOAD1]] ], [ [[RES_PHI_ELSE]], [[ELSE]] ]
; CHECK-NEXT: ret <2 x i32> [[RES_PHI_ELSE3]]
;
%ret = call <2 x i32> @llvm.masked.gather.v2i32.v2p0i32(<2 x ptr> %p, i32 8, <2 x i1> %mask, <2 x i32> %passthru)
%ret = call <2 x i32> @llvm.masked.gather.v2i32.v2p0(<2 x ptr> %p, i32 8, <2 x i1> %mask, <2 x i32> %passthru)
ret <2 x i32> %ret
}

Expand All @@ -54,9 +54,9 @@ define void @scalarize_v2i64(<2 x ptr> %p, <2 x i1> %mask, <2 x i64> %value) {
; CHECK: else2:
; CHECK-NEXT: ret void
;
call void @llvm.masked.scatter.v2i64.v2p0i64(<2 x i64> %value, <2 x ptr> %p, i32 8, <2 x i1> %mask)
call void @llvm.masked.scatter.v2i64.v2p0(<2 x i64> %value, <2 x ptr> %p, i32 8, <2 x i1> %mask)
ret void
}

declare <2 x i32> @llvm.masked.gather.v2i32.v2p0i32(<2 x i32*>, i32, <2 x i1>, <2 x i32>)
declare void @llvm.masked.scatter.v2i64.v2p0i64(<2 x i64>, <2 x i64*>, i32, <2 x i1>)
declare <2 x i32> @llvm.masked.gather.v2i32.v2p0(<2 x ptr>, i32, <2 x i1>, <2 x i32>)
declare void @llvm.masked.scatter.v2i64.v2p0(<2 x i64>, <2 x ptr>, i32, <2 x i1>)
2 changes: 1 addition & 1 deletion llvm/test/Transforms/Util/pr49185.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -53,7 +53,7 @@ land.end1851: ; preds = %land.rhs1834, %lbl_
br i1 %tobool2351, label %if.then2352, label %if.else3029

if.then2352: ; preds = %land.end1851
%3 = load i16, ptr getelementptr inbounds ({ i16, i16 }, ptr @g_79, i32 0, i32 0), align 1, !tbaa !1
%3 = load i16, ptr @g_79, align 1, !tbaa !1
%tobool3011 = icmp ne i16 %3, 0
call void @llvm.assume(i1 %tobool3011)
store i32 11, ptr %cleanup.dest.slot, align 1
Expand Down
94 changes: 47 additions & 47 deletions llvm/test/Transforms/VectorCombine/AArch64/select-shuffle.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -487,7 +487,7 @@ define void @test_1652048214(ptr %src, ptr %dst) {
ret void
}

define dso_local i32 @full(i8* nocapture noundef readonly %p1, i32 noundef %st1, i8* nocapture noundef readonly %p2, i32 noundef %st2) {
define dso_local i32 @full(ptr nocapture noundef readonly %p1, i32 noundef %st1, ptr nocapture noundef readonly %p2, i32 noundef %st2) {
; CHECK-LABEL: @full(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[IDX_EXT:%.*]] = sext i32 [[ST1:%.*]] to i64
Expand Down Expand Up @@ -606,71 +606,71 @@ define dso_local i32 @full(i8* nocapture noundef readonly %p1, i32 noundef %st1,
entry:
%idx.ext = sext i32 %st1 to i64
%idx.ext63 = sext i32 %st2 to i64
%arrayidx3 = getelementptr inbounds i8, i8* %p1, i64 4
%arrayidx5 = getelementptr inbounds i8, i8* %p2, i64 4
%add.ptr = getelementptr inbounds i8, i8* %p1, i64 %idx.ext
%add.ptr64 = getelementptr inbounds i8, i8* %p2, i64 %idx.ext63
%arrayidx3.1 = getelementptr inbounds i8, i8* %add.ptr, i64 4
%arrayidx5.1 = getelementptr inbounds i8, i8* %add.ptr64, i64 4
%add.ptr.1 = getelementptr inbounds i8, i8* %add.ptr, i64 %idx.ext
%add.ptr64.1 = getelementptr inbounds i8, i8* %add.ptr64, i64 %idx.ext63
%arrayidx3.2 = getelementptr inbounds i8, i8* %add.ptr.1, i64 4
%arrayidx5.2 = getelementptr inbounds i8, i8* %add.ptr64.1, i64 4
%add.ptr.2 = getelementptr inbounds i8, i8* %add.ptr.1, i64 %idx.ext
%add.ptr64.2 = getelementptr inbounds i8, i8* %add.ptr64.1, i64 %idx.ext63
%arrayidx3.3 = getelementptr inbounds i8, i8* %add.ptr.2, i64 4
%arrayidx5.3 = getelementptr inbounds i8, i8* %add.ptr64.2, i64 4
%0 = bitcast i8* %p1 to <4 x i8>*
%1 = load <4 x i8>, <4 x i8>* %0, align 1
%2 = bitcast i8* %p2 to <4 x i8>*
%3 = load <4 x i8>, <4 x i8>* %2, align 1
%4 = bitcast i8* %arrayidx3 to <4 x i8>*
%5 = load <4 x i8>, <4 x i8>* %4, align 1
%6 = bitcast i8* %arrayidx5 to <4 x i8>*
%7 = load <4 x i8>, <4 x i8>* %6, align 1
%8 = bitcast i8* %add.ptr to <4 x i8>*
%9 = load <4 x i8>, <4 x i8>* %8, align 1
%10 = bitcast i8* %add.ptr64 to <4 x i8>*
%11 = load <4 x i8>, <4 x i8>* %10, align 1
%12 = bitcast i8* %arrayidx3.1 to <4 x i8>*
%13 = load <4 x i8>, <4 x i8>* %12, align 1
%14 = bitcast i8* %arrayidx5.1 to <4 x i8>*
%15 = load <4 x i8>, <4 x i8>* %14, align 1
%16 = bitcast i8* %add.ptr.1 to <4 x i8>*
%17 = load <4 x i8>, <4 x i8>* %16, align 1
%18 = bitcast i8* %add.ptr64.1 to <4 x i8>*
%19 = load <4 x i8>, <4 x i8>* %18, align 1
%20 = bitcast i8* %arrayidx3.2 to <4 x i8>*
%21 = load <4 x i8>, <4 x i8>* %20, align 1
%22 = bitcast i8* %arrayidx5.2 to <4 x i8>*
%23 = load <4 x i8>, <4 x i8>* %22, align 1
%24 = bitcast i8* %add.ptr.2 to <4 x i8>*
%25 = load <4 x i8>, <4 x i8>* %24, align 1
%arrayidx3 = getelementptr inbounds i8, ptr %p1, i64 4
%arrayidx5 = getelementptr inbounds i8, ptr %p2, i64 4
%add.ptr = getelementptr inbounds i8, ptr %p1, i64 %idx.ext
%add.ptr64 = getelementptr inbounds i8, ptr %p2, i64 %idx.ext63
%arrayidx3.1 = getelementptr inbounds i8, ptr %add.ptr, i64 4
%arrayidx5.1 = getelementptr inbounds i8, ptr %add.ptr64, i64 4
%add.ptr.1 = getelementptr inbounds i8, ptr %add.ptr, i64 %idx.ext
%add.ptr64.1 = getelementptr inbounds i8, ptr %add.ptr64, i64 %idx.ext63
%arrayidx3.2 = getelementptr inbounds i8, ptr %add.ptr.1, i64 4
%arrayidx5.2 = getelementptr inbounds i8, ptr %add.ptr64.1, i64 4
%add.ptr.2 = getelementptr inbounds i8, ptr %add.ptr.1, i64 %idx.ext
%add.ptr64.2 = getelementptr inbounds i8, ptr %add.ptr64.1, i64 %idx.ext63
%arrayidx3.3 = getelementptr inbounds i8, ptr %add.ptr.2, i64 4
%arrayidx5.3 = getelementptr inbounds i8, ptr %add.ptr64.2, i64 4
%0 = bitcast ptr %p1 to ptr
%1 = load <4 x i8>, ptr %0, align 1
%2 = bitcast ptr %p2 to ptr
%3 = load <4 x i8>, ptr %2, align 1
%4 = bitcast ptr %arrayidx3 to ptr
%5 = load <4 x i8>, ptr %4, align 1
%6 = bitcast ptr %arrayidx5 to ptr
%7 = load <4 x i8>, ptr %6, align 1
%8 = bitcast ptr %add.ptr to ptr
%9 = load <4 x i8>, ptr %8, align 1
%10 = bitcast ptr %add.ptr64 to ptr
%11 = load <4 x i8>, ptr %10, align 1
%12 = bitcast ptr %arrayidx3.1 to ptr
%13 = load <4 x i8>, ptr %12, align 1
%14 = bitcast ptr %arrayidx5.1 to ptr
%15 = load <4 x i8>, ptr %14, align 1
%16 = bitcast ptr %add.ptr.1 to ptr
%17 = load <4 x i8>, ptr %16, align 1
%18 = bitcast ptr %add.ptr64.1 to ptr
%19 = load <4 x i8>, ptr %18, align 1
%20 = bitcast ptr %arrayidx3.2 to ptr
%21 = load <4 x i8>, ptr %20, align 1
%22 = bitcast ptr %arrayidx5.2 to ptr
%23 = load <4 x i8>, ptr %22, align 1
%24 = bitcast ptr %add.ptr.2 to ptr
%25 = load <4 x i8>, ptr %24, align 1
%26 = shufflevector <4 x i8> %25, <4 x i8> %17, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%27 = shufflevector <4 x i8> %9, <4 x i8> poison, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%28 = shufflevector <16 x i8> %26, <16 x i8> %27, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 16, i32 17, i32 18, i32 19, i32 undef, i32 undef, i32 undef, i32 undef>
%29 = shufflevector <4 x i8> %1, <4 x i8> poison, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%30 = shufflevector <16 x i8> %28, <16 x i8> %29, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 16, i32 17, i32 18, i32 19>
%31 = zext <16 x i8> %30 to <16 x i32>
%32 = bitcast i8* %add.ptr64.2 to <4 x i8>*
%33 = load <4 x i8>, <4 x i8>* %32, align 1
%32 = bitcast ptr %add.ptr64.2 to ptr
%33 = load <4 x i8>, ptr %32, align 1
%34 = shufflevector <4 x i8> %33, <4 x i8> %19, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%35 = shufflevector <4 x i8> %11, <4 x i8> poison, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%36 = shufflevector <16 x i8> %34, <16 x i8> %35, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 16, i32 17, i32 18, i32 19, i32 undef, i32 undef, i32 undef, i32 undef>
%37 = shufflevector <4 x i8> %3, <4 x i8> poison, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%38 = shufflevector <16 x i8> %36, <16 x i8> %37, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 16, i32 17, i32 18, i32 19>
%39 = zext <16 x i8> %38 to <16 x i32>
%40 = sub nsw <16 x i32> %31, %39
%41 = bitcast i8* %arrayidx3.3 to <4 x i8>*
%42 = load <4 x i8>, <4 x i8>* %41, align 1
%41 = bitcast ptr %arrayidx3.3 to ptr
%42 = load <4 x i8>, ptr %41, align 1
%43 = shufflevector <4 x i8> %42, <4 x i8> %21, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%44 = shufflevector <4 x i8> %13, <4 x i8> poison, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%45 = shufflevector <16 x i8> %43, <16 x i8> %44, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 16, i32 17, i32 18, i32 19, i32 undef, i32 undef, i32 undef, i32 undef>
%46 = shufflevector <4 x i8> %5, <4 x i8> poison, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%47 = shufflevector <16 x i8> %45, <16 x i8> %46, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 16, i32 17, i32 18, i32 19>
%48 = zext <16 x i8> %47 to <16 x i32>
%49 = bitcast i8* %arrayidx5.3 to <4 x i8>*
%50 = load <4 x i8>, <4 x i8>* %49, align 1
%49 = bitcast ptr %arrayidx5.3 to ptr
%50 = load <4 x i8>, ptr %49, align 1
%51 = shufflevector <4 x i8> %50, <4 x i8> %23, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%52 = shufflevector <4 x i8> %15, <4 x i8> poison, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%53 = shufflevector <16 x i8> %51, <16 x i8> %52, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 16, i32 17, i32 18, i32 19, i32 undef, i32 undef, i32 undef, i32 undef>
Expand Down
2 changes: 1 addition & 1 deletion llvm/test/Transforms/VectorCombine/X86/load-widening.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -79,7 +79,7 @@ define <3 x float> @vec_with_3elts_underaligned(ptr align 8 dereferenceable(16)

; We don't know we can load 128 bits, but since it's aligned, we still can do wide load.
; FIXME: this should still get widened.
define <3 x float> @vec_with_3elts_underdereferenceable(<3 x float>* align 16 dereferenceable(12) %p) {
define <3 x float> @vec_with_3elts_underdereferenceable(ptr align 16 dereferenceable(12) %p) {
; CHECK-LABEL: @vec_with_3elts_underdereferenceable(
; CHECK-NEXT: [[R:%.*]] = load <3 x float>, ptr [[P:%.*]], align 16
; CHECK-NEXT: ret <3 x float> [[R]]
Expand Down