This is an archive of the discontinued LLVM Phabricator instance.

Differential D62918

[EarlyCSE] Add tests for negated min/max/abs [NFC]
ClosedPublic

Authored by JosephTremoulet on Jun 5 2019, 10:12 AM.

Details

Reviewers
spatel
Commits
rGacb56090639d: [EarlyCSE] Add tests for negated min/max/abs [NFC]
rL362657: [EarlyCSE] Add tests for negated min/max/abs [NFC]
Summary

I'm planning to update the hashing logic to recognize their equivalence
in a subsequent change (D62644).

Diff Detail

Repository
rL LLVM

Event Timeline

JosephTremoulet created this revision.Jun 5 2019, 10:12 AM
Herald added a project: Restricted Project. · View Herald TranscriptJun 5 2019, 10:12 AM
Harbormaster completed remote builds in B32941: Diff 203193.Jun 5 2019, 10:13 AM
JosephTremoulet edited the summary of this revision. (Show Details)Jun 5 2019, 10:13 AM
JosephTremoulet added a child revision: D62644: [EarlyCSE] Ensure equal keys have the same hash value.Jun 5 2019, 10:23 AM
spatel accepted this revision.Jun 5 2019, 10:27 AM

LGTM - thanks!

This revision is now accepted and ready to land.Jun 5 2019, 10:27 AM
Closed by commit rL362657: [EarlyCSE] Add tests for negated min/max/abs [NFC] (authored by josepht). · Explain WhyJun 5 2019, 2:27 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
trunk/
test/
Transforms/
EarlyCSE/
102 lines

Diff 203251

llvm/trunk/test/Transforms/EarlyCSE/commute.ll

Show First 20 Lines • Show All 101 Lines • ▼ Show 20 Lines;
%cmp1 = icmp sgt i8 %a, %b %cmp1 = icmp sgt i8 %a, %b
%cmp2 = icmp slt i8 %a, %b %cmp2 = icmp slt i8 %a, %b
%m1 = select i1 %cmp1, i8 %b, i8 %a %m1 = select i1 %cmp1, i8 %b, i8 %a
%m2 = select i1 %cmp2, i8 %a, i8 %b %m2 = select i1 %cmp2, i8 %a, i8 %b
%r = icmp eq i8 %m2, %m1 %r = icmp eq i8 %m2, %m1
ret i1 %r ret i1 %r
} }
; Min/max can also have an inverted predicate and select operands.
; TODO: Ensure we always recognize this (currently depends on hash collision)
define i1 @smin_inverted(i8 %a, i8 %b) {
; CHECK-LABEL: @smin_inverted(
; CHECK-NEXT: [[CMP1:%.*]] = icmp slt i8 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[CMP2:%.*]] = xor i1 [[CMP1]], true
; CHECK-NEXT: [[M1:%.*]] = select i1 [[CMP1]], i8 [[A]], i8 [[B]]
; CHECK: ret i1
;
%cmp1 = icmp slt i8 %a, %b
%cmp2 = xor i1 %cmp1, -1
%m1 = select i1 %cmp1, i8 %a, i8 %b
%m2 = select i1 %cmp2, i8 %b, i8 %a
%r = icmp eq i8 %m1, %m2
ret i1 %r
}
define i8 @smax_commute(i8 %a, i8 %b) { define i8 @smax_commute(i8 %a, i8 %b) {
; CHECK-LABEL: @smax_commute( ; CHECK-LABEL: @smax_commute(
; CHECK-NEXT: [[CMP1:%.*]] = icmp sgt i8 [[A:%.*]], [[B:%.*]] ; CHECK-NEXT: [[CMP1:%.*]] = icmp sgt i8 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[CMP2:%.*]] = icmp sgt i8 [[B]], [[A]] ; CHECK-NEXT: [[CMP2:%.*]] = icmp sgt i8 [[B]], [[A]]
; CHECK-NEXT: [[M1:%.*]] = select i1 [[CMP1]], i8 [[A]], i8 [[B]] ; CHECK-NEXT: [[M1:%.*]] = select i1 [[CMP1]], i8 [[A]], i8 [[B]]
; CHECK-NEXT: ret i8 0 ; CHECK-NEXT: ret i8 0
; ;
%cmp1 = icmp sgt i8 %a, %b %cmp1 = icmp sgt i8 %a, %b
Show All 14 Lines;
%cmp1 = icmp slt i8 %a, %b %cmp1 = icmp slt i8 %a, %b
%cmp2 = icmp sgt i8 %a, %b %cmp2 = icmp sgt i8 %a, %b
%m1 = select i1 %cmp1, i8 %b, i8 %a %m1 = select i1 %cmp1, i8 %b, i8 %a
%m2 = select i1 %cmp2, i8 %a, i8 %b %m2 = select i1 %cmp2, i8 %a, i8 %b
%r = sdiv i8 %m1, %m2 %r = sdiv i8 %m1, %m2
ret i8 %r ret i8 %r
} }
; TODO: Ensure we always recognize this (currently depends on hash collision)
define i1 @smax_inverted(i8 %a, i8 %b) {
; CHECK-LABEL: @smax_inverted(
; CHECK-NEXT: [[CMP1:%.*]] = icmp sgt i8 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[CMP2:%.*]] = xor i1 [[CMP1]], true
; CHECK-NEXT: [[M1:%.*]] = select i1 [[CMP1]], i8 [[A]], i8 [[B]]
; CHECK: ret i1
;
%cmp1 = icmp sgt i8 %a, %b
%cmp2 = xor i1 %cmp1, -1
%m1 = select i1 %cmp1, i8 %a, i8 %b
%m2 = select i1 %cmp2, i8 %b, i8 %a
%r = icmp eq i8 %m1, %m2
ret i1 %r
}
define i8 @umin_commute(i8 %a, i8 %b) { define i8 @umin_commute(i8 %a, i8 %b) {
; CHECK-LABEL: @umin_commute( ; CHECK-LABEL: @umin_commute(
; CHECK-NEXT: [[CMP1:%.*]] = icmp ult i8 [[A:%.*]], [[B:%.*]] ; CHECK-NEXT: [[CMP1:%.*]] = icmp ult i8 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[CMP2:%.*]] = icmp ult i8 [[B]], [[A]] ; CHECK-NEXT: [[CMP2:%.*]] = icmp ult i8 [[B]], [[A]]
; CHECK-NEXT: [[M1:%.*]] = select i1 [[CMP1]], i8 [[A]], i8 [[B]] ; CHECK-NEXT: [[M1:%.*]] = select i1 [[CMP1]], i8 [[A]], i8 [[B]]
; CHECK-NEXT: ret i8 0 ; CHECK-NEXT: ret i8 0
; ;
%cmp1 = icmp ult i8 %a, %b %cmp1 = icmp ult i8 %a, %b
Show All 16 Lines;
%cmp1 = icmp ugt <2 x i8> %a, %b %cmp1 = icmp ugt <2 x i8> %a, %b
%cmp2 = icmp ult <2 x i8> %a, %b %cmp2 = icmp ult <2 x i8> %a, %b
%m1 = select <2 x i1> %cmp1, <2 x i8> %b, <2 x i8> %a %m1 = select <2 x i1> %cmp1, <2 x i8> %b, <2 x i8> %a
%m2 = select <2 x i1> %cmp2, <2 x i8> %a, <2 x i8> %b %m2 = select <2 x i1> %cmp2, <2 x i8> %a, <2 x i8> %b
%r = sub <2 x i8> %m2, %m1 %r = sub <2 x i8> %m2, %m1
ret <2 x i8> %r ret <2 x i8> %r
} }
; TODO: Ensure we always recognize this (currently depends on hash collision)
define i1 @umin_inverted(i8 %a, i8 %b) {
; CHECK-LABEL: @umin_inverted(
; CHECK-NEXT: [[CMP1:%.*]] = icmp ult i8 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[CMP2:%.*]] = xor i1 [[CMP1]], true
; CHECK-NEXT: [[M1:%.*]] = select i1 [[CMP1]], i8 [[A]], i8 [[B]]
; CHECK: ret i1
;
%cmp1 = icmp ult i8 %a, %b
%cmp2 = xor i1 %cmp1, -1
%m1 = select i1 %cmp1, i8 %a, i8 %b
%m2 = select i1 %cmp2, i8 %b, i8 %a
%r = icmp eq i8 %m1, %m2
ret i1 %r
}
define i8 @umax_commute(i8 %a, i8 %b) { define i8 @umax_commute(i8 %a, i8 %b) {
; CHECK-LABEL: @umax_commute( ; CHECK-LABEL: @umax_commute(
; CHECK-NEXT: [[CMP1:%.*]] = icmp ugt i8 [[A:%.*]], [[B:%.*]] ; CHECK-NEXT: [[CMP1:%.*]] = icmp ugt i8 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[CMP2:%.*]] = icmp ugt i8 [[B]], [[A]] ; CHECK-NEXT: [[CMP2:%.*]] = icmp ugt i8 [[B]], [[A]]
; CHECK-NEXT: [[M1:%.*]] = select i1 [[CMP1]], i8 [[A]], i8 [[B]] ; CHECK-NEXT: [[M1:%.*]] = select i1 [[CMP1]], i8 [[A]], i8 [[B]]
; CHECK-NEXT: ret i8 1 ; CHECK-NEXT: ret i8 1
; ;
%cmp1 = icmp ugt i8 %a, %b %cmp1 = icmp ugt i8 %a, %b
Show All 15 Lines;
%cmp1 = icmp ult i8 %a, %b %cmp1 = icmp ult i8 %a, %b
%cmp2 = icmp ugt i8 %a, %b %cmp2 = icmp ugt i8 %a, %b
%m1 = select i1 %cmp1, i8 %b, i8 %a %m1 = select i1 %cmp1, i8 %b, i8 %a
%m2 = select i1 %cmp2, i8 %a, i8 %b %m2 = select i1 %cmp2, i8 %a, i8 %b
%r = add i8 %m2, %m1 %r = add i8 %m2, %m1
ret i8 %r ret i8 %r
} }
; TODO: Ensure we always recognize this (currently depends on hash collision)
define i1 @umax_inverted(i8 %a, i8 %b) {
; CHECK-LABEL: @umax_inverted(
; CHECK-NEXT: [[CMP1:%.*]] = icmp ugt i8 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[CMP2:%.*]] = xor i1 [[CMP1]], true
; CHECK-NEXT: [[M1:%.*]] = select i1 [[CMP1]], i8 [[A]], i8 [[B]]
; CHECK: ret i1
;
%cmp1 = icmp ugt i8 %a, %b
%cmp2 = xor i1 %cmp1, -1
%m1 = select i1 %cmp1, i8 %a, i8 %b
%m2 = select i1 %cmp2, i8 %b, i8 %a
%r = icmp eq i8 %m1, %m2
ret i1 %r
}
; Min/max may exist with non-canonical operands. Value tracking can match those. ; Min/max may exist with non-canonical operands. Value tracking can match those.
define i8 @smax_nsw(i8 %a, i8 %b) { define i8 @smax_nsw(i8 %a, i8 %b) {
; CHECK-LABEL: @smax_nsw( ; CHECK-LABEL: @smax_nsw(
; CHECK-NEXT: [[SUB:%.*]] = sub nsw i8 [[A:%.*]], [[B:%.*]] ; CHECK-NEXT: [[SUB:%.*]] = sub nsw i8 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[CMP1:%.*]] = icmp slt i8 [[A]], [[B]] ; CHECK-NEXT: [[CMP1:%.*]] = icmp slt i8 [[A]], [[B]]
; CHECK-NEXT: [[CMP2:%.*]] = icmp sgt i8 [[SUB]], 0 ; CHECK-NEXT: [[CMP2:%.*]] = icmp sgt i8 [[SUB]], 0
; CHECK-NEXT: [[M1:%.*]] = select i1 [[CMP1]], i8 0, i8 [[SUB]] ; CHECK-NEXT: [[M1:%.*]] = select i1 [[CMP1]], i8 0, i8 [[SUB]]
Show All 20 Lines;
%cmp1 = icmp sgt i8 %a, 0 %cmp1 = icmp sgt i8 %a, 0
%cmp2 = icmp slt i8 %a, 0 %cmp2 = icmp slt i8 %a, 0
%m1 = select i1 %cmp1, i8 %a, i8 %neg %m1 = select i1 %cmp1, i8 %a, i8 %neg
%m2 = select i1 %cmp2, i8 %neg, i8 %a %m2 = select i1 %cmp2, i8 %neg, i8 %a
%r = or i8 %m2, %m1 %r = or i8 %m2, %m1
ret i8 %r ret i8 %r
} }
; TODO: Ensure we always recognize this (currently depends on hash collision)
define i8 @abs_inverted(i8 %a) {
; CHECK-LABEL: @abs_inverted(
; CHECK-NEXT: [[NEG:%.*]] = sub i8 0, [[A:%.*]]
; CHECK-NEXT: [[CMP1:%.*]] = icmp sgt i8 [[A]], 0
; CHECK-NEXT: [[CMP2:%.*]] = xor i1 [[CMP1]], true
; CHECK-NEXT: [[M1:%.*]] = select i1 [[CMP1]], i8 [[A]], i8 [[NEG]]
; CHECK: ret i8
;
%neg = sub i8 0, %a
%cmp1 = icmp sgt i8 %a, 0
%cmp2 = xor i1 %cmp1, -1
%m1 = select i1 %cmp1, i8 %a, i8 %neg
%m2 = select i1 %cmp2, i8 %neg, i8 %a
%r = or i8 %m2, %m1
ret i8 %r
}
define i8 @nabs_swapped(i8 %a) { define i8 @nabs_swapped(i8 %a) {
; CHECK-LABEL: @nabs_swapped( ; CHECK-LABEL: @nabs_swapped(
; CHECK-NEXT: [[NEG:%.*]] = sub i8 0, [[A:%.*]] ; CHECK-NEXT: [[NEG:%.*]] = sub i8 0, [[A:%.*]]
; CHECK-NEXT: [[CMP1:%.*]] = icmp slt i8 [[A]], 0 ; CHECK-NEXT: [[CMP1:%.*]] = icmp slt i8 [[A]], 0
; CHECK-NEXT: [[CMP2:%.*]] = icmp sgt i8 [[A]], 0 ; CHECK-NEXT: [[CMP2:%.*]] = icmp sgt i8 [[A]], 0
; CHECK-NEXT: [[M1:%.*]] = select i1 [[CMP1]], i8 [[A]], i8 [[NEG]] ; CHECK-NEXT: [[M1:%.*]] = select i1 [[CMP1]], i8 [[A]], i8 [[NEG]]
; CHECK-NEXT: ret i8 0 ; CHECK-NEXT: ret i8 0
; ;
%neg = sub i8 0, %a %neg = sub i8 0, %a
%cmp1 = icmp slt i8 %a, 0 %cmp1 = icmp slt i8 %a, 0
%cmp2 = icmp sgt i8 %a, 0 %cmp2 = icmp sgt i8 %a, 0
%m1 = select i1 %cmp1, i8 %a, i8 %neg %m1 = select i1 %cmp1, i8 %a, i8 %neg
%m2 = select i1 %cmp2, i8 %neg, i8 %a %m2 = select i1 %cmp2, i8 %neg, i8 %a
%r = xor i8 %m2, %m1 %r = xor i8 %m2, %m1
ret i8 %r ret i8 %r
} }
; TODO: Ensure we always recognize this (currently depends on hash collision)
define i8 @nabs_inverted(i8 %a) {
; CHECK-LABEL: @nabs_inverted(
; CHECK-NEXT: [[NEG:%.*]] = sub i8 0, [[A:%.*]]
; CHECK-NEXT: [[CMP1:%.*]] = icmp slt i8 [[A]], 0
; CHECK-NEXT: [[CMP2:%.*]] = xor i1 [[CMP1]], true
; CHECK-NEXT: [[M1:%.*]] = select i1 [[CMP1]], i8 [[A]], i8 [[NEG]]
; CHECK: ret i8
;
%neg = sub i8 0, %a
%cmp1 = icmp slt i8 %a, 0
%cmp2 = xor i1 %cmp1, -1
%m1 = select i1 %cmp1, i8 %a, i8 %neg
%m2 = select i1 %cmp2, i8 %neg, i8 %a
%r = xor i8 %m2, %m1
ret i8 %r
}
; These two tests make sure we still consider it a match when the RHS of the ; These two tests make sure we still consider it a match when the RHS of the
; compares are different. ; compares are different.
define i8 @abs_different_constants(i8 %a) { define i8 @abs_different_constants(i8 %a) {
; CHECK-LABEL: @abs_different_constants( ; CHECK-LABEL: @abs_different_constants(
; CHECK-NEXT: [[NEG:%.*]] = sub i8 0, [[A:%.*]] ; CHECK-NEXT: [[NEG:%.*]] = sub i8 0, [[A:%.*]]
; CHECK-NEXT: [[CMP1:%.*]] = icmp sgt i8 [[A]], -1 ; CHECK-NEXT: [[CMP1:%.*]] = icmp sgt i8 [[A]], -1
; CHECK-NEXT: [[CMP2:%.*]] = icmp slt i8 [[A]], 0 ; CHECK-NEXT: [[CMP2:%.*]] = icmp slt i8 [[A]], 0
; CHECK-NEXT: [[M1:%.*]] = select i1 [[CMP1]], i8 [[A]], i8 [[NEG]] ; CHECK-NEXT: [[M1:%.*]] = select i1 [[CMP1]], i8 [[A]], i8 [[NEG]]
▲ Show 20 Lines • Show All 283 Lines • Show Last 20 Lines