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