1 //===---- llvm/unittest/IR/PatternMatch.cpp - PatternMatch unit tests ----===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
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/Instructions.h"
17 #include "llvm/IR/IRBuilder.h"
18 #include "llvm/IR/LLVMContext.h"
19 #include "llvm/IR/MDBuilder.h"
20 #include "llvm/IR/Operator.h"
21 #include "llvm/Support/NoFolder.h"
22 #include "llvm/Support/PatternMatch.h"
23 #include "gtest/gtest.h"
25 using namespace llvm::PatternMatch;
30 /// Ordered floating point minimum/maximum tests.
32 static void m_OrdFMin_expect_match_and_delete(Value *Cmp, Value *Select,
34 Value *MatchL, *MatchR;
35 EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR)).match(Select));
42 static void m_OrdFMin_expect_nomatch_and_delete(Value *Cmp, Value *Select,
44 Value *MatchL, *MatchR;
45 EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR)).match(Select));
50 static void m_OrdFMax_expect_match_and_delete(Value *Cmp, Value *Select,
52 Value *MatchL, *MatchR;
53 EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR)).match(Select));
60 static void m_OrdFMax_expect_nomatch_and_delete(Value *Cmp, Value *Select,
62 Value *MatchL, *MatchR;
63 EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR)).match(Select));
70 TEST(PatternMatchTest, FloatingPointOrderedMin) {
71 LLVMContext &C(getGlobalContext());
72 IRBuilder<true, NoFolder> Builder(C);
74 Type *FltTy = Builder.getFloatTy();
75 Value *L = ConstantFP::get(FltTy, 1.0);
76 Value *R = ConstantFP::get(FltTy, 2.0);
79 Value *Cmp = Builder.CreateFCmpOLT(L, R);
80 Value *Select = Builder.CreateSelect(Cmp, L, R);
81 m_OrdFMin_expect_match_and_delete(Cmp, Select, L, R);
84 Cmp = Builder.CreateFCmpOLE(L, R);
85 Select = Builder.CreateSelect(Cmp, L, R);
86 m_OrdFMin_expect_match_and_delete(Cmp, Select, L, R);
88 // Test no match on OGE.
89 Cmp = Builder.CreateFCmpOGE(L, R);
90 Select = Builder.CreateSelect(Cmp, L, R);
91 m_OrdFMin_expect_nomatch_and_delete(Cmp, Select, L, R);
93 // Test no match on OGT.
94 Cmp = Builder.CreateFCmpOGT(L, R);
95 Select = Builder.CreateSelect(Cmp, L, R);
96 m_OrdFMin_expect_nomatch_and_delete(Cmp, Select, L, R);
98 // Test match on OGE with inverted select.
99 Cmp = Builder.CreateFCmpOGE(L, R);
100 Select = Builder.CreateSelect(Cmp, R, L);
101 m_OrdFMin_expect_match_and_delete(Cmp, Select, L, R);
103 // Test match on OGT with inverted select.
104 Cmp = Builder.CreateFCmpOGT(L, R);
105 Select = Builder.CreateSelect(Cmp, R, L);
106 m_OrdFMin_expect_match_and_delete(Cmp, Select, L, R);
109 TEST(PatternMatchTest, FloatingPointOrderedMax) {
110 LLVMContext &C(getGlobalContext());
111 IRBuilder<true, NoFolder> Builder(C);
113 Type *FltTy = Builder.getFloatTy();
114 Value *L = ConstantFP::get(FltTy, 1.0);
115 Value *R = ConstantFP::get(FltTy, 2.0);
118 Value *Cmp = Builder.CreateFCmpOGT(L, R);
119 Value *Select = Builder.CreateSelect(Cmp, L, R);
120 m_OrdFMax_expect_match_and_delete(Cmp, Select, L, R);
123 Cmp = Builder.CreateFCmpOGE(L, R);
124 Select = Builder.CreateSelect(Cmp, L, R);
125 m_OrdFMax_expect_match_and_delete(Cmp, Select, L, R);
127 // Test no match on OLE.
128 Cmp = Builder.CreateFCmpOLE(L, R);
129 Select = Builder.CreateSelect(Cmp, L, R);
130 m_OrdFMax_expect_nomatch_and_delete(Cmp, Select, L, R);
132 // Test no match on OLT.
133 Cmp = Builder.CreateFCmpOLT(L, R);
134 Select = Builder.CreateSelect(Cmp, L, R);
135 m_OrdFMax_expect_nomatch_and_delete(Cmp, Select, L, R);
137 // Test match on OLE with inverted select.
138 Cmp = Builder.CreateFCmpOLE(L, R);
139 Select = Builder.CreateSelect(Cmp, R, L);
140 m_OrdFMax_expect_match_and_delete(Cmp, Select, L, R);
142 // Test match on OLT with inverted select.
143 Cmp = Builder.CreateFCmpOLT(L, R);
144 Select = Builder.CreateSelect(Cmp, R, L);
145 m_OrdFMax_expect_match_and_delete(Cmp, Select, L, R);
148 /// Unordered floating point minimum/maximum tests.
150 static void m_UnordFMin_expect_match_and_delete(Value *Cmp, Value *Select,
151 Value *L, Value *R) {
152 Value *MatchL, *MatchR;
153 EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR)).match(Select));
154 EXPECT_EQ(L, MatchL);
155 EXPECT_EQ(R, MatchR);
160 static void m_UnordFMin_expect_nomatch_and_delete(Value *Cmp, Value *Select,
161 Value *L, Value *R) {
162 Value *MatchL, *MatchR;
163 EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR)).match(Select));
168 static void m_UnordFMax_expect_match_and_delete(Value *Cmp, Value *Select,
169 Value *L, Value *R) {
170 Value *MatchL, *MatchR;
171 EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR)).match(Select));
172 EXPECT_EQ(L, MatchL);
173 EXPECT_EQ(R, MatchR);
178 static void m_UnordFMax_expect_nomatch_and_delete(Value *Cmp, Value *Select,
179 Value *L, Value *R) {
180 Value *MatchL, *MatchR;
181 EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR)).match(Select));
186 TEST(PatternMatchTest, FloatingPointUnorderedMin) {
187 LLVMContext &C(getGlobalContext());
188 IRBuilder<true, NoFolder> Builder(C);
190 Type *FltTy = Builder.getFloatTy();
191 Value *L = ConstantFP::get(FltTy, 1.0);
192 Value *R = ConstantFP::get(FltTy, 2.0);
195 Value *Cmp = Builder.CreateFCmpULT(L, R);
196 Value *Select = Builder.CreateSelect(Cmp, L, R);
197 m_UnordFMin_expect_match_and_delete(Cmp, Select, L, R);
200 Cmp = Builder.CreateFCmpULE(L, R);
201 Select = Builder.CreateSelect(Cmp, L, R);
202 m_UnordFMin_expect_match_and_delete(Cmp, Select, L, R);
204 // Test no match on UGE.
205 Cmp = Builder.CreateFCmpUGE(L, R);
206 Select = Builder.CreateSelect(Cmp, L, R);
207 m_UnordFMin_expect_nomatch_and_delete(Cmp, Select, L, R);
209 // Test no match on UGT.
210 Cmp = Builder.CreateFCmpUGT(L, R);
211 Select = Builder.CreateSelect(Cmp, L, R);
212 m_UnordFMin_expect_nomatch_and_delete(Cmp, Select, L, R);
214 // Test match on UGE with inverted select.
215 Cmp = Builder.CreateFCmpUGE(L, R);
216 Select = Builder.CreateSelect(Cmp, R, L);
217 m_UnordFMin_expect_match_and_delete(Cmp, Select, L, R);
219 // Test match on UGT with inverted select.
220 Cmp = Builder.CreateFCmpUGT(L, R);
221 Select = Builder.CreateSelect(Cmp, R, L);
222 m_UnordFMin_expect_match_and_delete(Cmp, Select, L, R);
225 TEST(PatternMatchTest, FloatingPointUnorderedMax) {
226 LLVMContext &C(getGlobalContext());
227 IRBuilder<true, NoFolder> Builder(C);
229 Type *FltTy = Builder.getFloatTy();
230 Value *L = ConstantFP::get(FltTy, 1.0);
231 Value *R = ConstantFP::get(FltTy, 2.0);
234 Value *Cmp = Builder.CreateFCmpUGT(L, R);
235 Value *Select = Builder.CreateSelect(Cmp, L, R);
236 m_UnordFMax_expect_match_and_delete(Cmp, Select, L, R);
239 Cmp = Builder.CreateFCmpUGE(L, R);
240 Select = Builder.CreateSelect(Cmp, L, R);
241 m_UnordFMax_expect_match_and_delete(Cmp, Select, L, R);
243 // Test no match on ULE.
244 Cmp = Builder.CreateFCmpULE(L, R);
245 Select = Builder.CreateSelect(Cmp, L, R);
246 m_UnordFMax_expect_nomatch_and_delete(Cmp, Select, L, R);
248 // Test no match on ULT.
249 Cmp = Builder.CreateFCmpULT(L, R);
250 Select = Builder.CreateSelect(Cmp, L, R);
251 m_UnordFMax_expect_nomatch_and_delete(Cmp, Select, L, R);
253 // Test match on ULE with inverted select.
254 Cmp = Builder.CreateFCmpULE(L, R);
255 Select = Builder.CreateSelect(Cmp, R, L);
256 m_UnordFMax_expect_match_and_delete(Cmp, Select, L, R);
258 // Test match on ULT with inverted select.
259 Cmp = Builder.CreateFCmpULT(L, R);
260 Select = Builder.CreateSelect(Cmp, R, L);
261 m_UnordFMax_expect_match_and_delete(Cmp, Select, L, R);
264 } // anonymous namespace.