This is an archive of the discontinued LLVM Phabricator instance.

Differential D106563

Precommit tests for D101727
ClosedPublic

Authored by Krishnakariya on Jul 22 2021, 8:26 AM.

Details

Reviewers
spatel
Commits
rGae4e8f7d528f: [InstCombine][test] add coverage for possible fabs folds; NFC
Summary

I have added the tests here, as discussed in D101727.

Diff Detail

Event Timeline

Krishnakariya requested review of this revision.Jul 22 2021, 8:26 AM
Krishnakariya created this revision.
Herald added a project: Restricted Project. · View Herald TranscriptJul 22 2021, 8:26 AM
Herald added a subscriber: llvm-commits. · View Herald Transcript
Krishnakariya added a reviewer: spatel.Jul 22 2021, 8:26 AM
spatel accepted this revision.Jul 22 2021, 8:35 AM

LGTM

This revision is now accepted and ready to land.Jul 22 2021, 8:35 AM
Krishnakariya added a comment.Jul 22 2021, 8:36 AM

Could you please commit this patch for me? I do not have commit access yet.

Harbormaster completed remote builds in B115587: Diff 360830.Jul 22 2021, 9:45 AM
This revision was landed with ongoing or failed builds.Jul 22 2021, 10:24 AM
Closed by commit rGae4e8f7d528f: [InstCombine][test] add coverage for possible fabs folds; NFC (authored by Krishnakariya, committed by spatel). · Explain Why
This revision was automatically updated to reflect the committed changes.
spatel added a commit: rGae4e8f7d528f: [InstCombine][test] add coverage for possible fabs folds; NFC.

Revision Contents

PathSize
llvm/
test/
Transforms/
InstCombine/
88 lines

Diff 360874

llvm/test/Transforms/InstCombine/fabs.ll

Show First 20 Lines • Show All 272 Lines • ▼ Show 20 Lines
; CHECK-NEXT: ret double [[TMP1]] ; CHECK-NEXT: ret double [[TMP1]]
; ;
%lezero = fcmp ole double %x, 0.0 %lezero = fcmp ole double %x, 0.0
%negx = fsub nnan double 0.0, %x %negx = fsub nnan double 0.0, %x
%fabs = select i1 %lezero, double %negx, double %x %fabs = select i1 %lezero, double %negx, double %x
ret double %fabs ret double %fabs
} }
define double @select_nnan_fcmp_nnan_ole_zero(double %x) {
; CHECK-LABEL: @select_nnan_fcmp_nnan_ole_zero(
; CHECK-NEXT: [[TMP1:%.*]] = call nnan double @llvm.fabs.f64(double [[X:%.*]])
; CHECK-NEXT: ret double [[TMP1]]
;
%lezero = fcmp ole double %x, 0.0
%negx = fsub nnan double 0.0, %x
%fabs = select nnan i1 %lezero, double %negx, double %x
ret double %fabs
}
; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically. ; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.
define double @select_fcmp_nnan_ule_zero(double %x) { define double @select_fcmp_nnan_ule_zero(double %x) {
; CHECK-LABEL: @select_fcmp_nnan_ule_zero( ; CHECK-LABEL: @select_fcmp_nnan_ule_zero(
; CHECK-NEXT: [[TMP1:%.*]] = call nnan double @llvm.fabs.f64(double [[X:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call nnan double @llvm.fabs.f64(double [[X:%.*]])
; CHECK-NEXT: ret double [[TMP1]] ; CHECK-NEXT: ret double [[TMP1]]
; ;
%lezero = fcmp ule double %x, 0.0 %lezero = fcmp ule double %x, 0.0
Show All 25 Lines
; CHECK-NEXT: ret <2 x float> [[TMP1]] ; CHECK-NEXT: ret <2 x float> [[TMP1]]
; ;
%lezero = fcmp ole <2 x float> %x, <float -0.0, float -0.0> %lezero = fcmp ole <2 x float> %x, <float -0.0, float -0.0>
%negx = fsub nnan <2 x float> <float 0.0, float undef>, %x %negx = fsub nnan <2 x float> <float 0.0, float undef>, %x
%fabs = select <2 x i1> %lezero, <2 x float> %negx, <2 x float> %x %fabs = select <2 x i1> %lezero, <2 x float> %negx, <2 x float> %x
ret <2 x float> %fabs ret <2 x float> %fabs
} }
define <2 x float> @select_nnan_fcmp_nnan_ole_negzero(<2 x float> %x) {
; CHECK-LABEL: @select_nnan_fcmp_nnan_ole_negzero(
; CHECK-NEXT: [[TMP1:%.*]] = call nnan <2 x float> @llvm.fabs.v2f32(<2 x float> [[X:%.*]])
; CHECK-NEXT: ret <2 x float> [[TMP1]]
;
%lezero = fcmp ole <2 x float> %x, <float -0.0, float -0.0>
%negx = fsub nnan <2 x float> <float 0.0, float undef>, %x
%fabs = select nnan <2 x i1> %lezero, <2 x float> %negx, <2 x float> %x
ret <2 x float> %fabs
}
; X > 0.0 ? X : (0.0 - X) --> fabs(X) ; X > 0.0 ? X : (0.0 - X) --> fabs(X)
define fp128 @select_fcmp_nnan_ogt_zero(fp128 %x) { define fp128 @select_fcmp_nnan_ogt_zero(fp128 %x) {
; CHECK-LABEL: @select_fcmp_nnan_ogt_zero( ; CHECK-LABEL: @select_fcmp_nnan_ogt_zero(
; CHECK-NEXT: [[TMP1:%.*]] = call nnan fp128 @llvm.fabs.f128(fp128 [[X:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call nnan fp128 @llvm.fabs.f128(fp128 [[X:%.*]])
; CHECK-NEXT: ret fp128 [[TMP1]] ; CHECK-NEXT: ret fp128 [[TMP1]]
; ;
%gtzero = fcmp ogt fp128 %x, zeroinitializer %gtzero = fcmp ogt fp128 %x, zeroinitializer
%negx = fsub nnan fp128 zeroinitializer, %x %negx = fsub nnan fp128 zeroinitializer, %x
%fabs = select i1 %gtzero, fp128 %x, fp128 %negx %fabs = select i1 %gtzero, fp128 %x, fp128 %negx
ret fp128 %fabs ret fp128 %fabs
} }
define fp128 @select_nnan_fcmp_nnan_ogt_zero(fp128 %x) {
; CHECK-LABEL: @select_nnan_fcmp_nnan_ogt_zero(
; CHECK-NEXT: [[TMP1:%.*]] = call nnan fp128 @llvm.fabs.f128(fp128 [[X:%.*]])
; CHECK-NEXT: ret fp128 [[TMP1]]
;
%gtzero = fcmp ogt fp128 %x, zeroinitializer
%negx = fsub nnan fp128 zeroinitializer, %x
%fabs = select nnan i1 %gtzero, fp128 %x, fp128 %negx
ret fp128 %fabs
}
; X > -0.0 ? X : (0.0 - X) --> fabs(X) ; X > -0.0 ? X : (0.0 - X) --> fabs(X)
define half @select_fcmp_nnan_ogt_negzero(half %x) { define half @select_fcmp_nnan_ogt_negzero(half %x) {
; CHECK-LABEL: @select_fcmp_nnan_ogt_negzero( ; CHECK-LABEL: @select_fcmp_nnan_ogt_negzero(
; CHECK-NEXT: [[TMP1:%.*]] = call nnan half @llvm.fabs.f16(half [[X:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call nnan half @llvm.fabs.f16(half [[X:%.*]])
; CHECK-NEXT: ret half [[TMP1]] ; CHECK-NEXT: ret half [[TMP1]]
; ;
%gtzero = fcmp ogt half %x, -0.0 %gtzero = fcmp ogt half %x, -0.0
%negx = fsub nnan half 0.0, %x %negx = fsub nnan half 0.0, %x
%fabs = select i1 %gtzero, half %x, half %negx %fabs = select i1 %gtzero, half %x, half %negx
ret half %fabs ret half %fabs
} }
define half @select_nnan_fcmp_nnan_ogt_negzero(half %x) {
; CHECK-LABEL: @select_nnan_fcmp_nnan_ogt_negzero(
; CHECK-NEXT: [[TMP1:%.*]] = call nnan half @llvm.fabs.f16(half [[X:%.*]])
; CHECK-NEXT: ret half [[TMP1]]
;
%gtzero = fcmp ogt half %x, -0.0
%negx = fsub nnan half 0.0, %x
%fabs = select nnan i1 %gtzero, half %x, half %negx
ret half %fabs
}
; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically. ; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.
define half @select_fcmp_nnan_ugt_negzero(half %x) { define half @select_fcmp_nnan_ugt_negzero(half %x) {
; CHECK-LABEL: @select_fcmp_nnan_ugt_negzero( ; CHECK-LABEL: @select_fcmp_nnan_ugt_negzero(
; CHECK-NEXT: [[TMP1:%.*]] = call nnan half @llvm.fabs.f16(half [[X:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call nnan half @llvm.fabs.f16(half [[X:%.*]])
; CHECK-NEXT: ret half [[TMP1]] ; CHECK-NEXT: ret half [[TMP1]]
; ;
%gtzero = fcmp ugt half %x, -0.0 %gtzero = fcmp ugt half %x, -0.0
Show All 25 Lines
; CHECK-NEXT: ret double [[TMP1]] ; CHECK-NEXT: ret double [[TMP1]]
; ;
%ltzero = fcmp olt double %x, 0.0 %ltzero = fcmp olt double %x, 0.0
%negx = fsub nnan nsz double -0.0, %x %negx = fsub nnan nsz double -0.0, %x
%fabs = select i1 %ltzero, double %negx, double %x %fabs = select i1 %ltzero, double %negx, double %x
ret double %fabs ret double %fabs
} }
define double @select_nnan_nsz_fcmp_nnan_nsz_olt_zero(double %x) {
; CHECK-LABEL: @select_nnan_nsz_fcmp_nnan_nsz_olt_zero(
; CHECK-NEXT: [[TMP1:%.*]] = call nnan nsz double @llvm.fabs.f64(double [[X:%.*]])
; CHECK-NEXT: ret double [[TMP1]]
;
%ltzero = fcmp olt double %x, 0.0
%negx = fsub nnan nsz double -0.0, %x
%fabs = select nnan nsz i1 %ltzero, double %negx, double %x
ret double %fabs
}
; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically. ; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.
define double @select_fcmp_nnan_nsz_ult_zero(double %x) { define double @select_fcmp_nnan_nsz_ult_zero(double %x) {
; CHECK-LABEL: @select_fcmp_nnan_nsz_ult_zero( ; CHECK-LABEL: @select_fcmp_nnan_nsz_ult_zero(
; CHECK-NEXT: [[TMP1:%.*]] = call nnan nsz double @llvm.fabs.f64(double [[X:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call nnan nsz double @llvm.fabs.f64(double [[X:%.*]])
; CHECK-NEXT: ret double [[TMP1]] ; CHECK-NEXT: ret double [[TMP1]]
; ;
%ltzero = fcmp ult double %x, 0.0 %ltzero = fcmp ult double %x, 0.0
Show All 34 Lines
; CHECK-NEXT: ret float [[TMP1]] ; CHECK-NEXT: ret float [[TMP1]]
; ;
%ltzero = fcmp olt float %x, -0.0 %ltzero = fcmp olt float %x, -0.0
%negx = fsub nnan ninf nsz float -0.0, %x %negx = fsub nnan ninf nsz float -0.0, %x
%fabs = select i1 %ltzero, float %negx, float %x %fabs = select i1 %ltzero, float %negx, float %x
ret float %fabs ret float %fabs
} }
define float @select_nnan_ninf_nsz_fcmp_nnan_nsz_olt_negzero(float %x) {
; CHECK-LABEL: @select_nnan_ninf_nsz_fcmp_nnan_nsz_olt_negzero(
; CHECK-NEXT: [[TMP1:%.*]] = call nnan nsz float @llvm.fabs.f32(float [[X:%.*]])
; CHECK-NEXT: ret float [[TMP1]]
;
%ltzero = fcmp olt float %x, -0.0
%negx = fsub nnan nsz float -0.0, %x
%fabs = select nnan ninf nsz i1 %ltzero, float %negx, float %x
ret float %fabs
}
; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically. ; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.
define float @select_fcmp_nnan_nsz_ult_negzero(float %x) { define float @select_fcmp_nnan_nsz_ult_negzero(float %x) {
; CHECK-LABEL: @select_fcmp_nnan_nsz_ult_negzero( ; CHECK-LABEL: @select_fcmp_nnan_nsz_ult_negzero(
; CHECK-NEXT: [[TMP1:%.*]] = call nnan ninf nsz float @llvm.fabs.f32(float [[X:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call nnan ninf nsz float @llvm.fabs.f32(float [[X:%.*]])
; CHECK-NEXT: ret float [[TMP1]] ; CHECK-NEXT: ret float [[TMP1]]
; ;
%ltzero = fcmp ult float %x, -0.0 %ltzero = fcmp ult float %x, -0.0
Show All 34 Lines
; CHECK-NEXT: ret double [[TMP1]] ; CHECK-NEXT: ret double [[TMP1]]
; ;
%lezero = fcmp ole double %x, 0.0 %lezero = fcmp ole double %x, 0.0
%negx = fsub fast double -0.0, %x %negx = fsub fast double -0.0, %x
%fabs = select i1 %lezero, double %negx, double %x %fabs = select i1 %lezero, double %negx, double %x
ret double %fabs ret double %fabs
} }
define double @select_fast_fcmp_nnan_nsz_ole_zero(double %x) {
; CHECK-LABEL: @select_fast_fcmp_nnan_nsz_ole_zero(
; CHECK-NEXT: [[TMP1:%.*]] = call nnan nsz double @llvm.fabs.f64(double [[X:%.*]])
; CHECK-NEXT: ret double [[TMP1]]
;
%lezero = fcmp ole double %x, 0.0
%negx = fsub nnan nsz double -0.0, %x
%fabs = select fast i1 %lezero, double %negx, double %x
ret double %fabs
}
; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically. ; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.
define double @select_fcmp_nnan_nsz_ule_zero(double %x) { define double @select_fcmp_nnan_nsz_ule_zero(double %x) {
; CHECK-LABEL: @select_fcmp_nnan_nsz_ule_zero( ; CHECK-LABEL: @select_fcmp_nnan_nsz_ule_zero(
; CHECK-NEXT: [[TMP1:%.*]] = call fast double @llvm.fabs.f64(double [[X:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call fast double @llvm.fabs.f64(double [[X:%.*]])
; CHECK-NEXT: ret double [[TMP1]] ; CHECK-NEXT: ret double [[TMP1]]
; ;
%lezero = fcmp ule double %x, 0.0 %lezero = fcmp ule double %x, 0.0
Show All 34 Lines
; CHECK-NEXT: ret float [[TMP1]] ; CHECK-NEXT: ret float [[TMP1]]
; ;
%lezero = fcmp ole float %x, -0.0 %lezero = fcmp ole float %x, -0.0
%negx = fsub nnan nsz float -0.0, %x %negx = fsub nnan nsz float -0.0, %x
%fabs = select i1 %lezero, float %negx, float %x %fabs = select i1 %lezero, float %negx, float %x
ret float %fabs ret float %fabs
} }
define float @select_nnan_nsz_fcmp_nnan_nsz_ole_negzero(float %x) {
; CHECK-LABEL: @select_nnan_nsz_fcmp_nnan_nsz_ole_negzero(
; CHECK-NEXT: [[TMP1:%.*]] = call nnan nsz float @llvm.fabs.f32(float [[X:%.*]])
; CHECK-NEXT: ret float [[TMP1]]
;
%lezero = fcmp ole float %x, -0.0
%negx = fsub nnan nsz float -0.0, %x
%fabs = select nnan nsz i1 %lezero, float %negx, float %x
ret float %fabs
}
; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically. ; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.
define float @select_fcmp_nnan_nsz_ule_negzero(float %x) { define float @select_fcmp_nnan_nsz_ule_negzero(float %x) {
; CHECK-LABEL: @select_fcmp_nnan_nsz_ule_negzero( ; CHECK-LABEL: @select_fcmp_nnan_nsz_ule_negzero(
; CHECK-NEXT: [[TMP1:%.*]] = call nnan nsz float @llvm.fabs.f32(float [[X:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call nnan nsz float @llvm.fabs.f32(float [[X:%.*]])
; CHECK-NEXT: ret float [[TMP1]] ; CHECK-NEXT: ret float [[TMP1]]
; ;
%lezero = fcmp ule float %x, -0.0 %lezero = fcmp ule float %x, -0.0
▲ Show 20 Lines • Show All 255 Lines • Show Last 20 Lines