?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix test failures introduced by PR #113697 (#116941)
[llvm-project.git] / llvm / unittests / Analysis / VectorUtilsTest.cpp
blobb4d74f715b2db068253c01b945752fe33e0be1ff
1 //===- VectorUtilsTest.cpp - VectorUtils tests ------------------------===//
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 "llvm/Analysis/VectorUtils.h"
10 #include "llvm/Analysis/ValueTracking.h"
11 #include "llvm/AsmParser/Parser.h"
12 #include "llvm/IR/Function.h"
13 #include "llvm/IR/InstIterator.h"
14 #include "llvm/IR/IRBuilder.h"
15 #include "llvm/IR/LLVMContext.h"
16 #include "llvm/IR/Module.h"
17 #include "llvm/IR/NoFolder.h"
18 #include "llvm/Support/ErrorHandling.h"
19 #include "llvm/Support/SourceMgr.h"
20 #include "gtest/gtest.h"
21
22 using namespace llvm;
23
24 namespace {
25
26 class VectorUtilsTest : public testing::Test {
27 protected:
28 void parseAssembly(const char *Assembly) {
29 SMDiagnostic Error;
30 M = parseAssemblyString(Assembly, Error, Context);
31
32 std::string errMsg;
33 raw_string_ostream os(errMsg);
34 Error.print("", os);
35
36 // A failure here means that the test itself is buggy.
37 if (!M)
38 report_fatal_error(Twine(errMsg));
39
40 Function *F = M->getFunction("test");
41 if (F == nullptr)
42 report_fatal_error("Test must have a function named @test");
43
44 A = nullptr;
45 for (inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I) {
46 if (I->hasName()) {
47 if (I->getName() == "A")
48 A = &*I;
49 }
50 }
51 if (A == nullptr)
52 report_fatal_error("@test must have an instruction %A");
53 }
54
55 LLVMContext Context;
56 std::unique_ptr<Module> M;
57 Instruction *A;
58 };
59
60 struct BasicTest : public testing::Test {
61 LLVMContext Ctx;
62 std::unique_ptr<Module> M;
63 Function *F;
64 BasicBlock *BB;
65 IRBuilder<NoFolder> IRB;
66
67 BasicTest()
68 : M(new Module("VectorUtils", Ctx)),
69 F(Function::Create(
70 FunctionType::get(Type::getVoidTy(Ctx), /* IsVarArg */ false),
71 Function::ExternalLinkage, "f", M.get())),
72 BB(BasicBlock::Create(Ctx, "entry", F)), IRB(BB) {}
73 };
74
75
76 } // namespace
77
78 TEST_F(BasicTest, isSplat) {
79 Value *UndefVec = UndefValue::get(FixedVectorType::get(IRB.getInt8Ty(), 4));
80 EXPECT_TRUE(isSplatValue(UndefVec));
81
82 Constant *UndefScalar = UndefValue::get(IRB.getInt8Ty());
83 EXPECT_FALSE(isSplatValue(UndefScalar));
84
85 Constant *ScalarC = IRB.getInt8(42);
86 EXPECT_FALSE(isSplatValue(ScalarC));
87
88 Constant *OtherScalarC = IRB.getInt8(-42);
89 Constant *NonSplatC = ConstantVector::get({ScalarC, OtherScalarC});
90 EXPECT_FALSE(isSplatValue(NonSplatC));
91
92 Value *SplatC = IRB.CreateVectorSplat(5, ScalarC);
93 EXPECT_TRUE(isSplatValue(SplatC));
94
95 Value *SplatC_SVE =
96 IRB.CreateVectorSplat(ElementCount::getScalable(5), ScalarC);
97 EXPECT_TRUE(isSplatValue(SplatC_SVE));
98
99 // FIXME: Constant splat analysis does not allow undef elements.
100 Constant *SplatWithUndefC = ConstantVector::get({ScalarC, UndefScalar});
101 EXPECT_FALSE(isSplatValue(SplatWithUndefC));
102 }
103
104 TEST_F(BasicTest, narrowShuffleMaskElts) {
105 SmallVector<int, 16> ScaledMask;
106 narrowShuffleMaskElts(1, {3,2,0,-2}, ScaledMask);
107 EXPECT_EQ(ArrayRef(ScaledMask), ArrayRef({3, 2, 0, -2}));
108 narrowShuffleMaskElts(4, {3,2,0,-1}, ScaledMask);
109 EXPECT_EQ(ArrayRef(ScaledMask), ArrayRef({12, 13, 14, 15, 8, 9, 10, 11, 0, 1,
110 2, 3, -1, -1, -1, -1}));
111 }
112
113 TEST_F(BasicTest, widenShuffleMaskElts) {
114 SmallVector<int, 16> WideMask;
115 SmallVector<int, 16> NarrowMask;
116
117 // scale == 1 is a copy
118 EXPECT_TRUE(widenShuffleMaskElts(1, {3,2,0,-1}, WideMask));
119 EXPECT_EQ(ArrayRef(WideMask), ArrayRef({3, 2, 0, -1}));
120
121 // back to original mask
122 narrowShuffleMaskElts(1, ArrayRef(WideMask), NarrowMask);
123 EXPECT_EQ(ArrayRef(NarrowMask), ArrayRef({3, 2, 0, -1}));
124
125 // can't widen non-consecutive 3/2
126 EXPECT_FALSE(widenShuffleMaskElts(2, {3,2,0,-1}, WideMask));
127
128 // can't widen if not evenly divisible
129 EXPECT_FALSE(widenShuffleMaskElts(2, {0,1,2}, WideMask));
130
131 // can always widen identity to single element
132 EXPECT_TRUE(widenShuffleMaskElts(3, {0,1,2}, WideMask));
133 EXPECT_EQ(ArrayRef(WideMask), ArrayRef({0}));
134
135 // back to original mask
136 narrowShuffleMaskElts(3, ArrayRef(WideMask), NarrowMask);
137 EXPECT_EQ(ArrayRef(NarrowMask), ArrayRef({0, 1, 2}));
138
139 // groups of 4 must be consecutive/undef
140 EXPECT_TRUE(widenShuffleMaskElts(4, {12,13,14,15,8,9,10,11,0,1,2,3,-1,-1,-1,-1}, WideMask));
141 EXPECT_EQ(ArrayRef(WideMask), ArrayRef({3, 2, 0, -1}));
142
143 // back to original mask
144 narrowShuffleMaskElts(4, ArrayRef(WideMask), NarrowMask);
145 EXPECT_EQ(ArrayRef(NarrowMask), ArrayRef({12, 13, 14, 15, 8, 9, 10, 11, 0, 1,
146 2, 3, -1, -1, -1, -1}));
147
148 // groups of 2 must be consecutive/undef
149 EXPECT_FALSE(widenShuffleMaskElts(2, {12,12,14,15,8,9,10,11,0,1,2,3,-1,-1,-1,-1}, WideMask));
150
151 // groups of 3 must be consecutive/undef
152 EXPECT_TRUE(widenShuffleMaskElts(3, {6,7,8,0,1,2,-1,-1,-1}, WideMask));
153 EXPECT_EQ(ArrayRef(WideMask), ArrayRef({2, 0, -1}));
154
155 // back to original mask
156 narrowShuffleMaskElts(3, ArrayRef(WideMask), NarrowMask);
157 EXPECT_EQ(ArrayRef(NarrowMask), ArrayRef({6, 7, 8, 0, 1, 2, -1, -1, -1}));
158
159 // groups of 3 must be consecutive/undef (partial undefs are not ok)
160 EXPECT_FALSE(widenShuffleMaskElts(3, {-1,7,8,0,-1,2,-1,-1,-1}, WideMask));
161
162 // negative indexes must match across a wide element
163 EXPECT_FALSE(widenShuffleMaskElts(2, {-1,-2,-1,-1}, WideMask));
164
165 // negative indexes must match across a wide element
166 EXPECT_TRUE(widenShuffleMaskElts(2, {-2,-2,-3,-3}, WideMask));
167 EXPECT_EQ(ArrayRef(WideMask), ArrayRef({-2, -3}));
168 }
169
170 TEST_F(BasicTest, getShuffleMaskWithWidestElts) {
171 SmallVector<int, 16> WideMask;
172
173 // can not widen anything here.
174 getShuffleMaskWithWidestElts({3, 2, 0, -1}, WideMask);
175 EXPECT_EQ(ArrayRef(WideMask), ArrayRef({3, 2, 0, -1}));
176
177 // can't widen non-consecutive 3/2
178 getShuffleMaskWithWidestElts({3, 2, 0, -1}, WideMask);
179 EXPECT_EQ(ArrayRef(WideMask), ArrayRef({3, 2, 0, -1}));
180
181 // can always widen identity to single element
182 getShuffleMaskWithWidestElts({0, 1, 2}, WideMask);
183 EXPECT_EQ(ArrayRef(WideMask), ArrayRef({0}));
184
185 // groups of 4 must be consecutive/undef
186 getShuffleMaskWithWidestElts(
187 {12, 13, 14, 15, 8, 9, 10, 11, 0, 1, 2, 3, -1, -1, -1, -1}, WideMask);
188 EXPECT_EQ(ArrayRef(WideMask), ArrayRef({3, 2, 0, -1}));
189
190 // groups of 2 must be consecutive/undef
191 getShuffleMaskWithWidestElts(
192 {12, 12, 14, 15, 8, 9, 10, 11, 0, 1, 2, 3, -1, -1, -1, -1}, WideMask);
193 EXPECT_EQ(ArrayRef(WideMask), ArrayRef({12, 12, 14, 15, 8, 9, 10, 11, 0, 1, 2,
194 3, -1, -1, -1, -1}));
195
196 // groups of 3 must be consecutive/undef
197 getShuffleMaskWithWidestElts({6, 7, 8, 0, 1, 2, -1, -1, -1}, WideMask);
198 EXPECT_EQ(ArrayRef(WideMask), ArrayRef({2, 0, -1}));
199
200 // groups of 3 must be consecutive/undef (partial undefs are not ok)
201 getShuffleMaskWithWidestElts({-1, 7, 8, 0, -1, 2, -1, -1, -1}, WideMask);
202 EXPECT_EQ(ArrayRef(WideMask), ArrayRef({-1, 7, 8, 0, -1, 2, -1, -1, -1}));
203
204 // negative indexes must match across a wide element
205 getShuffleMaskWithWidestElts({-1, -2, -1, -1}, WideMask);
206 EXPECT_EQ(ArrayRef(WideMask), ArrayRef({-1, -2, -1, -1}));
207
208 // negative indexes must match across a wide element
209 getShuffleMaskWithWidestElts({-2, -2, -3, -3}, WideMask);
210 EXPECT_EQ(ArrayRef(WideMask), ArrayRef({-2, -3}));
211 }
212
213 TEST_F(BasicTest, getShuffleDemandedElts) {
214 APInt LHS, RHS;
215
216 // broadcast zero
217 EXPECT_TRUE(getShuffleDemandedElts(4, {0, 0, 0, 0}, APInt(4,0xf), LHS, RHS));
218 EXPECT_EQ(LHS.getZExtValue(), 0x1U);
219 EXPECT_EQ(RHS.getZExtValue(), 0x0U);
220
221 // broadcast zero (with non-permitted undefs)
222 EXPECT_FALSE(getShuffleDemandedElts(2, {0, -1}, APInt(2, 0x3), LHS, RHS));
223
224 // broadcast zero (with permitted undefs)
225 EXPECT_TRUE(getShuffleDemandedElts(3, {0, 0, -1}, APInt(3, 0x7), LHS, RHS, true));
226 EXPECT_EQ(LHS.getZExtValue(), 0x1U);
227 EXPECT_EQ(RHS.getZExtValue(), 0x0U);
228
229 // broadcast one in demanded
230 EXPECT_TRUE(getShuffleDemandedElts(4, {1, 1, 1, -1}, APInt(4, 0x7), LHS, RHS));
231 EXPECT_EQ(LHS.getZExtValue(), 0x2U);
232 EXPECT_EQ(RHS.getZExtValue(), 0x0U);
233
234 // broadcast 7 in demanded
235 EXPECT_TRUE(getShuffleDemandedElts(4, {7, 0, 7, 7}, APInt(4, 0xd), LHS, RHS));
236 EXPECT_EQ(LHS.getZExtValue(), 0x0U);
237 EXPECT_EQ(RHS.getZExtValue(), 0x8U);
238
239 // general test
240 EXPECT_TRUE(getShuffleDemandedElts(4, {4, 2, 7, 3}, APInt(4, 0xf), LHS, RHS));
241 EXPECT_EQ(LHS.getZExtValue(), 0xcU);
242 EXPECT_EQ(RHS.getZExtValue(), 0x9U);
243 }
244
245 TEST_F(BasicTest, getHorizontalDemandedEltsForFirstOperand) {
246 APInt LHS, RHS;
247
248 getHorizDemandedEltsForFirstOperand(128, APInt(4, 0b0000), LHS, RHS);
249 EXPECT_EQ(LHS.getZExtValue(), 0b0000U);
250 EXPECT_EQ(RHS.getZExtValue(), 0b0000U);
251
252 getHorizDemandedEltsForFirstOperand(128, APInt(4, 0b0001), LHS, RHS);
253 EXPECT_EQ(LHS.getZExtValue(), 0b0001U);
254 EXPECT_EQ(RHS.getZExtValue(), 0b0000U);
255
256 getHorizDemandedEltsForFirstOperand(128, APInt(4, 0b1000), LHS, RHS);
257 EXPECT_EQ(LHS.getZExtValue(), 0b0000U);
258 EXPECT_EQ(RHS.getZExtValue(), 0b0100U);
259
260 getHorizDemandedEltsForFirstOperand(128, APInt(4, 0b0110), LHS, RHS);
261 EXPECT_EQ(LHS.getZExtValue(), 0b0100U);
262 EXPECT_EQ(RHS.getZExtValue(), 0b0001U);
263
264 getHorizDemandedEltsForFirstOperand(256, APInt(4, 0b0100), LHS, RHS);
265 EXPECT_EQ(LHS.getZExtValue(), 0b0100U);
266 EXPECT_EQ(RHS.getZExtValue(), 0b0000U);
267 }
268
269 TEST_F(BasicTest, getSplatIndex) {
270 EXPECT_EQ(getSplatIndex({0,0,0}), 0);
271 EXPECT_EQ(getSplatIndex({1,0,0}), -1); // no splat
272 EXPECT_EQ(getSplatIndex({0,1,1}), -1); // no splat
273 EXPECT_EQ(getSplatIndex({42,42,42}), 42); // array size is independent of splat index
274 EXPECT_EQ(getSplatIndex({42,42,-1}), 42); // ignore negative
275 EXPECT_EQ(getSplatIndex({-1,42,-1}), 42); // ignore negatives
276 EXPECT_EQ(getSplatIndex({-4,42,-42}), 42); // ignore all negatives
277 EXPECT_EQ(getSplatIndex({-4,-1,-42}), -1); // all negative values map to -1
278 }
279
280 TEST_F(VectorUtilsTest, isSplatValue_00) {
281 parseAssembly(
282 "define <2 x i8> @test(<2 x i8> %x) {\n"
283 " %A = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> zeroinitializer\n"
284 " ret <2 x i8> %A\n"
285 "}\n");
286 EXPECT_TRUE(isSplatValue(A));
287 }
288
289 TEST_F(VectorUtilsTest, isSplatValue_00_index0) {
290 parseAssembly(
291 "define <2 x i8> @test(<2 x i8> %x) {\n"
292 " %A = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> zeroinitializer\n"
293 " ret <2 x i8> %A\n"
294 "}\n");
295 EXPECT_TRUE(isSplatValue(A, 0));
296 }
297
298 TEST_F(VectorUtilsTest, isSplatValue_00_index1) {
299 parseAssembly(
300 "define <2 x i8> @test(<2 x i8> %x) {\n"
301 " %A = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> zeroinitializer\n"
302 " ret <2 x i8> %A\n"
303 "}\n");
304 EXPECT_FALSE(isSplatValue(A, 1));
305 }
306
307 TEST_F(VectorUtilsTest, isSplatValue_11) {
308 parseAssembly(
309 "define <2 x i8> @test(<2 x i8> %x) {\n"
310 " %A = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
311 " ret <2 x i8> %A\n"
312 "}\n");
313 EXPECT_TRUE(isSplatValue(A));
314 }
315
316 TEST_F(VectorUtilsTest, isSplatValue_11_index0) {
317 parseAssembly(
318 "define <2 x i8> @test(<2 x i8> %x) {\n"
319 " %A = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
320 " ret <2 x i8> %A\n"
321 "}\n");
322 EXPECT_FALSE(isSplatValue(A, 0));
323 }
324
325 TEST_F(VectorUtilsTest, isSplatValue_11_index1) {
326 parseAssembly(
327 "define <2 x i8> @test(<2 x i8> %x) {\n"
328 " %A = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
329 " ret <2 x i8> %A\n"
330 "}\n");
331 EXPECT_TRUE(isSplatValue(A, 1));
332 }
333
334 TEST_F(VectorUtilsTest, isSplatValue_01) {
335 parseAssembly(
336 "define <2 x i8> @test(<2 x i8> %x) {\n"
337 " %A = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 0, i32 1>\n"
338 " ret <2 x i8> %A\n"
339 "}\n");
340 EXPECT_FALSE(isSplatValue(A));
341 }
342
343 TEST_F(VectorUtilsTest, isSplatValue_01_index0) {
344 parseAssembly(
345 "define <2 x i8> @test(<2 x i8> %x) {\n"
346 " %A = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 0, i32 1>\n"
347 " ret <2 x i8> %A\n"
348 "}\n");
349 EXPECT_FALSE(isSplatValue(A, 0));
350 }
351
352 TEST_F(VectorUtilsTest, isSplatValue_01_index1) {
353 parseAssembly(
354 "define <2 x i8> @test(<2 x i8> %x) {\n"
355 " %A = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 0, i32 1>\n"
356 " ret <2 x i8> %A\n"
357 "}\n");
358 EXPECT_FALSE(isSplatValue(A, 1));
359 }
360
361 // FIXME: Allow undef matching with Constant (mask) splat analysis.
362
363 TEST_F(VectorUtilsTest, isSplatValue_0u) {
364 parseAssembly(
365 "define <2 x i8> @test(<2 x i8> %x) {\n"
366 " %A = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 0, i32 undef>\n"
367 " ret <2 x i8> %A\n"
368 "}\n");
369 EXPECT_FALSE(isSplatValue(A));
370 }
371
372 // FIXME: Allow undef matching with Constant (mask) splat analysis.
373
374 TEST_F(VectorUtilsTest, isSplatValue_0u_index0) {
375 parseAssembly(
376 "define <2 x i8> @test(<2 x i8> %x) {\n"
377 " %A = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 0, i32 undef>\n"
378 " ret <2 x i8> %A\n"
379 "}\n");
380 EXPECT_FALSE(isSplatValue(A, 0));
381 }
382
383 TEST_F(VectorUtilsTest, isSplatValue_0u_index1) {
384 parseAssembly(
385 "define <2 x i8> @test(<2 x i8> %x) {\n"
386 " %A = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 0, i32 undef>\n"
387 " ret <2 x i8> %A\n"
388 "}\n");
389 EXPECT_FALSE(isSplatValue(A, 1));
390 }
391
392 TEST_F(VectorUtilsTest, isSplatValue_Binop) {
393 parseAssembly(
394 "define <2 x i8> @test(<2 x i8> %x) {\n"
395 " %v0 = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 0, i32 0>\n"
396 " %v1 = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
397 " %A = udiv <2 x i8> %v0, %v1\n"
398 " ret <2 x i8> %A\n"
399 "}\n");
400 EXPECT_TRUE(isSplatValue(A));
401 }
402
403 TEST_F(VectorUtilsTest, isSplatValue_Binop_index0) {
404 parseAssembly(
405 "define <2 x i8> @test(<2 x i8> %x) {\n"
406 " %v0 = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 0, i32 0>\n"
407 " %v1 = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
408 " %A = udiv <2 x i8> %v0, %v1\n"
409 " ret <2 x i8> %A\n"
410 "}\n");
411 EXPECT_FALSE(isSplatValue(A, 0));
412 }
413
414 TEST_F(VectorUtilsTest, isSplatValue_Binop_index1) {
415 parseAssembly(
416 "define <2 x i8> @test(<2 x i8> %x) {\n"
417 " %v0 = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 0, i32 0>\n"
418 " %v1 = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
419 " %A = udiv <2 x i8> %v0, %v1\n"
420 " ret <2 x i8> %A\n"
421 "}\n");
422 EXPECT_FALSE(isSplatValue(A, 1));
423 }
424
425 TEST_F(VectorUtilsTest, isSplatValue_Binop_ConstantOp0) {
426 parseAssembly(
427 "define <2 x i8> @test(<2 x i8> %x) {\n"
428 " %v1 = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
429 " %A = ashr <2 x i8> <i8 42, i8 42>, %v1\n"
430 " ret <2 x i8> %A\n"
431 "}\n");
432 EXPECT_TRUE(isSplatValue(A));
433 }
434
435 TEST_F(VectorUtilsTest, isSplatValue_Binop_ConstantOp0_index0) {
436 parseAssembly(
437 "define <2 x i8> @test(<2 x i8> %x) {\n"
438 " %v1 = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
439 " %A = ashr <2 x i8> <i8 42, i8 42>, %v1\n"
440 " ret <2 x i8> %A\n"
441 "}\n");
442 EXPECT_FALSE(isSplatValue(A, 0));
443 }
444
445 TEST_F(VectorUtilsTest, isSplatValue_Binop_ConstantOp0_index1) {
446 parseAssembly(
447 "define <2 x i8> @test(<2 x i8> %x) {\n"
448 " %v1 = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
449 " %A = ashr <2 x i8> <i8 42, i8 42>, %v1\n"
450 " ret <2 x i8> %A\n"
451 "}\n");
452 EXPECT_TRUE(isSplatValue(A, 1));
453 }
454
455 TEST_F(VectorUtilsTest, isSplatValue_Binop_Not_Op0) {
456 parseAssembly(
457 "define <2 x i8> @test(<2 x i8> %x) {\n"
458 " %v0 = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 1, i32 0>\n"
459 " %v1 = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
460 " %A = add <2 x i8> %v0, %v1\n"
461 " ret <2 x i8> %A\n"
462 "}\n");
463 EXPECT_FALSE(isSplatValue(A));
464 }
465
466 TEST_F(VectorUtilsTest, isSplatValue_Binop_Not_Op1) {
467 parseAssembly(
468 "define <2 x i8> @test(<2 x i8> %x) {\n"
469 " %v0 = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
470 " %v1 = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 0, i32 1>\n"
471 " %A = shl <2 x i8> %v0, %v1\n"
472 " ret <2 x i8> %A\n"
473 "}\n");
474 EXPECT_FALSE(isSplatValue(A));
475 }
476
477 TEST_F(VectorUtilsTest, isSplatValue_Select) {
478 parseAssembly(
479 "define <2 x i8> @test(<2 x i1> %x, <2 x i8> %y, <2 x i8> %z) {\n"
480 " %v0 = shufflevector <2 x i1> %x, <2 x i1> undef, <2 x i32> <i32 1, i32 1>\n"
481 " %v1 = shufflevector <2 x i8> %y, <2 x i8> undef, <2 x i32> <i32 0, i32 0>\n"
482 " %v2 = shufflevector <2 x i8> %z, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
483 " %A = select <2 x i1> %v0, <2 x i8> %v1, <2 x i8> %v2\n"
484 " ret <2 x i8> %A\n"
485 "}\n");
486 EXPECT_TRUE(isSplatValue(A));
487 }
488
489 TEST_F(VectorUtilsTest, isSplatValue_Select_ConstantOp) {
490 parseAssembly(
491 "define <2 x i8> @test(<2 x i1> %x, <2 x i8> %y, <2 x i8> %z) {\n"
492 " %v0 = shufflevector <2 x i1> %x, <2 x i1> undef, <2 x i32> <i32 1, i32 1>\n"
493 " %v2 = shufflevector <2 x i8> %z, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
494 " %A = select <2 x i1> %v0, <2 x i8> <i8 42, i8 42>, <2 x i8> %v2\n"
495 " ret <2 x i8> %A\n"
496 "}\n");
497 EXPECT_TRUE(isSplatValue(A));
498 }
499
500 TEST_F(VectorUtilsTest, isSplatValue_Select_NotCond) {
501 parseAssembly(
502 "define <2 x i8> @test(<2 x i1> %x, <2 x i8> %y, <2 x i8> %z) {\n"
503 " %v1 = shufflevector <2 x i8> %y, <2 x i8> undef, <2 x i32> <i32 0, i32 0>\n"
504 " %v2 = shufflevector <2 x i8> %z, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
505 " %A = select <2 x i1> %x, <2 x i8> %v1, <2 x i8> %v2\n"
506 " ret <2 x i8> %A\n"
507 "}\n");
508 EXPECT_FALSE(isSplatValue(A));
509 }
510
511 TEST_F(VectorUtilsTest, isSplatValue_Select_NotOp1) {
512 parseAssembly(
513 "define <2 x i8> @test(<2 x i1> %x, <2 x i8> %y, <2 x i8> %z) {\n"
514 " %v0 = shufflevector <2 x i1> %x, <2 x i1> undef, <2 x i32> <i32 1, i32 1>\n"
515 " %v2 = shufflevector <2 x i8> %z, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
516 " %A = select <2 x i1> %v0, <2 x i8> %y, <2 x i8> %v2\n"
517 " ret <2 x i8> %A\n"
518 "}\n");
519 EXPECT_FALSE(isSplatValue(A));
520 }
521
522 TEST_F(VectorUtilsTest, isSplatValue_Select_NotOp2) {
523 parseAssembly(
524 "define <2 x i8> @test(<2 x i1> %x, <2 x i8> %y, <2 x i8> %z) {\n"
525 " %v0 = shufflevector <2 x i1> %x, <2 x i1> undef, <2 x i32> <i32 1, i32 1>\n"
526 " %v1 = shufflevector <2 x i8> %y, <2 x i8> undef, <2 x i32> <i32 0, i32 0>\n"
527 " %A = select <2 x i1> %v0, <2 x i8> %v1, <2 x i8> %z\n"
528 " ret <2 x i8> %A\n"
529 "}\n");
530 EXPECT_FALSE(isSplatValue(A));
531 }
532
533 TEST_F(VectorUtilsTest, isSplatValue_SelectBinop) {
534 parseAssembly(
535 "define <2 x i8> @test(<2 x i1> %x, <2 x i8> %y, <2 x i8> %z) {\n"
536 " %v0 = shufflevector <2 x i1> %x, <2 x i1> undef, <2 x i32> <i32 1, i32 1>\n"
537 " %v1 = shufflevector <2 x i8> %y, <2 x i8> undef, <2 x i32> <i32 0, i32 0>\n"
538 " %v2 = shufflevector <2 x i8> %z, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
539 " %bo = xor <2 x i8> %v1, %v2\n"
540 " %A = select <2 x i1> %v0, <2 x i8> %bo, <2 x i8> %v2\n"
541 " ret <2 x i8> %A\n"
542 "}\n");
543 EXPECT_TRUE(isSplatValue(A));
544 }
545
546 TEST_F(VectorUtilsTest, getSplatValueElt0) {
547 parseAssembly(
548 "define <2 x i8> @test(i8 %x) {\n"
549 " %ins = insertelement <2 x i8> undef, i8 %x, i32 0\n"
550 " %A = shufflevector <2 x i8> %ins, <2 x i8> undef, <2 x i32> zeroinitializer\n"
551 " ret <2 x i8> %A\n"
552 "}\n");
553 EXPECT_EQ(getSplatValue(A)->getName(), "x");
554 }
555
556 TEST_F(VectorUtilsTest, getSplatValueEltMismatch) {
557 parseAssembly(
558 "define <2 x i8> @test(i8 %x) {\n"
559 " %ins = insertelement <2 x i8> undef, i8 %x, i32 1\n"
560 " %A = shufflevector <2 x i8> %ins, <2 x i8> undef, <2 x i32> zeroinitializer\n"
561 " ret <2 x i8> %A\n"
562 "}\n");
563 EXPECT_EQ(getSplatValue(A), nullptr);
564 }
565
566 // TODO: This is a splat, but we don't recognize it.
567
568 TEST_F(VectorUtilsTest, getSplatValueElt1) {
569 parseAssembly(
570 "define <2 x i8> @test(i8 %x) {\n"
571 " %ins = insertelement <2 x i8> undef, i8 %x, i32 1\n"
572 " %A = shufflevector <2 x i8> %ins, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
573 " ret <2 x i8> %A\n"
574 "}\n");
575 EXPECT_EQ(getSplatValue(A), nullptr);
576 }
577
578 ////////////////////////////////////////////////////////////////////////////////
579 // VFShape API tests.
580 ////////////////////////////////////////////////////////////////////////////////
581
582 class VFShapeAPITest : public testing::Test {
583 protected:
584 void SetUp() override {
585 M = parseAssemblyString(IR, Err, Ctx);
586 // Get the only call instruction in the block, which is the first
587 // instruction.
588 CI = dyn_cast<CallInst>(&*(instructions(M->getFunction("f")).begin()));
589 }
590
591 const char *IR = "define i32 @f(i32 %a, i64 %b, double %c) {\n"
592 " %1 = call i32 @g(i32 %a, i64 %b, double %c)\n"
593 " ret i32 %1\n"
594 "}\n"
595 "declare i32 @g(i32, i64, double)\n";
596 LLVMContext Ctx;
597 SMDiagnostic Err;
598 std::unique_ptr<Module> M;
599 CallInst *CI;
600 // Dummy shape with no parameters, overwritten by buildShape when invoked.
601 VFShape Shape = {/*VF*/ ElementCount::getFixed(2), /*Parameters*/ {}};
602 VFShape Expected;
603 SmallVector<VFParameter, 8> &ExpectedParams = Expected.Parameters;
604
605 void buildShape(ElementCount VF, bool HasGlobalPred) {
606 Shape = VFShape::get(CI->getFunctionType(), VF, HasGlobalPred);
607 }
608
609 bool validParams(ArrayRef<VFParameter> Parameters) {
610 Shape.Parameters = SmallVector<VFParameter, 8>(Parameters);
611 return Shape.hasValidParameterList();
612 }
613 };
614
615 TEST_F(VFShapeAPITest, API_buildVFShape) {
616 buildShape(/*VF*/ ElementCount::getFixed(2), /*HasGlobalPred*/ false);
617 Expected = {/*VF*/ ElementCount::getFixed(2), /*Parameters*/ {
618 {0, VFParamKind::Vector},
619 {1, VFParamKind::Vector},
620 {2, VFParamKind::Vector},
621 }};
622 EXPECT_EQ(Shape, Expected);
623
624 buildShape(/*VF*/ ElementCount::getFixed(4), /*HasGlobalPred*/ true);
625 Expected = {/*VF*/ ElementCount::getFixed(4), /*Parameters*/ {
626 {0, VFParamKind::Vector},
627 {1, VFParamKind::Vector},
628 {2, VFParamKind::Vector},
629 {3, VFParamKind::GlobalPredicate},
630 }};
631 EXPECT_EQ(Shape, Expected);
632
633 buildShape(/*VF*/ ElementCount::getScalable(16), /*HasGlobalPred*/ false);
634 Expected = {/*VF*/ ElementCount::getScalable(16), /*Parameters*/ {
635 {0, VFParamKind::Vector},
636 {1, VFParamKind::Vector},
637 {2, VFParamKind::Vector},
638 }};
639 EXPECT_EQ(Shape, Expected);
640 }
641
642 TEST_F(VFShapeAPITest, API_getScalarShape) {
643 buildShape(/*VF*/ ElementCount::getFixed(1), /*HasGlobalPred*/ false);
644 EXPECT_EQ(VFShape::getScalarShape(CI->getFunctionType()), Shape);
645 }
646
647 TEST_F(VFShapeAPITest, API_getVectorizedFunction) {
648 VFShape ScalarShape = VFShape::getScalarShape(CI->getFunctionType());
649 EXPECT_EQ(VFDatabase(*CI).getVectorizedFunction(ScalarShape),
650 M->getFunction("g"));
651
652 buildShape(/*VF*/ ElementCount::getScalable(1), /*HasGlobalPred*/ false);
653 EXPECT_EQ(VFDatabase(*CI).getVectorizedFunction(Shape), nullptr);
654 buildShape(/*VF*/ ElementCount::getFixed(1), /*HasGlobalPred*/ true);
655 EXPECT_EQ(VFDatabase(*CI).getVectorizedFunction(Shape), nullptr);
656 buildShape(/*VF*/ ElementCount::getScalable(1), /*HasGlobalPred*/ true);
657 EXPECT_EQ(VFDatabase(*CI).getVectorizedFunction(Shape), nullptr);
658 }
659
660 TEST_F(VFShapeAPITest, API_updateVFShape) {
661
662 buildShape(/*VF*/ ElementCount::getFixed(2), /*HasGlobalPred*/ false);
663 Shape.updateParam({0 /*Pos*/, VFParamKind::OMP_Linear, 1, Align(4)});
664 Expected = {/*VF*/ ElementCount::getFixed(2), /*Parameters*/ {
665 {0, VFParamKind::OMP_Linear, 1, Align(4)},
666 {1, VFParamKind::Vector},
667 {2, VFParamKind::Vector},
668 }};
669 EXPECT_EQ(Shape, Expected);
670
671 // From this point on, we update only the parameters of the VFShape,
672 // so we update only the reference of the expected Parameters.
673 Shape.updateParam({1 /*Pos*/, VFParamKind::OMP_Uniform});
674 ExpectedParams = {
675 {0, VFParamKind::OMP_Linear, 1, Align(4)},
676 {1, VFParamKind::OMP_Uniform},
677 {2, VFParamKind::Vector},
678 };
679 EXPECT_EQ(Shape, Expected);
680
681 Shape.updateParam({2 /*Pos*/, VFParamKind::OMP_LinearRefPos, 1});
682 ExpectedParams = {
683 {0, VFParamKind::OMP_Linear, 1, Align(4)},
684 {1, VFParamKind::OMP_Uniform},
685 {2, VFParamKind::OMP_LinearRefPos, 1},
686 };
687 EXPECT_EQ(Shape, Expected);
688 }
689
690 TEST_F(VFShapeAPITest, API_updateVFShape_GlobalPredicate) {
691
692 buildShape(/*VF*/ ElementCount::getScalable(2), /*HasGlobalPred*/ true);
693 Shape.updateParam({1 /*Pos*/, VFParamKind::OMP_Uniform});
694 Expected = {/*VF*/ ElementCount::getScalable(2),
695 /*Parameters*/ {{0, VFParamKind::Vector},
696 {1, VFParamKind::OMP_Uniform},
697 {2, VFParamKind::Vector},
698 {3, VFParamKind::GlobalPredicate}}};
699 EXPECT_EQ(Shape, Expected);
700 }
701
702 TEST_F(VFShapeAPITest, Parameters_Valid) {
703 // ParamPos in order.
704 EXPECT_TRUE(validParams({{0, VFParamKind::Vector}}));
705 EXPECT_TRUE(
706 validParams({{0, VFParamKind::Vector}, {1, VFParamKind::Vector}}));
707 EXPECT_TRUE(validParams({{0, VFParamKind::Vector},
708 {1, VFParamKind::Vector},
709 {2, VFParamKind::Vector}}));
710
711 // GlocalPredicate is unique.
712 EXPECT_TRUE(validParams({{0, VFParamKind::Vector},
713 {1, VFParamKind::Vector},
714 {2, VFParamKind::Vector},
715 {3, VFParamKind::GlobalPredicate}}));
716
717 EXPECT_TRUE(validParams({{0, VFParamKind::Vector},
718 {1, VFParamKind::GlobalPredicate},
719 {2, VFParamKind::Vector}}));
720 }
721
722 TEST_F(VFShapeAPITest, Parameters_ValidOpenMPLinear) {
723 // Valid linear constant step (>0).
724 #define __BUILD_PARAMETERS(Kind, Val) \
725 { \
726 { 0, Kind, Val } \
727 }
728 EXPECT_TRUE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_Linear, 1)));
729 EXPECT_TRUE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearRef, 2)));
730 EXPECT_TRUE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearVal, 4)));
731 EXPECT_TRUE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearUVal, 33)));
732 #undef __BUILD_PARAMETERS
733
734 // Valid linear runtime step (the step parameter is marked uniform).
735 #define __BUILD_PARAMETERS(Kind) \
736 { \
737 {0, VFParamKind::OMP_Uniform}, {1, VFParamKind::Vector}, { 2, Kind, 0 } \
738 }
739 EXPECT_TRUE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearPos)));
740 EXPECT_TRUE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearRefPos)));
741 EXPECT_TRUE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearValPos)));
742 EXPECT_TRUE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearUValPos)));
743 #undef __BUILD_PARAMETERS
744 }
745
746 TEST_F(VFShapeAPITest, Parameters_Invalid) {
747 #ifndef NDEBUG
748 // Wrong order is checked by an assertion: make sure that the
749 // assertion is not removed.
750 EXPECT_DEATH(validParams({{1, VFParamKind::Vector}}),
751 "Broken parameter list.");
752 EXPECT_DEATH(
753 validParams({{1, VFParamKind::Vector}, {0, VFParamKind::Vector}}),
754 "Broken parameter list.");
755 #endif
756
757 // GlobalPredicate is not unique
758 EXPECT_FALSE(validParams({{0, VFParamKind::Vector},
759 {1, VFParamKind::GlobalPredicate},
760 {2, VFParamKind::GlobalPredicate}}));
761 EXPECT_FALSE(validParams({{0, VFParamKind::GlobalPredicate},
762 {1, VFParamKind::Vector},
763 {2, VFParamKind::GlobalPredicate}}));
764 }
765
766 TEST_F(VFShapeAPITest, Parameters_InvalidOpenMPLinear) {
767 // Compile time linear steps must be non-zero (compile time invariant).
768 #define __BUILD_PARAMETERS(Kind) \
769 { \
770 { 0, Kind, 0 } \
771 }
772 EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_Linear)));
773 EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearRef)));
774 EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearVal)));
775 EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearUVal)));
776 #undef __BUILD_PARAMETERS
777
778 // The step of a runtime linear parameter must be marked
779 // as uniform (runtime invariant).
780 #define __BUILD_PARAMETERS(Kind) \
781 { \
782 {0, VFParamKind::OMP_Uniform}, {1, VFParamKind::Vector}, { 2, Kind, 1 } \
783 }
784 EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearPos)));
785 EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearRefPos)));
786 EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearValPos)));
787 EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearUValPos)));
788 #undef __BUILD_PARAMETERS
789
790 // The linear step parameter can't point at itself.
791 #define __BUILD_PARAMETERS(Kind) \
792 { \
793 {0, VFParamKind::Vector}, {1, VFParamKind::Vector}, { 2, Kind, 2 } \
794 }
795 EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearPos)));
796 EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearRefPos)));
797 EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearValPos)));
798 EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearUValPos)));
799 #undef __BUILD_PARAMETERS
800
801 // Linear parameter (runtime) is out of range.
802 #define __BUILD_PARAMETERS(Kind) \
803 { \
804 {0, VFParamKind::Vector}, {1, VFParamKind::Vector}, { 2, Kind, 3 } \
805 }
806 EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearPos)));
807 EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearRefPos)));
808 EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearValPos)));
809 EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearUValPos)));
810 #undef __BUILD_PARAMETERS
811 }
LLVM monorepo