1 //===- llvm/unittest/Transforms/Vectorize/VPlanHCFGTest.cpp ---------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "../lib/Transforms/Vectorize/VPlan.h" 10 #include "../lib/Transforms/Vectorize/VPlanTransforms.h" 11 #include "VPlanTestBase.h" 12 #include "gtest/gtest.h" 13 #include <string> 14 15 namespace llvm { 16 namespace { 17 18 class VPlanHCFGTest : public VPlanTestBase {}; 19 20 TEST_F(VPlanHCFGTest, testBuildHCFGInnerLoop) { 21 const char *ModuleString = 22 "define void @f(i32* %A, i64 %N) {\n" 23 "entry:\n" 24 " br label %for.body\n" 25 "for.body:\n" 26 " %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]\n" 27 " %arr.idx = getelementptr inbounds i32, i32* %A, i64 %indvars.iv\n" 28 " %l1 = load i32, i32* %arr.idx, align 4\n" 29 " %res = add i32 %l1, 10\n" 30 " store i32 %res, i32* %arr.idx, align 4\n" 31 " %indvars.iv.next = add i64 %indvars.iv, 1\n" 32 " %exitcond = icmp ne i64 %indvars.iv.next, %N\n" 33 " br i1 %exitcond, label %for.body, label %for.end\n" 34 "for.end:\n" 35 " ret void\n" 36 "}\n"; 37 38 Module &M = parseModule(ModuleString); 39 40 Function *F = M.getFunction("f"); 41 BasicBlock *LoopHeader = F->getEntryBlock().getSingleSuccessor(); 42 auto Plan = buildHCFG(LoopHeader); 43 44 VPBasicBlock *Entry = Plan->getEntry()->getEntryBasicBlock(); 45 EXPECT_NE(nullptr, Entry->getSingleSuccessor()); 46 EXPECT_EQ(0u, Entry->getNumPredecessors()); 47 EXPECT_EQ(1u, Entry->getNumSuccessors()); 48 EXPECT_EQ(nullptr, Entry->getCondBit()); 49 50 // Check that the region following the preheader is a single basic-block 51 // region (loop). 52 VPBasicBlock *VecBB = Entry->getSingleSuccessor()->getEntryBasicBlock(); 53 EXPECT_EQ(7u, VecBB->size()); 54 EXPECT_EQ(0u, VecBB->getNumPredecessors()); 55 EXPECT_EQ(0u, VecBB->getNumSuccessors()); 56 EXPECT_EQ(VecBB->getParent()->getEntryBasicBlock(), VecBB); 57 EXPECT_EQ(VecBB->getParent()->getExitingBasicBlock(), VecBB); 58 EXPECT_EQ(&*Plan, VecBB->getPlan()); 59 60 auto Iter = VecBB->begin(); 61 VPWidenPHIRecipe *Phi = dyn_cast<VPWidenPHIRecipe>(&*Iter++); 62 EXPECT_NE(nullptr, Phi); 63 64 VPInstruction *Idx = dyn_cast<VPInstruction>(&*Iter++); 65 EXPECT_EQ(Instruction::GetElementPtr, Idx->getOpcode()); 66 EXPECT_EQ(2u, Idx->getNumOperands()); 67 EXPECT_EQ(Phi, Idx->getOperand(1)); 68 69 VPInstruction *Load = dyn_cast<VPInstruction>(&*Iter++); 70 EXPECT_EQ(Instruction::Load, Load->getOpcode()); 71 EXPECT_EQ(1u, Load->getNumOperands()); 72 EXPECT_EQ(Idx, Load->getOperand(0)); 73 74 VPInstruction *Add = dyn_cast<VPInstruction>(&*Iter++); 75 EXPECT_EQ(Instruction::Add, Add->getOpcode()); 76 EXPECT_EQ(2u, Add->getNumOperands()); 77 EXPECT_EQ(Load, Add->getOperand(0)); 78 79 VPInstruction *Store = dyn_cast<VPInstruction>(&*Iter++); 80 EXPECT_EQ(Instruction::Store, Store->getOpcode()); 81 EXPECT_EQ(2u, Store->getNumOperands()); 82 EXPECT_EQ(Add, Store->getOperand(0)); 83 EXPECT_EQ(Idx, Store->getOperand(1)); 84 85 VPInstruction *IndvarAdd = dyn_cast<VPInstruction>(&*Iter++); 86 EXPECT_EQ(Instruction::Add, IndvarAdd->getOpcode()); 87 EXPECT_EQ(2u, IndvarAdd->getNumOperands()); 88 EXPECT_EQ(Phi, IndvarAdd->getOperand(0)); 89 90 VPInstruction *ICmp = dyn_cast<VPInstruction>(&*Iter++); 91 EXPECT_EQ(Instruction::ICmp, ICmp->getOpcode()); 92 EXPECT_EQ(2u, ICmp->getNumOperands()); 93 EXPECT_EQ(IndvarAdd, ICmp->getOperand(0)); 94 EXPECT_EQ(VecBB->getCondBit(), ICmp); 95 96 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) 97 // Add an external value to check we do not print the list of external values, 98 // as this is not required with the new printing. 99 Plan->addVPValue(&*F->arg_begin()); 100 std::string FullDump; 101 raw_string_ostream OS(FullDump); 102 Plan->printDOT(OS); 103 const char *ExpectedStr = R"(digraph VPlan { 104 graph [labelloc=t, fontsize=30; label="Vectorization Plan"] 105 node [shape=rect, fontname=Courier, fontsize=30] 106 edge [fontname=Courier, fontsize=30] 107 compound=true 108 N0 [label = 109 "vector.ph:\l" + 110 "Successor(s): for.body\l" 111 ] 112 N0 -> N1 [ label="" lhead=cluster_N2] 113 subgraph cluster_N2 { 114 fontname=Courier 115 label="\<x1\> for.body" 116 N1 [label = 117 "vector.body:\l" + 118 " WIDEN-PHI ir\<%indvars.iv\> = phi ir\<0\>, ir\<%indvars.iv.next\>\l" + 119 " EMIT ir\<%arr.idx\> = getelementptr ir\<%A\> ir\<%indvars.iv\>\l" + 120 " EMIT ir\<%l1\> = load ir\<%arr.idx\>\l" + 121 " EMIT ir\<%res\> = add ir\<%l1\> ir\<10\>\l" + 122 " EMIT store ir\<%res\> ir\<%arr.idx\>\l" + 123 " EMIT ir\<%indvars.iv.next\> = add ir\<%indvars.iv\> ir\<1\>\l" + 124 " EMIT ir\<%exitcond\> = icmp ir\<%indvars.iv.next\> ir\<%N\>\l" + 125 "No successors\l" + 126 "CondBit: ir\<%exitcond\> (vector.body)\l" 127 ] 128 } 129 N1 -> N3 [ label="" ltail=cluster_N2] 130 N3 [label = 131 "for.end:\l" + 132 "No successors\l" 133 ] 134 } 135 )"; 136 EXPECT_EQ(ExpectedStr, FullDump); 137 #endif 138 139 SmallPtrSet<Instruction *, 1> DeadInstructions; 140 VPlanTransforms::VPInstructionsToVPRecipes( 141 LI->getLoopFor(LoopHeader), Plan, [](PHINode *P) { return nullptr; }, 142 DeadInstructions, *SE); 143 } 144 145 TEST_F(VPlanHCFGTest, testVPInstructionToVPRecipesInner) { 146 const char *ModuleString = 147 "define void @f(i32* %A, i64 %N) {\n" 148 "entry:\n" 149 " br label %for.body\n" 150 "for.body:\n" 151 " %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]\n" 152 " %arr.idx = getelementptr inbounds i32, i32* %A, i64 %indvars.iv\n" 153 " %l1 = load i32, i32* %arr.idx, align 4\n" 154 " %res = add i32 %l1, 10\n" 155 " store i32 %res, i32* %arr.idx, align 4\n" 156 " %indvars.iv.next = add i64 %indvars.iv, 1\n" 157 " %exitcond = icmp ne i64 %indvars.iv.next, %N\n" 158 " br i1 %exitcond, label %for.body, label %for.end\n" 159 "for.end:\n" 160 " ret void\n" 161 "}\n"; 162 163 Module &M = parseModule(ModuleString); 164 165 Function *F = M.getFunction("f"); 166 BasicBlock *LoopHeader = F->getEntryBlock().getSingleSuccessor(); 167 auto Plan = buildHCFG(LoopHeader); 168 169 SmallPtrSet<Instruction *, 1> DeadInstructions; 170 VPlanTransforms::VPInstructionsToVPRecipes( 171 LI->getLoopFor(LoopHeader), Plan, [](PHINode *P) { return nullptr; }, 172 DeadInstructions, *SE); 173 174 VPBlockBase *Entry = Plan->getEntry()->getEntryBasicBlock(); 175 EXPECT_NE(nullptr, Entry->getSingleSuccessor()); 176 EXPECT_EQ(0u, Entry->getNumPredecessors()); 177 EXPECT_EQ(1u, Entry->getNumSuccessors()); 178 179 // Check that the region following the preheader is a single basic-block 180 // region (loop). 181 VPBasicBlock *VecBB = Entry->getSingleSuccessor()->getEntryBasicBlock(); 182 EXPECT_EQ(7u, VecBB->size()); 183 EXPECT_EQ(0u, VecBB->getNumPredecessors()); 184 EXPECT_EQ(0u, VecBB->getNumSuccessors()); 185 EXPECT_EQ(VecBB->getParent()->getEntryBasicBlock(), VecBB); 186 EXPECT_EQ(VecBB->getParent()->getExitingBasicBlock(), VecBB); 187 188 auto Iter = VecBB->begin(); 189 EXPECT_NE(nullptr, dyn_cast<VPWidenPHIRecipe>(&*Iter++)); 190 EXPECT_NE(nullptr, dyn_cast<VPWidenGEPRecipe>(&*Iter++)); 191 EXPECT_NE(nullptr, dyn_cast<VPWidenMemoryInstructionRecipe>(&*Iter++)); 192 EXPECT_NE(nullptr, dyn_cast<VPWidenRecipe>(&*Iter++)); 193 EXPECT_NE(nullptr, dyn_cast<VPWidenMemoryInstructionRecipe>(&*Iter++)); 194 EXPECT_NE(nullptr, dyn_cast<VPWidenRecipe>(&*Iter++)); 195 EXPECT_NE(nullptr, dyn_cast<VPWidenRecipe>(&*Iter++)); 196 EXPECT_EQ(VecBB->end(), Iter); 197 } 198 199 } // namespace 200 } // namespace llvm 201