1 //===---- llvm/unittest/IR/PatternMatch.cpp - PatternMatch unit 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/IR/PatternMatch.h" 10 #include "llvm/ADT/STLExtras.h" 11 #include "llvm/Analysis/ValueTracking.h" 12 #include "llvm/IR/BasicBlock.h" 13 #include "llvm/IR/Constants.h" 14 #include "llvm/IR/DataLayout.h" 15 #include "llvm/IR/DerivedTypes.h" 16 #include "llvm/IR/Function.h" 17 #include "llvm/IR/IRBuilder.h" 18 #include "llvm/IR/Instructions.h" 19 #include "llvm/IR/LLVMContext.h" 20 #include "llvm/IR/MDBuilder.h" 21 #include "llvm/IR/Module.h" 22 #include "llvm/IR/NoFolder.h" 23 #include "llvm/IR/Operator.h" 24 #include "llvm/IR/Type.h" 25 #include "gtest/gtest.h" 26 27 using namespace llvm; 28 using namespace llvm::PatternMatch; 29 30 namespace { 31 32 struct PatternMatchTest : ::testing::Test { 33 LLVMContext Ctx; 34 std::unique_ptr<Module> M; 35 Function *F; 36 BasicBlock *BB; 37 IRBuilder<NoFolder> IRB; 38 39 PatternMatchTest() 40 : M(new Module("PatternMatchTestModule", Ctx)), 41 F(Function::Create( 42 FunctionType::get(Type::getVoidTy(Ctx), /* IsVarArg */ false), 43 Function::ExternalLinkage, "f", M.get())), 44 BB(BasicBlock::Create(Ctx, "entry", F)), IRB(BB) {} 45 }; 46 47 TEST_F(PatternMatchTest, OneUse) { 48 // Build up a little tree of values: 49 // 50 // One = (1 + 2) + 42 51 // Two = One + 42 52 // Leaf = (Two + 8) + (Two + 13) 53 Value *One = IRB.CreateAdd(IRB.CreateAdd(IRB.getInt32(1), IRB.getInt32(2)), 54 IRB.getInt32(42)); 55 Value *Two = IRB.CreateAdd(One, IRB.getInt32(42)); 56 Value *Leaf = IRB.CreateAdd(IRB.CreateAdd(Two, IRB.getInt32(8)), 57 IRB.CreateAdd(Two, IRB.getInt32(13))); 58 Value *V; 59 60 EXPECT_TRUE(m_OneUse(m_Value(V)).match(One)); 61 EXPECT_EQ(One, V); 62 63 EXPECT_FALSE(m_OneUse(m_Value()).match(Two)); 64 EXPECT_FALSE(m_OneUse(m_Value()).match(Leaf)); 65 } 66 67 TEST_F(PatternMatchTest, SpecificIntEQ) { 68 Type *IntTy = IRB.getInt32Ty(); 69 unsigned BitWidth = IntTy->getScalarSizeInBits(); 70 71 Value *Zero = ConstantInt::get(IntTy, 0); 72 Value *One = ConstantInt::get(IntTy, 1); 73 Value *NegOne = ConstantInt::get(IntTy, -1); 74 75 EXPECT_TRUE( 76 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, 0)) 77 .match(Zero)); 78 EXPECT_FALSE( 79 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, 0)) 80 .match(One)); 81 EXPECT_FALSE( 82 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, 0)) 83 .match(NegOne)); 84 85 EXPECT_FALSE( 86 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, 1)) 87 .match(Zero)); 88 EXPECT_TRUE( 89 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, 1)) 90 .match(One)); 91 EXPECT_FALSE( 92 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, 1)) 93 .match(NegOne)); 94 95 EXPECT_FALSE( 96 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, -1)) 97 .match(Zero)); 98 EXPECT_FALSE( 99 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, -1)) 100 .match(One)); 101 EXPECT_TRUE( 102 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, -1)) 103 .match(NegOne)); 104 } 105 106 TEST_F(PatternMatchTest, SpecificIntNE) { 107 Type *IntTy = IRB.getInt32Ty(); 108 unsigned BitWidth = IntTy->getScalarSizeInBits(); 109 110 Value *Zero = ConstantInt::get(IntTy, 0); 111 Value *One = ConstantInt::get(IntTy, 1); 112 Value *NegOne = ConstantInt::get(IntTy, -1); 113 114 EXPECT_FALSE( 115 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, 0)) 116 .match(Zero)); 117 EXPECT_TRUE( 118 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, 0)) 119 .match(One)); 120 EXPECT_TRUE( 121 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, 0)) 122 .match(NegOne)); 123 124 EXPECT_TRUE( 125 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, 1)) 126 .match(Zero)); 127 EXPECT_FALSE( 128 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, 1)) 129 .match(One)); 130 EXPECT_TRUE( 131 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, 1)) 132 .match(NegOne)); 133 134 EXPECT_TRUE( 135 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, -1)) 136 .match(Zero)); 137 EXPECT_TRUE( 138 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, -1)) 139 .match(One)); 140 EXPECT_FALSE( 141 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, -1)) 142 .match(NegOne)); 143 } 144 145 TEST_F(PatternMatchTest, SpecificIntUGT) { 146 Type *IntTy = IRB.getInt32Ty(); 147 unsigned BitWidth = IntTy->getScalarSizeInBits(); 148 149 Value *Zero = ConstantInt::get(IntTy, 0); 150 Value *One = ConstantInt::get(IntTy, 1); 151 Value *NegOne = ConstantInt::get(IntTy, -1); 152 153 EXPECT_FALSE( 154 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, 0)) 155 .match(Zero)); 156 EXPECT_TRUE( 157 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, 0)) 158 .match(One)); 159 EXPECT_TRUE( 160 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, 0)) 161 .match(NegOne)); 162 163 EXPECT_FALSE( 164 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, 1)) 165 .match(Zero)); 166 EXPECT_FALSE( 167 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, 1)) 168 .match(One)); 169 EXPECT_TRUE( 170 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, 1)) 171 .match(NegOne)); 172 173 EXPECT_FALSE( 174 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, -1)) 175 .match(Zero)); 176 EXPECT_FALSE( 177 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, -1)) 178 .match(One)); 179 EXPECT_FALSE( 180 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, -1)) 181 .match(NegOne)); 182 } 183 184 TEST_F(PatternMatchTest, SpecificIntUGE) { 185 Type *IntTy = IRB.getInt32Ty(); 186 unsigned BitWidth = IntTy->getScalarSizeInBits(); 187 188 Value *Zero = ConstantInt::get(IntTy, 0); 189 Value *One = ConstantInt::get(IntTy, 1); 190 Value *NegOne = ConstantInt::get(IntTy, -1); 191 192 EXPECT_TRUE( 193 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, 0)) 194 .match(Zero)); 195 EXPECT_TRUE( 196 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, 0)) 197 .match(One)); 198 EXPECT_TRUE( 199 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, 0)) 200 .match(NegOne)); 201 202 EXPECT_FALSE( 203 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, 1)) 204 .match(Zero)); 205 EXPECT_TRUE( 206 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, 1)) 207 .match(One)); 208 EXPECT_TRUE( 209 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, 1)) 210 .match(NegOne)); 211 212 EXPECT_FALSE( 213 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, -1)) 214 .match(Zero)); 215 EXPECT_FALSE( 216 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, -1)) 217 .match(One)); 218 EXPECT_TRUE( 219 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, -1)) 220 .match(NegOne)); 221 } 222 223 TEST_F(PatternMatchTest, SpecificIntULT) { 224 Type *IntTy = IRB.getInt32Ty(); 225 unsigned BitWidth = IntTy->getScalarSizeInBits(); 226 227 Value *Zero = ConstantInt::get(IntTy, 0); 228 Value *One = ConstantInt::get(IntTy, 1); 229 Value *NegOne = ConstantInt::get(IntTy, -1); 230 231 EXPECT_FALSE( 232 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, 0)) 233 .match(Zero)); 234 EXPECT_FALSE( 235 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, 0)) 236 .match(One)); 237 EXPECT_FALSE( 238 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, 0)) 239 .match(NegOne)); 240 241 EXPECT_TRUE( 242 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, 1)) 243 .match(Zero)); 244 EXPECT_FALSE( 245 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, 1)) 246 .match(One)); 247 EXPECT_FALSE( 248 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, 1)) 249 .match(NegOne)); 250 251 EXPECT_TRUE( 252 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, -1)) 253 .match(Zero)); 254 EXPECT_TRUE( 255 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, -1)) 256 .match(One)); 257 EXPECT_FALSE( 258 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, -1)) 259 .match(NegOne)); 260 } 261 262 TEST_F(PatternMatchTest, SpecificIntULE) { 263 Type *IntTy = IRB.getInt32Ty(); 264 unsigned BitWidth = IntTy->getScalarSizeInBits(); 265 266 Value *Zero = ConstantInt::get(IntTy, 0); 267 Value *One = ConstantInt::get(IntTy, 1); 268 Value *NegOne = ConstantInt::get(IntTy, -1); 269 270 EXPECT_TRUE( 271 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, 0)) 272 .match(Zero)); 273 EXPECT_FALSE( 274 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, 0)) 275 .match(One)); 276 EXPECT_FALSE( 277 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, 0)) 278 .match(NegOne)); 279 280 EXPECT_TRUE( 281 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, 1)) 282 .match(Zero)); 283 EXPECT_TRUE( 284 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, 1)) 285 .match(One)); 286 EXPECT_FALSE( 287 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, 1)) 288 .match(NegOne)); 289 290 EXPECT_TRUE( 291 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, -1)) 292 .match(Zero)); 293 EXPECT_TRUE( 294 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, -1)) 295 .match(One)); 296 EXPECT_TRUE( 297 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, -1)) 298 .match(NegOne)); 299 } 300 301 TEST_F(PatternMatchTest, SpecificIntSGT) { 302 Type *IntTy = IRB.getInt32Ty(); 303 unsigned BitWidth = IntTy->getScalarSizeInBits(); 304 305 Value *Zero = ConstantInt::get(IntTy, 0); 306 Value *One = ConstantInt::get(IntTy, 1); 307 Value *NegOne = ConstantInt::get(IntTy, -1); 308 309 EXPECT_FALSE( 310 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, 0)) 311 .match(Zero)); 312 EXPECT_TRUE( 313 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, 0)) 314 .match(One)); 315 EXPECT_FALSE( 316 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, 0)) 317 .match(NegOne)); 318 319 EXPECT_FALSE( 320 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, 1)) 321 .match(Zero)); 322 EXPECT_FALSE( 323 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, 1)) 324 .match(One)); 325 EXPECT_FALSE( 326 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, 1)) 327 .match(NegOne)); 328 329 EXPECT_TRUE( 330 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, -1)) 331 .match(Zero)); 332 EXPECT_TRUE( 333 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, -1)) 334 .match(One)); 335 EXPECT_FALSE( 336 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, -1)) 337 .match(NegOne)); 338 } 339 340 TEST_F(PatternMatchTest, SpecificIntSGE) { 341 Type *IntTy = IRB.getInt32Ty(); 342 unsigned BitWidth = IntTy->getScalarSizeInBits(); 343 344 Value *Zero = ConstantInt::get(IntTy, 0); 345 Value *One = ConstantInt::get(IntTy, 1); 346 Value *NegOne = ConstantInt::get(IntTy, -1); 347 348 EXPECT_TRUE( 349 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, 0)) 350 .match(Zero)); 351 EXPECT_TRUE( 352 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, 0)) 353 .match(One)); 354 EXPECT_FALSE( 355 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, 0)) 356 .match(NegOne)); 357 358 EXPECT_FALSE( 359 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, 1)) 360 .match(Zero)); 361 EXPECT_TRUE( 362 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, 1)) 363 .match(One)); 364 EXPECT_FALSE( 365 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, 1)) 366 .match(NegOne)); 367 368 EXPECT_TRUE( 369 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, -1)) 370 .match(Zero)); 371 EXPECT_TRUE( 372 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, -1)) 373 .match(One)); 374 EXPECT_TRUE( 375 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, -1)) 376 .match(NegOne)); 377 } 378 379 TEST_F(PatternMatchTest, SpecificIntSLT) { 380 Type *IntTy = IRB.getInt32Ty(); 381 unsigned BitWidth = IntTy->getScalarSizeInBits(); 382 383 Value *Zero = ConstantInt::get(IntTy, 0); 384 Value *One = ConstantInt::get(IntTy, 1); 385 Value *NegOne = ConstantInt::get(IntTy, -1); 386 387 EXPECT_FALSE( 388 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, 0)) 389 .match(Zero)); 390 EXPECT_FALSE( 391 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, 0)) 392 .match(One)); 393 EXPECT_TRUE( 394 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, 0)) 395 .match(NegOne)); 396 397 EXPECT_TRUE( 398 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, 1)) 399 .match(Zero)); 400 EXPECT_FALSE( 401 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, 1)) 402 .match(One)); 403 EXPECT_TRUE( 404 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, 1)) 405 .match(NegOne)); 406 407 EXPECT_FALSE( 408 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, -1)) 409 .match(Zero)); 410 EXPECT_FALSE( 411 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, -1)) 412 .match(One)); 413 EXPECT_FALSE( 414 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, -1)) 415 .match(NegOne)); 416 } 417 418 TEST_F(PatternMatchTest, SpecificIntSLE) { 419 Type *IntTy = IRB.getInt32Ty(); 420 unsigned BitWidth = IntTy->getScalarSizeInBits(); 421 422 Value *Zero = ConstantInt::get(IntTy, 0); 423 Value *One = ConstantInt::get(IntTy, 1); 424 Value *NegOne = ConstantInt::get(IntTy, -1); 425 426 EXPECT_TRUE( 427 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, 0)) 428 .match(Zero)); 429 EXPECT_FALSE( 430 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, 0)) 431 .match(One)); 432 EXPECT_TRUE( 433 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, 0)) 434 .match(NegOne)); 435 436 EXPECT_TRUE( 437 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, 1)) 438 .match(Zero)); 439 EXPECT_TRUE( 440 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, 1)) 441 .match(One)); 442 EXPECT_TRUE( 443 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, 1)) 444 .match(NegOne)); 445 446 EXPECT_FALSE( 447 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, -1)) 448 .match(Zero)); 449 EXPECT_FALSE( 450 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, -1)) 451 .match(One)); 452 EXPECT_TRUE( 453 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, -1)) 454 .match(NegOne)); 455 } 456 457 TEST_F(PatternMatchTest, CommutativeDeferredValue) { 458 Value *X = IRB.getInt32(1); 459 Value *Y = IRB.getInt32(2); 460 461 { 462 Value *tX = X; 463 EXPECT_TRUE(match(X, m_Deferred(tX))); 464 EXPECT_FALSE(match(Y, m_Deferred(tX))); 465 } 466 { 467 const Value *tX = X; 468 EXPECT_TRUE(match(X, m_Deferred(tX))); 469 EXPECT_FALSE(match(Y, m_Deferred(tX))); 470 } 471 { 472 Value *const tX = X; 473 EXPECT_TRUE(match(X, m_Deferred(tX))); 474 EXPECT_FALSE(match(Y, m_Deferred(tX))); 475 } 476 { 477 const Value *const tX = X; 478 EXPECT_TRUE(match(X, m_Deferred(tX))); 479 EXPECT_FALSE(match(Y, m_Deferred(tX))); 480 } 481 482 { 483 Value *tX = nullptr; 484 EXPECT_TRUE(match(IRB.CreateAnd(X, X), m_And(m_Value(tX), m_Deferred(tX)))); 485 EXPECT_EQ(tX, X); 486 } 487 { 488 Value *tX = nullptr; 489 EXPECT_FALSE( 490 match(IRB.CreateAnd(X, Y), m_c_And(m_Value(tX), m_Deferred(tX)))); 491 } 492 493 auto checkMatch = [X, Y](Value *Pattern) { 494 Value *tX = nullptr, *tY = nullptr; 495 EXPECT_TRUE(match( 496 Pattern, m_c_And(m_Value(tX), m_c_And(m_Deferred(tX), m_Value(tY))))); 497 EXPECT_EQ(tX, X); 498 EXPECT_EQ(tY, Y); 499 }; 500 501 checkMatch(IRB.CreateAnd(X, IRB.CreateAnd(X, Y))); 502 checkMatch(IRB.CreateAnd(X, IRB.CreateAnd(Y, X))); 503 checkMatch(IRB.CreateAnd(IRB.CreateAnd(X, Y), X)); 504 checkMatch(IRB.CreateAnd(IRB.CreateAnd(Y, X), X)); 505 } 506 507 TEST_F(PatternMatchTest, FloatingPointOrderedMin) { 508 Type *FltTy = IRB.getFloatTy(); 509 Value *L = ConstantFP::get(FltTy, 1.0); 510 Value *R = ConstantFP::get(FltTy, 2.0); 511 Value *MatchL, *MatchR; 512 513 // Test OLT. 514 EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR)) 515 .match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), L, R))); 516 EXPECT_EQ(L, MatchL); 517 EXPECT_EQ(R, MatchR); 518 519 // Test OLE. 520 EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR)) 521 .match(IRB.CreateSelect(IRB.CreateFCmpOLE(L, R), L, R))); 522 EXPECT_EQ(L, MatchL); 523 EXPECT_EQ(R, MatchR); 524 525 // Test no match on OGE. 526 EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR)) 527 .match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), L, R))); 528 529 // Test no match on OGT. 530 EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR)) 531 .match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), L, R))); 532 533 // Test inverted selects. Note, that this "inverts" the ordering, e.g.: 534 // %cmp = fcmp oge L, R 535 // %min = select %cmp R, L 536 // Given L == NaN 537 // the above is expanded to %cmp == false ==> %min = L 538 // which is true for UnordFMin, not OrdFMin, so test that: 539 540 // [OU]GE with inverted select. 541 EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR)) 542 .match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), R, L))); 543 EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR)) 544 .match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), R, L))); 545 EXPECT_EQ(L, MatchL); 546 EXPECT_EQ(R, MatchR); 547 548 // [OU]GT with inverted select. 549 EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR)) 550 .match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), R, L))); 551 EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR)) 552 .match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), R, L))); 553 EXPECT_EQ(L, MatchL); 554 EXPECT_EQ(R, MatchR); 555 } 556 557 TEST_F(PatternMatchTest, FloatingPointOrderedMax) { 558 Type *FltTy = IRB.getFloatTy(); 559 Value *L = ConstantFP::get(FltTy, 1.0); 560 Value *R = ConstantFP::get(FltTy, 2.0); 561 Value *MatchL, *MatchR; 562 563 // Test OGT. 564 EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR)) 565 .match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), L, R))); 566 EXPECT_EQ(L, MatchL); 567 EXPECT_EQ(R, MatchR); 568 569 // Test OGE. 570 EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR)) 571 .match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), L, R))); 572 EXPECT_EQ(L, MatchL); 573 EXPECT_EQ(R, MatchR); 574 575 // Test no match on OLE. 576 EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR)) 577 .match(IRB.CreateSelect(IRB.CreateFCmpOLE(L, R), L, R))); 578 579 // Test no match on OLT. 580 EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR)) 581 .match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), L, R))); 582 583 584 // Test inverted selects. Note, that this "inverts" the ordering, e.g.: 585 // %cmp = fcmp ole L, R 586 // %max = select %cmp, R, L 587 // Given L == NaN, 588 // the above is expanded to %cmp == false ==> %max == L 589 // which is true for UnordFMax, not OrdFMax, so test that: 590 591 // [OU]LE with inverted select. 592 EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR)) 593 .match(IRB.CreateSelect(IRB.CreateFCmpOLE(L, R), R, L))); 594 EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR)) 595 .match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), R, L))); 596 EXPECT_EQ(L, MatchL); 597 EXPECT_EQ(R, MatchR); 598 599 // [OUT]LT with inverted select. 600 EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR)) 601 .match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), R, L))); 602 EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR)) 603 .match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), R, L))); 604 EXPECT_EQ(L, MatchL); 605 EXPECT_EQ(R, MatchR); 606 } 607 608 TEST_F(PatternMatchTest, FloatingPointUnorderedMin) { 609 Type *FltTy = IRB.getFloatTy(); 610 Value *L = ConstantFP::get(FltTy, 1.0); 611 Value *R = ConstantFP::get(FltTy, 2.0); 612 Value *MatchL, *MatchR; 613 614 // Test ULT. 615 EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR)) 616 .match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), L, R))); 617 EXPECT_EQ(L, MatchL); 618 EXPECT_EQ(R, MatchR); 619 620 // Test ULE. 621 EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR)) 622 .match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), L, R))); 623 EXPECT_EQ(L, MatchL); 624 EXPECT_EQ(R, MatchR); 625 626 // Test no match on UGE. 627 EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR)) 628 .match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), L, R))); 629 630 // Test no match on UGT. 631 EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR)) 632 .match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), L, R))); 633 634 // Test inverted selects. Note, that this "inverts" the ordering, e.g.: 635 // %cmp = fcmp uge L, R 636 // %min = select %cmp R, L 637 // Given L == NaN 638 // the above is expanded to %cmp == true ==> %min = R 639 // which is true for OrdFMin, not UnordFMin, so test that: 640 641 // [UO]GE with inverted select. 642 EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR)) 643 .match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), R, L))); 644 EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR)) 645 .match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), R, L))); 646 EXPECT_EQ(L, MatchL); 647 EXPECT_EQ(R, MatchR); 648 649 // [UO]GT with inverted select. 650 EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR)) 651 .match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), R, L))); 652 EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR)) 653 .match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), R, L))); 654 EXPECT_EQ(L, MatchL); 655 EXPECT_EQ(R, MatchR); 656 } 657 658 TEST_F(PatternMatchTest, FloatingPointUnorderedMax) { 659 Type *FltTy = IRB.getFloatTy(); 660 Value *L = ConstantFP::get(FltTy, 1.0); 661 Value *R = ConstantFP::get(FltTy, 2.0); 662 Value *MatchL, *MatchR; 663 664 // Test UGT. 665 EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR)) 666 .match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), L, R))); 667 EXPECT_EQ(L, MatchL); 668 EXPECT_EQ(R, MatchR); 669 670 // Test UGE. 671 EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR)) 672 .match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), L, R))); 673 EXPECT_EQ(L, MatchL); 674 EXPECT_EQ(R, MatchR); 675 676 // Test no match on ULE. 677 EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR)) 678 .match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), L, R))); 679 680 // Test no match on ULT. 681 EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR)) 682 .match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), L, R))); 683 684 // Test inverted selects. Note, that this "inverts" the ordering, e.g.: 685 // %cmp = fcmp ule L, R 686 // %max = select %cmp R, L 687 // Given L == NaN 688 // the above is expanded to %cmp == true ==> %max = R 689 // which is true for OrdFMax, not UnordFMax, so test that: 690 691 // [UO]LE with inverted select. 692 EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR)) 693 .match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), R, L))); 694 EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR)) 695 .match(IRB.CreateSelect(IRB.CreateFCmpOLE(L, R), R, L))); 696 EXPECT_EQ(L, MatchL); 697 EXPECT_EQ(R, MatchR); 698 699 // [UO]LT with inverted select. 700 EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR)) 701 .match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), R, L))); 702 EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR)) 703 .match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), R, L))); 704 EXPECT_EQ(L, MatchL); 705 EXPECT_EQ(R, MatchR); 706 } 707 708 TEST_F(PatternMatchTest, OverflowingBinOps) { 709 Value *L = IRB.getInt32(1); 710 Value *R = IRB.getInt32(2); 711 Value *MatchL, *MatchR; 712 713 EXPECT_TRUE( 714 m_NSWAdd(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNSWAdd(L, R))); 715 EXPECT_EQ(L, MatchL); 716 EXPECT_EQ(R, MatchR); 717 MatchL = MatchR = nullptr; 718 EXPECT_TRUE( 719 m_NSWSub(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNSWSub(L, R))); 720 EXPECT_EQ(L, MatchL); 721 EXPECT_EQ(R, MatchR); 722 MatchL = MatchR = nullptr; 723 EXPECT_TRUE( 724 m_NSWMul(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNSWMul(L, R))); 725 EXPECT_EQ(L, MatchL); 726 EXPECT_EQ(R, MatchR); 727 MatchL = MatchR = nullptr; 728 EXPECT_TRUE(m_NSWShl(m_Value(MatchL), m_Value(MatchR)).match( 729 IRB.CreateShl(L, R, "", /* NUW */ false, /* NSW */ true))); 730 EXPECT_EQ(L, MatchL); 731 EXPECT_EQ(R, MatchR); 732 733 EXPECT_TRUE( 734 m_NUWAdd(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNUWAdd(L, R))); 735 EXPECT_EQ(L, MatchL); 736 EXPECT_EQ(R, MatchR); 737 MatchL = MatchR = nullptr; 738 EXPECT_TRUE( 739 m_NUWSub(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNUWSub(L, R))); 740 EXPECT_EQ(L, MatchL); 741 EXPECT_EQ(R, MatchR); 742 MatchL = MatchR = nullptr; 743 EXPECT_TRUE( 744 m_NUWMul(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNUWMul(L, R))); 745 EXPECT_EQ(L, MatchL); 746 EXPECT_EQ(R, MatchR); 747 MatchL = MatchR = nullptr; 748 EXPECT_TRUE(m_NUWShl(m_Value(MatchL), m_Value(MatchR)).match( 749 IRB.CreateShl(L, R, "", /* NUW */ true, /* NSW */ false))); 750 EXPECT_EQ(L, MatchL); 751 EXPECT_EQ(R, MatchR); 752 753 EXPECT_FALSE(m_NSWAdd(m_Value(), m_Value()).match(IRB.CreateAdd(L, R))); 754 EXPECT_FALSE(m_NSWAdd(m_Value(), m_Value()).match(IRB.CreateNUWAdd(L, R))); 755 EXPECT_FALSE(m_NSWAdd(m_Value(), m_Value()).match(IRB.CreateNSWSub(L, R))); 756 EXPECT_FALSE(m_NSWSub(m_Value(), m_Value()).match(IRB.CreateSub(L, R))); 757 EXPECT_FALSE(m_NSWSub(m_Value(), m_Value()).match(IRB.CreateNUWSub(L, R))); 758 EXPECT_FALSE(m_NSWSub(m_Value(), m_Value()).match(IRB.CreateNSWAdd(L, R))); 759 EXPECT_FALSE(m_NSWMul(m_Value(), m_Value()).match(IRB.CreateMul(L, R))); 760 EXPECT_FALSE(m_NSWMul(m_Value(), m_Value()).match(IRB.CreateNUWMul(L, R))); 761 EXPECT_FALSE(m_NSWMul(m_Value(), m_Value()).match(IRB.CreateNSWAdd(L, R))); 762 EXPECT_FALSE(m_NSWShl(m_Value(), m_Value()).match(IRB.CreateShl(L, R))); 763 EXPECT_FALSE(m_NSWShl(m_Value(), m_Value()).match( 764 IRB.CreateShl(L, R, "", /* NUW */ true, /* NSW */ false))); 765 EXPECT_FALSE(m_NSWShl(m_Value(), m_Value()).match(IRB.CreateNSWAdd(L, R))); 766 767 EXPECT_FALSE(m_NUWAdd(m_Value(), m_Value()).match(IRB.CreateAdd(L, R))); 768 EXPECT_FALSE(m_NUWAdd(m_Value(), m_Value()).match(IRB.CreateNSWAdd(L, R))); 769 EXPECT_FALSE(m_NUWAdd(m_Value(), m_Value()).match(IRB.CreateNUWSub(L, R))); 770 EXPECT_FALSE(m_NUWSub(m_Value(), m_Value()).match(IRB.CreateSub(L, R))); 771 EXPECT_FALSE(m_NUWSub(m_Value(), m_Value()).match(IRB.CreateNSWSub(L, R))); 772 EXPECT_FALSE(m_NUWSub(m_Value(), m_Value()).match(IRB.CreateNUWAdd(L, R))); 773 EXPECT_FALSE(m_NUWMul(m_Value(), m_Value()).match(IRB.CreateMul(L, R))); 774 EXPECT_FALSE(m_NUWMul(m_Value(), m_Value()).match(IRB.CreateNSWMul(L, R))); 775 EXPECT_FALSE(m_NUWMul(m_Value(), m_Value()).match(IRB.CreateNUWAdd(L, R))); 776 EXPECT_FALSE(m_NUWShl(m_Value(), m_Value()).match(IRB.CreateShl(L, R))); 777 EXPECT_FALSE(m_NUWShl(m_Value(), m_Value()).match( 778 IRB.CreateShl(L, R, "", /* NUW */ false, /* NSW */ true))); 779 EXPECT_FALSE(m_NUWShl(m_Value(), m_Value()).match(IRB.CreateNUWAdd(L, R))); 780 } 781 782 TEST_F(PatternMatchTest, LoadStoreOps) { 783 // Create this load/store sequence: 784 // 785 // %p = alloca i32* 786 // %0 = load i32*, i32** %p 787 // store i32 42, i32* %0 788 789 Value *Alloca = IRB.CreateAlloca(IRB.getInt32Ty()); 790 Value *LoadInst = IRB.CreateLoad(IRB.getInt32Ty(), Alloca); 791 Value *FourtyTwo = IRB.getInt32(42); 792 Value *StoreInst = IRB.CreateStore(FourtyTwo, Alloca); 793 Value *MatchLoad, *MatchStoreVal, *MatchStorePointer; 794 795 EXPECT_TRUE(m_Load(m_Value(MatchLoad)).match(LoadInst)); 796 EXPECT_EQ(Alloca, MatchLoad); 797 798 EXPECT_TRUE(m_Load(m_Specific(Alloca)).match(LoadInst)); 799 800 EXPECT_FALSE(m_Load(m_Value(MatchLoad)).match(Alloca)); 801 802 EXPECT_TRUE(m_Store(m_Value(MatchStoreVal), m_Value(MatchStorePointer)) 803 .match(StoreInst)); 804 EXPECT_EQ(FourtyTwo, MatchStoreVal); 805 EXPECT_EQ(Alloca, MatchStorePointer); 806 807 EXPECT_FALSE(m_Store(m_Value(MatchStoreVal), m_Value(MatchStorePointer)) 808 .match(Alloca)); 809 810 EXPECT_TRUE(m_Store(m_SpecificInt(42), m_Specific(Alloca)) 811 .match(StoreInst)); 812 EXPECT_FALSE(m_Store(m_SpecificInt(42), m_Specific(FourtyTwo)) 813 .match(StoreInst)); 814 EXPECT_FALSE(m_Store(m_SpecificInt(43), m_Specific(Alloca)) 815 .match(StoreInst)); 816 } 817 818 TEST_F(PatternMatchTest, VectorOps) { 819 // Build up small tree of vector operations 820 // 821 // Val = 0 + 1 822 // Val2 = Val + 3 823 // VI1 = insertelement <2 x i8> undef, i8 1, i32 0 = <1, undef> 824 // VI2 = insertelement <2 x i8> %VI1, i8 %Val2, i8 %Val = <1, 4> 825 // VI3 = insertelement <2 x i8> %VI1, i8 %Val2, i32 1 = <1, 4> 826 // VI4 = insertelement <2 x i8> %VI1, i8 2, i8 %Val = <1, 2> 827 // 828 // SI1 = shufflevector <2 x i8> %VI1, <2 x i8> undef, zeroinitializer 829 // SI2 = shufflevector <2 x i8> %VI3, <2 x i8> %VI4, <2 x i8> <i8 0, i8 2> 830 // SI3 = shufflevector <2 x i8> %VI3, <2 x i8> undef, zeroinitializer 831 // SI4 = shufflevector <2 x i8> %VI4, <2 x i8> undef, zeroinitializer 832 // 833 // SP1 = VectorSplat(2, i8 2) 834 // SP2 = VectorSplat(2, i8 %Val) 835 Type *VecTy = VectorType::get(IRB.getInt8Ty(), 2); 836 Type *i32 = IRB.getInt32Ty(); 837 Type *i32VecTy = VectorType::get(i32, 2); 838 839 Value *Val = IRB.CreateAdd(IRB.getInt8(0), IRB.getInt8(1)); 840 Value *Val2 = IRB.CreateAdd(Val, IRB.getInt8(3)); 841 842 SmallVector<Constant *, 2> VecElemIdxs; 843 VecElemIdxs.push_back(ConstantInt::get(i32, 0)); 844 VecElemIdxs.push_back(ConstantInt::get(i32, 2)); 845 auto *IdxVec = ConstantVector::get(VecElemIdxs); 846 847 Value *UndefVec = UndefValue::get(VecTy); 848 Value *VI1 = IRB.CreateInsertElement(UndefVec, IRB.getInt8(1), (uint64_t)0); 849 Value *VI2 = IRB.CreateInsertElement(VI1, Val2, Val); 850 Value *VI3 = IRB.CreateInsertElement(VI1, Val2, (uint64_t)1); 851 Value *VI4 = IRB.CreateInsertElement(VI1, IRB.getInt8(2), Val); 852 853 Value *EX1 = IRB.CreateExtractElement(VI4, Val); 854 Value *EX2 = IRB.CreateExtractElement(VI4, (uint64_t)0); 855 Value *EX3 = IRB.CreateExtractElement(IdxVec, (uint64_t)1); 856 857 Value *Zero = ConstantAggregateZero::get(i32VecTy); 858 Value *SI1 = IRB.CreateShuffleVector(VI1, UndefVec, Zero); 859 Value *SI2 = IRB.CreateShuffleVector(VI3, VI4, IdxVec); 860 Value *SI3 = IRB.CreateShuffleVector(VI3, UndefVec, Zero); 861 Value *SI4 = IRB.CreateShuffleVector(VI4, UndefVec, Zero); 862 863 Value *SP1 = IRB.CreateVectorSplat(2, IRB.getInt8(2)); 864 Value *SP2 = IRB.CreateVectorSplat(2, Val); 865 866 Value *A = nullptr, *B = nullptr, *C = nullptr; 867 868 // Test matching insertelement 869 EXPECT_TRUE(match(VI1, m_InsertElement(m_Value(), m_Value(), m_Value()))); 870 EXPECT_TRUE( 871 match(VI1, m_InsertElement(m_Undef(), m_ConstantInt(), m_ConstantInt()))); 872 EXPECT_TRUE( 873 match(VI1, m_InsertElement(m_Undef(), m_ConstantInt(), m_Zero()))); 874 EXPECT_TRUE( 875 match(VI1, m_InsertElement(m_Undef(), m_SpecificInt(1), m_Zero()))); 876 EXPECT_TRUE(match(VI2, m_InsertElement(m_Value(), m_Value(), m_Value()))); 877 EXPECT_FALSE( 878 match(VI2, m_InsertElement(m_Value(), m_Value(), m_ConstantInt()))); 879 EXPECT_FALSE( 880 match(VI2, m_InsertElement(m_Value(), m_ConstantInt(), m_Value()))); 881 EXPECT_FALSE(match(VI2, m_InsertElement(m_Constant(), m_Value(), m_Value()))); 882 EXPECT_TRUE(match(VI3, m_InsertElement(m_Value(A), m_Value(B), m_Value(C)))); 883 EXPECT_TRUE(A == VI1); 884 EXPECT_TRUE(B == Val2); 885 EXPECT_TRUE(isa<ConstantInt>(C)); 886 A = B = C = nullptr; // reset 887 888 // Test matching extractelement 889 EXPECT_TRUE(match(EX1, m_ExtractElement(m_Value(A), m_Value(B)))); 890 EXPECT_TRUE(A == VI4); 891 EXPECT_TRUE(B == Val); 892 A = B = C = nullptr; // reset 893 EXPECT_FALSE(match(EX1, m_ExtractElement(m_Value(), m_ConstantInt()))); 894 EXPECT_TRUE(match(EX2, m_ExtractElement(m_Value(), m_ConstantInt()))); 895 EXPECT_TRUE(match(EX3, m_ExtractElement(m_Constant(), m_ConstantInt()))); 896 897 // Test matching shufflevector 898 EXPECT_TRUE(match(SI1, m_ShuffleVector(m_Value(), m_Undef(), m_Zero()))); 899 EXPECT_TRUE(match(SI2, m_ShuffleVector(m_Value(A), m_Value(B), m_Value(C)))); 900 EXPECT_TRUE(A == VI3); 901 EXPECT_TRUE(B == VI4); 902 EXPECT_TRUE(C == IdxVec); 903 A = B = C = nullptr; // reset 904 905 // Test matching the vector splat pattern 906 EXPECT_TRUE(match( 907 SI1, 908 m_ShuffleVector(m_InsertElement(m_Undef(), m_SpecificInt(1), m_Zero()), 909 m_Undef(), m_Zero()))); 910 EXPECT_FALSE(match( 911 SI3, m_ShuffleVector(m_InsertElement(m_Undef(), m_Value(), m_Zero()), 912 m_Undef(), m_Zero()))); 913 EXPECT_FALSE(match( 914 SI4, m_ShuffleVector(m_InsertElement(m_Undef(), m_Value(), m_Zero()), 915 m_Undef(), m_Zero()))); 916 EXPECT_TRUE(match( 917 SP1, 918 m_ShuffleVector(m_InsertElement(m_Undef(), m_SpecificInt(2), m_Zero()), 919 m_Undef(), m_Zero()))); 920 EXPECT_TRUE(match( 921 SP2, m_ShuffleVector(m_InsertElement(m_Undef(), m_Value(A), m_Zero()), 922 m_Undef(), m_Zero()))); 923 EXPECT_TRUE(A == Val); 924 } 925 926 TEST_F(PatternMatchTest, VectorUndefInt) { 927 Type *ScalarTy = IRB.getInt8Ty(); 928 Type *VectorTy = VectorType::get(ScalarTy, 4); 929 Constant *ScalarUndef = UndefValue::get(ScalarTy); 930 Constant *VectorUndef = UndefValue::get(VectorTy); 931 Constant *ScalarZero = Constant::getNullValue(ScalarTy); 932 Constant *VectorZero = Constant::getNullValue(VectorTy); 933 934 SmallVector<Constant *, 4> Elems; 935 Elems.push_back(ScalarUndef); 936 Elems.push_back(ScalarZero); 937 Elems.push_back(ScalarUndef); 938 Elems.push_back(ScalarZero); 939 Constant *VectorZeroUndef = ConstantVector::get(Elems); 940 941 EXPECT_TRUE(match(ScalarUndef, m_Undef())); 942 EXPECT_TRUE(match(VectorUndef, m_Undef())); 943 EXPECT_FALSE(match(ScalarZero, m_Undef())); 944 EXPECT_FALSE(match(VectorZero, m_Undef())); 945 EXPECT_FALSE(match(VectorZeroUndef, m_Undef())); 946 947 EXPECT_FALSE(match(ScalarUndef, m_Zero())); 948 EXPECT_FALSE(match(VectorUndef, m_Zero())); 949 EXPECT_TRUE(match(ScalarZero, m_Zero())); 950 EXPECT_TRUE(match(VectorZero, m_Zero())); 951 EXPECT_TRUE(match(VectorZeroUndef, m_Zero())); 952 } 953 954 TEST_F(PatternMatchTest, VectorUndefFloat) { 955 Type *ScalarTy = IRB.getFloatTy(); 956 Type *VectorTy = VectorType::get(ScalarTy, 4); 957 Constant *ScalarUndef = UndefValue::get(ScalarTy); 958 Constant *VectorUndef = UndefValue::get(VectorTy); 959 Constant *ScalarZero = Constant::getNullValue(ScalarTy); 960 Constant *VectorZero = Constant::getNullValue(VectorTy); 961 962 SmallVector<Constant *, 4> Elems; 963 Elems.push_back(ScalarUndef); 964 Elems.push_back(ScalarZero); 965 Elems.push_back(ScalarUndef); 966 Elems.push_back(ScalarZero); 967 Constant *VectorZeroUndef = ConstantVector::get(Elems); 968 969 EXPECT_TRUE(match(ScalarUndef, m_Undef())); 970 EXPECT_TRUE(match(VectorUndef, m_Undef())); 971 EXPECT_FALSE(match(ScalarZero, m_Undef())); 972 EXPECT_FALSE(match(VectorZero, m_Undef())); 973 EXPECT_FALSE(match(VectorZeroUndef, m_Undef())); 974 975 EXPECT_FALSE(match(ScalarUndef, m_AnyZeroFP())); 976 EXPECT_FALSE(match(VectorUndef, m_AnyZeroFP())); 977 EXPECT_TRUE(match(ScalarZero, m_AnyZeroFP())); 978 EXPECT_TRUE(match(VectorZero, m_AnyZeroFP())); 979 EXPECT_TRUE(match(VectorZeroUndef, m_AnyZeroFP())); 980 } 981 982 TEST_F(PatternMatchTest, FloatingPointFNeg) { 983 Type *FltTy = IRB.getFloatTy(); 984 Value *One = ConstantFP::get(FltTy, 1.0); 985 Value *Z = ConstantFP::get(FltTy, 0.0); 986 Value *NZ = ConstantFP::get(FltTy, -0.0); 987 Value *V = IRB.CreateFNeg(One); 988 Value *V1 = IRB.CreateFSub(NZ, One); 989 Value *V2 = IRB.CreateFSub(Z, One); 990 Value *V3 = IRB.CreateFAdd(NZ, One); 991 Value *Match; 992 993 // Test FNeg(1.0) 994 EXPECT_TRUE(match(V, m_FNeg(m_Value(Match)))); 995 EXPECT_EQ(One, Match); 996 997 // Test FSub(-0.0, 1.0) 998 EXPECT_TRUE(match(V1, m_FNeg(m_Value(Match)))); 999 EXPECT_EQ(One, Match); 1000 1001 // Test FSub(0.0, 1.0) 1002 EXPECT_FALSE(match(V2, m_FNeg(m_Value(Match)))); 1003 cast<Instruction>(V2)->setHasNoSignedZeros(true); 1004 EXPECT_TRUE(match(V2, m_FNeg(m_Value(Match)))); 1005 EXPECT_EQ(One, Match); 1006 1007 // Test FAdd(-0.0, 1.0) 1008 EXPECT_FALSE(match(V3, m_FNeg(m_Value(Match)))); 1009 } 1010 1011 template <typename T> struct MutableConstTest : PatternMatchTest { }; 1012 1013 typedef ::testing::Types<std::tuple<Value*, Instruction*>, 1014 std::tuple<const Value*, const Instruction *>> 1015 MutableConstTestTypes; 1016 TYPED_TEST_CASE(MutableConstTest, MutableConstTestTypes); 1017 1018 TYPED_TEST(MutableConstTest, ICmp) { 1019 auto &IRB = PatternMatchTest::IRB; 1020 1021 typedef typename std::tuple_element<0, TypeParam>::type ValueType; 1022 typedef typename std::tuple_element<1, TypeParam>::type InstructionType; 1023 1024 Value *L = IRB.getInt32(1); 1025 Value *R = IRB.getInt32(2); 1026 ICmpInst::Predicate Pred = ICmpInst::ICMP_UGT; 1027 1028 ValueType MatchL; 1029 ValueType MatchR; 1030 ICmpInst::Predicate MatchPred; 1031 1032 EXPECT_TRUE(m_ICmp(MatchPred, m_Value(MatchL), m_Value(MatchR)) 1033 .match((InstructionType)IRB.CreateICmp(Pred, L, R))); 1034 EXPECT_EQ(L, MatchL); 1035 EXPECT_EQ(R, MatchR); 1036 } 1037 1038 } // anonymous namespace. 1039