50b9ca4dda
After https://github.com/llvm/llvm-project/pull/153643, there may be a BranchOnCond with constant condition in the entry block. Simplify those in removeBranchOnConst. This removes a number of redundant conditional branch from entry blocks. In some cases, it may also make the original scalar loop unreachable, because we know it will never execute. In that case, we need to remove the loop from LoopInfo, because all unreachable blocks may dominate each other, making LoopInfo invalid. In those cases, we can also completely remove the loop, for which I'll share a follow-up patch. Depends on https://github.com/llvm/llvm-project/pull/153643. PR: https://github.com/llvm/llvm-project/pull/154510
404 lines
16 KiB
LLVM
404 lines
16 KiB
LLVM
; 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: [[SHIFT:%.*]] = shufflevector <4 x i32> [[X:%.*]], <4 x i32> poison, <4 x i32> <i32 1, i32 poison, i32 poison, i32 poison>
|
|
; CHECK-NEXT: [[TMP1:%.*]] = add <4 x i32> [[SHIFT]], [[X]]
|
|
; CHECK-NEXT: [[SHIFT1:%.*]] = shufflevector <4 x i32> [[X]], <4 x i32> poison, <4 x i32> <i32 2, i32 poison, i32 poison, i32 poison>
|
|
; CHECK-NEXT: [[TMP2:%.*]] = add <4 x i32> [[TMP1]], [[SHIFT1]]
|
|
; CHECK-NEXT: [[X210:%.*]] = extractelement <4 x i32> [[TMP2]], i64 0
|
|
; 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
|
|
|
|
; FIXME: this should be vectorized
|
|
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: [[TMP0:%.*]] = insertelement <2 x double> poison, double [[C:%.*]], i64 0
|
|
; CHECK-NEXT: [[TMP1:%.*]] = insertelement <2 x double> [[TMP0]], double [[FNEG]], i64 1
|
|
; CHECK-NEXT: [[TMP2:%.*]] = insertelement <2 x double> poison, double [[B]], i64 0
|
|
; CHECK-NEXT: [[TMP3:%.*]] = insertelement <2 x double> [[TMP2]], double [[C]], i64 1
|
|
; CHECK-NEXT: [[TMP4:%.*]] = fsub <2 x double> [[TMP1]], [[TMP3]]
|
|
; 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> [[TMP4]], [[TMP6]]
|
|
; CHECK-NEXT: [[TMP8:%.*]] = fcmp olt <2 x double> [[TMP7]], splat (double 0x3EB0C6F7A0B5ED8D)
|
|
; CHECK-NEXT: [[SHIFT:%.*]] = shufflevector <2 x i1> [[TMP8]], <2 x i1> poison, <2 x i32> <i32 1, i32 poison>
|
|
; CHECK-NEXT: [[TMP9:%.*]] = and <2 x i1> [[TMP8]], [[SHIFT]]
|
|
; CHECK-NEXT: [[OR_COND:%.*]] = extractelement <2 x i1> [[TMP9]], i64 0
|
|
; CHECK-NEXT: [[TMP10:%.*]] = fcmp ule <2 x double> [[TMP7]], splat (double 1.000000e+00)
|
|
; CHECK-NEXT: [[SHIFT2:%.*]] = shufflevector <2 x i1> [[TMP10]], <2 x i1> poison, <2 x i32> <i32 1, i32 poison>
|
|
; CHECK-NEXT: [[TMP11:%.*]] = or <2 x i1> [[TMP10]], [[SHIFT2]]
|
|
; CHECK-NEXT: [[OR_COND1_NOT:%.*]] = extractelement <2 x i1> [[TMP11]], i64 0
|
|
; CHECK-NEXT: [[RETVAL_0:%.*]] = select i1 [[OR_COND]], i1 false, i1 [[OR_COND1_NOT]]
|
|
; 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
|
|
}
|