This is an archive of the discontinued LLVM Phabricator instance.

Differential D101184

[InstCombine] X - usub.sat(X, Y) => umin(X, Y)
ClosedPublic

Authored by xbolva00 on Apr 23 2021, 10:27 AM.

Details

Reviewers
nikic
spatel
Commits
rG9aee07abd0ca: [InstCombine] X - usub.sat(X, Y) => umin(X, Y)
Summary

Pattern regressed in LLVM 9 with the introduction of usub.sat.

Fixes https://bugs.llvm.org/show_bug.cgi?id=42178#c2

Diff Detail

Event Timeline

xbolva00 created this revision.Apr 23 2021, 10:27 AM
Herald added a subscriber: hiraditya. · View Herald TranscriptApr 23 2021, 10:27 AM
xbolva00 requested review of this revision.Apr 23 2021, 10:27 AM
Herald added a project: Restricted Project. · View Herald TranscriptApr 23 2021, 10:27 AM
Herald added a subscriber: llvm-commits. · View Herald Transcript
Harbormaster completed remote builds in B100623: Diff 340104.Apr 23 2021, 10:54 AM
nikic accepted this revision.Apr 23 2021, 12:02 PM

LGTM https://alive2.llvm.org/ce/z/722vAm

This revision is now accepted and ready to land.Apr 23 2021, 12:02 PM
This revision was landed with ongoing or failed builds.Apr 23 2021, 12:13 PM
Closed by commit rG9aee07abd0ca: [InstCombine] X - usub.sat(X, Y) => umin(X, Y) (authored by xbolva00). · Explain Why
This revision was automatically updated to reflect the committed changes.
xbolva00 added a commit: rG9aee07abd0ca: [InstCombine] X - usub.sat(X, Y) => umin(X, Y).

Revision Contents

PathSize
llvm/
lib/
Transforms/
InstCombine/
6 lines
test/
Transforms/
InstCombine/
55 lines

Diff 340136

llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp

Show First 20 Lines • Show All 2,092 Lines • ▼ Show 20 Lines if (match(Op0, m_Add(m_Value(X), m_APInt(AddC))) &&
if ((HighMask & *AndC).isNullValue()) if ((HighMask & *AndC).isNullValue())
return BinaryOperator::CreateAnd(Op0, ConstantInt::get(Ty, ~(*AndC))); return BinaryOperator::CreateAnd(Op0, ConstantInt::get(Ty, ~(*AndC)));
} }
if (Instruction *V = if (Instruction *V =
canonicalizeCondSignextOfHighBitExtractToSignextHighBitExtract(I)) canonicalizeCondSignextOfHighBitExtractToSignextHighBitExtract(I))
return V; return V;
// X - usub.sat(X, Y) => umin(X, Y)
if (match(Op1, m_OneUse(m_Intrinsic<Intrinsic::usub_sat>(m_Specific(Op0),
m_Value(Y)))))
return replaceInstUsesWith(
I, Builder.CreateIntrinsic(Intrinsic::umin, {I.getType()}, {Op0, Y}));
return TryToNarrowDeduceFlags(); return TryToNarrowDeduceFlags();
} }
/// This eliminates floating-point negation in either 'fneg(X)' or /// This eliminates floating-point negation in either 'fneg(X)' or
/// 'fsub(-0.0, X)' form by combining into a constant operand. /// 'fsub(-0.0, X)' form by combining into a constant operand.
static Instruction *foldFNegIntoConstant(Instruction &I) { static Instruction *foldFNegIntoConstant(Instruction &I) {
Value *X; Value *X;
Constant *C; Constant *C;
▲ Show 20 Lines • Show All 223 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/saturating-add-sub.ll

Show First 20 Lines • Show All 1,090 Lines • ▼ Show 20 Lines
; CHECK-NEXT: [[TMP1:%.*]] = call i8 @llvm.umax.i8(i8 [[A:%.*]], i8 42) ; CHECK-NEXT: [[TMP1:%.*]] = call i8 @llvm.umax.i8(i8 [[A:%.*]], i8 42)
; CHECK-NEXT: ret i8 [[TMP1]] ; CHECK-NEXT: ret i8 [[TMP1]]
; ;
%sat = call i8 @llvm.usub.sat.i8(i8 %a, i8 42) %sat = call i8 @llvm.usub.sat.i8(i8 %a, i8 42)
%res = add i8 %sat, 42 %res = add i8 %sat, 42
ret i8 %res ret i8 %res
} }
define i8 @test_scalar_usub_sub(i8 %a, i8 %b) {
; CHECK-LABEL: @test_scalar_usub_sub(
; CHECK-NEXT: [[TMP1:%.*]] = call i8 @llvm.umin.i8(i8 [[A:%.*]], i8 [[B:%.*]])
; CHECK-NEXT: ret i8 [[TMP1]]
;
%sat = call i8 @llvm.usub.sat.i8(i8 %a, i8 %b)
%res = sub i8 %a, %sat
ret i8 %res
}
define i8 @test_scalar_usub_sub_extra_use(i8 %a, i8 %b, i8* %p) {
; CHECK-LABEL: @test_scalar_usub_sub_extra_use(
; CHECK-NEXT: [[SAT:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[A:%.*]], i8 [[B:%.*]])
; CHECK-NEXT: store i8 [[SAT]], i8* [[P:%.*]], align 1
; CHECK-NEXT: [[RES:%.*]] = sub i8 [[A]], [[SAT]]
; CHECK-NEXT: ret i8 [[RES]]
;
%sat = call i8 @llvm.usub.sat.i8(i8 %a, i8 %b)
store i8 %sat, i8* %p
%res = sub i8 %a, %sat
ret i8 %res
}
define <2 x i8> @test_vector_usub_sub(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: @test_vector_usub_sub(
; CHECK-NEXT: [[TMP1:%.*]] = call <2 x i8> @llvm.umin.v2i8(<2 x i8> [[A:%.*]], <2 x i8> [[B:%.*]])
; CHECK-NEXT: ret <2 x i8> [[TMP1]]
;
%sat = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %a, <2 x i8> %b)
%res = sub <2 x i8> %a, %sat
ret <2 x i8> %res
}
define i8 @test_scalar_usub_sub_wrong(i8 %a, i8 %b) {
; CHECK-LABEL: @test_scalar_usub_sub_wrong(
; CHECK-NEXT: [[SAT:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[A:%.*]], i8 [[B:%.*]])
; CHECK-NEXT: [[RES:%.*]] = sub i8 [[B]], [[SAT]]
; CHECK-NEXT: ret i8 [[RES]]
;
%sat = call i8 @llvm.usub.sat.i8(i8 %a, i8 %b)
%res = sub i8 %b, %sat
ret i8 %res
}
define i8 @test_scalar_usub_sub_wrong2(i8 %a, i8 %b) {
; CHECK-LABEL: @test_scalar_usub_sub_wrong2(
; CHECK-NEXT: [[SAT:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[A:%.*]], i8 [[B:%.*]])
; CHECK-NEXT: [[RES:%.*]] = sub i8 [[SAT]], [[B]]
; CHECK-NEXT: ret i8 [[RES]]
;
%sat = call i8 @llvm.usub.sat.i8(i8 %a, i8 %b)
%res = sub i8 %sat, %b
ret i8 %res
}
define i8 @test_scalar_uadd_sub(i8 %a, i8 %b) { define i8 @test_scalar_uadd_sub(i8 %a, i8 %b) {
; CHECK-LABEL: @test_scalar_uadd_sub( ; CHECK-LABEL: @test_scalar_uadd_sub(
; CHECK-NEXT: [[SAT:%.*]] = call i8 @llvm.uadd.sat.i8(i8 [[A:%.*]], i8 [[B:%.*]]) ; CHECK-NEXT: [[SAT:%.*]] = call i8 @llvm.uadd.sat.i8(i8 [[A:%.*]], i8 [[B:%.*]])
; CHECK-NEXT: [[RES:%.*]] = sub i8 [[SAT]], [[B]] ; CHECK-NEXT: [[RES:%.*]] = sub i8 [[SAT]], [[B]]
; CHECK-NEXT: ret i8 [[RES]] ; CHECK-NEXT: ret i8 [[RES]]
; ;
%sat = call i8 @llvm.uadd.sat.i8(i8 %a, i8 %b) %sat = call i8 @llvm.uadd.sat.i8(i8 %a, i8 %b)
%res = sub i8 %sat, %b %res = sub i8 %sat, %b
▲ Show 20 Lines • Show All 779 Lines • Show Last 20 Lines