This is an archive of the discontinued LLVM Phabricator instance.

Differential D159059

[InstCombine] Make the `(icmp eq/ne (and X, Y), X)` canonicalization work for non-const operands
AbandonedPublic

Authored by goldstein.w.n on Aug 28 2023, 9:29 PM.

Details

Reviewers
nikic
RKSimon
Allen
Summary

We currently do:

`(icmp eq/ne (and X, Y), Y)` -> `(icmp eq/ne (and ~X, Y), 0)`

if X is constant. We can make this more general and do it if X is
freely invertable (i.e say X = ~Z).

As well, we can also do:

`(icmp eq/ne (and X, Y), Y)` -> `(icmp eq/ne (or X, ~Y), -1)`

If Y is freely invertible.

Proofs: https://alive2.llvm.org/ce/z/yeWH3E

Diff Detail

Event Timeline

goldstein.w.n created this revision.Aug 28 2023, 9:29 PM
Herald added a project: Restricted Project. · View Herald TranscriptAug 28 2023, 9:29 PM
Herald added subscribers: StephenFan, hiraditya. · View Herald Transcript
goldstein.w.n requested review of this revision.Aug 28 2023, 9:29 PM
Herald added a project: Restricted Project. · View Herald TranscriptAug 28 2023, 9:29 PM
Herald added a subscriber: llvm-commits. · View Herald Transcript
Harbormaster completed remote builds in B255401: Diff 554166.Aug 28 2023, 9:30 PM
goldstein.w.n added a parent revision: D159058: [InstCombine] Improve mask detection in `foldICmpWithLowBitMaskedVal`.Aug 28 2023, 9:33 PM
goldstein.w.n added a child revision: D159060: [InstCombine] Make `getKnownSign` a member function of InstCombiner; NFC.
goldstein.w.n mentioned this in D145425: [InstCombine] Transform `(icmp ult/uge (and X, Y), X)` -> `(icmp ne/eq (and X, Y), X)`.Aug 28 2023, 9:37 PM
goldstein.w.n updated this revision to Diff 555229.Aug 31 2023, 6:30 PM

Rebase

goldstein.w.n removed a parent revision: D159058: [InstCombine] Improve mask detection in `foldICmpWithLowBitMaskedVal`.Aug 31 2023, 6:35 PM
goldstein.w.n added a parent revision: D159329: [InstCombine] Recognize `(icmp eq/ne (and X, ~Mask), 0)` pattern in `foldICmpWithLowBitMaskedVal`.
goldstein.w.n updated this revision to Diff 556704.Sep 13 2023, 12:55 PM

Rebase

Harbormaster completed remote builds in B257176: Diff 556704.Sep 13 2023, 2:37 PM
goldstein.w.n abandoned this revision.Sep 19 2023, 9:10 AM

Abandoning and resubmitting on GH

Revision Contents

Diff 556704

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 4,572 Lines • ▼ Show 20 Linesstatic Instruction *foldICmpAndXX(ICmpInst &I, const SimplifyQuery &Q,
// (icmp (X & Y) u< X --> (X & Y) != X // (icmp (X & Y) u< X --> (X & Y) != X
if (Pred == ICmpInst::ICMP_ULT) if (Pred == ICmpInst::ICMP_ULT)
return new ICmpInst(ICmpInst::ICMP_NE, Op0, Op1); return new ICmpInst(ICmpInst::ICMP_NE, Op0, Op1);
// (icmp (X & Y) u>= X --> (X & Y) == X // (icmp (X & Y) u>= X --> (X & Y) == X
if (Pred == ICmpInst::ICMP_UGE) if (Pred == ICmpInst::ICMP_UGE)
return new ICmpInst(ICmpInst::ICMP_EQ, Op0, Op1); return new ICmpInst(ICmpInst::ICMP_EQ, Op0, Op1);
if (ICmpInst::isEquality(Pred) && Op0->hasOneUse()) {
// icmp (X & Y) eq/ne Y --> (X | ~Y) eq/ne -1 if Y is freely invertible and
// Y is non-constant. If Y is constant this form is preferable (and
// canonicalize too it elsewhere).
if (!match(Op1, m_ImmConstant()) &&
IC.isFreeToInvert(Op1, Op1->hasOneUse() || Op1->hasNUses(2)))
return new ICmpInst(Pred,
IC.Builder.CreateOr(A, IC.Builder.CreateNot(Op1)),
Constant::getAllOnesValue(Op1->getType()));
// icmp (X & Y) eq/ne Y --> (~X & Y) eq/ne 0 if X is freely invertible.
if (IC.isFreeToInvert(A, A->hasOneUse()))
return new ICmpInst(Pred,
IC.Builder.CreateAnd(Op1, IC.Builder.CreateNot(A)),
Constant::getNullValue(Op1->getType()));
}
return nullptr; return nullptr;
} }
static Instruction *foldICmpOrXX(ICmpInst &I, const SimplifyQuery &Q, static Instruction *foldICmpOrXX(ICmpInst &I, const SimplifyQuery &Q,
InstCombinerImpl &IC) { InstCombinerImpl &IC) {
Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1), *A; Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1), *A;
// Normalize or operand as operand 0. // Normalize or operand as operand 0.
▲ Show 20 Lines • Show All 750 Lines • ▼ Show 20 Lines if (match(Op1, m_Xor(m_Value(C), m_Value(D)))) {
return new ICmpInst(Pred, B, C); return new ICmpInst(Pred, B, C);
if (B == C) if (B == C)
return new ICmpInst(Pred, A, D); return new ICmpInst(Pred, A, D);
if (B == D) if (B == D)
return new ICmpInst(Pred, A, C); return new ICmpInst(Pred, A, C);
} }
} }
// canoncalize:
// (icmp eq/ne (and X, C), X)
// -> (icmp eq/ne (and X, ~C), 0)
{
Constant *CMask;
A = nullptr;
if (match(Op0, m_OneUse(m_And(m_Specific(Op1), m_ImmConstant(CMask)))))
A = Op1;
else if (match(Op1, m_OneUse(m_And(m_Specific(Op0), m_ImmConstant(CMask)))))
A = Op0;
if (A)
return new ICmpInst(Pred, Builder.CreateAnd(A, Builder.CreateNot(CMask)),
Constant::getNullValue(A->getType()));
}
if (match(Op1, m_Xor(m_Value(A), m_Value(B))) && (A == Op0 || B == Op0)) { if (match(Op1, m_Xor(m_Value(A), m_Value(B))) && (A == Op0 || B == Op0)) {
// A == (A^B) -> B == 0 // A == (A^B) -> B == 0
Value *OtherVal = A == Op0 ? B : A; Value *OtherVal = A == Op0 ? B : A;
return new ICmpInst(Pred, OtherVal, Constant::getNullValue(A->getType())); return new ICmpInst(Pred, OtherVal, Constant::getNullValue(A->getType()));
} }
// (X&Z) == (Y&Z) -> (X^Y) & Z == 0 // (X&Z) == (Y&Z) -> (X^Y) & Z == 0
if (match(Op0, m_OneUse(m_And(m_Value(A), m_Value(B)))) && if (match(Op0, m_OneUse(m_And(m_Value(A), m_Value(B)))) &&
▲ Show 20 Lines • Show All 2,537 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize-low-bit-mask-v2-and-icmp-eq-to-icmp-ule.ll

Show First 20 Lines • Show All 263 Lines • ▼ Show 20 Lines;
%t2 = and i8 %t1, %x %t2 = and i8 %t1, %x
%ret = icmp eq i8 %t2, %notx ; not %x %ret = icmp eq i8 %t2, %notx ; not %x
ret i1 %ret ret i1 %ret
} }
define i1 @n1(i8 %x, i8 %y) { define i1 @n1(i8 %x, i8 %y) {
; CHECK-LABEL: @n1( ; CHECK-LABEL: @n1(
; CHECK-NEXT: [[T0:%.*]] = shl nuw i8 1, [[Y:%.*]] ; CHECK-NEXT: [[T0:%.*]] = shl nuw i8 1, [[Y:%.*]]
; CHECK-NEXT: [[T1:%.*]] = xor i8 [[T0]], -1 ; CHECK-NEXT: [[TMP1:%.*]] = and i8 [[T0]], [[X:%.*]]
; CHECK-NEXT: [[T2:%.*]] = and i8 [[T1]], [[X:%.*]] ; CHECK-NEXT: [[RET:%.*]] = icmp eq i8 [[TMP1]], 0
; CHECK-NEXT: [[RET:%.*]] = icmp eq i8 [[T2]], [[X]]
; CHECK-NEXT: ret i1 [[RET]] ; CHECK-NEXT: ret i1 [[RET]]
; ;
%t0 = shl i8 1, %y ; not -1 %t0 = shl i8 1, %y ; not -1
%t1 = xor i8 %t0, -1 %t1 = xor i8 %t0, -1
%t2 = and i8 %t1, %x %t2 = and i8 %t1, %x
%ret = icmp eq i8 %t2, %x %ret = icmp eq i8 %t2, %x
ret i1 %ret ret i1 %ret
} }
Show All 15 Lines

llvm/test/Transforms/InstCombine/canonicalize-low-bit-mask-v2-and-icmp-ne-to-icmp-ugt.ll

Show First 20 Lines • Show All 263 Lines • ▼ Show 20 Lines;
%t2 = and i8 %t1, %x %t2 = and i8 %t1, %x
%ret = icmp ne i8 %t2, %notx ; not %x %ret = icmp ne i8 %t2, %notx ; not %x
ret i1 %ret ret i1 %ret
} }
define i1 @n1(i8 %x, i8 %y) { define i1 @n1(i8 %x, i8 %y) {
; CHECK-LABEL: @n1( ; CHECK-LABEL: @n1(
; CHECK-NEXT: [[T0:%.*]] = shl nuw i8 1, [[Y:%.*]] ; CHECK-NEXT: [[T0:%.*]] = shl nuw i8 1, [[Y:%.*]]
; CHECK-NEXT: [[T1:%.*]] = xor i8 [[T0]], -1 ; CHECK-NEXT: [[TMP1:%.*]] = and i8 [[T0]], [[X:%.*]]
; CHECK-NEXT: [[T2:%.*]] = and i8 [[T1]], [[X:%.*]] ; CHECK-NEXT: [[RET:%.*]] = icmp ne i8 [[TMP1]], 0
; CHECK-NEXT: [[RET:%.*]] = icmp ne i8 [[T2]], [[X]]
; CHECK-NEXT: ret i1 [[RET]] ; CHECK-NEXT: ret i1 [[RET]]
; ;
%t0 = shl i8 1, %y ; not -1 %t0 = shl i8 1, %y ; not -1
%t1 = xor i8 %t0, -1 %t1 = xor i8 %t0, -1
%t2 = and i8 %t1, %x %t2 = and i8 %t1, %x
%ret = icmp ne i8 %t2, %x %ret = icmp ne i8 %t2, %x
ret i1 %ret ret i1 %ret
} }
Show All 15 Lines

llvm/test/Transforms/InstCombine/canonicalize-low-bit-mask-v3-and-icmp-eq-to-icmp-ule.ll

Show First 20 Lines • Show All 245 Lines • ▼ Show 20 Lines;
%ret = icmp eq i8 %t2, %notx ; not %x %ret = icmp eq i8 %t2, %notx ; not %x
ret i1 %ret ret i1 %ret
} }
define i1 @n1(i8 %x, i8 %y) { define i1 @n1(i8 %x, i8 %y) {
; CHECK-LABEL: @n1( ; CHECK-LABEL: @n1(
; CHECK-NEXT: [[T0:%.*]] = shl i8 -1, [[Y:%.*]] ; CHECK-NEXT: [[T0:%.*]] = shl i8 -1, [[Y:%.*]]
; CHECK-NEXT: call void @use8(i8 [[T0]]) ; CHECK-NEXT: call void @use8(i8 [[T0]])
; CHECK-NEXT: [[T1:%.*]] = add i8 [[T0]], -1 ; CHECK-NEXT: [[TMP1:%.*]] = sub i8 0, [[T0]]
; CHECK-NEXT: [[T2:%.*]] = and i8 [[T1]], [[X:%.*]] ; CHECK-NEXT: [[TMP2:%.*]] = and i8 [[TMP1]], [[X:%.*]]
; CHECK-NEXT: [[RET:%.*]] = icmp eq i8 [[T2]], [[X]] ; CHECK-NEXT: [[RET:%.*]] = icmp eq i8 [[TMP2]], 0
; CHECK-NEXT: ret i1 [[RET]] ; CHECK-NEXT: ret i1 [[RET]]
; ;
%t0 = shl i8 -1, %y ; not 1 %t0 = shl i8 -1, %y ; not 1
call void @use8(i8 %t0) call void @use8(i8 %t0)
%t1 = add i8 %t0, -1 %t1 = add i8 %t0, -1
%t2 = and i8 %t1, %x %t2 = and i8 %t1, %x
%ret = icmp eq i8 %t2, %x %ret = icmp eq i8 %t2, %x
ret i1 %ret ret i1 %ret
} }
define i1 @n2(i8 %x, i8 %y) { define i1 @n2(i8 %x, i8 %y) {
; CHECK-LABEL: @n2( ; CHECK-LABEL: @n2(
; CHECK-NEXT: [[T0:%.*]] = shl nuw i8 1, [[Y:%.*]] ; CHECK-NEXT: [[T0:%.*]] = shl nuw i8 1, [[Y:%.*]]
; CHECK-NEXT: call void @use8(i8 [[T0]]) ; CHECK-NEXT: call void @use8(i8 [[T0]])
; CHECK-NEXT: [[T1:%.*]] = add nuw i8 [[T0]], 1 ; CHECK-NEXT: [[TMP1:%.*]] = sub nuw i8 -2, [[T0]]
; CHECK-NEXT: [[T2:%.*]] = and i8 [[T1]], [[X:%.*]] ; CHECK-NEXT: [[TMP2:%.*]] = and i8 [[TMP1]], [[X:%.*]]
; CHECK-NEXT: [[RET:%.*]] = icmp eq i8 [[T2]], [[X]] ; CHECK-NEXT: [[RET:%.*]] = icmp eq i8 [[TMP2]], 0
; CHECK-NEXT: ret i1 [[RET]] ; CHECK-NEXT: ret i1 [[RET]]
; ;
%t0 = shl i8 1, %y %t0 = shl i8 1, %y
call void @use8(i8 %t0) call void @use8(i8 %t0)
%t1 = add i8 %t0, 1 ; not -1 %t1 = add i8 %t0, 1 ; not -1
%t2 = and i8 %t1, %x %t2 = and i8 %t1, %x
%ret = icmp eq i8 %t2, %x %ret = icmp eq i8 %t2, %x
ret i1 %ret ret i1 %ret
} }

llvm/test/Transforms/InstCombine/canonicalize-low-bit-mask-v3-and-icmp-ne-to-icmp-ugt.ll

Show First 20 Lines • Show All 245 Lines • ▼ Show 20 Lines;
%ret = icmp ne i8 %t2, %notx ; not %x %ret = icmp ne i8 %t2, %notx ; not %x
ret i1 %ret ret i1 %ret
} }
define i1 @n1(i8 %x, i8 %y) { define i1 @n1(i8 %x, i8 %y) {
; CHECK-LABEL: @n1( ; CHECK-LABEL: @n1(
; CHECK-NEXT: [[T0:%.*]] = shl i8 -1, [[Y:%.*]] ; CHECK-NEXT: [[T0:%.*]] = shl i8 -1, [[Y:%.*]]
; CHECK-NEXT: call void @use8(i8 [[T0]]) ; CHECK-NEXT: call void @use8(i8 [[T0]])
; CHECK-NEXT: [[T1:%.*]] = add i8 [[T0]], -1 ; CHECK-NEXT: [[TMP1:%.*]] = sub i8 0, [[T0]]
; CHECK-NEXT: [[T2:%.*]] = and i8 [[T1]], [[X:%.*]] ; CHECK-NEXT: [[TMP2:%.*]] = and i8 [[TMP1]], [[X:%.*]]
; CHECK-NEXT: [[RET:%.*]] = icmp ne i8 [[T2]], [[X]] ; CHECK-NEXT: [[RET:%.*]] = icmp ne i8 [[TMP2]], 0
; CHECK-NEXT: ret i1 [[RET]] ; CHECK-NEXT: ret i1 [[RET]]
; ;
%t0 = shl i8 -1, %y ; not 1 %t0 = shl i8 -1, %y ; not 1
call void @use8(i8 %t0) call void @use8(i8 %t0)
%t1 = add i8 %t0, -1 %t1 = add i8 %t0, -1
%t2 = and i8 %t1, %x %t2 = and i8 %t1, %x
%ret = icmp ne i8 %t2, %x %ret = icmp ne i8 %t2, %x
ret i1 %ret ret i1 %ret
} }
define i1 @n2(i8 %x, i8 %y) { define i1 @n2(i8 %x, i8 %y) {
; CHECK-LABEL: @n2( ; CHECK-LABEL: @n2(
; CHECK-NEXT: [[T0:%.*]] = shl nuw i8 1, [[Y:%.*]] ; CHECK-NEXT: [[T0:%.*]] = shl nuw i8 1, [[Y:%.*]]
; CHECK-NEXT: call void @use8(i8 [[T0]]) ; CHECK-NEXT: call void @use8(i8 [[T0]])
; CHECK-NEXT: [[T1:%.*]] = add nuw i8 [[T0]], 1 ; CHECK-NEXT: [[TMP1:%.*]] = sub nuw i8 -2, [[T0]]
; CHECK-NEXT: [[T2:%.*]] = and i8 [[T1]], [[X:%.*]] ; CHECK-NEXT: [[TMP2:%.*]] = and i8 [[TMP1]], [[X:%.*]]
; CHECK-NEXT: [[RET:%.*]] = icmp ne i8 [[T2]], [[X]] ; CHECK-NEXT: [[RET:%.*]] = icmp ne i8 [[TMP2]], 0
; CHECK-NEXT: ret i1 [[RET]] ; CHECK-NEXT: ret i1 [[RET]]
; ;
%t0 = shl i8 1, %y %t0 = shl i8 1, %y
call void @use8(i8 %t0) call void @use8(i8 %t0)
%t1 = add i8 %t0, 1 ; not -1 %t1 = add i8 %t0, 1 ; not -1
%t2 = and i8 %t1, %x %t2 = and i8 %t1, %x
%ret = icmp ne i8 %t2, %x %ret = icmp ne i8 %t2, %x
ret i1 %ret ret i1 %ret
} }

llvm/test/Transforms/InstCombine/icmp-and-lowbit-mask.ll

Show First 20 Lines • Show All 497 Lines • ▼ Show 20 Lines;
ret i1 %r ret i1 %r
} }
define i1 @src_is_notmask_lshr_shl_fail_mismatch_shifts(i8 %x_in, i8 %y, i8 %z) { define i1 @src_is_notmask_lshr_shl_fail_mismatch_shifts(i8 %x_in, i8 %y, i8 %z) {
; CHECK-LABEL: @src_is_notmask_lshr_shl_fail_mismatch_shifts( ; CHECK-LABEL: @src_is_notmask_lshr_shl_fail_mismatch_shifts(
; CHECK-NEXT: [[X:%.*]] = xor i8 [[X_IN:%.*]], 123 ; CHECK-NEXT: [[X:%.*]] = xor i8 [[X_IN:%.*]], 123
; CHECK-NEXT: [[MASK_SHR:%.*]] = lshr i8 -1, [[Y:%.*]] ; CHECK-NEXT: [[MASK_SHR:%.*]] = lshr i8 -1, [[Y:%.*]]
; CHECK-NEXT: [[NMASK:%.*]] = shl i8 [[MASK_SHR]], [[Z:%.*]] ; CHECK-NEXT: [[NMASK:%.*]] = shl i8 [[MASK_SHR]], [[Z:%.*]]
; CHECK-NEXT: [[MASK:%.*]] = xor i8 [[NMASK]], -1 ; CHECK-NEXT: [[TMP1:%.*]] = and i8 [[X]], [[NMASK]]
; CHECK-NEXT: [[AND:%.*]] = and i8 [[X]], [[MASK]] ; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[TMP1]], 0
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[AND]], [[X]]
; CHECK-NEXT: ret i1 [[R]] ; CHECK-NEXT: ret i1 [[R]]
; ;
%x = xor i8 %x_in, 123 %x = xor i8 %x_in, 123
%mask_shr = lshr i8 -1, %y %mask_shr = lshr i8 -1, %y
%nmask = shl i8 %mask_shr, %z %nmask = shl i8 %mask_shr, %z
%mask = xor i8 %nmask, -1 %mask = xor i8 %nmask, -1
%and = and i8 %mask, %x %and = and i8 %mask, %x
%r = icmp eq i8 %and, %x %r = icmp eq i8 %and, %x
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/icmp-of-and-x.ll

Show First 20 Lines • Show All 232 Lines • ▼ Show 20 Lines;
call void @llvm.assume(i1 %cx) call void @llvm.assume(i1 %cx)
%and = and i8 %x, %y %and = and i8 %x, %y
%z = icmp sle i8 %and, %x %z = icmp sle i8 %and, %x
ret i1 %z ret i1 %z
} }
define i1 @icmp_eq_x_invertable_y_todo(i8 %x, i1 %y) { define i1 @icmp_eq_x_invertable_y_todo(i8 %x, i1 %y) {
; CHECK-LABEL: @icmp_eq_x_invertable_y_todo( ; CHECK-LABEL: @icmp_eq_x_invertable_y_todo(
; CHECK-NEXT: [[YY:%.*]] = select i1 [[Y:%.*]], i8 7, i8 24 ; CHECK-NEXT: [[TMP1:%.*]] = select i1 [[Y:%.*]], i8 -8, i8 -25
; CHECK-NEXT: [[AND:%.*]] = and i8 [[YY]], [[X:%.*]] ; CHECK-NEXT: [[TMP2:%.*]] = and i8 [[TMP1]], [[X:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[AND]], [[X]] ; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[TMP2]], 0
; CHECK-NEXT: ret i1 [[R]] ; CHECK-NEXT: ret i1 [[R]]
; ;
%yy = select i1 %y, i8 7, i8 24 %yy = select i1 %y, i8 7, i8 24
%and = and i8 %x, %yy %and = and i8 %x, %yy
%r = icmp eq i8 %x, %and %r = icmp eq i8 %x, %and
ret i1 %r ret i1 %r
} }
define i1 @icmp_eq_x_invertable_y(i8 %x, i8 %y) { define i1 @icmp_eq_x_invertable_y(i8 %x, i8 %y) {
; CHECK-LABEL: @icmp_eq_x_invertable_y( ; CHECK-LABEL: @icmp_eq_x_invertable_y(
; CHECK-NEXT: [[YY:%.*]] = xor i8 [[Y:%.*]], -1 ; CHECK-NEXT: [[TMP1:%.*]] = and i8 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: [[AND:%.*]] = and i8 [[YY]], [[X:%.*]] ; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[TMP1]], 0
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[AND]], [[X]]
; CHECK-NEXT: ret i1 [[R]] ; CHECK-NEXT: ret i1 [[R]]
; ;
%yy = xor i8 %y, -1 %yy = xor i8 %y, -1
%and = and i8 %x, %yy %and = and i8 %x, %yy
%r = icmp eq i8 %x, %and %r = icmp eq i8 %x, %and
ret i1 %r ret i1 %r
} }
define i1 @icmp_eq_x_invertable_y2_todo(i8 %x, i1 %y) { define i1 @icmp_eq_x_invertable_y2_todo(i8 %x, i1 %y) {
; CHECK-LABEL: @icmp_eq_x_invertable_y2_todo( ; CHECK-LABEL: @icmp_eq_x_invertable_y2_todo(
; CHECK-NEXT: [[YY:%.*]] = select i1 [[Y:%.*]], i8 7, i8 24 ; CHECK-NEXT: [[TMP1:%.*]] = select i1 [[Y:%.*]], i8 -8, i8 -25
; CHECK-NEXT: [[AND:%.*]] = and i8 [[YY]], [[X:%.*]] ; CHECK-NEXT: [[TMP2:%.*]] = or i8 [[TMP1]], [[X:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[YY]], [[AND]] ; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[TMP2]], -1
; CHECK-NEXT: ret i1 [[R]] ; CHECK-NEXT: ret i1 [[R]]
; ;
%yy = select i1 %y, i8 7, i8 24 %yy = select i1 %y, i8 7, i8 24
%and = and i8 %x, %yy %and = and i8 %x, %yy
%r = icmp eq i8 %yy, %and %r = icmp eq i8 %yy, %and
ret i1 %r ret i1 %r
} }
define i1 @icmp_eq_x_invertable_y2(i8 %x, i8 %y) { define i1 @icmp_eq_x_invertable_y2(i8 %x, i8 %y) {
; CHECK-LABEL: @icmp_eq_x_invertable_y2( ; CHECK-LABEL: @icmp_eq_x_invertable_y2(
; CHECK-NEXT: [[YY:%.*]] = xor i8 [[Y:%.*]], -1 ; CHECK-NEXT: [[TMP1:%.*]] = or i8 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: [[AND:%.*]] = and i8 [[YY]], [[X:%.*]] ; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[TMP1]], -1
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[AND]], [[YY]]
; CHECK-NEXT: ret i1 [[R]] ; CHECK-NEXT: ret i1 [[R]]
; ;
%yy = xor i8 %y, -1 %yy = xor i8 %y, -1
%and = and i8 %x, %yy %and = and i8 %x, %yy
%r = icmp eq i8 %yy, %and %r = icmp eq i8 %yy, %and
ret i1 %r ret i1 %r
} }
Show All 10 Lines