This is an archive of the discontinued LLVM Phabricator instance.

Differential D87168

[InstSimplify] Fold min/max based on dominating condition
ClosedPublic

Authored by nikic on Sep 4 2020, 2:50 PM.

Details

Reviewers
spatel
lebedev.ri
Commits
rG73104b0751a1: [InstSimplify] Fold min/max based on dominating condition
Summary

If we have a dominating condition that x >= y, then umax(x, y) is x, etc. I'm doing this in InstSimplify as the corresponding transform for the select form is also done there.

Diff Detail

Event Timeline

nikic created this revision.Sep 4 2020, 2:50 PM
Herald added a project: Restricted Project. · View Herald TranscriptSep 4 2020, 2:50 PM
Herald added subscribers: llvm-commits, hiraditya. · View Herald Transcript
nikic requested review of this revision.Sep 4 2020, 2:50 PM
Harbormaster completed remote builds in B70700: Diff 290034.Sep 4 2020, 3:23 PM
nikic mentioned this in D87184: [InstCombine] Fold abs with dominating condition.Sep 5 2020, 2:12 AM
spatel accepted this revision.Sep 5 2020, 6:08 AM

LGTM

This revision is now accepted and ready to land.Sep 5 2020, 6:08 AM
Closed by commit rG73104b0751a1: [InstSimplify] Fold min/max based on dominating condition (authored by nikic). · Explain WhySep 5 2020, 7:18 AM
This revision was automatically updated to reflect the committed changes.
nikic added a commit: rG73104b0751a1: [InstSimplify] Fold min/max based on dominating condition.
nikic mentioned this in rG4892d3a1983b: [InstCombine] Fold abs with dominating condition.

Revision Contents

PathSize
llvm/
lib/
Analysis/
7 lines
test/
Transforms/
InstSimplify/
42 lines

Diff 290085

llvm/lib/Analysis/InstructionSimplify.cpp

Show First 20 Lines • Show All 5,320 Lines • ▼ Show 20 Lines if (Value *V = foldMinMaxSharedOp(IID, Op1, Op0))
return V; return V;
ICmpInst::Predicate Pred = getMaxMinPredicate(IID); ICmpInst::Predicate Pred = getMaxMinPredicate(IID);
if (isICmpTrue(Pred, Op0, Op1, Q.getWithoutUndef(), RecursionLimit)) if (isICmpTrue(Pred, Op0, Op1, Q.getWithoutUndef(), RecursionLimit))
return Op0; return Op0;
if (isICmpTrue(Pred, Op1, Op0, Q.getWithoutUndef(), RecursionLimit)) if (isICmpTrue(Pred, Op1, Op0, Q.getWithoutUndef(), RecursionLimit))
return Op1; return Op1;
if (Optional<bool> Imp =
isImpliedByDomCondition(Pred, Op0, Op1, Q.CxtI, Q.DL))
return *Imp ? Op0 : Op1;
if (Optional<bool> Imp =
isImpliedByDomCondition(Pred, Op1, Op0, Q.CxtI, Q.DL))
return *Imp ? Op1 : Op0;
break; break;
} }
case Intrinsic::usub_with_overflow: case Intrinsic::usub_with_overflow:
case Intrinsic::ssub_with_overflow: case Intrinsic::ssub_with_overflow:
// X - X -> { 0, false } // X - X -> { 0, false }
if (Op0 == Op1) if (Op0 == Op1)
return Constant::getNullValue(ReturnType); return Constant::getNullValue(ReturnType);
LLVM_FALLTHROUGH; LLVM_FALLTHROUGH;
▲ Show 20 Lines • Show All 537 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/maxmin_intrinsics.ll

Show First 20 Lines • Show All 2,133 Lines • ▼ Show 20 Lines;
ret i8 %max ret i8 %max
} }
define i8 @umax_dom_cond_uge(i8 %x, i8 %y) { define i8 @umax_dom_cond_uge(i8 %x, i8 %y) {
; CHECK-LABEL: @umax_dom_cond_uge( ; CHECK-LABEL: @umax_dom_cond_uge(
; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: br i1 [[CMP]], label [[TRUE:%.*]], label [[FALSE:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[TRUE:%.*]], label [[FALSE:%.*]]
; CHECK: true: ; CHECK: true:
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umax.i8(i8 [[X]], i8 [[Y]]) ; CHECK-NEXT: ret i8 [[X]]
; CHECK-NEXT: ret i8 [[M1]]
; CHECK: false: ; CHECK: false:
; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[X]], i8 [[Y]]) ; CHECK-NEXT: ret i8 [[Y]]
; CHECK-NEXT: ret i8 [[M2]]
; ;
%cmp = icmp uge i8 %x, %y %cmp = icmp uge i8 %x, %y
br i1 %cmp, label %true, label %false br i1 %cmp, label %true, label %false
true: true:
%m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y) %m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y)
ret i8 %m1 ret i8 %m1
false: false:
%m2 = call i8 @llvm.umax.i8(i8 %x, i8 %y) %m2 = call i8 @llvm.umax.i8(i8 %x, i8 %y)
ret i8 %m2 ret i8 %m2
} }
define i8 @umax_dom_cond_ugt(i8 %x, i8 %y) { define i8 @umax_dom_cond_ugt(i8 %x, i8 %y) {
; CHECK-LABEL: @umax_dom_cond_ugt( ; CHECK-LABEL: @umax_dom_cond_ugt(
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: br i1 [[CMP]], label [[TRUE:%.*]], label [[FALSE:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[TRUE:%.*]], label [[FALSE:%.*]]
; CHECK: true: ; CHECK: true:
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umax.i8(i8 [[X]], i8 [[Y]]) ; CHECK-NEXT: ret i8 [[X]]
; CHECK-NEXT: ret i8 [[M1]]
; CHECK: false: ; CHECK: false:
; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[X]], i8 [[Y]]) ; CHECK-NEXT: ret i8 [[Y]]
; CHECK-NEXT: ret i8 [[M2]]
; ;
%cmp = icmp ugt i8 %x, %y %cmp = icmp ugt i8 %x, %y
br i1 %cmp, label %true, label %false br i1 %cmp, label %true, label %false
true: true:
%m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y) %m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y)
ret i8 %m1 ret i8 %m1
false: false:
%m2 = call i8 @llvm.umax.i8(i8 %x, i8 %y) %m2 = call i8 @llvm.umax.i8(i8 %x, i8 %y)
ret i8 %m2 ret i8 %m2
} }
define i8 @umax_dom_cond_ule(i8 %x, i8 %y) { define i8 @umax_dom_cond_ule(i8 %x, i8 %y) {
; CHECK-LABEL: @umax_dom_cond_ule( ; CHECK-LABEL: @umax_dom_cond_ule(
; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: br i1 [[CMP]], label [[TRUE:%.*]], label [[FALSE:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[TRUE:%.*]], label [[FALSE:%.*]]
; CHECK: true: ; CHECK: true:
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umax.i8(i8 [[X]], i8 [[Y]]) ; CHECK-NEXT: ret i8 [[Y]]
; CHECK-NEXT: ret i8 [[M1]]
; CHECK: false: ; CHECK: false:
; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[X]], i8 [[Y]]) ; CHECK-NEXT: ret i8 [[X]]
; CHECK-NEXT: ret i8 [[M2]]
; ;
%cmp = icmp ule i8 %x, %y %cmp = icmp ule i8 %x, %y
br i1 %cmp, label %true, label %false br i1 %cmp, label %true, label %false
true: true:
%m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y) %m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y)
ret i8 %m1 ret i8 %m1
false: false:
%m2 = call i8 @llvm.umax.i8(i8 %x, i8 %y) %m2 = call i8 @llvm.umax.i8(i8 %x, i8 %y)
ret i8 %m2 ret i8 %m2
} }
define i8 @umax_dom_cond_ult(i8 %x, i8 %y) { define i8 @umax_dom_cond_ult(i8 %x, i8 %y) {
; CHECK-LABEL: @umax_dom_cond_ult( ; CHECK-LABEL: @umax_dom_cond_ult(
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: br i1 [[CMP]], label [[TRUE:%.*]], label [[FALSE:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[TRUE:%.*]], label [[FALSE:%.*]]
; CHECK: true: ; CHECK: true:
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umax.i8(i8 [[X]], i8 [[Y]]) ; CHECK-NEXT: ret i8 [[Y]]
; CHECK-NEXT: ret i8 [[M1]]
; CHECK: false: ; CHECK: false:
; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[X]], i8 [[Y]]) ; CHECK-NEXT: ret i8 [[X]]
; CHECK-NEXT: ret i8 [[M2]]
; ;
%cmp = icmp ult i8 %x, %y %cmp = icmp ult i8 %x, %y
br i1 %cmp, label %true, label %false br i1 %cmp, label %true, label %false
true: true:
%m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y) %m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y)
ret i8 %m1 ret i8 %m1
false: false:
%m2 = call i8 @llvm.umax.i8(i8 %x, i8 %y) %m2 = call i8 @llvm.umax.i8(i8 %x, i8 %y)
ret i8 %m2 ret i8 %m2
} }
define i8 @umin_dom_cond_uge(i8 %x, i8 %y) { define i8 @umin_dom_cond_uge(i8 %x, i8 %y) {
; CHECK-LABEL: @umin_dom_cond_uge( ; CHECK-LABEL: @umin_dom_cond_uge(
; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: br i1 [[CMP]], label [[TRUE:%.*]], label [[FALSE:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[TRUE:%.*]], label [[FALSE:%.*]]
; CHECK: true: ; CHECK: true:
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umin.i8(i8 [[X]], i8 [[Y]]) ; CHECK-NEXT: ret i8 [[Y]]
; CHECK-NEXT: ret i8 [[M1]]
; CHECK: false: ; CHECK: false:
; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umin.i8(i8 [[X]], i8 [[Y]]) ; CHECK-NEXT: ret i8 [[X]]
; CHECK-NEXT: ret i8 [[M2]]
; ;
%cmp = icmp uge i8 %x, %y %cmp = icmp uge i8 %x, %y
br i1 %cmp, label %true, label %false br i1 %cmp, label %true, label %false
true: true:
%m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y) %m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y)
ret i8 %m1 ret i8 %m1
false: false:
%m2 = call i8 @llvm.umin.i8(i8 %x, i8 %y) %m2 = call i8 @llvm.umin.i8(i8 %x, i8 %y)
ret i8 %m2 ret i8 %m2
} }
define i8 @smax_dom_cond_sge(i8 %x, i8 %y) { define i8 @smax_dom_cond_sge(i8 %x, i8 %y) {
; CHECK-LABEL: @smax_dom_cond_sge( ; CHECK-LABEL: @smax_dom_cond_sge(
; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: br i1 [[CMP]], label [[TRUE:%.*]], label [[FALSE:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[TRUE:%.*]], label [[FALSE:%.*]]
; CHECK: true: ; CHECK: true:
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smax.i8(i8 [[X]], i8 [[Y]]) ; CHECK-NEXT: ret i8 [[X]]
; CHECK-NEXT: ret i8 [[M1]]
; CHECK: false: ; CHECK: false:
; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smax.i8(i8 [[X]], i8 [[Y]]) ; CHECK-NEXT: ret i8 [[Y]]
; CHECK-NEXT: ret i8 [[M2]]
; ;
%cmp = icmp sge i8 %x, %y %cmp = icmp sge i8 %x, %y
br i1 %cmp, label %true, label %false br i1 %cmp, label %true, label %false
true: true:
%m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y) %m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y)
ret i8 %m1 ret i8 %m1
false: false:
%m2 = call i8 @llvm.smax.i8(i8 %x, i8 %y) %m2 = call i8 @llvm.smax.i8(i8 %x, i8 %y)
ret i8 %m2 ret i8 %m2
} }
define i8 @smin_dom_cond_sge(i8 %x, i8 %y) { define i8 @smin_dom_cond_sge(i8 %x, i8 %y) {
; CHECK-LABEL: @smin_dom_cond_sge( ; CHECK-LABEL: @smin_dom_cond_sge(
; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: br i1 [[CMP]], label [[TRUE:%.*]], label [[FALSE:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[TRUE:%.*]], label [[FALSE:%.*]]
; CHECK: true: ; CHECK: true:
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smin.i8(i8 [[X]], i8 [[Y]]) ; CHECK-NEXT: ret i8 [[Y]]
; CHECK-NEXT: ret i8 [[M1]]
; CHECK: false: ; CHECK: false:
; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[X]], i8 [[Y]]) ; CHECK-NEXT: ret i8 [[X]]
; CHECK-NEXT: ret i8 [[M2]]
; ;
%cmp = icmp sge i8 %x, %y %cmp = icmp sge i8 %x, %y
br i1 %cmp, label %true, label %false br i1 %cmp, label %true, label %false
true: true:
%m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y) %m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y)
ret i8 %m1 ret i8 %m1
false: false:
%m2 = call i8 @llvm.smin.i8(i8 %x, i8 %y) %m2 = call i8 @llvm.smin.i8(i8 %x, i8 %y)
ret i8 %m2 ret i8 %m2
} }