Skip to content

Commit c833360

Browse files
LebedevRILebedevRI
committed
[InstCombine][NFC] masked-merge: commutativity tests: ensure the ordering.
This was intended since initially, but i did not really think about it, and did not know how to force that. Now that the xor->or fold is working (patch upcoming), this came up to improve the test coverage. A followup for rL330003, rL330007 https://bugs.llvm.org/show_bug.cgi?id=6773 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@330039 91177308-0d34-0410-b5e6-96231b3b80d8
1 parent 24b0700 commit c833360

File tree

1 file changed

+37
-16
lines changed

1 file changed

+37
-16
lines changed

‎test/Transforms/InstCombine/masked-merge.ll‎

Lines changed: 37 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -211,6 +211,10 @@ define <3 x i32> @xor_constmask_vec_undef(<3 x i32> %x, <3 x i32> %y) {
211211
; Commutativity.
212212
; ============================================================================ ;
213213

214+
; Used to make sure that the IR complexity sorting does not interfere.
215+
declare i32 @gen32()
216+
217+
214218
define i32 @or_commutative0(i32 %x, i32 %y, i32 %m) {
215219
; CHECK-LABEL: @or_commutative0(
216220
; CHECK-NEXT: [[AND:%.*]] = and i32 [[M:%.*]], [[X:%.*]]
@@ -226,14 +230,16 @@ define i32 @or_commutative0(i32 %x, i32 %y, i32 %m) {
226230
ret i32 %or
227231
}
228232

229-
define i32 @or_commutative1(i32 %x, i32 %y, i32 %m) {
233+
define i32 @or_commutative1(i32 %x, i32 %m) {
230234
; CHECK-LABEL: @or_commutative1(
235+
; CHECK-NEXT: [[Y:%.*]] = call i32 @gen32()
231236
; CHECK-NEXT: [[AND:%.*]] = and i32 [[X:%.*]], [[M:%.*]]
232237
; CHECK-NEXT: [[NEG:%.*]] = xor i32 [[M]], -1
233-
; CHECK-NEXT: [[AND1:%.*]] = and i32 [[NEG]], [[Y:%.*]]
238+
; CHECK-NEXT: [[AND1:%.*]] = and i32 [[Y]], [[NEG]]
234239
; CHECK-NEXT: [[OR:%.*]] = or i32 [[AND]], [[AND1]]
235240
; CHECK-NEXT: ret i32 [[OR]]
236241
;
242+
%y = call i32 @gen32()
237243
%and = and i32 %x, %m
238244
%neg = xor i32 %m, -1
239245
%and1 = and i32 %y, %neg; swapped order
@@ -257,14 +263,16 @@ define i32 @or_commutative2(i32 %x, i32 %y, i32 %m) {
257263
}
258264

259265

260-
define i32 @or_commutative3(i32 %x, i32 %y, i32 %m) {
266+
define i32 @or_commutative3(i32 %x, i32 %m) {
261267
; CHECK-LABEL: @or_commutative3(
268+
; CHECK-NEXT: [[Y:%.*]] = call i32 @gen32()
262269
; CHECK-NEXT: [[AND:%.*]] = and i32 [[M:%.*]], [[X:%.*]]
263270
; CHECK-NEXT: [[NEG:%.*]] = xor i32 [[M]], -1
264-
; CHECK-NEXT: [[AND1:%.*]] = and i32 [[NEG]], [[Y:%.*]]
271+
; CHECK-NEXT: [[AND1:%.*]] = and i32 [[Y]], [[NEG]]
265272
; CHECK-NEXT: [[OR:%.*]] = or i32 [[AND]], [[AND1]]
266273
; CHECK-NEXT: ret i32 [[OR]]
267274
;
275+
%y = call i32 @gen32()
268276
%and = and i32 %m, %x ; swapped order
269277
%neg = xor i32 %m, -1
270278
%and1 = and i32 %y, %neg; swapped order
@@ -287,14 +295,16 @@ define i32 @or_commutative4(i32 %x, i32 %y, i32 %m) {
287295
ret i32 %or
288296
}
289297

290-
define i32 @or_commutative5(i32 %x, i32 %y, i32 %m) {
298+
define i32 @or_commutative5(i32 %x, i32 %m) {
291299
; CHECK-LABEL: @or_commutative5(
300+
; CHECK-NEXT: [[Y:%.*]] = call i32 @gen32()
292301
; CHECK-NEXT: [[AND:%.*]] = and i32 [[X:%.*]], [[M:%.*]]
293302
; CHECK-NEXT: [[NEG:%.*]] = xor i32 [[M]], -1
294-
; CHECK-NEXT: [[AND1:%.*]] = and i32 [[NEG]], [[Y:%.*]]
303+
; CHECK-NEXT: [[AND1:%.*]] = and i32 [[Y]], [[NEG]]
295304
; CHECK-NEXT: [[OR:%.*]] = or i32 [[AND1]], [[AND]]
296305
; CHECK-NEXT: ret i32 [[OR]]
297306
;
307+
%y = call i32 @gen32()
298308
%and = and i32 %x, %m
299309
%neg = xor i32 %m, -1
300310
%and1 = and i32 %y, %neg; swapped order
@@ -303,14 +313,16 @@ define i32 @or_commutative5(i32 %x, i32 %y, i32 %m) {
303313
}
304314

305315

306-
define i32 @or_commutative6(i32 %x, i32 %y, i32 %m) {
316+
define i32 @or_commutative6(i32 %x, i32 %m) {
307317
; CHECK-LABEL: @or_commutative6(
318+
; CHECK-NEXT: [[Y:%.*]] = call i32 @gen32()
308319
; CHECK-NEXT: [[AND:%.*]] = and i32 [[M:%.*]], [[X:%.*]]
309320
; CHECK-NEXT: [[NEG:%.*]] = xor i32 [[M]], -1
310-
; CHECK-NEXT: [[AND1:%.*]] = and i32 [[NEG]], [[Y:%.*]]
321+
; CHECK-NEXT: [[AND1:%.*]] = and i32 [[Y]], [[NEG]]
311322
; CHECK-NEXT: [[OR:%.*]] = or i32 [[AND1]], [[AND]]
312323
; CHECK-NEXT: ret i32 [[OR]]
313324
;
325+
%y = call i32 @gen32()
314326
%and = and i32 %m, %x ; swapped order
315327
%neg = xor i32 %m, -1
316328
%and1 = and i32 %y, %neg; swapped order
@@ -335,14 +347,16 @@ define i32 @xor_commutative0(i32 %x, i32 %y, i32 %m) {
335347
ret i32 %xor
336348
}
337349

338-
define i32 @xor_commutative1(i32 %x, i32 %y, i32 %m) {
350+
define i32 @xor_commutative1(i32 %x, i32 %m) {
339351
; CHECK-LABEL: @xor_commutative1(
352+
; CHECK-NEXT: [[Y:%.*]] = call i32 @gen32()
340353
; CHECK-NEXT: [[AND:%.*]] = and i32 [[X:%.*]], [[M:%.*]]
341354
; CHECK-NEXT: [[NEG:%.*]] = xor i32 [[M]], -1
342-
; CHECK-NEXT: [[AND1:%.*]] = and i32 [[NEG]], [[Y:%.*]]
355+
; CHECK-NEXT: [[AND1:%.*]] = and i32 [[Y]], [[NEG]]
343356
; CHECK-NEXT: [[XOR:%.*]] = xor i32 [[AND]], [[AND1]]
344357
; CHECK-NEXT: ret i32 [[XOR]]
345358
;
359+
%y = call i32 @gen32()
346360
%and = and i32 %x, %m
347361
%neg = xor i32 %m, -1
348362
%and1 = and i32 %y, %neg; swapped order
@@ -366,14 +380,16 @@ define i32 @xor_commutative2(i32 %x, i32 %y, i32 %m) {
366380
}
367381

368382

369-
define i32 @xor_commutative3(i32 %x, i32 %y, i32 %m) {
383+
define i32 @xor_commutative3(i32 %x, i32 %m) {
370384
; CHECK-LABEL: @xor_commutative3(
385+
; CHECK-NEXT: [[Y:%.*]] = call i32 @gen32()
371386
; CHECK-NEXT: [[AND:%.*]] = and i32 [[M:%.*]], [[X:%.*]]
372387
; CHECK-NEXT: [[NEG:%.*]] = xor i32 [[M]], -1
373-
; CHECK-NEXT: [[AND1:%.*]] = and i32 [[NEG]], [[Y:%.*]]
388+
; CHECK-NEXT: [[AND1:%.*]] = and i32 [[Y]], [[NEG]]
374389
; CHECK-NEXT: [[XOR:%.*]] = xor i32 [[AND]], [[AND1]]
375390
; CHECK-NEXT: ret i32 [[XOR]]
376391
;
392+
%y = call i32 @gen32()
377393
%and = and i32 %m, %x ; swapped order
378394
%neg = xor i32 %m, -1
379395
%and1 = and i32 %y, %neg; swapped order
@@ -396,14 +412,16 @@ define i32 @xor_commutative4(i32 %x, i32 %y, i32 %m) {
396412
ret i32 %xor
397413
}
398414

399-
define i32 @xor_commutative5(i32 %x, i32 %y, i32 %m) {
415+
define i32 @xor_commutative5(i32 %x, i32 %m) {
400416
; CHECK-LABEL: @xor_commutative5(
417+
; CHECK-NEXT: [[Y:%.*]] = call i32 @gen32()
401418
; CHECK-NEXT: [[AND:%.*]] = and i32 [[X:%.*]], [[M:%.*]]
402419
; CHECK-NEXT: [[NEG:%.*]] = xor i32 [[M]], -1
403-
; CHECK-NEXT: [[AND1:%.*]] = and i32 [[NEG]], [[Y:%.*]]
420+
; CHECK-NEXT: [[AND1:%.*]] = and i32 [[Y]], [[NEG]]
404421
; CHECK-NEXT: [[XOR:%.*]] = xor i32 [[AND1]], [[AND]]
405422
; CHECK-NEXT: ret i32 [[XOR]]
406423
;
424+
%y = call i32 @gen32()
407425
%and = and i32 %x, %m
408426
%neg = xor i32 %m, -1
409427
%and1 = and i32 %y, %neg; swapped order
@@ -412,14 +430,16 @@ define i32 @xor_commutative5(i32 %x, i32 %y, i32 %m) {
412430
}
413431

414432

415-
define i32 @xor_commutative6(i32 %x, i32 %y, i32 %m) {
433+
define i32 @xor_commutative6(i32 %x, i32 %m) {
416434
; CHECK-LABEL: @xor_commutative6(
435+
; CHECK-NEXT: [[Y:%.*]] = call i32 @gen32()
417436
; CHECK-NEXT: [[AND:%.*]] = and i32 [[M:%.*]], [[X:%.*]]
418437
; CHECK-NEXT: [[NEG:%.*]] = xor i32 [[M]], -1
419-
; CHECK-NEXT: [[AND1:%.*]] = and i32 [[NEG]], [[Y:%.*]]
438+
; CHECK-NEXT: [[AND1:%.*]] = and i32 [[Y]], [[NEG]]
420439
; CHECK-NEXT: [[XOR:%.*]] = xor i32 [[AND1]], [[AND]]
421440
; CHECK-NEXT: ret i32 [[XOR]]
422441
;
442+
%y = call i32 @gen32()
423443
%and = and i32 %m, %x ; swapped order
424444
%neg = xor i32 %m, -1
425445
%and1 = and i32 %y, %neg; swapped order
@@ -428,6 +448,7 @@ define i32 @xor_commutative6(i32 %x, i32 %y, i32 %m) {
428448
}
429449

430450

451+
431452
define i32 @or_constmask_commutative(i32 %x, i32 %y) {
432453
; CHECK-LABEL: @or_constmask_commutative(
433454
; CHECK-NEXT: [[AND:%.*]] = and i32 [[X:%.*]], 65280

0 commit comments

Comments
 (0)