This is an archive of the discontinued LLVM Phabricator instance.

Differential D146195

[InstSimplify] Pre-commit test for inner commute case for and-or-icmp-nullptr.ll (NFC)
AbandonedPublic

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

Details

Reviewers
None
Summary

in and-or-icmp-nullptr.ll, should be commutative for inner (in)equality.

Diff Detail

Event Timeline

khei4 created this revision.Mar 15 2023, 11:47 PM
Herald added a project: Restricted Project. · View Herald TranscriptMar 15 2023, 11:47 PM
khei4 requested review of this revision.Mar 15 2023, 11:47 PM
Herald added a project: Restricted Project. · View Herald TranscriptMar 15 2023, 11:47 PM
Herald added a subscriber: llvm-commits. · View Herald Transcript
khei4 updated this revision to Diff 505706.Mar 15 2023, 11:48 PM

fix missing commute

khei4 mentioned this in D146196: [InstSimplify] make simplifyUnsignedRangeCheck commutative for ZeroICmp.Mar 15 2023, 11:53 PM
khei4 added a child revision: D146196: [InstSimplify] make simplifyUnsignedRangeCheck commutative for ZeroICmp.
Harbormaster completed remote builds in B219793: Diff 505706.Mar 16 2023, 1:42 AM
khei4 abandoned this revision.Mar 16 2023, 1:59 AM

Currently, I haven't found the phase ordering issue.
https://reviews.llvm.org/D146196#4198590

Revision Contents

PathSize
llvm/
test/
Transforms/
InstSimplify/
158 lines

Diff 505706

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

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -passes=instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; This is a specialization of generic folds for min/max values targeted to the ; This is a specialization of generic folds for min/max values targeted to the
; 'null' ptr constant. ; 'null' ptr constant.
; Related tests for non-pointer types should be included in another file. ; Related tests for non-pointer types should be included in another file.
; There are 6 basic patterns (or 3 with DeMorganized equivalent) with ; There are 6 basic patterns (or 3 with DeMorganized equivalent) with
; 2 (commute logic op) * ; 2 (commute logic op) *
; 2 (swap compare operands) * ; 3 (swap compare and NAND eq operands) *
; variations for a total of 24 tests. ; variations for a total of 24 tests.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; ;
; (X == null) && (X > Y) --> false ; (X == null) && (X > Y) --> false
; ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Show All 12 Lines
; CHECK-NEXT: ret i1 false ; CHECK-NEXT: ret i1 false
; ;
%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) {
; CHECK-LABEL: @ugt_and_min_commute_inner(
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt ptr [[X:%.*]], [[Y:%.*]]
; 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
%cmpeq = icmp eq ptr null, %x
%r = and i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @ugt_swap_and_min(ptr %x, ptr %y) { define i1 @ugt_swap_and_min(ptr %x, ptr %y) {
; CHECK-LABEL: @ugt_swap_and_min( ; CHECK-LABEL: @ugt_swap_and_min(
; CHECK-NEXT: ret i1 false ; CHECK-NEXT: ret i1 false
; ;
%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 %cmp, %cmpeq %r = and i1 %cmp, %cmpeq
ret i1 %r ret i1 %r
} }
define i1 @ugt_swap_and_min_commute(ptr %x, ptr %y) { define i1 @ugt_swap_and_min_commute(ptr %x, ptr %y) {
; CHECK-LABEL: @ugt_swap_and_min_commute( ; CHECK-LABEL: @ugt_swap_and_min_commute(
; CHECK-NEXT: ret i1 false ; CHECK-NEXT: ret i1 false
; ;
%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) {
; CHECK-LABEL: @ugt_swap_and_min_commute_inner(
; CHECK-NEXT: [[CMP:%.*]] = icmp ult ptr [[Y:%.*]], [[X:%.*]]
; 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
%cmpeq = icmp eq ptr null, %x
%r = and i1 %cmp, %cmpeq
ret i1 %r
}
; Negative test - signed compare ; Negative test - signed compare
define i1 @sgt_and_min(ptr %x, ptr %y) { define i1 @sgt_and_min(ptr %x, ptr %y) {
; CHECK-LABEL: @sgt_and_min( ; CHECK-LABEL: @sgt_and_min(
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt ptr [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[CMP:%.*]] = icmp sgt ptr [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq ptr [[X]], null ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq ptr [[X]], null
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]] ; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]] ; CHECK-NEXT: ret i1 [[R]]
Show All 25 Lines
; CHECK-NEXT: ret i1 true ; CHECK-NEXT: ret i1 true
; ;
%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) {
; CHECK-LABEL: @ule_or_not_min_commute_inner(
; CHECK-NEXT: [[CMP:%.*]] = icmp ule ptr [[X:%.*]], [[Y:%.*]]
; 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
%cmpeq = icmp ne ptr null, %x
%r = or i1 %cmp, %cmpeq
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) {
; CHECK-LABEL: @ule_swap_or_not_min( ; CHECK-LABEL: @ule_swap_or_not_min(
; CHECK-NEXT: ret i1 true ; CHECK-NEXT: ret i1 true
; ;
%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 %cmp, %cmpeq %r = or i1 %cmp, %cmpeq
ret i1 %r ret i1 %r
} }
define i1 @ule_swap_or_not_min_commute(ptr %x, ptr %y) { define i1 @ule_swap_or_not_min_commute(ptr %x, ptr %y) {
; CHECK-LABEL: @ule_swap_or_not_min_commute( ; CHECK-LABEL: @ule_swap_or_not_min_commute(
; CHECK-NEXT: ret i1 true ; CHECK-NEXT: ret i1 true
; ;
%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) {
; CHECK-LABEL: @ule_swap_or_not_min_commute_inner(
; CHECK-NEXT: [[CMP:%.*]] = icmp uge ptr [[Y:%.*]], [[X:%.*]]
; 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
%cmpeq = icmp ne ptr null, %x
%r = or i1 %cmp, %cmpeq
ret i1 %r
}
; Negative test - signed compare ; Negative test - signed compare
define i1 @sle_or_not_min(ptr %x, ptr %y) { define i1 @sle_or_not_min(ptr %x, ptr %y) {
; CHECK-LABEL: @sle_or_not_min( ; CHECK-LABEL: @sle_or_not_min(
; CHECK-NEXT: [[CMP:%.*]] = icmp sle ptr [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[CMP:%.*]] = icmp sle ptr [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne ptr [[X]], null ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne ptr [[X]], null
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]] ; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]] ; CHECK-NEXT: ret i1 [[R]]
Show All 27 Lines
; CHECK-NEXT: ret i1 [[CMPEQ]] ; CHECK-NEXT: ret i1 [[CMPEQ]]
; ;
%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) {
; 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: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%cmp = icmp ule ptr %x, %y
%cmpeq = icmp eq ptr null, %x
%r = and i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @ule_swap_and_min(ptr %x, ptr %y) { define i1 @ule_swap_and_min(ptr %x, ptr %y) {
; CHECK-LABEL: @ule_swap_and_min( ; CHECK-LABEL: @ule_swap_and_min(
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq ptr [[X:%.*]], null ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq ptr [[X:%.*]], null
; CHECK-NEXT: ret i1 [[CMPEQ]] ; CHECK-NEXT: ret i1 [[CMPEQ]]
; ;
%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 %cmp, %cmpeq %r = and i1 %cmp, %cmpeq
ret i1 %r ret i1 %r
} }
define i1 @ule_swap_and_min_commute(ptr %x, ptr %y) { define i1 @ule_swap_and_min_commute(ptr %x, ptr %y) {
; CHECK-LABEL: @ule_swap_and_min_commute( ; CHECK-LABEL: @ule_swap_and_min_commute(
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq ptr [[X:%.*]], null ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq ptr [[X:%.*]], null
; CHECK-NEXT: ret i1 [[CMPEQ]] ; CHECK-NEXT: ret i1 [[CMPEQ]]
; ;
%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) {
; 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: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%cmp = icmp uge ptr %y, %x
%cmpeq = icmp eq ptr null, %x
%r = and i1 %cmp, %cmpeq
ret i1 %r
}
; Negative test - signed compare ; Negative test - signed compare
define i1 @sle_and_min(ptr %x, ptr %y) { define i1 @sle_and_min(ptr %x, ptr %y) {
; CHECK-LABEL: @sle_and_min( ; CHECK-LABEL: @sle_and_min(
; CHECK-NEXT: [[CMP:%.*]] = icmp sle ptr [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[CMP:%.*]] = icmp sle ptr [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq ptr [[X]], null ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq ptr [[X]], null
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]] ; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]] ; CHECK-NEXT: ret i1 [[R]]
Show All 27 Lines
; CHECK-NEXT: ret i1 [[CMP]] ; CHECK-NEXT: ret i1 [[CMP]]
; ;
%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 = 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) {
; CHECK-LABEL: @ule_or_min_commute_inner(
; CHECK-NEXT: [[CMP:%.*]] = icmp ule ptr [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq ptr null, [[X]]
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%cmp = icmp ule ptr %x, %y
%cmpeq = icmp eq ptr null, %x
%r = or i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @ule_swap_or_min(ptr %x, ptr %y) { define i1 @ule_swap_or_min(ptr %x, ptr %y) {
; CHECK-LABEL: @ule_swap_or_min( ; CHECK-LABEL: @ule_swap_or_min(
; CHECK-NEXT: [[CMP:%.*]] = icmp uge ptr [[Y:%.*]], [[X:%.*]] ; CHECK-NEXT: [[CMP:%.*]] = icmp uge ptr [[Y:%.*]], [[X:%.*]]
; CHECK-NEXT: ret i1 [[CMP]] ; CHECK-NEXT: ret i1 [[CMP]]
; ;
%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 = or i1 %cmp, %cmpeq %r = or i1 %cmp, %cmpeq
ret i1 %r ret i1 %r
} }
define i1 @ule_swap_or_min_commute(ptr %x, ptr %y) { define i1 @ule_swap_or_min_commute(ptr %x, ptr %y) {
; CHECK-LABEL: @ule_swap_or_min_commute( ; CHECK-LABEL: @ule_swap_or_min_commute(
; CHECK-NEXT: [[CMP:%.*]] = icmp uge ptr [[Y:%.*]], [[X:%.*]] ; CHECK-NEXT: [[CMP:%.*]] = icmp uge ptr [[Y:%.*]], [[X:%.*]]
; CHECK-NEXT: ret i1 [[CMP]] ; CHECK-NEXT: ret i1 [[CMP]]
; ;
%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 = 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) {
; CHECK-LABEL: @ule_swap_or_min_commute_inner(
; CHECK-NEXT: [[CMP:%.*]] = icmp uge ptr [[Y:%.*]], [[X:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq ptr null, [[X]]
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%cmp = icmp uge ptr %y, %x
%cmpeq = icmp eq ptr null, %x
%r = or i1 %cmp, %cmpeq
ret i1 %r
}
; Negative test - signed compare ; Negative test - signed compare
define i1 @sle_or_min(ptr %x, ptr %y) { define i1 @sle_or_min(ptr %x, ptr %y) {
; CHECK-LABEL: @sle_or_min( ; CHECK-LABEL: @sle_or_min(
; CHECK-NEXT: [[CMP:%.*]] = icmp sle ptr [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[CMP:%.*]] = icmp sle ptr [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq ptr [[X]], null ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq ptr [[X]], null
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]] ; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]] ; CHECK-NEXT: ret i1 [[R]]
Show All 27 Lines
; CHECK-NEXT: ret i1 [[CMP]] ; CHECK-NEXT: ret i1 [[CMP]]
; ;
%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 = 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) {
; CHECK-LABEL: @ugt_and_not_min_commute_inner(
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt ptr [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne ptr null, [[X]]
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%cmp = icmp ugt ptr %x, %y
%cmpeq = icmp ne ptr null, %x
%r = and i1 %cmp, %cmpeq
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) {
; CHECK-LABEL: @ugt_swap_and_not_min( ; CHECK-LABEL: @ugt_swap_and_not_min(
; CHECK-NEXT: [[CMP:%.*]] = icmp ult ptr [[Y:%.*]], [[X:%.*]] ; CHECK-NEXT: [[CMP:%.*]] = icmp ult ptr [[Y:%.*]], [[X:%.*]]
; CHECK-NEXT: ret i1 [[CMP]] ; CHECK-NEXT: ret i1 [[CMP]]
; ;
%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 = and i1 %cmp, %cmpeq %r = and i1 %cmp, %cmpeq
ret i1 %r ret i1 %r
} }
define i1 @ugt_swap_and_not_min_commute(ptr %x, ptr %y) { define i1 @ugt_swap_and_not_min_commute(ptr %x, ptr %y) {
; CHECK-LABEL: @ugt_swap_and_not_min_commute( ; CHECK-LABEL: @ugt_swap_and_not_min_commute(
; CHECK-NEXT: [[CMP:%.*]] = icmp ult ptr [[Y:%.*]], [[X:%.*]] ; CHECK-NEXT: [[CMP:%.*]] = icmp ult ptr [[Y:%.*]], [[X:%.*]]
; CHECK-NEXT: ret i1 [[CMP]] ; CHECK-NEXT: ret i1 [[CMP]]
; ;
%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 = 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) {
; CHECK-LABEL: @ugt_swap_and_not_min_commute_inner(
; CHECK-NEXT: [[CMP:%.*]] = icmp ult ptr [[Y:%.*]], [[X:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne ptr null, [[X]]
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%cmp = icmp ult ptr %y, %x
%cmpeq = icmp ne ptr null, %x
%r = and i1 %cmp, %cmpeq
ret i1 %r
}
; Negative test - signed compare ; Negative test - signed compare
define i1 @sgt_and_not_min(ptr %x, ptr %y) { define i1 @sgt_and_not_min(ptr %x, ptr %y) {
; CHECK-LABEL: @sgt_and_not_min( ; CHECK-LABEL: @sgt_and_not_min(
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt ptr [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[CMP:%.*]] = icmp sgt ptr [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne ptr [[X]], null ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne ptr [[X]], null
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]] ; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]] ; CHECK-NEXT: ret i1 [[R]]
Show All 27 Lines
; CHECK-NEXT: ret i1 [[CMPEQ]] ; CHECK-NEXT: ret i1 [[CMPEQ]]
; ;
%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) {
; 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: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%cmp = icmp ugt ptr %x, %y
%cmpeq = icmp ne ptr null, %x
%r = or i1 %cmp, %cmpeq
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) {
; CHECK-LABEL: @ugt_swap_or_not_min( ; CHECK-LABEL: @ugt_swap_or_not_min(
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne ptr [[X:%.*]], null ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne ptr [[X:%.*]], null
; CHECK-NEXT: ret i1 [[CMPEQ]] ; CHECK-NEXT: ret i1 [[CMPEQ]]
; ;
%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 %cmp, %cmpeq %r = or i1 %cmp, %cmpeq
ret i1 %r ret i1 %r
} }
define i1 @ugt_swap_or_not_min_commute(ptr %x, ptr %y) { define i1 @ugt_swap_or_not_min_commute(ptr %x, ptr %y) {
; CHECK-LABEL: @ugt_swap_or_not_min_commute( ; CHECK-LABEL: @ugt_swap_or_not_min_commute(
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne ptr [[X:%.*]], null ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne ptr [[X:%.*]], null
; CHECK-NEXT: ret i1 [[CMPEQ]] ; CHECK-NEXT: ret i1 [[CMPEQ]]
; ;
%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) {
; 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: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%cmp = icmp ult ptr %y, %x
%cmpeq = icmp ne ptr null, %x
%r = or i1 %cmp, %cmpeq
ret i1 %r
}
; Negative test - signed compare ; Negative test - signed compare
define i1 @sgt_or_not_min(ptr %x, ptr %y) { define i1 @sgt_or_not_min(ptr %x, ptr %y) {
; CHECK-LABEL: @sgt_or_not_min( ; CHECK-LABEL: @sgt_or_not_min(
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt ptr [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[CMP:%.*]] = icmp sgt ptr [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne ptr [[X]], null ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne ptr [[X]], null
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]] ; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]] ; CHECK-NEXT: ret i1 [[R]]
; ;
%cmp = icmp sgt ptr %x, %y %cmp = icmp sgt ptr %x, %y
%cmpeq = icmp ne ptr %x, null %cmpeq = icmp ne ptr %x, null
%r = or i1 %cmp, %cmpeq %r = or i1 %cmp, %cmpeq
ret i1 %r ret i1 %r
} }