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 VPSlotTracker SlotTracker; 350 I3->print(OS, "", SlotTracker); 351 OS.flush(); 352 EXPECT_EQ("EMIT br <badref> <badref>", I3Dump); 353 } 354 355 VPlan Plan; 356 Plan.setEntry(VPBB1); 357 std::string FullDump; 358 raw_string_ostream(FullDump) << Plan; 359 360 const char *ExpectedStr = R"(digraph VPlan { 361 graph [labelloc=t, fontsize=30; label="Vectorization Plan"] 362 node [shape=rect, fontname=Courier, fontsize=30] 363 edge [fontname=Courier, fontsize=30] 364 compound=true 365 N0 [label = 366 ":\n" + 367 "EMIT vp<%0> = add\l" + 368 "EMIT vp<%1> = sub vp<%0>\l" + 369 "EMIT br vp<%0> vp<%1>\l" 370 ] 371 N0 -> N1 [ label=""] 372 N1 [label = 373 ":\n" + 374 "EMIT vp<%3> = mul vp<%1> vp<%0>\l" + 375 "EMIT ret vp<%3>\l" 376 ] 377 } 378 )"; 379 EXPECT_EQ(ExpectedStr, FullDump); 380 381 { 382 std::string I3Dump; 383 raw_string_ostream OS(I3Dump); 384 VPSlotTracker SlotTracker(&Plan); 385 I3->print(OS, "", SlotTracker); 386 OS.flush(); 387 EXPECT_EQ("EMIT br vp<%0> vp<%1>", I3Dump); 388 } 389 390 { 391 std::string I4Dump; 392 raw_string_ostream OS(I4Dump); 393 OS << *I4; 394 OS.flush(); 395 EXPECT_EQ("EMIT vp<%3> = mul vp<%1> vp<%0>", I4Dump); 396 } 397 } 398 399 TEST(VPRecipeTest, CastVPInstructionToVPUser) { 400 VPValue Op1; 401 VPValue Op2; 402 VPInstruction Recipe(Instruction::Add, {&Op1, &Op2}); 403 EXPECT_TRUE(isa<VPUser>(&Recipe)); 404 VPRecipeBase *BaseR = &Recipe; 405 EXPECT_TRUE(isa<VPUser>(BaseR)); 406 EXPECT_EQ(&Recipe, BaseR); 407 } 408 409 TEST(VPRecipeTest, CastVPWidenRecipeToVPUser) { 410 LLVMContext C; 411 412 IntegerType *Int32 = IntegerType::get(C, 32); 413 auto *AI = 414 BinaryOperator::CreateAdd(UndefValue::get(Int32), UndefValue::get(Int32)); 415 VPValue Op1; 416 VPValue Op2; 417 SmallVector<VPValue *, 2> Args; 418 Args.push_back(&Op1); 419 Args.push_back(&Op1); 420 VPWidenRecipe WidenR(*AI, make_range(Args.begin(), Args.end())); 421 EXPECT_TRUE(isa<VPUser>(&WidenR)); 422 VPRecipeBase *WidenRBase = &WidenR; 423 EXPECT_TRUE(isa<VPUser>(WidenRBase)); 424 EXPECT_EQ(&WidenR, WidenRBase); 425 delete AI; 426 } 427 428 TEST(VPRecipeTest, CastVPWidenCallRecipeToVPUserAndVPDef) { 429 LLVMContext C; 430 431 IntegerType *Int32 = IntegerType::get(C, 32); 432 FunctionType *FTy = FunctionType::get(Int32, false); 433 auto *Call = CallInst::Create(FTy, UndefValue::get(FTy)); 434 VPValue Op1; 435 VPValue Op2; 436 SmallVector<VPValue *, 2> Args; 437 Args.push_back(&Op1); 438 Args.push_back(&Op2); 439 VPWidenCallRecipe Recipe(*Call, make_range(Args.begin(), Args.end())); 440 EXPECT_TRUE(isa<VPUser>(&Recipe)); 441 VPRecipeBase *BaseR = &Recipe; 442 EXPECT_TRUE(isa<VPUser>(BaseR)); 443 EXPECT_EQ(&Recipe, BaseR); 444 445 VPValue *VPV = &Recipe; 446 EXPECT_TRUE(isa<VPRecipeBase>(VPV->getDef())); 447 EXPECT_EQ(&Recipe, dyn_cast<VPRecipeBase>(VPV->getDef())); 448 449 delete Call; 450 } 451 452 TEST(VPRecipeTest, CastVPWidenSelectRecipeToVPUserAndVPDef) { 453 LLVMContext C; 454 455 IntegerType *Int1 = IntegerType::get(C, 1); 456 IntegerType *Int32 = IntegerType::get(C, 32); 457 auto *SelectI = SelectInst::Create( 458 UndefValue::get(Int1), UndefValue::get(Int32), UndefValue::get(Int32)); 459 VPValue Op1; 460 VPValue Op2; 461 VPValue Op3; 462 SmallVector<VPValue *, 4> Args; 463 Args.push_back(&Op1); 464 Args.push_back(&Op2); 465 Args.push_back(&Op3); 466 VPWidenSelectRecipe WidenSelectR(*SelectI, 467 make_range(Args.begin(), Args.end()), false); 468 EXPECT_TRUE(isa<VPUser>(&WidenSelectR)); 469 VPRecipeBase *BaseR = &WidenSelectR; 470 EXPECT_TRUE(isa<VPUser>(BaseR)); 471 EXPECT_EQ(&WidenSelectR, BaseR); 472 473 VPValue *VPV = &WidenSelectR; 474 EXPECT_TRUE(isa<VPRecipeBase>(VPV->getDef())); 475 EXPECT_EQ(&WidenSelectR, dyn_cast<VPRecipeBase>(VPV->getDef())); 476 477 delete SelectI; 478 } 479 480 TEST(VPRecipeTest, CastVPWidenGEPRecipeToVPUserAndVPDef) { 481 LLVMContext C; 482 483 IntegerType *Int32 = IntegerType::get(C, 32); 484 PointerType *Int32Ptr = PointerType::get(Int32, 0); 485 auto *GEP = GetElementPtrInst::Create(Int32, UndefValue::get(Int32Ptr), 486 UndefValue::get(Int32)); 487 VPValue Op1; 488 VPValue Op2; 489 SmallVector<VPValue *, 4> Args; 490 Args.push_back(&Op1); 491 Args.push_back(&Op2); 492 VPWidenGEPRecipe Recipe(GEP, make_range(Args.begin(), Args.end())); 493 EXPECT_TRUE(isa<VPUser>(&Recipe)); 494 VPRecipeBase *BaseR = &Recipe; 495 EXPECT_TRUE(isa<VPUser>(BaseR)); 496 EXPECT_EQ(&Recipe, BaseR); 497 498 VPValue *VPV = &Recipe; 499 EXPECT_TRUE(isa<VPRecipeBase>(VPV->getDef())); 500 EXPECT_EQ(&Recipe, dyn_cast<VPRecipeBase>(VPV->getDef())); 501 502 delete GEP; 503 } 504 505 TEST(VPRecipeTest, CastVPBlendRecipeToVPUser) { 506 LLVMContext C; 507 508 IntegerType *Int32 = IntegerType::get(C, 32); 509 auto *Phi = PHINode::Create(Int32, 1); 510 VPValue Op1; 511 VPValue Op2; 512 SmallVector<VPValue *, 4> Args; 513 Args.push_back(&Op1); 514 Args.push_back(&Op2); 515 VPBlendRecipe Recipe(Phi, Args); 516 EXPECT_TRUE(isa<VPUser>(&Recipe)); 517 VPRecipeBase *BaseR = &Recipe; 518 EXPECT_TRUE(isa<VPUser>(BaseR)); 519 delete Phi; 520 } 521 522 TEST(VPRecipeTest, CastVPInterleaveRecipeToVPUser) { 523 LLVMContext C; 524 525 VPValue Addr; 526 VPValue Mask; 527 InterleaveGroup<Instruction> IG(4, false, Align(4)); 528 VPInterleaveRecipe Recipe(&IG, &Addr, {}, &Mask); 529 EXPECT_TRUE(isa<VPUser>(&Recipe)); 530 VPRecipeBase *BaseR = &Recipe; 531 EXPECT_TRUE(isa<VPUser>(BaseR)); 532 EXPECT_EQ(&Recipe, BaseR); 533 } 534 535 TEST(VPRecipeTest, CastVPReplicateRecipeToVPUser) { 536 LLVMContext C; 537 538 VPValue Op1; 539 VPValue Op2; 540 SmallVector<VPValue *, 4> Args; 541 Args.push_back(&Op1); 542 Args.push_back(&Op2); 543 544 VPReplicateRecipe Recipe(nullptr, make_range(Args.begin(), Args.end()), true, 545 false); 546 EXPECT_TRUE(isa<VPUser>(&Recipe)); 547 VPRecipeBase *BaseR = &Recipe; 548 EXPECT_TRUE(isa<VPUser>(BaseR)); 549 } 550 551 TEST(VPRecipeTest, CastVPBranchOnMaskRecipeToVPUser) { 552 LLVMContext C; 553 554 VPValue Mask; 555 VPBranchOnMaskRecipe Recipe(&Mask); 556 EXPECT_TRUE(isa<VPUser>(&Recipe)); 557 VPRecipeBase *BaseR = &Recipe; 558 EXPECT_TRUE(isa<VPUser>(BaseR)); 559 EXPECT_EQ(&Recipe, BaseR); 560 } 561 562 TEST(VPRecipeTest, CastVPWidenMemoryInstructionRecipeToVPUserAndVPDef) { 563 LLVMContext C; 564 565 IntegerType *Int32 = IntegerType::get(C, 32); 566 PointerType *Int32Ptr = PointerType::get(Int32, 0); 567 auto *Load = 568 new LoadInst(Int32, UndefValue::get(Int32Ptr), "", false, Align(1)); 569 VPValue Addr; 570 VPValue Mask; 571 VPWidenMemoryInstructionRecipe Recipe(*Load, &Addr, &Mask); 572 EXPECT_TRUE(isa<VPUser>(&Recipe)); 573 VPRecipeBase *BaseR = &Recipe; 574 EXPECT_TRUE(isa<VPUser>(BaseR)); 575 EXPECT_EQ(&Recipe, BaseR); 576 577 VPValue *VPV = Recipe.getVPValue(); 578 EXPECT_TRUE(isa<VPRecipeBase>(VPV->getDef())); 579 EXPECT_EQ(&Recipe, dyn_cast<VPRecipeBase>(VPV->getDef())); 580 581 delete Load; 582 } 583 584 TEST(VPRecipeTest, dump) { 585 VPlan Plan; 586 VPBasicBlock *VPBB1 = new VPBasicBlock(); 587 Plan.setEntry(VPBB1); 588 589 LLVMContext C; 590 591 IntegerType *Int32 = IntegerType::get(C, 32); 592 auto *AI = 593 BinaryOperator::CreateAdd(UndefValue::get(Int32), UndefValue::get(Int32)); 594 AI->setName("a"); 595 SmallVector<VPValue *, 2> Args; 596 VPValue *ExtVPV1 = new VPValue(); 597 VPValue *ExtVPV2 = new VPValue(); 598 Plan.addExternalDef(ExtVPV1); 599 Plan.addExternalDef(ExtVPV2); 600 Args.push_back(ExtVPV1); 601 Args.push_back(ExtVPV2); 602 VPWidenRecipe *WidenR = 603 new VPWidenRecipe(*AI, make_range(Args.begin(), Args.end())); 604 VPBB1->appendRecipe(WidenR); 605 606 { 607 // Use EXPECT_EXIT to capture stderr and compare against expected output. 608 // 609 // Test VPValue::dump(). 610 VPValue *VPV = WidenR; 611 EXPECT_EXIT( 612 { 613 VPV->dump(); 614 exit(0); 615 }, 616 testing::ExitedWithCode(0), "WIDEN ir<%a> = add vp<%0>, vp<%1>"); 617 618 // Test VPRecipeBase::dump(). 619 VPRecipeBase *R = WidenR; 620 EXPECT_EXIT( 621 { 622 R->dump(); 623 exit(0); 624 }, 625 testing::ExitedWithCode(0), "WIDEN ir<%a> = add vp<%0>, vp<%1>"); 626 627 // Test VPDef::dump(). 628 VPDef *D = WidenR; 629 EXPECT_EXIT( 630 { 631 D->dump(); 632 exit(0); 633 }, 634 testing::ExitedWithCode(0), "WIDEN ir<%a> = add vp<%0>, vp<%1>"); 635 } 636 637 delete AI; 638 } 639 640 TEST(VPRecipeTest, CastVPReductionRecipeToVPUser) { 641 LLVMContext C; 642 643 VPValue ChainOp; 644 VPValue VecOp; 645 VPValue CondOp; 646 VPReductionRecipe Recipe(nullptr, nullptr, &ChainOp, &CondOp, &VecOp, 647 nullptr); 648 EXPECT_TRUE(isa<VPUser>(&Recipe)); 649 VPRecipeBase *BaseR = &Recipe; 650 EXPECT_TRUE(isa<VPUser>(BaseR)); 651 } 652 653 struct VPDoubleValueDef : public VPRecipeBase { 654 VPDoubleValueDef(ArrayRef<VPValue *> Operands) : VPRecipeBase(99, Operands) { 655 new VPValue(nullptr, this); 656 new VPValue(nullptr, this); 657 } 658 659 void execute(struct VPTransformState &State) override{}; 660 void print(raw_ostream &O, const Twine &Indent, 661 VPSlotTracker &SlotTracker) const override {} 662 }; 663 664 TEST(VPDoubleValueDefTest, traverseUseLists) { 665 // Check that the def-use chains of a multi-def can be traversed in both 666 // directions. 667 668 // Create a new VPDef which defines 2 values and has 2 operands. 669 VPInstruction Op0(20, {}); 670 VPInstruction Op1(30, {}); 671 VPDoubleValueDef DoubleValueDef({&Op0, &Op1}); 672 673 // Create a new users of the defined values. 674 VPInstruction I1( 675 1, {DoubleValueDef.getVPValue(0), DoubleValueDef.getVPValue(1)}); 676 VPInstruction I2(2, {DoubleValueDef.getVPValue(0)}); 677 VPInstruction I3(3, {DoubleValueDef.getVPValue(1)}); 678 679 // Check operands of the VPDef (traversing upwards). 680 SmallVector<VPValue *, 4> DoubleOperands(DoubleValueDef.op_begin(), 681 DoubleValueDef.op_end()); 682 EXPECT_EQ(2u, DoubleOperands.size()); 683 EXPECT_EQ(&Op0, DoubleOperands[0]); 684 EXPECT_EQ(&Op1, DoubleOperands[1]); 685 686 // Check users of the defined values (traversing downwards). 687 SmallVector<VPUser *, 4> DoubleValueDefV0Users( 688 DoubleValueDef.getVPValue(0)->user_begin(), 689 DoubleValueDef.getVPValue(0)->user_end()); 690 EXPECT_EQ(2u, DoubleValueDefV0Users.size()); 691 EXPECT_EQ(&I1, DoubleValueDefV0Users[0]); 692 EXPECT_EQ(&I2, DoubleValueDefV0Users[1]); 693 694 SmallVector<VPUser *, 4> DoubleValueDefV1Users( 695 DoubleValueDef.getVPValue(1)->user_begin(), 696 DoubleValueDef.getVPValue(1)->user_end()); 697 EXPECT_EQ(2u, DoubleValueDefV1Users.size()); 698 EXPECT_EQ(&I1, DoubleValueDefV1Users[0]); 699 EXPECT_EQ(&I3, DoubleValueDefV1Users[1]); 700 701 // Now check that we can get the right VPDef for each defined value. 702 EXPECT_EQ(&DoubleValueDef, I1.getOperand(0)->getDef()); 703 EXPECT_EQ(&DoubleValueDef, I1.getOperand(1)->getDef()); 704 EXPECT_EQ(&DoubleValueDef, I2.getOperand(0)->getDef()); 705 EXPECT_EQ(&DoubleValueDef, I3.getOperand(0)->getDef()); 706 } 707 708 } // namespace 709 } // namespace llvm 710