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/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/Operator.h"
  23 #include "llvm/IR/Type.h"
  24 #include "llvm/Support/NoFolder.h"
  25 #include "llvm/Support/PatternMatch.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   OwningPtr<Module> M;
  36   Function *F;
  37   BasicBlock *BB;
  38   IRBuilder<true, 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, FloatingPointOrderedMin) {
  49   Type *FltTy = IRB.getFloatTy();
  50   Value *L = ConstantFP::get(FltTy, 1.0);
  51   Value *R = ConstantFP::get(FltTy, 2.0);
  52   Value *MatchL, *MatchR;
  53
  54   // Test OLT.
  55   EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
  56                   .match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), L, R)));
  57   EXPECT_EQ(L, MatchL);
  58   EXPECT_EQ(R, MatchR);
  59
  60   // Test OLE.
  61   EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
  62                   .match(IRB.CreateSelect(IRB.CreateFCmpOLE(L, R), L, R)));
  63   EXPECT_EQ(L, MatchL);
  64   EXPECT_EQ(R, MatchR);
  65
  66   // Test no match on OGE.
  67   EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
  68                    .match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), L, R)));
  69
  70   // Test no match on OGT.
  71   EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
  72                    .match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), L, R)));
  73
  74   // Test match on OGE with inverted select.
  75   EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
  76                   .match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), R, L)));
  77   EXPECT_EQ(L, MatchL);
  78   EXPECT_EQ(R, MatchR);
  79
  80   // Test match on OGT with inverted select.
  81   EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
  82                   .match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), R, L)));
  83   EXPECT_EQ(L, MatchL);
  84   EXPECT_EQ(R, MatchR);
  85 }
  86
  87 TEST_F(PatternMatchTest, FloatingPointOrderedMax) {
  88   Type *FltTy = IRB.getFloatTy();
  89   Value *L = ConstantFP::get(FltTy, 1.0);
  90   Value *R = ConstantFP::get(FltTy, 2.0);
  91   Value *MatchL, *MatchR;
  92
  93   // Test OGT.
  94   EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
  95                   .match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), L, R)));
  96   EXPECT_EQ(L, MatchL);
  97   EXPECT_EQ(R, MatchR);
  98
  99   // Test OGE.
 100   EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
 101                   .match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), L, R)));
 102   EXPECT_EQ(L, MatchL);
 103   EXPECT_EQ(R, MatchR);
 104
 105   // Test no match on OLE.
 106   EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
 107                    .match(IRB.CreateSelect(IRB.CreateFCmpOLE(L, R), L, R)));
 108
 109   // Test no match on OLT.
 110   EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
 111                    .match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), L, R)));
 112
 113   // Test match on OLE with inverted select.
 114   EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
 115                   .match(IRB.CreateSelect(IRB.CreateFCmpOLE(L, R), R, L)));
 116   EXPECT_EQ(L, MatchL);
 117   EXPECT_EQ(R, MatchR);
 118
 119   // Test match on OLT with inverted select.
 120   EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
 121                   .match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), R, L)));
 122   EXPECT_EQ(L, MatchL);
 123   EXPECT_EQ(R, MatchR);
 124 }
 125
 126 TEST_F(PatternMatchTest, FloatingPointUnorderedMin) {
 127   Type *FltTy = IRB.getFloatTy();
 128   Value *L = ConstantFP::get(FltTy, 1.0);
 129   Value *R = ConstantFP::get(FltTy, 2.0);
 130   Value *MatchL, *MatchR;
 131
 132   // Test ULT.
 133   EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
 134                   .match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), L, R)));
 135   EXPECT_EQ(L, MatchL);
 136   EXPECT_EQ(R, MatchR);
 137
 138   // Test ULE.
 139   EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
 140                   .match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), L, R)));
 141   EXPECT_EQ(L, MatchL);
 142   EXPECT_EQ(R, MatchR);
 143
 144   // Test no match on UGE.
 145   EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
 146                    .match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), L, R)));
 147
 148   // Test no match on UGT.
 149   EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
 150                    .match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), L, R)));
 151
 152   // Test match on UGE with inverted select.
 153   EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
 154                   .match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), R, L)));
 155   EXPECT_EQ(L, MatchL);
 156   EXPECT_EQ(R, MatchR);
 157
 158   // Test match on UGT with inverted select.
 159   EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
 160                   .match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), R, L)));
 161   EXPECT_EQ(L, MatchL);
 162   EXPECT_EQ(R, MatchR);
 163 }
 164
 165 TEST_F(PatternMatchTest, FloatingPointUnorderedMax) {
 166   Type *FltTy = IRB.getFloatTy();
 167   Value *L = ConstantFP::get(FltTy, 1.0);
 168   Value *R = ConstantFP::get(FltTy, 2.0);
 169   Value *MatchL, *MatchR;
 170
 171   // Test UGT.
 172   EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
 173                   .match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), L, R)));
 174   EXPECT_EQ(L, MatchL);
 175   EXPECT_EQ(R, MatchR);
 176
 177   // Test UGE.
 178   EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
 179                   .match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), L, R)));
 180   EXPECT_EQ(L, MatchL);
 181   EXPECT_EQ(R, MatchR);
 182
 183   // Test no match on ULE.
 184   EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
 185                    .match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), L, R)));
 186
 187   // Test no match on ULT.
 188   EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
 189                    .match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), L, R)));
 190
 191   // Test match on ULE with inverted select.
 192   EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
 193                   .match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), R, L)));
 194   EXPECT_EQ(L, MatchL);
 195   EXPECT_EQ(R, MatchR);
 196
 197   // Test match on ULT with inverted select.
 198   EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
 199                   .match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), R, L)));
 200   EXPECT_EQ(L, MatchL);
 201   EXPECT_EQ(R, MatchR);
 202 }
 203
 204 } // anonymous namespace.