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, SpecificIntULT) { 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_FALSE(m_SpecificInt_ULT(APInt(BitWidth, 0)).match(Zero)); 76 EXPECT_FALSE(m_SpecificInt_ULT(APInt(BitWidth, 0)).match(One)); 77 EXPECT_FALSE(m_SpecificInt_ULT(APInt(BitWidth, 0)).match(NegOne)); 78 79 EXPECT_TRUE(m_SpecificInt_ULT(APInt(BitWidth, 1)).match(Zero)); 80 EXPECT_FALSE(m_SpecificInt_ULT(APInt(BitWidth, 1)).match(One)); 81 EXPECT_FALSE(m_SpecificInt_ULT(APInt(BitWidth, 1)).match(NegOne)); 82 83 EXPECT_TRUE(m_SpecificInt_ULT(APInt(BitWidth, -1)).match(Zero)); 84 EXPECT_TRUE(m_SpecificInt_ULT(APInt(BitWidth, -1)).match(One)); 85 EXPECT_FALSE(m_SpecificInt_ULT(APInt(BitWidth, -1)).match(NegOne)); 86 } 87 88 TEST_F(PatternMatchTest, CommutativeDeferredValue) { 89 Value *X = IRB.getInt32(1); 90 Value *Y = IRB.getInt32(2); 91 92 { 93 Value *tX = X; 94 EXPECT_TRUE(match(X, m_Deferred(tX))); 95 EXPECT_FALSE(match(Y, m_Deferred(tX))); 96 } 97 { 98 const Value *tX = X; 99 EXPECT_TRUE(match(X, m_Deferred(tX))); 100 EXPECT_FALSE(match(Y, m_Deferred(tX))); 101 } 102 { 103 Value *const tX = X; 104 EXPECT_TRUE(match(X, m_Deferred(tX))); 105 EXPECT_FALSE(match(Y, m_Deferred(tX))); 106 } 107 { 108 const Value *const tX = X; 109 EXPECT_TRUE(match(X, m_Deferred(tX))); 110 EXPECT_FALSE(match(Y, m_Deferred(tX))); 111 } 112 113 { 114 Value *tX = nullptr; 115 EXPECT_TRUE(match(IRB.CreateAnd(X, X), m_And(m_Value(tX), m_Deferred(tX)))); 116 EXPECT_EQ(tX, X); 117 } 118 { 119 Value *tX = nullptr; 120 EXPECT_FALSE( 121 match(IRB.CreateAnd(X, Y), m_c_And(m_Value(tX), m_Deferred(tX)))); 122 } 123 124 auto checkMatch = [X, Y](Value *Pattern) { 125 Value *tX = nullptr, *tY = nullptr; 126 EXPECT_TRUE(match( 127 Pattern, m_c_And(m_Value(tX), m_c_And(m_Deferred(tX), m_Value(tY))))); 128 EXPECT_EQ(tX, X); 129 EXPECT_EQ(tY, Y); 130 }; 131 132 checkMatch(IRB.CreateAnd(X, IRB.CreateAnd(X, Y))); 133 checkMatch(IRB.CreateAnd(X, IRB.CreateAnd(Y, X))); 134 checkMatch(IRB.CreateAnd(IRB.CreateAnd(X, Y), X)); 135 checkMatch(IRB.CreateAnd(IRB.CreateAnd(Y, X), X)); 136 } 137 138 TEST_F(PatternMatchTest, FloatingPointOrderedMin) { 139 Type *FltTy = IRB.getFloatTy(); 140 Value *L = ConstantFP::get(FltTy, 1.0); 141 Value *R = ConstantFP::get(FltTy, 2.0); 142 Value *MatchL, *MatchR; 143 144 // Test OLT. 145 EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR)) 146 .match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), L, R))); 147 EXPECT_EQ(L, MatchL); 148 EXPECT_EQ(R, MatchR); 149 150 // Test OLE. 151 EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR)) 152 .match(IRB.CreateSelect(IRB.CreateFCmpOLE(L, R), L, R))); 153 EXPECT_EQ(L, MatchL); 154 EXPECT_EQ(R, MatchR); 155 156 // Test no match on OGE. 157 EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR)) 158 .match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), L, R))); 159 160 // Test no match on OGT. 161 EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR)) 162 .match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), L, R))); 163 164 // Test inverted selects. Note, that this "inverts" the ordering, e.g.: 165 // %cmp = fcmp oge L, R 166 // %min = select %cmp R, L 167 // Given L == NaN 168 // the above is expanded to %cmp == false ==> %min = L 169 // which is true for UnordFMin, not OrdFMin, so test that: 170 171 // [OU]GE with inverted select. 172 EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR)) 173 .match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), R, L))); 174 EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR)) 175 .match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), R, L))); 176 EXPECT_EQ(L, MatchL); 177 EXPECT_EQ(R, MatchR); 178 179 // [OU]GT with inverted select. 180 EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR)) 181 .match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), R, L))); 182 EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR)) 183 .match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), R, L))); 184 EXPECT_EQ(L, MatchL); 185 EXPECT_EQ(R, MatchR); 186 } 187 188 TEST_F(PatternMatchTest, FloatingPointOrderedMax) { 189 Type *FltTy = IRB.getFloatTy(); 190 Value *L = ConstantFP::get(FltTy, 1.0); 191 Value *R = ConstantFP::get(FltTy, 2.0); 192 Value *MatchL, *MatchR; 193 194 // Test OGT. 195 EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR)) 196 .match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), L, R))); 197 EXPECT_EQ(L, MatchL); 198 EXPECT_EQ(R, MatchR); 199 200 // Test OGE. 201 EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR)) 202 .match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), L, R))); 203 EXPECT_EQ(L, MatchL); 204 EXPECT_EQ(R, MatchR); 205 206 // Test no match on OLE. 207 EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR)) 208 .match(IRB.CreateSelect(IRB.CreateFCmpOLE(L, R), L, R))); 209 210 // Test no match on OLT. 211 EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR)) 212 .match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), L, R))); 213 214 215 // Test inverted selects. Note, that this "inverts" the ordering, e.g.: 216 // %cmp = fcmp ole L, R 217 // %max = select %cmp, R, L 218 // Given L == NaN, 219 // the above is expanded to %cmp == false ==> %max == L 220 // which is true for UnordFMax, not OrdFMax, so test that: 221 222 // [OU]LE with inverted select. 223 EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR)) 224 .match(IRB.CreateSelect(IRB.CreateFCmpOLE(L, R), R, L))); 225 EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR)) 226 .match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), R, L))); 227 EXPECT_EQ(L, MatchL); 228 EXPECT_EQ(R, MatchR); 229 230 // [OUT]LT with inverted select. 231 EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR)) 232 .match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), R, L))); 233 EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR)) 234 .match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), R, L))); 235 EXPECT_EQ(L, MatchL); 236 EXPECT_EQ(R, MatchR); 237 } 238 239 TEST_F(PatternMatchTest, FloatingPointUnorderedMin) { 240 Type *FltTy = IRB.getFloatTy(); 241 Value *L = ConstantFP::get(FltTy, 1.0); 242 Value *R = ConstantFP::get(FltTy, 2.0); 243 Value *MatchL, *MatchR; 244 245 // Test ULT. 246 EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR)) 247 .match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), L, R))); 248 EXPECT_EQ(L, MatchL); 249 EXPECT_EQ(R, MatchR); 250 251 // Test ULE. 252 EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR)) 253 .match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), L, R))); 254 EXPECT_EQ(L, MatchL); 255 EXPECT_EQ(R, MatchR); 256 257 // Test no match on UGE. 258 EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR)) 259 .match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), L, R))); 260 261 // Test no match on UGT. 262 EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR)) 263 .match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), L, R))); 264 265 // Test inverted selects. Note, that this "inverts" the ordering, e.g.: 266 // %cmp = fcmp uge L, R 267 // %min = select %cmp R, L 268 // Given L == NaN 269 // the above is expanded to %cmp == true ==> %min = R 270 // which is true for OrdFMin, not UnordFMin, so test that: 271 272 // [UO]GE with inverted select. 273 EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR)) 274 .match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), R, L))); 275 EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR)) 276 .match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), R, L))); 277 EXPECT_EQ(L, MatchL); 278 EXPECT_EQ(R, MatchR); 279 280 // [UO]GT with inverted select. 281 EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR)) 282 .match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), R, L))); 283 EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR)) 284 .match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), R, L))); 285 EXPECT_EQ(L, MatchL); 286 EXPECT_EQ(R, MatchR); 287 } 288 289 TEST_F(PatternMatchTest, FloatingPointUnorderedMax) { 290 Type *FltTy = IRB.getFloatTy(); 291 Value *L = ConstantFP::get(FltTy, 1.0); 292 Value *R = ConstantFP::get(FltTy, 2.0); 293 Value *MatchL, *MatchR; 294 295 // Test UGT. 296 EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR)) 297 .match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), L, R))); 298 EXPECT_EQ(L, MatchL); 299 EXPECT_EQ(R, MatchR); 300 301 // Test UGE. 302 EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR)) 303 .match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), L, R))); 304 EXPECT_EQ(L, MatchL); 305 EXPECT_EQ(R, MatchR); 306 307 // Test no match on ULE. 308 EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR)) 309 .match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), L, R))); 310 311 // Test no match on ULT. 312 EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR)) 313 .match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), L, R))); 314 315 // Test inverted selects. Note, that this "inverts" the ordering, e.g.: 316 // %cmp = fcmp ule L, R 317 // %max = select %cmp R, L 318 // Given L == NaN 319 // the above is expanded to %cmp == true ==> %max = R 320 // which is true for OrdFMax, not UnordFMax, so test that: 321 322 // [UO]LE with inverted select. 323 EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR)) 324 .match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), R, L))); 325 EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR)) 326 .match(IRB.CreateSelect(IRB.CreateFCmpOLE(L, R), R, L))); 327 EXPECT_EQ(L, MatchL); 328 EXPECT_EQ(R, MatchR); 329 330 // [UO]LT with inverted select. 331 EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR)) 332 .match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), R, L))); 333 EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR)) 334 .match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), R, L))); 335 EXPECT_EQ(L, MatchL); 336 EXPECT_EQ(R, MatchR); 337 } 338 339 TEST_F(PatternMatchTest, OverflowingBinOps) { 340 Value *L = IRB.getInt32(1); 341 Value *R = IRB.getInt32(2); 342 Value *MatchL, *MatchR; 343 344 EXPECT_TRUE( 345 m_NSWAdd(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNSWAdd(L, R))); 346 EXPECT_EQ(L, MatchL); 347 EXPECT_EQ(R, MatchR); 348 MatchL = MatchR = nullptr; 349 EXPECT_TRUE( 350 m_NSWSub(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNSWSub(L, R))); 351 EXPECT_EQ(L, MatchL); 352 EXPECT_EQ(R, MatchR); 353 MatchL = MatchR = nullptr; 354 EXPECT_TRUE( 355 m_NSWMul(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNSWMul(L, R))); 356 EXPECT_EQ(L, MatchL); 357 EXPECT_EQ(R, MatchR); 358 MatchL = MatchR = nullptr; 359 EXPECT_TRUE(m_NSWShl(m_Value(MatchL), m_Value(MatchR)).match( 360 IRB.CreateShl(L, R, "", /* NUW */ false, /* NSW */ true))); 361 EXPECT_EQ(L, MatchL); 362 EXPECT_EQ(R, MatchR); 363 364 EXPECT_TRUE( 365 m_NUWAdd(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNUWAdd(L, R))); 366 EXPECT_EQ(L, MatchL); 367 EXPECT_EQ(R, MatchR); 368 MatchL = MatchR = nullptr; 369 EXPECT_TRUE( 370 m_NUWSub(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNUWSub(L, R))); 371 EXPECT_EQ(L, MatchL); 372 EXPECT_EQ(R, MatchR); 373 MatchL = MatchR = nullptr; 374 EXPECT_TRUE( 375 m_NUWMul(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNUWMul(L, R))); 376 EXPECT_EQ(L, MatchL); 377 EXPECT_EQ(R, MatchR); 378 MatchL = MatchR = nullptr; 379 EXPECT_TRUE(m_NUWShl(m_Value(MatchL), m_Value(MatchR)).match( 380 IRB.CreateShl(L, R, "", /* NUW */ true, /* NSW */ false))); 381 EXPECT_EQ(L, MatchL); 382 EXPECT_EQ(R, MatchR); 383 384 EXPECT_FALSE(m_NSWAdd(m_Value(), m_Value()).match(IRB.CreateAdd(L, R))); 385 EXPECT_FALSE(m_NSWAdd(m_Value(), m_Value()).match(IRB.CreateNUWAdd(L, R))); 386 EXPECT_FALSE(m_NSWAdd(m_Value(), m_Value()).match(IRB.CreateNSWSub(L, R))); 387 EXPECT_FALSE(m_NSWSub(m_Value(), m_Value()).match(IRB.CreateSub(L, R))); 388 EXPECT_FALSE(m_NSWSub(m_Value(), m_Value()).match(IRB.CreateNUWSub(L, R))); 389 EXPECT_FALSE(m_NSWSub(m_Value(), m_Value()).match(IRB.CreateNSWAdd(L, R))); 390 EXPECT_FALSE(m_NSWMul(m_Value(), m_Value()).match(IRB.CreateMul(L, R))); 391 EXPECT_FALSE(m_NSWMul(m_Value(), m_Value()).match(IRB.CreateNUWMul(L, R))); 392 EXPECT_FALSE(m_NSWMul(m_Value(), m_Value()).match(IRB.CreateNSWAdd(L, R))); 393 EXPECT_FALSE(m_NSWShl(m_Value(), m_Value()).match(IRB.CreateShl(L, R))); 394 EXPECT_FALSE(m_NSWShl(m_Value(), m_Value()).match( 395 IRB.CreateShl(L, R, "", /* NUW */ true, /* NSW */ false))); 396 EXPECT_FALSE(m_NSWShl(m_Value(), m_Value()).match(IRB.CreateNSWAdd(L, R))); 397 398 EXPECT_FALSE(m_NUWAdd(m_Value(), m_Value()).match(IRB.CreateAdd(L, R))); 399 EXPECT_FALSE(m_NUWAdd(m_Value(), m_Value()).match(IRB.CreateNSWAdd(L, R))); 400 EXPECT_FALSE(m_NUWAdd(m_Value(), m_Value()).match(IRB.CreateNUWSub(L, R))); 401 EXPECT_FALSE(m_NUWSub(m_Value(), m_Value()).match(IRB.CreateSub(L, R))); 402 EXPECT_FALSE(m_NUWSub(m_Value(), m_Value()).match(IRB.CreateNSWSub(L, R))); 403 EXPECT_FALSE(m_NUWSub(m_Value(), m_Value()).match(IRB.CreateNUWAdd(L, R))); 404 EXPECT_FALSE(m_NUWMul(m_Value(), m_Value()).match(IRB.CreateMul(L, R))); 405 EXPECT_FALSE(m_NUWMul(m_Value(), m_Value()).match(IRB.CreateNSWMul(L, R))); 406 EXPECT_FALSE(m_NUWMul(m_Value(), m_Value()).match(IRB.CreateNUWAdd(L, R))); 407 EXPECT_FALSE(m_NUWShl(m_Value(), m_Value()).match(IRB.CreateShl(L, R))); 408 EXPECT_FALSE(m_NUWShl(m_Value(), m_Value()).match( 409 IRB.CreateShl(L, R, "", /* NUW */ false, /* NSW */ true))); 410 EXPECT_FALSE(m_NUWShl(m_Value(), m_Value()).match(IRB.CreateNUWAdd(L, R))); 411 } 412 413 TEST_F(PatternMatchTest, LoadStoreOps) { 414 // Create this load/store sequence: 415 // 416 // %p = alloca i32* 417 // %0 = load i32*, i32** %p 418 // store i32 42, i32* %0 419 420 Value *Alloca = IRB.CreateAlloca(IRB.getInt32Ty()); 421 Value *LoadInst = IRB.CreateLoad(IRB.getInt32Ty(), Alloca); 422 Value *FourtyTwo = IRB.getInt32(42); 423 Value *StoreInst = IRB.CreateStore(FourtyTwo, Alloca); 424 Value *MatchLoad, *MatchStoreVal, *MatchStorePointer; 425 426 EXPECT_TRUE(m_Load(m_Value(MatchLoad)).match(LoadInst)); 427 EXPECT_EQ(Alloca, MatchLoad); 428 429 EXPECT_TRUE(m_Load(m_Specific(Alloca)).match(LoadInst)); 430 431 EXPECT_FALSE(m_Load(m_Value(MatchLoad)).match(Alloca)); 432 433 EXPECT_TRUE(m_Store(m_Value(MatchStoreVal), m_Value(MatchStorePointer)) 434 .match(StoreInst)); 435 EXPECT_EQ(FourtyTwo, MatchStoreVal); 436 EXPECT_EQ(Alloca, MatchStorePointer); 437 438 EXPECT_FALSE(m_Store(m_Value(MatchStoreVal), m_Value(MatchStorePointer)) 439 .match(Alloca)); 440 441 EXPECT_TRUE(m_Store(m_SpecificInt(42), m_Specific(Alloca)) 442 .match(StoreInst)); 443 EXPECT_FALSE(m_Store(m_SpecificInt(42), m_Specific(FourtyTwo)) 444 .match(StoreInst)); 445 EXPECT_FALSE(m_Store(m_SpecificInt(43), m_Specific(Alloca)) 446 .match(StoreInst)); 447 } 448 449 TEST_F(PatternMatchTest, VectorOps) { 450 // Build up small tree of vector operations 451 // 452 // Val = 0 + 1 453 // Val2 = Val + 3 454 // VI1 = insertelement <2 x i8> undef, i8 1, i32 0 = <1, undef> 455 // VI2 = insertelement <2 x i8> %VI1, i8 %Val2, i8 %Val = <1, 4> 456 // VI3 = insertelement <2 x i8> %VI1, i8 %Val2, i32 1 = <1, 4> 457 // VI4 = insertelement <2 x i8> %VI1, i8 2, i8 %Val = <1, 2> 458 // 459 // SI1 = shufflevector <2 x i8> %VI1, <2 x i8> undef, zeroinitializer 460 // SI2 = shufflevector <2 x i8> %VI3, <2 x i8> %VI4, <2 x i8> <i8 0, i8 2> 461 // SI3 = shufflevector <2 x i8> %VI3, <2 x i8> undef, zeroinitializer 462 // SI4 = shufflevector <2 x i8> %VI4, <2 x i8> undef, zeroinitializer 463 // 464 // SP1 = VectorSplat(2, i8 2) 465 // SP2 = VectorSplat(2, i8 %Val) 466 Type *VecTy = VectorType::get(IRB.getInt8Ty(), 2); 467 Type *i32 = IRB.getInt32Ty(); 468 Type *i32VecTy = VectorType::get(i32, 2); 469 470 Value *Val = IRB.CreateAdd(IRB.getInt8(0), IRB.getInt8(1)); 471 Value *Val2 = IRB.CreateAdd(Val, IRB.getInt8(3)); 472 473 SmallVector<Constant *, 2> VecElemIdxs; 474 VecElemIdxs.push_back(ConstantInt::get(i32, 0)); 475 VecElemIdxs.push_back(ConstantInt::get(i32, 2)); 476 auto *IdxVec = ConstantVector::get(VecElemIdxs); 477 478 Value *UndefVec = UndefValue::get(VecTy); 479 Value *VI1 = IRB.CreateInsertElement(UndefVec, IRB.getInt8(1), (uint64_t)0); 480 Value *VI2 = IRB.CreateInsertElement(VI1, Val2, Val); 481 Value *VI3 = IRB.CreateInsertElement(VI1, Val2, (uint64_t)1); 482 Value *VI4 = IRB.CreateInsertElement(VI1, IRB.getInt8(2), Val); 483 484 Value *EX1 = IRB.CreateExtractElement(VI4, Val); 485 Value *EX2 = IRB.CreateExtractElement(VI4, (uint64_t)0); 486 Value *EX3 = IRB.CreateExtractElement(IdxVec, (uint64_t)1); 487 488 Value *Zero = ConstantAggregateZero::get(i32VecTy); 489 Value *SI1 = IRB.CreateShuffleVector(VI1, UndefVec, Zero); 490 Value *SI2 = IRB.CreateShuffleVector(VI3, VI4, IdxVec); 491 Value *SI3 = IRB.CreateShuffleVector(VI3, UndefVec, Zero); 492 Value *SI4 = IRB.CreateShuffleVector(VI4, UndefVec, Zero); 493 494 Value *SP1 = IRB.CreateVectorSplat(2, IRB.getInt8(2)); 495 Value *SP2 = IRB.CreateVectorSplat(2, Val); 496 497 Value *A = nullptr, *B = nullptr, *C = nullptr; 498 499 // Test matching insertelement 500 EXPECT_TRUE(match(VI1, m_InsertElement(m_Value(), m_Value(), m_Value()))); 501 EXPECT_TRUE( 502 match(VI1, m_InsertElement(m_Undef(), m_ConstantInt(), m_ConstantInt()))); 503 EXPECT_TRUE( 504 match(VI1, m_InsertElement(m_Undef(), m_ConstantInt(), m_Zero()))); 505 EXPECT_TRUE( 506 match(VI1, m_InsertElement(m_Undef(), m_SpecificInt(1), m_Zero()))); 507 EXPECT_TRUE(match(VI2, m_InsertElement(m_Value(), m_Value(), m_Value()))); 508 EXPECT_FALSE( 509 match(VI2, m_InsertElement(m_Value(), m_Value(), m_ConstantInt()))); 510 EXPECT_FALSE( 511 match(VI2, m_InsertElement(m_Value(), m_ConstantInt(), m_Value()))); 512 EXPECT_FALSE(match(VI2, m_InsertElement(m_Constant(), m_Value(), m_Value()))); 513 EXPECT_TRUE(match(VI3, m_InsertElement(m_Value(A), m_Value(B), m_Value(C)))); 514 EXPECT_TRUE(A == VI1); 515 EXPECT_TRUE(B == Val2); 516 EXPECT_TRUE(isa<ConstantInt>(C)); 517 A = B = C = nullptr; // reset 518 519 // Test matching extractelement 520 EXPECT_TRUE(match(EX1, m_ExtractElement(m_Value(A), m_Value(B)))); 521 EXPECT_TRUE(A == VI4); 522 EXPECT_TRUE(B == Val); 523 A = B = C = nullptr; // reset 524 EXPECT_FALSE(match(EX1, m_ExtractElement(m_Value(), m_ConstantInt()))); 525 EXPECT_TRUE(match(EX2, m_ExtractElement(m_Value(), m_ConstantInt()))); 526 EXPECT_TRUE(match(EX3, m_ExtractElement(m_Constant(), m_ConstantInt()))); 527 528 // Test matching shufflevector 529 EXPECT_TRUE(match(SI1, m_ShuffleVector(m_Value(), m_Undef(), m_Zero()))); 530 EXPECT_TRUE(match(SI2, m_ShuffleVector(m_Value(A), m_Value(B), m_Value(C)))); 531 EXPECT_TRUE(A == VI3); 532 EXPECT_TRUE(B == VI4); 533 EXPECT_TRUE(C == IdxVec); 534 A = B = C = nullptr; // reset 535 536 // Test matching the vector splat pattern 537 EXPECT_TRUE(match( 538 SI1, 539 m_ShuffleVector(m_InsertElement(m_Undef(), m_SpecificInt(1), m_Zero()), 540 m_Undef(), m_Zero()))); 541 EXPECT_FALSE(match( 542 SI3, m_ShuffleVector(m_InsertElement(m_Undef(), m_Value(), m_Zero()), 543 m_Undef(), m_Zero()))); 544 EXPECT_FALSE(match( 545 SI4, m_ShuffleVector(m_InsertElement(m_Undef(), m_Value(), m_Zero()), 546 m_Undef(), m_Zero()))); 547 EXPECT_TRUE(match( 548 SP1, 549 m_ShuffleVector(m_InsertElement(m_Undef(), m_SpecificInt(2), m_Zero()), 550 m_Undef(), m_Zero()))); 551 EXPECT_TRUE(match( 552 SP2, m_ShuffleVector(m_InsertElement(m_Undef(), m_Value(A), m_Zero()), 553 m_Undef(), m_Zero()))); 554 EXPECT_TRUE(A == Val); 555 } 556 557 TEST_F(PatternMatchTest, VectorUndefInt) { 558 Type *ScalarTy = IRB.getInt8Ty(); 559 Type *VectorTy = VectorType::get(ScalarTy, 4); 560 Constant *ScalarUndef = UndefValue::get(ScalarTy); 561 Constant *VectorUndef = UndefValue::get(VectorTy); 562 Constant *ScalarZero = Constant::getNullValue(ScalarTy); 563 Constant *VectorZero = Constant::getNullValue(VectorTy); 564 565 SmallVector<Constant *, 4> Elems; 566 Elems.push_back(ScalarUndef); 567 Elems.push_back(ScalarZero); 568 Elems.push_back(ScalarUndef); 569 Elems.push_back(ScalarZero); 570 Constant *VectorZeroUndef = ConstantVector::get(Elems); 571 572 EXPECT_TRUE(match(ScalarUndef, m_Undef())); 573 EXPECT_TRUE(match(VectorUndef, m_Undef())); 574 EXPECT_FALSE(match(ScalarZero, m_Undef())); 575 EXPECT_FALSE(match(VectorZero, m_Undef())); 576 EXPECT_FALSE(match(VectorZeroUndef, m_Undef())); 577 578 EXPECT_FALSE(match(ScalarUndef, m_Zero())); 579 EXPECT_FALSE(match(VectorUndef, m_Zero())); 580 EXPECT_TRUE(match(ScalarZero, m_Zero())); 581 EXPECT_TRUE(match(VectorZero, m_Zero())); 582 EXPECT_TRUE(match(VectorZeroUndef, m_Zero())); 583 } 584 585 TEST_F(PatternMatchTest, VectorUndefFloat) { 586 Type *ScalarTy = IRB.getFloatTy(); 587 Type *VectorTy = VectorType::get(ScalarTy, 4); 588 Constant *ScalarUndef = UndefValue::get(ScalarTy); 589 Constant *VectorUndef = UndefValue::get(VectorTy); 590 Constant *ScalarZero = Constant::getNullValue(ScalarTy); 591 Constant *VectorZero = Constant::getNullValue(VectorTy); 592 593 SmallVector<Constant *, 4> Elems; 594 Elems.push_back(ScalarUndef); 595 Elems.push_back(ScalarZero); 596 Elems.push_back(ScalarUndef); 597 Elems.push_back(ScalarZero); 598 Constant *VectorZeroUndef = ConstantVector::get(Elems); 599 600 EXPECT_TRUE(match(ScalarUndef, m_Undef())); 601 EXPECT_TRUE(match(VectorUndef, m_Undef())); 602 EXPECT_FALSE(match(ScalarZero, m_Undef())); 603 EXPECT_FALSE(match(VectorZero, m_Undef())); 604 EXPECT_FALSE(match(VectorZeroUndef, m_Undef())); 605 606 EXPECT_FALSE(match(ScalarUndef, m_AnyZeroFP())); 607 EXPECT_FALSE(match(VectorUndef, m_AnyZeroFP())); 608 EXPECT_TRUE(match(ScalarZero, m_AnyZeroFP())); 609 EXPECT_TRUE(match(VectorZero, m_AnyZeroFP())); 610 EXPECT_TRUE(match(VectorZeroUndef, m_AnyZeroFP())); 611 } 612 613 TEST_F(PatternMatchTest, FloatingPointFNeg) { 614 Type *FltTy = IRB.getFloatTy(); 615 Value *One = ConstantFP::get(FltTy, 1.0); 616 Value *Z = ConstantFP::get(FltTy, 0.0); 617 Value *NZ = ConstantFP::get(FltTy, -0.0); 618 Value *V = IRB.CreateFNeg(One); 619 Value *V1 = IRB.CreateFSub(NZ, One); 620 Value *V2 = IRB.CreateFSub(Z, One); 621 Value *V3 = IRB.CreateFAdd(NZ, One); 622 Value *Match; 623 624 // Test FNeg(1.0) 625 EXPECT_TRUE(match(V, m_FNeg(m_Value(Match)))); 626 EXPECT_EQ(One, Match); 627 628 // Test FSub(-0.0, 1.0) 629 EXPECT_TRUE(match(V1, m_FNeg(m_Value(Match)))); 630 EXPECT_EQ(One, Match); 631 632 // Test FSub(0.0, 1.0) 633 EXPECT_FALSE(match(V2, m_FNeg(m_Value(Match)))); 634 cast<Instruction>(V2)->setHasNoSignedZeros(true); 635 EXPECT_TRUE(match(V2, m_FNeg(m_Value(Match)))); 636 EXPECT_EQ(One, Match); 637 638 // Test FAdd(-0.0, 1.0) 639 EXPECT_FALSE(match(V3, m_FNeg(m_Value(Match)))); 640 } 641 642 template <typename T> struct MutableConstTest : PatternMatchTest { }; 643 644 typedef ::testing::Types<std::tuple<Value*, Instruction*>, 645 std::tuple<const Value*, const Instruction *>> 646 MutableConstTestTypes; 647 TYPED_TEST_CASE(MutableConstTest, MutableConstTestTypes); 648 649 TYPED_TEST(MutableConstTest, ICmp) { 650 auto &IRB = PatternMatchTest::IRB; 651 652 typedef typename std::tuple_element<0, TypeParam>::type ValueType; 653 typedef typename std::tuple_element<1, TypeParam>::type InstructionType; 654 655 Value *L = IRB.getInt32(1); 656 Value *R = IRB.getInt32(2); 657 ICmpInst::Predicate Pred = ICmpInst::ICMP_UGT; 658 659 ValueType MatchL; 660 ValueType MatchR; 661 ICmpInst::Predicate MatchPred; 662 663 EXPECT_TRUE(m_ICmp(MatchPred, m_Value(MatchL), m_Value(MatchR)) 664 .match((InstructionType)IRB.CreateICmp(Pred, L, R))); 665 EXPECT_EQ(L, MatchL); 666 EXPECT_EQ(R, MatchR); 667 } 668 669 } // anonymous namespace. 670