unittests/IR/PatternMatch.cpp

   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, FloatingPointOrderedMin) {
  69   Type *FltTy = IRB.getFloatTy();
  70   Value *L = ConstantFP::get(FltTy, 1.0);
  71   Value *R = ConstantFP::get(FltTy, 2.0);
  72   Value *MatchL, *MatchR;
  73
  74   // Test OLT.
  75   EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
  76                   .match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), L, R)));
  77   EXPECT_EQ(L, MatchL);
  78   EXPECT_EQ(R, MatchR);
  79
  80   // Test OLE.
  81   EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
  82                   .match(IRB.CreateSelect(IRB.CreateFCmpOLE(L, R), L, R)));
  83   EXPECT_EQ(L, MatchL);
  84   EXPECT_EQ(R, MatchR);
  85
  86   // Test no match on OGE.
  87   EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
  88                    .match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), L, R)));
  89
  90   // Test no match on OGT.
  91   EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
  92                    .match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), L, R)));
  93
  94   // Test inverted selects. Note, that this "inverts" the ordering, e.g.:
  95   // %cmp = fcmp oge L, R
  96   // %min = select %cmp R, L
  97   // Given L == NaN
  98   // the above is expanded to %cmp == false ==> %min = L
  99   // which is true for UnordFMin, not OrdFMin, so test that:
 100
 101   // [OU]GE with inverted select.
 102   EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
 103                   .match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), R, L)));
 104   EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
 105                   .match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), R, L)));
 106   EXPECT_EQ(L, MatchL);
 107   EXPECT_EQ(R, MatchR);
 108
 109   // [OU]GT with inverted select.
 110   EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
 111                   .match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), R, L)));
 112   EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
 113                   .match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), R, L)));
 114   EXPECT_EQ(L, MatchL);
 115   EXPECT_EQ(R, MatchR);
 116 }
 117
 118 TEST_F(PatternMatchTest, FloatingPointOrderedMax) {
 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 OGT.
 125   EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
 126                   .match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), L, R)));
 127   EXPECT_EQ(L, MatchL);
 128   EXPECT_EQ(R, MatchR);
 129
 130   // Test OGE.
 131   EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
 132                   .match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), L, R)));
 133   EXPECT_EQ(L, MatchL);
 134   EXPECT_EQ(R, MatchR);
 135
 136   // Test no match on OLE.
 137   EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
 138                    .match(IRB.CreateSelect(IRB.CreateFCmpOLE(L, R), L, R)));
 139
 140   // Test no match on OLT.
 141   EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
 142                    .match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), L, R)));
 143
 144
 145   // Test inverted selects. Note, that this "inverts" the ordering, e.g.:
 146   // %cmp = fcmp ole L, R
 147   // %max = select %cmp, R, L
 148   // Given L == NaN,
 149   // the above is expanded to %cmp == false ==> %max == L
 150   // which is true for UnordFMax, not OrdFMax, so test that:
 151
 152   // [OU]LE with inverted select.
 153   EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
 154                    .match(IRB.CreateSelect(IRB.CreateFCmpOLE(L, R), R, L)));
 155   EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
 156                   .match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), R, L)));
 157   EXPECT_EQ(L, MatchL);
 158   EXPECT_EQ(R, MatchR);
 159
 160   // [OUT]LT with inverted select.
 161   EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
 162                    .match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), R, L)));
 163   EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
 164                   .match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), R, L)));
 165   EXPECT_EQ(L, MatchL);
 166   EXPECT_EQ(R, MatchR);
 167 }
 168
 169 TEST_F(PatternMatchTest, FloatingPointUnorderedMin) {
 170   Type *FltTy = IRB.getFloatTy();
 171   Value *L = ConstantFP::get(FltTy, 1.0);
 172   Value *R = ConstantFP::get(FltTy, 2.0);
 173   Value *MatchL, *MatchR;
 174
 175   // Test ULT.
 176   EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
 177                   .match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), L, R)));
 178   EXPECT_EQ(L, MatchL);
 179   EXPECT_EQ(R, MatchR);
 180
 181   // Test ULE.
 182   EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
 183                   .match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), L, R)));
 184   EXPECT_EQ(L, MatchL);
 185   EXPECT_EQ(R, MatchR);
 186
 187   // Test no match on UGE.
 188   EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
 189                    .match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), L, R)));
 190
 191   // Test no match on UGT.
 192   EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
 193                    .match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), L, R)));
 194
 195   // Test inverted selects. Note, that this "inverts" the ordering, e.g.:
 196   // %cmp = fcmp uge L, R
 197   // %min = select %cmp R, L
 198   // Given L == NaN
 199   // the above is expanded to %cmp == true ==> %min = R
 200   // which is true for OrdFMin, not UnordFMin, so test that:
 201
 202   // [UO]GE with inverted select.
 203   EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
 204                   .match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), R, L)));
 205   EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
 206                   .match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), R, L)));
 207   EXPECT_EQ(L, MatchL);
 208   EXPECT_EQ(R, MatchR);
 209
 210   // [UO]GT with inverted select.
 211   EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
 212                   .match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), R, L)));
 213   EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
 214                   .match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), R, L)));
 215   EXPECT_EQ(L, MatchL);
 216   EXPECT_EQ(R, MatchR);
 217 }
 218
 219 TEST_F(PatternMatchTest, FloatingPointUnorderedMax) {
 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 UGT.
 226   EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
 227                   .match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), L, R)));
 228   EXPECT_EQ(L, MatchL);
 229   EXPECT_EQ(R, MatchR);
 230
 231   // Test UGE.
 232   EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
 233                   .match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), L, R)));
 234   EXPECT_EQ(L, MatchL);
 235   EXPECT_EQ(R, MatchR);
 236
 237   // Test no match on ULE.
 238   EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
 239                    .match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), L, R)));
 240
 241   // Test no match on ULT.
 242   EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
 243                    .match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), L, R)));
 244
 245   // Test inverted selects. Note, that this "inverts" the ordering, e.g.:
 246   // %cmp = fcmp ule L, R
 247   // %max = select %cmp R, L
 248   // Given L == NaN
 249   // the above is expanded to %cmp == true ==> %max = R
 250   // which is true for OrdFMax, not UnordFMax, so test that:
 251
 252   // [UO]LE with inverted select.
 253   EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
 254                   .match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), R, L)));
 255   EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
 256                   .match(IRB.CreateSelect(IRB.CreateFCmpOLE(L, R), R, L)));
 257   EXPECT_EQ(L, MatchL);
 258   EXPECT_EQ(R, MatchR);
 259
 260   // [UO]LT with inverted select.
 261   EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
 262                   .match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), R, L)));
 263   EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
 264                   .match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), R, L)));
 265   EXPECT_EQ(L, MatchL);
 266   EXPECT_EQ(R, MatchR);
 267 }
 268
 269 TEST_F(PatternMatchTest, OverflowingBinOps) {
 270   Value *L = IRB.getInt32(1);
 271   Value *R = IRB.getInt32(2);
 272   Value *MatchL, *MatchR;
 273
 274   EXPECT_TRUE(
 275       m_NSWAdd(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNSWAdd(L, R)));
 276   EXPECT_EQ(L, MatchL);
 277   EXPECT_EQ(R, MatchR);
 278   MatchL = MatchR = nullptr;
 279   EXPECT_TRUE(
 280       m_NSWSub(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNSWSub(L, R)));
 281   EXPECT_EQ(L, MatchL);
 282   EXPECT_EQ(R, MatchR);
 283   MatchL = MatchR = nullptr;
 284   EXPECT_TRUE(
 285       m_NSWMul(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNSWMul(L, R)));
 286   EXPECT_EQ(L, MatchL);
 287   EXPECT_EQ(R, MatchR);
 288   MatchL = MatchR = nullptr;
 289   EXPECT_TRUE(m_NSWShl(m_Value(MatchL), m_Value(MatchR)).match(
 290       IRB.CreateShl(L, R, "", /* NUW */ false, /* NSW */ true)));
 291   EXPECT_EQ(L, MatchL);
 292   EXPECT_EQ(R, MatchR);
 293
 294   EXPECT_TRUE(
 295       m_NUWAdd(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNUWAdd(L, R)));
 296   EXPECT_EQ(L, MatchL);
 297   EXPECT_EQ(R, MatchR);
 298   MatchL = MatchR = nullptr;
 299   EXPECT_TRUE(
 300       m_NUWSub(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNUWSub(L, R)));
 301   EXPECT_EQ(L, MatchL);
 302   EXPECT_EQ(R, MatchR);
 303   MatchL = MatchR = nullptr;
 304   EXPECT_TRUE(
 305       m_NUWMul(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNUWMul(L, R)));
 306   EXPECT_EQ(L, MatchL);
 307   EXPECT_EQ(R, MatchR);
 308   MatchL = MatchR = nullptr;
 309   EXPECT_TRUE(m_NUWShl(m_Value(MatchL), m_Value(MatchR)).match(
 310       IRB.CreateShl(L, R, "", /* NUW */ true, /* NSW */ false)));
 311   EXPECT_EQ(L, MatchL);
 312   EXPECT_EQ(R, MatchR);
 313
 314   EXPECT_FALSE(m_NSWAdd(m_Value(), m_Value()).match(IRB.CreateAdd(L, R)));
 315   EXPECT_FALSE(m_NSWAdd(m_Value(), m_Value()).match(IRB.CreateNUWAdd(L, R)));
 316   EXPECT_FALSE(m_NSWAdd(m_Value(), m_Value()).match(IRB.CreateNSWSub(L, R)));
 317   EXPECT_FALSE(m_NSWSub(m_Value(), m_Value()).match(IRB.CreateSub(L, R)));
 318   EXPECT_FALSE(m_NSWSub(m_Value(), m_Value()).match(IRB.CreateNUWSub(L, R)));
 319   EXPECT_FALSE(m_NSWSub(m_Value(), m_Value()).match(IRB.CreateNSWAdd(L, R)));
 320   EXPECT_FALSE(m_NSWMul(m_Value(), m_Value()).match(IRB.CreateMul(L, R)));
 321   EXPECT_FALSE(m_NSWMul(m_Value(), m_Value()).match(IRB.CreateNUWMul(L, R)));
 322   EXPECT_FALSE(m_NSWMul(m_Value(), m_Value()).match(IRB.CreateNSWAdd(L, R)));
 323   EXPECT_FALSE(m_NSWShl(m_Value(), m_Value()).match(IRB.CreateShl(L, R)));
 324   EXPECT_FALSE(m_NSWShl(m_Value(), m_Value()).match(
 325       IRB.CreateShl(L, R, "", /* NUW */ true, /* NSW */ false)));
 326   EXPECT_FALSE(m_NSWShl(m_Value(), m_Value()).match(IRB.CreateNSWAdd(L, R)));
 327
 328   EXPECT_FALSE(m_NUWAdd(m_Value(), m_Value()).match(IRB.CreateAdd(L, R)));
 329   EXPECT_FALSE(m_NUWAdd(m_Value(), m_Value()).match(IRB.CreateNSWAdd(L, R)));
 330   EXPECT_FALSE(m_NUWAdd(m_Value(), m_Value()).match(IRB.CreateNUWSub(L, R)));
 331   EXPECT_FALSE(m_NUWSub(m_Value(), m_Value()).match(IRB.CreateSub(L, R)));
 332   EXPECT_FALSE(m_NUWSub(m_Value(), m_Value()).match(IRB.CreateNSWSub(L, R)));
 333   EXPECT_FALSE(m_NUWSub(m_Value(), m_Value()).match(IRB.CreateNUWAdd(L, R)));
 334   EXPECT_FALSE(m_NUWMul(m_Value(), m_Value()).match(IRB.CreateMul(L, R)));
 335   EXPECT_FALSE(m_NUWMul(m_Value(), m_Value()).match(IRB.CreateNSWMul(L, R)));
 336   EXPECT_FALSE(m_NUWMul(m_Value(), m_Value()).match(IRB.CreateNUWAdd(L, R)));
 337   EXPECT_FALSE(m_NUWShl(m_Value(), m_Value()).match(IRB.CreateShl(L, R)));
 338   EXPECT_FALSE(m_NUWShl(m_Value(), m_Value()).match(
 339       IRB.CreateShl(L, R, "", /* NUW */ false, /* NSW */ true)));
 340   EXPECT_FALSE(m_NUWShl(m_Value(), m_Value()).match(IRB.CreateNUWAdd(L, R)));
 341 }
 342
 343 template <typename T> struct MutableConstTest : PatternMatchTest { };
 344
 345 typedef ::testing::Types<std::tuple<Value*, Instruction*>,
 346                          std::tuple<const Value*, const Instruction *>>
 347     MutableConstTestTypes;
 348 TYPED_TEST_CASE(MutableConstTest, MutableConstTestTypes);
 349
 350 TYPED_TEST(MutableConstTest, ICmp) {
 351   auto &IRB = PatternMatchTest::IRB;
 352
 353   typedef typename std::tuple_element<0, TypeParam>::type ValueType;
 354   typedef typename std::tuple_element<1, TypeParam>::type InstructionType;
 355
 356   Value *L = IRB.getInt32(1);
 357   Value *R = IRB.getInt32(2);
 358   ICmpInst::Predicate Pred = ICmpInst::ICMP_UGT;
 359
 360   ValueType MatchL;
 361   ValueType MatchR;
 362   ICmpInst::Predicate MatchPred;
 363
 364   EXPECT_TRUE(m_ICmp(MatchPred, m_Value(MatchL), m_Value(MatchR))
 365               .match((InstructionType)IRB.CreateICmp(Pred, L, R)));
 366   EXPECT_EQ(L, MatchL);
 367   EXPECT_EQ(R, MatchR);
 368 }
 369
 370 } // anonymous namespace.