1 //===- llvm/unittests/Transforms/Vectorize/VPlanTest.cpp - VPlan tests ----===// 2 // 3 // 4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5 // See https://llvm.org/LICENSE.txt for license information. 6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "../lib/Transforms/Vectorize/VPlan.h" 11 #include "llvm/Analysis/VectorUtils.h" 12 #include "llvm/IR/Instruction.h" 13 #include "llvm/IR/Instructions.h" 14 #include "gtest/gtest.h" 15 #include <string> 16 17 namespace llvm { 18 namespace { 19 20 #define CHECK_ITERATOR(Range1, ...) \ 21 do { \ 22 std::vector<VPInstruction *> Tmp = {__VA_ARGS__}; \ 23 EXPECT_EQ((size_t)std::distance(Range1.begin(), Range1.end()), \ 24 Tmp.size()); \ 25 for (auto Pair : zip(Range1, make_range(Tmp.begin(), Tmp.end()))) \ 26 EXPECT_EQ(&std::get<0>(Pair), std::get<1>(Pair)); \ 27 } while (0) 28 29 TEST(VPInstructionTest, insertBefore) { 30 VPInstruction *I1 = new VPInstruction(0, {}); 31 VPInstruction *I2 = new VPInstruction(1, {}); 32 VPInstruction *I3 = new VPInstruction(2, {}); 33 34 VPBasicBlock VPBB1; 35 VPBB1.appendRecipe(I1); 36 37 I2->insertBefore(I1); 38 CHECK_ITERATOR(VPBB1, I2, I1); 39 40 I3->insertBefore(I2); 41 CHECK_ITERATOR(VPBB1, I3, I2, I1); 42 } 43 44 TEST(VPInstructionTest, eraseFromParent) { 45 VPInstruction *I1 = new VPInstruction(0, {}); 46 VPInstruction *I2 = new VPInstruction(1, {}); 47 VPInstruction *I3 = new VPInstruction(2, {}); 48 49 VPBasicBlock VPBB1; 50 VPBB1.appendRecipe(I1); 51 VPBB1.appendRecipe(I2); 52 VPBB1.appendRecipe(I3); 53 54 I2->eraseFromParent(); 55 CHECK_ITERATOR(VPBB1, I1, I3); 56 57 I1->eraseFromParent(); 58 CHECK_ITERATOR(VPBB1, I3); 59 60 I3->eraseFromParent(); 61 EXPECT_TRUE(VPBB1.empty()); 62 } 63 64 TEST(VPInstructionTest, moveAfter) { 65 VPInstruction *I1 = new VPInstruction(0, {}); 66 VPInstruction *I2 = new VPInstruction(1, {}); 67 VPInstruction *I3 = new VPInstruction(2, {}); 68 69 VPBasicBlock VPBB1; 70 VPBB1.appendRecipe(I1); 71 VPBB1.appendRecipe(I2); 72 VPBB1.appendRecipe(I3); 73 74 I1->moveAfter(I2); 75 76 CHECK_ITERATOR(VPBB1, I2, I1, I3); 77 78 VPInstruction *I4 = new VPInstruction(4, {}); 79 VPInstruction *I5 = new VPInstruction(5, {}); 80 VPBasicBlock VPBB2; 81 VPBB2.appendRecipe(I4); 82 VPBB2.appendRecipe(I5); 83 84 I3->moveAfter(I4); 85 86 CHECK_ITERATOR(VPBB1, I2, I1); 87 CHECK_ITERATOR(VPBB2, I4, I3, I5); 88 EXPECT_EQ(I3->getParent(), I4->getParent()); 89 } 90 91 TEST(VPInstructionTest, moveBefore) { 92 VPInstruction *I1 = new VPInstruction(0, {}); 93 VPInstruction *I2 = new VPInstruction(1, {}); 94 VPInstruction *I3 = new VPInstruction(2, {}); 95 96 VPBasicBlock VPBB1; 97 VPBB1.appendRecipe(I1); 98 VPBB1.appendRecipe(I2); 99 VPBB1.appendRecipe(I3); 100 101 I1->moveBefore(VPBB1, I3->getIterator()); 102 103 CHECK_ITERATOR(VPBB1, I2, I1, I3); 104 105 VPInstruction *I4 = new VPInstruction(4, {}); 106 VPInstruction *I5 = new VPInstruction(5, {}); 107 VPBasicBlock VPBB2; 108 VPBB2.appendRecipe(I4); 109 VPBB2.appendRecipe(I5); 110 111 I3->moveBefore(VPBB2, I4->getIterator()); 112 113 CHECK_ITERATOR(VPBB1, I2, I1); 114 CHECK_ITERATOR(VPBB2, I3, I4, I5); 115 EXPECT_EQ(I3->getParent(), I4->getParent()); 116 117 VPBasicBlock VPBB3; 118 119 I4->moveBefore(VPBB3, VPBB3.end()); 120 121 CHECK_ITERATOR(VPBB1, I2, I1); 122 CHECK_ITERATOR(VPBB2, I3, I5); 123 CHECK_ITERATOR(VPBB3, I4); 124 EXPECT_EQ(&VPBB3, I4->getParent()); 125 } 126 127 TEST(VPInstructionTest, setOperand) { 128 VPValue *VPV1 = new VPValue(); 129 VPValue *VPV2 = new VPValue(); 130 VPInstruction *I1 = new VPInstruction(0, {VPV1, VPV2}); 131 EXPECT_EQ(1u, VPV1->getNumUsers()); 132 EXPECT_EQ(I1, *VPV1->user_begin()); 133 EXPECT_EQ(1u, VPV2->getNumUsers()); 134 EXPECT_EQ(I1, *VPV2->user_begin()); 135 136 // Replace operand 0 (VPV1) with VPV3. 137 VPValue *VPV3 = new VPValue(); 138 I1->setOperand(0, VPV3); 139 EXPECT_EQ(0u, VPV1->getNumUsers()); 140 EXPECT_EQ(1u, VPV2->getNumUsers()); 141 EXPECT_EQ(I1, *VPV2->user_begin()); 142 EXPECT_EQ(1u, VPV3->getNumUsers()); 143 EXPECT_EQ(I1, *VPV3->user_begin()); 144 145 // Replace operand 1 (VPV2) with VPV3. 146 I1->setOperand(1, VPV3); 147 EXPECT_EQ(0u, VPV1->getNumUsers()); 148 EXPECT_EQ(0u, VPV2->getNumUsers()); 149 EXPECT_EQ(2u, VPV3->getNumUsers()); 150 EXPECT_EQ(I1, *VPV3->user_begin()); 151 EXPECT_EQ(I1, *std::next(VPV3->user_begin())); 152 153 // Replace operand 0 (VPV3) with VPV4. 154 VPValue *VPV4 = new VPValue(); 155 I1->setOperand(0, VPV4); 156 EXPECT_EQ(1u, VPV3->getNumUsers()); 157 EXPECT_EQ(I1, *VPV3->user_begin()); 158 EXPECT_EQ(I1, *VPV4->user_begin()); 159 160 // Replace operand 1 (VPV3) with VPV4. 161 I1->setOperand(1, VPV4); 162 EXPECT_EQ(0u, VPV3->getNumUsers()); 163 EXPECT_EQ(I1, *VPV4->user_begin()); 164 EXPECT_EQ(I1, *std::next(VPV4->user_begin())); 165 166 delete I1; 167 delete VPV1; 168 delete VPV2; 169 delete VPV3; 170 delete VPV4; 171 } 172 173 TEST(VPInstructionTest, replaceAllUsesWith) { 174 VPValue *VPV1 = new VPValue(); 175 VPValue *VPV2 = new VPValue(); 176 VPInstruction *I1 = new VPInstruction(0, {VPV1, VPV2}); 177 178 // Replace all uses of VPV1 with VPV3. 179 VPValue *VPV3 = new VPValue(); 180 VPV1->replaceAllUsesWith(VPV3); 181 EXPECT_EQ(VPV3, I1->getOperand(0)); 182 EXPECT_EQ(VPV2, I1->getOperand(1)); 183 EXPECT_EQ(0u, VPV1->getNumUsers()); 184 EXPECT_EQ(1u, VPV2->getNumUsers()); 185 EXPECT_EQ(I1, *VPV2->user_begin()); 186 EXPECT_EQ(1u, VPV3->getNumUsers()); 187 EXPECT_EQ(I1, *VPV3->user_begin()); 188 189 // Replace all uses of VPV2 with VPV3. 190 VPV2->replaceAllUsesWith(VPV3); 191 EXPECT_EQ(VPV3, I1->getOperand(0)); 192 EXPECT_EQ(VPV3, I1->getOperand(1)); 193 EXPECT_EQ(0u, VPV1->getNumUsers()); 194 EXPECT_EQ(0u, VPV2->getNumUsers()); 195 EXPECT_EQ(2u, VPV3->getNumUsers()); 196 EXPECT_EQ(I1, *VPV3->user_begin()); 197 198 // Replace all uses of VPV3 with VPV1. 199 VPV3->replaceAllUsesWith(VPV1); 200 EXPECT_EQ(VPV1, I1->getOperand(0)); 201 EXPECT_EQ(VPV1, I1->getOperand(1)); 202 EXPECT_EQ(2u, VPV1->getNumUsers()); 203 EXPECT_EQ(I1, *VPV1->user_begin()); 204 EXPECT_EQ(0u, VPV2->getNumUsers()); 205 EXPECT_EQ(0u, VPV3->getNumUsers()); 206 207 VPInstruction *I2 = new VPInstruction(0, {VPV1, VPV2}); 208 EXPECT_EQ(3u, VPV1->getNumUsers()); 209 VPV1->replaceAllUsesWith(VPV3); 210 EXPECT_EQ(3u, VPV3->getNumUsers()); 211 212 delete I1; 213 delete I2; 214 delete VPV1; 215 delete VPV2; 216 delete VPV3; 217 } 218 219 TEST(VPInstructionTest, releaseOperandsAtDeletion) { 220 VPValue *VPV1 = new VPValue(); 221 VPValue *VPV2 = new VPValue(); 222 VPInstruction *I1 = new VPInstruction(0, {VPV1, VPV2}); 223 224 EXPECT_EQ(1u, VPV1->getNumUsers()); 225 EXPECT_EQ(I1, *VPV1->user_begin()); 226 EXPECT_EQ(1u, VPV2->getNumUsers()); 227 EXPECT_EQ(I1, *VPV2->user_begin()); 228 229 delete I1; 230 231 EXPECT_EQ(0u, VPV1->getNumUsers()); 232 EXPECT_EQ(0u, VPV2->getNumUsers()); 233 234 delete VPV1; 235 delete VPV2; 236 } 237 TEST(VPBasicBlockTest, getPlan) { 238 { 239 VPBasicBlock *VPBB1 = new VPBasicBlock(); 240 VPBasicBlock *VPBB2 = new VPBasicBlock(); 241 VPBasicBlock *VPBB3 = new VPBasicBlock(); 242 VPBasicBlock *VPBB4 = new VPBasicBlock(); 243 244 // VPBB1 245 // / \ 246 // VPBB2 VPBB3 247 // \ / 248 // VPBB4 249 VPBlockUtils::connectBlocks(VPBB1, VPBB2); 250 VPBlockUtils::connectBlocks(VPBB1, VPBB3); 251 VPBlockUtils::connectBlocks(VPBB2, VPBB4); 252 VPBlockUtils::connectBlocks(VPBB3, VPBB4); 253 254 VPlan Plan; 255 Plan.setEntry(VPBB1); 256 257 EXPECT_EQ(&Plan, VPBB1->getPlan()); 258 EXPECT_EQ(&Plan, VPBB2->getPlan()); 259 EXPECT_EQ(&Plan, VPBB3->getPlan()); 260 EXPECT_EQ(&Plan, VPBB4->getPlan()); 261 } 262 263 { 264 // Region block is entry into VPlan. 265 VPBasicBlock *R1BB1 = new VPBasicBlock(); 266 VPBasicBlock *R1BB2 = new VPBasicBlock(); 267 VPRegionBlock *R1 = new VPRegionBlock(R1BB1, R1BB2, "R1"); 268 VPBlockUtils::connectBlocks(R1BB1, R1BB2); 269 270 VPlan Plan; 271 Plan.setEntry(R1); 272 EXPECT_EQ(&Plan, R1->getPlan()); 273 EXPECT_EQ(&Plan, R1BB1->getPlan()); 274 EXPECT_EQ(&Plan, R1BB2->getPlan()); 275 } 276 277 { 278 // VPBasicBlock is the entry into the VPlan, followed by a region. 279 VPBasicBlock *R1BB1 = new VPBasicBlock(); 280 VPBasicBlock *R1BB2 = new VPBasicBlock(); 281 VPRegionBlock *R1 = new VPRegionBlock(R1BB1, R1BB2, "R1"); 282 VPBlockUtils::connectBlocks(R1BB1, R1BB2); 283 284 VPBasicBlock *VPBB1 = new VPBasicBlock(); 285 VPBlockUtils::connectBlocks(VPBB1, R1); 286 287 VPlan Plan; 288 Plan.setEntry(VPBB1); 289 EXPECT_EQ(&Plan, VPBB1->getPlan()); 290 EXPECT_EQ(&Plan, R1->getPlan()); 291 EXPECT_EQ(&Plan, R1BB1->getPlan()); 292 EXPECT_EQ(&Plan, R1BB2->getPlan()); 293 } 294 295 { 296 VPBasicBlock *R1BB1 = new VPBasicBlock(); 297 VPBasicBlock *R1BB2 = new VPBasicBlock(); 298 VPRegionBlock *R1 = new VPRegionBlock(R1BB1, R1BB2, "R1"); 299 VPBlockUtils::connectBlocks(R1BB1, R1BB2); 300 301 VPBasicBlock *R2BB1 = new VPBasicBlock(); 302 VPBasicBlock *R2BB2 = new VPBasicBlock(); 303 VPRegionBlock *R2 = new VPRegionBlock(R2BB1, R2BB2, "R2"); 304 VPBlockUtils::connectBlocks(R2BB1, R2BB2); 305 306 VPBasicBlock *VPBB1 = new VPBasicBlock(); 307 VPBlockUtils::connectBlocks(VPBB1, R1); 308 VPBlockUtils::connectBlocks(VPBB1, R2); 309 310 VPBasicBlock *VPBB2 = new VPBasicBlock(); 311 VPBlockUtils::connectBlocks(R1, VPBB2); 312 VPBlockUtils::connectBlocks(R2, VPBB2); 313 314 VPlan Plan; 315 Plan.setEntry(VPBB1); 316 EXPECT_EQ(&Plan, VPBB1->getPlan()); 317 EXPECT_EQ(&Plan, R1->getPlan()); 318 EXPECT_EQ(&Plan, R1BB1->getPlan()); 319 EXPECT_EQ(&Plan, R1BB2->getPlan()); 320 EXPECT_EQ(&Plan, R2->getPlan()); 321 EXPECT_EQ(&Plan, R2BB1->getPlan()); 322 EXPECT_EQ(&Plan, R2BB2->getPlan()); 323 EXPECT_EQ(&Plan, VPBB2->getPlan()); 324 } 325 } 326 327 TEST(VPBasicBlockTest, print) { 328 VPInstruction *I1 = new VPInstruction(Instruction::Add, {}); 329 VPInstruction *I2 = new VPInstruction(Instruction::Sub, {I1}); 330 VPInstruction *I3 = new VPInstruction(Instruction::Br, {I1, I2}); 331 332 VPBasicBlock *VPBB1 = new VPBasicBlock(); 333 VPBB1->appendRecipe(I1); 334 VPBB1->appendRecipe(I2); 335 VPBB1->appendRecipe(I3); 336 337 VPInstruction *I4 = new VPInstruction(Instruction::Mul, {I2, I1}); 338 VPInstruction *I5 = new VPInstruction(Instruction::Ret, {I4}); 339 VPBasicBlock *VPBB2 = new VPBasicBlock(); 340 VPBB2->appendRecipe(I4); 341 VPBB2->appendRecipe(I5); 342 343 VPBlockUtils::connectBlocks(VPBB1, VPBB2); 344 345 // Check printing an instruction without associated VPlan. 346 { 347 std::string I3Dump; 348 raw_string_ostream OS(I3Dump); 349 I3->print(OS); 350 OS.flush(); 351 EXPECT_EQ("br <badref> <badref>", I3Dump); 352 } 353 354 VPlan Plan; 355 Plan.setEntry(VPBB1); 356 std::string FullDump; 357 raw_string_ostream(FullDump) << Plan; 358 359 const char *ExpectedStr = R"(digraph VPlan { 360 graph [labelloc=t, fontsize=30; label="Vectorization Plan"] 361 node [shape=rect, fontname=Courier, fontsize=30] 362 edge [fontname=Courier, fontsize=30] 363 compound=true 364 N0 [label = 365 ":\n" + 366 "EMIT vp<%0> = add\l" + 367 "EMIT vp<%1> = sub vp<%0>\l" + 368 "EMIT br vp<%0> vp<%1>\l" 369 ] 370 N0 -> N1 [ label=""] 371 N1 [label = 372 ":\n" + 373 "EMIT vp<%2> = mul vp<%1> vp<%0>\l" + 374 "EMIT ret vp<%2>\l" 375 ] 376 } 377 )"; 378 EXPECT_EQ(ExpectedStr, FullDump); 379 380 { 381 std::string I3Dump; 382 raw_string_ostream OS(I3Dump); 383 I3->print(OS); 384 OS.flush(); 385 EXPECT_EQ("br vp<%0> vp<%1>", I3Dump); 386 } 387 388 { 389 std::string I4Dump; 390 raw_string_ostream OS(I4Dump); 391 OS << *I4; 392 OS.flush(); 393 EXPECT_EQ("vp<%2> = mul vp<%1> vp<%0>", I4Dump); 394 } 395 } 396 397 TEST(VPRecipeTest, CastVPInstructionToVPUser) { 398 VPValue Op1; 399 VPValue Op2; 400 VPInstruction Recipe(Instruction::Add, {&Op1, &Op2}); 401 EXPECT_TRUE(isa<VPUser>(&Recipe)); 402 VPRecipeBase *BaseR = &Recipe; 403 EXPECT_TRUE(isa<VPUser>(BaseR)); 404 EXPECT_EQ(&Recipe, BaseR); 405 } 406 407 TEST(VPRecipeTest, CastVPWidenRecipeToVPUser) { 408 LLVMContext C; 409 410 IntegerType *Int32 = IntegerType::get(C, 32); 411 auto *AI = 412 BinaryOperator::CreateAdd(UndefValue::get(Int32), UndefValue::get(Int32)); 413 VPValue Op1; 414 VPValue Op2; 415 SmallVector<VPValue *, 2> Args; 416 Args.push_back(&Op1); 417 Args.push_back(&Op1); 418 VPWidenRecipe WidenR(*AI, make_range(Args.begin(), Args.end())); 419 EXPECT_TRUE(isa<VPUser>(&WidenR)); 420 VPRecipeBase *WidenRBase = &WidenR; 421 EXPECT_TRUE(isa<VPUser>(WidenRBase)); 422 EXPECT_EQ(&WidenR, WidenRBase); 423 delete AI; 424 } 425 426 TEST(VPRecipeTest, CastVPWidenCallRecipeToVPUserAndVPDef) { 427 LLVMContext C; 428 429 IntegerType *Int32 = IntegerType::get(C, 32); 430 FunctionType *FTy = FunctionType::get(Int32, false); 431 auto *Call = CallInst::Create(FTy, UndefValue::get(FTy)); 432 VPValue Op1; 433 VPValue Op2; 434 SmallVector<VPValue *, 2> Args; 435 Args.push_back(&Op1); 436 Args.push_back(&Op2); 437 VPWidenCallRecipe Recipe(*Call, make_range(Args.begin(), Args.end())); 438 EXPECT_TRUE(isa<VPUser>(&Recipe)); 439 VPRecipeBase *BaseR = &Recipe; 440 EXPECT_TRUE(isa<VPUser>(BaseR)); 441 EXPECT_EQ(&Recipe, BaseR); 442 443 VPValue *VPV = &Recipe; 444 EXPECT_TRUE(isa<VPRecipeBase>(VPV->getDef())); 445 EXPECT_EQ(&Recipe, dyn_cast<VPRecipeBase>(VPV->getDef())); 446 447 delete Call; 448 } 449 450 TEST(VPRecipeTest, CastVPWidenSelectRecipeToVPUserAndVPDef) { 451 LLVMContext C; 452 453 IntegerType *Int1 = IntegerType::get(C, 1); 454 IntegerType *Int32 = IntegerType::get(C, 32); 455 auto *SelectI = SelectInst::Create( 456 UndefValue::get(Int1), UndefValue::get(Int32), UndefValue::get(Int32)); 457 VPValue Op1; 458 VPValue Op2; 459 VPValue Op3; 460 SmallVector<VPValue *, 4> Args; 461 Args.push_back(&Op1); 462 Args.push_back(&Op2); 463 Args.push_back(&Op3); 464 VPWidenSelectRecipe WidenSelectR(*SelectI, 465 make_range(Args.begin(), Args.end()), false); 466 EXPECT_TRUE(isa<VPUser>(&WidenSelectR)); 467 VPRecipeBase *BaseR = &WidenSelectR; 468 EXPECT_TRUE(isa<VPUser>(BaseR)); 469 EXPECT_EQ(&WidenSelectR, BaseR); 470 471 VPValue *VPV = &WidenSelectR; 472 EXPECT_TRUE(isa<VPRecipeBase>(VPV->getDef())); 473 EXPECT_EQ(&WidenSelectR, dyn_cast<VPRecipeBase>(VPV->getDef())); 474 475 delete SelectI; 476 } 477 478 TEST(VPRecipeTest, CastVPWidenGEPRecipeToVPUserAndVPDef) { 479 LLVMContext C; 480 481 IntegerType *Int32 = IntegerType::get(C, 32); 482 PointerType *Int32Ptr = PointerType::get(Int32, 0); 483 auto *GEP = GetElementPtrInst::Create(Int32, UndefValue::get(Int32Ptr), 484 UndefValue::get(Int32)); 485 VPValue Op1; 486 VPValue Op2; 487 SmallVector<VPValue *, 4> Args; 488 Args.push_back(&Op1); 489 Args.push_back(&Op2); 490 VPWidenGEPRecipe Recipe(GEP, make_range(Args.begin(), Args.end())); 491 EXPECT_TRUE(isa<VPUser>(&Recipe)); 492 VPRecipeBase *BaseR = &Recipe; 493 EXPECT_TRUE(isa<VPUser>(BaseR)); 494 EXPECT_EQ(&Recipe, BaseR); 495 496 VPValue *VPV = &Recipe; 497 EXPECT_TRUE(isa<VPRecipeBase>(VPV->getDef())); 498 EXPECT_EQ(&Recipe, dyn_cast<VPRecipeBase>(VPV->getDef())); 499 500 delete GEP; 501 } 502 503 TEST(VPRecipeTest, CastVPBlendRecipeToVPUser) { 504 LLVMContext C; 505 506 IntegerType *Int32 = IntegerType::get(C, 32); 507 auto *Phi = PHINode::Create(Int32, 1); 508 VPValue Op1; 509 VPValue Op2; 510 SmallVector<VPValue *, 4> Args; 511 Args.push_back(&Op1); 512 Args.push_back(&Op2); 513 VPBlendRecipe Recipe(Phi, Args); 514 EXPECT_TRUE(isa<VPUser>(&Recipe)); 515 VPRecipeBase *BaseR = &Recipe; 516 EXPECT_TRUE(isa<VPUser>(BaseR)); 517 delete Phi; 518 } 519 520 TEST(VPRecipeTest, CastVPInterleaveRecipeToVPUser) { 521 LLVMContext C; 522 523 VPValue Addr; 524 VPValue Mask; 525 InterleaveGroup<Instruction> IG(4, false, Align(4)); 526 VPInterleaveRecipe Recipe(&IG, &Addr, {}, &Mask); 527 EXPECT_TRUE(isa<VPUser>(&Recipe)); 528 VPRecipeBase *BaseR = &Recipe; 529 EXPECT_TRUE(isa<VPUser>(BaseR)); 530 EXPECT_EQ(&Recipe, BaseR); 531 } 532 533 TEST(VPRecipeTest, CastVPReplicateRecipeToVPUser) { 534 LLVMContext C; 535 536 VPValue Op1; 537 VPValue Op2; 538 SmallVector<VPValue *, 4> Args; 539 Args.push_back(&Op1); 540 Args.push_back(&Op2); 541 542 VPReplicateRecipe Recipe(nullptr, make_range(Args.begin(), Args.end()), true, 543 false); 544 EXPECT_TRUE(isa<VPUser>(&Recipe)); 545 VPRecipeBase *BaseR = &Recipe; 546 EXPECT_TRUE(isa<VPUser>(BaseR)); 547 } 548 549 TEST(VPRecipeTest, CastVPBranchOnMaskRecipeToVPUser) { 550 LLVMContext C; 551 552 VPValue Mask; 553 VPBranchOnMaskRecipe Recipe(&Mask); 554 EXPECT_TRUE(isa<VPUser>(&Recipe)); 555 VPRecipeBase *BaseR = &Recipe; 556 EXPECT_TRUE(isa<VPUser>(BaseR)); 557 EXPECT_EQ(&Recipe, BaseR); 558 } 559 560 TEST(VPRecipeTest, CastVPWidenMemoryInstructionRecipeToVPUserAndVPDef) { 561 LLVMContext C; 562 563 IntegerType *Int32 = IntegerType::get(C, 32); 564 PointerType *Int32Ptr = PointerType::get(Int32, 0); 565 auto *Load = 566 new LoadInst(Int32, UndefValue::get(Int32Ptr), "", false, Align(1)); 567 VPValue Addr; 568 VPValue Mask; 569 VPWidenMemoryInstructionRecipe Recipe(*Load, &Addr, &Mask); 570 EXPECT_TRUE(isa<VPUser>(&Recipe)); 571 VPRecipeBase *BaseR = &Recipe; 572 EXPECT_TRUE(isa<VPUser>(BaseR)); 573 EXPECT_EQ(&Recipe, BaseR); 574 575 VPValue *VPV = Recipe.getVPValue(); 576 EXPECT_TRUE(isa<VPRecipeBase>(VPV->getDef())); 577 EXPECT_EQ(&Recipe, dyn_cast<VPRecipeBase>(VPV->getDef())); 578 579 delete Load; 580 } 581 582 TEST(VPRecipeTest, CastVPReductionRecipeToVPUser) { 583 LLVMContext C; 584 585 VPValue ChainOp; 586 VPValue VecOp; 587 VPValue CondOp; 588 VPReductionRecipe Recipe(nullptr, nullptr, &ChainOp, &CondOp, &VecOp, false, 589 nullptr); 590 EXPECT_TRUE(isa<VPUser>(&Recipe)); 591 VPRecipeBase *BaseR = &Recipe; 592 EXPECT_TRUE(isa<VPUser>(BaseR)); 593 } 594 595 struct VPDoubleValueDef : public VPRecipeBase, public VPUser { 596 VPDoubleValueDef(ArrayRef<VPValue *> Operands) 597 : VPRecipeBase(99), VPUser(Operands) { 598 new VPValue(nullptr, this); 599 new VPValue(nullptr, this); 600 } 601 602 void execute(struct VPTransformState &State) override{}; 603 void print(raw_ostream &O, const Twine &Indent, 604 VPSlotTracker &SlotTracker) const override {} 605 }; 606 607 TEST(VPDoubleValueDefTest, traverseUseLists) { 608 // Check that the def-use chains of a multi-def can be traversed in both 609 // directions. 610 611 // Create a new VPDef which defines 2 values and has 2 operands. 612 VPInstruction Op0(20, {}); 613 VPInstruction Op1(30, {}); 614 VPDoubleValueDef DoubleValueDef({&Op0, &Op1}); 615 616 // Create a new users of the defined values. 617 VPInstruction I1( 618 1, {DoubleValueDef.getVPValue(0), DoubleValueDef.getVPValue(1)}); 619 VPInstruction I2(2, {DoubleValueDef.getVPValue(0)}); 620 VPInstruction I3(3, {DoubleValueDef.getVPValue(1)}); 621 622 // Check operands of the VPDef (traversing upwards). 623 SmallVector<VPValue *, 4> DoubleOperands(DoubleValueDef.op_begin(), 624 DoubleValueDef.op_end()); 625 EXPECT_EQ(2u, DoubleOperands.size()); 626 EXPECT_EQ(&Op0, DoubleOperands[0]); 627 EXPECT_EQ(&Op1, DoubleOperands[1]); 628 629 // Check users of the defined values (traversing downwards). 630 SmallVector<VPUser *, 4> DoubleValueDefV0Users( 631 DoubleValueDef.getVPValue(0)->user_begin(), 632 DoubleValueDef.getVPValue(0)->user_end()); 633 EXPECT_EQ(2u, DoubleValueDefV0Users.size()); 634 EXPECT_EQ(&I1, DoubleValueDefV0Users[0]); 635 EXPECT_EQ(&I2, DoubleValueDefV0Users[1]); 636 637 SmallVector<VPUser *, 4> DoubleValueDefV1Users( 638 DoubleValueDef.getVPValue(1)->user_begin(), 639 DoubleValueDef.getVPValue(1)->user_end()); 640 EXPECT_EQ(2u, DoubleValueDefV1Users.size()); 641 EXPECT_EQ(&I1, DoubleValueDefV1Users[0]); 642 EXPECT_EQ(&I3, DoubleValueDefV1Users[1]); 643 644 // Now check that we can get the right VPDef for each defined value. 645 EXPECT_EQ(&DoubleValueDef, I1.getOperand(0)->getDef()); 646 EXPECT_EQ(&DoubleValueDef, I1.getOperand(1)->getDef()); 647 EXPECT_EQ(&DoubleValueDef, I2.getOperand(0)->getDef()); 648 EXPECT_EQ(&DoubleValueDef, I3.getOperand(0)->getDef()); 649 } 650 651 } // namespace 652 } // namespace llvm 653