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.
371