| ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5 |
| ; RUN: opt -passes=loop-vectorize \ |
| ; RUN: -prefer-predicate-over-epilogue=predicate-else-scalar-epilogue \ |
| ; RUN: -mtriple=riscv64 -mattr=+v -S %s | FileCheck %s --check-prefix=IF-EVL |
| |
| ; RUN: opt -passes=loop-vectorize \ |
| ; RUN: -prefer-predicate-over-epilogue=scalar-epilogue \ |
| ; RUN: -mtriple=riscv64 -mattr=+v -S %s | FileCheck %s --check-prefix=NO-VP |
| |
| define void @vp_smax(ptr %a, ptr %b, ptr %c, i64 %N) { |
| ; IF-EVL-LABEL: define void @vp_smax( |
| ; IF-EVL-SAME: ptr [[A:%.*]], ptr [[B:%.*]], ptr [[C:%.*]], i64 [[N:%.*]]) #[[ATTR0:[0-9]+]] { |
| ; IF-EVL-NEXT: [[ENTRY:.*:]] |
| ; IF-EVL-NEXT: [[C3:%.*]] = ptrtoint ptr [[C]] to i64 |
| ; IF-EVL-NEXT: [[B2:%.*]] = ptrtoint ptr [[B]] to i64 |
| ; IF-EVL-NEXT: [[A1:%.*]] = ptrtoint ptr [[A]] to i64 |
| ; IF-EVL-NEXT: br label %[[VECTOR_MEMCHECK:.*]] |
| ; IF-EVL: [[VECTOR_MEMCHECK]]: |
| ; IF-EVL-NEXT: [[TMP4:%.*]] = call i64 @llvm.vscale.i64() |
| ; IF-EVL-NEXT: [[TMP5:%.*]] = mul nuw i64 [[TMP4]], 4 |
| ; IF-EVL-NEXT: [[TMP23:%.*]] = mul i64 [[TMP5]], 4 |
| ; IF-EVL-NEXT: [[TMP24:%.*]] = sub i64 [[A1]], [[B2]] |
| ; IF-EVL-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP24]], [[TMP23]] |
| ; IF-EVL-NEXT: [[TMP25:%.*]] = mul i64 [[TMP5]], 4 |
| ; IF-EVL-NEXT: [[TMP26:%.*]] = sub i64 [[A1]], [[C3]] |
| ; IF-EVL-NEXT: [[DIFF_CHECK4:%.*]] = icmp ult i64 [[TMP26]], [[TMP25]] |
| ; IF-EVL-NEXT: [[CONFLICT_RDX:%.*]] = or i1 [[DIFF_CHECK]], [[DIFF_CHECK4]] |
| ; IF-EVL-NEXT: br i1 [[CONFLICT_RDX]], label %[[SCALAR_PH:.*]], label %[[VECTOR_PH:.*]] |
| ; IF-EVL: [[VECTOR_PH]]: |
| ; IF-EVL-NEXT: br label %[[VECTOR_BODY:.*]] |
| ; IF-EVL: [[VECTOR_BODY]]: |
| ; IF-EVL-NEXT: [[EVL_BASED_IV:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_EVL_NEXT:%.*]], %[[VECTOR_BODY]] ] |
| ; IF-EVL-NEXT: [[AVL:%.*]] = phi i64 [ [[N]], %[[VECTOR_PH]] ], [ [[AVL_NEXT:%.*]], %[[VECTOR_BODY]] ] |
| ; IF-EVL-NEXT: [[TMP9:%.*]] = call i32 @llvm.experimental.get.vector.length.i64(i64 [[AVL]], i32 4, i1 true) |
| ; IF-EVL-NEXT: [[TMP11:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: [[VP_OP_LOAD:%.*]] = call <vscale x 4 x i32> @llvm.vp.load.nxv4i32.p0(ptr align 4 [[TMP11]], <vscale x 4 x i1> splat (i1 true), i32 [[TMP9]]) |
| ; IF-EVL-NEXT: [[TMP13:%.*]] = getelementptr inbounds i32, ptr [[C]], i64 [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: [[VP_OP_LOAD5:%.*]] = call <vscale x 4 x i32> @llvm.vp.load.nxv4i32.p0(ptr align 4 [[TMP13]], <vscale x 4 x i1> splat (i1 true), i32 [[TMP9]]) |
| ; IF-EVL-NEXT: [[TMP29:%.*]] = call <vscale x 4 x i32> @llvm.smax.nxv4i32(<vscale x 4 x i32> [[VP_OP_LOAD]], <vscale x 4 x i32> [[VP_OP_LOAD5]]) |
| ; IF-EVL-NEXT: [[TMP16:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: call void @llvm.vp.store.nxv4i32.p0(<vscale x 4 x i32> [[TMP29]], ptr align 4 [[TMP16]], <vscale x 4 x i1> splat (i1 true), i32 [[TMP9]]) |
| ; IF-EVL-NEXT: [[TMP18:%.*]] = zext i32 [[TMP9]] to i64 |
| ; IF-EVL-NEXT: [[INDEX_EVL_NEXT]] = add i64 [[TMP18]], [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: [[AVL_NEXT]] = sub nuw i64 [[AVL]], [[TMP18]] |
| ; IF-EVL-NEXT: [[TMP17:%.*]] = icmp eq i64 [[AVL_NEXT]], 0 |
| ; IF-EVL-NEXT: br i1 [[TMP17]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP0:![0-9]+]] |
| ; IF-EVL: [[MIDDLE_BLOCK]]: |
| ; IF-EVL-NEXT: br label %[[EXIT:.*]] |
| ; IF-EVL: [[SCALAR_PH]]: |
| ; IF-EVL-NEXT: br label %[[LOOP:.*]] |
| ; IF-EVL: [[LOOP]]: |
| ; IF-EVL-NEXT: [[IV:%.*]] = phi i64 [ [[IV_NEXT:%.*]], %[[LOOP]] ], [ 0, %[[SCALAR_PH]] ] |
| ; IF-EVL-NEXT: [[GEP:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[IV]] |
| ; IF-EVL-NEXT: [[TMP20:%.*]] = load i32, ptr [[GEP]], align 4 |
| ; IF-EVL-NEXT: [[GEP3:%.*]] = getelementptr inbounds i32, ptr [[C]], i64 [[IV]] |
| ; IF-EVL-NEXT: [[TMP21:%.*]] = load i32, ptr [[GEP3]], align 4 |
| ; IF-EVL-NEXT: [[DOT:%.*]] = tail call i32 @llvm.smax.i32(i32 [[TMP20]], i32 [[TMP21]]) |
| ; IF-EVL-NEXT: [[GEP11:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[IV]] |
| ; IF-EVL-NEXT: store i32 [[DOT]], ptr [[GEP11]], align 4 |
| ; IF-EVL-NEXT: [[IV_NEXT]] = add nuw nsw i64 [[IV]], 1 |
| ; IF-EVL-NEXT: [[EXITCOND_NOT:%.*]] = icmp eq i64 [[IV_NEXT]], [[N]] |
| ; IF-EVL-NEXT: br i1 [[EXITCOND_NOT]], label %[[EXIT]], label %[[LOOP]], !llvm.loop [[LOOP3:![0-9]+]] |
| ; IF-EVL: [[EXIT]]: |
| ; IF-EVL-NEXT: ret void |
| ; |
| ; NO-VP-LABEL: define void @vp_smax( |
| ; NO-VP-SAME: ptr [[A:%.*]], ptr [[B:%.*]], ptr [[C:%.*]], i64 [[N:%.*]]) #[[ATTR0:[0-9]+]] { |
| ; NO-VP-NEXT: [[ENTRY:.*]]: |
| ; NO-VP-NEXT: [[C3:%.*]] = ptrtoint ptr [[C]] to i64 |
| ; NO-VP-NEXT: [[B2:%.*]] = ptrtoint ptr [[B]] to i64 |
| ; NO-VP-NEXT: [[A1:%.*]] = ptrtoint ptr [[A]] to i64 |
| ; NO-VP-NEXT: [[TMP12:%.*]] = call i64 @llvm.vscale.i64() |
| ; NO-VP-NEXT: [[TMP11:%.*]] = shl nuw i64 [[TMP12]], 2 |
| ; NO-VP-NEXT: [[TMP2:%.*]] = call i64 @llvm.umax.i64(i64 [[TMP11]], i64 16) |
| ; NO-VP-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[N]], [[TMP2]] |
| ; NO-VP-NEXT: br i1 [[MIN_ITERS_CHECK]], label %[[SCALAR_PH:.*]], label %[[VECTOR_MEMCHECK:.*]] |
| ; NO-VP: [[VECTOR_MEMCHECK]]: |
| ; NO-VP-NEXT: [[TMP3:%.*]] = call i64 @llvm.vscale.i64() |
| ; NO-VP-NEXT: [[TMP4:%.*]] = mul nuw i64 [[TMP3]], 4 |
| ; NO-VP-NEXT: [[TMP5:%.*]] = mul i64 [[TMP4]], 4 |
| ; NO-VP-NEXT: [[TMP6:%.*]] = sub i64 [[A1]], [[B2]] |
| ; NO-VP-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP6]], [[TMP5]] |
| ; NO-VP-NEXT: [[TMP7:%.*]] = mul i64 [[TMP4]], 4 |
| ; NO-VP-NEXT: [[TMP8:%.*]] = sub i64 [[A1]], [[C3]] |
| ; NO-VP-NEXT: [[DIFF_CHECK4:%.*]] = icmp ult i64 [[TMP8]], [[TMP7]] |
| ; NO-VP-NEXT: [[CONFLICT_RDX:%.*]] = or i1 [[DIFF_CHECK]], [[DIFF_CHECK4]] |
| ; NO-VP-NEXT: br i1 [[CONFLICT_RDX]], label %[[SCALAR_PH]], label %[[VECTOR_PH:.*]] |
| ; NO-VP: [[VECTOR_PH]]: |
| ; NO-VP-NEXT: [[TMP9:%.*]] = call i64 @llvm.vscale.i64() |
| ; NO-VP-NEXT: [[TMP10:%.*]] = mul nuw i64 [[TMP9]], 4 |
| ; NO-VP-NEXT: [[N_MOD_VF:%.*]] = urem i64 [[N]], [[TMP10]] |
| ; NO-VP-NEXT: [[N_VEC:%.*]] = sub i64 [[N]], [[N_MOD_VF]] |
| ; NO-VP-NEXT: br label %[[VECTOR_BODY:.*]] |
| ; NO-VP: [[VECTOR_BODY]]: |
| ; NO-VP-NEXT: [[INDEX:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ] |
| ; NO-VP-NEXT: [[TMP13:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[INDEX]] |
| ; NO-VP-NEXT: [[WIDE_LOAD:%.*]] = load <vscale x 4 x i32>, ptr [[TMP13]], align 4 |
| ; NO-VP-NEXT: [[TMP14:%.*]] = getelementptr inbounds i32, ptr [[C]], i64 [[INDEX]] |
| ; NO-VP-NEXT: [[WIDE_LOAD5:%.*]] = load <vscale x 4 x i32>, ptr [[TMP14]], align 4 |
| ; NO-VP-NEXT: [[TMP15:%.*]] = call <vscale x 4 x i32> @llvm.smax.nxv4i32(<vscale x 4 x i32> [[WIDE_LOAD]], <vscale x 4 x i32> [[WIDE_LOAD5]]) |
| ; NO-VP-NEXT: [[TMP16:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[INDEX]] |
| ; NO-VP-NEXT: store <vscale x 4 x i32> [[TMP15]], ptr [[TMP16]], align 4 |
| ; NO-VP-NEXT: [[INDEX_NEXT]] = add nuw i64 [[INDEX]], [[TMP10]] |
| ; NO-VP-NEXT: [[TMP17:%.*]] = icmp eq i64 [[INDEX_NEXT]], [[N_VEC]] |
| ; NO-VP-NEXT: br i1 [[TMP17]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP0:![0-9]+]] |
| ; NO-VP: [[MIDDLE_BLOCK]]: |
| ; NO-VP-NEXT: [[CMP_N:%.*]] = icmp eq i64 [[N]], [[N_VEC]] |
| ; NO-VP-NEXT: br i1 [[CMP_N]], label %[[EXIT:.*]], label %[[SCALAR_PH]] |
| ; NO-VP: [[SCALAR_PH]]: |
| ; NO-VP-NEXT: [[BC_RESUME_VAL:%.*]] = phi i64 [ [[N_VEC]], %[[MIDDLE_BLOCK]] ], [ 0, %[[ENTRY]] ], [ 0, %[[VECTOR_MEMCHECK]] ] |
| ; NO-VP-NEXT: br label %[[LOOP:.*]] |
| ; NO-VP: [[LOOP]]: |
| ; NO-VP-NEXT: [[IV:%.*]] = phi i64 [ [[IV_NEXT:%.*]], %[[LOOP]] ], [ [[BC_RESUME_VAL]], %[[SCALAR_PH]] ] |
| ; NO-VP-NEXT: [[GEP:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[IV]] |
| ; NO-VP-NEXT: [[TMP0:%.*]] = load i32, ptr [[GEP]], align 4 |
| ; NO-VP-NEXT: [[GEP3:%.*]] = getelementptr inbounds i32, ptr [[C]], i64 [[IV]] |
| ; NO-VP-NEXT: [[TMP1:%.*]] = load i32, ptr [[GEP3]], align 4 |
| ; NO-VP-NEXT: [[DOT:%.*]] = tail call i32 @llvm.smax.i32(i32 [[TMP0]], i32 [[TMP1]]) |
| ; NO-VP-NEXT: [[GEP11:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[IV]] |
| ; NO-VP-NEXT: store i32 [[DOT]], ptr [[GEP11]], align 4 |
| ; NO-VP-NEXT: [[IV_NEXT]] = add nuw nsw i64 [[IV]], 1 |
| ; NO-VP-NEXT: [[EXITCOND_NOT:%.*]] = icmp eq i64 [[IV_NEXT]], [[N]] |
| ; NO-VP-NEXT: br i1 [[EXITCOND_NOT]], label %[[EXIT]], label %[[LOOP]], !llvm.loop [[LOOP3:![0-9]+]] |
| ; NO-VP: [[EXIT]]: |
| ; NO-VP-NEXT: ret void |
| ; |
| |
| entry: |
| br label %loop |
| |
| loop: |
| %iv = phi i64 [ %iv.next, %loop ], [ 0, %entry ] |
| %gep = getelementptr inbounds i32, ptr %b, i64 %iv |
| %0 = load i32, ptr %gep, align 4 |
| %gep3 = getelementptr inbounds i32, ptr %c, i64 %iv |
| %1 = load i32, ptr %gep3, align 4 |
| %. = tail call i32 @llvm.smax.i32(i32 %0, i32 %1) |
| %gep11 = getelementptr inbounds i32, ptr %a, i64 %iv |
| store i32 %., ptr %gep11, align 4 |
| %iv.next = add nuw nsw i64 %iv, 1 |
| %exitcond.not = icmp eq i64 %iv.next, %N |
| br i1 %exitcond.not, label %exit, label %loop |
| |
| exit: |
| ret void |
| } |
| |
| define void @vp_smin(ptr %a, ptr %b, ptr %c, i64 %N) { |
| ; IF-EVL-LABEL: define void @vp_smin( |
| ; IF-EVL-SAME: ptr [[A:%.*]], ptr [[B:%.*]], ptr [[C:%.*]], i64 [[N:%.*]]) #[[ATTR0]] { |
| ; IF-EVL-NEXT: [[ENTRY:.*:]] |
| ; IF-EVL-NEXT: [[C3:%.*]] = ptrtoint ptr [[C]] to i64 |
| ; IF-EVL-NEXT: [[B2:%.*]] = ptrtoint ptr [[B]] to i64 |
| ; IF-EVL-NEXT: [[A1:%.*]] = ptrtoint ptr [[A]] to i64 |
| ; IF-EVL-NEXT: br label %[[VECTOR_MEMCHECK:.*]] |
| ; IF-EVL: [[VECTOR_MEMCHECK]]: |
| ; IF-EVL-NEXT: [[TMP4:%.*]] = call i64 @llvm.vscale.i64() |
| ; IF-EVL-NEXT: [[TMP5:%.*]] = mul nuw i64 [[TMP4]], 4 |
| ; IF-EVL-NEXT: [[TMP23:%.*]] = mul i64 [[TMP5]], 4 |
| ; IF-EVL-NEXT: [[TMP24:%.*]] = sub i64 [[A1]], [[B2]] |
| ; IF-EVL-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP24]], [[TMP23]] |
| ; IF-EVL-NEXT: [[TMP25:%.*]] = mul i64 [[TMP5]], 4 |
| ; IF-EVL-NEXT: [[TMP26:%.*]] = sub i64 [[A1]], [[C3]] |
| ; IF-EVL-NEXT: [[DIFF_CHECK4:%.*]] = icmp ult i64 [[TMP26]], [[TMP25]] |
| ; IF-EVL-NEXT: [[CONFLICT_RDX:%.*]] = or i1 [[DIFF_CHECK]], [[DIFF_CHECK4]] |
| ; IF-EVL-NEXT: br i1 [[CONFLICT_RDX]], label %[[SCALAR_PH:.*]], label %[[VECTOR_PH:.*]] |
| ; IF-EVL: [[VECTOR_PH]]: |
| ; IF-EVL-NEXT: br label %[[VECTOR_BODY:.*]] |
| ; IF-EVL: [[VECTOR_BODY]]: |
| ; IF-EVL-NEXT: [[EVL_BASED_IV:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_EVL_NEXT:%.*]], %[[VECTOR_BODY]] ] |
| ; IF-EVL-NEXT: [[AVL:%.*]] = phi i64 [ [[N]], %[[VECTOR_PH]] ], [ [[AVL_NEXT:%.*]], %[[VECTOR_BODY]] ] |
| ; IF-EVL-NEXT: [[TMP9:%.*]] = call i32 @llvm.experimental.get.vector.length.i64(i64 [[AVL]], i32 4, i1 true) |
| ; IF-EVL-NEXT: [[TMP11:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: [[VP_OP_LOAD:%.*]] = call <vscale x 4 x i32> @llvm.vp.load.nxv4i32.p0(ptr align 4 [[TMP11]], <vscale x 4 x i1> splat (i1 true), i32 [[TMP9]]) |
| ; IF-EVL-NEXT: [[TMP13:%.*]] = getelementptr inbounds i32, ptr [[C]], i64 [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: [[VP_OP_LOAD5:%.*]] = call <vscale x 4 x i32> @llvm.vp.load.nxv4i32.p0(ptr align 4 [[TMP13]], <vscale x 4 x i1> splat (i1 true), i32 [[TMP9]]) |
| ; IF-EVL-NEXT: [[TMP29:%.*]] = call <vscale x 4 x i32> @llvm.smin.nxv4i32(<vscale x 4 x i32> [[VP_OP_LOAD]], <vscale x 4 x i32> [[VP_OP_LOAD5]]) |
| ; IF-EVL-NEXT: [[TMP16:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: call void @llvm.vp.store.nxv4i32.p0(<vscale x 4 x i32> [[TMP29]], ptr align 4 [[TMP16]], <vscale x 4 x i1> splat (i1 true), i32 [[TMP9]]) |
| ; IF-EVL-NEXT: [[TMP18:%.*]] = zext i32 [[TMP9]] to i64 |
| ; IF-EVL-NEXT: [[INDEX_EVL_NEXT]] = add i64 [[TMP18]], [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: [[AVL_NEXT]] = sub nuw i64 [[AVL]], [[TMP18]] |
| ; IF-EVL-NEXT: [[TMP17:%.*]] = icmp eq i64 [[AVL_NEXT]], 0 |
| ; IF-EVL-NEXT: br i1 [[TMP17]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP4:![0-9]+]] |
| ; IF-EVL: [[MIDDLE_BLOCK]]: |
| ; IF-EVL-NEXT: br label %[[EXIT:.*]] |
| ; IF-EVL: [[SCALAR_PH]]: |
| ; IF-EVL-NEXT: br label %[[LOOP:.*]] |
| ; IF-EVL: [[LOOP]]: |
| ; IF-EVL-NEXT: [[IV:%.*]] = phi i64 [ [[IV_NEXT:%.*]], %[[LOOP]] ], [ 0, %[[SCALAR_PH]] ] |
| ; IF-EVL-NEXT: [[GEP:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[IV]] |
| ; IF-EVL-NEXT: [[TMP20:%.*]] = load i32, ptr [[GEP]], align 4 |
| ; IF-EVL-NEXT: [[GEP3:%.*]] = getelementptr inbounds i32, ptr [[C]], i64 [[IV]] |
| ; IF-EVL-NEXT: [[TMP21:%.*]] = load i32, ptr [[GEP3]], align 4 |
| ; IF-EVL-NEXT: [[DOT:%.*]] = tail call i32 @llvm.smin.i32(i32 [[TMP20]], i32 [[TMP21]]) |
| ; IF-EVL-NEXT: [[GEP11:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[IV]] |
| ; IF-EVL-NEXT: store i32 [[DOT]], ptr [[GEP11]], align 4 |
| ; IF-EVL-NEXT: [[IV_NEXT]] = add nuw nsw i64 [[IV]], 1 |
| ; IF-EVL-NEXT: [[EXITCOND_NOT:%.*]] = icmp eq i64 [[IV_NEXT]], [[N]] |
| ; IF-EVL-NEXT: br i1 [[EXITCOND_NOT]], label %[[EXIT]], label %[[LOOP]], !llvm.loop [[LOOP5:![0-9]+]] |
| ; IF-EVL: [[EXIT]]: |
| ; IF-EVL-NEXT: ret void |
| ; |
| ; NO-VP-LABEL: define void @vp_smin( |
| ; NO-VP-SAME: ptr [[A:%.*]], ptr [[B:%.*]], ptr [[C:%.*]], i64 [[N:%.*]]) #[[ATTR0]] { |
| ; NO-VP-NEXT: [[ENTRY:.*]]: |
| ; NO-VP-NEXT: [[C3:%.*]] = ptrtoint ptr [[C]] to i64 |
| ; NO-VP-NEXT: [[B2:%.*]] = ptrtoint ptr [[B]] to i64 |
| ; NO-VP-NEXT: [[A1:%.*]] = ptrtoint ptr [[A]] to i64 |
| ; NO-VP-NEXT: [[TMP12:%.*]] = call i64 @llvm.vscale.i64() |
| ; NO-VP-NEXT: [[TMP11:%.*]] = shl nuw i64 [[TMP12]], 2 |
| ; NO-VP-NEXT: [[TMP2:%.*]] = call i64 @llvm.umax.i64(i64 [[TMP11]], i64 16) |
| ; NO-VP-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[N]], [[TMP2]] |
| ; NO-VP-NEXT: br i1 [[MIN_ITERS_CHECK]], label %[[SCALAR_PH:.*]], label %[[VECTOR_MEMCHECK:.*]] |
| ; NO-VP: [[VECTOR_MEMCHECK]]: |
| ; NO-VP-NEXT: [[TMP3:%.*]] = call i64 @llvm.vscale.i64() |
| ; NO-VP-NEXT: [[TMP4:%.*]] = mul nuw i64 [[TMP3]], 4 |
| ; NO-VP-NEXT: [[TMP5:%.*]] = mul i64 [[TMP4]], 4 |
| ; NO-VP-NEXT: [[TMP6:%.*]] = sub i64 [[A1]], [[B2]] |
| ; NO-VP-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP6]], [[TMP5]] |
| ; NO-VP-NEXT: [[TMP7:%.*]] = mul i64 [[TMP4]], 4 |
| ; NO-VP-NEXT: [[TMP8:%.*]] = sub i64 [[A1]], [[C3]] |
| ; NO-VP-NEXT: [[DIFF_CHECK4:%.*]] = icmp ult i64 [[TMP8]], [[TMP7]] |
| ; NO-VP-NEXT: [[CONFLICT_RDX:%.*]] = or i1 [[DIFF_CHECK]], [[DIFF_CHECK4]] |
| ; NO-VP-NEXT: br i1 [[CONFLICT_RDX]], label %[[SCALAR_PH]], label %[[VECTOR_PH:.*]] |
| ; NO-VP: [[VECTOR_PH]]: |
| ; NO-VP-NEXT: [[TMP9:%.*]] = call i64 @llvm.vscale.i64() |
| ; NO-VP-NEXT: [[TMP10:%.*]] = mul nuw i64 [[TMP9]], 4 |
| ; NO-VP-NEXT: [[N_MOD_VF:%.*]] = urem i64 [[N]], [[TMP10]] |
| ; NO-VP-NEXT: [[N_VEC:%.*]] = sub i64 [[N]], [[N_MOD_VF]] |
| ; NO-VP-NEXT: br label %[[VECTOR_BODY:.*]] |
| ; NO-VP: [[VECTOR_BODY]]: |
| ; NO-VP-NEXT: [[INDEX:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ] |
| ; NO-VP-NEXT: [[TMP13:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[INDEX]] |
| ; NO-VP-NEXT: [[WIDE_LOAD:%.*]] = load <vscale x 4 x i32>, ptr [[TMP13]], align 4 |
| ; NO-VP-NEXT: [[TMP14:%.*]] = getelementptr inbounds i32, ptr [[C]], i64 [[INDEX]] |
| ; NO-VP-NEXT: [[WIDE_LOAD5:%.*]] = load <vscale x 4 x i32>, ptr [[TMP14]], align 4 |
| ; NO-VP-NEXT: [[TMP15:%.*]] = call <vscale x 4 x i32> @llvm.smin.nxv4i32(<vscale x 4 x i32> [[WIDE_LOAD]], <vscale x 4 x i32> [[WIDE_LOAD5]]) |
| ; NO-VP-NEXT: [[TMP16:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[INDEX]] |
| ; NO-VP-NEXT: store <vscale x 4 x i32> [[TMP15]], ptr [[TMP16]], align 4 |
| ; NO-VP-NEXT: [[INDEX_NEXT]] = add nuw i64 [[INDEX]], [[TMP10]] |
| ; NO-VP-NEXT: [[TMP17:%.*]] = icmp eq i64 [[INDEX_NEXT]], [[N_VEC]] |
| ; NO-VP-NEXT: br i1 [[TMP17]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP4:![0-9]+]] |
| ; NO-VP: [[MIDDLE_BLOCK]]: |
| ; NO-VP-NEXT: [[CMP_N:%.*]] = icmp eq i64 [[N]], [[N_VEC]] |
| ; NO-VP-NEXT: br i1 [[CMP_N]], label %[[EXIT:.*]], label %[[SCALAR_PH]] |
| ; NO-VP: [[SCALAR_PH]]: |
| ; NO-VP-NEXT: [[BC_RESUME_VAL:%.*]] = phi i64 [ [[N_VEC]], %[[MIDDLE_BLOCK]] ], [ 0, %[[ENTRY]] ], [ 0, %[[VECTOR_MEMCHECK]] ] |
| ; NO-VP-NEXT: br label %[[LOOP:.*]] |
| ; NO-VP: [[LOOP]]: |
| ; NO-VP-NEXT: [[IV:%.*]] = phi i64 [ [[IV_NEXT:%.*]], %[[LOOP]] ], [ [[BC_RESUME_VAL]], %[[SCALAR_PH]] ] |
| ; NO-VP-NEXT: [[GEP:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[IV]] |
| ; NO-VP-NEXT: [[TMP0:%.*]] = load i32, ptr [[GEP]], align 4 |
| ; NO-VP-NEXT: [[GEP3:%.*]] = getelementptr inbounds i32, ptr [[C]], i64 [[IV]] |
| ; NO-VP-NEXT: [[TMP1:%.*]] = load i32, ptr [[GEP3]], align 4 |
| ; NO-VP-NEXT: [[DOT:%.*]] = tail call i32 @llvm.smin.i32(i32 [[TMP0]], i32 [[TMP1]]) |
| ; NO-VP-NEXT: [[GEP11:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[IV]] |
| ; NO-VP-NEXT: store i32 [[DOT]], ptr [[GEP11]], align 4 |
| ; NO-VP-NEXT: [[IV_NEXT]] = add nuw nsw i64 [[IV]], 1 |
| ; NO-VP-NEXT: [[EXITCOND_NOT:%.*]] = icmp eq i64 [[IV_NEXT]], [[N]] |
| ; NO-VP-NEXT: br i1 [[EXITCOND_NOT]], label %[[EXIT]], label %[[LOOP]], !llvm.loop [[LOOP5:![0-9]+]] |
| ; NO-VP: [[EXIT]]: |
| ; NO-VP-NEXT: ret void |
| ; |
| |
| entry: |
| br label %loop |
| |
| loop: |
| %iv = phi i64 [ %iv.next, %loop ], [ 0, %entry ] |
| %gep = getelementptr inbounds i32, ptr %b, i64 %iv |
| %0 = load i32, ptr %gep, align 4 |
| %gep3 = getelementptr inbounds i32, ptr %c, i64 %iv |
| %1 = load i32, ptr %gep3, align 4 |
| %. = tail call i32 @llvm.smin.i32(i32 %0, i32 %1) |
| %gep11 = getelementptr inbounds i32, ptr %a, i64 %iv |
| store i32 %., ptr %gep11, align 4 |
| %iv.next = add nuw nsw i64 %iv, 1 |
| %exitcond.not = icmp eq i64 %iv.next, %N |
| br i1 %exitcond.not, label %exit, label %loop |
| |
| exit: |
| ret void |
| } |
| |
| define void @vp_umax(ptr %a, ptr %b, ptr %c, i64 %N) { |
| ; IF-EVL-LABEL: define void @vp_umax( |
| ; IF-EVL-SAME: ptr [[A:%.*]], ptr [[B:%.*]], ptr [[C:%.*]], i64 [[N:%.*]]) #[[ATTR0]] { |
| ; IF-EVL-NEXT: [[ENTRY:.*:]] |
| ; IF-EVL-NEXT: [[C3:%.*]] = ptrtoint ptr [[C]] to i64 |
| ; IF-EVL-NEXT: [[B2:%.*]] = ptrtoint ptr [[B]] to i64 |
| ; IF-EVL-NEXT: [[A1:%.*]] = ptrtoint ptr [[A]] to i64 |
| ; IF-EVL-NEXT: br label %[[VECTOR_MEMCHECK:.*]] |
| ; IF-EVL: [[VECTOR_MEMCHECK]]: |
| ; IF-EVL-NEXT: [[TMP4:%.*]] = call i64 @llvm.vscale.i64() |
| ; IF-EVL-NEXT: [[TMP5:%.*]] = mul nuw i64 [[TMP4]], 4 |
| ; IF-EVL-NEXT: [[TMP23:%.*]] = mul i64 [[TMP5]], 4 |
| ; IF-EVL-NEXT: [[TMP24:%.*]] = sub i64 [[A1]], [[B2]] |
| ; IF-EVL-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP24]], [[TMP23]] |
| ; IF-EVL-NEXT: [[TMP25:%.*]] = mul i64 [[TMP5]], 4 |
| ; IF-EVL-NEXT: [[TMP26:%.*]] = sub i64 [[A1]], [[C3]] |
| ; IF-EVL-NEXT: [[DIFF_CHECK4:%.*]] = icmp ult i64 [[TMP26]], [[TMP25]] |
| ; IF-EVL-NEXT: [[CONFLICT_RDX:%.*]] = or i1 [[DIFF_CHECK]], [[DIFF_CHECK4]] |
| ; IF-EVL-NEXT: br i1 [[CONFLICT_RDX]], label %[[SCALAR_PH:.*]], label %[[VECTOR_PH:.*]] |
| ; IF-EVL: [[VECTOR_PH]]: |
| ; IF-EVL-NEXT: br label %[[VECTOR_BODY:.*]] |
| ; IF-EVL: [[VECTOR_BODY]]: |
| ; IF-EVL-NEXT: [[EVL_BASED_IV:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_EVL_NEXT:%.*]], %[[VECTOR_BODY]] ] |
| ; IF-EVL-NEXT: [[AVL:%.*]] = phi i64 [ [[N]], %[[VECTOR_PH]] ], [ [[AVL_NEXT:%.*]], %[[VECTOR_BODY]] ] |
| ; IF-EVL-NEXT: [[TMP9:%.*]] = call i32 @llvm.experimental.get.vector.length.i64(i64 [[AVL]], i32 4, i1 true) |
| ; IF-EVL-NEXT: [[TMP11:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: [[VP_OP_LOAD:%.*]] = call <vscale x 4 x i32> @llvm.vp.load.nxv4i32.p0(ptr align 4 [[TMP11]], <vscale x 4 x i1> splat (i1 true), i32 [[TMP9]]) |
| ; IF-EVL-NEXT: [[TMP13:%.*]] = getelementptr inbounds i32, ptr [[C]], i64 [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: [[VP_OP_LOAD5:%.*]] = call <vscale x 4 x i32> @llvm.vp.load.nxv4i32.p0(ptr align 4 [[TMP13]], <vscale x 4 x i1> splat (i1 true), i32 [[TMP9]]) |
| ; IF-EVL-NEXT: [[TMP29:%.*]] = call <vscale x 4 x i32> @llvm.umax.nxv4i32(<vscale x 4 x i32> [[VP_OP_LOAD]], <vscale x 4 x i32> [[VP_OP_LOAD5]]) |
| ; IF-EVL-NEXT: [[TMP16:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: call void @llvm.vp.store.nxv4i32.p0(<vscale x 4 x i32> [[TMP29]], ptr align 4 [[TMP16]], <vscale x 4 x i1> splat (i1 true), i32 [[TMP9]]) |
| ; IF-EVL-NEXT: [[TMP18:%.*]] = zext i32 [[TMP9]] to i64 |
| ; IF-EVL-NEXT: [[INDEX_EVL_NEXT]] = add i64 [[TMP18]], [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: [[AVL_NEXT]] = sub nuw i64 [[AVL]], [[TMP18]] |
| ; IF-EVL-NEXT: [[TMP17:%.*]] = icmp eq i64 [[AVL_NEXT]], 0 |
| ; IF-EVL-NEXT: br i1 [[TMP17]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP6:![0-9]+]] |
| ; IF-EVL: [[MIDDLE_BLOCK]]: |
| ; IF-EVL-NEXT: br label %[[EXIT:.*]] |
| ; IF-EVL: [[SCALAR_PH]]: |
| ; IF-EVL-NEXT: br label %[[LOOP:.*]] |
| ; IF-EVL: [[LOOP]]: |
| ; IF-EVL-NEXT: [[IV:%.*]] = phi i64 [ [[IV_NEXT:%.*]], %[[LOOP]] ], [ 0, %[[SCALAR_PH]] ] |
| ; IF-EVL-NEXT: [[GEP:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[IV]] |
| ; IF-EVL-NEXT: [[TMP20:%.*]] = load i32, ptr [[GEP]], align 4 |
| ; IF-EVL-NEXT: [[GEP3:%.*]] = getelementptr inbounds i32, ptr [[C]], i64 [[IV]] |
| ; IF-EVL-NEXT: [[TMP21:%.*]] = load i32, ptr [[GEP3]], align 4 |
| ; IF-EVL-NEXT: [[DOT:%.*]] = tail call i32 @llvm.umax.i32(i32 [[TMP20]], i32 [[TMP21]]) |
| ; IF-EVL-NEXT: [[GEP11:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[IV]] |
| ; IF-EVL-NEXT: store i32 [[DOT]], ptr [[GEP11]], align 4 |
| ; IF-EVL-NEXT: [[IV_NEXT]] = add nuw nsw i64 [[IV]], 1 |
| ; IF-EVL-NEXT: [[EXITCOND_NOT:%.*]] = icmp eq i64 [[IV_NEXT]], [[N]] |
| ; IF-EVL-NEXT: br i1 [[EXITCOND_NOT]], label %[[EXIT]], label %[[LOOP]], !llvm.loop [[LOOP7:![0-9]+]] |
| ; IF-EVL: [[EXIT]]: |
| ; IF-EVL-NEXT: ret void |
| ; |
| ; NO-VP-LABEL: define void @vp_umax( |
| ; NO-VP-SAME: ptr [[A:%.*]], ptr [[B:%.*]], ptr [[C:%.*]], i64 [[N:%.*]]) #[[ATTR0]] { |
| ; NO-VP-NEXT: [[ENTRY:.*]]: |
| ; NO-VP-NEXT: [[C3:%.*]] = ptrtoint ptr [[C]] to i64 |
| ; NO-VP-NEXT: [[B2:%.*]] = ptrtoint ptr [[B]] to i64 |
| ; NO-VP-NEXT: [[A1:%.*]] = ptrtoint ptr [[A]] to i64 |
| ; NO-VP-NEXT: [[TMP12:%.*]] = call i64 @llvm.vscale.i64() |
| ; NO-VP-NEXT: [[TMP11:%.*]] = shl nuw i64 [[TMP12]], 2 |
| ; NO-VP-NEXT: [[TMP2:%.*]] = call i64 @llvm.umax.i64(i64 [[TMP11]], i64 16) |
| ; NO-VP-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[N]], [[TMP2]] |
| ; NO-VP-NEXT: br i1 [[MIN_ITERS_CHECK]], label %[[SCALAR_PH:.*]], label %[[VECTOR_MEMCHECK:.*]] |
| ; NO-VP: [[VECTOR_MEMCHECK]]: |
| ; NO-VP-NEXT: [[TMP3:%.*]] = call i64 @llvm.vscale.i64() |
| ; NO-VP-NEXT: [[TMP4:%.*]] = mul nuw i64 [[TMP3]], 4 |
| ; NO-VP-NEXT: [[TMP5:%.*]] = mul i64 [[TMP4]], 4 |
| ; NO-VP-NEXT: [[TMP6:%.*]] = sub i64 [[A1]], [[B2]] |
| ; NO-VP-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP6]], [[TMP5]] |
| ; NO-VP-NEXT: [[TMP7:%.*]] = mul i64 [[TMP4]], 4 |
| ; NO-VP-NEXT: [[TMP8:%.*]] = sub i64 [[A1]], [[C3]] |
| ; NO-VP-NEXT: [[DIFF_CHECK4:%.*]] = icmp ult i64 [[TMP8]], [[TMP7]] |
| ; NO-VP-NEXT: [[CONFLICT_RDX:%.*]] = or i1 [[DIFF_CHECK]], [[DIFF_CHECK4]] |
| ; NO-VP-NEXT: br i1 [[CONFLICT_RDX]], label %[[SCALAR_PH]], label %[[VECTOR_PH:.*]] |
| ; NO-VP: [[VECTOR_PH]]: |
| ; NO-VP-NEXT: [[TMP9:%.*]] = call i64 @llvm.vscale.i64() |
| ; NO-VP-NEXT: [[TMP10:%.*]] = mul nuw i64 [[TMP9]], 4 |
| ; NO-VP-NEXT: [[N_MOD_VF:%.*]] = urem i64 [[N]], [[TMP10]] |
| ; NO-VP-NEXT: [[N_VEC:%.*]] = sub i64 [[N]], [[N_MOD_VF]] |
| ; NO-VP-NEXT: br label %[[VECTOR_BODY:.*]] |
| ; NO-VP: [[VECTOR_BODY]]: |
| ; NO-VP-NEXT: [[INDEX:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ] |
| ; NO-VP-NEXT: [[TMP13:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[INDEX]] |
| ; NO-VP-NEXT: [[WIDE_LOAD:%.*]] = load <vscale x 4 x i32>, ptr [[TMP13]], align 4 |
| ; NO-VP-NEXT: [[TMP14:%.*]] = getelementptr inbounds i32, ptr [[C]], i64 [[INDEX]] |
| ; NO-VP-NEXT: [[WIDE_LOAD5:%.*]] = load <vscale x 4 x i32>, ptr [[TMP14]], align 4 |
| ; NO-VP-NEXT: [[TMP15:%.*]] = call <vscale x 4 x i32> @llvm.umax.nxv4i32(<vscale x 4 x i32> [[WIDE_LOAD]], <vscale x 4 x i32> [[WIDE_LOAD5]]) |
| ; NO-VP-NEXT: [[TMP16:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[INDEX]] |
| ; NO-VP-NEXT: store <vscale x 4 x i32> [[TMP15]], ptr [[TMP16]], align 4 |
| ; NO-VP-NEXT: [[INDEX_NEXT]] = add nuw i64 [[INDEX]], [[TMP10]] |
| ; NO-VP-NEXT: [[TMP17:%.*]] = icmp eq i64 [[INDEX_NEXT]], [[N_VEC]] |
| ; NO-VP-NEXT: br i1 [[TMP17]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP6:![0-9]+]] |
| ; NO-VP: [[MIDDLE_BLOCK]]: |
| ; NO-VP-NEXT: [[CMP_N:%.*]] = icmp eq i64 [[N]], [[N_VEC]] |
| ; NO-VP-NEXT: br i1 [[CMP_N]], label %[[EXIT:.*]], label %[[SCALAR_PH]] |
| ; NO-VP: [[SCALAR_PH]]: |
| ; NO-VP-NEXT: [[BC_RESUME_VAL:%.*]] = phi i64 [ [[N_VEC]], %[[MIDDLE_BLOCK]] ], [ 0, %[[ENTRY]] ], [ 0, %[[VECTOR_MEMCHECK]] ] |
| ; NO-VP-NEXT: br label %[[LOOP:.*]] |
| ; NO-VP: [[LOOP]]: |
| ; NO-VP-NEXT: [[IV:%.*]] = phi i64 [ [[IV_NEXT:%.*]], %[[LOOP]] ], [ [[BC_RESUME_VAL]], %[[SCALAR_PH]] ] |
| ; NO-VP-NEXT: [[GEP:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[IV]] |
| ; NO-VP-NEXT: [[TMP0:%.*]] = load i32, ptr [[GEP]], align 4 |
| ; NO-VP-NEXT: [[GEP3:%.*]] = getelementptr inbounds i32, ptr [[C]], i64 [[IV]] |
| ; NO-VP-NEXT: [[TMP1:%.*]] = load i32, ptr [[GEP3]], align 4 |
| ; NO-VP-NEXT: [[DOT:%.*]] = tail call i32 @llvm.umax.i32(i32 [[TMP0]], i32 [[TMP1]]) |
| ; NO-VP-NEXT: [[GEP11:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[IV]] |
| ; NO-VP-NEXT: store i32 [[DOT]], ptr [[GEP11]], align 4 |
| ; NO-VP-NEXT: [[IV_NEXT]] = add nuw nsw i64 [[IV]], 1 |
| ; NO-VP-NEXT: [[EXITCOND_NOT:%.*]] = icmp eq i64 [[IV_NEXT]], [[N]] |
| ; NO-VP-NEXT: br i1 [[EXITCOND_NOT]], label %[[EXIT]], label %[[LOOP]], !llvm.loop [[LOOP7:![0-9]+]] |
| ; NO-VP: [[EXIT]]: |
| ; NO-VP-NEXT: ret void |
| ; |
| |
| entry: |
| br label %loop |
| |
| loop: |
| %iv = phi i64 [ %iv.next, %loop ], [ 0, %entry ] |
| %gep = getelementptr inbounds i32, ptr %b, i64 %iv |
| %0 = load i32, ptr %gep, align 4 |
| %gep3 = getelementptr inbounds i32, ptr %c, i64 %iv |
| %1 = load i32, ptr %gep3, align 4 |
| %. = tail call i32 @llvm.umax.i32(i32 %0, i32 %1) |
| %gep11 = getelementptr inbounds i32, ptr %a, i64 %iv |
| store i32 %., ptr %gep11, align 4 |
| %iv.next = add nuw nsw i64 %iv, 1 |
| %exitcond.not = icmp eq i64 %iv.next, %N |
| br i1 %exitcond.not, label %exit, label %loop |
| |
| exit: |
| ret void |
| } |
| |
| define void @vp_umin(ptr %a, ptr %b, ptr %c, i64 %N) { |
| ; IF-EVL-LABEL: define void @vp_umin( |
| ; IF-EVL-SAME: ptr [[A:%.*]], ptr [[B:%.*]], ptr [[C:%.*]], i64 [[N:%.*]]) #[[ATTR0]] { |
| ; IF-EVL-NEXT: [[ENTRY:.*:]] |
| ; IF-EVL-NEXT: [[C3:%.*]] = ptrtoint ptr [[C]] to i64 |
| ; IF-EVL-NEXT: [[B2:%.*]] = ptrtoint ptr [[B]] to i64 |
| ; IF-EVL-NEXT: [[A1:%.*]] = ptrtoint ptr [[A]] to i64 |
| ; IF-EVL-NEXT: br label %[[VECTOR_MEMCHECK:.*]] |
| ; IF-EVL: [[VECTOR_MEMCHECK]]: |
| ; IF-EVL-NEXT: [[TMP4:%.*]] = call i64 @llvm.vscale.i64() |
| ; IF-EVL-NEXT: [[TMP5:%.*]] = mul nuw i64 [[TMP4]], 4 |
| ; IF-EVL-NEXT: [[TMP23:%.*]] = mul i64 [[TMP5]], 4 |
| ; IF-EVL-NEXT: [[TMP24:%.*]] = sub i64 [[A1]], [[B2]] |
| ; IF-EVL-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP24]], [[TMP23]] |
| ; IF-EVL-NEXT: [[TMP25:%.*]] = mul i64 [[TMP5]], 4 |
| ; IF-EVL-NEXT: [[TMP26:%.*]] = sub i64 [[A1]], [[C3]] |
| ; IF-EVL-NEXT: [[DIFF_CHECK4:%.*]] = icmp ult i64 [[TMP26]], [[TMP25]] |
| ; IF-EVL-NEXT: [[CONFLICT_RDX:%.*]] = or i1 [[DIFF_CHECK]], [[DIFF_CHECK4]] |
| ; IF-EVL-NEXT: br i1 [[CONFLICT_RDX]], label %[[SCALAR_PH:.*]], label %[[VECTOR_PH:.*]] |
| ; IF-EVL: [[VECTOR_PH]]: |
| ; IF-EVL-NEXT: br label %[[VECTOR_BODY:.*]] |
| ; IF-EVL: [[VECTOR_BODY]]: |
| ; IF-EVL-NEXT: [[EVL_BASED_IV:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_EVL_NEXT:%.*]], %[[VECTOR_BODY]] ] |
| ; IF-EVL-NEXT: [[AVL:%.*]] = phi i64 [ [[N]], %[[VECTOR_PH]] ], [ [[AVL_NEXT:%.*]], %[[VECTOR_BODY]] ] |
| ; IF-EVL-NEXT: [[TMP9:%.*]] = call i32 @llvm.experimental.get.vector.length.i64(i64 [[AVL]], i32 4, i1 true) |
| ; IF-EVL-NEXT: [[TMP11:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: [[VP_OP_LOAD:%.*]] = call <vscale x 4 x i32> @llvm.vp.load.nxv4i32.p0(ptr align 4 [[TMP11]], <vscale x 4 x i1> splat (i1 true), i32 [[TMP9]]) |
| ; IF-EVL-NEXT: [[TMP13:%.*]] = getelementptr inbounds i32, ptr [[C]], i64 [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: [[VP_OP_LOAD5:%.*]] = call <vscale x 4 x i32> @llvm.vp.load.nxv4i32.p0(ptr align 4 [[TMP13]], <vscale x 4 x i1> splat (i1 true), i32 [[TMP9]]) |
| ; IF-EVL-NEXT: [[TMP29:%.*]] = call <vscale x 4 x i32> @llvm.umin.nxv4i32(<vscale x 4 x i32> [[VP_OP_LOAD]], <vscale x 4 x i32> [[VP_OP_LOAD5]]) |
| ; IF-EVL-NEXT: [[TMP16:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: call void @llvm.vp.store.nxv4i32.p0(<vscale x 4 x i32> [[TMP29]], ptr align 4 [[TMP16]], <vscale x 4 x i1> splat (i1 true), i32 [[TMP9]]) |
| ; IF-EVL-NEXT: [[TMP18:%.*]] = zext i32 [[TMP9]] to i64 |
| ; IF-EVL-NEXT: [[INDEX_EVL_NEXT]] = add i64 [[TMP18]], [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: [[AVL_NEXT]] = sub nuw i64 [[AVL]], [[TMP18]] |
| ; IF-EVL-NEXT: [[TMP17:%.*]] = icmp eq i64 [[AVL_NEXT]], 0 |
| ; IF-EVL-NEXT: br i1 [[TMP17]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP8:![0-9]+]] |
| ; IF-EVL: [[MIDDLE_BLOCK]]: |
| ; IF-EVL-NEXT: br label %[[EXIT:.*]] |
| ; IF-EVL: [[SCALAR_PH]]: |
| ; IF-EVL-NEXT: br label %[[LOOP:.*]] |
| ; IF-EVL: [[LOOP]]: |
| ; IF-EVL-NEXT: [[IV:%.*]] = phi i64 [ [[IV_NEXT:%.*]], %[[LOOP]] ], [ 0, %[[SCALAR_PH]] ] |
| ; IF-EVL-NEXT: [[GEP:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[IV]] |
| ; IF-EVL-NEXT: [[TMP20:%.*]] = load i32, ptr [[GEP]], align 4 |
| ; IF-EVL-NEXT: [[GEP3:%.*]] = getelementptr inbounds i32, ptr [[C]], i64 [[IV]] |
| ; IF-EVL-NEXT: [[TMP21:%.*]] = load i32, ptr [[GEP3]], align 4 |
| ; IF-EVL-NEXT: [[DOT:%.*]] = tail call i32 @llvm.umin.i32(i32 [[TMP20]], i32 [[TMP21]]) |
| ; IF-EVL-NEXT: [[GEP11:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[IV]] |
| ; IF-EVL-NEXT: store i32 [[DOT]], ptr [[GEP11]], align 4 |
| ; IF-EVL-NEXT: [[IV_NEXT]] = add nuw nsw i64 [[IV]], 1 |
| ; IF-EVL-NEXT: [[EXITCOND_NOT:%.*]] = icmp eq i64 [[IV_NEXT]], [[N]] |
| ; IF-EVL-NEXT: br i1 [[EXITCOND_NOT]], label %[[EXIT]], label %[[LOOP]], !llvm.loop [[LOOP9:![0-9]+]] |
| ; IF-EVL: [[EXIT]]: |
| ; IF-EVL-NEXT: ret void |
| ; |
| ; NO-VP-LABEL: define void @vp_umin( |
| ; NO-VP-SAME: ptr [[A:%.*]], ptr [[B:%.*]], ptr [[C:%.*]], i64 [[N:%.*]]) #[[ATTR0]] { |
| ; NO-VP-NEXT: [[ENTRY:.*]]: |
| ; NO-VP-NEXT: [[C3:%.*]] = ptrtoint ptr [[C]] to i64 |
| ; NO-VP-NEXT: [[B2:%.*]] = ptrtoint ptr [[B]] to i64 |
| ; NO-VP-NEXT: [[A1:%.*]] = ptrtoint ptr [[A]] to i64 |
| ; NO-VP-NEXT: [[TMP12:%.*]] = call i64 @llvm.vscale.i64() |
| ; NO-VP-NEXT: [[TMP11:%.*]] = shl nuw i64 [[TMP12]], 2 |
| ; NO-VP-NEXT: [[TMP2:%.*]] = call i64 @llvm.umax.i64(i64 [[TMP11]], i64 16) |
| ; NO-VP-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[N]], [[TMP2]] |
| ; NO-VP-NEXT: br i1 [[MIN_ITERS_CHECK]], label %[[SCALAR_PH:.*]], label %[[VECTOR_MEMCHECK:.*]] |
| ; NO-VP: [[VECTOR_MEMCHECK]]: |
| ; NO-VP-NEXT: [[TMP3:%.*]] = call i64 @llvm.vscale.i64() |
| ; NO-VP-NEXT: [[TMP4:%.*]] = mul nuw i64 [[TMP3]], 4 |
| ; NO-VP-NEXT: [[TMP5:%.*]] = mul i64 [[TMP4]], 4 |
| ; NO-VP-NEXT: [[TMP6:%.*]] = sub i64 [[A1]], [[B2]] |
| ; NO-VP-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP6]], [[TMP5]] |
| ; NO-VP-NEXT: [[TMP7:%.*]] = mul i64 [[TMP4]], 4 |
| ; NO-VP-NEXT: [[TMP8:%.*]] = sub i64 [[A1]], [[C3]] |
| ; NO-VP-NEXT: [[DIFF_CHECK4:%.*]] = icmp ult i64 [[TMP8]], [[TMP7]] |
| ; NO-VP-NEXT: [[CONFLICT_RDX:%.*]] = or i1 [[DIFF_CHECK]], [[DIFF_CHECK4]] |
| ; NO-VP-NEXT: br i1 [[CONFLICT_RDX]], label %[[SCALAR_PH]], label %[[VECTOR_PH:.*]] |
| ; NO-VP: [[VECTOR_PH]]: |
| ; NO-VP-NEXT: [[TMP9:%.*]] = call i64 @llvm.vscale.i64() |
| ; NO-VP-NEXT: [[TMP10:%.*]] = mul nuw i64 [[TMP9]], 4 |
| ; NO-VP-NEXT: [[N_MOD_VF:%.*]] = urem i64 [[N]], [[TMP10]] |
| ; NO-VP-NEXT: [[N_VEC:%.*]] = sub i64 [[N]], [[N_MOD_VF]] |
| ; NO-VP-NEXT: br label %[[VECTOR_BODY:.*]] |
| ; NO-VP: [[VECTOR_BODY]]: |
| ; NO-VP-NEXT: [[INDEX:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ] |
| ; NO-VP-NEXT: [[TMP13:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[INDEX]] |
| ; NO-VP-NEXT: [[WIDE_LOAD:%.*]] = load <vscale x 4 x i32>, ptr [[TMP13]], align 4 |
| ; NO-VP-NEXT: [[TMP14:%.*]] = getelementptr inbounds i32, ptr [[C]], i64 [[INDEX]] |
| ; NO-VP-NEXT: [[WIDE_LOAD5:%.*]] = load <vscale x 4 x i32>, ptr [[TMP14]], align 4 |
| ; NO-VP-NEXT: [[TMP15:%.*]] = call <vscale x 4 x i32> @llvm.umin.nxv4i32(<vscale x 4 x i32> [[WIDE_LOAD]], <vscale x 4 x i32> [[WIDE_LOAD5]]) |
| ; NO-VP-NEXT: [[TMP16:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[INDEX]] |
| ; NO-VP-NEXT: store <vscale x 4 x i32> [[TMP15]], ptr [[TMP16]], align 4 |
| ; NO-VP-NEXT: [[INDEX_NEXT]] = add nuw i64 [[INDEX]], [[TMP10]] |
| ; NO-VP-NEXT: [[TMP17:%.*]] = icmp eq i64 [[INDEX_NEXT]], [[N_VEC]] |
| ; NO-VP-NEXT: br i1 [[TMP17]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP8:![0-9]+]] |
| ; NO-VP: [[MIDDLE_BLOCK]]: |
| ; NO-VP-NEXT: [[CMP_N:%.*]] = icmp eq i64 [[N]], [[N_VEC]] |
| ; NO-VP-NEXT: br i1 [[CMP_N]], label %[[EXIT:.*]], label %[[SCALAR_PH]] |
| ; NO-VP: [[SCALAR_PH]]: |
| ; NO-VP-NEXT: [[BC_RESUME_VAL:%.*]] = phi i64 [ [[N_VEC]], %[[MIDDLE_BLOCK]] ], [ 0, %[[ENTRY]] ], [ 0, %[[VECTOR_MEMCHECK]] ] |
| ; NO-VP-NEXT: br label %[[LOOP:.*]] |
| ; NO-VP: [[LOOP]]: |
| ; NO-VP-NEXT: [[IV:%.*]] = phi i64 [ [[IV_NEXT:%.*]], %[[LOOP]] ], [ [[BC_RESUME_VAL]], %[[SCALAR_PH]] ] |
| ; NO-VP-NEXT: [[GEP:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[IV]] |
| ; NO-VP-NEXT: [[TMP0:%.*]] = load i32, ptr [[GEP]], align 4 |
| ; NO-VP-NEXT: [[GEP3:%.*]] = getelementptr inbounds i32, ptr [[C]], i64 [[IV]] |
| ; NO-VP-NEXT: [[TMP1:%.*]] = load i32, ptr [[GEP3]], align 4 |
| ; NO-VP-NEXT: [[DOT:%.*]] = tail call i32 @llvm.umin.i32(i32 [[TMP0]], i32 [[TMP1]]) |
| ; NO-VP-NEXT: [[GEP11:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[IV]] |
| ; NO-VP-NEXT: store i32 [[DOT]], ptr [[GEP11]], align 4 |
| ; NO-VP-NEXT: [[IV_NEXT]] = add nuw nsw i64 [[IV]], 1 |
| ; NO-VP-NEXT: [[EXITCOND_NOT:%.*]] = icmp eq i64 [[IV_NEXT]], [[N]] |
| ; NO-VP-NEXT: br i1 [[EXITCOND_NOT]], label %[[EXIT]], label %[[LOOP]], !llvm.loop [[LOOP9:![0-9]+]] |
| ; NO-VP: [[EXIT]]: |
| ; NO-VP-NEXT: ret void |
| ; |
| |
| entry: |
| br label %loop |
| |
| loop: |
| %iv = phi i64 [ %iv.next, %loop ], [ 0, %entry ] |
| %gep = getelementptr inbounds i32, ptr %b, i64 %iv |
| %0 = load i32, ptr %gep, align 4 |
| %gep3 = getelementptr inbounds i32, ptr %c, i64 %iv |
| %1 = load i32, ptr %gep3, align 4 |
| %. = tail call i32 @llvm.umin.i32(i32 %0, i32 %1) |
| %gep11 = getelementptr inbounds i32, ptr %a, i64 %iv |
| store i32 %., ptr %gep11, align 4 |
| %iv.next = add nuw nsw i64 %iv, 1 |
| %exitcond.not = icmp eq i64 %iv.next, %N |
| br i1 %exitcond.not, label %exit, label %loop |
| |
| exit: |
| ret void |
| } |
| |
| |
| define void @vp_ctlz(ptr %a, ptr %b, i64 %N) { |
| ; IF-EVL-LABEL: define void @vp_ctlz( |
| ; IF-EVL-SAME: ptr [[A:%.*]], ptr [[B:%.*]], i64 [[N:%.*]]) #[[ATTR0]] { |
| ; IF-EVL-NEXT: [[ENTRY:.*:]] |
| ; IF-EVL-NEXT: [[B2:%.*]] = ptrtoint ptr [[B]] to i64 |
| ; IF-EVL-NEXT: [[A1:%.*]] = ptrtoint ptr [[A]] to i64 |
| ; IF-EVL-NEXT: br label %[[VECTOR_MEMCHECK:.*]] |
| ; IF-EVL: [[VECTOR_MEMCHECK]]: |
| ; IF-EVL-NEXT: [[TMP4:%.*]] = call i64 @llvm.vscale.i64() |
| ; IF-EVL-NEXT: [[TMP5:%.*]] = mul nuw i64 [[TMP4]], 4 |
| ; IF-EVL-NEXT: [[TMP20:%.*]] = mul i64 [[TMP5]], 4 |
| ; IF-EVL-NEXT: [[TMP21:%.*]] = sub i64 [[A1]], [[B2]] |
| ; IF-EVL-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP21]], [[TMP20]] |
| ; IF-EVL-NEXT: br i1 [[DIFF_CHECK]], label %[[SCALAR_PH:.*]], label %[[VECTOR_PH:.*]] |
| ; IF-EVL: [[VECTOR_PH]]: |
| ; IF-EVL-NEXT: br label %[[VECTOR_BODY:.*]] |
| ; IF-EVL: [[VECTOR_BODY]]: |
| ; IF-EVL-NEXT: [[EVL_BASED_IV:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_EVL_NEXT:%.*]], %[[VECTOR_BODY]] ] |
| ; IF-EVL-NEXT: [[AVL:%.*]] = phi i64 [ [[N]], %[[VECTOR_PH]] ], [ [[AVL_NEXT:%.*]], %[[VECTOR_BODY]] ] |
| ; IF-EVL-NEXT: [[TMP9:%.*]] = call i32 @llvm.experimental.get.vector.length.i64(i64 [[AVL]], i32 4, i1 true) |
| ; IF-EVL-NEXT: [[TMP11:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: [[VP_OP_LOAD:%.*]] = call <vscale x 4 x i32> @llvm.vp.load.nxv4i32.p0(ptr align 4 [[TMP11]], <vscale x 4 x i1> splat (i1 true), i32 [[TMP9]]) |
| ; IF-EVL-NEXT: [[TMP24:%.*]] = call <vscale x 4 x i32> @llvm.ctlz.nxv4i32(<vscale x 4 x i32> [[VP_OP_LOAD]], i1 true) |
| ; IF-EVL-NEXT: [[TMP14:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: call void @llvm.vp.store.nxv4i32.p0(<vscale x 4 x i32> [[TMP24]], ptr align 4 [[TMP14]], <vscale x 4 x i1> splat (i1 true), i32 [[TMP9]]) |
| ; IF-EVL-NEXT: [[TMP16:%.*]] = zext i32 [[TMP9]] to i64 |
| ; IF-EVL-NEXT: [[INDEX_EVL_NEXT]] = add i64 [[TMP16]], [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: [[AVL_NEXT]] = sub nuw i64 [[AVL]], [[TMP16]] |
| ; IF-EVL-NEXT: [[TMP15:%.*]] = icmp eq i64 [[AVL_NEXT]], 0 |
| ; IF-EVL-NEXT: br i1 [[TMP15]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP10:![0-9]+]] |
| ; IF-EVL: [[MIDDLE_BLOCK]]: |
| ; IF-EVL-NEXT: br label %[[EXIT:.*]] |
| ; IF-EVL: [[SCALAR_PH]]: |
| ; IF-EVL-NEXT: br label %[[LOOP:.*]] |
| ; IF-EVL: [[LOOP]]: |
| ; IF-EVL-NEXT: [[IV:%.*]] = phi i64 [ [[IV_NEXT:%.*]], %[[LOOP]] ], [ 0, %[[SCALAR_PH]] ] |
| ; IF-EVL-NEXT: [[GEP:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[IV]] |
| ; IF-EVL-NEXT: [[TMP18:%.*]] = load i32, ptr [[GEP]], align 4 |
| ; IF-EVL-NEXT: [[TMP19:%.*]] = tail call range(i32 0, 33) i32 @llvm.ctlz.i32(i32 [[TMP18]], i1 true) |
| ; IF-EVL-NEXT: [[GEP3:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[IV]] |
| ; IF-EVL-NEXT: store i32 [[TMP19]], ptr [[GEP3]], align 4 |
| ; IF-EVL-NEXT: [[IV_NEXT]] = add nuw nsw i64 [[IV]], 1 |
| ; IF-EVL-NEXT: [[EXITCOND_NOT:%.*]] = icmp eq i64 [[IV_NEXT]], [[N]] |
| ; IF-EVL-NEXT: br i1 [[EXITCOND_NOT]], label %[[EXIT]], label %[[LOOP]], !llvm.loop [[LOOP11:![0-9]+]] |
| ; IF-EVL: [[EXIT]]: |
| ; IF-EVL-NEXT: ret void |
| ; |
| ; NO-VP-LABEL: define void @vp_ctlz( |
| ; NO-VP-SAME: ptr [[A:%.*]], ptr [[B:%.*]], i64 [[N:%.*]]) #[[ATTR0]] { |
| ; NO-VP-NEXT: [[ENTRY:.*]]: |
| ; NO-VP-NEXT: [[B2:%.*]] = ptrtoint ptr [[B]] to i64 |
| ; NO-VP-NEXT: [[A1:%.*]] = ptrtoint ptr [[A]] to i64 |
| ; NO-VP-NEXT: [[TMP10:%.*]] = call i64 @llvm.vscale.i64() |
| ; NO-VP-NEXT: [[TMP9:%.*]] = shl nuw i64 [[TMP10]], 2 |
| ; NO-VP-NEXT: [[TMP2:%.*]] = call i64 @llvm.umax.i64(i64 [[TMP9]], i64 8) |
| ; NO-VP-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[N]], [[TMP2]] |
| ; NO-VP-NEXT: br i1 [[MIN_ITERS_CHECK]], label %[[SCALAR_PH:.*]], label %[[VECTOR_MEMCHECK:.*]] |
| ; NO-VP: [[VECTOR_MEMCHECK]]: |
| ; NO-VP-NEXT: [[TMP3:%.*]] = call i64 @llvm.vscale.i64() |
| ; NO-VP-NEXT: [[TMP4:%.*]] = mul nuw i64 [[TMP3]], 4 |
| ; NO-VP-NEXT: [[TMP5:%.*]] = mul i64 [[TMP4]], 4 |
| ; NO-VP-NEXT: [[TMP6:%.*]] = sub i64 [[A1]], [[B2]] |
| ; NO-VP-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP6]], [[TMP5]] |
| ; NO-VP-NEXT: br i1 [[DIFF_CHECK]], label %[[SCALAR_PH]], label %[[VECTOR_PH:.*]] |
| ; NO-VP: [[VECTOR_PH]]: |
| ; NO-VP-NEXT: [[TMP7:%.*]] = call i64 @llvm.vscale.i64() |
| ; NO-VP-NEXT: [[TMP8:%.*]] = mul nuw i64 [[TMP7]], 4 |
| ; NO-VP-NEXT: [[N_MOD_VF:%.*]] = urem i64 [[N]], [[TMP8]] |
| ; NO-VP-NEXT: [[N_VEC:%.*]] = sub i64 [[N]], [[N_MOD_VF]] |
| ; NO-VP-NEXT: br label %[[VECTOR_BODY:.*]] |
| ; NO-VP: [[VECTOR_BODY]]: |
| ; NO-VP-NEXT: [[IV:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ] |
| ; NO-VP-NEXT: [[GEP:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[IV]] |
| ; NO-VP-NEXT: [[WIDE_LOAD:%.*]] = load <vscale x 4 x i32>, ptr [[GEP]], align 4 |
| ; NO-VP-NEXT: [[TMP12:%.*]] = call <vscale x 4 x i32> @llvm.ctlz.nxv4i32(<vscale x 4 x i32> [[WIDE_LOAD]], i1 true) |
| ; NO-VP-NEXT: [[TMP13:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[IV]] |
| ; NO-VP-NEXT: store <vscale x 4 x i32> [[TMP12]], ptr [[TMP13]], align 4 |
| ; NO-VP-NEXT: [[INDEX_NEXT]] = add nuw i64 [[IV]], [[TMP8]] |
| ; NO-VP-NEXT: [[TMP14:%.*]] = icmp eq i64 [[INDEX_NEXT]], [[N_VEC]] |
| ; NO-VP-NEXT: br i1 [[TMP14]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP10:![0-9]+]] |
| ; NO-VP: [[MIDDLE_BLOCK]]: |
| ; NO-VP-NEXT: [[CMP_N:%.*]] = icmp eq i64 [[N]], [[N_VEC]] |
| ; NO-VP-NEXT: br i1 [[CMP_N]], label %[[EXIT:.*]], label %[[SCALAR_PH]] |
| ; NO-VP: [[SCALAR_PH]]: |
| ; NO-VP-NEXT: [[BC_RESUME_VAL:%.*]] = phi i64 [ [[N_VEC]], %[[MIDDLE_BLOCK]] ], [ 0, %[[ENTRY]] ], [ 0, %[[VECTOR_MEMCHECK]] ] |
| ; NO-VP-NEXT: br label %[[LOOP:.*]] |
| ; NO-VP: [[LOOP]]: |
| ; NO-VP-NEXT: [[IV1:%.*]] = phi i64 [ [[IV_NEXT:%.*]], %[[LOOP]] ], [ [[BC_RESUME_VAL]], %[[SCALAR_PH]] ] |
| ; NO-VP-NEXT: [[GEP1:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[IV1]] |
| ; NO-VP-NEXT: [[TMP0:%.*]] = load i32, ptr [[GEP1]], align 4 |
| ; NO-VP-NEXT: [[TMP1:%.*]] = tail call range(i32 0, 33) i32 @llvm.ctlz.i32(i32 [[TMP0]], i1 true) |
| ; NO-VP-NEXT: [[GEP3:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[IV1]] |
| ; NO-VP-NEXT: store i32 [[TMP1]], ptr [[GEP3]], align 4 |
| ; NO-VP-NEXT: [[IV_NEXT]] = add nuw nsw i64 [[IV1]], 1 |
| ; NO-VP-NEXT: [[EXITCOND_NOT:%.*]] = icmp eq i64 [[IV_NEXT]], [[N]] |
| ; NO-VP-NEXT: br i1 [[EXITCOND_NOT]], label %[[EXIT]], label %[[LOOP]], !llvm.loop [[LOOP11:![0-9]+]] |
| ; NO-VP: [[EXIT]]: |
| ; NO-VP-NEXT: ret void |
| ; |
| |
| entry: |
| br label %loop |
| |
| loop: |
| %iv = phi i64 [ %iv.next, %loop ], [ 0, %entry ] |
| %gep = getelementptr inbounds i32, ptr %b, i64 %iv |
| %0 = load i32, ptr %gep, align 4 |
| %1 = tail call range(i32 0, 33) i32 @llvm.ctlz.i32(i32 %0, i1 true) |
| %gep3 = getelementptr inbounds i32, ptr %a, i64 %iv |
| store i32 %1, ptr %gep3, align 4 |
| %iv.next = add nuw nsw i64 %iv, 1 |
| %exitcond.not = icmp eq i64 %iv.next, %N |
| br i1 %exitcond.not, label %exit, label %loop |
| |
| exit: |
| ret void |
| } |
| |
| define void @vp_cttz(ptr %a, ptr %b, i64 %N) { |
| ; IF-EVL-LABEL: define void @vp_cttz( |
| ; IF-EVL-SAME: ptr [[A:%.*]], ptr [[B:%.*]], i64 [[N:%.*]]) #[[ATTR0]] { |
| ; IF-EVL-NEXT: [[ENTRY:.*:]] |
| ; IF-EVL-NEXT: [[B2:%.*]] = ptrtoint ptr [[B]] to i64 |
| ; IF-EVL-NEXT: [[A1:%.*]] = ptrtoint ptr [[A]] to i64 |
| ; IF-EVL-NEXT: br label %[[VECTOR_MEMCHECK:.*]] |
| ; IF-EVL: [[VECTOR_MEMCHECK]]: |
| ; IF-EVL-NEXT: [[TMP4:%.*]] = call i64 @llvm.vscale.i64() |
| ; IF-EVL-NEXT: [[TMP5:%.*]] = mul nuw i64 [[TMP4]], 4 |
| ; IF-EVL-NEXT: [[TMP6:%.*]] = mul i64 [[TMP5]], 4 |
| ; IF-EVL-NEXT: [[TMP7:%.*]] = sub i64 [[A1]], [[B2]] |
| ; IF-EVL-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP7]], [[TMP6]] |
| ; IF-EVL-NEXT: br i1 [[DIFF_CHECK]], label %[[SCALAR_PH:.*]], label %[[VECTOR_PH:.*]] |
| ; IF-EVL: [[VECTOR_PH]]: |
| ; IF-EVL-NEXT: br label %[[VECTOR_BODY:.*]] |
| ; IF-EVL: [[VECTOR_BODY]]: |
| ; IF-EVL-NEXT: [[EVL_BASED_IV:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_EVL_NEXT:%.*]], %[[VECTOR_BODY]] ] |
| ; IF-EVL-NEXT: [[AVL:%.*]] = phi i64 [ [[N]], %[[VECTOR_PH]] ], [ [[AVL_NEXT:%.*]], %[[VECTOR_BODY]] ] |
| ; IF-EVL-NEXT: [[TMP13:%.*]] = call i32 @llvm.experimental.get.vector.length.i64(i64 [[AVL]], i32 4, i1 true) |
| ; IF-EVL-NEXT: [[TMP15:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: [[VP_OP_LOAD:%.*]] = call <vscale x 4 x i32> @llvm.vp.load.nxv4i32.p0(ptr align 4 [[TMP15]], <vscale x 4 x i1> splat (i1 true), i32 [[TMP13]]) |
| ; IF-EVL-NEXT: [[TMP17:%.*]] = call <vscale x 4 x i32> @llvm.cttz.nxv4i32(<vscale x 4 x i32> [[VP_OP_LOAD]], i1 true) |
| ; IF-EVL-NEXT: [[TMP18:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: call void @llvm.vp.store.nxv4i32.p0(<vscale x 4 x i32> [[TMP17]], ptr align 4 [[TMP18]], <vscale x 4 x i1> splat (i1 true), i32 [[TMP13]]) |
| ; IF-EVL-NEXT: [[TMP20:%.*]] = zext i32 [[TMP13]] to i64 |
| ; IF-EVL-NEXT: [[INDEX_EVL_NEXT]] = add i64 [[TMP20]], [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: [[AVL_NEXT]] = sub nuw i64 [[AVL]], [[TMP20]] |
| ; IF-EVL-NEXT: [[TMP14:%.*]] = icmp eq i64 [[AVL_NEXT]], 0 |
| ; IF-EVL-NEXT: br i1 [[TMP14]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP12:![0-9]+]] |
| ; IF-EVL: [[MIDDLE_BLOCK]]: |
| ; IF-EVL-NEXT: br label %[[EXIT:.*]] |
| ; IF-EVL: [[SCALAR_PH]]: |
| ; IF-EVL-NEXT: br label %[[LOOP:.*]] |
| ; IF-EVL: [[LOOP]]: |
| ; IF-EVL-NEXT: [[IV:%.*]] = phi i64 [ [[IV_NEXT:%.*]], %[[LOOP]] ], [ 0, %[[SCALAR_PH]] ] |
| ; IF-EVL-NEXT: [[GEP:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[IV]] |
| ; IF-EVL-NEXT: [[TMP22:%.*]] = load i32, ptr [[GEP]], align 4 |
| ; IF-EVL-NEXT: [[TMP23:%.*]] = tail call range(i32 0, 33) i32 @llvm.cttz.i32(i32 [[TMP22]], i1 true) |
| ; IF-EVL-NEXT: [[GEP3:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[IV]] |
| ; IF-EVL-NEXT: store i32 [[TMP23]], ptr [[GEP3]], align 4 |
| ; IF-EVL-NEXT: [[IV_NEXT]] = add nuw nsw i64 [[IV]], 1 |
| ; IF-EVL-NEXT: [[EXITCOND_NOT:%.*]] = icmp eq i64 [[IV_NEXT]], [[N]] |
| ; IF-EVL-NEXT: br i1 [[EXITCOND_NOT]], label %[[EXIT]], label %[[LOOP]], !llvm.loop [[LOOP13:![0-9]+]] |
| ; IF-EVL: [[EXIT]]: |
| ; IF-EVL-NEXT: ret void |
| ; |
| ; NO-VP-LABEL: define void @vp_cttz( |
| ; NO-VP-SAME: ptr [[A:%.*]], ptr [[B:%.*]], i64 [[N:%.*]]) #[[ATTR0]] { |
| ; NO-VP-NEXT: [[ENTRY:.*]]: |
| ; NO-VP-NEXT: [[B2:%.*]] = ptrtoint ptr [[B]] to i64 |
| ; NO-VP-NEXT: [[A1:%.*]] = ptrtoint ptr [[A]] to i64 |
| ; NO-VP-NEXT: [[TMP10:%.*]] = call i64 @llvm.vscale.i64() |
| ; NO-VP-NEXT: [[TMP9:%.*]] = shl nuw i64 [[TMP10]], 2 |
| ; NO-VP-NEXT: [[TMP2:%.*]] = call i64 @llvm.umax.i64(i64 [[TMP9]], i64 8) |
| ; NO-VP-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[N]], [[TMP2]] |
| ; NO-VP-NEXT: br i1 [[MIN_ITERS_CHECK]], label %[[SCALAR_PH:.*]], label %[[VECTOR_MEMCHECK:.*]] |
| ; NO-VP: [[VECTOR_MEMCHECK]]: |
| ; NO-VP-NEXT: [[TMP3:%.*]] = call i64 @llvm.vscale.i64() |
| ; NO-VP-NEXT: [[TMP4:%.*]] = mul nuw i64 [[TMP3]], 4 |
| ; NO-VP-NEXT: [[TMP5:%.*]] = mul i64 [[TMP4]], 4 |
| ; NO-VP-NEXT: [[TMP6:%.*]] = sub i64 [[A1]], [[B2]] |
| ; NO-VP-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP6]], [[TMP5]] |
| ; NO-VP-NEXT: br i1 [[DIFF_CHECK]], label %[[SCALAR_PH]], label %[[VECTOR_PH:.*]] |
| ; NO-VP: [[VECTOR_PH]]: |
| ; NO-VP-NEXT: [[TMP7:%.*]] = call i64 @llvm.vscale.i64() |
| ; NO-VP-NEXT: [[TMP8:%.*]] = mul nuw i64 [[TMP7]], 4 |
| ; NO-VP-NEXT: [[N_MOD_VF:%.*]] = urem i64 [[N]], [[TMP8]] |
| ; NO-VP-NEXT: [[N_VEC:%.*]] = sub i64 [[N]], [[N_MOD_VF]] |
| ; NO-VP-NEXT: br label %[[VECTOR_BODY:.*]] |
| ; NO-VP: [[VECTOR_BODY]]: |
| ; NO-VP-NEXT: [[IV:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ] |
| ; NO-VP-NEXT: [[GEP:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[IV]] |
| ; NO-VP-NEXT: [[WIDE_LOAD:%.*]] = load <vscale x 4 x i32>, ptr [[GEP]], align 4 |
| ; NO-VP-NEXT: [[TMP12:%.*]] = call <vscale x 4 x i32> @llvm.cttz.nxv4i32(<vscale x 4 x i32> [[WIDE_LOAD]], i1 true) |
| ; NO-VP-NEXT: [[TMP13:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[IV]] |
| ; NO-VP-NEXT: store <vscale x 4 x i32> [[TMP12]], ptr [[TMP13]], align 4 |
| ; NO-VP-NEXT: [[INDEX_NEXT]] = add nuw i64 [[IV]], [[TMP8]] |
| ; NO-VP-NEXT: [[TMP14:%.*]] = icmp eq i64 [[INDEX_NEXT]], [[N_VEC]] |
| ; NO-VP-NEXT: br i1 [[TMP14]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP12:![0-9]+]] |
| ; NO-VP: [[MIDDLE_BLOCK]]: |
| ; NO-VP-NEXT: [[CMP_N:%.*]] = icmp eq i64 [[N]], [[N_VEC]] |
| ; NO-VP-NEXT: br i1 [[CMP_N]], label %[[EXIT:.*]], label %[[SCALAR_PH]] |
| ; NO-VP: [[SCALAR_PH]]: |
| ; NO-VP-NEXT: [[BC_RESUME_VAL:%.*]] = phi i64 [ [[N_VEC]], %[[MIDDLE_BLOCK]] ], [ 0, %[[ENTRY]] ], [ 0, %[[VECTOR_MEMCHECK]] ] |
| ; NO-VP-NEXT: br label %[[LOOP:.*]] |
| ; NO-VP: [[LOOP]]: |
| ; NO-VP-NEXT: [[IV1:%.*]] = phi i64 [ [[IV_NEXT:%.*]], %[[LOOP]] ], [ [[BC_RESUME_VAL]], %[[SCALAR_PH]] ] |
| ; NO-VP-NEXT: [[GEP1:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[IV1]] |
| ; NO-VP-NEXT: [[TMP0:%.*]] = load i32, ptr [[GEP1]], align 4 |
| ; NO-VP-NEXT: [[TMP1:%.*]] = tail call range(i32 0, 33) i32 @llvm.cttz.i32(i32 [[TMP0]], i1 true) |
| ; NO-VP-NEXT: [[GEP3:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[IV1]] |
| ; NO-VP-NEXT: store i32 [[TMP1]], ptr [[GEP3]], align 4 |
| ; NO-VP-NEXT: [[IV_NEXT]] = add nuw nsw i64 [[IV1]], 1 |
| ; NO-VP-NEXT: [[EXITCOND_NOT:%.*]] = icmp eq i64 [[IV_NEXT]], [[N]] |
| ; NO-VP-NEXT: br i1 [[EXITCOND_NOT]], label %[[EXIT]], label %[[LOOP]], !llvm.loop [[LOOP13:![0-9]+]] |
| ; NO-VP: [[EXIT]]: |
| ; NO-VP-NEXT: ret void |
| ; |
| |
| entry: |
| br label %loop |
| |
| loop: |
| %iv = phi i64 [ %iv.next, %loop ], [ 0, %entry ] |
| %gep = getelementptr inbounds i32, ptr %b, i64 %iv |
| %0 = load i32, ptr %gep, align 4 |
| %1 = tail call range(i32 0, 33) i32 @llvm.cttz.i32(i32 %0, i1 true) |
| %gep3 = getelementptr inbounds i32, ptr %a, i64 %iv |
| store i32 %1, ptr %gep3, align 4 |
| %iv.next = add nuw nsw i64 %iv, 1 |
| %exitcond.not = icmp eq i64 %iv.next, %N |
| br i1 %exitcond.not, label %exit, label %loop |
| |
| exit: |
| ret void |
| } |
| |
| define void @vp_lrint(ptr %a, ptr %b, i64 %N) { |
| ; IF-EVL-LABEL: define void @vp_lrint( |
| ; IF-EVL-SAME: ptr [[A:%.*]], ptr [[B:%.*]], i64 [[N:%.*]]) #[[ATTR0]] { |
| ; IF-EVL-NEXT: [[ENTRY:.*:]] |
| ; IF-EVL-NEXT: [[B2:%.*]] = ptrtoint ptr [[B]] to i64 |
| ; IF-EVL-NEXT: [[A1:%.*]] = ptrtoint ptr [[A]] to i64 |
| ; IF-EVL-NEXT: br label %[[VECTOR_MEMCHECK:.*]] |
| ; IF-EVL: [[VECTOR_MEMCHECK]]: |
| ; IF-EVL-NEXT: [[TMP4:%.*]] = call i64 @llvm.vscale.i64() |
| ; IF-EVL-NEXT: [[TMP5:%.*]] = mul nuw i64 [[TMP4]], 4 |
| ; IF-EVL-NEXT: [[TMP23:%.*]] = mul i64 [[TMP5]], 4 |
| ; IF-EVL-NEXT: [[TMP24:%.*]] = sub i64 [[A1]], [[B2]] |
| ; IF-EVL-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP24]], [[TMP23]] |
| ; IF-EVL-NEXT: br i1 [[DIFF_CHECK]], label %[[SCALAR_PH:.*]], label %[[VECTOR_PH:.*]] |
| ; IF-EVL: [[VECTOR_PH]]: |
| ; IF-EVL-NEXT: br label %[[VECTOR_BODY:.*]] |
| ; IF-EVL: [[VECTOR_BODY]]: |
| ; IF-EVL-NEXT: [[EVL_BASED_IV:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_EVL_NEXT:%.*]], %[[VECTOR_BODY]] ] |
| ; IF-EVL-NEXT: [[AVL:%.*]] = phi i64 [ [[N]], %[[VECTOR_PH]] ], [ [[AVL_NEXT:%.*]], %[[VECTOR_BODY]] ] |
| ; IF-EVL-NEXT: [[TMP9:%.*]] = call i32 @llvm.experimental.get.vector.length.i64(i64 [[AVL]], i32 4, i1 true) |
| ; IF-EVL-NEXT: [[TMP11:%.*]] = getelementptr inbounds float, ptr [[B]], i64 [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: [[VP_OP_LOAD:%.*]] = call <vscale x 4 x float> @llvm.vp.load.nxv4f32.p0(ptr align 4 [[TMP11]], <vscale x 4 x i1> splat (i1 true), i32 [[TMP9]]) |
| ; IF-EVL-NEXT: [[TMP27:%.*]] = fpext <vscale x 4 x float> [[VP_OP_LOAD]] to <vscale x 4 x double> |
| ; IF-EVL-NEXT: [[TMP28:%.*]] = call <vscale x 4 x i64> @llvm.lrint.nxv4i64.nxv4f64(<vscale x 4 x double> [[TMP27]]) |
| ; IF-EVL-NEXT: [[TMP15:%.*]] = trunc <vscale x 4 x i64> [[TMP28]] to <vscale x 4 x i32> |
| ; IF-EVL-NEXT: [[TMP16:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: call void @llvm.vp.store.nxv4i32.p0(<vscale x 4 x i32> [[TMP15]], ptr align 4 [[TMP16]], <vscale x 4 x i1> splat (i1 true), i32 [[TMP9]]) |
| ; IF-EVL-NEXT: [[TMP18:%.*]] = zext i32 [[TMP9]] to i64 |
| ; IF-EVL-NEXT: [[INDEX_EVL_NEXT]] = add i64 [[TMP18]], [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: [[AVL_NEXT]] = sub nuw i64 [[AVL]], [[TMP18]] |
| ; IF-EVL-NEXT: [[TMP17:%.*]] = icmp eq i64 [[AVL_NEXT]], 0 |
| ; IF-EVL-NEXT: br i1 [[TMP17]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP14:![0-9]+]] |
| ; IF-EVL: [[MIDDLE_BLOCK]]: |
| ; IF-EVL-NEXT: br label %[[EXIT:.*]] |
| ; IF-EVL: [[SCALAR_PH]]: |
| ; IF-EVL-NEXT: br label %[[LOOP:.*]] |
| ; IF-EVL: [[LOOP]]: |
| ; IF-EVL-NEXT: [[IV:%.*]] = phi i64 [ [[IV_NEXT:%.*]], %[[LOOP]] ], [ 0, %[[SCALAR_PH]] ] |
| ; IF-EVL-NEXT: [[GEP:%.*]] = getelementptr inbounds float, ptr [[B]], i64 [[IV]] |
| ; IF-EVL-NEXT: [[TMP20:%.*]] = load float, ptr [[GEP]], align 4 |
| ; IF-EVL-NEXT: [[CONV2:%.*]] = fpext float [[TMP20]] to double |
| ; IF-EVL-NEXT: [[TMP21:%.*]] = tail call i64 @llvm.lrint.i64.f64(double [[CONV2]]) |
| ; IF-EVL-NEXT: [[CONV3:%.*]] = trunc i64 [[TMP21]] to i32 |
| ; IF-EVL-NEXT: [[GEP5:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[IV]] |
| ; IF-EVL-NEXT: store i32 [[CONV3]], ptr [[GEP5]], align 4 |
| ; IF-EVL-NEXT: [[IV_NEXT]] = add nuw nsw i64 [[IV]], 1 |
| ; IF-EVL-NEXT: [[EXITCOND_NOT:%.*]] = icmp eq i64 [[IV_NEXT]], [[N]] |
| ; IF-EVL-NEXT: br i1 [[EXITCOND_NOT]], label %[[EXIT]], label %[[LOOP]], !llvm.loop [[LOOP15:![0-9]+]] |
| ; IF-EVL: [[EXIT]]: |
| ; IF-EVL-NEXT: ret void |
| ; |
| ; NO-VP-LABEL: define void @vp_lrint( |
| ; NO-VP-SAME: ptr [[A:%.*]], ptr [[B:%.*]], i64 [[N:%.*]]) #[[ATTR0]] { |
| ; NO-VP-NEXT: [[ENTRY:.*]]: |
| ; NO-VP-NEXT: [[B2:%.*]] = ptrtoint ptr [[B]] to i64 |
| ; NO-VP-NEXT: [[A1:%.*]] = ptrtoint ptr [[A]] to i64 |
| ; NO-VP-NEXT: [[TMP10:%.*]] = call i64 @llvm.vscale.i64() |
| ; NO-VP-NEXT: [[TMP9:%.*]] = shl nuw i64 [[TMP10]], 2 |
| ; NO-VP-NEXT: [[TMP2:%.*]] = call i64 @llvm.umax.i64(i64 [[TMP9]], i64 16) |
| ; NO-VP-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[N]], [[TMP2]] |
| ; NO-VP-NEXT: br i1 [[MIN_ITERS_CHECK]], label %[[SCALAR_PH:.*]], label %[[VECTOR_MEMCHECK:.*]] |
| ; NO-VP: [[VECTOR_MEMCHECK]]: |
| ; NO-VP-NEXT: [[TMP3:%.*]] = call i64 @llvm.vscale.i64() |
| ; NO-VP-NEXT: [[TMP4:%.*]] = mul nuw i64 [[TMP3]], 4 |
| ; NO-VP-NEXT: [[TMP5:%.*]] = mul i64 [[TMP4]], 4 |
| ; NO-VP-NEXT: [[TMP6:%.*]] = sub i64 [[A1]], [[B2]] |
| ; NO-VP-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP6]], [[TMP5]] |
| ; NO-VP-NEXT: br i1 [[DIFF_CHECK]], label %[[SCALAR_PH]], label %[[VECTOR_PH:.*]] |
| ; NO-VP: [[VECTOR_PH]]: |
| ; NO-VP-NEXT: [[TMP7:%.*]] = call i64 @llvm.vscale.i64() |
| ; NO-VP-NEXT: [[TMP8:%.*]] = mul nuw i64 [[TMP7]], 4 |
| ; NO-VP-NEXT: [[N_MOD_VF:%.*]] = urem i64 [[N]], [[TMP8]] |
| ; NO-VP-NEXT: [[N_VEC:%.*]] = sub i64 [[N]], [[N_MOD_VF]] |
| ; NO-VP-NEXT: br label %[[VECTOR_BODY:.*]] |
| ; NO-VP: [[VECTOR_BODY]]: |
| ; NO-VP-NEXT: [[IV:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ] |
| ; NO-VP-NEXT: [[GEP:%.*]] = getelementptr inbounds float, ptr [[B]], i64 [[IV]] |
| ; NO-VP-NEXT: [[WIDE_LOAD:%.*]] = load <vscale x 4 x float>, ptr [[GEP]], align 4 |
| ; NO-VP-NEXT: [[TMP12:%.*]] = fpext <vscale x 4 x float> [[WIDE_LOAD]] to <vscale x 4 x double> |
| ; NO-VP-NEXT: [[TMP13:%.*]] = call <vscale x 4 x i64> @llvm.lrint.nxv4i64.nxv4f64(<vscale x 4 x double> [[TMP12]]) |
| ; NO-VP-NEXT: [[TMP14:%.*]] = trunc <vscale x 4 x i64> [[TMP13]] to <vscale x 4 x i32> |
| ; NO-VP-NEXT: [[TMP15:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[IV]] |
| ; NO-VP-NEXT: store <vscale x 4 x i32> [[TMP14]], ptr [[TMP15]], align 4 |
| ; NO-VP-NEXT: [[INDEX_NEXT]] = add nuw i64 [[IV]], [[TMP8]] |
| ; NO-VP-NEXT: [[TMP16:%.*]] = icmp eq i64 [[INDEX_NEXT]], [[N_VEC]] |
| ; NO-VP-NEXT: br i1 [[TMP16]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP14:![0-9]+]] |
| ; NO-VP: [[MIDDLE_BLOCK]]: |
| ; NO-VP-NEXT: [[CMP_N:%.*]] = icmp eq i64 [[N]], [[N_VEC]] |
| ; NO-VP-NEXT: br i1 [[CMP_N]], label %[[EXIT:.*]], label %[[SCALAR_PH]] |
| ; NO-VP: [[SCALAR_PH]]: |
| ; NO-VP-NEXT: [[BC_RESUME_VAL:%.*]] = phi i64 [ [[N_VEC]], %[[MIDDLE_BLOCK]] ], [ 0, %[[ENTRY]] ], [ 0, %[[VECTOR_MEMCHECK]] ] |
| ; NO-VP-NEXT: br label %[[LOOP:.*]] |
| ; NO-VP: [[LOOP]]: |
| ; NO-VP-NEXT: [[IV1:%.*]] = phi i64 [ [[IV_NEXT:%.*]], %[[LOOP]] ], [ [[BC_RESUME_VAL]], %[[SCALAR_PH]] ] |
| ; NO-VP-NEXT: [[GEP1:%.*]] = getelementptr inbounds float, ptr [[B]], i64 [[IV1]] |
| ; NO-VP-NEXT: [[TMP0:%.*]] = load float, ptr [[GEP1]], align 4 |
| ; NO-VP-NEXT: [[CONV2:%.*]] = fpext float [[TMP0]] to double |
| ; NO-VP-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.lrint.i64.f64(double [[CONV2]]) |
| ; NO-VP-NEXT: [[CONV3:%.*]] = trunc i64 [[TMP1]] to i32 |
| ; NO-VP-NEXT: [[GEP5:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[IV1]] |
| ; NO-VP-NEXT: store i32 [[CONV3]], ptr [[GEP5]], align 4 |
| ; NO-VP-NEXT: [[IV_NEXT]] = add nuw nsw i64 [[IV1]], 1 |
| ; NO-VP-NEXT: [[EXITCOND_NOT:%.*]] = icmp eq i64 [[IV_NEXT]], [[N]] |
| ; NO-VP-NEXT: br i1 [[EXITCOND_NOT]], label %[[EXIT]], label %[[LOOP]], !llvm.loop [[LOOP15:![0-9]+]] |
| ; NO-VP: [[EXIT]]: |
| ; NO-VP-NEXT: ret void |
| ; |
| |
| entry: |
| br label %loop |
| |
| loop: |
| %iv = phi i64 [ %iv.next, %loop ], [ 0, %entry ] |
| %gep = getelementptr inbounds float, ptr %b, i64 %iv |
| %0 = load float, ptr %gep, align 4 |
| %conv2 = fpext float %0 to double |
| %1 = tail call i64 @llvm.lrint.i64.f64(double %conv2) |
| %conv3 = trunc i64 %1 to i32 |
| %gep5 = getelementptr inbounds i32, ptr %a, i64 %iv |
| store i32 %conv3, ptr %gep5, align 4 |
| %iv.next = add nuw nsw i64 %iv, 1 |
| %exitcond.not = icmp eq i64 %iv.next, %N |
| br i1 %exitcond.not, label %exit, label %loop |
| |
| exit: |
| ret void |
| } |
| |
| define void @vp_llrint(ptr %a, ptr %b, i64 %N) { |
| ; IF-EVL-LABEL: define void @vp_llrint( |
| ; IF-EVL-SAME: ptr [[A:%.*]], ptr [[B:%.*]], i64 [[N:%.*]]) #[[ATTR0]] { |
| ; IF-EVL-NEXT: [[ENTRY:.*:]] |
| ; IF-EVL-NEXT: [[B2:%.*]] = ptrtoint ptr [[B]] to i64 |
| ; IF-EVL-NEXT: [[A1:%.*]] = ptrtoint ptr [[A]] to i64 |
| ; IF-EVL-NEXT: br label %[[VECTOR_MEMCHECK:.*]] |
| ; IF-EVL: [[VECTOR_MEMCHECK]]: |
| ; IF-EVL-NEXT: [[TMP4:%.*]] = call i64 @llvm.vscale.i64() |
| ; IF-EVL-NEXT: [[TMP5:%.*]] = mul nuw i64 [[TMP4]], 4 |
| ; IF-EVL-NEXT: [[TMP23:%.*]] = mul i64 [[TMP5]], 4 |
| ; IF-EVL-NEXT: [[TMP24:%.*]] = sub i64 [[A1]], [[B2]] |
| ; IF-EVL-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP24]], [[TMP23]] |
| ; IF-EVL-NEXT: br i1 [[DIFF_CHECK]], label %[[SCALAR_PH:.*]], label %[[VECTOR_PH:.*]] |
| ; IF-EVL: [[VECTOR_PH]]: |
| ; IF-EVL-NEXT: br label %[[VECTOR_BODY:.*]] |
| ; IF-EVL: [[VECTOR_BODY]]: |
| ; IF-EVL-NEXT: [[EVL_BASED_IV:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_EVL_NEXT:%.*]], %[[VECTOR_BODY]] ] |
| ; IF-EVL-NEXT: [[AVL:%.*]] = phi i64 [ [[N]], %[[VECTOR_PH]] ], [ [[AVL_NEXT:%.*]], %[[VECTOR_BODY]] ] |
| ; IF-EVL-NEXT: [[TMP9:%.*]] = call i32 @llvm.experimental.get.vector.length.i64(i64 [[AVL]], i32 4, i1 true) |
| ; IF-EVL-NEXT: [[TMP11:%.*]] = getelementptr inbounds float, ptr [[B]], i64 [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: [[VP_OP_LOAD:%.*]] = call <vscale x 4 x float> @llvm.vp.load.nxv4f32.p0(ptr align 4 [[TMP11]], <vscale x 4 x i1> splat (i1 true), i32 [[TMP9]]) |
| ; IF-EVL-NEXT: [[TMP27:%.*]] = fpext <vscale x 4 x float> [[VP_OP_LOAD]] to <vscale x 4 x double> |
| ; IF-EVL-NEXT: [[TMP28:%.*]] = call <vscale x 4 x i64> @llvm.llrint.nxv4i64.nxv4f64(<vscale x 4 x double> [[TMP27]]) |
| ; IF-EVL-NEXT: [[TMP15:%.*]] = trunc <vscale x 4 x i64> [[TMP28]] to <vscale x 4 x i32> |
| ; IF-EVL-NEXT: [[TMP16:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: call void @llvm.vp.store.nxv4i32.p0(<vscale x 4 x i32> [[TMP15]], ptr align 4 [[TMP16]], <vscale x 4 x i1> splat (i1 true), i32 [[TMP9]]) |
| ; IF-EVL-NEXT: [[TMP18:%.*]] = zext i32 [[TMP9]] to i64 |
| ; IF-EVL-NEXT: [[INDEX_EVL_NEXT]] = add i64 [[TMP18]], [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: [[AVL_NEXT]] = sub nuw i64 [[AVL]], [[TMP18]] |
| ; IF-EVL-NEXT: [[TMP17:%.*]] = icmp eq i64 [[AVL_NEXT]], 0 |
| ; IF-EVL-NEXT: br i1 [[TMP17]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP16:![0-9]+]] |
| ; IF-EVL: [[MIDDLE_BLOCK]]: |
| ; IF-EVL-NEXT: br label %[[EXIT:.*]] |
| ; IF-EVL: [[SCALAR_PH]]: |
| ; IF-EVL-NEXT: br label %[[LOOP:.*]] |
| ; IF-EVL: [[LOOP]]: |
| ; IF-EVL-NEXT: [[IV:%.*]] = phi i64 [ [[IV_NEXT:%.*]], %[[LOOP]] ], [ 0, %[[SCALAR_PH]] ] |
| ; IF-EVL-NEXT: [[GEP:%.*]] = getelementptr inbounds float, ptr [[B]], i64 [[IV]] |
| ; IF-EVL-NEXT: [[TMP20:%.*]] = load float, ptr [[GEP]], align 4 |
| ; IF-EVL-NEXT: [[CONV2:%.*]] = fpext float [[TMP20]] to double |
| ; IF-EVL-NEXT: [[TMP21:%.*]] = tail call i64 @llvm.llrint.i64.f64(double [[CONV2]]) |
| ; IF-EVL-NEXT: [[CONV3:%.*]] = trunc i64 [[TMP21]] to i32 |
| ; IF-EVL-NEXT: [[GEP5:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[IV]] |
| ; IF-EVL-NEXT: store i32 [[CONV3]], ptr [[GEP5]], align 4 |
| ; IF-EVL-NEXT: [[IV_NEXT]] = add nuw nsw i64 [[IV]], 1 |
| ; IF-EVL-NEXT: [[EXITCOND_NOT:%.*]] = icmp eq i64 [[IV_NEXT]], [[N]] |
| ; IF-EVL-NEXT: br i1 [[EXITCOND_NOT]], label %[[EXIT]], label %[[LOOP]], !llvm.loop [[LOOP17:![0-9]+]] |
| ; IF-EVL: [[EXIT]]: |
| ; IF-EVL-NEXT: ret void |
| ; |
| ; NO-VP-LABEL: define void @vp_llrint( |
| ; NO-VP-SAME: ptr [[A:%.*]], ptr [[B:%.*]], i64 [[N:%.*]]) #[[ATTR0]] { |
| ; NO-VP-NEXT: [[ENTRY:.*]]: |
| ; NO-VP-NEXT: [[B2:%.*]] = ptrtoint ptr [[B]] to i64 |
| ; NO-VP-NEXT: [[A1:%.*]] = ptrtoint ptr [[A]] to i64 |
| ; NO-VP-NEXT: [[TMP10:%.*]] = call i64 @llvm.vscale.i64() |
| ; NO-VP-NEXT: [[TMP9:%.*]] = shl nuw i64 [[TMP10]], 2 |
| ; NO-VP-NEXT: [[TMP2:%.*]] = call i64 @llvm.umax.i64(i64 [[TMP9]], i64 16) |
| ; NO-VP-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[N]], [[TMP2]] |
| ; NO-VP-NEXT: br i1 [[MIN_ITERS_CHECK]], label %[[SCALAR_PH:.*]], label %[[VECTOR_MEMCHECK:.*]] |
| ; NO-VP: [[VECTOR_MEMCHECK]]: |
| ; NO-VP-NEXT: [[TMP3:%.*]] = call i64 @llvm.vscale.i64() |
| ; NO-VP-NEXT: [[TMP4:%.*]] = mul nuw i64 [[TMP3]], 4 |
| ; NO-VP-NEXT: [[TMP5:%.*]] = mul i64 [[TMP4]], 4 |
| ; NO-VP-NEXT: [[TMP6:%.*]] = sub i64 [[A1]], [[B2]] |
| ; NO-VP-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP6]], [[TMP5]] |
| ; NO-VP-NEXT: br i1 [[DIFF_CHECK]], label %[[SCALAR_PH]], label %[[VECTOR_PH:.*]] |
| ; NO-VP: [[VECTOR_PH]]: |
| ; NO-VP-NEXT: [[TMP7:%.*]] = call i64 @llvm.vscale.i64() |
| ; NO-VP-NEXT: [[TMP8:%.*]] = mul nuw i64 [[TMP7]], 4 |
| ; NO-VP-NEXT: [[N_MOD_VF:%.*]] = urem i64 [[N]], [[TMP8]] |
| ; NO-VP-NEXT: [[N_VEC:%.*]] = sub i64 [[N]], [[N_MOD_VF]] |
| ; NO-VP-NEXT: br label %[[VECTOR_BODY:.*]] |
| ; NO-VP: [[VECTOR_BODY]]: |
| ; NO-VP-NEXT: [[IV:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ] |
| ; NO-VP-NEXT: [[GEP:%.*]] = getelementptr inbounds float, ptr [[B]], i64 [[IV]] |
| ; NO-VP-NEXT: [[WIDE_LOAD:%.*]] = load <vscale x 4 x float>, ptr [[GEP]], align 4 |
| ; NO-VP-NEXT: [[TMP12:%.*]] = fpext <vscale x 4 x float> [[WIDE_LOAD]] to <vscale x 4 x double> |
| ; NO-VP-NEXT: [[TMP13:%.*]] = call <vscale x 4 x i64> @llvm.llrint.nxv4i64.nxv4f64(<vscale x 4 x double> [[TMP12]]) |
| ; NO-VP-NEXT: [[TMP14:%.*]] = trunc <vscale x 4 x i64> [[TMP13]] to <vscale x 4 x i32> |
| ; NO-VP-NEXT: [[TMP15:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[IV]] |
| ; NO-VP-NEXT: store <vscale x 4 x i32> [[TMP14]], ptr [[TMP15]], align 4 |
| ; NO-VP-NEXT: [[INDEX_NEXT]] = add nuw i64 [[IV]], [[TMP8]] |
| ; NO-VP-NEXT: [[TMP16:%.*]] = icmp eq i64 [[INDEX_NEXT]], [[N_VEC]] |
| ; NO-VP-NEXT: br i1 [[TMP16]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP16:![0-9]+]] |
| ; NO-VP: [[MIDDLE_BLOCK]]: |
| ; NO-VP-NEXT: [[CMP_N:%.*]] = icmp eq i64 [[N]], [[N_VEC]] |
| ; NO-VP-NEXT: br i1 [[CMP_N]], label %[[EXIT:.*]], label %[[SCALAR_PH]] |
| ; NO-VP: [[SCALAR_PH]]: |
| ; NO-VP-NEXT: [[BC_RESUME_VAL:%.*]] = phi i64 [ [[N_VEC]], %[[MIDDLE_BLOCK]] ], [ 0, %[[ENTRY]] ], [ 0, %[[VECTOR_MEMCHECK]] ] |
| ; NO-VP-NEXT: br label %[[LOOP:.*]] |
| ; NO-VP: [[LOOP]]: |
| ; NO-VP-NEXT: [[IV1:%.*]] = phi i64 [ [[IV_NEXT:%.*]], %[[LOOP]] ], [ [[BC_RESUME_VAL]], %[[SCALAR_PH]] ] |
| ; NO-VP-NEXT: [[GEP1:%.*]] = getelementptr inbounds float, ptr [[B]], i64 [[IV1]] |
| ; NO-VP-NEXT: [[TMP0:%.*]] = load float, ptr [[GEP1]], align 4 |
| ; NO-VP-NEXT: [[CONV2:%.*]] = fpext float [[TMP0]] to double |
| ; NO-VP-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.llrint.i64.f64(double [[CONV2]]) |
| ; NO-VP-NEXT: [[CONV3:%.*]] = trunc i64 [[TMP1]] to i32 |
| ; NO-VP-NEXT: [[GEP5:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[IV1]] |
| ; NO-VP-NEXT: store i32 [[CONV3]], ptr [[GEP5]], align 4 |
| ; NO-VP-NEXT: [[IV_NEXT]] = add nuw nsw i64 [[IV1]], 1 |
| ; NO-VP-NEXT: [[EXITCOND_NOT:%.*]] = icmp eq i64 [[IV_NEXT]], [[N]] |
| ; NO-VP-NEXT: br i1 [[EXITCOND_NOT]], label %[[EXIT]], label %[[LOOP]], !llvm.loop [[LOOP17:![0-9]+]] |
| ; NO-VP: [[EXIT]]: |
| ; NO-VP-NEXT: ret void |
| ; |
| |
| entry: |
| br label %loop |
| |
| loop: |
| %iv = phi i64 [ %iv.next, %loop ], [ 0, %entry ] |
| %gep = getelementptr inbounds float, ptr %b, i64 %iv |
| %0 = load float, ptr %gep, align 4 |
| %conv2 = fpext float %0 to double |
| %1 = tail call i64 @llvm.llrint.i64.f64(double %conv2) |
| %conv3 = trunc i64 %1 to i32 |
| %gep5 = getelementptr inbounds i32, ptr %a, i64 %iv |
| store i32 %conv3, ptr %gep5, align 4 |
| %iv.next = add nuw nsw i64 %iv, 1 |
| %exitcond.not = icmp eq i64 %iv.next, %N |
| br i1 %exitcond.not, label %exit, label %loop |
| |
| exit: |
| ret void |
| } |
| |
| define void @vp_abs(ptr %a, ptr %b, i64 %N) { |
| ; IF-EVL-LABEL: define void @vp_abs( |
| ; IF-EVL-SAME: ptr [[A:%.*]], ptr [[B:%.*]], i64 [[N:%.*]]) #[[ATTR0]] { |
| ; IF-EVL-NEXT: [[ENTRY:.*:]] |
| ; IF-EVL-NEXT: [[B2:%.*]] = ptrtoint ptr [[B]] to i64 |
| ; IF-EVL-NEXT: [[A1:%.*]] = ptrtoint ptr [[A]] to i64 |
| ; IF-EVL-NEXT: br label %[[VECTOR_MEMCHECK:.*]] |
| ; IF-EVL: [[VECTOR_MEMCHECK]]: |
| ; IF-EVL-NEXT: [[TMP4:%.*]] = call i64 @llvm.vscale.i64() |
| ; IF-EVL-NEXT: [[TMP5:%.*]] = mul nuw i64 [[TMP4]], 4 |
| ; IF-EVL-NEXT: [[TMP20:%.*]] = mul i64 [[TMP5]], 4 |
| ; IF-EVL-NEXT: [[TMP21:%.*]] = sub i64 [[A1]], [[B2]] |
| ; IF-EVL-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP21]], [[TMP20]] |
| ; IF-EVL-NEXT: br i1 [[DIFF_CHECK]], label %[[SCALAR_PH:.*]], label %[[VECTOR_PH:.*]] |
| ; IF-EVL: [[VECTOR_PH]]: |
| ; IF-EVL-NEXT: br label %[[VECTOR_BODY:.*]] |
| ; IF-EVL: [[VECTOR_BODY]]: |
| ; IF-EVL-NEXT: [[EVL_BASED_IV:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_EVL_NEXT:%.*]], %[[VECTOR_BODY]] ] |
| ; IF-EVL-NEXT: [[AVL:%.*]] = phi i64 [ [[N]], %[[VECTOR_PH]] ], [ [[AVL_NEXT:%.*]], %[[VECTOR_BODY]] ] |
| ; IF-EVL-NEXT: [[TMP9:%.*]] = call i32 @llvm.experimental.get.vector.length.i64(i64 [[AVL]], i32 4, i1 true) |
| ; IF-EVL-NEXT: [[TMP11:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: [[VP_OP_LOAD:%.*]] = call <vscale x 4 x i32> @llvm.vp.load.nxv4i32.p0(ptr align 4 [[TMP11]], <vscale x 4 x i1> splat (i1 true), i32 [[TMP9]]) |
| ; IF-EVL-NEXT: [[TMP24:%.*]] = call <vscale x 4 x i32> @llvm.abs.nxv4i32(<vscale x 4 x i32> [[VP_OP_LOAD]], i1 true) |
| ; IF-EVL-NEXT: [[TMP14:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: call void @llvm.vp.store.nxv4i32.p0(<vscale x 4 x i32> [[TMP24]], ptr align 4 [[TMP14]], <vscale x 4 x i1> splat (i1 true), i32 [[TMP9]]) |
| ; IF-EVL-NEXT: [[TMP16:%.*]] = zext i32 [[TMP9]] to i64 |
| ; IF-EVL-NEXT: [[INDEX_EVL_NEXT]] = add i64 [[TMP16]], [[EVL_BASED_IV]] |
| ; IF-EVL-NEXT: [[AVL_NEXT]] = sub nuw i64 [[AVL]], [[TMP16]] |
| ; IF-EVL-NEXT: [[TMP15:%.*]] = icmp eq i64 [[AVL_NEXT]], 0 |
| ; IF-EVL-NEXT: br i1 [[TMP15]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP18:![0-9]+]] |
| ; IF-EVL: [[MIDDLE_BLOCK]]: |
| ; IF-EVL-NEXT: br label %[[EXIT:.*]] |
| ; IF-EVL: [[SCALAR_PH]]: |
| ; IF-EVL-NEXT: br label %[[LOOP:.*]] |
| ; IF-EVL: [[LOOP]]: |
| ; IF-EVL-NEXT: [[IV:%.*]] = phi i64 [ [[IV_NEXT:%.*]], %[[LOOP]] ], [ 0, %[[SCALAR_PH]] ] |
| ; IF-EVL-NEXT: [[GEP:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[IV]] |
| ; IF-EVL-NEXT: [[TMP18:%.*]] = load i32, ptr [[GEP]], align 4 |
| ; IF-EVL-NEXT: [[COND:%.*]] = tail call i32 @llvm.abs.i32(i32 [[TMP18]], i1 true) |
| ; IF-EVL-NEXT: [[GEP9:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[IV]] |
| ; IF-EVL-NEXT: store i32 [[COND]], ptr [[GEP9]], align 4 |
| ; IF-EVL-NEXT: [[IV_NEXT]] = add nuw nsw i64 [[IV]], 1 |
| ; IF-EVL-NEXT: [[EXITCOND_NOT:%.*]] = icmp eq i64 [[IV_NEXT]], [[N]] |
| ; IF-EVL-NEXT: br i1 [[EXITCOND_NOT]], label %[[EXIT]], label %[[LOOP]], !llvm.loop [[LOOP19:![0-9]+]] |
| ; IF-EVL: [[EXIT]]: |
| ; IF-EVL-NEXT: ret void |
| ; |
| ; NO-VP-LABEL: define void @vp_abs( |
| ; NO-VP-SAME: ptr [[A:%.*]], ptr [[B:%.*]], i64 [[N:%.*]]) #[[ATTR0]] { |
| ; NO-VP-NEXT: [[ENTRY:.*]]: |
| ; NO-VP-NEXT: [[B2:%.*]] = ptrtoint ptr [[B]] to i64 |
| ; NO-VP-NEXT: [[A1:%.*]] = ptrtoint ptr [[A]] to i64 |
| ; NO-VP-NEXT: [[TMP9:%.*]] = call i64 @llvm.vscale.i64() |
| ; NO-VP-NEXT: [[TMP1:%.*]] = shl nuw i64 [[TMP9]], 2 |
| ; NO-VP-NEXT: [[TMP2:%.*]] = call i64 @llvm.umax.i64(i64 [[TMP1]], i64 8) |
| ; NO-VP-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[N]], [[TMP2]] |
| ; NO-VP-NEXT: br i1 [[MIN_ITERS_CHECK]], label %[[SCALAR_PH:.*]], label %[[VECTOR_MEMCHECK:.*]] |
| ; NO-VP: [[VECTOR_MEMCHECK]]: |
| ; NO-VP-NEXT: [[TMP3:%.*]] = call i64 @llvm.vscale.i64() |
| ; NO-VP-NEXT: [[TMP4:%.*]] = mul nuw i64 [[TMP3]], 4 |
| ; NO-VP-NEXT: [[TMP5:%.*]] = mul i64 [[TMP4]], 4 |
| ; NO-VP-NEXT: [[TMP6:%.*]] = sub i64 [[A1]], [[B2]] |
| ; NO-VP-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP6]], [[TMP5]] |
| ; NO-VP-NEXT: br i1 [[DIFF_CHECK]], label %[[SCALAR_PH]], label %[[VECTOR_PH:.*]] |
| ; NO-VP: [[VECTOR_PH]]: |
| ; NO-VP-NEXT: [[TMP7:%.*]] = call i64 @llvm.vscale.i64() |
| ; NO-VP-NEXT: [[TMP8:%.*]] = mul nuw i64 [[TMP7]], 4 |
| ; NO-VP-NEXT: [[N_MOD_VF:%.*]] = urem i64 [[N]], [[TMP8]] |
| ; NO-VP-NEXT: [[N_VEC:%.*]] = sub i64 [[N]], [[N_MOD_VF]] |
| ; NO-VP-NEXT: br label %[[VECTOR_BODY:.*]] |
| ; NO-VP: [[VECTOR_BODY]]: |
| ; NO-VP-NEXT: [[IV:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ] |
| ; NO-VP-NEXT: [[GEP:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[IV]] |
| ; NO-VP-NEXT: [[WIDE_LOAD:%.*]] = load <vscale x 4 x i32>, ptr [[GEP]], align 4 |
| ; NO-VP-NEXT: [[TMP12:%.*]] = call <vscale x 4 x i32> @llvm.abs.nxv4i32(<vscale x 4 x i32> [[WIDE_LOAD]], i1 true) |
| ; NO-VP-NEXT: [[TMP13:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[IV]] |
| ; NO-VP-NEXT: store <vscale x 4 x i32> [[TMP12]], ptr [[TMP13]], align 4 |
| ; NO-VP-NEXT: [[INDEX_NEXT]] = add nuw i64 [[IV]], [[TMP8]] |
| ; NO-VP-NEXT: [[TMP14:%.*]] = icmp eq i64 [[INDEX_NEXT]], [[N_VEC]] |
| ; NO-VP-NEXT: br i1 [[TMP14]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP18:![0-9]+]] |
| ; NO-VP: [[MIDDLE_BLOCK]]: |
| ; NO-VP-NEXT: [[CMP_N:%.*]] = icmp eq i64 [[N]], [[N_VEC]] |
| ; NO-VP-NEXT: br i1 [[CMP_N]], label %[[EXIT:.*]], label %[[SCALAR_PH]] |
| ; NO-VP: [[SCALAR_PH]]: |
| ; NO-VP-NEXT: [[BC_RESUME_VAL:%.*]] = phi i64 [ [[N_VEC]], %[[MIDDLE_BLOCK]] ], [ 0, %[[ENTRY]] ], [ 0, %[[VECTOR_MEMCHECK]] ] |
| ; NO-VP-NEXT: br label %[[LOOP:.*]] |
| ; NO-VP: [[LOOP]]: |
| ; NO-VP-NEXT: [[IV1:%.*]] = phi i64 [ [[IV_NEXT:%.*]], %[[LOOP]] ], [ [[BC_RESUME_VAL]], %[[SCALAR_PH]] ] |
| ; NO-VP-NEXT: [[GEP1:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[IV1]] |
| ; NO-VP-NEXT: [[TMP0:%.*]] = load i32, ptr [[GEP1]], align 4 |
| ; NO-VP-NEXT: [[COND:%.*]] = tail call i32 @llvm.abs.i32(i32 [[TMP0]], i1 true) |
| ; NO-VP-NEXT: [[GEP9:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[IV1]] |
| ; NO-VP-NEXT: store i32 [[COND]], ptr [[GEP9]], align 4 |
| ; NO-VP-NEXT: [[IV_NEXT]] = add nuw nsw i64 [[IV1]], 1 |
| ; NO-VP-NEXT: [[EXITCOND_NOT:%.*]] = icmp eq i64 [[IV_NEXT]], [[N]] |
| ; NO-VP-NEXT: br i1 [[EXITCOND_NOT]], label %[[EXIT]], label %[[LOOP]], !llvm.loop [[LOOP19:![0-9]+]] |
| ; NO-VP: [[EXIT]]: |
| ; NO-VP-NEXT: ret void |
| ; |
| |
| entry: |
| br label %loop |
| |
| loop: |
| %iv = phi i64 [ %iv.next, %loop ], [ 0, %entry ] |
| %gep = getelementptr inbounds i32, ptr %b, i64 %iv |
| %0 = load i32, ptr %gep, align 4 |
| %cond = tail call i32 @llvm.abs.i32(i32 %0, i1 true) |
| %gep9 = getelementptr inbounds i32, ptr %a, i64 %iv |
| store i32 %cond, ptr %gep9, align 4 |
| %iv.next = add nuw nsw i64 %iv, 1 |
| %exitcond.not = icmp eq i64 %iv.next, %N |
| br i1 %exitcond.not, label %exit, label %loop |
| |
| exit: |
| ret void |
| } |
| |
| ; There's no @llvm.vp.log10, so don't transform it. |
| define void @log10(ptr %a, ptr %b, i64 %N) { |
| ; IF-EVL-LABEL: define void @log10( |
| ; IF-EVL-SAME: ptr [[A:%.*]], ptr [[B:%.*]], i64 [[N:%.*]]) #[[ATTR0]] { |
| ; IF-EVL-NEXT: [[ENTRY:.*]]: |
| ; IF-EVL-NEXT: br label %[[LOOP:.*]] |
| ; IF-EVL: [[LOOP]]: |
| ; IF-EVL-NEXT: [[IV:%.*]] = phi i64 [ [[IV_NEXT:%.*]], %[[LOOP]] ], [ 0, %[[ENTRY]] ] |
| ; IF-EVL-NEXT: [[GEP:%.*]] = getelementptr inbounds float, ptr [[B]], i64 [[IV]] |
| ; IF-EVL-NEXT: [[TMP0:%.*]] = load float, ptr [[GEP]], align 4 |
| ; IF-EVL-NEXT: [[COND:%.*]] = tail call float @llvm.log10.f32(float [[TMP0]]) |
| ; IF-EVL-NEXT: [[GEP9:%.*]] = getelementptr inbounds float, ptr [[A]], i64 [[IV]] |
| ; IF-EVL-NEXT: store float [[COND]], ptr [[GEP9]], align 4 |
| ; IF-EVL-NEXT: [[IV_NEXT]] = add nuw nsw i64 [[IV]], 1 |
| ; IF-EVL-NEXT: [[EXITCOND_NOT:%.*]] = icmp eq i64 [[IV_NEXT]], [[N]] |
| ; IF-EVL-NEXT: br i1 [[EXITCOND_NOT]], label %[[EXIT:.*]], label %[[LOOP]] |
| ; IF-EVL: [[EXIT]]: |
| ; IF-EVL-NEXT: ret void |
| ; |
| ; NO-VP-LABEL: define void @log10( |
| ; NO-VP-SAME: ptr [[A:%.*]], ptr [[B:%.*]], i64 [[N:%.*]]) #[[ATTR0]] { |
| ; NO-VP-NEXT: [[ENTRY:.*]]: |
| ; NO-VP-NEXT: [[B2:%.*]] = ptrtoint ptr [[B]] to i64 |
| ; NO-VP-NEXT: [[A1:%.*]] = ptrtoint ptr [[A]] to i64 |
| ; NO-VP-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[N]], 8 |
| ; NO-VP-NEXT: br i1 [[MIN_ITERS_CHECK]], label %[[SCALAR_PH:.*]], label %[[VECTOR_MEMCHECK:.*]] |
| ; NO-VP: [[VECTOR_MEMCHECK]]: |
| ; NO-VP-NEXT: [[TMP1:%.*]] = sub i64 [[A1]], [[B2]] |
| ; NO-VP-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP1]], 16 |
| ; NO-VP-NEXT: br i1 [[DIFF_CHECK]], label %[[SCALAR_PH]], label %[[VECTOR_PH:.*]] |
| ; NO-VP: [[VECTOR_PH]]: |
| ; NO-VP-NEXT: [[N_MOD_VF:%.*]] = urem i64 [[N]], 4 |
| ; NO-VP-NEXT: [[N_VEC:%.*]] = sub i64 [[N]], [[N_MOD_VF]] |
| ; NO-VP-NEXT: br label %[[VECTOR_BODY:.*]] |
| ; NO-VP: [[VECTOR_BODY]]: |
| ; NO-VP-NEXT: [[IV:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ] |
| ; NO-VP-NEXT: [[GEP:%.*]] = getelementptr inbounds float, ptr [[B]], i64 [[IV]] |
| ; NO-VP-NEXT: [[WIDE_LOAD:%.*]] = load <4 x float>, ptr [[GEP]], align 4 |
| ; NO-VP-NEXT: [[TMP2:%.*]] = call <4 x float> @llvm.log10.v4f32(<4 x float> [[WIDE_LOAD]]) |
| ; NO-VP-NEXT: [[TMP3:%.*]] = getelementptr inbounds float, ptr [[A]], i64 [[IV]] |
| ; NO-VP-NEXT: store <4 x float> [[TMP2]], ptr [[TMP3]], align 4 |
| ; NO-VP-NEXT: [[INDEX_NEXT]] = add nuw i64 [[IV]], 4 |
| ; NO-VP-NEXT: [[TMP4:%.*]] = icmp eq i64 [[INDEX_NEXT]], [[N_VEC]] |
| ; NO-VP-NEXT: br i1 [[TMP4]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP20:![0-9]+]] |
| ; NO-VP: [[MIDDLE_BLOCK]]: |
| ; NO-VP-NEXT: [[CMP_N:%.*]] = icmp eq i64 [[N]], [[N_VEC]] |
| ; NO-VP-NEXT: br i1 [[CMP_N]], label %[[EXIT:.*]], label %[[SCALAR_PH]] |
| ; NO-VP: [[SCALAR_PH]]: |
| ; NO-VP-NEXT: [[BC_RESUME_VAL:%.*]] = phi i64 [ [[N_VEC]], %[[MIDDLE_BLOCK]] ], [ 0, %[[ENTRY]] ], [ 0, %[[VECTOR_MEMCHECK]] ] |
| ; NO-VP-NEXT: br label %[[LOOP:.*]] |
| ; NO-VP: [[LOOP]]: |
| ; NO-VP-NEXT: [[IV1:%.*]] = phi i64 [ [[IV_NEXT:%.*]], %[[LOOP]] ], [ [[BC_RESUME_VAL]], %[[SCALAR_PH]] ] |
| ; NO-VP-NEXT: [[GEP1:%.*]] = getelementptr inbounds float, ptr [[B]], i64 [[IV1]] |
| ; NO-VP-NEXT: [[TMP0:%.*]] = load float, ptr [[GEP1]], align 4 |
| ; NO-VP-NEXT: [[COND:%.*]] = tail call float @llvm.log10.f32(float [[TMP0]]) |
| ; NO-VP-NEXT: [[GEP9:%.*]] = getelementptr inbounds float, ptr [[A]], i64 [[IV1]] |
| ; NO-VP-NEXT: store float [[COND]], ptr [[GEP9]], align 4 |
| ; NO-VP-NEXT: [[IV_NEXT]] = add nuw nsw i64 [[IV1]], 1 |
| ; NO-VP-NEXT: [[EXITCOND_NOT:%.*]] = icmp eq i64 [[IV_NEXT]], [[N]] |
| ; NO-VP-NEXT: br i1 [[EXITCOND_NOT]], label %[[EXIT]], label %[[LOOP]], !llvm.loop [[LOOP21:![0-9]+]] |
| ; NO-VP: [[EXIT]]: |
| ; NO-VP-NEXT: ret void |
| ; |
| |
| entry: |
| br label %loop |
| |
| loop: |
| %iv = phi i64 [ %iv.next, %loop ], [ 0, %entry ] |
| %gep = getelementptr inbounds float, ptr %b, i64 %iv |
| %0 = load float, ptr %gep, align 4 |
| %cond = tail call float @llvm.log10.f32(float %0) |
| %gep9 = getelementptr inbounds float, ptr %a, i64 %iv |
| store float %cond, ptr %gep9, align 4 |
| %iv.next = add nuw nsw i64 %iv, 1 |
| %exitcond.not = icmp eq i64 %iv.next, %N |
| br i1 %exitcond.not, label %exit, label %loop |
| |
| exit: |
| ret void |
| } |
| |
| |
| declare i32 @llvm.smax.i32(i32, i32) |
| declare i32 @llvm.smin.i32(i32, i32) |
| declare i32 @llvm.umax.i32(i32, i32) |
| declare i32 @llvm.umin.i32(i32, i32) |
| declare i32 @llvm.ctlz.i32(i32, i1 immarg) |
| declare i32 @llvm.cttz.i32(i32, i1 immarg) |
| declare i64 @llvm.lrint.i64.f64(double) |
| declare i64 @llvm.llrint.i64.f64(double) |
| declare i32 @llvm.abs.i32(i32, i1 immarg) |
| ;. |
| ; IF-EVL: [[LOOP0]] = distinct !{[[LOOP0]], [[META1:![0-9]+]], [[META2:![0-9]+]]} |
| ; IF-EVL: [[META1]] = !{!"llvm.loop.isvectorized", i32 1} |
| ; IF-EVL: [[META2]] = !{!"llvm.loop.unroll.runtime.disable"} |
| ; IF-EVL: [[LOOP3]] = distinct !{[[LOOP3]], [[META1]]} |
| ; IF-EVL: [[LOOP4]] = distinct !{[[LOOP4]], [[META1]], [[META2]]} |
| ; IF-EVL: [[LOOP5]] = distinct !{[[LOOP5]], [[META1]]} |
| ; IF-EVL: [[LOOP6]] = distinct !{[[LOOP6]], [[META1]], [[META2]]} |
| ; IF-EVL: [[LOOP7]] = distinct !{[[LOOP7]], [[META1]]} |
| ; IF-EVL: [[LOOP8]] = distinct !{[[LOOP8]], [[META1]], [[META2]]} |
| ; IF-EVL: [[LOOP9]] = distinct !{[[LOOP9]], [[META1]]} |
| ; IF-EVL: [[LOOP10]] = distinct !{[[LOOP10]], [[META1]], [[META2]]} |
| ; IF-EVL: [[LOOP11]] = distinct !{[[LOOP11]], [[META1]]} |
| ; IF-EVL: [[LOOP12]] = distinct !{[[LOOP12]], [[META1]], [[META2]]} |
| ; IF-EVL: [[LOOP13]] = distinct !{[[LOOP13]], [[META1]]} |
| ; IF-EVL: [[LOOP14]] = distinct !{[[LOOP14]], [[META1]], [[META2]]} |
| ; IF-EVL: [[LOOP15]] = distinct !{[[LOOP15]], [[META1]]} |
| ; IF-EVL: [[LOOP16]] = distinct !{[[LOOP16]], [[META1]], [[META2]]} |
| ; IF-EVL: [[LOOP17]] = distinct !{[[LOOP17]], [[META1]]} |
| ; IF-EVL: [[LOOP18]] = distinct !{[[LOOP18]], [[META1]], [[META2]]} |
| ; IF-EVL: [[LOOP19]] = distinct !{[[LOOP19]], [[META1]]} |
| ;. |
| ; NO-VP: [[LOOP0]] = distinct !{[[LOOP0]], [[META1:![0-9]+]], [[META2:![0-9]+]]} |
| ; NO-VP: [[META1]] = !{!"llvm.loop.isvectorized", i32 1} |
| ; NO-VP: [[META2]] = !{!"llvm.loop.unroll.runtime.disable"} |
| ; NO-VP: [[LOOP3]] = distinct !{[[LOOP3]], [[META1]]} |
| ; NO-VP: [[LOOP4]] = distinct !{[[LOOP4]], [[META1]], [[META2]]} |
| ; NO-VP: [[LOOP5]] = distinct !{[[LOOP5]], [[META1]]} |
| ; NO-VP: [[LOOP6]] = distinct !{[[LOOP6]], [[META1]], [[META2]]} |
| ; NO-VP: [[LOOP7]] = distinct !{[[LOOP7]], [[META1]]} |
| ; NO-VP: [[LOOP8]] = distinct !{[[LOOP8]], [[META1]], [[META2]]} |
| ; NO-VP: [[LOOP9]] = distinct !{[[LOOP9]], [[META1]]} |
| ; NO-VP: [[LOOP10]] = distinct !{[[LOOP10]], [[META1]], [[META2]]} |
| ; NO-VP: [[LOOP11]] = distinct !{[[LOOP11]], [[META1]]} |
| ; NO-VP: [[LOOP12]] = distinct !{[[LOOP12]], [[META1]], [[META2]]} |
| ; NO-VP: [[LOOP13]] = distinct !{[[LOOP13]], [[META1]]} |
| ; NO-VP: [[LOOP14]] = distinct !{[[LOOP14]], [[META1]], [[META2]]} |
| ; NO-VP: [[LOOP15]] = distinct !{[[LOOP15]], [[META1]]} |
| ; NO-VP: [[LOOP16]] = distinct !{[[LOOP16]], [[META1]], [[META2]]} |
| ; NO-VP: [[LOOP17]] = distinct !{[[LOOP17]], [[META1]]} |
| ; NO-VP: [[LOOP18]] = distinct !{[[LOOP18]], [[META1]], [[META2]]} |
| ; NO-VP: [[LOOP19]] = distinct !{[[LOOP19]], [[META1]]} |
| ; NO-VP: [[LOOP20]] = distinct !{[[LOOP20]], [[META1]], [[META2]]} |
| ; NO-VP: [[LOOP21]] = distinct !{[[LOOP21]], [[META1]]} |
| ;. |
