This is an archive of the discontinued LLVM Phabricator instance.

Differential D146196

[InstSimplify] make simplifyUnsignedRangeCheck commutative for ZeroICmp
AbandonedPublic

Authored by khei4 on Mar 15 2023, 11:53 PM.

Details

Reviewers
spatel
nikic
lebedev.ri
aqjune
Summary

on InstSimplify, simplifyUnsignedRangeCheck missed being commutative for inner equality comparison.
related Functional patch: https://reviews.llvm.org/D78430

Depends on https://reviews.llvm.org/D146195

Diff Detail

Event Timeline

khei4 created this revision.Mar 15 2023, 11:53 PM
Herald added a project: Restricted Project. · View Herald TranscriptMar 15 2023, 11:53 PM
Herald added subscribers: StephenFan, hiraditya. · View Herald Transcript
khei4 requested review of this revision.Mar 15 2023, 11:53 PM
Herald added a project: Restricted Project. · View Herald TranscriptMar 15 2023, 11:53 PM
Herald added a subscriber: llvm-commits. · View Herald Transcript
Harbormaster completed remote builds in B219794: Diff 505707.Mar 15 2023, 11:53 PM
khei4 added a parent revision: D146195: [InstSimplify] Pre-commit test for inner commute case for and-or-icmp-nullptr.ll (NFC).Mar 15 2023, 11:54 PM
nikic requested changes to this revision.Mar 16 2023, 1:31 AM

InstCombine canonicalizes constant icmp operands to the RHS, this is why constants are not usually handled on the LHS. Unless there is some PhaseOrdering reason why it is important to handle this pattern prior to the first InstCombine run, we shouldn't do this.

llvm/lib/Analysis/InstructionSimplify.cpp
1564

You can use m_c_ICmp.

This revision now requires changes to proceed.Mar 16 2023, 1:31 AM
khei4 abandoned this revision.Mar 16 2023, 1:57 AM
In D146196#4198590, @nikic wrote:

InstCombine canonicalizes constant icmp operands to the RHS, this is why constants are not usually handled on the LHS. Unless there is some PhaseOrdering reason why it is important to handle this pattern prior to the first InstCombine run, we shouldn't do this.

Oh, now I could have found that canonicalization. Thank you!

khei4 mentioned this in D146195: [InstSimplify] Pre-commit test for inner commute case for and-or-icmp-nullptr.ll (NFC).Mar 16 2023, 1:59 AM

Revision Contents

PathSize
llvm/
lib/
Analysis/
3 lines
test/
Transforms/
InstSimplify/
60 lines

Diff 505707

llvm/lib/Analysis/InstructionSimplify.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 1,554 Lines • ▼ Show 20 Lines
/// Commuted variants are assumed to be handled by calling this function again /// Commuted variants are assumed to be handled by calling this function again
/// with the parameters swapped. /// with the parameters swapped.
static Value *simplifyUnsignedRangeCheck(ICmpInst *ZeroICmp, static Value *simplifyUnsignedRangeCheck(ICmpInst *ZeroICmp,
ICmpInst *UnsignedICmp, bool IsAnd, ICmpInst *UnsignedICmp, bool IsAnd,
const SimplifyQuery &Q) { const SimplifyQuery &Q) {
Value *X, *Y; Value *X, *Y;
ICmpInst::Predicate EqPred; ICmpInst::Predicate EqPred;
if (!match(ZeroICmp, m_ICmp(EqPred, m_Value(Y), m_Zero())) || if (!(match(ZeroICmp, m_ICmp(EqPred, m_Value(Y), m_Zero())) ||
match(ZeroICmp, m_ICmp(EqPred, m_Zero(), m_Value(Y)))) ||
nikicUnsubmitted
Not Done
ReplyInline Actions

You can use m_c_ICmp.

nikic: You can use `m_c_ICmp`.
!ICmpInst::isEquality(EqPred)) !ICmpInst::isEquality(EqPred))
return nullptr; return nullptr;
ICmpInst::Predicate UnsignedPred; ICmpInst::Predicate UnsignedPred;
Value *A, *B; Value *A, *B;
// Y = (A - B); // Y = (A - B);
if (match(Y, m_Sub(m_Value(A), m_Value(B)))) { if (match(Y, m_Sub(m_Value(A), m_Value(B)))) {
▲ Show 20 Lines • Show All 5,353 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/and-or-icmp-nullptr.ll

Show All 32 Lines;
%cmp = icmp ugt ptr %x, %y %cmp = icmp ugt ptr %x, %y
%cmpeq = icmp eq ptr %x, null %cmpeq = icmp eq ptr %x, null
%r = and i1 %cmpeq, %cmp %r = and i1 %cmpeq, %cmp
ret i1 %r ret i1 %r
} }
define i1 @ugt_and_min_commute_inner(ptr %x, ptr %y) { define i1 @ugt_and_min_commute_inner(ptr %x, ptr %y) {
; CHECK-LABEL: @ugt_and_min_commute_inner( ; CHECK-LABEL: @ugt_and_min_commute_inner(
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt ptr [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: ret i1 false
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq ptr null, [[X]]
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
; ;
%cmp = icmp ugt ptr %x, %y %cmp = icmp ugt ptr %x, %y
%cmpeq = icmp eq ptr null, %x %cmpeq = icmp eq ptr null, %x
%r = and i1 %cmp, %cmpeq %r = and i1 %cmp, %cmpeq
ret i1 %r ret i1 %r
} }
define i1 @ugt_swap_and_min(ptr %x, ptr %y) { define i1 @ugt_swap_and_min(ptr %x, ptr %y) {
Show All 13 Lines;
%cmp = icmp ult ptr %y, %x %cmp = icmp ult ptr %y, %x
%cmpeq = icmp eq ptr %x, null %cmpeq = icmp eq ptr %x, null
%r = and i1 %cmpeq, %cmp %r = and i1 %cmpeq, %cmp
ret i1 %r ret i1 %r
} }
define i1 @ugt_swap_and_min_commute_inner(ptr %x, ptr %y) { define i1 @ugt_swap_and_min_commute_inner(ptr %x, ptr %y) {
; CHECK-LABEL: @ugt_swap_and_min_commute_inner( ; CHECK-LABEL: @ugt_swap_and_min_commute_inner(
; CHECK-NEXT: [[CMP:%.*]] = icmp ult ptr [[Y:%.*]], [[X:%.*]] ; CHECK-NEXT: ret i1 false
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq ptr null, [[X]]
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
; ;
%cmp = icmp ult ptr %y, %x %cmp = icmp ult ptr %y, %x
%cmpeq = icmp eq ptr null, %x %cmpeq = icmp eq ptr null, %x
%r = and i1 %cmp, %cmpeq %r = and i1 %cmp, %cmpeq
ret i1 %r ret i1 %r
} }
; Negative test - signed compare ; Negative test - signed compare
Show All 34 Lines;
%cmp = icmp ule ptr %x, %y %cmp = icmp ule ptr %x, %y
%cmpeq = icmp ne ptr %x, null %cmpeq = icmp ne ptr %x, null
%r = or i1 %cmpeq, %cmp %r = or i1 %cmpeq, %cmp
ret i1 %r ret i1 %r
} }
define i1 @ule_or_not_min_commute_inner(ptr %x, ptr %y) { define i1 @ule_or_not_min_commute_inner(ptr %x, ptr %y) {
; CHECK-LABEL: @ule_or_not_min_commute_inner( ; CHECK-LABEL: @ule_or_not_min_commute_inner(
; CHECK-NEXT: [[CMP:%.*]] = icmp ule ptr [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: ret i1 true
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne ptr null, [[X]]
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
; ;
%cmp = icmp ule ptr %x, %y %cmp = icmp ule ptr %x, %y
%cmpeq = icmp ne ptr null, %x %cmpeq = icmp ne ptr null, %x
%r = or i1 %cmp, %cmpeq %r = or i1 %cmp, %cmpeq
ret i1 %r ret i1 %r
} }
define i1 @ule_swap_or_not_min(ptr %x, ptr %y) { define i1 @ule_swap_or_not_min(ptr %x, ptr %y) {
Show All 13 Lines;
%cmp = icmp uge ptr %y, %x %cmp = icmp uge ptr %y, %x
%cmpeq = icmp ne ptr %x, null %cmpeq = icmp ne ptr %x, null
%r = or i1 %cmpeq, %cmp %r = or i1 %cmpeq, %cmp
ret i1 %r ret i1 %r
} }
define i1 @ule_swap_or_not_min_commute_inner(ptr %x, ptr %y) { define i1 @ule_swap_or_not_min_commute_inner(ptr %x, ptr %y) {
; CHECK-LABEL: @ule_swap_or_not_min_commute_inner( ; CHECK-LABEL: @ule_swap_or_not_min_commute_inner(
; CHECK-NEXT: [[CMP:%.*]] = icmp uge ptr [[Y:%.*]], [[X:%.*]] ; CHECK-NEXT: ret i1 true
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne ptr null, [[X]]
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
; ;
%cmp = icmp uge ptr %y, %x %cmp = icmp uge ptr %y, %x
%cmpeq = icmp ne ptr null, %x %cmpeq = icmp ne ptr null, %x
%r = or i1 %cmp, %cmpeq %r = or i1 %cmp, %cmpeq
ret i1 %r ret i1 %r
} }
; Negative test - signed compare ; Negative test - signed compare
Show All 36 Lines;
%cmp = icmp ule ptr %x, %y %cmp = icmp ule ptr %x, %y
%cmpeq = icmp eq ptr %x, null %cmpeq = icmp eq ptr %x, null
%r = and i1 %cmpeq, %cmp %r = and i1 %cmpeq, %cmp
ret i1 %r ret i1 %r
} }
define i1 @ule_and_min_commute_inner(ptr %x, ptr %y) { define i1 @ule_and_min_commute_inner(ptr %x, ptr %y) {
; CHECK-LABEL: @ule_and_min_commute_inner( ; CHECK-LABEL: @ule_and_min_commute_inner(
; CHECK-NEXT: [[CMP:%.*]] = icmp ule ptr [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq ptr null, [[X:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq ptr null, [[X]] ; CHECK-NEXT: ret i1 [[CMPEQ]]
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
; ;
%cmp = icmp ule ptr %x, %y %cmp = icmp ule ptr %x, %y
%cmpeq = icmp eq ptr null, %x %cmpeq = icmp eq ptr null, %x
%r = and i1 %cmp, %cmpeq %r = and i1 %cmp, %cmpeq
ret i1 %r ret i1 %r
} }
define i1 @ule_swap_and_min(ptr %x, ptr %y) { define i1 @ule_swap_and_min(ptr %x, ptr %y) {
Show All 15 Lines;
%cmp = icmp uge ptr %y, %x %cmp = icmp uge ptr %y, %x
%cmpeq = icmp eq ptr %x, null %cmpeq = icmp eq ptr %x, null
%r = and i1 %cmpeq, %cmp %r = and i1 %cmpeq, %cmp
ret i1 %r ret i1 %r
} }
define i1 @ule_swap_and_min_commute_inner(ptr %x, ptr %y) { define i1 @ule_swap_and_min_commute_inner(ptr %x, ptr %y) {
; CHECK-LABEL: @ule_swap_and_min_commute_inner( ; CHECK-LABEL: @ule_swap_and_min_commute_inner(
; CHECK-NEXT: [[CMP:%.*]] = icmp uge ptr [[Y:%.*]], [[X:%.*]] ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq ptr null, [[X:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq ptr null, [[X]] ; CHECK-NEXT: ret i1 [[CMPEQ]]
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
; ;
%cmp = icmp uge ptr %y, %x %cmp = icmp uge ptr %y, %x
%cmpeq = icmp eq ptr null, %x %cmpeq = icmp eq ptr null, %x
%r = and i1 %cmp, %cmpeq %r = and i1 %cmp, %cmpeq
ret i1 %r ret i1 %r
} }
; Negative test - signed compare ; Negative test - signed compare
Show All 37 Lines;
%cmpeq = icmp eq ptr %x, null %cmpeq = icmp eq ptr %x, null
%r = or i1 %cmpeq, %cmp %r = or i1 %cmpeq, %cmp
ret i1 %r ret i1 %r
} }
define i1 @ule_or_min_commute_inner(ptr %x, ptr %y) { define i1 @ule_or_min_commute_inner(ptr %x, ptr %y) {
; CHECK-LABEL: @ule_or_min_commute_inner( ; CHECK-LABEL: @ule_or_min_commute_inner(
; CHECK-NEXT: [[CMP:%.*]] = icmp ule ptr [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[CMP:%.*]] = icmp ule ptr [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq ptr null, [[X]] ; CHECK-NEXT: ret i1 [[CMP]]
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
; ;
%cmp = icmp ule ptr %x, %y %cmp = icmp ule ptr %x, %y
%cmpeq = icmp eq ptr null, %x %cmpeq = icmp eq ptr null, %x
%r = or i1 %cmp, %cmpeq %r = or i1 %cmp, %cmpeq
ret i1 %r ret i1 %r
} }
define i1 @ule_swap_or_min(ptr %x, ptr %y) { define i1 @ule_swap_or_min(ptr %x, ptr %y) {
Show All 16 Lines;
%cmpeq = icmp eq ptr %x, null %cmpeq = icmp eq ptr %x, null
%r = or i1 %cmpeq, %cmp %r = or i1 %cmpeq, %cmp
ret i1 %r ret i1 %r
} }
define i1 @ule_swap_or_min_commute_inner(ptr %x, ptr %y) { define i1 @ule_swap_or_min_commute_inner(ptr %x, ptr %y) {
; CHECK-LABEL: @ule_swap_or_min_commute_inner( ; CHECK-LABEL: @ule_swap_or_min_commute_inner(
; CHECK-NEXT: [[CMP:%.*]] = icmp uge ptr [[Y:%.*]], [[X:%.*]] ; CHECK-NEXT: [[CMP:%.*]] = icmp uge ptr [[Y:%.*]], [[X:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq ptr null, [[X]] ; CHECK-NEXT: ret i1 [[CMP]]
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
; ;
%cmp = icmp uge ptr %y, %x %cmp = icmp uge ptr %y, %x
%cmpeq = icmp eq ptr null, %x %cmpeq = icmp eq ptr null, %x
%r = or i1 %cmp, %cmpeq %r = or i1 %cmp, %cmpeq
ret i1 %r ret i1 %r
} }
; Negative test - signed compare ; Negative test - signed compare
Show All 37 Lines;
%cmpeq = icmp ne ptr %x, null %cmpeq = icmp ne ptr %x, null
%r = and i1 %cmpeq, %cmp %r = and i1 %cmpeq, %cmp
ret i1 %r ret i1 %r
} }
define i1 @ugt_and_not_min_commute_inner(ptr %x, ptr %y) { define i1 @ugt_and_not_min_commute_inner(ptr %x, ptr %y) {
; CHECK-LABEL: @ugt_and_not_min_commute_inner( ; CHECK-LABEL: @ugt_and_not_min_commute_inner(
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt ptr [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[CMP:%.*]] = icmp ugt ptr [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne ptr null, [[X]] ; CHECK-NEXT: ret i1 [[CMP]]
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
; ;
%cmp = icmp ugt ptr %x, %y %cmp = icmp ugt ptr %x, %y
%cmpeq = icmp ne ptr null, %x %cmpeq = icmp ne ptr null, %x
%r = and i1 %cmp, %cmpeq %r = and i1 %cmp, %cmpeq
ret i1 %r ret i1 %r
} }
define i1 @ugt_swap_and_not_min(ptr %x, ptr %y) { define i1 @ugt_swap_and_not_min(ptr %x, ptr %y) {
Show All 16 Lines;
%cmpeq = icmp ne ptr %x, null %cmpeq = icmp ne ptr %x, null
%r = and i1 %cmpeq, %cmp %r = and i1 %cmpeq, %cmp
ret i1 %r ret i1 %r
} }
define i1 @ugt_swap_and_not_min_commute_inner(ptr %x, ptr %y) { define i1 @ugt_swap_and_not_min_commute_inner(ptr %x, ptr %y) {
; CHECK-LABEL: @ugt_swap_and_not_min_commute_inner( ; CHECK-LABEL: @ugt_swap_and_not_min_commute_inner(
; CHECK-NEXT: [[CMP:%.*]] = icmp ult ptr [[Y:%.*]], [[X:%.*]] ; CHECK-NEXT: [[CMP:%.*]] = icmp ult ptr [[Y:%.*]], [[X:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne ptr null, [[X]] ; CHECK-NEXT: ret i1 [[CMP]]
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
; ;
%cmp = icmp ult ptr %y, %x %cmp = icmp ult ptr %y, %x
%cmpeq = icmp ne ptr null, %x %cmpeq = icmp ne ptr null, %x
%r = and i1 %cmp, %cmpeq %r = and i1 %cmp, %cmpeq
ret i1 %r ret i1 %r
} }
; Negative test - signed compare ; Negative test - signed compare
Show All 36 Lines;
%cmp = icmp ugt ptr %x, %y %cmp = icmp ugt ptr %x, %y
%cmpeq = icmp ne ptr %x, null %cmpeq = icmp ne ptr %x, null
%r = or i1 %cmpeq, %cmp %r = or i1 %cmpeq, %cmp
ret i1 %r ret i1 %r
} }
define i1 @ugt_or_not_min_commute_inner(ptr %x, ptr %y) { define i1 @ugt_or_not_min_commute_inner(ptr %x, ptr %y) {
; CHECK-LABEL: @ugt_or_not_min_commute_inner( ; CHECK-LABEL: @ugt_or_not_min_commute_inner(
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt ptr [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne ptr null, [[X:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne ptr null, [[X]] ; CHECK-NEXT: ret i1 [[CMPEQ]]
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
; ;
%cmp = icmp ugt ptr %x, %y %cmp = icmp ugt ptr %x, %y
%cmpeq = icmp ne ptr null, %x %cmpeq = icmp ne ptr null, %x
%r = or i1 %cmp, %cmpeq %r = or i1 %cmp, %cmpeq
ret i1 %r ret i1 %r
} }
define i1 @ugt_swap_or_not_min(ptr %x, ptr %y) { define i1 @ugt_swap_or_not_min(ptr %x, ptr %y) {
Show All 15 Lines;
%cmp = icmp ult ptr %y, %x %cmp = icmp ult ptr %y, %x
%cmpeq = icmp ne ptr %x, null %cmpeq = icmp ne ptr %x, null
%r = or i1 %cmpeq, %cmp %r = or i1 %cmpeq, %cmp
ret i1 %r ret i1 %r
} }
define i1 @ugt_swap_or_not_min_commute_inner(ptr %x, ptr %y) { define i1 @ugt_swap_or_not_min_commute_inner(ptr %x, ptr %y) {
; CHECK-LABEL: @ugt_swap_or_not_min_commute_inner( ; CHECK-LABEL: @ugt_swap_or_not_min_commute_inner(
; CHECK-NEXT: [[CMP:%.*]] = icmp ult ptr [[Y:%.*]], [[X:%.*]] ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne ptr null, [[X:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne ptr null, [[X]] ; CHECK-NEXT: ret i1 [[CMPEQ]]
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
; ;
%cmp = icmp ult ptr %y, %x %cmp = icmp ult ptr %y, %x
%cmpeq = icmp ne ptr null, %x %cmpeq = icmp ne ptr null, %x
%r = or i1 %cmp, %cmpeq %r = or i1 %cmp, %cmpeq
ret i1 %r ret i1 %r
} }
; Negative test - signed compare ; Negative test - signed compare
Show All 13 Lines