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 "llvm/Analysis/TargetLibraryInfo.h" 13 #include "llvm/TargetParser/Triple.h" 14 #include "gtest/gtest.h" 15 #include <string> 16 17 namespace llvm { 18 namespace { 19 20 class VPlanHCFGTest : public VPlanTestIRBase {}; 21 22 TEST_F(VPlanHCFGTest, testBuildHCFGInnerLoop) { 23 const char *ModuleString = 24 "define void @f(ptr %A, i64 %N) {\n" 25 "entry:\n" 26 " br label %for.body\n" 27 "for.body:\n" 28 " %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]\n" 29 " %arr.idx = getelementptr inbounds i32, ptr %A, i64 %indvars.iv\n" 30 " %l1 = load i32, ptr %arr.idx, align 4\n" 31 " %res = add i32 %l1, 10\n" 32 " store i32 %res, ptr %arr.idx, align 4\n" 33 " %indvars.iv.next = add i64 %indvars.iv, 1\n" 34 " %exitcond = icmp ne i64 %indvars.iv.next, %N\n" 35 " br i1 %exitcond, label %for.body, label %for.end\n" 36 "for.end:\n" 37 " ret void\n" 38 "}\n"; 39 40 Module &M = parseModule(ModuleString); 41 42 Function *F = M.getFunction("f"); 43 BasicBlock *LoopHeader = F->getEntryBlock().getSingleSuccessor(); 44 auto Plan = buildHCFG(LoopHeader); 45 46 VPBasicBlock *Entry = Plan->getEntry()->getEntryBasicBlock(); 47 EXPECT_NE(nullptr, Entry->getSingleSuccessor()); 48 EXPECT_EQ(0u, Entry->getNumPredecessors()); 49 EXPECT_EQ(1u, Entry->getNumSuccessors()); 50 51 // Check that the region following the preheader is a single basic-block 52 // region (loop). 53 VPBasicBlock *VecBB = Plan->getVectorLoopRegion()->getEntryBasicBlock(); 54 EXPECT_EQ(8u, VecBB->size()); 55 EXPECT_EQ(0u, VecBB->getNumPredecessors()); 56 EXPECT_EQ(0u, VecBB->getNumSuccessors()); 57 EXPECT_EQ(VecBB->getParent()->getEntryBasicBlock(), VecBB); 58 EXPECT_EQ(VecBB->getParent()->getExitingBasicBlock(), VecBB); 59 EXPECT_EQ(&*Plan, VecBB->getPlan()); 60 61 auto Iter = VecBB->begin(); 62 VPWidenPHIRecipe *Phi = dyn_cast<VPWidenPHIRecipe>(&*Iter++); 63 EXPECT_NE(nullptr, Phi); 64 65 VPInstruction *Idx = dyn_cast<VPInstruction>(&*Iter++); 66 EXPECT_EQ(Instruction::GetElementPtr, Idx->getOpcode()); 67 EXPECT_EQ(2u, Idx->getNumOperands()); 68 EXPECT_EQ(Phi, Idx->getOperand(1)); 69 70 VPInstruction *Load = dyn_cast<VPInstruction>(&*Iter++); 71 EXPECT_EQ(Instruction::Load, Load->getOpcode()); 72 EXPECT_EQ(1u, Load->getNumOperands()); 73 EXPECT_EQ(Idx, Load->getOperand(0)); 74 75 VPInstruction *Add = dyn_cast<VPInstruction>(&*Iter++); 76 EXPECT_EQ(Instruction::Add, Add->getOpcode()); 77 EXPECT_EQ(2u, Add->getNumOperands()); 78 EXPECT_EQ(Load, Add->getOperand(0)); 79 80 VPInstruction *Store = dyn_cast<VPInstruction>(&*Iter++); 81 EXPECT_EQ(Instruction::Store, Store->getOpcode()); 82 EXPECT_EQ(2u, Store->getNumOperands()); 83 EXPECT_EQ(Add, Store->getOperand(0)); 84 EXPECT_EQ(Idx, Store->getOperand(1)); 85 86 VPInstruction *IndvarAdd = dyn_cast<VPInstruction>(&*Iter++); 87 EXPECT_EQ(Instruction::Add, IndvarAdd->getOpcode()); 88 EXPECT_EQ(2u, IndvarAdd->getNumOperands()); 89 EXPECT_EQ(Phi, IndvarAdd->getOperand(0)); 90 91 VPInstruction *ICmp = dyn_cast<VPInstruction>(&*Iter++); 92 EXPECT_EQ(Instruction::ICmp, ICmp->getOpcode()); 93 EXPECT_EQ(2u, ICmp->getNumOperands()); 94 EXPECT_EQ(IndvarAdd, ICmp->getOperand(0)); 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->getOrAddLiveIn(&*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\n for UF\>=1\nLive-in vp\<%0\> = vector-trip-count\nLive-in ir\<%N\> = original trip-count\n"] 105 node [shape=rect, fontname=Courier, fontsize=30] 106 edge [fontname=Courier, fontsize=30] 107 compound=true 108 N0 [label = 109 "ir-bb\<entry\>:\l" + 110 "Successor(s): vector.ph\l" 111 ] 112 N0 -> N1 [ label=""] 113 N1 [label = 114 "vector.ph:\l" + 115 "Successor(s): vector loop\l" 116 ] 117 N1 -> N2 [ label="" lhead=cluster_N3] 118 subgraph cluster_N3 { 119 fontname=Courier 120 label="\<x1\> vector loop" 121 N2 [label = 122 "vector.body:\l" + 123 " WIDEN-PHI ir\<%indvars.iv\> = phi ir\<0\>, ir\<%indvars.iv.next\>\l" + 124 " EMIT ir\<%arr.idx\> = getelementptr ir\<%A\>, ir\<%indvars.iv\>\l" + 125 " EMIT ir\<%l1\> = load ir\<%arr.idx\>\l" + 126 " EMIT ir\<%res\> = add ir\<%l1\>, ir\<10\>\l" + 127 " EMIT store ir\<%res\>, ir\<%arr.idx\>\l" + 128 " EMIT ir\<%indvars.iv.next\> = add ir\<%indvars.iv\>, ir\<1\>\l" + 129 " EMIT ir\<%exitcond\> = icmp ir\<%indvars.iv.next\>, ir\<%N\>\l" + 130 " EMIT branch-on-cond ir\<%exitcond\>\l" + 131 "No successors\l" 132 ] 133 } 134 N2 -> N4 [ label="" ltail=cluster_N3] 135 N4 [label = 136 "middle.block:\l" + 137 " EMIT vp\<%cmp.n\> = icmp eq ir\<%N\>, vp\<%0\>\l" + 138 " EMIT branch-on-cond vp\<%cmp.n\>\l" + 139 "Successor(s): ir-bb\<for.end\>, scalar.ph\l" 140 ] 141 N4 -> N5 [ label="T"] 142 N4 -> N6 [ label="F"] 143 N5 [label = 144 "ir-bb\<for.end\>:\l" + 145 "No successors\l" 146 ] 147 N6 [label = 148 "scalar.ph:\l" + 149 "Successor(s): ir-bb\<for.body\>\l" 150 ] 151 N6 -> N7 [ label=""] 152 N7 [label = 153 "ir-bb\<for.body\>:\l" + 154 " IR %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]\l" + 155 " IR %arr.idx = getelementptr inbounds i32, ptr %A, i64 %indvars.iv\l" + 156 " IR %l1 = load i32, ptr %arr.idx, align 4\l" + 157 " IR %res = add i32 %l1, 10\l" + 158 " IR store i32 %res, ptr %arr.idx, align 4\l" + 159 " IR %indvars.iv.next = add i64 %indvars.iv, 1\l" + 160 " IR %exitcond = icmp ne i64 %indvars.iv.next, %N\l" + 161 "No successors\l" 162 ] 163 } 164 )"; 165 EXPECT_EQ(ExpectedStr, FullDump); 166 #endif 167 TargetLibraryInfoImpl TLII(Triple(M.getTargetTriple())); 168 TargetLibraryInfo TLI(TLII); 169 VPlanTransforms::VPInstructionsToVPRecipes( 170 Plan, [](PHINode *P) { return nullptr; }, *SE, TLI); 171 } 172 173 TEST_F(VPlanHCFGTest, testVPInstructionToVPRecipesInner) { 174 const char *ModuleString = 175 "define void @f(ptr %A, i64 %N) {\n" 176 "entry:\n" 177 " br label %for.body\n" 178 "for.body:\n" 179 " %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]\n" 180 " %arr.idx = getelementptr inbounds i32, ptr %A, i64 %indvars.iv\n" 181 " %l1 = load i32, ptr %arr.idx, align 4\n" 182 " %res = add i32 %l1, 10\n" 183 " store i32 %res, ptr %arr.idx, align 4\n" 184 " %indvars.iv.next = add i64 %indvars.iv, 1\n" 185 " %exitcond = icmp ne i64 %indvars.iv.next, %N\n" 186 " br i1 %exitcond, label %for.body, label %for.end\n" 187 "for.end:\n" 188 " ret void\n" 189 "}\n"; 190 191 Module &M = parseModule(ModuleString); 192 193 Function *F = M.getFunction("f"); 194 BasicBlock *LoopHeader = F->getEntryBlock().getSingleSuccessor(); 195 auto Plan = buildHCFG(LoopHeader); 196 197 TargetLibraryInfoImpl TLII(Triple(M.getTargetTriple())); 198 TargetLibraryInfo TLI(TLII); 199 VPlanTransforms::VPInstructionsToVPRecipes( 200 Plan, [](PHINode *P) { return nullptr; }, *SE, TLI); 201 202 VPBlockBase *Entry = Plan->getEntry()->getEntryBasicBlock(); 203 EXPECT_NE(nullptr, Entry->getSingleSuccessor()); 204 EXPECT_EQ(0u, Entry->getNumPredecessors()); 205 EXPECT_EQ(1u, Entry->getNumSuccessors()); 206 207 // Check that the region following the preheader is a single basic-block 208 // region (loop). 209 VPBasicBlock *VecBB = Plan->getVectorLoopRegion()->getEntryBasicBlock(); 210 EXPECT_EQ(8u, VecBB->size()); 211 EXPECT_EQ(0u, VecBB->getNumPredecessors()); 212 EXPECT_EQ(0u, VecBB->getNumSuccessors()); 213 EXPECT_EQ(VecBB->getParent()->getEntryBasicBlock(), VecBB); 214 EXPECT_EQ(VecBB->getParent()->getExitingBasicBlock(), VecBB); 215 216 auto Iter = VecBB->begin(); 217 EXPECT_NE(nullptr, dyn_cast<VPWidenPHIRecipe>(&*Iter++)); 218 EXPECT_NE(nullptr, dyn_cast<VPWidenGEPRecipe>(&*Iter++)); 219 EXPECT_NE(nullptr, dyn_cast<VPWidenMemoryRecipe>(&*Iter++)); 220 EXPECT_NE(nullptr, dyn_cast<VPWidenRecipe>(&*Iter++)); 221 EXPECT_NE(nullptr, dyn_cast<VPWidenMemoryRecipe>(&*Iter++)); 222 EXPECT_NE(nullptr, dyn_cast<VPWidenRecipe>(&*Iter++)); 223 EXPECT_NE(nullptr, dyn_cast<VPWidenRecipe>(&*Iter++)); 224 EXPECT_NE(nullptr, dyn_cast<VPInstruction>(&*Iter++)); 225 EXPECT_EQ(VecBB->end(), Iter); 226 } 227 228 } // namespace 229 } // namespace llvm 230