This is an archive of the discontinued LLVM Phabricator instance.

Differential D155703

[InstCombine] Fold icmp or sub chain ((x1 - y1) | (x2 - y2)) == 0 tests
ClosedPublic

Authored by kitaisreal on Jul 19 2023, 6:54 AM.

Details

Reviewers
nikic
goldstein.w.n
Commits
rG5af6720d4fe1: [InstCombine] Fold icmp or sub chain ((x1 - y1) | (x2 - y2)) == 0 tests
Summary

Precommit tests for D155704.

Diff Detail

Event Timeline

kitaisreal created this revision.Jul 19 2023, 6:54 AM
Herald added a subscriber: StephenFan. · View Herald TranscriptJul 19 2023, 6:54 AM
kitaisreal requested review of this revision.Jul 19 2023, 6:54 AM
Herald added a subscriber: llvm-commits. · View Herald TranscriptJul 19 2023, 6:54 AM
kitaisreal added a child revision: D155704: [InstCombine] Fold icmp or sub chain ((x1 - y1) | (x2 - y2)) == 0.Jul 19 2023, 6:56 AM
kitaisreal mentioned this in D155704: [InstCombine] Fold icmp or sub chain ((x1 - y1) | (x2 - y2)) == 0.
kitaisreal edited the summary of this revision. (Show Details)
Harbormaster completed remote builds in B246541: Diff 542003.Jul 19 2023, 7:03 AM
kitaisreal set the repository for this revision to rG LLVM Github Monorepo.Jul 25 2023, 7:48 AM
kitaisreal updated this revision to Diff 543977.Jul 25 2023, 7:51 AM

Re-upload the same patch with mentioning correct repository LLVM Github Monorepo.

Harbormaster completed remote builds in B247997: Diff 543977.Jul 25 2023, 3:24 PM
This revision was not accepted when it landed; it landed in state Needs Review.Jul 26 2023, 9:21 AM
This revision was landed with ongoing or failed builds.
Closed by commit rG5af6720d4fe1: [InstCombine] Fold icmp or sub chain ((x1 - y1) | (x2 - y2)) == 0 tests (authored by kitaisreal). · Explain Why
This revision was automatically updated to reflect the committed changes.
kitaisreal added a commit: rG5af6720d4fe1: [InstCombine] Fold icmp or sub chain ((x1 - y1) | (x2 - y2)) == 0 tests.
kitaisreal mentioned this in rGac357a4773c2: [InstCombine] Fold icmp or sub chain ((x1 - y1) | (x2 - y2)) == 0.

Revision Contents

PathSize
llvm/
test/
Transforms/
InstCombine/
380 lines

Diff 544392

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

Show First 20 Lines • Show All 482 Lines • ▼ Show 20 Lines;
%xor2 = xor i64 %x3, %y3 %xor2 = xor i64 %x3, %y3
%or1 = or i64 %or, %xor2 %or1 = or i64 %or, %xor2
%cmp = icmp eq i64 %or1, 0 %cmp = icmp eq i64 %or1, 0
ret i1 %cmp ret i1 %cmp
} }
; negative test - and instead of or ; 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) { define i1 @icmp_or_xor_3_2_fail(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
; CHECK-LABEL: @icmp_or_xor_3_fail( ; CHECK-LABEL: @icmp_or_xor_3_2_fail(
; CHECK-NEXT: [[XOR:%.*]] = xor i64 [[X1:%.*]], [[Y1:%.*]] ; CHECK-NEXT: [[XOR:%.*]] = xor i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[XOR1:%.*]] = xor i64 [[X2:%.*]], [[Y2:%.*]] ; CHECK-NEXT: [[XOR1:%.*]] = xor i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[AND:%.*]] = and i64 [[XOR]], [[XOR1]] ; CHECK-NEXT: [[AND:%.*]] = and i64 [[XOR]], [[XOR1]]
; CHECK-NEXT: [[XOR2:%.*]] = xor i64 [[X3:%.*]], [[Y3:%.*]] ; CHECK-NEXT: [[XOR2:%.*]] = xor i64 [[X3:%.*]], [[Y3:%.*]]
; CHECK-NEXT: [[OR1:%.*]] = or i64 [[AND]], [[XOR2]] ; CHECK-NEXT: [[OR1:%.*]] = or i64 [[AND]], [[XOR2]]
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[OR1]], 0 ; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[OR1]], 0
; CHECK-NEXT: ret i1 [[CMP]] ; CHECK-NEXT: ret i1 [[CMP]]
; ;
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Lines;
%or = or i64 %xor, %xor1 %or = or i64 %xor, %xor1
%xor2 = xor i64 %x3, %y3 %xor2 = xor i64 %x3, %y3
%xor3 = xor i64 %x4, %y4 %xor3 = xor i64 %x4, %y4
%or1 = or i64 %xor2, %xor3 %or1 = or i64 %xor2, %xor3
%or2 = or i64 %or1, %or %or2 = or i64 %or1, %or
%cmp = icmp eq i64 %or2, 0 %cmp = icmp eq i64 %or2, 0
ret i1 %cmp ret i1 %cmp
} }
define i1 @icmp_or_sub_2_eq(i64 %x1, i64 %y1, i64 %x2, i64 %y2) {
; CHECK-LABEL: @icmp_or_sub_2_eq(
; CHECK-NEXT: [[SUB:%.*]] = sub i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[SUB1:%.*]] = sub i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[OR:%.*]] = or i64 [[SUB]], [[SUB1]]
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[OR]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%sub = sub i64 %x1, %y1
%sub1 = sub i64 %x2, %y2
%or = or i64 %sub, %sub1
%cmp = icmp eq i64 %or, 0
ret i1 %cmp
}
define i1 @icmp_or_sub_2_ne(i64 %x1, i64 %y1, i64 %x2, i64 %y2) {
; CHECK-LABEL: @icmp_or_sub_2_ne(
; CHECK-NEXT: [[SUB:%.*]] = sub i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[SUB1:%.*]] = sub i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[OR:%.*]] = or i64 [[SUB]], [[SUB1]]
; CHECK-NEXT: [[CMP:%.*]] = icmp ne i64 [[OR]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%sub = sub i64 %x1, %y1
%sub1 = sub i64 %x2, %y2
%or = or i64 %sub, %sub1
%cmp = icmp ne i64 %or, 0
ret i1 %cmp
}
; negative test - wrong cmp constant
define i1 @icmp_or_sub_2_eq_fail(i64 %x1, i64 %y1, i64 %x2, i64 %y2) {
; CHECK-LABEL: @icmp_or_sub_2_eq_fail(
; CHECK-NEXT: [[SUB:%.*]] = sub i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[SUB1:%.*]] = sub i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[OR:%.*]] = or i64 [[SUB]], [[SUB1]]
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[OR]], 1
; CHECK-NEXT: ret i1 [[CMP]]
;
%sub = sub i64 %x1, %y1
%sub1 = sub i64 %x2, %y2
%or = or i64 %sub, %sub1
%cmp = icmp eq i64 %or, 1
ret i1 %cmp
}
; negative test - wrong cmp constant
define i1 @icmp_or_sub_2_ne_fail(i64 %x1, i64 %y1, i64 %x2, i64 %y2) {
; CHECK-LABEL: @icmp_or_sub_2_ne_fail(
; CHECK-NEXT: [[SUB:%.*]] = sub i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[SUB1:%.*]] = sub i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[OR:%.*]] = or i64 [[SUB]], [[SUB1]]
; CHECK-NEXT: [[CMP:%.*]] = icmp ne i64 [[OR]], 1
; CHECK-NEXT: ret i1 [[CMP]]
;
%sub = sub i64 %x1, %y1
%sub1 = sub i64 %x2, %y2
%or = or i64 %sub, %sub1
%cmp = icmp ne i64 %or, 1
ret i1 %cmp
}
; negative test - sub multiuse
define i1 @icmp_or_sub_2_3_fail(i64 %x1, i64 %y1, i64 %x2, i64 %y2) {
; CHECK-LABEL: @icmp_or_sub_2_3_fail(
; CHECK-NEXT: [[SUB:%.*]] = sub i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[SUB1:%.*]] = sub i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[OR:%.*]] = or i64 [[SUB]], [[SUB1]]
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[OR]], 0
; CHECK-NEXT: [[CMP_1:%.*]] = icmp eq i64 [[SUB]], 1
; CHECK-NEXT: [[OR1:%.*]] = or i1 [[CMP]], [[CMP_1]]
; CHECK-NEXT: ret i1 [[OR1]]
;
%sub = sub i64 %x1, %y1
%sub1 = sub i64 %x2, %y2
%or = or i64 %sub, %sub1
%cmp = icmp eq i64 %or, 0
%cmp_1 = icmp eq i64 %sub, 1
%or1 = or i1 %cmp, %cmp_1
ret i1 %or1
}
; negative test - sub multiuse
define i1 @icmp_or_sub_2_4_fail(i64 %x1, i64 %y1, i64 %x2, i64 %y2) {
; CHECK-LABEL: @icmp_or_sub_2_4_fail(
; CHECK-NEXT: [[SUB:%.*]] = sub i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[SUB1:%.*]] = sub i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[OR:%.*]] = or i64 [[SUB]], [[SUB1]]
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[OR]], 0
; CHECK-NEXT: [[CMP_1:%.*]] = icmp eq i64 [[SUB1]], 1
; CHECK-NEXT: [[OR1:%.*]] = or i1 [[CMP]], [[CMP_1]]
; CHECK-NEXT: ret i1 [[OR1]]
;
%sub = sub i64 %x1, %y1
%sub1 = sub i64 %x2, %y2
%or = or i64 %sub, %sub1
%cmp = icmp eq i64 %or, 0
%cmp_1 = icmp eq i64 %sub1, 1
%or1 = or i1 %cmp, %cmp_1
ret i1 %or1
}
define i1 @icmp_or_sub_3_1(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
; CHECK-LABEL: @icmp_or_sub_3_1(
; CHECK-NEXT: [[SUB:%.*]] = sub i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[SUB1:%.*]] = sub i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[OR:%.*]] = or i64 [[SUB]], [[SUB1]]
; CHECK-NEXT: [[SUB2:%.*]] = sub i64 [[X3:%.*]], [[Y3:%.*]]
; CHECK-NEXT: [[OR1:%.*]] = or i64 [[OR]], [[SUB2]]
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[OR1]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%sub = sub i64 %x1, %y1
%sub1 = sub i64 %x2, %y2
%or = or i64 %sub, %sub1
%sub2 = sub i64 %x3, %y3
%or1 = or i64 %or, %sub2
%cmp = icmp eq i64 %or1, 0
ret i1 %cmp
}
; negative test - and instead of or
define i1 @icmp_or_sub_3_2_fail(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
; CHECK-LABEL: @icmp_or_sub_3_2_fail(
; CHECK-NEXT: [[SUB:%.*]] = sub i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[SUB1:%.*]] = sub i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[AND:%.*]] = and i64 [[SUB]], [[SUB1]]
; CHECK-NEXT: [[SUB2:%.*]] = sub i64 [[X3:%.*]], [[Y3:%.*]]
; CHECK-NEXT: [[OR1:%.*]] = or i64 [[AND]], [[SUB2]]
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[OR1]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%sub = sub i64 %x1, %y1
%sub1 = sub i64 %x2, %y2
%and = and i64 %sub, %sub1
%sub2 = sub i64 %x3, %y3
%or1 = or i64 %and, %sub2
%cmp = icmp eq i64 %or1, 0
ret i1 %cmp
}
define i1 @icmp_or_sub_3_3(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
; CHECK-LABEL: @icmp_or_sub_3_3(
; CHECK-NEXT: [[SUB:%.*]] = sub i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[SUB1:%.*]] = sub i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[OR:%.*]] = or i64 [[SUB]], [[SUB1]]
; CHECK-NEXT: [[SUB2:%.*]] = sub i64 [[X3:%.*]], [[Y3:%.*]]
; CHECK-NEXT: [[OR1:%.*]] = or i64 [[SUB2]], [[OR]]
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[OR1]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%sub = sub i64 %x1, %y1
%sub1 = sub i64 %x2, %y2
%or = or i64 %sub, %sub1
%sub2 = sub i64 %x3, %y3
%or1 = or i64 %sub2, %or
%cmp = icmp eq i64 %or1, 0
ret i1 %cmp
}
; negative test - and instead of or
define i1 @icmp_or_sub_3_4_fail(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
; CHECK-LABEL: @icmp_or_sub_3_4_fail(
; CHECK-NEXT: [[SUB:%.*]] = sub i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[SUB1:%.*]] = sub i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[AND:%.*]] = and i64 [[SUB]], [[SUB1]]
; CHECK-NEXT: [[SUB2:%.*]] = sub i64 [[X3:%.*]], [[Y3:%.*]]
; CHECK-NEXT: [[OR1:%.*]] = or i64 [[SUB2]], [[AND]]
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[OR1]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%sub = sub i64 %x1, %y1
%sub1 = sub i64 %x2, %y2
%and = and i64 %sub, %sub1
%sub2 = sub i64 %x3, %y3
%or1 = or i64 %sub2, %and
%cmp = icmp eq i64 %or1, 0
ret i1 %cmp
}
define i1 @icmp_or_sub_4_1(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3, i64 %x4, i64 %y4) {
; CHECK-LABEL: @icmp_or_sub_4_1(
; CHECK-NEXT: [[SUB:%.*]] = sub i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[SUB1:%.*]] = sub i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[OR:%.*]] = or i64 [[SUB]], [[SUB1]]
; CHECK-NEXT: [[SUB2:%.*]] = sub i64 [[X3:%.*]], [[Y3:%.*]]
; CHECK-NEXT: [[SUB3:%.*]] = sub i64 [[X4:%.*]], [[Y4:%.*]]
; CHECK-NEXT: [[OR1:%.*]] = or i64 [[SUB2]], [[SUB3]]
; CHECK-NEXT: [[OR2:%.*]] = or i64 [[OR]], [[OR1]]
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[OR2]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%sub = sub i64 %x1, %y1
%sub1 = sub i64 %x2, %y2
%or = or i64 %sub, %sub1
%sub2 = sub i64 %x3, %y3
%sub3 = sub i64 %x4, %y4
%or1 = or i64 %sub2, %sub3
%or2 = or i64 %or, %or1
%cmp = icmp eq i64 %or2, 0
ret i1 %cmp
}
define i1 @icmp_or_sub_4_2(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3, i64 %x4, i64 %y4) {
; CHECK-LABEL: @icmp_or_sub_4_2(
; CHECK-NEXT: [[SUB:%.*]] = sub i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[SUB1:%.*]] = sub i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[OR:%.*]] = or i64 [[SUB]], [[SUB1]]
; CHECK-NEXT: [[SUB2:%.*]] = sub i64 [[X3:%.*]], [[Y3:%.*]]
; CHECK-NEXT: [[SUB3:%.*]] = sub i64 [[X4:%.*]], [[Y4:%.*]]
; CHECK-NEXT: [[OR1:%.*]] = or i64 [[SUB2]], [[SUB3]]
; CHECK-NEXT: [[OR2:%.*]] = or i64 [[OR1]], [[OR]]
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[OR2]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%sub = sub i64 %x1, %y1
%sub1 = sub i64 %x2, %y2
%or = or i64 %sub, %sub1
%sub2 = sub i64 %x3, %y3
%sub3 = sub i64 %x4, %y4
%or1 = or i64 %sub2, %sub3
%or2 = or i64 %or1, %or
%cmp = icmp eq i64 %or2, 0
ret i1 %cmp
}
define i1 @icmp_or_xor_with_sub_2_eq(i64 %x1, i64 %y1, i64 %x2, i64 %y2) {
; CHECK-LABEL: @icmp_or_xor_with_sub_2_eq(
; CHECK-NEXT: [[XOR:%.*]] = xor i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[SUB:%.*]] = sub i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[OR:%.*]] = or i64 [[XOR]], [[SUB]]
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[OR]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%xor = xor i64 %x1, %y1
%sub = sub i64 %x2, %y2
%or = or i64 %xor, %sub
%cmp = icmp eq i64 %or, 0
ret i1 %cmp
}
define i1 @icmp_or_xor_with_sub_2_ne(i64 %x1, i64 %y1, i64 %x2, i64 %y2) {
; CHECK-LABEL: @icmp_or_xor_with_sub_2_ne(
; CHECK-NEXT: [[XOR:%.*]] = xor i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[SUB:%.*]] = sub i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[OR:%.*]] = or i64 [[XOR]], [[SUB]]
; CHECK-NEXT: [[CMP:%.*]] = icmp ne i64 [[OR]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%xor = xor i64 %x1, %y1
%sub = sub i64 %x2, %y2
%or = or i64 %xor, %sub
%cmp = icmp ne i64 %or, 0
ret i1 %cmp
}
define i1 @icmp_or_xor_with_sub_3_1(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
; CHECK-LABEL: @icmp_or_xor_with_sub_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: [[SUB1:%.*]] = sub i64 [[X3:%.*]], [[Y3:%.*]]
; CHECK-NEXT: [[OR1:%.*]] = or i64 [[OR]], [[SUB1]]
; 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
%sub1 = sub i64 %x3, %y3
%or1 = or i64 %or, %sub1
%cmp = icmp eq i64 %or1, 0
ret i1 %cmp
}
define i1 @icmp_or_xor_with_sub_3_2(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
; CHECK-LABEL: @icmp_or_xor_with_sub_3_2(
; CHECK-NEXT: [[XOR:%.*]] = xor i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[SUB:%.*]] = sub i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[OR:%.*]] = or i64 [[XOR]], [[SUB]]
; CHECK-NEXT: [[XOR1:%.*]] = xor i64 [[X3:%.*]], [[Y3:%.*]]
; CHECK-NEXT: [[OR1:%.*]] = or i64 [[OR]], [[XOR1]]
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[OR1]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%xor = xor i64 %x1, %y1
%sub = sub i64 %x2, %y2
%or = or i64 %xor, %sub
%xor1 = xor i64 %x3, %y3
%or1 = or i64 %or, %xor1
%cmp = icmp eq i64 %or1, 0
ret i1 %cmp
}
define i1 @icmp_or_xor_with_sub_3_3(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
; CHECK-LABEL: @icmp_or_xor_with_sub_3_3(
; CHECK-NEXT: [[XOR:%.*]] = xor i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[SUB:%.*]] = sub i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[OR:%.*]] = or i64 [[XOR]], [[SUB]]
; CHECK-NEXT: [[SUB1:%.*]] = sub i64 [[X3:%.*]], [[Y3:%.*]]
; CHECK-NEXT: [[OR1:%.*]] = or i64 [[OR]], [[SUB1]]
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[OR1]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%xor = xor i64 %x1, %y1
%sub = sub i64 %x2, %y2
%or = or i64 %xor, %sub
%sub1 = sub i64 %x3, %y3
%or1 = or i64 %or, %sub1
%cmp = icmp eq i64 %or1, 0
ret i1 %cmp
}
define i1 @icmp_or_xor_with_sub_3_4(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
; CHECK-LABEL: @icmp_or_xor_with_sub_3_4(
; CHECK-NEXT: [[SUB:%.*]] = sub i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[XOR:%.*]] = xor i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[OR:%.*]] = or i64 [[SUB]], [[XOR]]
; CHECK-NEXT: [[XOR1:%.*]] = xor i64 [[X3:%.*]], [[Y3:%.*]]
; CHECK-NEXT: [[OR1:%.*]] = or i64 [[OR]], [[XOR1]]
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[OR1]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%sub = sub i64 %x1, %y1
%xor = xor i64 %x2, %y2
%or = or i64 %sub, %xor
%xor1 = xor i64 %x3, %y3
%or1 = or i64 %or, %xor1
%cmp = icmp eq i64 %or1, 0
ret i1 %cmp
}
define i1 @icmp_or_xor_with_sub_3_5(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
; CHECK-LABEL: @icmp_or_xor_with_sub_3_5(
; CHECK-NEXT: [[SUB:%.*]] = sub i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[XOR:%.*]] = xor i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[OR:%.*]] = or i64 [[SUB]], [[XOR]]
; CHECK-NEXT: [[SUB1:%.*]] = sub i64 [[X3:%.*]], [[Y3:%.*]]
; CHECK-NEXT: [[OR1:%.*]] = or i64 [[OR]], [[SUB1]]
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[OR1]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%sub = sub i64 %x1, %y1
%xor = xor i64 %x2, %y2
%or = or i64 %sub, %xor
%sub1 = sub i64 %x3, %y3
%or1 = or i64 %or, %sub1
%cmp = icmp eq i64 %or1, 0
ret i1 %cmp
}
define i1 @icmp_or_xor_with_sub_3_6(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
; CHECK-LABEL: @icmp_or_xor_with_sub_3_6(
; CHECK-NEXT: [[SUB:%.*]] = sub i64 [[X1:%.*]], [[Y1:%.*]]
; CHECK-NEXT: [[SUB1:%.*]] = sub i64 [[X2:%.*]], [[Y2:%.*]]
; CHECK-NEXT: [[OR:%.*]] = or i64 [[SUB]], [[SUB1]]
; CHECK-NEXT: [[XOR:%.*]] = xor i64 [[X3:%.*]], [[Y3:%.*]]
; CHECK-NEXT: [[OR1:%.*]] = or i64 [[OR]], [[XOR]]
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[OR1]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%sub = sub i64 %x1, %y1
%sub1 = sub i64 %x2, %y2
%or = or i64 %sub, %sub1
%xor = xor i64 %x3, %y3
%or1 = or i64 %or, %xor
%cmp = icmp eq i64 %or1, 0
ret i1 %cmp
}