812 lines · cpp
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-exception6//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 22using namespace llvm;23 24namespace {25 26class VectorUtilsTest : public testing::Test {27protected: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 60struct 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} // namespace77 78TEST_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 104TEST_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 113TEST_F(BasicTest, widenShuffleMaskElts) {114 SmallVector<int, 16> WideMask;115 SmallVector<int, 16> NarrowMask;116 117 // scale == 1 is a copy118 EXPECT_TRUE(widenShuffleMaskElts(1, {3,2,0,-1}, WideMask));119 EXPECT_EQ(ArrayRef(WideMask), ArrayRef({3, 2, 0, -1}));120 121 // back to original mask122 narrowShuffleMaskElts(1, ArrayRef(WideMask), NarrowMask);123 EXPECT_EQ(ArrayRef(NarrowMask), ArrayRef({3, 2, 0, -1}));124 125 // can't widen non-consecutive 3/2126 EXPECT_FALSE(widenShuffleMaskElts(2, {3,2,0,-1}, WideMask));127 128 // can't widen if not evenly divisible129 EXPECT_FALSE(widenShuffleMaskElts(2, {0,1,2}, WideMask));130 131 // can always widen identity to single element132 EXPECT_TRUE(widenShuffleMaskElts(3, {0,1,2}, WideMask));133 EXPECT_EQ(ArrayRef(WideMask), ArrayRef({0}));134 135 // back to original mask136 narrowShuffleMaskElts(3, ArrayRef(WideMask), NarrowMask);137 EXPECT_EQ(ArrayRef(NarrowMask), ArrayRef({0, 1, 2}));138 139 // groups of 4 must be consecutive/undef140 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 mask144 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/undef149 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/undef152 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 mask156 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 element163 EXPECT_FALSE(widenShuffleMaskElts(2, {-1,-2,-1,-1}, WideMask));164 165 // negative indexes must match across a wide element166 EXPECT_TRUE(widenShuffleMaskElts(2, {-2,-2,-3,-3}, WideMask));167 EXPECT_EQ(ArrayRef(WideMask), ArrayRef({-2, -3}));168}169 170TEST_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/2178 getShuffleMaskWithWidestElts({3, 2, 0, -1}, WideMask);179 EXPECT_EQ(ArrayRef(WideMask), ArrayRef({3, 2, 0, -1}));180 181 // can always widen identity to single element182 getShuffleMaskWithWidestElts({0, 1, 2}, WideMask);183 EXPECT_EQ(ArrayRef(WideMask), ArrayRef({0}));184 185 // groups of 4 must be consecutive/undef186 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/undef191 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/undef197 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 element205 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 element209 getShuffleMaskWithWidestElts({-2, -2, -3, -3}, WideMask);210 EXPECT_EQ(ArrayRef(WideMask), ArrayRef({-2, -3}));211}212 213TEST_F(BasicTest, getShuffleDemandedElts) {214 APInt LHS, RHS;215 216 // broadcast zero217 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 demanded230 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 demanded235 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 test240 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 245TEST_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 269TEST_F(BasicTest, getSplatIndex) {270 EXPECT_EQ(getSplatIndex({0,0,0}), 0);271 EXPECT_EQ(getSplatIndex({1,0,0}), -1); // no splat272 EXPECT_EQ(getSplatIndex({0,1,1}), -1); // no splat273 EXPECT_EQ(getSplatIndex({42,42,42}), 42); // array size is independent of splat index274 EXPECT_EQ(getSplatIndex({42,42,-1}), 42); // ignore negative275 EXPECT_EQ(getSplatIndex({-1,42,-1}), 42); // ignore negatives276 EXPECT_EQ(getSplatIndex({-4,42,-42}), 42); // ignore all negatives277 EXPECT_EQ(getSplatIndex({-4,-1,-42}), -1); // all negative values map to -1278}279 280TEST_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 289TEST_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 298TEST_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 307TEST_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 316TEST_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 325TEST_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 334TEST_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 343TEST_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 352TEST_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 363TEST_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 374TEST_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 383TEST_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 392TEST_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 403TEST_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 414TEST_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 425TEST_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 435TEST_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 445TEST_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 455TEST_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 466TEST_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 477TEST_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 489TEST_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 500TEST_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 511TEST_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 522TEST_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 533TEST_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 546TEST_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 556TEST_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 568TEST_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 582class VFShapeAPITest : public testing::Test {583protected:584 void SetUp() override {585 M = parseAssemblyString(IR, Err, Ctx);586 // Get the only call instruction in the block, which is the first587 // 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 615TEST_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 642TEST_F(VFShapeAPITest, API_getScalarShape) {643 buildShape(/*VF*/ ElementCount::getFixed(1), /*HasGlobalPred*/ false);644 EXPECT_EQ(VFShape::getScalarShape(CI->getFunctionType()), Shape);645}646 647TEST_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 660TEST_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 690TEST_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 702TEST_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 722TEST_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_PARAMETERS733 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_PARAMETERS744}745 746TEST_F(VFShapeAPITest, Parameters_Invalid) {747#ifndef NDEBUG748 // Wrong order is checked by an assertion: make sure that the749 // 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#endif756 757 // GlobalPredicate is not unique758 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 766TEST_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_PARAMETERS777 778// The step of a runtime linear parameter must be marked779// 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_PARAMETERS789 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_PARAMETERS800 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_PARAMETERS811}812