[llvm-branch-commits] [llvm] InstCombine: Add SimplifyDemandedFPClass tests for round (PR #174841)
via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Wed Jan 7 11:15:42 PST 2026
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-llvm-analysis
Author: Matt Arsenault (arsenm)
<details>
<summary>Changes</summary>
Add tests for the family of rounding intrinsics
---
Patch is 47.23 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/174841.diff
1 Files Affected:
- (added) llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-rounding-intrinsics.ll (+943)
``````````diff
diff --git a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-rounding-intrinsics.ll b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-rounding-intrinsics.ll
new file mode 100644
index 0000000000000..8e881efa86286
--- /dev/null
+++ b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-rounding-intrinsics.ll
@@ -0,0 +1,943 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 6
+; RUN: opt -S -passes=instcombine < %s | FileCheck %s
+
+define nofpclass(snan) float @ret_no_snan__floor_no_snan(float nofpclass(nan) %x) {
+; CHECK-LABEL: define nofpclass(snan) float @ret_no_snan__floor_no_snan(
+; CHECK-SAME: float nofpclass(nan) [[X:%.*]]) {
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.floor.f32(float [[X]])
+; CHECK-NEXT: ret float [[RESULT]]
+;
+ %result = call float @llvm.floor.f32(float %x)
+ ret float %result
+}
+
+define nofpclass(inf norm sub zero) float @ret_only_nan__floor(float %x) {
+; CHECK-LABEL: define nofpclass(inf zero sub norm) float @ret_only_nan__floor(
+; CHECK-SAME: float [[X:%.*]]) {
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.floor.f32(float [[X]])
+; CHECK-NEXT: ret float [[RESULT]]
+;
+ %result = call float @llvm.floor.f32(float %x)
+ ret float %result
+}
+
+define nofpclass(inf norm sub zero) <2 x float> @ret_only_nan__floor_vec(<2 x float> %x) {
+; CHECK-LABEL: define nofpclass(inf zero sub norm) <2 x float> @ret_only_nan__floor_vec(
+; CHECK-SAME: <2 x float> [[X:%.*]]) {
+; CHECK-NEXT: [[RESULT:%.*]] = call <2 x float> @llvm.floor.v2f32(<2 x float> [[X]])
+; CHECK-NEXT: ret <2 x float> [[RESULT]]
+;
+ %result = call <2 x float> @llvm.floor.v2f32(<2 x float> %x)
+ ret <2 x float> %result
+}
+
+define nofpclass(inf norm sub zero qnan) float @ret_only_snan__floor(float %x) {
+; CHECK-LABEL: define nofpclass(qnan inf zero sub norm) float @ret_only_snan__floor(
+; CHECK-SAME: float [[X:%.*]]) {
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.floor.f32(float [[X]])
+; CHECK-NEXT: ret float [[RESULT]]
+;
+ %result = call float @llvm.floor.f32(float %x)
+ ret float %result
+}
+
+define nofpclass(inf norm sub zero snan) float @ret_only_qnan__floor(float %x) {
+; CHECK-LABEL: define nofpclass(snan inf zero sub norm) float @ret_only_qnan__floor(
+; CHECK-SAME: float [[X:%.*]]) {
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.floor.f32(float [[X]])
+; CHECK-NEXT: ret float [[RESULT]]
+;
+ %result = call float @llvm.floor.f32(float %x)
+ ret float %result
+}
+
+define nofpclass(nan norm sub zero) float @ret_only_inf__floor(float %x) {
+; CHECK-LABEL: define nofpclass(nan zero sub norm) float @ret_only_inf__floor(
+; CHECK-SAME: float [[X:%.*]]) {
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.floor.f32(float [[X]])
+; CHECK-NEXT: ret float [[RESULT]]
+;
+ %result = call float @llvm.floor.f32(float %x)
+ ret float %result
+}
+
+define nofpclass(nan pinf norm sub zero) float @ret_only_ninf__floor(float %x) {
+; CHECK-LABEL: define nofpclass(nan pinf zero sub norm) float @ret_only_ninf__floor(
+; CHECK-SAME: float [[X:%.*]]) {
+; CHECK-NEXT: ret float 0xFFF0000000000000
+;
+ %result = call float @llvm.floor.f32(float %x)
+ ret float %result
+}
+
+define nofpclass(nan ninf norm sub zero) float @ret_only_pinf__floor(float %x) {
+; CHECK-LABEL: define nofpclass(nan ninf zero sub norm) float @ret_only_pinf__floor(
+; CHECK-SAME: float [[X:%.*]]) {
+; CHECK-NEXT: ret float 0x7FF0000000000000
+;
+ %result = call float @llvm.floor.f32(float %x)
+ ret float %result
+}
+
+define nofpclass(inf nan norm sub) float @ret_only_zero__floor(float %x) {
+; CHECK-LABEL: define nofpclass(nan inf sub norm) float @ret_only_zero__floor(
+; CHECK-SAME: float [[X:%.*]]) {
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.floor.f32(float [[X]])
+; CHECK-NEXT: ret float [[RESULT]]
+;
+ %result = call float @llvm.floor.f32(float %x)
+ ret float %result
+}
+
+define nofpclass(inf nan norm sub nzero) float @ret_only_pzero__floor(float %x) {
+; CHECK-LABEL: define nofpclass(nan inf nzero sub norm) float @ret_only_pzero__floor(
+; CHECK-SAME: float [[X:%.*]]) {
+; CHECK-NEXT: ret float 0.000000e+00
+;
+ %result = call float @llvm.floor.f32(float %x)
+ ret float %result
+}
+
+define nofpclass(inf nan norm sub pzero) float @ret_only_nzero__floor(float %x) {
+; CHECK-LABEL: define nofpclass(nan inf pzero sub norm) float @ret_only_nzero__floor(
+; CHECK-SAME: float [[X:%.*]]) {
+; CHECK-NEXT: ret float -0.000000e+00
+;
+ %result = call float @llvm.floor.f32(float %x)
+ ret float %result
+}
+
+define nofpclass(nan) float @ret_no_nans__floor(float %x) {
+; CHECK-LABEL: define nofpclass(nan) float @ret_no_nans__floor(
+; CHECK-SAME: float [[X:%.*]]) {
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.floor.f32(float [[X]])
+; CHECK-NEXT: ret float [[RESULT]]
+;
+ %result = call float @llvm.floor.f32(float %x)
+ ret float %result
+}
+
+define nofpclass(inf) float @ret_no_infs__floor(float %x) {
+; CHECK-LABEL: define nofpclass(inf) float @ret_no_infs__floor(
+; CHECK-SAME: float [[X:%.*]]) {
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.floor.f32(float [[X]])
+; CHECK-NEXT: ret float [[RESULT]]
+;
+ %result = call float @llvm.floor.f32(float %x)
+ ret float %result
+}
+
+define nofpclass(nan inf) float @ret_no_nans_no_infs__floor(float %x) {
+; CHECK-LABEL: define nofpclass(nan inf) float @ret_no_nans_no_infs__floor(
+; CHECK-SAME: float [[X:%.*]]) {
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.floor.f32(float [[X]])
+; CHECK-NEXT: ret float [[RESULT]]
+;
+ %result = call float @llvm.floor.f32(float %x)
+ ret float %result
+}
+
+define nofpclass(nan) float @ret_no_nans__simplify_select_nan__floor(i1 %cond, float nofpclass(inf norm sub zero) %is.nan, float %unknown) {
+; CHECK-LABEL: define nofpclass(nan) float @ret_no_nans__simplify_select_nan__floor(
+; CHECK-SAME: i1 [[COND:%.*]], float nofpclass(inf zero sub norm) [[IS_NAN:%.*]], float [[UNKNOWN:%.*]]) {
+; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], float [[IS_NAN]], float [[UNKNOWN]]
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.floor.f32(float [[SELECT]])
+; CHECK-NEXT: ret float [[RESULT]]
+;
+ %select = select i1 %cond, float %is.nan, float %unknown
+ %result = call float @llvm.floor.f32(float %select)
+ ret float %result
+}
+
+define nofpclass(inf) float @ret_no_infs__simplify_select_inf__floor(i1 %cond, float nofpclass(nan norm sub zero) %is.inf, float %unknown) {
+; CHECK-LABEL: define nofpclass(inf) float @ret_no_infs__simplify_select_inf__floor(
+; CHECK-SAME: i1 [[COND:%.*]], float nofpclass(nan zero sub norm) [[IS_INF:%.*]], float [[UNKNOWN:%.*]]) {
+; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], float [[IS_INF]], float [[UNKNOWN]]
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.floor.f32(float [[SELECT]])
+; CHECK-NEXT: ret float [[RESULT]]
+;
+ %select = select i1 %cond, float %is.inf, float %unknown
+ %result = call float @llvm.floor.f32(float %select)
+ ret float %result
+}
+
+define nofpclass(nan inf) float @ret_no_inf_no_nan__simplify_select_inf_or_nan__floor(i1 %cond, float nofpclass(norm sub zero) %is.inf.or.nan, float %unknown) {
+; CHECK-LABEL: define nofpclass(nan inf) float @ret_no_inf_no_nan__simplify_select_inf_or_nan__floor(
+; CHECK-SAME: i1 [[COND:%.*]], float nofpclass(zero sub norm) [[IS_INF_OR_NAN:%.*]], float [[UNKNOWN:%.*]]) {
+; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], float [[IS_INF_OR_NAN]], float [[UNKNOWN]]
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.floor.f32(float [[SELECT]])
+; CHECK-NEXT: ret float [[RESULT]]
+;
+ %select = select i1 %cond, float %is.inf.or.nan, float %unknown
+ %result = call float @llvm.floor.f32(float %select)
+ ret float %result
+}
+
+define float @ret_nozero_select_zero__floor(i1 %cond, float nofpclass(inf norm sub nan) %is.zero, float %unknown) {
+; CHECK-LABEL: define float @ret_nozero_select_zero__floor(
+; CHECK-SAME: i1 [[COND:%.*]], float nofpclass(nan inf sub norm) [[IS_ZERO:%.*]], float [[UNKNOWN:%.*]]) {
+; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], float [[IS_ZERO]], float [[UNKNOWN]]
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.floor.f32(float [[SELECT]])
+; CHECK-NEXT: ret float [[RESULT]]
+;
+ %select = select i1 %cond, float %is.zero, float %unknown
+ %result = call float @llvm.floor.f32(float %select)
+ ret float %result
+}
+
+define nofpclass(snan) float @source_known_sub_or_zero__floor(float nofpclass(nan inf norm) %sub.or.zero) {
+; CHECK-LABEL: define nofpclass(snan) float @source_known_sub_or_zero__floor(
+; CHECK-SAME: float nofpclass(nan inf norm) [[SUB_OR_ZERO:%.*]]) {
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.floor.f32(float [[SUB_OR_ZERO]])
+; CHECK-NEXT: ret float [[RESULT]]
+;
+ %result = call float @llvm.floor.f32(float %sub.or.zero)
+ ret float %result
+}
+
+define nofpclass(snan) <2 x float> @source_known_sub_or_zero__floor_vec(<2 x float> nofpclass(nan inf norm) %sub.or.zero) {
+; CHECK-LABEL: define nofpclass(snan) <2 x float> @source_known_sub_or_zero__floor_vec(
+; CHECK-SAME: <2 x float> nofpclass(nan inf norm) [[SUB_OR_ZERO:%.*]]) {
+; CHECK-NEXT: [[RESULT:%.*]] = call <2 x float> @llvm.floor.v2f32(<2 x float> [[SUB_OR_ZERO]])
+; CHECK-NEXT: ret <2 x float> [[RESULT]]
+;
+ %result = call <2 x float> @llvm.floor.v2f32(<2 x float> %sub.or.zero)
+ ret <2 x float> %result
+}
+
+define nofpclass(snan) float @source_known_sub_or_zero_or_nan__floor(float nofpclass(inf norm) %sub.or.zero.or.nan) {
+; CHECK-LABEL: define nofpclass(snan) float @source_known_sub_or_zero_or_nan__floor(
+; CHECK-SAME: float nofpclass(inf norm) [[SUB_OR_ZERO_OR_NAN:%.*]]) {
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.floor.f32(float [[SUB_OR_ZERO_OR_NAN]])
+; CHECK-NEXT: ret float [[RESULT]]
+;
+ %result = call float @llvm.floor.f32(float %sub.or.zero.or.nan)
+ ret float %result
+}
+
+define nofpclass(snan) <2 x float> @source_known_sub_or_zero_or_nan__floor_vec(<2 x float> nofpclass(inf norm) %sub.or.zero.or.nan) {
+; CHECK-LABEL: define nofpclass(snan) <2 x float> @source_known_sub_or_zero_or_nan__floor_vec(
+; CHECK-SAME: <2 x float> nofpclass(inf norm) [[SUB_OR_ZERO_OR_NAN:%.*]]) {
+; CHECK-NEXT: [[RESULT:%.*]] = call <2 x float> @llvm.floor.v2f32(<2 x float> [[SUB_OR_ZERO_OR_NAN]])
+; CHECK-NEXT: ret <2 x float> [[RESULT]]
+;
+ %result = call <2 x float> @llvm.floor.v2f32(<2 x float> %sub.or.zero.or.nan)
+ ret <2 x float> %result
+}
+
+define nofpclass(snan) float @source_known_psub_or_pzero__floor(float nofpclass(nan inf norm nsub nzero) %psub.or.pzero) {
+; CHECK-LABEL: define nofpclass(snan) float @source_known_psub_or_pzero__floor(
+; CHECK-SAME: float nofpclass(nan inf nzero nsub norm) [[PSUB_OR_PZERO:%.*]]) {
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.floor.f32(float [[PSUB_OR_PZERO]])
+; CHECK-NEXT: ret float [[RESULT]]
+;
+ %result = call float @llvm.floor.f32(float %psub.or.pzero)
+ ret float %result
+}
+
+define nofpclass(snan) float @source_known_psub_or_pzero_or_nan__floor(float nofpclass(inf norm nsub nzero) %psub.or.pzero.or.nan) {
+; CHECK-LABEL: define nofpclass(snan) float @source_known_psub_or_pzero_or_nan__floor(
+; CHECK-SAME: float nofpclass(inf nzero nsub norm) [[PSUB_OR_PZERO_OR_NAN:%.*]]) {
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.floor.f32(float [[PSUB_OR_PZERO_OR_NAN]])
+; CHECK-NEXT: ret float [[RESULT]]
+;
+ %result = call float @llvm.floor.f32(float %psub.or.pzero.or.nan)
+ ret float %result
+}
+
+define nofpclass(snan) float @source_known_nsub_or_nzero__floor(float nofpclass(nan inf norm psub pzero) %nsub.or.nzero) {
+; CHECK-LABEL: define nofpclass(snan) float @source_known_nsub_or_nzero__floor(
+; CHECK-SAME: float nofpclass(nan inf pzero psub norm) [[NSUB_OR_NZERO:%.*]]) {
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.floor.f32(float [[NSUB_OR_NZERO]])
+; CHECK-NEXT: ret float [[RESULT]]
+;
+ %result = call float @llvm.floor.f32(float %nsub.or.nzero)
+ ret float %result
+}
+
+define nofpclass(snan) float @source_known_nsub_or_nzero_or_nan__floor(float nofpclass(inf norm psub pzero) %nsub.or.nzero.or.nan) {
+; CHECK-LABEL: define nofpclass(snan) float @source_known_nsub_or_nzero_or_nan__floor(
+; CHECK-SAME: float nofpclass(inf pzero psub norm) [[NSUB_OR_NZERO_OR_NAN:%.*]]) {
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.floor.f32(float [[NSUB_OR_NZERO_OR_NAN]])
+; CHECK-NEXT: ret float [[RESULT]]
+;
+ %result = call float @llvm.floor.f32(float %nsub.or.nzero.or.nan)
+ ret float %result
+}
+
+define nofpclass(snan) float @source_known_inf__floor(float nofpclass(nan norm sub zero) %inf) {
+; CHECK-LABEL: define nofpclass(snan) float @source_known_inf__floor(
+; CHECK-SAME: float nofpclass(nan zero sub norm) [[INF:%.*]]) {
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.floor.f32(float [[INF]])
+; CHECK-NEXT: ret float [[RESULT]]
+;
+ %result = call float @llvm.floor.f32(float %inf)
+ ret float %result
+}
+
+define nofpclass(snan) float @source_known_inf_or_nan__floor(float nofpclass(norm sub zero) %inf.or.nan) {
+; CHECK-LABEL: define nofpclass(snan) float @source_known_inf_or_nan__floor(
+; CHECK-SAME: float nofpclass(zero sub norm) [[INF_OR_NAN:%.*]]) {
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.floor.f32(float [[INF_OR_NAN]])
+; CHECK-NEXT: ret float [[RESULT]]
+;
+ %result = call float @llvm.floor.f32(float %inf.or.nan)
+ ret float %result
+}
+
+define nofpclass(snan) float @source_known_pinf__floor(float nofpclass(nan ninf norm sub zero) %pinf) {
+; CHECK-LABEL: define nofpclass(snan) float @source_known_pinf__floor(
+; CHECK-SAME: float nofpclass(nan ninf zero sub norm) [[PINF:%.*]]) {
+; CHECK-NEXT: ret float 0x7FF0000000000000
+;
+ %result = call float @llvm.floor.f32(float %pinf)
+ ret float %result
+}
+
+define nofpclass(snan) float @source_known_pinf_or_nan__floor(float nofpclass(ninf norm sub zero) %pinf.or.nan) {
+; CHECK-LABEL: define nofpclass(snan) float @source_known_pinf_or_nan__floor(
+; CHECK-SAME: float nofpclass(ninf zero sub norm) [[PINF_OR_NAN:%.*]]) {
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.floor.f32(float [[PINF_OR_NAN]])
+; CHECK-NEXT: ret float [[RESULT]]
+;
+ %result = call float @llvm.floor.f32(float %pinf.or.nan)
+ ret float %result
+}
+
+define nofpclass(snan) float @source_known_ninf__floor(float nofpclass(nan pinf norm sub zero) %ninf) {
+; CHECK-LABEL: define nofpclass(snan) float @source_known_ninf__floor(
+; CHECK-SAME: float nofpclass(nan pinf zero sub norm) [[NINF:%.*]]) {
+; CHECK-NEXT: ret float 0xFFF0000000000000
+;
+ %result = call float @llvm.floor.f32(float %ninf)
+ ret float %result
+}
+
+define nofpclass(snan) float @source_known_ninf_or_nan__floor(float nofpclass(pinf norm sub zero) %ninf.or.nan) {
+; CHECK-LABEL: define nofpclass(snan) float @source_known_ninf_or_nan__floor(
+; CHECK-SAME: float nofpclass(pinf zero sub norm) [[NINF_OR_NAN:%.*]]) {
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.floor.f32(float [[NINF_OR_NAN]])
+; CHECK-NEXT: ret float [[RESULT]]
+;
+ %result = call float @llvm.floor.f32(float %ninf.or.nan)
+ ret float %result
+}
+
+define nofpclass(snan) float @source_known_not_pinf__floor(float nofpclass(pinf) %not.pinf) {
+; CHECK-LABEL: define nofpclass(snan) float @source_known_not_pinf__floor(
+; CHECK-SAME: float nofpclass(pinf) [[NOT_PINF:%.*]]) {
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.floor.f32(float [[NOT_PINF]])
+; CHECK-NEXT: ret float [[RESULT]]
+;
+ %result = call float @llvm.floor.f32(float %not.pinf)
+ ret float %result
+}
+
+define nofpclass(snan) float @source_known_not_ninf__floor(float nofpclass(ninf) %not.ninf) {
+; CHECK-LABEL: define nofpclass(snan) float @source_known_not_ninf__floor(
+; CHECK-SAME: float nofpclass(ninf) [[NOT_NINF:%.*]]) {
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.floor.f32(float [[NOT_NINF]])
+; CHECK-NEXT: ret float [[RESULT]]
+;
+ %result = call float @llvm.floor.f32(float %not.ninf)
+ ret float %result
+}
+
+define nofpclass(snan) ppc_fp128 @source_known_not_pinf__floor__ppcf128(ppc_fp128 nofpclass(pinf) %not.pinf) {
+; CHECK-LABEL: define nofpclass(snan) ppc_fp128 @source_known_not_pinf__floor__ppcf128(
+; CHECK-SAME: ppc_fp128 nofpclass(pinf) [[NOT_PINF:%.*]]) {
+; CHECK-NEXT: [[RESULT:%.*]] = call ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 [[NOT_PINF]])
+; CHECK-NEXT: ret ppc_fp128 [[RESULT]]
+;
+ %result = call ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 %not.pinf)
+ ret ppc_fp128 %result
+}
+
+define nofpclass(snan) ppc_fp128 @source_known_not_ninf__floor_ppcf128(ppc_fp128 nofpclass(ninf) %not.ninf) {
+; CHECK-LABEL: define nofpclass(snan) ppc_fp128 @source_known_not_ninf__floor_ppcf128(
+; CHECK-SAME: ppc_fp128 nofpclass(ninf) [[NOT_NINF:%.*]]) {
+; CHECK-NEXT: [[RESULT:%.*]] = call ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 [[NOT_NINF]])
+; CHECK-NEXT: ret ppc_fp128 [[RESULT]]
+;
+ %result = call ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 %not.ninf)
+ ret ppc_fp128 %result
+}
+
+define nofpclass(nan) float @ret_no_nans__simplify_select_nan__trunc(i1 %cond, float nofpclass(inf norm sub zero) %is.nan, float %unknown) {
+; CHECK-LABEL: define nofpclass(nan) float @ret_no_nans__simplify_select_nan__trunc(
+; CHECK-SAME: i1 [[COND:%.*]], float nofpclass(inf zero sub norm) [[IS_NAN:%.*]], float [[UNKNOWN:%.*]]) {
+; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], float [[IS_NAN]], float [[UNKNOWN]]
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.trunc.f32(float [[SELECT]])
+; CHECK-NEXT: ret float [[RESULT]]
+;
+ %select = select i1 %cond, float %is.nan, float %unknown
+ %result = call float @llvm.trunc.f32(float %select)
+ ret float %result
+}
+
+define nofpclass(nan) float @ret_no_nans__simplify_select_nan__ceil(i1 %cond, float nofpclass(inf norm sub zero) %is.nan, float %unknown) {
+; CHECK-LABEL: define nofpclass(nan) float @ret_no_nans__simplify_select_nan__ceil(
+; CHECK-SAME: i1 [[COND:%.*]], float nofpclass(inf zero sub norm) [[IS_NAN:%.*]], float [[UNKNOWN:%.*]]) {
+; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], float [[IS_NAN]], float [[UNKNOWN]]
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.ceil.f32(float [[SELECT]])
+; CHECK-NEXT: ret float [[RESULT]]
+;
+ %select = select i1 %cond, float %is.nan, float %unknown
+ %result = call float @llvm.ceil.f32(float %select)
+ ret float %result
+}
+
+define nofpclass(nan) float @ret_no_nans__simplify_select_nan__rint(i1 %cond, float nofpclass(inf norm sub zero) %is.nan, float %unknown) {
+; CHECK-LABEL: define nofpclass(nan) float @ret_no_nans__simplify_select_nan__rint(
+; CHECK-SAME: i1 [[COND:%.*]], float nofpclass(inf zero sub norm) [[IS_NAN:%.*]], float [[UNKNOWN:%.*]]) {
+; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], float [[IS_NAN]], float [[UNKNOWN]]
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.rint.f32(float [[SELECT]])
+; CHECK-NEXT: ret float [[RESULT]]
+;
+ %select = select i1 %cond, float %is.nan, float %unknown
+ %result = call float @llvm.rint.f32(float %select)
+ ret float %result
+}
+
+define nofpclass(nan) float @ret_no_nans__simplify_select_nan__nearbyint(i1 %cond, float nofpclass(inf norm sub zero) %is.nan, float %unknown) {
+; CHECK-LABEL: define nofpclass(nan) float @ret_no_nans__simplify_select_nan__nearbyint(
+; CHECK-SAME: i1 [[COND:%.*]], float nofpclass(inf zero sub norm) [[IS_NAN:%.*]], float [[UNKNOWN:%.*]]) {
+; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], float [[IS_NAN]], float [[UNKNOWN]]
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.nearbyint.f32(float [[SELECT]])
+; CHECK-NEXT: ret float [[RESULT]]
+;
+ %select = select i1 %cond, float %is.nan, float %unknown
+ %result = call float @llvm.nearbyint.f32(float %select)
+ ret float %result
+}
+
+define nofpclass(nan) float @ret_no_nans__simplify_select_nan__round(i1 %cond, float nofpclass(inf norm sub zero) %is.nan, float %unknown) {
+; CHECK-LABEL: define nofpclass(nan) float @ret_no_nans__simplify_select_nan__round(
+; CHECK-SAME: i1 [[COND:%.*]], float nofpclass(inf zero sub norm) [[IS_NAN:%.*]], float [[UNKNOWN:%.*]]) {
+; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], float [[IS_NAN]], float [[UNKNOWN]]
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.round.f32(float [[SELECT]])
+; CHECK-NEXT: ret float [[RESULT]]
+;
+ %select = select i1 %cond, float %is.nan, float %unk...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/174841
More information about the llvm-branch-commits
mailing list