mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-29 18:16:06 +00:00
fa8a726672
Update global_alias.ll with the IR after the O1 pipeline. Depending on the O1 makes the tests more fragile and also makes it more difficult to reason about the behavior of the tests, as it doesn't show the IR before LoopVectorize.
702 lines
23 KiB
LLVM
702 lines
23 KiB
LLVM
; RUN: opt -passes='loop-vectorize,dce,instcombine' -force-vector-interleave=1 -force-vector-width=4 -S %s | FileCheck %s
|
|
|
|
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:64:128-a0:0:64-n32-S64"
|
|
|
|
%struct.anon = type { [100 x i32], i32, [100 x i32] }
|
|
%struct.anon.0 = type { [100 x [100 x i32]], i32, [100 x [100 x i32]] }
|
|
|
|
@Foo = common global %struct.anon zeroinitializer, align 4
|
|
@Bar = common global %struct.anon.0 zeroinitializer, align 4
|
|
|
|
@PB = external global ptr
|
|
@PA = external global ptr
|
|
|
|
|
|
;; === First, the tests that should always vectorize, whether statically or by adding run-time checks ===
|
|
|
|
|
|
; /// Different objects, positive induction, constant distance
|
|
; int noAlias01 (int a) {
|
|
; int i;
|
|
; for (i=0; i<SIZE; i++)
|
|
; Foo.A[i] = Foo.B[i] + a;
|
|
; return Foo.A[a];
|
|
; }
|
|
; CHECK-LABEL: define i32 @noAlias01(
|
|
; CHECK: add nsw <4 x i32>
|
|
; CHECK: ret
|
|
|
|
define i32 @noAlias01(i32 %a) nounwind {
|
|
entry:
|
|
br label %for.body
|
|
|
|
for.body: ; preds = %entry, %for.body
|
|
%i.05 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
|
|
%arrayidx = getelementptr inbounds %struct.anon, ptr @Foo, i32 0, i32 2, i32 %i.05
|
|
%0 = load i32, ptr %arrayidx, align 4
|
|
%add = add nsw i32 %0, %a
|
|
%arrayidx1 = getelementptr inbounds [100 x i32], ptr @Foo, i32 0, i32 %i.05
|
|
store i32 %add, ptr %arrayidx1, align 4
|
|
%inc = add nuw nsw i32 %i.05, 1
|
|
%exitcond.not = icmp eq i32 %inc, 100
|
|
br i1 %exitcond.not, label %for.end, label %for.body
|
|
|
|
for.end: ; preds = %for.body
|
|
%arrayidx2 = getelementptr inbounds [100 x i32], ptr @Foo, i32 0, i32 %a
|
|
%1 = load i32, ptr %arrayidx2, align 4
|
|
ret i32 %1
|
|
}
|
|
|
|
; /// Different objects, positive induction with widening slide
|
|
; int noAlias02 (int a) {
|
|
; int i;
|
|
; for (i=0; i<SIZE-10; i++)
|
|
; Foo.A[i] = Foo.B[i+10] + a;
|
|
; return Foo.A[a];
|
|
; }
|
|
; CHECK-LABEL: define i32 @noAlias02(
|
|
; CHECK: add nsw <4 x i32>
|
|
; CHECK: ret
|
|
|
|
define i32 @noAlias02(i32 %a) {
|
|
entry:
|
|
br label %for.body
|
|
|
|
for.body: ; preds = %entry, %for.body
|
|
%i.05 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
|
|
%add = add nuw nsw i32 %i.05, 10
|
|
%arrayidx = getelementptr inbounds %struct.anon, ptr @Foo, i32 0, i32 2, i32 %add
|
|
%0 = load i32, ptr %arrayidx, align 4
|
|
%add1 = add nsw i32 %0, %a
|
|
%arrayidx2 = getelementptr inbounds [100 x i32], ptr @Foo, i32 0, i32 %i.05
|
|
store i32 %add1, ptr %arrayidx2, align 4
|
|
%inc = add nuw nsw i32 %i.05, 1
|
|
%exitcond.not = icmp eq i32 %inc, 90
|
|
br i1 %exitcond.not, label %for.end, label %for.body
|
|
|
|
for.end: ; preds = %for.body
|
|
%arrayidx3 = getelementptr inbounds [100 x i32], ptr @Foo, i32 0, i32 %a
|
|
%1 = load i32, ptr %arrayidx3, align 4
|
|
ret i32 %1
|
|
}
|
|
|
|
; /// Different objects, positive induction with shortening slide
|
|
; int noAlias03 (int a) {
|
|
; int i;
|
|
; for (i=0; i<SIZE; i++)
|
|
; Foo.A[i+10] = Foo.B[i] + a;
|
|
; return Foo.A[a];
|
|
; }
|
|
; CHECK-LABEL: define i32 @noAlias03(
|
|
; CHECK: add nsw <4 x i32>
|
|
; CHECK: ret
|
|
|
|
define i32 @noAlias03(i32 %a) {
|
|
entry:
|
|
br label %for.body
|
|
|
|
for.body: ; preds = %entry, %for.body
|
|
%i.05 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
|
|
%arrayidx = getelementptr inbounds %struct.anon, ptr @Foo, i32 0, i32 2, i32 %i.05
|
|
%0 = load i32, ptr %arrayidx, align 4
|
|
%add = add nsw i32 %0, %a
|
|
%add1 = add nuw nsw i32 %i.05, 10
|
|
%arrayidx2 = getelementptr inbounds [100 x i32], ptr @Foo, i32 0, i32 %add1
|
|
store i32 %add, ptr %arrayidx2, align 4
|
|
%inc = add nuw nsw i32 %i.05, 1
|
|
%exitcond.not = icmp eq i32 %inc, 100
|
|
br i1 %exitcond.not, label %for.end, label %for.body
|
|
|
|
for.end: ; preds = %for.body
|
|
%arrayidx3 = getelementptr inbounds [100 x i32], ptr @Foo, i32 0, i32 %a
|
|
%1 = load i32, ptr %arrayidx3, align 4
|
|
ret i32 %1
|
|
}
|
|
|
|
; /// Pointer access, positive stride, run-time check added
|
|
; int noAlias04 (int a) {
|
|
; int i;
|
|
; for (i=0; i<SIZE; i++)
|
|
; *(PA+i) = *(PB+i) + a;
|
|
; return *(PA+a);
|
|
; }
|
|
; CHECK-LABEL: define i32 @noAlias04(
|
|
; CHECK-NOT: add nsw <4 x i32>
|
|
; CHECK: ret
|
|
;
|
|
; TODO: This test vectorizes (with run-time check) on real targets with -O3)
|
|
; Check why it's not being vectorized even when forcing vectorization
|
|
|
|
define i32 @noAlias04(i32 %a) #0 {
|
|
entry:
|
|
br label %for.body
|
|
|
|
for.body: ; preds = %entry, %for.body
|
|
%i.05 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
|
|
%0 = load ptr, ptr @PB, align 4
|
|
%add.ptr = getelementptr inbounds i32, ptr %0, i32 %i.05
|
|
%1 = load i32, ptr %add.ptr, align 4
|
|
%add = add nsw i32 %1, %a
|
|
%2 = load ptr, ptr @PA, align 4
|
|
%add.ptr1 = getelementptr inbounds i32, ptr %2, i32 %i.05
|
|
store i32 %add, ptr %add.ptr1, align 4
|
|
%inc = add nuw nsw i32 %i.05, 1
|
|
%exitcond.not = icmp eq i32 %inc, 100
|
|
br i1 %exitcond.not, label %for.end, label %for.body
|
|
|
|
for.end: ; preds = %for.body
|
|
%3 = load ptr, ptr @PA, align 4
|
|
%add.ptr2 = getelementptr inbounds i32, ptr %3, i32 %a
|
|
%4 = load i32, ptr %add.ptr2, align 4
|
|
ret i32 %4
|
|
}
|
|
|
|
; /// Different objects, positive induction, multi-array
|
|
; int noAlias05 (int a) {
|
|
; int i, N=10;
|
|
; for (i=0; i<SIZE; i++)
|
|
; Bar.A[N][i] = Bar.B[N][i] + a;
|
|
; return Bar.A[N][a];
|
|
; }
|
|
; CHECK-LABEL: define i32 @noAlias05(
|
|
; CHECK: add nsw <4 x i32>
|
|
; CHECK: ret
|
|
|
|
define i32 @noAlias05(i32 %a) #0 {
|
|
entry:
|
|
br label %for.body
|
|
|
|
for.body: ; preds = %entry, %for.body
|
|
%i.07 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
|
|
%arrayidx1 = getelementptr inbounds %struct.anon.0, ptr @Bar, i32 0, i32 2, i32 10, i32 %i.07
|
|
%0 = load i32, ptr %arrayidx1, align 4
|
|
%add = add nsw i32 %0, %a
|
|
%arrayidx3 = getelementptr inbounds %struct.anon.0, ptr @Bar, i32 0, i32 0, i32 10, i32 %i.07
|
|
store i32 %add, ptr %arrayidx3, align 4
|
|
%inc = add nuw nsw i32 %i.07, 1
|
|
%exitcond.not = icmp eq i32 %inc, 100
|
|
br i1 %exitcond.not, label %for.end, label %for.body
|
|
|
|
for.end: ; preds = %for.body
|
|
%arrayidx5 = getelementptr inbounds %struct.anon.0, ptr @Bar, i32 0, i32 0, i32 10, i32 %a
|
|
%1 = load i32, ptr %arrayidx5, align 4
|
|
ret i32 %1
|
|
}
|
|
|
|
; /// Same objects, positive induction, multi-array, different sub-elements
|
|
; int noAlias06 (int a) {
|
|
; int i, N=10;
|
|
; for (i=0; i<SIZE; i++)
|
|
; Bar.A[N][i] = Bar.A[N+1][i] + a;
|
|
; return Bar.A[N][a];
|
|
; }
|
|
; CHECK-LABEL: define i32 @noAlias06(
|
|
; CHECK: add nsw <4 x i32>
|
|
; CHECK: ret
|
|
|
|
define i32 @noAlias06(i32 %a) #0 {
|
|
entry:
|
|
br label %for.body
|
|
|
|
for.body: ; preds = %entry, %for.body
|
|
%i.07 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
|
|
%arrayidx1 = getelementptr inbounds %struct.anon.0, ptr @Bar, i32 0, i32 0, i32 11, i32 %i.07
|
|
%0 = load i32, ptr %arrayidx1, align 4
|
|
%add2 = add nsw i32 %0, %a
|
|
%arrayidx4 = getelementptr inbounds %struct.anon.0, ptr @Bar, i32 0, i32 0, i32 10, i32 %i.07
|
|
store i32 %add2, ptr %arrayidx4, align 4
|
|
%inc = add nuw nsw i32 %i.07, 1
|
|
%exitcond.not = icmp eq i32 %inc, 100
|
|
br i1 %exitcond.not, label %for.end, label %for.body
|
|
|
|
for.end: ; preds = %for.body
|
|
%arrayidx6 = getelementptr inbounds %struct.anon.0, ptr @Bar, i32 0, i32 0, i32 10, i32 %a
|
|
%1 = load i32, ptr %arrayidx6, align 4
|
|
ret i32 %1
|
|
}
|
|
|
|
; /// Different objects, negative induction, constant distance
|
|
; int noAlias07 (int a) {
|
|
; int i;
|
|
; for (i=0; i<SIZE; i++)
|
|
; Foo.A[SIZE-i-1] = Foo.B[SIZE-i-1] + a;
|
|
; return Foo.A[a];
|
|
; }
|
|
; CHECK-LABEL: define i32 @noAlias07(
|
|
; CHECK: store <4 x i32>
|
|
; CHECK: ret
|
|
define i32 @noAlias07(i32 %a) #0 {
|
|
entry:
|
|
br label %for.body
|
|
|
|
for.body: ; preds = %entry, %for.body
|
|
%i.05 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
|
|
%sub1 = sub nuw nsw i32 99, %i.05
|
|
%arrayidx = getelementptr inbounds %struct.anon, ptr @Foo, i32 0, i32 2, i32 %sub1
|
|
%0 = load i32, ptr %arrayidx, align 4
|
|
%add = add nsw i32 %0, %a
|
|
%arrayidx4 = getelementptr inbounds [100 x i32], ptr @Foo, i32 0, i32 %sub1
|
|
store i32 %add, ptr %arrayidx4, align 4
|
|
%inc = add nuw nsw i32 %i.05, 1
|
|
%exitcond.not = icmp eq i32 %inc, 100
|
|
br i1 %exitcond.not, label %for.end, label %for.body
|
|
|
|
for.end: ; preds = %for.body
|
|
%arrayidx5 = getelementptr inbounds [100 x i32], ptr @Foo, i32 0, i32 %a
|
|
%1 = load i32, ptr %arrayidx5, align 4
|
|
ret i32 %1
|
|
}
|
|
|
|
; /// Different objects, negative induction, shortening slide
|
|
; int noAlias08 (int a) {
|
|
; int i;
|
|
; for (i=0; i<SIZE-10; i++)
|
|
; Foo.A[SIZE-i-1] = Foo.B[SIZE-i-10] + a;
|
|
; return Foo.A[a];
|
|
; }
|
|
; CHECK-LABEL: define i32 @noAlias08(
|
|
; CHECK: load <4 x i32>
|
|
; CHECK: ret
|
|
|
|
define i32 @noAlias08(i32 %a) #0 {
|
|
entry:
|
|
br label %for.body
|
|
|
|
for.body: ; preds = %entry, %for.body
|
|
%i.05 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
|
|
%sub1 = sub nuw nsw i32 90, %i.05
|
|
%arrayidx = getelementptr inbounds %struct.anon, ptr @Foo, i32 0, i32 2, i32 %sub1
|
|
%0 = load i32, ptr %arrayidx, align 4
|
|
%add = add nsw i32 %0, %a
|
|
%sub3 = sub nuw nsw i32 99, %i.05
|
|
%arrayidx4 = getelementptr inbounds [100 x i32], ptr @Foo, i32 0, i32 %sub3
|
|
store i32 %add, ptr %arrayidx4, align 4
|
|
%inc = add nuw nsw i32 %i.05, 1
|
|
%exitcond.not = icmp eq i32 %inc, 90
|
|
br i1 %exitcond.not, label %for.end, label %for.body
|
|
|
|
for.end: ; preds = %for.body
|
|
%arrayidx5 = getelementptr inbounds [100 x i32], ptr @Foo, i32 0, i32 %a
|
|
%1 = load i32, ptr %arrayidx5, align 4
|
|
ret i32 %1
|
|
}
|
|
|
|
; /// Different objects, negative induction, widening slide
|
|
; int noAlias09 (int a) {
|
|
; int i;
|
|
; for (i=0; i<SIZE; i++)
|
|
; Foo.A[SIZE-i-10] = Foo.B[SIZE-i-1] + a;
|
|
; return Foo.A[a];
|
|
; }
|
|
; CHECK-LABEL: define i32 @noAlias09(
|
|
; CHECK: load <4 x i32>
|
|
; CHECK: ret
|
|
|
|
define i32 @noAlias09(i32 %a) #0 {
|
|
entry:
|
|
br label %for.body
|
|
|
|
for.body: ; preds = %entry, %for.body
|
|
%i.05 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
|
|
%sub1 = sub nuw nsw i32 99, %i.05
|
|
%arrayidx = getelementptr inbounds %struct.anon, ptr @Foo, i32 0, i32 2, i32 %sub1
|
|
%0 = load i32, ptr %arrayidx, align 4
|
|
%add = add nsw i32 %0, %a
|
|
%sub3 = sub nsw i32 90, %i.05
|
|
%arrayidx4 = getelementptr inbounds [100 x i32], ptr @Foo, i32 0, i32 %sub3
|
|
store i32 %add, ptr %arrayidx4, align 4
|
|
%inc = add nuw nsw i32 %i.05, 1
|
|
%exitcond.not = icmp eq i32 %inc, 100
|
|
br i1 %exitcond.not, label %for.end, label %for.body
|
|
|
|
for.end: ; preds = %for.body
|
|
%arrayidx5 = getelementptr inbounds [100 x i32], ptr @Foo, i32 0, i32 %a
|
|
%1 = load i32, ptr %arrayidx5, align 4
|
|
ret i32 %1
|
|
}
|
|
|
|
; /// Pointer access, negative stride, run-time check added
|
|
; int noAlias10 (int a) {
|
|
; int i;
|
|
; for (i=0; i<SIZE; i++)
|
|
; *(PA+SIZE-i-1) = *(PB+SIZE-i-1) + a;
|
|
; return *(PA+a);
|
|
; }
|
|
; CHECK-LABEL: define i32 @noAlias10(
|
|
; CHECK-NOT: sub {{.*}} <4 x i32>
|
|
; CHECK: ret
|
|
;
|
|
; TODO: This test vectorizes (with run-time check) on real targets with -O3)
|
|
; Check why it's not being vectorized even when forcing vectorization
|
|
|
|
define i32 @noAlias10(i32 %a) #0 {
|
|
entry:
|
|
br label %for.body
|
|
|
|
for.body: ; preds = %entry, %for.body
|
|
%i.05 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
|
|
%0 = load ptr, ptr @PB, align 4
|
|
%add.ptr = getelementptr inbounds i8, ptr %0, i32 400
|
|
%idx.neg = sub nsw i32 0, %i.05
|
|
%add.ptr1 = getelementptr inbounds i32, ptr %add.ptr, i32 %idx.neg
|
|
%add.ptr2 = getelementptr inbounds i8, ptr %add.ptr1, i32 -4
|
|
%1 = load i32, ptr %add.ptr2, align 4
|
|
%add = add nsw i32 %1, %a
|
|
%2 = load ptr, ptr @PA, align 4
|
|
%add.ptr3 = getelementptr inbounds i8, ptr %2, i32 400
|
|
%add.ptr5 = getelementptr inbounds i32, ptr %add.ptr3, i32 %idx.neg
|
|
%add.ptr6 = getelementptr inbounds i8, ptr %add.ptr5, i32 -4
|
|
store i32 %add, ptr %add.ptr6, align 4
|
|
%inc = add nuw nsw i32 %i.05, 1
|
|
%exitcond.not = icmp eq i32 %inc, 100
|
|
br i1 %exitcond.not, label %for.end, label %for.body
|
|
|
|
for.end: ; preds = %for.body
|
|
%3 = load ptr, ptr @PA, align 4
|
|
%add.ptr7 = getelementptr inbounds i32, ptr %3, i32 %a
|
|
%4 = load i32, ptr %add.ptr7, align 4
|
|
ret i32 %4
|
|
}
|
|
|
|
; /// Different objects, negative induction, multi-array
|
|
; int noAlias11 (int a) {
|
|
; int i, N=10;
|
|
; for (i=0; i<SIZE; i++)
|
|
; Bar.A[N][SIZE-i-1] = Bar.B[N][SIZE-i-1] + a;
|
|
; return Bar.A[N][a];
|
|
; }
|
|
; CHECK-LABEL: define i32 @noAlias11(
|
|
; CHECK: store <4 x i32>
|
|
; CHECK: ret
|
|
|
|
define i32 @noAlias11(i32 %a) #0 {
|
|
entry:
|
|
br label %for.body
|
|
|
|
for.body: ; preds = %entry, %for.body
|
|
%i.07 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
|
|
%sub1 = sub nuw nsw i32 99, %i.07
|
|
%arrayidx2 = getelementptr inbounds %struct.anon.0, ptr @Bar, i32 0, i32 2, i32 10, i32 %sub1
|
|
%0 = load i32, ptr %arrayidx2, align 4
|
|
%add = add nsw i32 %0, %a
|
|
%arrayidx6 = getelementptr inbounds %struct.anon.0, ptr @Bar, i32 0, i32 0, i32 10, i32 %sub1
|
|
store i32 %add, ptr %arrayidx6, align 4
|
|
%inc = add nuw nsw i32 %i.07, 1
|
|
%exitcond.not = icmp eq i32 %inc, 100
|
|
br i1 %exitcond.not, label %for.end, label %for.body
|
|
|
|
for.end: ; preds = %for.body
|
|
%arrayidx8 = getelementptr inbounds %struct.anon.0, ptr @Bar, i32 0, i32 0, i32 10, i32 %a
|
|
%1 = load i32, ptr %arrayidx8, align 4
|
|
ret i32 %1
|
|
}
|
|
|
|
; /// Same objects, negative induction, multi-array, different sub-elements
|
|
; int noAlias12 (int a) {
|
|
; int i, N=10;
|
|
; for (i=0; i<SIZE; i++)
|
|
; Bar.A[N][SIZE-i-1] = Bar.A[N+1][SIZE-i-1] + a;
|
|
; return Bar.A[N][a];
|
|
; }
|
|
; CHECK-LABEL: define i32 @noAlias12(
|
|
; CHECK: store <4 x i32>
|
|
; CHECK: ret
|
|
|
|
define i32 @noAlias12(i32 %a) #0 {
|
|
entry:
|
|
br label %for.body
|
|
|
|
for.body: ; preds = %entry, %for.body
|
|
%i.07 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
|
|
%sub1 = sub nuw nsw i32 99, %i.07
|
|
%arrayidx2 = getelementptr inbounds %struct.anon.0, ptr @Bar, i32 0, i32 0, i32 11, i32 %sub1
|
|
%0 = load i32, ptr %arrayidx2, align 4
|
|
%add3 = add nsw i32 %0, %a
|
|
%arrayidx7 = getelementptr inbounds %struct.anon.0, ptr @Bar, i32 0, i32 0, i32 10, i32 %sub1
|
|
store i32 %add3, ptr %arrayidx7, align 4
|
|
%inc = add nuw nsw i32 %i.07, 1
|
|
%exitcond.not = icmp eq i32 %inc, 100
|
|
br i1 %exitcond.not, label %for.end, label %for.body
|
|
|
|
for.end: ; preds = %for.body
|
|
%arrayidx9 = getelementptr inbounds %struct.anon.0, ptr @Bar, i32 0, i32 0, i32 10, i32 %a
|
|
%1 = load i32, ptr %arrayidx9, align 4
|
|
ret i32 %1
|
|
}
|
|
|
|
; /// Same objects, positive induction, constant distance, just enough for vector size
|
|
; int noAlias13 (int a) {
|
|
; int i;
|
|
; for (i=0; i<SIZE; i++)
|
|
; Foo.A[i] = Foo.A[i+4] + a;
|
|
; return Foo.A[a];
|
|
; }
|
|
; CHECK-LABEL: define i32 @noAlias13(
|
|
; CHECK: add nsw <4 x i32>
|
|
; CHECK: ret
|
|
|
|
define i32 @noAlias13(i32 %a) #0 {
|
|
entry:
|
|
br label %for.body
|
|
|
|
for.body: ; preds = %entry, %for.body
|
|
%i.05 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
|
|
%add = add nuw nsw i32 %i.05, 4
|
|
%arrayidx = getelementptr inbounds [100 x i32], ptr @Foo, i32 0, i32 %add
|
|
%0 = load i32, ptr %arrayidx, align 4
|
|
%add1 = add nsw i32 %0, %a
|
|
%arrayidx2 = getelementptr inbounds [100 x i32], ptr @Foo, i32 0, i32 %i.05
|
|
store i32 %add1, ptr %arrayidx2, align 4
|
|
%inc = add nuw nsw i32 %i.05, 1
|
|
%exitcond.not = icmp eq i32 %inc, 100
|
|
br i1 %exitcond.not, label %for.end, label %for.body
|
|
|
|
for.end: ; preds = %for.body
|
|
%arrayidx3 = getelementptr inbounds [100 x i32], ptr @Foo, i32 0, i32 %a
|
|
%1 = load i32, ptr %arrayidx3, align 4
|
|
ret i32 %1
|
|
}
|
|
|
|
; /// Same objects, negative induction, constant distance, just enough for vector size
|
|
; int noAlias14 (int a) {
|
|
; int i;
|
|
; for (i=0; i<SIZE; i++)
|
|
; Foo.A[SIZE-i-1] = Foo.A[SIZE-i-5] + a;
|
|
; return Foo.A[a];
|
|
; }
|
|
; CHECK-LABEL: define i32 @noAlias14(
|
|
; CHECK: load <4 x i32>
|
|
; CHECK: ret
|
|
|
|
define i32 @noAlias14(i32 %a) #0 {
|
|
entry:
|
|
br label %for.body
|
|
|
|
for.body: ; preds = %entry, %for.body
|
|
%i.05 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
|
|
%sub1 = sub nsw i32 95, %i.05
|
|
%arrayidx = getelementptr inbounds [100 x i32], ptr @Foo, i32 0, i32 %sub1
|
|
%0 = load i32, ptr %arrayidx, align 4
|
|
%add = add nsw i32 %0, %a
|
|
%sub3 = sub nuw nsw i32 99, %i.05
|
|
%arrayidx4 = getelementptr inbounds [100 x i32], ptr @Foo, i32 0, i32 %sub3
|
|
store i32 %add, ptr %arrayidx4, align 4
|
|
%inc = add nuw nsw i32 %i.05, 1
|
|
%exitcond.not = icmp eq i32 %inc, 100
|
|
br i1 %exitcond.not, label %for.end, label %for.body
|
|
|
|
for.end: ; preds = %for.body
|
|
%arrayidx5 = getelementptr inbounds [100 x i32], ptr @Foo, i32 0, i32 %a
|
|
%1 = load i32, ptr %arrayidx5, align 4
|
|
ret i32 %1
|
|
}
|
|
|
|
|
|
;; === Now, the tests that we could vectorize with induction changes or run-time checks ===
|
|
|
|
|
|
; /// Different objects, swapped induction, alias at the end
|
|
; int mayAlias01 (int a) {
|
|
; int i;
|
|
; for (i=0; i<SIZE; i++)
|
|
; Foo.A[i] = Foo.B[SIZE-i-1] + a;
|
|
; return Foo.A[a];
|
|
; }
|
|
; CHECK-LABEL: define i32 @mayAlias01(
|
|
; CHECK-NOT: add nsw <4 x i32>
|
|
; CHECK: ret
|
|
|
|
define i32 @mayAlias01(i32 %a) nounwind {
|
|
entry:
|
|
br label %for.body
|
|
|
|
for.body: ; preds = %entry, %for.body
|
|
%i.05 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
|
|
%sub1 = sub nuw nsw i32 99, %i.05
|
|
%arrayidx = getelementptr inbounds %struct.anon, ptr @Foo, i32 0, i32 2, i32 %sub1
|
|
%0 = load i32, ptr %arrayidx, align 4
|
|
%add = add nsw i32 %0, %a
|
|
%arrayidx2 = getelementptr inbounds [100 x i32], ptr @Foo, i32 0, i32 %i.05
|
|
store i32 %add, ptr %arrayidx2, align 4
|
|
%inc = add nuw nsw i32 %i.05, 1
|
|
%exitcond.not = icmp eq i32 %inc, 100
|
|
br i1 %exitcond.not, label %for.end, label %for.body
|
|
|
|
for.end: ; preds = %for.body
|
|
%arrayidx3 = getelementptr inbounds [100 x i32], ptr @Foo, i32 0, i32 %a
|
|
%1 = load i32, ptr %arrayidx3, align 4
|
|
ret i32 %1
|
|
}
|
|
|
|
; /// Different objects, swapped induction, alias at the beginning
|
|
; int mayAlias02 (int a) {
|
|
; int i;
|
|
; for (i=0; i<SIZE; i++)
|
|
; Foo.A[SIZE-i-1] = Foo.B[i] + a;
|
|
; return Foo.A[a];
|
|
; }
|
|
; CHECK-LABEL: define i32 @mayAlias02(
|
|
; CHECK-NOT: add nsw <4 x i32>
|
|
; CHECK: ret
|
|
|
|
define i32 @mayAlias02(i32 %a) nounwind {
|
|
entry:
|
|
br label %for.body
|
|
|
|
for.body: ; preds = %entry, %for.body
|
|
%i.05 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
|
|
%arrayidx = getelementptr inbounds %struct.anon, ptr @Foo, i32 0, i32 2, i32 %i.05
|
|
%0 = load i32, ptr %arrayidx, align 4
|
|
%add = add nsw i32 %0, %a
|
|
%sub1 = sub nuw nsw i32 99, %i.05
|
|
%arrayidx2 = getelementptr inbounds [100 x i32], ptr @Foo, i32 0, i32 %sub1
|
|
store i32 %add, ptr %arrayidx2, align 4
|
|
%inc = add nuw nsw i32 %i.05, 1
|
|
%exitcond.not = icmp eq i32 %inc, 100
|
|
br i1 %exitcond.not, label %for.end, label %for.body
|
|
|
|
for.end: ; preds = %for.body
|
|
%arrayidx3 = getelementptr inbounds [100 x i32], ptr @Foo, i32 0, i32 %a
|
|
%1 = load i32, ptr %arrayidx3, align 4
|
|
ret i32 %1
|
|
}
|
|
|
|
; /// Pointer access, run-time check added
|
|
; int mayAlias03 (int a) {
|
|
; int i;
|
|
; for (i=0; i<SIZE; i++)
|
|
; *(PA+i) = *(PB+SIZE-i-1) + a;
|
|
; return *(PA+a);
|
|
; }
|
|
; CHECK-LABEL: define i32 @mayAlias03(
|
|
; CHECK-NOT: add nsw <4 x i32>
|
|
; CHECK: ret
|
|
|
|
define i32 @mayAlias03(i32 %a) nounwind {
|
|
entry:
|
|
br label %for.body
|
|
|
|
for.body: ; preds = %entry, %for.body
|
|
%i.05 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
|
|
%0 = load ptr, ptr @PB, align 4
|
|
%add.ptr = getelementptr inbounds i8, ptr %0, i32 400
|
|
%idx.neg = sub nsw i32 0, %i.05
|
|
%add.ptr1 = getelementptr inbounds i32, ptr %add.ptr, i32 %idx.neg
|
|
%add.ptr2 = getelementptr inbounds i8, ptr %add.ptr1, i32 -4
|
|
%1 = load i32, ptr %add.ptr2, align 4
|
|
%add = add nsw i32 %1, %a
|
|
%2 = load ptr, ptr @PA, align 4
|
|
%add.ptr3 = getelementptr inbounds i32, ptr %2, i32 %i.05
|
|
store i32 %add, ptr %add.ptr3, align 4
|
|
%inc = add nuw nsw i32 %i.05, 1
|
|
%exitcond.not = icmp eq i32 %inc, 100
|
|
br i1 %exitcond.not, label %for.end, label %for.body
|
|
|
|
for.end: ; preds = %for.body
|
|
%3 = load ptr, ptr @PA, align 4
|
|
%add.ptr4 = getelementptr inbounds i32, ptr %3, i32 %a
|
|
%4 = load i32, ptr %add.ptr4, align 4
|
|
ret i32 %4
|
|
}
|
|
|
|
;; === Finally, the tests that should only vectorize with care (or if we ignore undefined behaviour at all) ===
|
|
|
|
|
|
; int mustAlias01 (int a) {
|
|
; int i;
|
|
; for (i=0; i<SIZE; i++)
|
|
; Foo.A[i+10] = Foo.B[SIZE-i-1] + a;
|
|
; return Foo.A[a];
|
|
; }
|
|
; CHECK-LABEL: define i32 @mustAlias01(
|
|
; CHECK-NOT: add nsw <4 x i32>
|
|
; CHECK: ret
|
|
|
|
define i32 @mustAlias01(i32 %a) nounwind {
|
|
entry:
|
|
br label %for.body
|
|
|
|
for.body: ; preds = %entry, %for.body
|
|
%i.05 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
|
|
%sub1 = sub nuw nsw i32 99, %i.05
|
|
%arrayidx = getelementptr inbounds %struct.anon, ptr @Foo, i32 0, i32 2, i32 %sub1
|
|
%0 = load i32, ptr %arrayidx, align 4
|
|
%add = add nsw i32 %0, %a
|
|
%add2 = add nuw nsw i32 %i.05, 10
|
|
%arrayidx3 = getelementptr inbounds [100 x i32], ptr @Foo, i32 0, i32 %add2
|
|
store i32 %add, ptr %arrayidx3, align 4
|
|
%inc = add nuw nsw i32 %i.05, 1
|
|
%exitcond.not = icmp eq i32 %inc, 100
|
|
br i1 %exitcond.not, label %for.end, label %for.body
|
|
|
|
for.end: ; preds = %for.body
|
|
%arrayidx4 = getelementptr inbounds [100 x i32], ptr @Foo, i32 0, i32 %a
|
|
%1 = load i32, ptr %arrayidx4, align 4
|
|
ret i32 %1
|
|
}
|
|
|
|
; int mustAlias02 (int a) {
|
|
; int i;
|
|
; for (i=0; i<SIZE; i++)
|
|
; Foo.A[i] = Foo.B[SIZE-i-10] + a;
|
|
; return Foo.A[a];
|
|
; }
|
|
; CHECK-LABEL: define i32 @mustAlias02(
|
|
; CHECK-NOT: add nsw <4 x i32>
|
|
; CHECK: ret
|
|
|
|
define i32 @mustAlias02(i32 %a) nounwind {
|
|
entry:
|
|
br label %for.body
|
|
|
|
for.body: ; preds = %entry, %for.body
|
|
%i.05 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
|
|
%sub1 = sub nsw i32 90, %i.05
|
|
%arrayidx = getelementptr inbounds %struct.anon, ptr @Foo, i32 0, i32 2, i32 %sub1
|
|
%0 = load i32, ptr %arrayidx, align 4
|
|
%add = add nsw i32 %0, %a
|
|
%arrayidx2 = getelementptr inbounds [100 x i32], ptr @Foo, i32 0, i32 %i.05
|
|
store i32 %add, ptr %arrayidx2, align 4
|
|
%inc = add nuw nsw i32 %i.05, 1
|
|
%exitcond.not = icmp eq i32 %inc, 100
|
|
br i1 %exitcond.not, label %for.end, label %for.body
|
|
|
|
for.end: ; preds = %for.body
|
|
%arrayidx3 = getelementptr inbounds [100 x i32], ptr @Foo, i32 0, i32 %a
|
|
%1 = load i32, ptr %arrayidx3, align 4
|
|
ret i32 %1
|
|
}
|
|
|
|
; int mustAlias03 (int a) {
|
|
; int i;
|
|
; for (i=0; i<SIZE; i++)
|
|
; Foo.A[i+10] = Foo.B[SIZE-i-10] + a;
|
|
; return Foo.A[a];
|
|
; }
|
|
; CHECK-LABEL: define i32 @mustAlias03(
|
|
; CHECK-NOT: add nsw <4 x i32>
|
|
; CHECK: ret
|
|
|
|
define i32 @mustAlias03(i32 %a) nounwind {
|
|
entry:
|
|
br label %for.body
|
|
|
|
for.body: ; preds = %entry, %for.body
|
|
%i.05 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
|
|
%sub1 = sub nsw i32 90, %i.05
|
|
%arrayidx = getelementptr inbounds %struct.anon, ptr @Foo, i32 0, i32 2, i32 %sub1
|
|
%0 = load i32, ptr %arrayidx, align 4
|
|
%add = add nsw i32 %0, %a
|
|
%add2 = add nuw nsw i32 %i.05, 10
|
|
%arrayidx3 = getelementptr inbounds [100 x i32], ptr @Foo, i32 0, i32 %add2
|
|
store i32 %add, ptr %arrayidx3, align 4
|
|
%inc = add nuw nsw i32 %i.05, 1
|
|
%exitcond.not = icmp eq i32 %inc, 100
|
|
br i1 %exitcond.not, label %for.end, label %for.body
|
|
|
|
for.end: ; preds = %for.body
|
|
%arrayidx4 = getelementptr inbounds [100 x i32], ptr @Foo, i32 0, i32 %a
|
|
%1 = load i32, ptr %arrayidx4, align 4
|
|
ret i32 %1
|
|
}
|