| //===- llvm/unittests/Transforms/Vectorize/VPlanPredicatorTest.cpp -----===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "../lib/Transforms/Vectorize/VPlanPredicator.h" |
| #include "VPlanTestBase.h" |
| #include "gtest/gtest.h" |
| |
| namespace llvm { |
| namespace { |
| |
| class VPlanPredicatorTest : public VPlanTestBase {}; |
| |
| TEST_F(VPlanPredicatorTest, BasicPredicatorTest) { |
| const char *ModuleString = |
| "@arr = common global [8 x [8 x i64]] " |
| "zeroinitializer, align 16\n" |
| "@arr2 = common global [8 x [8 x i64]] " |
| "zeroinitializer, align 16\n" |
| "@arr3 = common global [8 x [8 x i64]] " |
| "zeroinitializer, align 16\n" |
| "define void @f(i64 %n1) {\n" |
| "entry:\n" |
| " br label %for.cond1.preheader\n" |
| "for.cond1.preheader: \n" |
| " %i1.029 = phi i64 [ 0, %entry ], [ %inc14, %for.inc13 ]\n" |
| " br label %for.body3\n" |
| "for.body3: \n" |
| " %i2.028 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.inc ]\n" |
| " %arrayidx4 = getelementptr inbounds [8 x [8 x i64]], [8 x [8 x i64]]* " |
| "@arr, i64 0, i64 %i2.028, i64 %i1.029\n" |
| " %0 = load i64, i64* %arrayidx4, align 8\n" |
| " %cmp5 = icmp ugt i64 %0, 10\n" |
| " br i1 %cmp5, label %if.then, label %for.inc\n" |
| "if.then: \n" |
| " %arrayidx7 = getelementptr inbounds [8 x [8 x i64]], [8 x [8 x i64]]* " |
| "@arr2, i64 0, i64 %i2.028, i64 %i1.029\n" |
| " %1 = load i64, i64* %arrayidx7, align 8\n" |
| " %cmp8 = icmp ugt i64 %1, 100\n" |
| " br i1 %cmp8, label %if.then9, label %for.inc\n" |
| "if.then9: \n" |
| " %add = add nuw nsw i64 %i2.028, %i1.029\n" |
| " %arrayidx11 = getelementptr inbounds [8 x [8 x i64]], [8 x [8 x " |
| "i64]]* @arr3, i64 0, i64 %i2.028, i64 %i1.029\n" |
| " store i64 %add, i64* %arrayidx11, align 8\n" |
| " br label %for.inc\n" |
| "for.inc: \n" |
| " %inc = add nuw nsw i64 %i2.028, 1\n" |
| " %exitcond = icmp eq i64 %inc, 8\n" |
| " br i1 %exitcond, label %for.inc13, label %for.body3\n" |
| "for.inc13: \n" |
| " %inc14 = add nuw nsw i64 %i1.029, 1\n" |
| " %exitcond30 = icmp eq i64 %inc14, 8\n" |
| " br i1 %exitcond30, label %for.end15, label %for.cond1.preheader\n" |
| "for.end15: \n" |
| " ret void\n" |
| "}\n"; |
| |
| Module &M = parseModule(ModuleString); |
| |
| Function *F = M.getFunction("f"); |
| BasicBlock *LoopHeader = F->getEntryBlock().getSingleSuccessor(); |
| auto Plan = buildHCFG(LoopHeader); |
| |
| VPRegionBlock *TopRegion = cast<VPRegionBlock>(Plan->getEntry()); |
| VPBlockBase *PH = TopRegion->getEntry(); |
| VPBlockBase *H = PH->getSingleSuccessor(); |
| VPBlockBase *InnerLoopH = H->getSingleSuccessor(); |
| VPBlockBase *OuterIf = InnerLoopH->getSuccessors()[0]; |
| VPBlockBase *InnerLoopLatch = InnerLoopH->getSuccessors()[1]; |
| VPBlockBase *InnerIf = OuterIf->getSuccessors()[0]; |
| VPValue *CBV1 = InnerLoopH->getCondBit(); |
| VPValue *CBV2 = OuterIf->getCondBit(); |
| |
| // Apply predication. |
| VPlanPredicator VPP(*Plan); |
| VPP.predicate(); |
| |
| VPBlockBase *InnerLoopLinSucc = InnerLoopH->getSingleSuccessor(); |
| VPBlockBase *OuterIfLinSucc = OuterIf->getSingleSuccessor(); |
| VPBlockBase *InnerIfLinSucc = InnerIf->getSingleSuccessor(); |
| VPValue *OuterIfPred = OuterIf->getPredicate(); |
| VPInstruction *InnerAnd = |
| cast<VPInstruction>(InnerIf->getEntryBasicBlock()->begin()); |
| VPValue *InnerIfPred = InnerIf->getPredicate(); |
| |
| // Test block predicates |
| EXPECT_NE(nullptr, CBV1); |
| EXPECT_NE(nullptr, CBV2); |
| EXPECT_NE(nullptr, InnerAnd); |
| EXPECT_EQ(CBV1, OuterIfPred); |
| EXPECT_EQ(InnerAnd->getOpcode(), Instruction::And); |
| EXPECT_EQ(InnerAnd->getOperand(0), CBV1); |
| EXPECT_EQ(InnerAnd->getOperand(1), CBV2); |
| EXPECT_EQ(InnerIfPred, InnerAnd); |
| |
| // Test Linearization |
| EXPECT_EQ(InnerLoopLinSucc, OuterIf); |
| EXPECT_EQ(OuterIfLinSucc, InnerIf); |
| EXPECT_EQ(InnerIfLinSucc, InnerLoopLatch); |
| |
| // Check that the containing VPlan is set correctly. |
| EXPECT_EQ(&*Plan, InnerLoopLinSucc->getPlan()); |
| EXPECT_EQ(&*Plan, OuterIfLinSucc->getPlan()); |
| EXPECT_EQ(&*Plan, InnerIfLinSucc->getPlan()); |
| EXPECT_EQ(&*Plan, InnerIf->getPlan()); |
| EXPECT_EQ(&*Plan, InnerLoopLatch->getPlan()); |
| } |
| |
| // Test generation of Not and Or during predication. |
| TEST_F(VPlanPredicatorTest, PredicatorNegOrTest) { |
| const char *ModuleString = |
| "@arr = common global [100 x [100 x i32]] zeroinitializer, align 16\n" |
| "@arr2 = common global [100 x [100 x i32]] zeroinitializer, align 16\n" |
| "@arr3 = common global [100 x [100 x i32]] zeroinitializer, align 16\n" |
| "define void @foo() {\n" |
| "entry:\n" |
| " br label %for.cond1.preheader\n" |
| "for.cond1.preheader: \n" |
| " %indvars.iv42 = phi i64 [ 0, %entry ], [ %indvars.iv.next43, " |
| "%for.inc22 ]\n" |
| " br label %for.body3\n" |
| "for.body3: \n" |
| " %indvars.iv = phi i64 [ 0, %for.cond1.preheader ], [ " |
| "%indvars.iv.next, %if.end21 ]\n" |
| " %arrayidx5 = getelementptr inbounds [100 x [100 x i32]], [100 x [100 " |
| "x i32]]* @arr, i64 0, i64 %indvars.iv, i64 %indvars.iv42\n" |
| " %0 = load i32, i32* %arrayidx5, align 4\n" |
| " %cmp6 = icmp slt i32 %0, 100\n" |
| " br i1 %cmp6, label %if.then, label %if.end21\n" |
| "if.then: \n" |
| " %cmp7 = icmp sgt i32 %0, 10\n" |
| " br i1 %cmp7, label %if.then8, label %if.else\n" |
| "if.then8: \n" |
| " %add = add nsw i32 %0, 10\n" |
| " %arrayidx12 = getelementptr inbounds [100 x [100 x i32]], [100 x [100 " |
| "x i32]]* @arr2, i64 0, i64 %indvars.iv, i64 %indvars.iv42\n" |
| " store i32 %add, i32* %arrayidx12, align 4\n" |
| " br label %if.end\n" |
| "if.else: \n" |
| " %sub = add nsw i32 %0, -10\n" |
| " %arrayidx16 = getelementptr inbounds [100 x [100 x i32]], [100 x [100 " |
| "x i32]]* @arr3, i64 0, i64 %indvars.iv, i64 %indvars.iv42\n" |
| " store i32 %sub, i32* %arrayidx16, align 4\n" |
| " br label %if.end\n" |
| "if.end: \n" |
| " store i32 222, i32* %arrayidx5, align 4\n" |
| " br label %if.end21\n" |
| "if.end21: \n" |
| " %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1\n" |
| " %exitcond = icmp eq i64 %indvars.iv.next, 100\n" |
| " br i1 %exitcond, label %for.inc22, label %for.body3\n" |
| "for.inc22: \n" |
| " %indvars.iv.next43 = add nuw nsw i64 %indvars.iv42, 1\n" |
| " %exitcond44 = icmp eq i64 %indvars.iv.next43, 100\n" |
| " br i1 %exitcond44, label %for.end24, label %for.cond1.preheader\n" |
| "for.end24: \n" |
| " ret void\n" |
| "}\n"; |
| |
| Module &M = parseModule(ModuleString); |
| Function *F = M.getFunction("foo"); |
| BasicBlock *LoopHeader = F->getEntryBlock().getSingleSuccessor(); |
| auto Plan = buildHCFG(LoopHeader); |
| |
| VPRegionBlock *TopRegion = cast<VPRegionBlock>(Plan->getEntry()); |
| VPBlockBase *PH = TopRegion->getEntry(); |
| VPBlockBase *H = PH->getSingleSuccessor(); |
| VPBlockBase *OuterIfCmpBlk = H->getSingleSuccessor(); |
| VPBlockBase *InnerIfCmpBlk = OuterIfCmpBlk->getSuccessors()[0]; |
| VPBlockBase *InnerIfTSucc = InnerIfCmpBlk->getSuccessors()[0]; |
| VPBlockBase *InnerIfFSucc = InnerIfCmpBlk->getSuccessors()[1]; |
| VPBlockBase *TSuccSucc = InnerIfTSucc->getSingleSuccessor(); |
| VPBlockBase *FSuccSucc = InnerIfFSucc->getSingleSuccessor(); |
| |
| VPValue *OuterCBV = OuterIfCmpBlk->getCondBit(); |
| VPValue *InnerCBV = InnerIfCmpBlk->getCondBit(); |
| |
| // Apply predication. |
| VPlanPredicator VPP(*Plan); |
| VPP.predicate(); |
| |
| VPInstruction *And = |
| cast<VPInstruction>(InnerIfTSucc->getEntryBasicBlock()->begin()); |
| VPInstruction *Not = |
| cast<VPInstruction>(InnerIfFSucc->getEntryBasicBlock()->begin()); |
| VPInstruction *NotAnd = cast<VPInstruction>( |
| &*std::next(InnerIfFSucc->getEntryBasicBlock()->begin(), 1)); |
| VPInstruction *Or = |
| cast<VPInstruction>(TSuccSucc->getEntryBasicBlock()->begin()); |
| |
| // Test block predicates |
| EXPECT_NE(nullptr, OuterCBV); |
| EXPECT_NE(nullptr, InnerCBV); |
| EXPECT_NE(nullptr, And); |
| EXPECT_NE(nullptr, Not); |
| EXPECT_NE(nullptr, NotAnd); |
| |
| EXPECT_EQ(And->getOpcode(), Instruction::And); |
| EXPECT_EQ(NotAnd->getOpcode(), Instruction::And); |
| EXPECT_EQ(Not->getOpcode(), VPInstruction::Not); |
| |
| EXPECT_EQ(And->getOperand(0), OuterCBV); |
| EXPECT_EQ(And->getOperand(1), InnerCBV); |
| |
| EXPECT_EQ(Not->getOperand(0), InnerCBV); |
| |
| EXPECT_EQ(NotAnd->getOperand(0), OuterCBV); |
| EXPECT_EQ(NotAnd->getOperand(1), Not); |
| |
| EXPECT_EQ(InnerIfTSucc->getPredicate(), And); |
| EXPECT_EQ(InnerIfFSucc->getPredicate(), NotAnd); |
| |
| EXPECT_EQ(TSuccSucc, FSuccSucc); |
| EXPECT_EQ(Or->getOpcode(), Instruction::Or); |
| EXPECT_EQ(TSuccSucc->getPredicate(), Or); |
| |
| // Test operands of the Or - account for differences in predecessor block |
| // ordering. |
| VPInstruction *OrOp0Inst = cast<VPInstruction>(Or->getOperand(0)); |
| VPInstruction *OrOp1Inst = cast<VPInstruction>(Or->getOperand(1)); |
| |
| bool ValidOrOperands = false; |
| if (((OrOp0Inst == And) && (OrOp1Inst == NotAnd)) || |
| ((OrOp0Inst == NotAnd) && (OrOp1Inst == And))) |
| ValidOrOperands = true; |
| |
| EXPECT_TRUE(ValidOrOperands); |
| } |
| |
| } // namespace |
| } // namespace llvm |
