1 //===---- llvm/unittest/IR/PatternMatch.cpp - PatternMatch unit tests ----===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "llvm/IR/PatternMatch.h"
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/NoFolder.h"
23 #include "llvm/IR/Operator.h"
24 #include "llvm/IR/Type.h"
25 #include "gtest/gtest.h"
26
27 using namespace llvm;
28 using namespace llvm::PatternMatch;
29
30 namespace {
31
32 struct PatternMatchTest : ::testing::Test {
33 LLVMContext Ctx;
34 std::unique_ptr<Module> M;
35 Function *F;
36 BasicBlock *BB;
37 IRBuilder<NoFolder> IRB;
38
PatternMatchTest__anonb8c151270111::PatternMatchTest39 PatternMatchTest()
40 : M(new Module("PatternMatchTestModule", Ctx)),
41 F(Function::Create(
42 FunctionType::get(Type::getVoidTy(Ctx), /* IsVarArg */ false),
43 Function::ExternalLinkage, "f", M.get())),
44 BB(BasicBlock::Create(Ctx, "entry", F)), IRB(BB) {}
45 };
46
TEST_F(PatternMatchTest,OneUse)47 TEST_F(PatternMatchTest, OneUse) {
48 // Build up a little tree of values:
49 //
50 // One = (1 + 2) + 42
51 // Two = One + 42
52 // Leaf = (Two + 8) + (Two + 13)
53 Value *One = IRB.CreateAdd(IRB.CreateAdd(IRB.getInt32(1), IRB.getInt32(2)),
54 IRB.getInt32(42));
55 Value *Two = IRB.CreateAdd(One, IRB.getInt32(42));
56 Value *Leaf = IRB.CreateAdd(IRB.CreateAdd(Two, IRB.getInt32(8)),
57 IRB.CreateAdd(Two, IRB.getInt32(13)));
58 Value *V;
59
60 EXPECT_TRUE(m_OneUse(m_Value(V)).match(One));
61 EXPECT_EQ(One, V);
62
63 EXPECT_FALSE(m_OneUse(m_Value()).match(Two));
64 EXPECT_FALSE(m_OneUse(m_Value()).match(Leaf));
65 }
66
TEST_F(PatternMatchTest,SpecificIntEQ)67 TEST_F(PatternMatchTest, SpecificIntEQ) {
68 Type *IntTy = IRB.getInt32Ty();
69 unsigned BitWidth = IntTy->getScalarSizeInBits();
70
71 Value *Zero = ConstantInt::get(IntTy, 0);
72 Value *One = ConstantInt::get(IntTy, 1);
73 Value *NegOne = ConstantInt::get(IntTy, -1);
74
75 EXPECT_TRUE(
76 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, 0))
77 .match(Zero));
78 EXPECT_FALSE(
79 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, 0))
80 .match(One));
81 EXPECT_FALSE(
82 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, 0))
83 .match(NegOne));
84
85 EXPECT_FALSE(
86 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, 1))
87 .match(Zero));
88 EXPECT_TRUE(
89 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, 1))
90 .match(One));
91 EXPECT_FALSE(
92 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, 1))
93 .match(NegOne));
94
95 EXPECT_FALSE(
96 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, -1))
97 .match(Zero));
98 EXPECT_FALSE(
99 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, -1))
100 .match(One));
101 EXPECT_TRUE(
102 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, -1))
103 .match(NegOne));
104 }
105
TEST_F(PatternMatchTest,SpecificIntNE)106 TEST_F(PatternMatchTest, SpecificIntNE) {
107 Type *IntTy = IRB.getInt32Ty();
108 unsigned BitWidth = IntTy->getScalarSizeInBits();
109
110 Value *Zero = ConstantInt::get(IntTy, 0);
111 Value *One = ConstantInt::get(IntTy, 1);
112 Value *NegOne = ConstantInt::get(IntTy, -1);
113
114 EXPECT_FALSE(
115 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, 0))
116 .match(Zero));
117 EXPECT_TRUE(
118 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, 0))
119 .match(One));
120 EXPECT_TRUE(
121 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, 0))
122 .match(NegOne));
123
124 EXPECT_TRUE(
125 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, 1))
126 .match(Zero));
127 EXPECT_FALSE(
128 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, 1))
129 .match(One));
130 EXPECT_TRUE(
131 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, 1))
132 .match(NegOne));
133
134 EXPECT_TRUE(
135 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, -1))
136 .match(Zero));
137 EXPECT_TRUE(
138 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, -1))
139 .match(One));
140 EXPECT_FALSE(
141 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, -1))
142 .match(NegOne));
143 }
144
TEST_F(PatternMatchTest,SpecificIntUGT)145 TEST_F(PatternMatchTest, SpecificIntUGT) {
146 Type *IntTy = IRB.getInt32Ty();
147 unsigned BitWidth = IntTy->getScalarSizeInBits();
148
149 Value *Zero = ConstantInt::get(IntTy, 0);
150 Value *One = ConstantInt::get(IntTy, 1);
151 Value *NegOne = ConstantInt::get(IntTy, -1);
152
153 EXPECT_FALSE(
154 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, 0))
155 .match(Zero));
156 EXPECT_TRUE(
157 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, 0))
158 .match(One));
159 EXPECT_TRUE(
160 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, 0))
161 .match(NegOne));
162
163 EXPECT_FALSE(
164 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, 1))
165 .match(Zero));
166 EXPECT_FALSE(
167 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, 1))
168 .match(One));
169 EXPECT_TRUE(
170 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, 1))
171 .match(NegOne));
172
173 EXPECT_FALSE(
174 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, -1))
175 .match(Zero));
176 EXPECT_FALSE(
177 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, -1))
178 .match(One));
179 EXPECT_FALSE(
180 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, -1))
181 .match(NegOne));
182 }
183
TEST_F(PatternMatchTest,SpecificIntUGE)184 TEST_F(PatternMatchTest, SpecificIntUGE) {
185 Type *IntTy = IRB.getInt32Ty();
186 unsigned BitWidth = IntTy->getScalarSizeInBits();
187
188 Value *Zero = ConstantInt::get(IntTy, 0);
189 Value *One = ConstantInt::get(IntTy, 1);
190 Value *NegOne = ConstantInt::get(IntTy, -1);
191
192 EXPECT_TRUE(
193 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, 0))
194 .match(Zero));
195 EXPECT_TRUE(
196 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, 0))
197 .match(One));
198 EXPECT_TRUE(
199 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, 0))
200 .match(NegOne));
201
202 EXPECT_FALSE(
203 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, 1))
204 .match(Zero));
205 EXPECT_TRUE(
206 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, 1))
207 .match(One));
208 EXPECT_TRUE(
209 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, 1))
210 .match(NegOne));
211
212 EXPECT_FALSE(
213 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, -1))
214 .match(Zero));
215 EXPECT_FALSE(
216 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, -1))
217 .match(One));
218 EXPECT_TRUE(
219 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, -1))
220 .match(NegOne));
221 }
222
TEST_F(PatternMatchTest,SpecificIntULT)223 TEST_F(PatternMatchTest, SpecificIntULT) {
224 Type *IntTy = IRB.getInt32Ty();
225 unsigned BitWidth = IntTy->getScalarSizeInBits();
226
227 Value *Zero = ConstantInt::get(IntTy, 0);
228 Value *One = ConstantInt::get(IntTy, 1);
229 Value *NegOne = ConstantInt::get(IntTy, -1);
230
231 EXPECT_FALSE(
232 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, 0))
233 .match(Zero));
234 EXPECT_FALSE(
235 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, 0))
236 .match(One));
237 EXPECT_FALSE(
238 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, 0))
239 .match(NegOne));
240
241 EXPECT_TRUE(
242 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, 1))
243 .match(Zero));
244 EXPECT_FALSE(
245 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, 1))
246 .match(One));
247 EXPECT_FALSE(
248 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, 1))
249 .match(NegOne));
250
251 EXPECT_TRUE(
252 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, -1))
253 .match(Zero));
254 EXPECT_TRUE(
255 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, -1))
256 .match(One));
257 EXPECT_FALSE(
258 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, -1))
259 .match(NegOne));
260 }
261
TEST_F(PatternMatchTest,SpecificIntULE)262 TEST_F(PatternMatchTest, SpecificIntULE) {
263 Type *IntTy = IRB.getInt32Ty();
264 unsigned BitWidth = IntTy->getScalarSizeInBits();
265
266 Value *Zero = ConstantInt::get(IntTy, 0);
267 Value *One = ConstantInt::get(IntTy, 1);
268 Value *NegOne = ConstantInt::get(IntTy, -1);
269
270 EXPECT_TRUE(
271 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, 0))
272 .match(Zero));
273 EXPECT_FALSE(
274 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, 0))
275 .match(One));
276 EXPECT_FALSE(
277 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, 0))
278 .match(NegOne));
279
280 EXPECT_TRUE(
281 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, 1))
282 .match(Zero));
283 EXPECT_TRUE(
284 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, 1))
285 .match(One));
286 EXPECT_FALSE(
287 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, 1))
288 .match(NegOne));
289
290 EXPECT_TRUE(
291 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, -1))
292 .match(Zero));
293 EXPECT_TRUE(
294 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, -1))
295 .match(One));
296 EXPECT_TRUE(
297 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, -1))
298 .match(NegOne));
299 }
300
TEST_F(PatternMatchTest,SpecificIntSGT)301 TEST_F(PatternMatchTest, SpecificIntSGT) {
302 Type *IntTy = IRB.getInt32Ty();
303 unsigned BitWidth = IntTy->getScalarSizeInBits();
304
305 Value *Zero = ConstantInt::get(IntTy, 0);
306 Value *One = ConstantInt::get(IntTy, 1);
307 Value *NegOne = ConstantInt::get(IntTy, -1);
308
309 EXPECT_FALSE(
310 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, 0))
311 .match(Zero));
312 EXPECT_TRUE(
313 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, 0))
314 .match(One));
315 EXPECT_FALSE(
316 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, 0))
317 .match(NegOne));
318
319 EXPECT_FALSE(
320 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, 1))
321 .match(Zero));
322 EXPECT_FALSE(
323 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, 1))
324 .match(One));
325 EXPECT_FALSE(
326 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, 1))
327 .match(NegOne));
328
329 EXPECT_TRUE(
330 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, -1))
331 .match(Zero));
332 EXPECT_TRUE(
333 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, -1))
334 .match(One));
335 EXPECT_FALSE(
336 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, -1))
337 .match(NegOne));
338 }
339
TEST_F(PatternMatchTest,SpecificIntSGE)340 TEST_F(PatternMatchTest, SpecificIntSGE) {
341 Type *IntTy = IRB.getInt32Ty();
342 unsigned BitWidth = IntTy->getScalarSizeInBits();
343
344 Value *Zero = ConstantInt::get(IntTy, 0);
345 Value *One = ConstantInt::get(IntTy, 1);
346 Value *NegOne = ConstantInt::get(IntTy, -1);
347
348 EXPECT_TRUE(
349 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, 0))
350 .match(Zero));
351 EXPECT_TRUE(
352 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, 0))
353 .match(One));
354 EXPECT_FALSE(
355 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, 0))
356 .match(NegOne));
357
358 EXPECT_FALSE(
359 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, 1))
360 .match(Zero));
361 EXPECT_TRUE(
362 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, 1))
363 .match(One));
364 EXPECT_FALSE(
365 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, 1))
366 .match(NegOne));
367
368 EXPECT_TRUE(
369 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, -1))
370 .match(Zero));
371 EXPECT_TRUE(
372 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, -1))
373 .match(One));
374 EXPECT_TRUE(
375 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, -1))
376 .match(NegOne));
377 }
378
TEST_F(PatternMatchTest,SpecificIntSLT)379 TEST_F(PatternMatchTest, SpecificIntSLT) {
380 Type *IntTy = IRB.getInt32Ty();
381 unsigned BitWidth = IntTy->getScalarSizeInBits();
382
383 Value *Zero = ConstantInt::get(IntTy, 0);
384 Value *One = ConstantInt::get(IntTy, 1);
385 Value *NegOne = ConstantInt::get(IntTy, -1);
386
387 EXPECT_FALSE(
388 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, 0))
389 .match(Zero));
390 EXPECT_FALSE(
391 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, 0))
392 .match(One));
393 EXPECT_TRUE(
394 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, 0))
395 .match(NegOne));
396
397 EXPECT_TRUE(
398 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, 1))
399 .match(Zero));
400 EXPECT_FALSE(
401 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, 1))
402 .match(One));
403 EXPECT_TRUE(
404 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, 1))
405 .match(NegOne));
406
407 EXPECT_FALSE(
408 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, -1))
409 .match(Zero));
410 EXPECT_FALSE(
411 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, -1))
412 .match(One));
413 EXPECT_FALSE(
414 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, -1))
415 .match(NegOne));
416 }
417
TEST_F(PatternMatchTest,SpecificIntSLE)418 TEST_F(PatternMatchTest, SpecificIntSLE) {
419 Type *IntTy = IRB.getInt32Ty();
420 unsigned BitWidth = IntTy->getScalarSizeInBits();
421
422 Value *Zero = ConstantInt::get(IntTy, 0);
423 Value *One = ConstantInt::get(IntTy, 1);
424 Value *NegOne = ConstantInt::get(IntTy, -1);
425
426 EXPECT_TRUE(
427 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, 0))
428 .match(Zero));
429 EXPECT_FALSE(
430 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, 0))
431 .match(One));
432 EXPECT_TRUE(
433 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, 0))
434 .match(NegOne));
435
436 EXPECT_TRUE(
437 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, 1))
438 .match(Zero));
439 EXPECT_TRUE(
440 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, 1))
441 .match(One));
442 EXPECT_TRUE(
443 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, 1))
444 .match(NegOne));
445
446 EXPECT_FALSE(
447 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, -1))
448 .match(Zero));
449 EXPECT_FALSE(
450 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, -1))
451 .match(One));
452 EXPECT_TRUE(
453 m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, -1))
454 .match(NegOne));
455 }
456
TEST_F(PatternMatchTest,CommutativeDeferredValue)457 TEST_F(PatternMatchTest, CommutativeDeferredValue) {
458 Value *X = IRB.getInt32(1);
459 Value *Y = IRB.getInt32(2);
460
461 {
462 Value *tX = X;
463 EXPECT_TRUE(match(X, m_Deferred(tX)));
464 EXPECT_FALSE(match(Y, m_Deferred(tX)));
465 }
466 {
467 const Value *tX = X;
468 EXPECT_TRUE(match(X, m_Deferred(tX)));
469 EXPECT_FALSE(match(Y, m_Deferred(tX)));
470 }
471 {
472 Value *const tX = X;
473 EXPECT_TRUE(match(X, m_Deferred(tX)));
474 EXPECT_FALSE(match(Y, m_Deferred(tX)));
475 }
476 {
477 const Value *const tX = X;
478 EXPECT_TRUE(match(X, m_Deferred(tX)));
479 EXPECT_FALSE(match(Y, m_Deferred(tX)));
480 }
481
482 {
483 Value *tX = nullptr;
484 EXPECT_TRUE(match(IRB.CreateAnd(X, X), m_And(m_Value(tX), m_Deferred(tX))));
485 EXPECT_EQ(tX, X);
486 }
487 {
488 Value *tX = nullptr;
489 EXPECT_FALSE(
490 match(IRB.CreateAnd(X, Y), m_c_And(m_Value(tX), m_Deferred(tX))));
491 }
492
493 auto checkMatch = [X, Y](Value *Pattern) {
494 Value *tX = nullptr, *tY = nullptr;
495 EXPECT_TRUE(match(
496 Pattern, m_c_And(m_Value(tX), m_c_And(m_Deferred(tX), m_Value(tY)))));
497 EXPECT_EQ(tX, X);
498 EXPECT_EQ(tY, Y);
499 };
500
501 checkMatch(IRB.CreateAnd(X, IRB.CreateAnd(X, Y)));
502 checkMatch(IRB.CreateAnd(X, IRB.CreateAnd(Y, X)));
503 checkMatch(IRB.CreateAnd(IRB.CreateAnd(X, Y), X));
504 checkMatch(IRB.CreateAnd(IRB.CreateAnd(Y, X), X));
505 }
506
TEST_F(PatternMatchTest,FloatingPointOrderedMin)507 TEST_F(PatternMatchTest, FloatingPointOrderedMin) {
508 Type *FltTy = IRB.getFloatTy();
509 Value *L = ConstantFP::get(FltTy, 1.0);
510 Value *R = ConstantFP::get(FltTy, 2.0);
511 Value *MatchL, *MatchR;
512
513 // Test OLT.
514 EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
515 .match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), L, R)));
516 EXPECT_EQ(L, MatchL);
517 EXPECT_EQ(R, MatchR);
518
519 // Test OLE.
520 EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
521 .match(IRB.CreateSelect(IRB.CreateFCmpOLE(L, R), L, R)));
522 EXPECT_EQ(L, MatchL);
523 EXPECT_EQ(R, MatchR);
524
525 // Test no match on OGE.
526 EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
527 .match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), L, R)));
528
529 // Test no match on OGT.
530 EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
531 .match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), L, R)));
532
533 // Test inverted selects. Note, that this "inverts" the ordering, e.g.:
534 // %cmp = fcmp oge L, R
535 // %min = select %cmp R, L
536 // Given L == NaN
537 // the above is expanded to %cmp == false ==> %min = L
538 // which is true for UnordFMin, not OrdFMin, so test that:
539
540 // [OU]GE with inverted select.
541 EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
542 .match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), R, L)));
543 EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
544 .match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), R, L)));
545 EXPECT_EQ(L, MatchL);
546 EXPECT_EQ(R, MatchR);
547
548 // [OU]GT with inverted select.
549 EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
550 .match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), R, L)));
551 EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
552 .match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), R, L)));
553 EXPECT_EQ(L, MatchL);
554 EXPECT_EQ(R, MatchR);
555 }
556
TEST_F(PatternMatchTest,FloatingPointOrderedMax)557 TEST_F(PatternMatchTest, FloatingPointOrderedMax) {
558 Type *FltTy = IRB.getFloatTy();
559 Value *L = ConstantFP::get(FltTy, 1.0);
560 Value *R = ConstantFP::get(FltTy, 2.0);
561 Value *MatchL, *MatchR;
562
563 // Test OGT.
564 EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
565 .match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), L, R)));
566 EXPECT_EQ(L, MatchL);
567 EXPECT_EQ(R, MatchR);
568
569 // Test OGE.
570 EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
571 .match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), L, R)));
572 EXPECT_EQ(L, MatchL);
573 EXPECT_EQ(R, MatchR);
574
575 // Test no match on OLE.
576 EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
577 .match(IRB.CreateSelect(IRB.CreateFCmpOLE(L, R), L, R)));
578
579 // Test no match on OLT.
580 EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
581 .match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), L, R)));
582
583
584 // Test inverted selects. Note, that this "inverts" the ordering, e.g.:
585 // %cmp = fcmp ole L, R
586 // %max = select %cmp, R, L
587 // Given L == NaN,
588 // the above is expanded to %cmp == false ==> %max == L
589 // which is true for UnordFMax, not OrdFMax, so test that:
590
591 // [OU]LE with inverted select.
592 EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
593 .match(IRB.CreateSelect(IRB.CreateFCmpOLE(L, R), R, L)));
594 EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
595 .match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), R, L)));
596 EXPECT_EQ(L, MatchL);
597 EXPECT_EQ(R, MatchR);
598
599 // [OUT]LT with inverted select.
600 EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
601 .match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), R, L)));
602 EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
603 .match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), R, L)));
604 EXPECT_EQ(L, MatchL);
605 EXPECT_EQ(R, MatchR);
606 }
607
TEST_F(PatternMatchTest,FloatingPointUnorderedMin)608 TEST_F(PatternMatchTest, FloatingPointUnorderedMin) {
609 Type *FltTy = IRB.getFloatTy();
610 Value *L = ConstantFP::get(FltTy, 1.0);
611 Value *R = ConstantFP::get(FltTy, 2.0);
612 Value *MatchL, *MatchR;
613
614 // Test ULT.
615 EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
616 .match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), L, R)));
617 EXPECT_EQ(L, MatchL);
618 EXPECT_EQ(R, MatchR);
619
620 // Test ULE.
621 EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
622 .match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), L, R)));
623 EXPECT_EQ(L, MatchL);
624 EXPECT_EQ(R, MatchR);
625
626 // Test no match on UGE.
627 EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
628 .match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), L, R)));
629
630 // Test no match on UGT.
631 EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
632 .match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), L, R)));
633
634 // Test inverted selects. Note, that this "inverts" the ordering, e.g.:
635 // %cmp = fcmp uge L, R
636 // %min = select %cmp R, L
637 // Given L == NaN
638 // the above is expanded to %cmp == true ==> %min = R
639 // which is true for OrdFMin, not UnordFMin, so test that:
640
641 // [UO]GE with inverted select.
642 EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
643 .match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), R, L)));
644 EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
645 .match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), R, L)));
646 EXPECT_EQ(L, MatchL);
647 EXPECT_EQ(R, MatchR);
648
649 // [UO]GT with inverted select.
650 EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
651 .match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), R, L)));
652 EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
653 .match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), R, L)));
654 EXPECT_EQ(L, MatchL);
655 EXPECT_EQ(R, MatchR);
656 }
657
TEST_F(PatternMatchTest,FloatingPointUnorderedMax)658 TEST_F(PatternMatchTest, FloatingPointUnorderedMax) {
659 Type *FltTy = IRB.getFloatTy();
660 Value *L = ConstantFP::get(FltTy, 1.0);
661 Value *R = ConstantFP::get(FltTy, 2.0);
662 Value *MatchL, *MatchR;
663
664 // Test UGT.
665 EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
666 .match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), L, R)));
667 EXPECT_EQ(L, MatchL);
668 EXPECT_EQ(R, MatchR);
669
670 // Test UGE.
671 EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
672 .match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), L, R)));
673 EXPECT_EQ(L, MatchL);
674 EXPECT_EQ(R, MatchR);
675
676 // Test no match on ULE.
677 EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
678 .match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), L, R)));
679
680 // Test no match on ULT.
681 EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
682 .match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), L, R)));
683
684 // Test inverted selects. Note, that this "inverts" the ordering, e.g.:
685 // %cmp = fcmp ule L, R
686 // %max = select %cmp R, L
687 // Given L == NaN
688 // the above is expanded to %cmp == true ==> %max = R
689 // which is true for OrdFMax, not UnordFMax, so test that:
690
691 // [UO]LE with inverted select.
692 EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
693 .match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), R, L)));
694 EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
695 .match(IRB.CreateSelect(IRB.CreateFCmpOLE(L, R), R, L)));
696 EXPECT_EQ(L, MatchL);
697 EXPECT_EQ(R, MatchR);
698
699 // [UO]LT with inverted select.
700 EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
701 .match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), R, L)));
702 EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
703 .match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), R, L)));
704 EXPECT_EQ(L, MatchL);
705 EXPECT_EQ(R, MatchR);
706 }
707
TEST_F(PatternMatchTest,OverflowingBinOps)708 TEST_F(PatternMatchTest, OverflowingBinOps) {
709 Value *L = IRB.getInt32(1);
710 Value *R = IRB.getInt32(2);
711 Value *MatchL, *MatchR;
712
713 EXPECT_TRUE(
714 m_NSWAdd(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNSWAdd(L, R)));
715 EXPECT_EQ(L, MatchL);
716 EXPECT_EQ(R, MatchR);
717 MatchL = MatchR = nullptr;
718 EXPECT_TRUE(
719 m_NSWSub(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNSWSub(L, R)));
720 EXPECT_EQ(L, MatchL);
721 EXPECT_EQ(R, MatchR);
722 MatchL = MatchR = nullptr;
723 EXPECT_TRUE(
724 m_NSWMul(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNSWMul(L, R)));
725 EXPECT_EQ(L, MatchL);
726 EXPECT_EQ(R, MatchR);
727 MatchL = MatchR = nullptr;
728 EXPECT_TRUE(m_NSWShl(m_Value(MatchL), m_Value(MatchR)).match(
729 IRB.CreateShl(L, R, "", /* NUW */ false, /* NSW */ true)));
730 EXPECT_EQ(L, MatchL);
731 EXPECT_EQ(R, MatchR);
732
733 EXPECT_TRUE(
734 m_NUWAdd(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNUWAdd(L, R)));
735 EXPECT_EQ(L, MatchL);
736 EXPECT_EQ(R, MatchR);
737 MatchL = MatchR = nullptr;
738 EXPECT_TRUE(
739 m_NUWSub(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNUWSub(L, R)));
740 EXPECT_EQ(L, MatchL);
741 EXPECT_EQ(R, MatchR);
742 MatchL = MatchR = nullptr;
743 EXPECT_TRUE(
744 m_NUWMul(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNUWMul(L, R)));
745 EXPECT_EQ(L, MatchL);
746 EXPECT_EQ(R, MatchR);
747 MatchL = MatchR = nullptr;
748 EXPECT_TRUE(m_NUWShl(m_Value(MatchL), m_Value(MatchR)).match(
749 IRB.CreateShl(L, R, "", /* NUW */ true, /* NSW */ false)));
750 EXPECT_EQ(L, MatchL);
751 EXPECT_EQ(R, MatchR);
752
753 EXPECT_FALSE(m_NSWAdd(m_Value(), m_Value()).match(IRB.CreateAdd(L, R)));
754 EXPECT_FALSE(m_NSWAdd(m_Value(), m_Value()).match(IRB.CreateNUWAdd(L, R)));
755 EXPECT_FALSE(m_NSWAdd(m_Value(), m_Value()).match(IRB.CreateNSWSub(L, R)));
756 EXPECT_FALSE(m_NSWSub(m_Value(), m_Value()).match(IRB.CreateSub(L, R)));
757 EXPECT_FALSE(m_NSWSub(m_Value(), m_Value()).match(IRB.CreateNUWSub(L, R)));
758 EXPECT_FALSE(m_NSWSub(m_Value(), m_Value()).match(IRB.CreateNSWAdd(L, R)));
759 EXPECT_FALSE(m_NSWMul(m_Value(), m_Value()).match(IRB.CreateMul(L, R)));
760 EXPECT_FALSE(m_NSWMul(m_Value(), m_Value()).match(IRB.CreateNUWMul(L, R)));
761 EXPECT_FALSE(m_NSWMul(m_Value(), m_Value()).match(IRB.CreateNSWAdd(L, R)));
762 EXPECT_FALSE(m_NSWShl(m_Value(), m_Value()).match(IRB.CreateShl(L, R)));
763 EXPECT_FALSE(m_NSWShl(m_Value(), m_Value()).match(
764 IRB.CreateShl(L, R, "", /* NUW */ true, /* NSW */ false)));
765 EXPECT_FALSE(m_NSWShl(m_Value(), m_Value()).match(IRB.CreateNSWAdd(L, R)));
766
767 EXPECT_FALSE(m_NUWAdd(m_Value(), m_Value()).match(IRB.CreateAdd(L, R)));
768 EXPECT_FALSE(m_NUWAdd(m_Value(), m_Value()).match(IRB.CreateNSWAdd(L, R)));
769 EXPECT_FALSE(m_NUWAdd(m_Value(), m_Value()).match(IRB.CreateNUWSub(L, R)));
770 EXPECT_FALSE(m_NUWSub(m_Value(), m_Value()).match(IRB.CreateSub(L, R)));
771 EXPECT_FALSE(m_NUWSub(m_Value(), m_Value()).match(IRB.CreateNSWSub(L, R)));
772 EXPECT_FALSE(m_NUWSub(m_Value(), m_Value()).match(IRB.CreateNUWAdd(L, R)));
773 EXPECT_FALSE(m_NUWMul(m_Value(), m_Value()).match(IRB.CreateMul(L, R)));
774 EXPECT_FALSE(m_NUWMul(m_Value(), m_Value()).match(IRB.CreateNSWMul(L, R)));
775 EXPECT_FALSE(m_NUWMul(m_Value(), m_Value()).match(IRB.CreateNUWAdd(L, R)));
776 EXPECT_FALSE(m_NUWShl(m_Value(), m_Value()).match(IRB.CreateShl(L, R)));
777 EXPECT_FALSE(m_NUWShl(m_Value(), m_Value()).match(
778 IRB.CreateShl(L, R, "", /* NUW */ false, /* NSW */ true)));
779 EXPECT_FALSE(m_NUWShl(m_Value(), m_Value()).match(IRB.CreateNUWAdd(L, R)));
780 }
781
TEST_F(PatternMatchTest,LoadStoreOps)782 TEST_F(PatternMatchTest, LoadStoreOps) {
783 // Create this load/store sequence:
784 //
785 // %p = alloca i32*
786 // %0 = load i32*, i32** %p
787 // store i32 42, i32* %0
788
789 Value *Alloca = IRB.CreateAlloca(IRB.getInt32Ty());
790 Value *LoadInst = IRB.CreateLoad(IRB.getInt32Ty(), Alloca);
791 Value *FourtyTwo = IRB.getInt32(42);
792 Value *StoreInst = IRB.CreateStore(FourtyTwo, Alloca);
793 Value *MatchLoad, *MatchStoreVal, *MatchStorePointer;
794
795 EXPECT_TRUE(m_Load(m_Value(MatchLoad)).match(LoadInst));
796 EXPECT_EQ(Alloca, MatchLoad);
797
798 EXPECT_TRUE(m_Load(m_Specific(Alloca)).match(LoadInst));
799
800 EXPECT_FALSE(m_Load(m_Value(MatchLoad)).match(Alloca));
801
802 EXPECT_TRUE(m_Store(m_Value(MatchStoreVal), m_Value(MatchStorePointer))
803 .match(StoreInst));
804 EXPECT_EQ(FourtyTwo, MatchStoreVal);
805 EXPECT_EQ(Alloca, MatchStorePointer);
806
807 EXPECT_FALSE(m_Store(m_Value(MatchStoreVal), m_Value(MatchStorePointer))
808 .match(Alloca));
809
810 EXPECT_TRUE(m_Store(m_SpecificInt(42), m_Specific(Alloca))
811 .match(StoreInst));
812 EXPECT_FALSE(m_Store(m_SpecificInt(42), m_Specific(FourtyTwo))
813 .match(StoreInst));
814 EXPECT_FALSE(m_Store(m_SpecificInt(43), m_Specific(Alloca))
815 .match(StoreInst));
816 }
817
TEST_F(PatternMatchTest,VectorOps)818 TEST_F(PatternMatchTest, VectorOps) {
819 // Build up small tree of vector operations
820 //
821 // Val = 0 + 1
822 // Val2 = Val + 3
823 // VI1 = insertelement <2 x i8> undef, i8 1, i32 0 = <1, undef>
824 // VI2 = insertelement <2 x i8> %VI1, i8 %Val2, i8 %Val = <1, 4>
825 // VI3 = insertelement <2 x i8> %VI1, i8 %Val2, i32 1 = <1, 4>
826 // VI4 = insertelement <2 x i8> %VI1, i8 2, i8 %Val = <1, 2>
827 //
828 // SI1 = shufflevector <2 x i8> %VI1, <2 x i8> undef, zeroinitializer
829 // SI2 = shufflevector <2 x i8> %VI3, <2 x i8> %VI4, <2 x i8> <i8 0, i8 2>
830 // SI3 = shufflevector <2 x i8> %VI3, <2 x i8> undef, zeroinitializer
831 // SI4 = shufflevector <2 x i8> %VI4, <2 x i8> undef, zeroinitializer
832 //
833 // SP1 = VectorSplat(2, i8 2)
834 // SP2 = VectorSplat(2, i8 %Val)
835 Type *VecTy = VectorType::get(IRB.getInt8Ty(), 2);
836 Type *i32 = IRB.getInt32Ty();
837 Type *i32VecTy = VectorType::get(i32, 2);
838
839 Value *Val = IRB.CreateAdd(IRB.getInt8(0), IRB.getInt8(1));
840 Value *Val2 = IRB.CreateAdd(Val, IRB.getInt8(3));
841
842 SmallVector<Constant *, 2> VecElemIdxs;
843 VecElemIdxs.push_back(ConstantInt::get(i32, 0));
844 VecElemIdxs.push_back(ConstantInt::get(i32, 2));
845 auto *IdxVec = ConstantVector::get(VecElemIdxs);
846
847 Value *UndefVec = UndefValue::get(VecTy);
848 Value *VI1 = IRB.CreateInsertElement(UndefVec, IRB.getInt8(1), (uint64_t)0);
849 Value *VI2 = IRB.CreateInsertElement(VI1, Val2, Val);
850 Value *VI3 = IRB.CreateInsertElement(VI1, Val2, (uint64_t)1);
851 Value *VI4 = IRB.CreateInsertElement(VI1, IRB.getInt8(2), Val);
852
853 Value *EX1 = IRB.CreateExtractElement(VI4, Val);
854 Value *EX2 = IRB.CreateExtractElement(VI4, (uint64_t)0);
855 Value *EX3 = IRB.CreateExtractElement(IdxVec, (uint64_t)1);
856
857 Value *Zero = ConstantAggregateZero::get(i32VecTy);
858 Value *SI1 = IRB.CreateShuffleVector(VI1, UndefVec, Zero);
859 Value *SI2 = IRB.CreateShuffleVector(VI3, VI4, IdxVec);
860 Value *SI3 = IRB.CreateShuffleVector(VI3, UndefVec, Zero);
861 Value *SI4 = IRB.CreateShuffleVector(VI4, UndefVec, Zero);
862
863 Value *SP1 = IRB.CreateVectorSplat(2, IRB.getInt8(2));
864 Value *SP2 = IRB.CreateVectorSplat(2, Val);
865
866 Value *A = nullptr, *B = nullptr, *C = nullptr;
867
868 // Test matching insertelement
869 EXPECT_TRUE(match(VI1, m_InsertElement(m_Value(), m_Value(), m_Value())));
870 EXPECT_TRUE(
871 match(VI1, m_InsertElement(m_Undef(), m_ConstantInt(), m_ConstantInt())));
872 EXPECT_TRUE(
873 match(VI1, m_InsertElement(m_Undef(), m_ConstantInt(), m_Zero())));
874 EXPECT_TRUE(
875 match(VI1, m_InsertElement(m_Undef(), m_SpecificInt(1), m_Zero())));
876 EXPECT_TRUE(match(VI2, m_InsertElement(m_Value(), m_Value(), m_Value())));
877 EXPECT_FALSE(
878 match(VI2, m_InsertElement(m_Value(), m_Value(), m_ConstantInt())));
879 EXPECT_FALSE(
880 match(VI2, m_InsertElement(m_Value(), m_ConstantInt(), m_Value())));
881 EXPECT_FALSE(match(VI2, m_InsertElement(m_Constant(), m_Value(), m_Value())));
882 EXPECT_TRUE(match(VI3, m_InsertElement(m_Value(A), m_Value(B), m_Value(C))));
883 EXPECT_TRUE(A == VI1);
884 EXPECT_TRUE(B == Val2);
885 EXPECT_TRUE(isa<ConstantInt>(C));
886 A = B = C = nullptr; // reset
887
888 // Test matching extractelement
889 EXPECT_TRUE(match(EX1, m_ExtractElement(m_Value(A), m_Value(B))));
890 EXPECT_TRUE(A == VI4);
891 EXPECT_TRUE(B == Val);
892 A = B = C = nullptr; // reset
893 EXPECT_FALSE(match(EX1, m_ExtractElement(m_Value(), m_ConstantInt())));
894 EXPECT_TRUE(match(EX2, m_ExtractElement(m_Value(), m_ConstantInt())));
895 EXPECT_TRUE(match(EX3, m_ExtractElement(m_Constant(), m_ConstantInt())));
896
897 // Test matching shufflevector
898 EXPECT_TRUE(match(SI1, m_ShuffleVector(m_Value(), m_Undef(), m_Zero())));
899 EXPECT_TRUE(match(SI2, m_ShuffleVector(m_Value(A), m_Value(B), m_Value(C))));
900 EXPECT_TRUE(A == VI3);
901 EXPECT_TRUE(B == VI4);
902 EXPECT_TRUE(C == IdxVec);
903 A = B = C = nullptr; // reset
904
905 // Test matching the vector splat pattern
906 EXPECT_TRUE(match(
907 SI1,
908 m_ShuffleVector(m_InsertElement(m_Undef(), m_SpecificInt(1), m_Zero()),
909 m_Undef(), m_Zero())));
910 EXPECT_FALSE(match(
911 SI3, m_ShuffleVector(m_InsertElement(m_Undef(), m_Value(), m_Zero()),
912 m_Undef(), m_Zero())));
913 EXPECT_FALSE(match(
914 SI4, m_ShuffleVector(m_InsertElement(m_Undef(), m_Value(), m_Zero()),
915 m_Undef(), m_Zero())));
916 EXPECT_TRUE(match(
917 SP1,
918 m_ShuffleVector(m_InsertElement(m_Undef(), m_SpecificInt(2), m_Zero()),
919 m_Undef(), m_Zero())));
920 EXPECT_TRUE(match(
921 SP2, m_ShuffleVector(m_InsertElement(m_Undef(), m_Value(A), m_Zero()),
922 m_Undef(), m_Zero())));
923 EXPECT_TRUE(A == Val);
924 }
925
TEST_F(PatternMatchTest,VectorUndefInt)926 TEST_F(PatternMatchTest, VectorUndefInt) {
927 Type *ScalarTy = IRB.getInt8Ty();
928 Type *VectorTy = VectorType::get(ScalarTy, 4);
929 Constant *ScalarUndef = UndefValue::get(ScalarTy);
930 Constant *VectorUndef = UndefValue::get(VectorTy);
931 Constant *ScalarZero = Constant::getNullValue(ScalarTy);
932 Constant *VectorZero = Constant::getNullValue(VectorTy);
933
934 SmallVector<Constant *, 4> Elems;
935 Elems.push_back(ScalarUndef);
936 Elems.push_back(ScalarZero);
937 Elems.push_back(ScalarUndef);
938 Elems.push_back(ScalarZero);
939 Constant *VectorZeroUndef = ConstantVector::get(Elems);
940
941 EXPECT_TRUE(match(ScalarUndef, m_Undef()));
942 EXPECT_TRUE(match(VectorUndef, m_Undef()));
943 EXPECT_FALSE(match(ScalarZero, m_Undef()));
944 EXPECT_FALSE(match(VectorZero, m_Undef()));
945 EXPECT_FALSE(match(VectorZeroUndef, m_Undef()));
946
947 EXPECT_FALSE(match(ScalarUndef, m_Zero()));
948 EXPECT_FALSE(match(VectorUndef, m_Zero()));
949 EXPECT_TRUE(match(ScalarZero, m_Zero()));
950 EXPECT_TRUE(match(VectorZero, m_Zero()));
951 EXPECT_TRUE(match(VectorZeroUndef, m_Zero()));
952 }
953
TEST_F(PatternMatchTest,VectorUndefFloat)954 TEST_F(PatternMatchTest, VectorUndefFloat) {
955 Type *ScalarTy = IRB.getFloatTy();
956 Type *VectorTy = VectorType::get(ScalarTy, 4);
957 Constant *ScalarUndef = UndefValue::get(ScalarTy);
958 Constant *VectorUndef = UndefValue::get(VectorTy);
959 Constant *ScalarZero = Constant::getNullValue(ScalarTy);
960 Constant *VectorZero = Constant::getNullValue(VectorTy);
961
962 SmallVector<Constant *, 4> Elems;
963 Elems.push_back(ScalarUndef);
964 Elems.push_back(ScalarZero);
965 Elems.push_back(ScalarUndef);
966 Elems.push_back(ScalarZero);
967 Constant *VectorZeroUndef = ConstantVector::get(Elems);
968
969 EXPECT_TRUE(match(ScalarUndef, m_Undef()));
970 EXPECT_TRUE(match(VectorUndef, m_Undef()));
971 EXPECT_FALSE(match(ScalarZero, m_Undef()));
972 EXPECT_FALSE(match(VectorZero, m_Undef()));
973 EXPECT_FALSE(match(VectorZeroUndef, m_Undef()));
974
975 EXPECT_FALSE(match(ScalarUndef, m_AnyZeroFP()));
976 EXPECT_FALSE(match(VectorUndef, m_AnyZeroFP()));
977 EXPECT_TRUE(match(ScalarZero, m_AnyZeroFP()));
978 EXPECT_TRUE(match(VectorZero, m_AnyZeroFP()));
979 EXPECT_TRUE(match(VectorZeroUndef, m_AnyZeroFP()));
980 }
981
TEST_F(PatternMatchTest,FloatingPointFNeg)982 TEST_F(PatternMatchTest, FloatingPointFNeg) {
983 Type *FltTy = IRB.getFloatTy();
984 Value *One = ConstantFP::get(FltTy, 1.0);
985 Value *Z = ConstantFP::get(FltTy, 0.0);
986 Value *NZ = ConstantFP::get(FltTy, -0.0);
987 Value *V = IRB.CreateFNeg(One);
988 Value *V1 = IRB.CreateFSub(NZ, One);
989 Value *V2 = IRB.CreateFSub(Z, One);
990 Value *V3 = IRB.CreateFAdd(NZ, One);
991 Value *Match;
992
993 // Test FNeg(1.0)
994 EXPECT_TRUE(match(V, m_FNeg(m_Value(Match))));
995 EXPECT_EQ(One, Match);
996
997 // Test FSub(-0.0, 1.0)
998 EXPECT_TRUE(match(V1, m_FNeg(m_Value(Match))));
999 EXPECT_EQ(One, Match);
1000
1001 // Test FSub(0.0, 1.0)
1002 EXPECT_FALSE(match(V2, m_FNeg(m_Value(Match))));
1003 cast<Instruction>(V2)->setHasNoSignedZeros(true);
1004 EXPECT_TRUE(match(V2, m_FNeg(m_Value(Match))));
1005 EXPECT_EQ(One, Match);
1006
1007 // Test FAdd(-0.0, 1.0)
1008 EXPECT_FALSE(match(V3, m_FNeg(m_Value(Match))));
1009 }
1010
1011 template <typename T> struct MutableConstTest : PatternMatchTest { };
1012
1013 typedef ::testing::Types<std::tuple<Value*, Instruction*>,
1014 std::tuple<const Value*, const Instruction *>>
1015 MutableConstTestTypes;
1016 TYPED_TEST_CASE(MutableConstTest, MutableConstTestTypes);
1017
TYPED_TEST(MutableConstTest,ICmp)1018 TYPED_TEST(MutableConstTest, ICmp) {
1019 auto &IRB = PatternMatchTest::IRB;
1020
1021 typedef typename std::tuple_element<0, TypeParam>::type ValueType;
1022 typedef typename std::tuple_element<1, TypeParam>::type InstructionType;
1023
1024 Value *L = IRB.getInt32(1);
1025 Value *R = IRB.getInt32(2);
1026 ICmpInst::Predicate Pred = ICmpInst::ICMP_UGT;
1027
1028 ValueType MatchL;
1029 ValueType MatchR;
1030 ICmpInst::Predicate MatchPred;
1031
1032 EXPECT_TRUE(m_ICmp(MatchPred, m_Value(MatchL), m_Value(MatchR))
1033 .match((InstructionType)IRB.CreateICmp(Pred, L, R)));
1034 EXPECT_EQ(L, MatchL);
1035 EXPECT_EQ(R, MatchR);
1036 }
1037
1038 } // anonymous namespace.
1039