From c5edcdeb0e4eb20ada6b25a4d6ebd0d9e484ada6 Mon Sep 17 00:00:00 2001 From: Michael Kuperstein Date: Thu, 9 Jun 2016 18:03:15 +0000 Subject: [LV] Use vector phis for some secondary induction variables Previously, we materialized secondary vector IVs from the primary scalar IV, by offseting the primary to match the correct start value, and then broadcasting it - inside the loop body. Instead, we can use a real vector IV, like we do for the primary. This enables using vector IVs for secondary integer IVs whose type matches the type of the primary. Differential Revision: http://reviews.llvm.org/D20932 llvm-svn: 272283 --- llvm/test/Transforms/LoopVectorize/induction.ll | 51 +++++++++++++++++++++- .../Transforms/LoopVectorize/reverse_induction.ll | 14 +++--- 2 files changed, 57 insertions(+), 8 deletions(-) (limited to 'llvm/test/Transforms/LoopVectorize') diff --git a/llvm/test/Transforms/LoopVectorize/induction.ll b/llvm/test/Transforms/LoopVectorize/induction.ll index c2d4d96153a..b193a5b4a85 100644 --- a/llvm/test/Transforms/LoopVectorize/induction.ll +++ b/llvm/test/Transforms/LoopVectorize/induction.ll @@ -174,8 +174,11 @@ loopexit: ; CHECK-LABEL: wrappingindvars1 ; CHECK-LABEL: vector.scevcheck +; CHECK-LABEL: vector.ph +; CHECK: %[[START:.*]] = add <2 x i32> %{{.*}}, ; CHECK-LABEL: vector.body -; CHECK: add <2 x i32> {{%[^ ]*}}, +; CHECK: %[[PHI:.*]] = phi <2 x i32> [ %[[START]], %vector.ph ], [ %[[STEP:.*]], %vector.body ] +; CHECK: %[[STEP]] = add <2 x i32> %[[PHI]], define void @wrappingindvars1(i8 %t, i32 %len, i32 *%A) { entry: %st = zext i8 %t to i16 @@ -209,8 +212,11 @@ define void @wrappingindvars1(i8 %t, i32 %len, i32 *%A) { ; The expression gets converted to ({4 * (zext %t to i32),+,4}). ; CHECK-LABEL: wrappingindvars2 ; CHECK-LABEL: vector.scevcheck +; CHECK-LABEL: vector.ph +; CHECK: %[[START:.*]] = add <2 x i32> %{{.*}}, ; CHECK-LABEL: vector.body -; CHECK: add <2 x i32> {{%[^ ]*}}, +; CHECK: %[[PHI:.*]] = phi <2 x i32> [ %[[START]], %vector.ph ], [ %[[STEP:.*]], %vector.body ] +; CHECK: %[[STEP]] = add <2 x i32> %[[PHI]], define void @wrappingindvars2(i8 %t, i32 %len, i32 *%A) { entry: @@ -302,3 +308,44 @@ for.body: exit: ret void } + +; IND-LABEL: nonprimary +; IND-LABEL: vector.ph +; IND: %[[INSERT:.*]] = insertelement <2 x i32> undef, i32 %i, i32 0 +; IND: %[[SPLAT:.*]] = shufflevector <2 x i32> %[[INSERT]], <2 x i32> undef, <2 x i32> zeroinitializer +; IND: %[[START:.*]] = add <2 x i32> %[[SPLAT]], +; IND-LABEL: vector.body: +; IND: %index = phi i32 [ 0, %vector.ph ], [ %index.next, %vector.body ] +; IND: %vec.ind = phi <2 x i32> [ %[[START]], %vector.ph ], [ %step.add, %vector.body ] +; IND: %step.add = add <2 x i32> %vec.ind, +; IND: %index.next = add i32 %index, 2 +; IND: %[[CMP:.*]] = icmp eq i32 %index.next +; IND: br i1 %[[CMP]] +; UNROLL-LABEL: nonprimary +; UNROLL-LABEL: vector.ph +; UNROLL: %[[INSERT:.*]] = insertelement <2 x i32> undef, i32 %i, i32 0 +; UNROLL: %[[SPLAT:.*]] = shufflevector <2 x i32> %[[INSERT]], <2 x i32> undef, <2 x i32> zeroinitializer +; UNROLL: %[[START:.*]] = add <2 x i32> %[[SPLAT]], +; UNROLL-LABEL: vector.body: +; UNROLL: %index = phi i32 [ 0, %vector.ph ], [ %index.next, %vector.body ] +; UNROLL: %vec.ind = phi <2 x i32> [ %[[START]], %vector.ph ], [ %step.add1, %vector.body ] +; UNROLL: %step.add = add <2 x i32> %vec.ind, +; UNROLL: %step.add1 = add <2 x i32> %vec.ind, +; UNROLL: %index.next = add i32 %index, 4 +; UNROLL: %[[CMP:.*]] = icmp eq i32 %index.next +; UNROLL: br i1 %[[CMP]] +define void @nonprimary(i32* nocapture %a, i32 %start, i32 %i, i32 %k) { +for.body.preheader: + br label %for.body + +for.body: + %indvars.iv = phi i32 [ %indvars.iv.next, %for.body ], [ %i, %for.body.preheader ] + %arrayidx = getelementptr inbounds i32, i32* %a, i32 %indvars.iv + store i32 %indvars.iv, i32* %arrayidx, align 4 + %indvars.iv.next = add nuw nsw i32 %indvars.iv, 42 + %exitcond = icmp eq i32 %indvars.iv.next, %k + br i1 %exitcond, label %exit, label %for.body + +exit: + ret void +} diff --git a/llvm/test/Transforms/LoopVectorize/reverse_induction.ll b/llvm/test/Transforms/LoopVectorize/reverse_induction.ll index 88dd2e4d66c..c19e438bc71 100644 --- a/llvm/test/Transforms/LoopVectorize/reverse_induction.ll +++ b/llvm/test/Transforms/LoopVectorize/reverse_induction.ll @@ -6,8 +6,8 @@ target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f3 ; PR15882 ; CHECK-LABEL: @reverse_induction_i64( -; CHECK: add <4 x i64> %[[SPLAT:.*]], -; CHECK: add <4 x i64> %[[SPLAT]], +; CHECK: %step.add = add <4 x i64> %vec.ind, +; CHECK: %step.add2 = add <4 x i64> %step.add, define i32 @reverse_induction_i64(i64 %startval, i32 * %ptr) { entry: @@ -30,8 +30,8 @@ loopend: } ; CHECK-LABEL: @reverse_induction_i128( -; CHECK: add <4 x i128> %[[SPLAT:.*]], -; CHECK: add <4 x i128> %[[SPLAT]], +; CHECK: %step.add = add <4 x i128> %vec.ind, +; CHECK: %step.add2 = add <4 x i128> %step.add, define i32 @reverse_induction_i128(i128 %startval, i32 * %ptr) { entry: br label %for.body @@ -96,7 +96,8 @@ loopend: ; CHECK-LABEL: @reverse_forward_induction_i64_i8( ; CHECK: vector.body ; CHECK: %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ] -; CHECK: %offset.idx = sub i64 1023, %index +; CHECK: %vec.ind = phi <4 x i64> [ , %vector.ph ] +; CHECK: %step.add = add <4 x i64> %vec.ind, ; CHECK: trunc i64 %index to i8 define void @reverse_forward_induction_i64_i8() { @@ -122,7 +123,8 @@ while.end: ; CHECK-LABEL: @reverse_forward_induction_i64_i8_signed( ; CHECK: vector.body: ; CHECK: %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ] -; CHECK: %offset.idx = sub i64 1023, %index +; CHECK: %vec.ind = phi <4 x i64> [ , %vector.ph ] +; CHECK: %step.add = add <4 x i64> %vec.ind, define void @reverse_forward_induction_i64_i8_signed() { entry: -- cgit v1.2.3