This is an archive of the discontinued LLVM Phabricator instance.

Differential D154384

[InstCombine] Generalise ((x1 ^ y1) | (x2 ^ y2)) == 0 transform tests
ClosedPublic

Authored by kitaisreal on Jul 3 2023, 11:46 AM.

Details

Reviewers
goldstein.w.n
nikic
Commits
rG39f0afde98f3: [InstCombine] Generalise ((x1 ^ y1) | (x2 ^ y2)) == 0 transform tests
Summary

Precommit tests for D154306.

Diff Detail

Event Timeline

kitaisreal requested review of this revision.Jul 3 2023, 11:46 AM
kitaisreal created this revision.
Herald added a subscriber: llvm-commits. · View Herald TranscriptJul 3 2023, 11:46 AM
kitaisreal mentioned this in D154306: [InstCombine] Generalise ((x1 ^ y1) | (x2 ^ y2)) == 0 transform.Jul 3 2023, 11:47 AM
Harbormaster completed remote builds in B242867: Diff 536857.Jul 3 2023, 3:28 PM
kitaisreal updated this revision to Diff 537753.Jul 6 2023, 8:54 AM

Added negative test cases.

Harbormaster completed remote builds in B243489: Diff 537753.Jul 6 2023, 9:41 AM
kitaisreal updated this revision to Diff 539638.Jul 12 2023, 10:51 AM
kitaisreal retitled this revision from [InstCombine] added icmp or xor tests to [InstCombine] Generalise ((x1 ^ y1) | (x2 ^ y2)) == 0 transform tests.
kitaisreal edited the summary of this revision. (Show Details)

Updated tests.

kitaisreal added a reviewer: nikic.Jul 12 2023, 10:52 AM
Herald added a subscriber: StephenFan. · View Herald TranscriptJul 12 2023, 10:52 AM
Harbormaster completed remote builds in B244849: Diff 539638.Jul 12 2023, 2:51 PM
kitaisreal added a child revision: D154306: [InstCombine] Generalise ((x1 ^ y1) | (x2 ^ y2)) == 0 transform.Jul 13 2023, 2:47 AM
kitaisreal removed a child revision: D154306: [InstCombine] Generalise ((x1 ^ y1) | (x2 ^ y2)) == 0 transform.Jul 13 2023, 2:51 AM
kitaisreal added a parent revision: D154306: [InstCombine] Generalise ((x1 ^ y1) | (x2 ^ y2)) == 0 transform.
kitaisreal removed a parent revision: D154306: [InstCombine] Generalise ((x1 ^ y1) | (x2 ^ y2)) == 0 transform.
kitaisreal added a child revision: D154306: [InstCombine] Generalise ((x1 ^ y1) | (x2 ^ y2)) == 0 transform.
kitaisreal updated this revision to Diff 540346.Jul 14 2023, 3:21 AM

Updated tests.

Harbormaster completed remote builds in B245344: Diff 540346.Jul 14 2023, 4:17 AM
This revision was not accepted when it landed; it landed in state Needs Review.Jul 15 2023, 2:57 PM
This revision was landed with ongoing or failed builds.
Closed by commit rG39f0afde98f3: [InstCombine] Generalise ((x1 ^ y1) | (x2 ^ y2)) == 0 transform tests (authored by kitaisreal, committed by goldstein.w.n). · Explain Why
This revision was automatically updated to reflect the committed changes.
goldstein.w.n added a commit: rG39f0afde98f3: [InstCombine] Generalise ((x1 ^ y1) | (x2 ^ y2)) == 0 transform tests.
goldstein.w.n mentioned this in rGda822ce90ed9: [InstCombine] Generalise ((x1 ^ y1) | (x2 ^ y2)) == 0 transform.

Revision Contents

PathSize
llvm/
test/
Transforms/
InstCombine/
232 lines

Diff 540742

llvm/test/Transforms/InstCombine/icmp-or.ll

Show First 20 Lines • Show All 357 Lines • ▼ Show 20 Lines
; CHECK-NEXT: [[R:%.*]] = icmp sgt i8 [[OR]], -1 ; CHECK-NEXT: [[R:%.*]] = icmp sgt i8 [[OR]], -1
; CHECK-NEXT: ret i1 [[R]] ; CHECK-NEXT: ret i1 [[R]]
; ;
%dec = add i8 %x, -2 %dec = add i8 %x, -2
%or = or i8 %dec, %x %or = or i8 %dec, %x
%r = icmp sgt i8 %or, -1 %r = icmp sgt i8 %or, -1
ret i1 %r ret i1 %r
} }
define i1 @icmp_or_xor_2_eq(i64 %x1, i64 %y1, i64 %x2, i64 %y2) {
; CHECK-LABEL: @icmp_or_xor_2_eq(
; CHECK-NEXT: [[XOR:%.*]] = xor i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[XOR1:%.*]] = xor i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[OR:%.*]] = or i64 [[XOR]], [[XOR1]]
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[OR]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%xor = xor i64 %x1, %y1
%xor1 = xor i64 %x2, %y2
%or = or i64 %xor, %xor1
%cmp = icmp eq i64 %or, 0
ret i1 %cmp
}
define i1 @icmp_or_xor_2_ne(i64 %x1, i64 %y1, i64 %x2, i64 %y2) {
; CHECK-LABEL: @icmp_or_xor_2_ne(
; CHECK-NEXT: [[XOR:%.*]] = xor i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[XOR1:%.*]] = xor i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[OR:%.*]] = or i64 [[XOR]], [[XOR1]]
; CHECK-NEXT: [[CMP:%.*]] = icmp ne i64 [[OR]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%xor = xor i64 %x1, %y1
%xor1 = xor i64 %x2, %y2
%or = or i64 %xor, %xor1
%cmp = icmp ne i64 %or, 0
ret i1 %cmp
}
; negative test - wrong cmp constant
define i1 @icmp_or_xor_2_eq_fail(i64 %x1, i64 %y1, i64 %x2, i64 %y2) {
; CHECK-LABEL: @icmp_or_xor_2_eq_fail(
; CHECK-NEXT: [[XOR:%.*]] = xor i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[XOR1:%.*]] = xor i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[OR:%.*]] = or i64 [[XOR]], [[XOR1]]
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[OR]], 1
; CHECK-NEXT: ret i1 [[CMP]]
;
%xor = xor i64 %x1, %y1
%xor1 = xor i64 %x2, %y2
%or = or i64 %xor, %xor1
%cmp = icmp eq i64 %or, 1
ret i1 %cmp
}
; negative test - wrong cmp constant
define i1 @icmp_or_xor_2_ne_fail(i64 %x1, i64 %y1, i64 %x2, i64 %y2) {
; CHECK-LABEL: @icmp_or_xor_2_ne_fail(
; CHECK-NEXT: [[XOR:%.*]] = xor i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[XOR1:%.*]] = xor i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[OR:%.*]] = or i64 [[XOR]], [[XOR1]]
; CHECK-NEXT: [[CMP:%.*]] = icmp ne i64 [[OR]], 1
; CHECK-NEXT: ret i1 [[CMP]]
;
%xor = xor i64 %x1, %y1
%xor1 = xor i64 %x2, %y2
%or = or i64 %xor, %xor1
%cmp = icmp ne i64 %or, 1
ret i1 %cmp
}
; negative test - xor multiuse
define i1 @icmp_or_xor_2_3_fail(i64 %x1, i64 %y1, i64 %x2, i64 %y2) {
; CHECK-LABEL: @icmp_or_xor_2_3_fail(
; CHECK-NEXT: [[XOR:%.*]] = xor i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[XOR1:%.*]] = xor i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[OR:%.*]] = or i64 [[XOR]], [[XOR1]]
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[OR]], 0
; CHECK-NEXT: [[CMP_1:%.*]] = icmp eq i64 [[XOR]], 0
; CHECK-NEXT: [[OR1:%.*]] = or i1 [[CMP]], [[CMP_1]]
; CHECK-NEXT: ret i1 [[OR1]]
;
%xor = xor i64 %x1, %y1
%xor1 = xor i64 %x2, %y2
%or = or i64 %xor, %xor1
%cmp = icmp eq i64 %or, 0
%cmp_1 = icmp eq i64 %xor, 0
%or1 = or i1 %cmp, %cmp_1
ret i1 %or1
}
; negative test - xor multiuse
define i1 @icmp_or_xor_2_4_fail(i64 %x1, i64 %y1, i64 %x2, i64 %y2) {
; CHECK-LABEL: @icmp_or_xor_2_4_fail(
; CHECK-NEXT: [[XOR:%.*]] = xor i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[XOR1:%.*]] = xor i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[OR:%.*]] = or i64 [[XOR]], [[XOR1]]
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[OR]], 0
; CHECK-NEXT: [[CMP_1:%.*]] = icmp eq i64 [[XOR1]], 0
; CHECK-NEXT: [[OR1:%.*]] = or i1 [[CMP]], [[CMP_1]]
; CHECK-NEXT: ret i1 [[OR1]]
;
%xor = xor i64 %x1, %y1
%xor1 = xor i64 %x2, %y2
%or = or i64 %xor, %xor1
%cmp = icmp eq i64 %or, 0
%cmp_1 = icmp eq i64 %xor1, 0
%or1 = or i1 %cmp, %cmp_1
ret i1 %or1
}
define i1 @icmp_or_xor_3_1(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
; CHECK-LABEL: @icmp_or_xor_3_1(
; CHECK-NEXT: [[XOR:%.*]] = xor i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[XOR1:%.*]] = xor i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[OR:%.*]] = or i64 [[XOR]], [[XOR1]]
; CHECK-NEXT: [[XOR2:%.*]] = xor i64 [[X3:%.*]], [[Y3:%.*]]
; CHECK-NEXT: [[OR1:%.*]] = or i64 [[OR]], [[XOR2]]
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[OR1]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%xor = xor i64 %x1, %y1
%xor1 = xor i64 %x2, %y2
%or = or i64 %xor, %xor1
%xor2 = xor i64 %x3, %y3
%or1 = or i64 %or, %xor2
%cmp = icmp eq i64 %or1, 0
ret i1 %cmp
}
; negative test - and instead of or
define i1 @icmp_or_xor_3_fail(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
; CHECK-LABEL: @icmp_or_xor_3_fail(
; CHECK-NEXT: [[XOR:%.*]] = xor i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[XOR1:%.*]] = xor i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[AND:%.*]] = and i64 [[XOR]], [[XOR1]]
; CHECK-NEXT: [[XOR2:%.*]] = xor i64 [[X3:%.*]], [[Y3:%.*]]
; CHECK-NEXT: [[OR1:%.*]] = or i64 [[AND]], [[XOR2]]
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[OR1]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%xor = xor i64 %x1, %y1
%xor1 = xor i64 %x2, %y2
%and = and i64 %xor, %xor1
%xor2 = xor i64 %x3, %y3
%or1 = or i64 %and, %xor2
%cmp = icmp eq i64 %or1, 0
ret i1 %cmp
}
define i1 @icmp_or_xor_3_3(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
; CHECK-LABEL: @icmp_or_xor_3_3(
; CHECK-NEXT: [[XOR:%.*]] = xor i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[XOR1:%.*]] = xor i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[OR:%.*]] = or i64 [[XOR]], [[XOR1]]
; CHECK-NEXT: [[XOR2:%.*]] = xor i64 [[X3:%.*]], [[Y3:%.*]]
; CHECK-NEXT: [[OR1:%.*]] = or i64 [[XOR2]], [[OR]]
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[OR1]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%xor = xor i64 %x1, %y1
%xor1 = xor i64 %x2, %y2
%or = or i64 %xor, %xor1
%xor2 = xor i64 %x3, %y3
%or1 = or i64 %xor2, %or
%cmp = icmp eq i64 %or1, 0
ret i1 %cmp
}
; negative test - and instead of or
define i1 @icmp_or_xor_3_4_fail(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
; CHECK-LABEL: @icmp_or_xor_3_4_fail(
; CHECK-NEXT: [[XOR:%.*]] = xor i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[XOR1:%.*]] = xor i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[AND:%.*]] = and i64 [[XOR]], [[XOR1]]
; CHECK-NEXT: [[XOR2:%.*]] = xor i64 [[X3:%.*]], [[Y3:%.*]]
; CHECK-NEXT: [[OR1:%.*]] = or i64 [[XOR2]], [[AND]]
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[OR1]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%xor = xor i64 %x1, %y1
%xor1 = xor i64 %x2, %y2
%and = and i64 %xor, %xor1
%xor2 = xor i64 %x3, %y3
%or1 = or i64 %xor2, %and
%cmp = icmp eq i64 %or1, 0
ret i1 %cmp
}
define i1 @icmp_or_xor_4_1(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3, i64 %x4, i64 %y4) {
; CHECK-LABEL: @icmp_or_xor_4_1(
; CHECK-NEXT: [[XOR:%.*]] = xor i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[XOR1:%.*]] = xor i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[OR:%.*]] = or i64 [[XOR]], [[XOR1]]
; CHECK-NEXT: [[XOR2:%.*]] = xor i64 [[X3:%.*]], [[Y3:%.*]]
; CHECK-NEXT: [[XOR3:%.*]] = xor i64 [[X4:%.*]], [[Y4:%.*]]
; CHECK-NEXT: [[OR1:%.*]] = or i64 [[XOR2]], [[XOR3]]
; CHECK-NEXT: [[OR2:%.*]] = or i64 [[OR]], [[OR1]]
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[OR2]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%xor = xor i64 %x1, %y1
%xor1 = xor i64 %x2, %y2
%or = or i64 %xor, %xor1
%xor2 = xor i64 %x3, %y3
%xor3 = xor i64 %x4, %y4
%or1 = or i64 %xor2, %xor3
%or2 = or i64 %or, %or1
%cmp = icmp eq i64 %or2, 0
ret i1 %cmp
}
define i1 @icmp_or_xor_4_2(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3, i64 %x4, i64 %y4) {
; CHECK-LABEL: @icmp_or_xor_4_2(
; CHECK-NEXT: [[XOR:%.*]] = xor i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[XOR1:%.*]] = xor i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[OR:%.*]] = or i64 [[XOR]], [[XOR1]]
; CHECK-NEXT: [[XOR2:%.*]] = xor i64 [[X3:%.*]], [[Y3:%.*]]
; CHECK-NEXT: [[XOR3:%.*]] = xor i64 [[X4:%.*]], [[Y4:%.*]]
; CHECK-NEXT: [[OR1:%.*]] = or i64 [[XOR2]], [[XOR3]]
; CHECK-NEXT: [[OR2:%.*]] = or i64 [[OR1]], [[OR]]
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[OR2]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%xor = xor i64 %x1, %y1
%xor1 = xor i64 %x2, %y2
%or = or i64 %xor, %xor1
%xor2 = xor i64 %x3, %y3
%xor3 = xor i64 %x4, %y4
%or1 = or i64 %xor2, %xor3
%or2 = or i64 %or1, %or
%cmp = icmp eq i64 %or2, 0
ret i1 %cmp
}