[llvm] r362936 - [InstCombine] add tests for fcmp unordered pred -> fabs (PR42179); NFC
Sanjay Patel via llvm-commits
llvm-commits at lists.llvm.org
Mon Jun 10 07:04:11 PDT 2019
Author: spatel
Date: Mon Jun 10 07:04:10 2019
New Revision: 362936
URL: http://llvm.org/viewvc/llvm-project?rev=362936&view=rev
Log:
[InstCombine] add tests for fcmp unordered pred -> fabs (PR42179); NFC
Modified:
llvm/trunk/test/Transforms/InstCombine/fabs.ll
Modified: llvm/trunk/test/Transforms/InstCombine/fabs.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/InstCombine/fabs.ll?rev=362936&r1=362935&r2=362936&view=diff
==============================================================================
--- llvm/trunk/test/Transforms/InstCombine/fabs.ll (original)
+++ llvm/trunk/test/Transforms/InstCombine/fabs.ll Mon Jun 10 07:04:10 2019
@@ -327,6 +327,21 @@ define double @select_fcmp_nnan_nsz_olt_
ret double %fabs
}
+; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.
+
+define double @select_fcmp_nnan_nsz_ult_zero(double %x) {
+; CHECK-LABEL: @select_fcmp_nnan_nsz_ult_zero(
+; CHECK-NEXT: [[LTZERO:%.*]] = fcmp ult double [[X:%.*]], 0.000000e+00
+; CHECK-NEXT: [[NEGX:%.*]] = fsub nnan nsz double -0.000000e+00, [[X]]
+; CHECK-NEXT: [[FABS:%.*]] = select i1 [[LTZERO]], double [[NEGX]], double [[X]]
+; CHECK-NEXT: ret double [[FABS]]
+;
+ %ltzero = fcmp ult double %x, 0.0
+ %negx = fsub nnan nsz double -0.0, %x
+ %fabs = select i1 %ltzero, double %negx, double %x
+ ret double %fabs
+}
+
define double @select_fcmp_nnan_nsz_olt_zero_unary_fneg(double %x) {
; CHECK-LABEL: @select_fcmp_nnan_nsz_olt_zero_unary_fneg(
; CHECK-NEXT: [[TMP1:%.*]] = call nnan nsz double @llvm.fabs.f64(double [[X:%.*]])
@@ -338,6 +353,21 @@ define double @select_fcmp_nnan_nsz_olt_
ret double %fabs
}
+; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.
+
+define double @select_fcmp_nnan_nsz_ult_zero_unary_fneg(double %x) {
+; CHECK-LABEL: @select_fcmp_nnan_nsz_ult_zero_unary_fneg(
+; CHECK-NEXT: [[LTZERO:%.*]] = fcmp ult double [[X:%.*]], 0.000000e+00
+; CHECK-NEXT: [[NEGX:%.*]] = fneg nnan nsz double [[X]]
+; CHECK-NEXT: [[FABS:%.*]] = select i1 [[LTZERO]], double [[NEGX]], double [[X]]
+; CHECK-NEXT: ret double [[FABS]]
+;
+ %ltzero = fcmp ult double %x, 0.0
+ %negx = fneg nnan nsz double %x
+ %fabs = select i1 %ltzero, double %negx, double %x
+ ret double %fabs
+}
+
; X < -0.0 ? -X : X --> fabs(X)
define float @select_fcmp_nnan_nsz_olt_negzero(float %x) {
@@ -351,6 +381,21 @@ define float @select_fcmp_nnan_nsz_olt_n
ret float %fabs
}
+; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.
+
+define float @select_fcmp_nnan_nsz_ult_negzero(float %x) {
+; CHECK-LABEL: @select_fcmp_nnan_nsz_ult_negzero(
+; CHECK-NEXT: [[LTZERO:%.*]] = fcmp ult float [[X:%.*]], 0.000000e+00
+; CHECK-NEXT: [[NEGX:%.*]] = fsub nnan ninf nsz float -0.000000e+00, [[X]]
+; CHECK-NEXT: [[FABS:%.*]] = select i1 [[LTZERO]], float [[NEGX]], float [[X]]
+; CHECK-NEXT: ret float [[FABS]]
+;
+ %ltzero = fcmp ult float %x, -0.0
+ %negx = fsub nnan ninf nsz float -0.0, %x
+ %fabs = select i1 %ltzero, float %negx, float %x
+ ret float %fabs
+}
+
define float @select_fcmp_nnan_nsz_olt_negzero_unary_fneg(float %x) {
; CHECK-LABEL: @select_fcmp_nnan_nsz_olt_negzero_unary_fneg(
; CHECK-NEXT: [[TMP1:%.*]] = call nnan ninf nsz float @llvm.fabs.f32(float [[X:%.*]])
@@ -362,6 +407,21 @@ define float @select_fcmp_nnan_nsz_olt_n
ret float %fabs
}
+; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.
+
+define float @select_fcmp_nnan_nsz_ult_negzero_unary_fneg(float %x) {
+; CHECK-LABEL: @select_fcmp_nnan_nsz_ult_negzero_unary_fneg(
+; CHECK-NEXT: [[LTZERO:%.*]] = fcmp ult float [[X:%.*]], 0.000000e+00
+; CHECK-NEXT: [[NEGX:%.*]] = fneg nnan ninf nsz float [[X]]
+; CHECK-NEXT: [[FABS:%.*]] = select i1 [[LTZERO]], float [[NEGX]], float [[X]]
+; CHECK-NEXT: ret float [[FABS]]
+;
+ %ltzero = fcmp ult float %x, -0.0
+ %negx = fneg nnan ninf nsz float %x
+ %fabs = select i1 %ltzero, float %negx, float %x
+ ret float %fabs
+}
+
; X <= 0.0 ? -X : X --> fabs(X)
define double @select_fcmp_nnan_nsz_ole_zero(double %x) {
@@ -375,6 +435,21 @@ define double @select_fcmp_nnan_nsz_ole_
ret double %fabs
}
+; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.
+
+define double @select_fcmp_nnan_nsz_ule_zero(double %x) {
+; CHECK-LABEL: @select_fcmp_nnan_nsz_ule_zero(
+; CHECK-NEXT: [[LEZERO:%.*]] = fcmp ule double [[X:%.*]], 0.000000e+00
+; CHECK-NEXT: [[NEGX:%.*]] = fsub fast double -0.000000e+00, [[X]]
+; CHECK-NEXT: [[FABS:%.*]] = select i1 [[LEZERO]], double [[NEGX]], double [[X]]
+; CHECK-NEXT: ret double [[FABS]]
+;
+ %lezero = fcmp ule double %x, 0.0
+ %negx = fsub fast double -0.0, %x
+ %fabs = select i1 %lezero, double %negx, double %x
+ ret double %fabs
+}
+
define double @select_fcmp_nnan_nsz_ole_zero_unary_fneg(double %x) {
; CHECK-LABEL: @select_fcmp_nnan_nsz_ole_zero_unary_fneg(
; CHECK-NEXT: [[TMP1:%.*]] = call fast double @llvm.fabs.f64(double [[X:%.*]])
@@ -386,6 +461,21 @@ define double @select_fcmp_nnan_nsz_ole_
ret double %fabs
}
+; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.
+
+define double @select_fcmp_nnan_nsz_ule_zero_unary_fneg(double %x) {
+; CHECK-LABEL: @select_fcmp_nnan_nsz_ule_zero_unary_fneg(
+; CHECK-NEXT: [[LEZERO:%.*]] = fcmp ule double [[X:%.*]], 0.000000e+00
+; CHECK-NEXT: [[NEGX:%.*]] = fneg fast double [[X]]
+; CHECK-NEXT: [[FABS:%.*]] = select i1 [[LEZERO]], double [[NEGX]], double [[X]]
+; CHECK-NEXT: ret double [[FABS]]
+;
+ %lezero = fcmp ule double %x, 0.0
+ %negx = fneg fast double %x
+ %fabs = select i1 %lezero, double %negx, double %x
+ ret double %fabs
+}
+
; X <= -0.0 ? -X : X --> fabs(X)
define float @select_fcmp_nnan_nsz_ole_negzero(float %x) {
@@ -399,6 +489,21 @@ define float @select_fcmp_nnan_nsz_ole_n
ret float %fabs
}
+; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.
+
+define float @select_fcmp_nnan_nsz_ule_negzero(float %x) {
+; CHECK-LABEL: @select_fcmp_nnan_nsz_ule_negzero(
+; CHECK-NEXT: [[LEZERO:%.*]] = fcmp ule float [[X:%.*]], 0.000000e+00
+; CHECK-NEXT: [[NEGX:%.*]] = fsub nnan nsz float -0.000000e+00, [[X]]
+; CHECK-NEXT: [[FABS:%.*]] = select i1 [[LEZERO]], float [[NEGX]], float [[X]]
+; CHECK-NEXT: ret float [[FABS]]
+;
+ %lezero = fcmp ule float %x, -0.0
+ %negx = fsub nnan nsz float -0.0, %x
+ %fabs = select i1 %lezero, float %negx, float %x
+ ret float %fabs
+}
+
define float @select_fcmp_nnan_nsz_ole_negzero_unary_fneg(float %x) {
; CHECK-LABEL: @select_fcmp_nnan_nsz_ole_negzero_unary_fneg(
; CHECK-NEXT: [[TMP1:%.*]] = call nnan nsz float @llvm.fabs.f32(float [[X:%.*]])
@@ -410,6 +515,21 @@ define float @select_fcmp_nnan_nsz_ole_n
ret float %fabs
}
+; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.
+
+define float @select_fcmp_nnan_nsz_ule_negzero_unary_fneg(float %x) {
+; CHECK-LABEL: @select_fcmp_nnan_nsz_ule_negzero_unary_fneg(
+; CHECK-NEXT: [[LEZERO:%.*]] = fcmp ule float [[X:%.*]], 0.000000e+00
+; CHECK-NEXT: [[NEGX:%.*]] = fneg nnan nsz float [[X]]
+; CHECK-NEXT: [[FABS:%.*]] = select i1 [[LEZERO]], float [[NEGX]], float [[X]]
+; CHECK-NEXT: ret float [[FABS]]
+;
+ %lezero = fcmp ule float %x, -0.0
+ %negx = fneg nnan nsz float %x
+ %fabs = select i1 %lezero, float %negx, float %x
+ ret float %fabs
+}
+
; X > 0.0 ? X : (0.0 - X) --> fabs(X)
define <2 x float> @select_fcmp_nnan_nsz_ogt_zero(<2 x float> %x) {
@@ -423,6 +543,21 @@ define <2 x float> @select_fcmp_nnan_nsz
ret <2 x float> %fabs
}
+; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.
+
+define <2 x float> @select_fcmp_nnan_nsz_ugt_zero(<2 x float> %x) {
+; CHECK-LABEL: @select_fcmp_nnan_nsz_ugt_zero(
+; CHECK-NEXT: [[GTZERO:%.*]] = fcmp ugt <2 x float> [[X:%.*]], zeroinitializer
+; CHECK-NEXT: [[NEGX:%.*]] = fsub nnan nsz arcp <2 x float> <float -0.000000e+00, float -0.000000e+00>, [[X]]
+; CHECK-NEXT: [[FABS:%.*]] = select <2 x i1> [[GTZERO]], <2 x float> [[X]], <2 x float> [[NEGX]]
+; CHECK-NEXT: ret <2 x float> [[FABS]]
+;
+ %gtzero = fcmp ugt <2 x float> %x, zeroinitializer
+ %negx = fsub nnan nsz arcp <2 x float> <float -0.0, float -0.0>, %x
+ %fabs = select <2 x i1> %gtzero, <2 x float> %x, <2 x float> %negx
+ ret <2 x float> %fabs
+}
+
define <2 x float> @select_fcmp_nnan_nsz_ogt_zero_unary_fneg(<2 x float> %x) {
; CHECK-LABEL: @select_fcmp_nnan_nsz_ogt_zero_unary_fneg(
; CHECK-NEXT: [[TMP1:%.*]] = call nnan nsz arcp <2 x float> @llvm.fabs.v2f32(<2 x float> [[X:%.*]])
@@ -434,6 +569,21 @@ define <2 x float> @select_fcmp_nnan_nsz
ret <2 x float> %fabs
}
+; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.
+
+define <2 x float> @select_fcmp_nnan_nsz_ugt_zero_unary_fneg(<2 x float> %x) {
+; CHECK-LABEL: @select_fcmp_nnan_nsz_ugt_zero_unary_fneg(
+; CHECK-NEXT: [[GTZERO:%.*]] = fcmp ugt <2 x float> [[X:%.*]], zeroinitializer
+; CHECK-NEXT: [[NEGX:%.*]] = fneg nnan nsz arcp <2 x float> [[X]]
+; CHECK-NEXT: [[FABS:%.*]] = select <2 x i1> [[GTZERO]], <2 x float> [[X]], <2 x float> [[NEGX]]
+; CHECK-NEXT: ret <2 x float> [[FABS]]
+;
+ %gtzero = fcmp ugt <2 x float> %x, zeroinitializer
+ %negx = fneg nnan nsz arcp <2 x float> %x
+ %fabs = select <2 x i1> %gtzero, <2 x float> %x, <2 x float> %negx
+ ret <2 x float> %fabs
+}
+
; X > -0.0 ? X : (0.0 - X) --> fabs(X)
define half @select_fcmp_nnan_nsz_ogt_negzero(half %x) {
@@ -447,6 +597,21 @@ define half @select_fcmp_nnan_nsz_ogt_ne
ret half %fabs
}
+; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.
+
+define half @select_fcmp_nnan_nsz_ugt_negzero(half %x) {
+; CHECK-LABEL: @select_fcmp_nnan_nsz_ugt_negzero(
+; CHECK-NEXT: [[GTZERO:%.*]] = fcmp ugt half [[X:%.*]], 0xH0000
+; CHECK-NEXT: [[NEGX:%.*]] = fsub fast half 0xH8000, [[X]]
+; CHECK-NEXT: [[FABS:%.*]] = select i1 [[GTZERO]], half [[X]], half [[NEGX]]
+; CHECK-NEXT: ret half [[FABS]]
+;
+ %gtzero = fcmp ugt half %x, -0.0
+ %negx = fsub fast half 0.0, %x
+ %fabs = select i1 %gtzero, half %x, half %negx
+ ret half %fabs
+}
+
; X > 0.0 ? X : (0.0 - X) --> fabs(X)
define <2 x double> @select_fcmp_nnan_nsz_oge_zero(<2 x double> %x) {
@@ -460,6 +625,21 @@ define <2 x double> @select_fcmp_nnan_ns
ret <2 x double> %fabs
}
+; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.
+
+define <2 x double> @select_fcmp_nnan_nsz_uge_zero(<2 x double> %x) {
+; CHECK-LABEL: @select_fcmp_nnan_nsz_uge_zero(
+; CHECK-NEXT: [[GEZERO:%.*]] = fcmp uge <2 x double> [[X:%.*]], zeroinitializer
+; CHECK-NEXT: [[NEGX:%.*]] = fsub reassoc nnan nsz <2 x double> <double -0.000000e+00, double -0.000000e+00>, [[X]]
+; CHECK-NEXT: [[FABS:%.*]] = select <2 x i1> [[GEZERO]], <2 x double> [[X]], <2 x double> [[NEGX]]
+; CHECK-NEXT: ret <2 x double> [[FABS]]
+;
+ %gezero = fcmp uge <2 x double> %x, zeroinitializer
+ %negx = fsub nnan nsz reassoc <2 x double> <double -0.0, double -0.0>, %x
+ %fabs = select <2 x i1> %gezero, <2 x double> %x, <2 x double> %negx
+ ret <2 x double> %fabs
+}
+
define <2 x double> @select_fcmp_nnan_nsz_oge_zero_unary_fneg(<2 x double> %x) {
; CHECK-LABEL: @select_fcmp_nnan_nsz_oge_zero_unary_fneg(
; CHECK-NEXT: [[TMP1:%.*]] = call reassoc nnan nsz <2 x double> @llvm.fabs.v2f64(<2 x double> [[X:%.*]])
@@ -471,6 +651,21 @@ define <2 x double> @select_fcmp_nnan_ns
ret <2 x double> %fabs
}
+; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.
+
+define <2 x double> @select_fcmp_nnan_nsz_uge_zero_unary_fneg(<2 x double> %x) {
+; CHECK-LABEL: @select_fcmp_nnan_nsz_uge_zero_unary_fneg(
+; CHECK-NEXT: [[GEZERO:%.*]] = fcmp uge <2 x double> [[X:%.*]], zeroinitializer
+; CHECK-NEXT: [[NEGX:%.*]] = fneg reassoc nnan nsz <2 x double> [[X]]
+; CHECK-NEXT: [[FABS:%.*]] = select <2 x i1> [[GEZERO]], <2 x double> [[X]], <2 x double> [[NEGX]]
+; CHECK-NEXT: ret <2 x double> [[FABS]]
+;
+ %gezero = fcmp uge <2 x double> %x, zeroinitializer
+ %negx = fneg nnan nsz reassoc <2 x double> %x
+ %fabs = select <2 x i1> %gezero, <2 x double> %x, <2 x double> %negx
+ ret <2 x double> %fabs
+}
+
; X > -0.0 ? X : (0.0 - X) --> fabs(X)
define half @select_fcmp_nnan_nsz_oge_negzero(half %x) {
@@ -484,6 +679,21 @@ define half @select_fcmp_nnan_nsz_oge_ne
ret half %fabs
}
+; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.
+
+define half @select_fcmp_nnan_nsz_uge_negzero(half %x) {
+; CHECK-LABEL: @select_fcmp_nnan_nsz_uge_negzero(
+; CHECK-NEXT: [[GEZERO:%.*]] = fcmp uge half [[X:%.*]], 0xH0000
+; CHECK-NEXT: [[NEGX:%.*]] = fsub nnan nsz half 0xH8000, [[X]]
+; CHECK-NEXT: [[FABS:%.*]] = select i1 [[GEZERO]], half [[X]], half [[NEGX]]
+; CHECK-NEXT: ret half [[FABS]]
+;
+ %gezero = fcmp uge half %x, -0.0
+ %negx = fsub nnan nsz half -0.0, %x
+ %fabs = select i1 %gezero, half %x, half %negx
+ ret half %fabs
+}
+
define half @select_fcmp_nnan_nsz_oge_negzero_unary_fneg(half %x) {
; CHECK-LABEL: @select_fcmp_nnan_nsz_oge_negzero_unary_fneg(
; CHECK-NEXT: [[TMP1:%.*]] = call nnan nsz half @llvm.fabs.f16(half [[X:%.*]])
@@ -493,4 +703,19 @@ define half @select_fcmp_nnan_nsz_oge_ne
%negx = fneg nnan nsz half %x
%fabs = select i1 %gezero, half %x, half %negx
ret half %fabs
+}
+
+; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.
+
+define half @select_fcmp_nnan_nsz_uge_negzero_unary_fneg(half %x) {
+; CHECK-LABEL: @select_fcmp_nnan_nsz_uge_negzero_unary_fneg(
+; CHECK-NEXT: [[GEZERO:%.*]] = fcmp uge half [[X:%.*]], 0xH0000
+; CHECK-NEXT: [[NEGX:%.*]] = fneg nnan nsz half [[X]]
+; CHECK-NEXT: [[FABS:%.*]] = select i1 [[GEZERO]], half [[X]], half [[NEGX]]
+; CHECK-NEXT: ret half [[FABS]]
+;
+ %gezero = fcmp uge half %x, -0.0
+ %negx = fneg nnan nsz half %x
+ %fabs = select i1 %gezero, half %x, half %negx
+ ret half %fabs
}
More information about the llvm-commits
mailing list