1 //===---- llvm/unittest/IR/PatternMatch.cpp - PatternMatch unit tests ----===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "llvm/IR/PatternMatch.h" 11 #include "llvm/ADT/STLExtras.h" 12 #include "llvm/Analysis/ValueTracking.h" 13 #include "llvm/IR/BasicBlock.h" 14 #include "llvm/IR/Constants.h" 15 #include "llvm/IR/DataLayout.h" 16 #include "llvm/IR/DerivedTypes.h" 17 #include "llvm/IR/Function.h" 18 #include "llvm/IR/IRBuilder.h" 19 #include "llvm/IR/Instructions.h" 20 #include "llvm/IR/LLVMContext.h" 21 #include "llvm/IR/MDBuilder.h" 22 #include "llvm/IR/Module.h" 23 #include "llvm/IR/NoFolder.h" 24 #include "llvm/IR/Operator.h" 25 #include "llvm/IR/Type.h" 26 #include "gtest/gtest.h" 27 28 using namespace llvm; 29 using namespace llvm::PatternMatch; 30 31 namespace { 32 33 struct PatternMatchTest : ::testing::Test { 34 LLVMContext Ctx; 35 std::unique_ptr<Module> M; 36 Function *F; 37 BasicBlock *BB; 38 IRBuilder<NoFolder> IRB; 39 40 PatternMatchTest() 41 : M(new Module("PatternMatchTestModule", Ctx)), 42 F(Function::Create( 43 FunctionType::get(Type::getVoidTy(Ctx), /* IsVarArg */ false), 44 Function::ExternalLinkage, "f", M.get())), 45 BB(BasicBlock::Create(Ctx, "entry", F)), IRB(BB) {} 46 }; 47 48 TEST_F(PatternMatchTest, OneUse) { 49 // Build up a little tree of values: 50 // 51 // One = (1 + 2) + 42 52 // Two = One + 42 53 // Leaf = (Two + 8) + (Two + 13) 54 Value *One = IRB.CreateAdd(IRB.CreateAdd(IRB.getInt32(1), IRB.getInt32(2)), 55 IRB.getInt32(42)); 56 Value *Two = IRB.CreateAdd(One, IRB.getInt32(42)); 57 Value *Leaf = IRB.CreateAdd(IRB.CreateAdd(Two, IRB.getInt32(8)), 58 IRB.CreateAdd(Two, IRB.getInt32(13))); 59 Value *V; 60 61 EXPECT_TRUE(m_OneUse(m_Value(V)).match(One)); 62 EXPECT_EQ(One, V); 63 64 EXPECT_FALSE(m_OneUse(m_Value()).match(Two)); 65 EXPECT_FALSE(m_OneUse(m_Value()).match(Leaf)); 66 } 67 68 TEST_F(PatternMatchTest, CommutativeDeferredValue) { 69 Value *X = IRB.getInt32(1); 70 Value *Y = IRB.getInt32(2); 71 72 { 73 Value *tX = X; 74 EXPECT_TRUE(match(X, m_Deferred(tX))); 75 EXPECT_FALSE(match(Y, m_Deferred(tX))); 76 } 77 { 78 const Value *tX = X; 79 EXPECT_TRUE(match(X, m_Deferred(tX))); 80 EXPECT_FALSE(match(Y, m_Deferred(tX))); 81 } 82 { 83 Value *const tX = X; 84 EXPECT_TRUE(match(X, m_Deferred(tX))); 85 EXPECT_FALSE(match(Y, m_Deferred(tX))); 86 } 87 { 88 const Value *const tX = X; 89 EXPECT_TRUE(match(X, m_Deferred(tX))); 90 EXPECT_FALSE(match(Y, m_Deferred(tX))); 91 } 92 93 { 94 Value *tX = nullptr; 95 EXPECT_TRUE(match(IRB.CreateAnd(X, X), m_And(m_Value(tX), m_Deferred(tX)))); 96 EXPECT_EQ(tX, X); 97 } 98 { 99 Value *tX = nullptr; 100 EXPECT_FALSE( 101 match(IRB.CreateAnd(X, Y), m_c_And(m_Value(tX), m_Deferred(tX)))); 102 } 103 104 auto checkMatch = [X, Y](Value *Pattern) { 105 Value *tX = nullptr, *tY = nullptr; 106 EXPECT_TRUE(match( 107 Pattern, m_c_And(m_Value(tX), m_c_And(m_Deferred(tX), m_Value(tY))))); 108 EXPECT_EQ(tX, X); 109 EXPECT_EQ(tY, Y); 110 }; 111 112 checkMatch(IRB.CreateAnd(X, IRB.CreateAnd(X, Y))); 113 checkMatch(IRB.CreateAnd(X, IRB.CreateAnd(Y, X))); 114 checkMatch(IRB.CreateAnd(IRB.CreateAnd(X, Y), X)); 115 checkMatch(IRB.CreateAnd(IRB.CreateAnd(Y, X), X)); 116 } 117 118 TEST_F(PatternMatchTest, FloatingPointOrderedMin) { 119 Type *FltTy = IRB.getFloatTy(); 120 Value *L = ConstantFP::get(FltTy, 1.0); 121 Value *R = ConstantFP::get(FltTy, 2.0); 122 Value *MatchL, *MatchR; 123 124 // Test OLT. 125 EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR)) 126 .match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), L, R))); 127 EXPECT_EQ(L, MatchL); 128 EXPECT_EQ(R, MatchR); 129 130 // Test OLE. 131 EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR)) 132 .match(IRB.CreateSelect(IRB.CreateFCmpOLE(L, R), L, R))); 133 EXPECT_EQ(L, MatchL); 134 EXPECT_EQ(R, MatchR); 135 136 // Test no match on OGE. 137 EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR)) 138 .match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), L, R))); 139 140 // Test no match on OGT. 141 EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR)) 142 .match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), L, R))); 143 144 // Test inverted selects. Note, that this "inverts" the ordering, e.g.: 145 // %cmp = fcmp oge L, R 146 // %min = select %cmp R, L 147 // Given L == NaN 148 // the above is expanded to %cmp == false ==> %min = L 149 // which is true for UnordFMin, not OrdFMin, so test that: 150 151 // [OU]GE with inverted select. 152 EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR)) 153 .match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), R, L))); 154 EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR)) 155 .match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), R, L))); 156 EXPECT_EQ(L, MatchL); 157 EXPECT_EQ(R, MatchR); 158 159 // [OU]GT with inverted select. 160 EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR)) 161 .match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), R, L))); 162 EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR)) 163 .match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), R, L))); 164 EXPECT_EQ(L, MatchL); 165 EXPECT_EQ(R, MatchR); 166 } 167 168 TEST_F(PatternMatchTest, FloatingPointOrderedMax) { 169 Type *FltTy = IRB.getFloatTy(); 170 Value *L = ConstantFP::get(FltTy, 1.0); 171 Value *R = ConstantFP::get(FltTy, 2.0); 172 Value *MatchL, *MatchR; 173 174 // Test OGT. 175 EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR)) 176 .match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), L, R))); 177 EXPECT_EQ(L, MatchL); 178 EXPECT_EQ(R, MatchR); 179 180 // Test OGE. 181 EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR)) 182 .match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), L, R))); 183 EXPECT_EQ(L, MatchL); 184 EXPECT_EQ(R, MatchR); 185 186 // Test no match on OLE. 187 EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR)) 188 .match(IRB.CreateSelect(IRB.CreateFCmpOLE(L, R), L, R))); 189 190 // Test no match on OLT. 191 EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR)) 192 .match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), L, R))); 193 194 195 // Test inverted selects. Note, that this "inverts" the ordering, e.g.: 196 // %cmp = fcmp ole L, R 197 // %max = select %cmp, R, L 198 // Given L == NaN, 199 // the above is expanded to %cmp == false ==> %max == L 200 // which is true for UnordFMax, not OrdFMax, so test that: 201 202 // [OU]LE with inverted select. 203 EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR)) 204 .match(IRB.CreateSelect(IRB.CreateFCmpOLE(L, R), R, L))); 205 EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR)) 206 .match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), R, L))); 207 EXPECT_EQ(L, MatchL); 208 EXPECT_EQ(R, MatchR); 209 210 // [OUT]LT with inverted select. 211 EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR)) 212 .match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), R, L))); 213 EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR)) 214 .match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), R, L))); 215 EXPECT_EQ(L, MatchL); 216 EXPECT_EQ(R, MatchR); 217 } 218 219 TEST_F(PatternMatchTest, FloatingPointUnorderedMin) { 220 Type *FltTy = IRB.getFloatTy(); 221 Value *L = ConstantFP::get(FltTy, 1.0); 222 Value *R = ConstantFP::get(FltTy, 2.0); 223 Value *MatchL, *MatchR; 224 225 // Test ULT. 226 EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR)) 227 .match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), L, R))); 228 EXPECT_EQ(L, MatchL); 229 EXPECT_EQ(R, MatchR); 230 231 // Test ULE. 232 EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR)) 233 .match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), L, R))); 234 EXPECT_EQ(L, MatchL); 235 EXPECT_EQ(R, MatchR); 236 237 // Test no match on UGE. 238 EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR)) 239 .match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), L, R))); 240 241 // Test no match on UGT. 242 EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR)) 243 .match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), L, R))); 244 245 // Test inverted selects. Note, that this "inverts" the ordering, e.g.: 246 // %cmp = fcmp uge L, R 247 // %min = select %cmp R, L 248 // Given L == NaN 249 // the above is expanded to %cmp == true ==> %min = R 250 // which is true for OrdFMin, not UnordFMin, so test that: 251 252 // [UO]GE with inverted select. 253 EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR)) 254 .match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), R, L))); 255 EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR)) 256 .match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), R, L))); 257 EXPECT_EQ(L, MatchL); 258 EXPECT_EQ(R, MatchR); 259 260 // [UO]GT with inverted select. 261 EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR)) 262 .match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), R, L))); 263 EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR)) 264 .match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), R, L))); 265 EXPECT_EQ(L, MatchL); 266 EXPECT_EQ(R, MatchR); 267 } 268 269 TEST_F(PatternMatchTest, FloatingPointUnorderedMax) { 270 Type *FltTy = IRB.getFloatTy(); 271 Value *L = ConstantFP::get(FltTy, 1.0); 272 Value *R = ConstantFP::get(FltTy, 2.0); 273 Value *MatchL, *MatchR; 274 275 // Test UGT. 276 EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR)) 277 .match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), L, R))); 278 EXPECT_EQ(L, MatchL); 279 EXPECT_EQ(R, MatchR); 280 281 // Test UGE. 282 EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR)) 283 .match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), L, R))); 284 EXPECT_EQ(L, MatchL); 285 EXPECT_EQ(R, MatchR); 286 287 // Test no match on ULE. 288 EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR)) 289 .match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), L, R))); 290 291 // Test no match on ULT. 292 EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR)) 293 .match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), L, R))); 294 295 // Test inverted selects. Note, that this "inverts" the ordering, e.g.: 296 // %cmp = fcmp ule L, R 297 // %max = select %cmp R, L 298 // Given L == NaN 299 // the above is expanded to %cmp == true ==> %max = R 300 // which is true for OrdFMax, not UnordFMax, so test that: 301 302 // [UO]LE with inverted select. 303 EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR)) 304 .match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), R, L))); 305 EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR)) 306 .match(IRB.CreateSelect(IRB.CreateFCmpOLE(L, R), R, L))); 307 EXPECT_EQ(L, MatchL); 308 EXPECT_EQ(R, MatchR); 309 310 // [UO]LT with inverted select. 311 EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR)) 312 .match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), R, L))); 313 EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR)) 314 .match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), R, L))); 315 EXPECT_EQ(L, MatchL); 316 EXPECT_EQ(R, MatchR); 317 } 318 319 TEST_F(PatternMatchTest, OverflowingBinOps) { 320 Value *L = IRB.getInt32(1); 321 Value *R = IRB.getInt32(2); 322 Value *MatchL, *MatchR; 323 324 EXPECT_TRUE( 325 m_NSWAdd(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNSWAdd(L, R))); 326 EXPECT_EQ(L, MatchL); 327 EXPECT_EQ(R, MatchR); 328 MatchL = MatchR = nullptr; 329 EXPECT_TRUE( 330 m_NSWSub(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNSWSub(L, R))); 331 EXPECT_EQ(L, MatchL); 332 EXPECT_EQ(R, MatchR); 333 MatchL = MatchR = nullptr; 334 EXPECT_TRUE( 335 m_NSWMul(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNSWMul(L, R))); 336 EXPECT_EQ(L, MatchL); 337 EXPECT_EQ(R, MatchR); 338 MatchL = MatchR = nullptr; 339 EXPECT_TRUE(m_NSWShl(m_Value(MatchL), m_Value(MatchR)).match( 340 IRB.CreateShl(L, R, "", /* NUW */ false, /* NSW */ true))); 341 EXPECT_EQ(L, MatchL); 342 EXPECT_EQ(R, MatchR); 343 344 EXPECT_TRUE( 345 m_NUWAdd(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNUWAdd(L, R))); 346 EXPECT_EQ(L, MatchL); 347 EXPECT_EQ(R, MatchR); 348 MatchL = MatchR = nullptr; 349 EXPECT_TRUE( 350 m_NUWSub(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNUWSub(L, R))); 351 EXPECT_EQ(L, MatchL); 352 EXPECT_EQ(R, MatchR); 353 MatchL = MatchR = nullptr; 354 EXPECT_TRUE( 355 m_NUWMul(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNUWMul(L, R))); 356 EXPECT_EQ(L, MatchL); 357 EXPECT_EQ(R, MatchR); 358 MatchL = MatchR = nullptr; 359 EXPECT_TRUE(m_NUWShl(m_Value(MatchL), m_Value(MatchR)).match( 360 IRB.CreateShl(L, R, "", /* NUW */ true, /* NSW */ false))); 361 EXPECT_EQ(L, MatchL); 362 EXPECT_EQ(R, MatchR); 363 364 EXPECT_FALSE(m_NSWAdd(m_Value(), m_Value()).match(IRB.CreateAdd(L, R))); 365 EXPECT_FALSE(m_NSWAdd(m_Value(), m_Value()).match(IRB.CreateNUWAdd(L, R))); 366 EXPECT_FALSE(m_NSWAdd(m_Value(), m_Value()).match(IRB.CreateNSWSub(L, R))); 367 EXPECT_FALSE(m_NSWSub(m_Value(), m_Value()).match(IRB.CreateSub(L, R))); 368 EXPECT_FALSE(m_NSWSub(m_Value(), m_Value()).match(IRB.CreateNUWSub(L, R))); 369 EXPECT_FALSE(m_NSWSub(m_Value(), m_Value()).match(IRB.CreateNSWAdd(L, R))); 370 EXPECT_FALSE(m_NSWMul(m_Value(), m_Value()).match(IRB.CreateMul(L, R))); 371 EXPECT_FALSE(m_NSWMul(m_Value(), m_Value()).match(IRB.CreateNUWMul(L, R))); 372 EXPECT_FALSE(m_NSWMul(m_Value(), m_Value()).match(IRB.CreateNSWAdd(L, R))); 373 EXPECT_FALSE(m_NSWShl(m_Value(), m_Value()).match(IRB.CreateShl(L, R))); 374 EXPECT_FALSE(m_NSWShl(m_Value(), m_Value()).match( 375 IRB.CreateShl(L, R, "", /* NUW */ true, /* NSW */ false))); 376 EXPECT_FALSE(m_NSWShl(m_Value(), m_Value()).match(IRB.CreateNSWAdd(L, R))); 377 378 EXPECT_FALSE(m_NUWAdd(m_Value(), m_Value()).match(IRB.CreateAdd(L, R))); 379 EXPECT_FALSE(m_NUWAdd(m_Value(), m_Value()).match(IRB.CreateNSWAdd(L, R))); 380 EXPECT_FALSE(m_NUWAdd(m_Value(), m_Value()).match(IRB.CreateNUWSub(L, R))); 381 EXPECT_FALSE(m_NUWSub(m_Value(), m_Value()).match(IRB.CreateSub(L, R))); 382 EXPECT_FALSE(m_NUWSub(m_Value(), m_Value()).match(IRB.CreateNSWSub(L, R))); 383 EXPECT_FALSE(m_NUWSub(m_Value(), m_Value()).match(IRB.CreateNUWAdd(L, R))); 384 EXPECT_FALSE(m_NUWMul(m_Value(), m_Value()).match(IRB.CreateMul(L, R))); 385 EXPECT_FALSE(m_NUWMul(m_Value(), m_Value()).match(IRB.CreateNSWMul(L, R))); 386 EXPECT_FALSE(m_NUWMul(m_Value(), m_Value()).match(IRB.CreateNUWAdd(L, R))); 387 EXPECT_FALSE(m_NUWShl(m_Value(), m_Value()).match(IRB.CreateShl(L, R))); 388 EXPECT_FALSE(m_NUWShl(m_Value(), m_Value()).match( 389 IRB.CreateShl(L, R, "", /* NUW */ false, /* NSW */ true))); 390 EXPECT_FALSE(m_NUWShl(m_Value(), m_Value()).match(IRB.CreateNUWAdd(L, R))); 391 } 392 393 TEST_F(PatternMatchTest, LoadStoreOps) { 394 // Create this load/store sequence: 395 // 396 // %p = alloca i32* 397 // %0 = load i32*, i32** %p 398 // store i32 42, i32* %0 399 400 Value *Alloca = IRB.CreateAlloca(IRB.getInt32Ty()); 401 Value *LoadInst = IRB.CreateLoad(Alloca); 402 Value *FourtyTwo = IRB.getInt32(42); 403 Value *StoreInst = IRB.CreateStore(FourtyTwo, Alloca); 404 Value *MatchLoad, *MatchStoreVal, *MatchStorePointer; 405 406 EXPECT_TRUE(m_Load(m_Value(MatchLoad)).match(LoadInst)); 407 EXPECT_EQ(Alloca, MatchLoad); 408 409 EXPECT_TRUE(m_Load(m_Specific(Alloca)).match(LoadInst)); 410 411 EXPECT_FALSE(m_Load(m_Value(MatchLoad)).match(Alloca)); 412 413 EXPECT_TRUE(m_Store(m_Value(MatchStoreVal), m_Value(MatchStorePointer)) 414 .match(StoreInst)); 415 EXPECT_EQ(FourtyTwo, MatchStoreVal); 416 EXPECT_EQ(Alloca, MatchStorePointer); 417 418 EXPECT_FALSE(m_Store(m_Value(MatchStoreVal), m_Value(MatchStorePointer)) 419 .match(Alloca)); 420 421 EXPECT_TRUE(m_Store(m_SpecificInt(42), m_Specific(Alloca)) 422 .match(StoreInst)); 423 EXPECT_FALSE(m_Store(m_SpecificInt(42), m_Specific(FourtyTwo)) 424 .match(StoreInst)); 425 EXPECT_FALSE(m_Store(m_SpecificInt(43), m_Specific(Alloca)) 426 .match(StoreInst)); 427 } 428 429 TEST_F(PatternMatchTest, VectorOps) { 430 // Build up small tree of vector operations 431 // 432 // Val = 0 + 1 433 // Val2 = Val + 3 434 // VI1 = insertelement <2 x i8> undef, i8 1, i32 0 = <1, undef> 435 // VI2 = insertelement <2 x i8> %VI1, i8 %Val2, i8 %Val = <1, 4> 436 // VI3 = insertelement <2 x i8> %VI1, i8 %Val2, i32 1 = <1, 4> 437 // VI4 = insertelement <2 x i8> %VI1, i8 2, i8 %Val = <1, 2> 438 // 439 // SI1 = shufflevector <2 x i8> %VI1, <2 x i8> undef, zeroinitializer 440 // SI2 = shufflevector <2 x i8> %VI3, <2 x i8> %VI4, <2 x i8> <i8 0, i8 2> 441 // SI3 = shufflevector <2 x i8> %VI3, <2 x i8> undef, zeroinitializer 442 // SI4 = shufflevector <2 x i8> %VI4, <2 x i8> undef, zeroinitializer 443 // 444 // SP1 = VectorSplat(2, i8 2) 445 // SP2 = VectorSplat(2, i8 %Val) 446 Type *VecTy = VectorType::get(IRB.getInt8Ty(), 2); 447 Type *i32 = IRB.getInt32Ty(); 448 Type *i32VecTy = VectorType::get(i32, 2); 449 450 Value *Val = IRB.CreateAdd(IRB.getInt8(0), IRB.getInt8(1)); 451 Value *Val2 = IRB.CreateAdd(Val, IRB.getInt8(3)); 452 453 SmallVector<Constant *, 2> VecElemIdxs; 454 VecElemIdxs.push_back(ConstantInt::get(i32, 0)); 455 VecElemIdxs.push_back(ConstantInt::get(i32, 2)); 456 auto *IdxVec = ConstantVector::get(VecElemIdxs); 457 458 Value *UndefVec = UndefValue::get(VecTy); 459 Value *VI1 = IRB.CreateInsertElement(UndefVec, IRB.getInt8(1), (uint64_t)0); 460 Value *VI2 = IRB.CreateInsertElement(VI1, Val2, Val); 461 Value *VI3 = IRB.CreateInsertElement(VI1, Val2, (uint64_t)1); 462 Value *VI4 = IRB.CreateInsertElement(VI1, IRB.getInt8(2), Val); 463 464 Value *EX1 = IRB.CreateExtractElement(VI4, Val); 465 Value *EX2 = IRB.CreateExtractElement(VI4, (uint64_t)0); 466 Value *EX3 = IRB.CreateExtractElement(IdxVec, (uint64_t)1); 467 468 Value *Zero = ConstantAggregateZero::get(i32VecTy); 469 Value *SI1 = IRB.CreateShuffleVector(VI1, UndefVec, Zero); 470 Value *SI2 = IRB.CreateShuffleVector(VI3, VI4, IdxVec); 471 Value *SI3 = IRB.CreateShuffleVector(VI3, UndefVec, Zero); 472 Value *SI4 = IRB.CreateShuffleVector(VI4, UndefVec, Zero); 473 474 Value *SP1 = IRB.CreateVectorSplat(2, IRB.getInt8(2)); 475 Value *SP2 = IRB.CreateVectorSplat(2, Val); 476 477 Value *A = nullptr, *B = nullptr, *C = nullptr; 478 479 // Test matching insertelement 480 EXPECT_TRUE(match(VI1, m_InsertElement(m_Value(), m_Value(), m_Value()))); 481 EXPECT_TRUE( 482 match(VI1, m_InsertElement(m_Undef(), m_ConstantInt(), m_ConstantInt()))); 483 EXPECT_TRUE( 484 match(VI1, m_InsertElement(m_Undef(), m_ConstantInt(), m_Zero()))); 485 EXPECT_TRUE( 486 match(VI1, m_InsertElement(m_Undef(), m_SpecificInt(1), m_Zero()))); 487 EXPECT_TRUE(match(VI2, m_InsertElement(m_Value(), m_Value(), m_Value()))); 488 EXPECT_FALSE( 489 match(VI2, m_InsertElement(m_Value(), m_Value(), m_ConstantInt()))); 490 EXPECT_FALSE( 491 match(VI2, m_InsertElement(m_Value(), m_ConstantInt(), m_Value()))); 492 EXPECT_FALSE(match(VI2, m_InsertElement(m_Constant(), m_Value(), m_Value()))); 493 EXPECT_TRUE(match(VI3, m_InsertElement(m_Value(A), m_Value(B), m_Value(C)))); 494 EXPECT_TRUE(A == VI1); 495 EXPECT_TRUE(B == Val2); 496 EXPECT_TRUE(isa<ConstantInt>(C)); 497 A = B = C = nullptr; // reset 498 499 // Test matching extractelement 500 EXPECT_TRUE(match(EX1, m_ExtractElement(m_Value(A), m_Value(B)))); 501 EXPECT_TRUE(A == VI4); 502 EXPECT_TRUE(B == Val); 503 A = B = C = nullptr; // reset 504 EXPECT_FALSE(match(EX1, m_ExtractElement(m_Value(), m_ConstantInt()))); 505 EXPECT_TRUE(match(EX2, m_ExtractElement(m_Value(), m_ConstantInt()))); 506 EXPECT_TRUE(match(EX3, m_ExtractElement(m_Constant(), m_ConstantInt()))); 507 508 // Test matching shufflevector 509 EXPECT_TRUE(match(SI1, m_ShuffleVector(m_Value(), m_Undef(), m_Zero()))); 510 EXPECT_TRUE(match(SI2, m_ShuffleVector(m_Value(A), m_Value(B), m_Value(C)))); 511 EXPECT_TRUE(A == VI3); 512 EXPECT_TRUE(B == VI4); 513 EXPECT_TRUE(C == IdxVec); 514 A = B = C = nullptr; // reset 515 516 // Test matching the vector splat pattern 517 EXPECT_TRUE(match( 518 SI1, 519 m_ShuffleVector(m_InsertElement(m_Undef(), m_SpecificInt(1), m_Zero()), 520 m_Undef(), m_Zero()))); 521 EXPECT_FALSE(match( 522 SI3, m_ShuffleVector(m_InsertElement(m_Undef(), m_Value(), m_Zero()), 523 m_Undef(), m_Zero()))); 524 EXPECT_FALSE(match( 525 SI4, m_ShuffleVector(m_InsertElement(m_Undef(), m_Value(), m_Zero()), 526 m_Undef(), m_Zero()))); 527 EXPECT_TRUE(match( 528 SP1, 529 m_ShuffleVector(m_InsertElement(m_Undef(), m_SpecificInt(2), m_Zero()), 530 m_Undef(), m_Zero()))); 531 EXPECT_TRUE(match( 532 SP2, m_ShuffleVector(m_InsertElement(m_Undef(), m_Value(A), m_Zero()), 533 m_Undef(), m_Zero()))); 534 EXPECT_TRUE(A == Val); 535 } 536 537 template <typename T> struct MutableConstTest : PatternMatchTest { }; 538 539 typedef ::testing::Types<std::tuple<Value*, Instruction*>, 540 std::tuple<const Value*, const Instruction *>> 541 MutableConstTestTypes; 542 TYPED_TEST_CASE(MutableConstTest, MutableConstTestTypes); 543 544 TYPED_TEST(MutableConstTest, ICmp) { 545 auto &IRB = PatternMatchTest::IRB; 546 547 typedef typename std::tuple_element<0, TypeParam>::type ValueType; 548 typedef typename std::tuple_element<1, TypeParam>::type InstructionType; 549 550 Value *L = IRB.getInt32(1); 551 Value *R = IRB.getInt32(2); 552 ICmpInst::Predicate Pred = ICmpInst::ICMP_UGT; 553 554 ValueType MatchL; 555 ValueType MatchR; 556 ICmpInst::Predicate MatchPred; 557 558 EXPECT_TRUE(m_ICmp(MatchPred, m_Value(MatchL), m_Value(MatchR)) 559 .match((InstructionType)IRB.CreateICmp(Pred, L, R))); 560 EXPECT_EQ(L, MatchL); 561 EXPECT_EQ(R, MatchR); 562 } 563 564 } // anonymous namespace. 565