| ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py | |
| ; RUN: opt -O2 -S -mattr=avx < %s | FileCheck %s | |
| ; RUN: opt -passes="default<O2>" -S -mattr=avx < %s | FileCheck %s | |
| target triple = "x86_64--" | |
| target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" | |
| define i32 @ext_ext_or_reduction_v4i32(<4 x i32> %x, <4 x i32> %y) { | |
| ; CHECK-LABEL: @ext_ext_or_reduction_v4i32( | |
| ; CHECK-NEXT: [[Z:%.*]] = and <4 x i32> [[Y:%.*]], [[X:%.*]] | |
| ; CHECK-NEXT: [[TMP1:%.*]] = tail call i32 @llvm.vector.reduce.or.v4i32(<4 x i32> [[Z]]) | |
| ; CHECK-NEXT: ret i32 [[TMP1]] | |
| ; | |
| %z = and <4 x i32> %x, %y | |
| %z0 = extractelement <4 x i32> %z, i32 0 | |
| %z1 = extractelement <4 x i32> %z, i32 1 | |
| %z01 = or i32 %z0, %z1 | |
| %z2 = extractelement <4 x i32> %z, i32 2 | |
| %z012 = or i32 %z01, %z2 | |
| %z3 = extractelement <4 x i32> %z, i32 3 | |
| %z0123 = or i32 %z3, %z012 | |
| ret i32 %z0123 | |
| } | |
| define i32 @ext_ext_partial_add_reduction_v4i32(<4 x i32> %x) { | |
| ; CHECK-LABEL: @ext_ext_partial_add_reduction_v4i32( | |
| ; CHECK-NEXT: [[TMP1:%.*]] = shufflevector <4 x i32> [[X:%.*]], <4 x i32> poison, <3 x i32> <i32 0, i32 1, i32 2> | |
| ; CHECK-NEXT: [[X210:%.*]] = tail call i32 @llvm.vector.reduce.add.v3i32(<3 x i32> [[TMP1]]) | |
| ; CHECK-NEXT: ret i32 [[X210]] | |
| ; | |
| %x0 = extractelement <4 x i32> %x, i32 0 | |
| %x1 = extractelement <4 x i32> %x, i32 1 | |
| %x10 = add i32 %x1, %x0 | |
| %x2 = extractelement <4 x i32> %x, i32 2 | |
| %x210 = add i32 %x2, %x10 | |
| ret i32 %x210 | |
| } | |
| define i32 @ext_ext_partial_add_reduction_and_extra_add_v4i32(<4 x i32> %x, <4 x i32> %y) { | |
| ; CHECK-LABEL: @ext_ext_partial_add_reduction_and_extra_add_v4i32( | |
| ; CHECK-NEXT: [[TMP1:%.*]] = shufflevector <4 x i32> [[Y:%.*]], <4 x i32> [[X:%.*]], <4 x i32> <i32 0, i32 1, i32 2, i32 6> | |
| ; CHECK-NEXT: [[TMP2:%.*]] = tail call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> [[TMP1]]) | |
| ; CHECK-NEXT: ret i32 [[TMP2]] | |
| ; | |
| %y0 = extractelement <4 x i32> %y, i32 0 | |
| %y1 = extractelement <4 x i32> %y, i32 1 | |
| %y10 = add i32 %y1, %y0 | |
| %y2 = extractelement <4 x i32> %y, i32 2 | |
| %y210 = add i32 %y2, %y10 | |
| %x2 = extractelement <4 x i32> %x, i32 2 | |
| %x2y210 = add i32 %x2, %y210 | |
| ret i32 %x2y210 | |
| } | |
| ; PR43953 - https://bugs.llvm.org/show_bug.cgi?id=43953 | |
| ; We want to end up with a single reduction on the next 4 tests. | |
| define i32 @TestVectorsEqual(ptr noalias %Vec0, ptr noalias %Vec1, i32 %Tolerance) { | |
| ; CHECK-LABEL: @TestVectorsEqual( | |
| ; CHECK-NEXT: entry: | |
| ; CHECK-NEXT: [[TMP0:%.*]] = load <4 x i32>, ptr [[VEC0:%.*]], align 4 | |
| ; CHECK-NEXT: [[TMP1:%.*]] = load <4 x i32>, ptr [[VEC1:%.*]], align 4 | |
| ; CHECK-NEXT: [[TMP2:%.*]] = sub nsw <4 x i32> [[TMP0]], [[TMP1]] | |
| ; CHECK-NEXT: [[TMP3:%.*]] = tail call <4 x i32> @llvm.abs.v4i32(<4 x i32> [[TMP2]], i1 true) | |
| ; CHECK-NEXT: [[TMP4:%.*]] = tail call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> [[TMP3]]) | |
| ; CHECK-NEXT: [[CMP5_NOT:%.*]] = icmp sle i32 [[TMP4]], [[TOLERANCE:%.*]] | |
| ; CHECK-NEXT: [[COND6:%.*]] = zext i1 [[CMP5_NOT]] to i32 | |
| ; CHECK-NEXT: ret i32 [[COND6]] | |
| ; | |
| entry: | |
| br label %for.cond | |
| for.cond: | |
| %sum.0 = phi i32 [ 0, %entry ], [ %add, %for.inc ] | |
| %Component.0 = phi i32 [ 0, %entry ], [ %inc, %for.inc ] | |
| %cmp = icmp slt i32 %Component.0, 4 | |
| br i1 %cmp, label %for.body, label %for.cond.cleanup | |
| for.cond.cleanup: | |
| br label %for.end | |
| for.body: | |
| %idxprom = sext i32 %Component.0 to i64 | |
| %arrayidx = getelementptr inbounds i32, ptr %Vec0, i64 %idxprom | |
| %0 = load i32, ptr %arrayidx, align 4 | |
| %idxprom1 = sext i32 %Component.0 to i64 | |
| %arrayidx2 = getelementptr inbounds i32, ptr %Vec1, i64 %idxprom1 | |
| %1 = load i32, ptr %arrayidx2, align 4 | |
| %sub = sub nsw i32 %0, %1 | |
| %cmp3 = icmp sge i32 %sub, 0 | |
| br i1 %cmp3, label %cond.true, label %cond.false | |
| cond.true: | |
| br label %cond.end | |
| cond.false: | |
| %sub4 = sub nsw i32 0, %sub | |
| br label %cond.end | |
| cond.end: | |
| %cond = phi i32 [ %sub, %cond.true ], [ %sub4, %cond.false ] | |
| %add = add nsw i32 %sum.0, %cond | |
| br label %for.inc | |
| for.inc: | |
| %inc = add nsw i32 %Component.0, 1 | |
| br label %for.cond | |
| for.end: | |
| %cmp5 = icmp sle i32 %sum.0, %Tolerance | |
| %2 = zext i1 %cmp5 to i64 | |
| %cond6 = select i1 %cmp5, i32 1, i32 0 | |
| ret i32 %cond6 | |
| } | |
| define i32 @TestVectorsEqual_alt(ptr noalias %Vec0, ptr noalias %Vec1, i32 %Tolerance) { | |
| ; CHECK-LABEL: @TestVectorsEqual_alt( | |
| ; CHECK-NEXT: entry: | |
| ; CHECK-NEXT: [[TMP0:%.*]] = load <4 x i32>, ptr [[VEC0:%.*]], align 4 | |
| ; CHECK-NEXT: [[TMP1:%.*]] = load <4 x i32>, ptr [[VEC1:%.*]], align 4 | |
| ; CHECK-NEXT: [[TMP2:%.*]] = sub <4 x i32> [[TMP0]], [[TMP1]] | |
| ; CHECK-NEXT: [[ADD_3:%.*]] = tail call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> [[TMP2]]) | |
| ; CHECK-NEXT: [[CMP3_NOT:%.*]] = icmp ule i32 [[ADD_3]], [[TOLERANCE:%.*]] | |
| ; CHECK-NEXT: [[COND:%.*]] = zext i1 [[CMP3_NOT]] to i32 | |
| ; CHECK-NEXT: ret i32 [[COND]] | |
| ; | |
| entry: | |
| br label %for.cond | |
| for.cond: | |
| %sum.0 = phi i32 [ 0, %entry ], [ %add, %for.inc ] | |
| %Component.0 = phi i32 [ 0, %entry ], [ %inc, %for.inc ] | |
| %cmp = icmp slt i32 %Component.0, 4 | |
| br i1 %cmp, label %for.body, label %for.cond.cleanup | |
| for.cond.cleanup: | |
| br label %for.end | |
| for.body: | |
| %idxprom = sext i32 %Component.0 to i64 | |
| %arrayidx = getelementptr inbounds i32, ptr %Vec0, i64 %idxprom | |
| %0 = load i32, ptr %arrayidx, align 4 | |
| %idxprom1 = sext i32 %Component.0 to i64 | |
| %arrayidx2 = getelementptr inbounds i32, ptr %Vec1, i64 %idxprom1 | |
| %1 = load i32, ptr %arrayidx2, align 4 | |
| %sub = sub i32 %0, %1 | |
| %add = add i32 %sum.0, %sub | |
| br label %for.inc | |
| for.inc: | |
| %inc = add nsw i32 %Component.0, 1 | |
| br label %for.cond | |
| for.end: | |
| %cmp3 = icmp ule i32 %sum.0, %Tolerance | |
| %2 = zext i1 %cmp3 to i64 | |
| %cond = select i1 %cmp3, i32 1, i32 0 | |
| ret i32 %cond | |
| } | |
| define i32 @TestVectorsEqualFP(ptr noalias %Vec0, ptr noalias %Vec1, float %Tolerance) { | |
| ; CHECK-LABEL: @TestVectorsEqualFP( | |
| ; CHECK-NEXT: entry: | |
| ; CHECK-NEXT: [[TMP0:%.*]] = load <4 x float>, ptr [[VEC0:%.*]], align 4 | |
| ; CHECK-NEXT: [[TMP1:%.*]] = load <4 x float>, ptr [[VEC1:%.*]], align 4 | |
| ; CHECK-NEXT: [[TMP2:%.*]] = fsub fast <4 x float> [[TMP0]], [[TMP1]] | |
| ; CHECK-NEXT: [[TMP3:%.*]] = tail call fast <4 x float> @llvm.fabs.v4f32(<4 x float> [[TMP2]]) | |
| ; CHECK-NEXT: [[TMP4:%.*]] = tail call fast float @llvm.vector.reduce.fadd.v4f32(float 0.000000e+00, <4 x float> [[TMP3]]) | |
| ; CHECK-NEXT: [[CMP4:%.*]] = fcmp fast ole float [[TMP4]], [[TOLERANCE:%.*]] | |
| ; CHECK-NEXT: [[COND5:%.*]] = zext i1 [[CMP4]] to i32 | |
| ; CHECK-NEXT: ret i32 [[COND5]] | |
| ; | |
| entry: | |
| br label %for.cond | |
| for.cond: | |
| %sum.0 = phi float [ 0.000000e+00, %entry ], [ %add, %for.inc ] | |
| %Component.0 = phi i32 [ 0, %entry ], [ %inc, %for.inc ] | |
| %cmp = icmp slt i32 %Component.0, 4 | |
| br i1 %cmp, label %for.body, label %for.cond.cleanup | |
| for.cond.cleanup: | |
| br label %for.end | |
| for.body: | |
| %idxprom = sext i32 %Component.0 to i64 | |
| %arrayidx = getelementptr inbounds float, ptr %Vec0, i64 %idxprom | |
| %0 = load float, ptr %arrayidx, align 4 | |
| %idxprom1 = sext i32 %Component.0 to i64 | |
| %arrayidx2 = getelementptr inbounds float, ptr %Vec1, i64 %idxprom1 | |
| %1 = load float, ptr %arrayidx2, align 4 | |
| %sub = fsub fast float %0, %1 | |
| %cmp3 = fcmp fast oge float %sub, 0.000000e+00 | |
| br i1 %cmp3, label %cond.true, label %cond.false | |
| cond.true: | |
| br label %cond.end | |
| cond.false: | |
| %fneg = fneg fast float %sub | |
| br label %cond.end | |
| cond.end: | |
| %cond = phi fast float [ %sub, %cond.true ], [ %fneg, %cond.false ] | |
| %add = fadd fast float %sum.0, %cond | |
| br label %for.inc | |
| for.inc: | |
| %inc = add nsw i32 %Component.0, 1 | |
| br label %for.cond | |
| for.end: | |
| %cmp4 = fcmp fast ole float %sum.0, %Tolerance | |
| %2 = zext i1 %cmp4 to i64 | |
| %cond5 = select i1 %cmp4, i32 1, i32 0 | |
| ret i32 %cond5 | |
| } | |
| define i32 @TestVectorsEqualFP_alt(ptr noalias %Vec0, ptr noalias %Vec1, float %Tolerance) { | |
| ; CHECK-LABEL: @TestVectorsEqualFP_alt( | |
| ; CHECK-NEXT: entry: | |
| ; CHECK-NEXT: [[TMP0:%.*]] = load <4 x float>, ptr [[VEC0:%.*]], align 4 | |
| ; CHECK-NEXT: [[TMP1:%.*]] = load <4 x float>, ptr [[VEC1:%.*]], align 4 | |
| ; CHECK-NEXT: [[TMP2:%.*]] = fsub fast <4 x float> [[TMP0]], [[TMP1]] | |
| ; CHECK-NEXT: [[TMP3:%.*]] = tail call fast float @llvm.vector.reduce.fadd.v4f32(float 0.000000e+00, <4 x float> [[TMP2]]) | |
| ; CHECK-NEXT: [[CMP3:%.*]] = fcmp fast ole float [[TMP3]], [[TOLERANCE:%.*]] | |
| ; CHECK-NEXT: [[COND:%.*]] = zext i1 [[CMP3]] to i32 | |
| ; CHECK-NEXT: ret i32 [[COND]] | |
| ; | |
| entry: | |
| br label %for.cond | |
| for.cond: | |
| %sum.0 = phi float [ 0.000000e+00, %entry ], [ %add, %for.inc ] | |
| %Component.0 = phi i32 [ 0, %entry ], [ %inc, %for.inc ] | |
| %cmp = icmp slt i32 %Component.0, 4 | |
| br i1 %cmp, label %for.body, label %for.cond.cleanup | |
| for.cond.cleanup: | |
| br label %for.end | |
| for.body: | |
| %idxprom = sext i32 %Component.0 to i64 | |
| %arrayidx = getelementptr inbounds float, ptr %Vec0, i64 %idxprom | |
| %0 = load float, ptr %arrayidx, align 4 | |
| %idxprom1 = sext i32 %Component.0 to i64 | |
| %arrayidx2 = getelementptr inbounds float, ptr %Vec1, i64 %idxprom1 | |
| %1 = load float, ptr %arrayidx2, align 4 | |
| %sub = fsub fast float %0, %1 | |
| %add = fadd fast float %sum.0, %sub | |
| br label %for.inc | |
| for.inc: | |
| %inc = add nsw i32 %Component.0, 1 | |
| br label %for.cond | |
| for.end: | |
| %cmp3 = fcmp fast ole float %sum.0, %Tolerance | |
| %2 = zext i1 %cmp3 to i64 | |
| %cond = select i1 %cmp3, i32 1, i32 0 | |
| ret i32 %cond | |
| } | |
| ; PR43745 - https://bugs.llvm.org/show_bug.cgi?id=43745 | |
| define i1 @cmp_lt_gt(double %a, double %b, double %c) { | |
| ; CHECK-LABEL: @cmp_lt_gt( | |
| ; CHECK-NEXT: entry: | |
| ; CHECK-NEXT: [[FNEG:%.*]] = fneg double [[B:%.*]] | |
| ; CHECK-NEXT: [[MUL:%.*]] = fmul double [[A:%.*]], 2.000000e+00 | |
| ; CHECK-NEXT: [[ADD:%.*]] = fsub double [[C1:%.*]], [[B]] | |
| ; CHECK-NEXT: [[C:%.*]] = fsub double [[FNEG]], [[C1]] | |
| ; CHECK-NEXT: [[TMP2:%.*]] = insertelement <2 x double> poison, double [[ADD]], i64 0 | |
| ; CHECK-NEXT: [[TMP3:%.*]] = insertelement <2 x double> [[TMP2]], double [[C]], i64 1 | |
| ; CHECK-NEXT: [[TMP5:%.*]] = insertelement <2 x double> poison, double [[MUL]], i64 0 | |
| ; CHECK-NEXT: [[TMP6:%.*]] = shufflevector <2 x double> [[TMP5]], <2 x double> poison, <2 x i32> zeroinitializer | |
| ; CHECK-NEXT: [[TMP7:%.*]] = fdiv <2 x double> [[TMP3]], [[TMP6]] | |
| ; CHECK-NEXT: [[TMP8:%.*]] = fcmp uge <2 x double> [[TMP7]], splat (double f0x3EB0C6F7A0B5ED8D) | |
| ; CHECK-NEXT: [[TMP11:%.*]] = bitcast <2 x i1> [[TMP8]] to i2 | |
| ; CHECK-NEXT: [[TMP12:%.*]] = icmp ne i2 [[TMP11]], 0 | |
| ; CHECK-NEXT: [[TMP9:%.*]] = fcmp ule <2 x double> [[TMP7]], splat (double 1.000000e+00) | |
| ; CHECK-NEXT: [[TMP13:%.*]] = bitcast <2 x i1> [[TMP9]] to i2 | |
| ; CHECK-NEXT: [[TMP10:%.*]] = icmp ne i2 [[TMP13]], 0 | |
| ; CHECK-NEXT: [[RETVAL_0:%.*]] = and i1 [[TMP12]], [[TMP10]] | |
| ; CHECK-NEXT: ret i1 [[RETVAL_0]] | |
| ; | |
| entry: | |
| %fneg = fneg double %b | |
| %add = fadd double %fneg, %c | |
| %mul = fmul double 2.0, %a | |
| %div = fdiv double %add, %mul | |
| %fneg1 = fneg double %b | |
| %sub = fsub double %fneg1, %c | |
| %mul2 = fmul double 2.0, %a | |
| %div3 = fdiv double %sub, %mul2 | |
| %cmp = fcmp olt double %div, 0x3EB0C6F7A0B5ED8D | |
| br i1 %cmp, label %land.lhs.true, label %lor.lhs.false | |
| land.lhs.true: | |
| %cmp4 = fcmp olt double %div3, 0x3EB0C6F7A0B5ED8D | |
| br i1 %cmp4, label %if.then, label %lor.lhs.false | |
| lor.lhs.false: | |
| %cmp5 = fcmp ogt double %div, 1.0 | |
| br i1 %cmp5, label %land.lhs.true6, label %if.end | |
| land.lhs.true6: | |
| %cmp7 = fcmp ogt double %div3, 1.0 | |
| br i1 %cmp7, label %if.then, label %if.end | |
| if.then: | |
| br label %cleanup | |
| if.end: | |
| br label %cleanup | |
| cleanup: | |
| %retval.0 = phi i1 [ false, %if.then ], [ true, %if.end ] | |
| ret i1 %retval.0 | |
| } | |
| define i8 @masked_min_reduction(ptr %data, ptr %mask) { | |
| ; CHECK-LABEL: @masked_min_reduction( | |
| ; CHECK-NEXT: entry: | |
| ; CHECK-NEXT: br label [[VECTOR_BODY:%.*]] | |
| ; CHECK: vector.body: | |
| ; CHECK-NEXT: [[INDEX:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ] | |
| ; CHECK-NEXT: [[VEC_PHI:%.*]] = phi <32 x i8> [ splat (i8 -1), [[ENTRY]] ], [ [[TMP16:%.*]], [[VECTOR_BODY]] ] | |
| ; CHECK-NEXT: [[VEC_PHI1:%.*]] = phi <32 x i8> [ splat (i8 -1), [[ENTRY]] ], [ [[TMP17:%.*]], [[VECTOR_BODY]] ] | |
| ; CHECK-NEXT: [[VEC_PHI2:%.*]] = phi <32 x i8> [ splat (i8 -1), [[ENTRY]] ], [ [[TMP18:%.*]], [[VECTOR_BODY]] ] | |
| ; CHECK-NEXT: [[VEC_PHI3:%.*]] = phi <32 x i8> [ splat (i8 -1), [[ENTRY]] ], [ [[TMP19:%.*]], [[VECTOR_BODY]] ] | |
| ; CHECK-NEXT: [[DATA:%.*]] = getelementptr i8, ptr [[DATA1:%.*]], i64 [[INDEX]] | |
| ; CHECK-NEXT: [[TMP1:%.*]] = getelementptr i8, ptr [[DATA]], i64 32 | |
| ; CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[DATA]], i64 64 | |
| ; CHECK-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[DATA]], i64 96 | |
| ; CHECK-NEXT: [[WIDE_LOAD:%.*]] = load <32 x i8>, ptr [[DATA]], align 1 | |
| ; CHECK-NEXT: [[WIDE_LOAD4:%.*]] = load <32 x i8>, ptr [[TMP1]], align 1 | |
| ; CHECK-NEXT: [[WIDE_LOAD5:%.*]] = load <32 x i8>, ptr [[TMP2]], align 1 | |
| ; CHECK-NEXT: [[WIDE_LOAD6:%.*]] = load <32 x i8>, ptr [[TMP3]], align 1 | |
| ; CHECK-NEXT: [[TMP7:%.*]] = getelementptr i8, ptr [[MASK:%.*]], i64 [[INDEX]] | |
| ; CHECK-NEXT: [[TMP5:%.*]] = getelementptr i8, ptr [[TMP7]], i64 32 | |
| ; CHECK-NEXT: [[TMP6:%.*]] = getelementptr i8, ptr [[TMP7]], i64 64 | |
| ; CHECK-NEXT: [[TMP22:%.*]] = getelementptr i8, ptr [[TMP7]], i64 96 | |
| ; CHECK-NEXT: [[WIDE_LOAD7:%.*]] = load <32 x i8>, ptr [[TMP7]], align 1 | |
| ; CHECK-NEXT: [[WIDE_LOAD8:%.*]] = load <32 x i8>, ptr [[TMP5]], align 1 | |
| ; CHECK-NEXT: [[WIDE_LOAD9:%.*]] = load <32 x i8>, ptr [[TMP6]], align 1 | |
| ; CHECK-NEXT: [[WIDE_LOAD10:%.*]] = load <32 x i8>, ptr [[TMP22]], align 1 | |
| ; CHECK-NEXT: [[TMP8:%.*]] = icmp eq <32 x i8> [[WIDE_LOAD7]], zeroinitializer | |
| ; CHECK-NEXT: [[TMP9:%.*]] = icmp eq <32 x i8> [[WIDE_LOAD8]], zeroinitializer | |
| ; CHECK-NEXT: [[TMP10:%.*]] = icmp eq <32 x i8> [[WIDE_LOAD9]], zeroinitializer | |
| ; CHECK-NEXT: [[TMP11:%.*]] = icmp eq <32 x i8> [[WIDE_LOAD10]], zeroinitializer | |
| ; CHECK-NEXT: [[TMP12:%.*]] = select <32 x i1> [[TMP8]], <32 x i8> [[WIDE_LOAD]], <32 x i8> splat (i8 -1) | |
| ; CHECK-NEXT: [[TMP13:%.*]] = select <32 x i1> [[TMP9]], <32 x i8> [[WIDE_LOAD4]], <32 x i8> splat (i8 -1) | |
| ; CHECK-NEXT: [[TMP14:%.*]] = select <32 x i1> [[TMP10]], <32 x i8> [[WIDE_LOAD5]], <32 x i8> splat (i8 -1) | |
| ; CHECK-NEXT: [[TMP15:%.*]] = select <32 x i1> [[TMP11]], <32 x i8> [[WIDE_LOAD6]], <32 x i8> splat (i8 -1) | |
| ; CHECK-NEXT: [[TMP16]] = tail call <32 x i8> @llvm.umin.v32i8(<32 x i8> [[VEC_PHI]], <32 x i8> [[TMP12]]) | |
| ; CHECK-NEXT: [[TMP17]] = tail call <32 x i8> @llvm.umin.v32i8(<32 x i8> [[VEC_PHI1]], <32 x i8> [[TMP13]]) | |
| ; CHECK-NEXT: [[TMP18]] = tail call <32 x i8> @llvm.umin.v32i8(<32 x i8> [[VEC_PHI2]], <32 x i8> [[TMP14]]) | |
| ; CHECK-NEXT: [[TMP19]] = tail call <32 x i8> @llvm.umin.v32i8(<32 x i8> [[VEC_PHI3]], <32 x i8> [[TMP15]]) | |
| ; CHECK-NEXT: [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 128 | |
| ; CHECK-NEXT: [[TMP20:%.*]] = icmp eq i64 [[INDEX_NEXT]], 1024 | |
| ; CHECK-NEXT: br i1 [[TMP20]], label [[EXIT:%.*]], label [[VECTOR_BODY]], !llvm.loop [[LOOP0:![0-9]+]] | |
| ; CHECK: exit: | |
| ; CHECK-NEXT: [[RDX_MINMAX:%.*]] = tail call <32 x i8> @llvm.umin.v32i8(<32 x i8> [[TMP16]], <32 x i8> [[TMP17]]) | |
| ; CHECK-NEXT: [[RDX_MINMAX11:%.*]] = tail call <32 x i8> @llvm.umin.v32i8(<32 x i8> [[RDX_MINMAX]], <32 x i8> [[TMP18]]) | |
| ; CHECK-NEXT: [[RDX_MINMAX12:%.*]] = tail call <32 x i8> @llvm.umin.v32i8(<32 x i8> [[RDX_MINMAX11]], <32 x i8> [[TMP19]]) | |
| ; CHECK-NEXT: [[TMP21:%.*]] = tail call i8 @llvm.vector.reduce.umin.v32i8(<32 x i8> [[RDX_MINMAX12]]) | |
| ; CHECK-NEXT: ret i8 [[TMP21]] | |
| ; | |
| entry: | |
| br label %loop | |
| loop: | |
| %i = phi i64 [ 0, %entry ], [ %next, %loop ] | |
| %acc = phi i8 [ 255, %entry ], [ %acc_next, %loop ] | |
| %ptr_i = getelementptr i8, ptr %data, i64 %i | |
| %val = load i8, ptr %ptr_i, align 1 | |
| %mask_ptr = getelementptr i8, ptr %mask, i64 %i | |
| %m = load i8, ptr %mask_ptr, align 1 | |
| %cond = icmp eq i8 %m, 0 | |
| ; Use select to implement masking | |
| %masked_val = select i1 %cond, i8 %val, i8 255 | |
| ; min reduction | |
| %acc_next = call i8 @llvm.umin.i8(i8 %acc, i8 %masked_val) | |
| %next = add i64 %i, 1 | |
| %cmp = icmp ult i64 %next, 1024 | |
| br i1 %cmp, label %loop, label %exit | |
| exit: | |
| ret i8 %acc_next | |
| } |