[llvm] [InstSimplify] Add roundeven constant-propagation tests (PR #170688)

[via llvm-commits]

llvmbot wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-llvm-transforms

Author: None (valadaptive)

<details>
<summary>Changes</summary>

The libcall versions will later be optimized and constant-folded.


---
Full diff: https://github.com/llvm/llvm-project/pull/170688.diff


1 Files Affected:

- (added) llvm/test/Transforms/InstSimplify/ConstProp/roundeven.ll (+165) 


``````````diff
diff --git a/llvm/test/Transforms/InstSimplify/ConstProp/roundeven.ll b/llvm/test/Transforms/InstSimplify/ConstProp/roundeven.ll
new file mode 100644
index 0000000000000..68938b3c6244c
--- /dev/null
+++ b/llvm/test/Transforms/InstSimplify/ConstProp/roundeven.ll
@@ -0,0 +1,165 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 6
+; RUN: opt -S -passes=early-cse -earlycse-debug-hash < %s | FileCheck %s
+
+declare float @roundevenf(float) #0
+declare float @llvm.roundeven.f32(float)
+declare double @roundeven(double) #0
+declare double @llvm.roundeven.f64(double)
+
+define float @constant_fold_roundeven_f32_01() #0 {
+; CHECK-LABEL: define float @constant_fold_roundeven_f32_01(
+; CHECK-SAME: ) #[[ATTR0:[0-9]+]] {
+; CHECK-NEXT:    [[X:%.*]] = call float @roundevenf(float 1.250000e+00) #[[ATTR0]]
+; CHECK-NEXT:    ret float [[X]]
+;
+  %x = call float @roundevenf(float 1.25) #0
+  ret float %x
+}
+
+define float @constant_fold_roundeven_f32_02() #0 {
+; CHECK-LABEL: define float @constant_fold_roundeven_f32_02(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT:    ret float -1.000000e+00
+;
+  %x = call float @llvm.roundeven.f32(float -1.25) #0
+  ret float %x
+}
+
+; roundeven rounds ties to even, so 1.5 -> 2.0 (nearest even)
+define float @constant_fold_roundeven_f32_03() #0 {
+; CHECK-LABEL: define float @constant_fold_roundeven_f32_03(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT:    [[X:%.*]] = call float @roundevenf(float 1.500000e+00) #[[ATTR0]]
+; CHECK-NEXT:    ret float [[X]]
+;
+  %x = call float @roundevenf(float 1.5) #0
+  ret float %x
+}
+
+; roundeven rounds ties to even, so -1.5 -> -2.0 (nearest even)
+define float @constant_fold_roundeven_f32_04() #0 {
+; CHECK-LABEL: define float @constant_fold_roundeven_f32_04(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT:    ret float -2.000000e+00
+;
+  %x = call float @llvm.roundeven.f32(float -1.5) #0
+  ret float %x
+}
+
+; roundeven rounds ties to even, so 2.5 -> 2.0 (nearest even)
+define float @constant_fold_roundeven_f32_05() #0 {
+; CHECK-LABEL: define float @constant_fold_roundeven_f32_05(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT:    [[X:%.*]] = call float @roundevenf(float 2.500000e+00) #[[ATTR0]]
+; CHECK-NEXT:    ret float [[X]]
+;
+  %x = call float @roundevenf(float 2.5) #0
+  ret float %x
+}
+
+; roundeven rounds ties to even, so -2.5 -> -2.0 (nearest even)
+define float @constant_fold_roundeven_f32_06() #0 {
+; CHECK-LABEL: define float @constant_fold_roundeven_f32_06(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT:    ret float -2.000000e+00
+;
+  %x = call float @llvm.roundeven.f32(float -2.5) #0
+  ret float %x
+}
+
+define float @constant_fold_roundeven_f32_07() #0 {
+; CHECK-LABEL: define float @constant_fold_roundeven_f32_07(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT:    [[X:%.*]] = call float @roundevenf(float 2.750000e+00) #[[ATTR0]]
+; CHECK-NEXT:    ret float [[X]]
+;
+  %x = call float @roundevenf(float 2.75) #0
+  ret float %x
+}
+
+define float @constant_fold_roundeven_f32_08() #0 {
+; CHECK-LABEL: define float @constant_fold_roundeven_f32_08(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT:    ret float -3.000000e+00
+;
+  %x = call float @llvm.roundeven.f32(float -2.75) #0
+  ret float %x
+}
+
+define double @constant_fold_roundeven_f64_01() #0 {
+; CHECK-LABEL: define double @constant_fold_roundeven_f64_01(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT:    [[X:%.*]] = call double @roundeven(double 1.300000e+00) #[[ATTR0]]
+; CHECK-NEXT:    ret double [[X]]
+;
+  %x = call double @roundeven(double 1.3) #0
+  ret double %x
+}
+
+define double @constant_fold_roundeven_f64_02() #0 {
+; CHECK-LABEL: define double @constant_fold_roundeven_f64_02(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT:    ret double -1.000000e+00
+;
+  %x = call double @llvm.roundeven.f64(double -1.3) #0
+  ret double %x
+}
+
+define double @constant_fold_roundeven_f64_03() #0 {
+; CHECK-LABEL: define double @constant_fold_roundeven_f64_03(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT:    [[X:%.*]] = call double @roundeven(double 1.500000e+00) #[[ATTR0]]
+; CHECK-NEXT:    ret double [[X]]
+;
+  %x = call double @roundeven(double 1.5) #0
+  ret double %x
+}
+
+define double @constant_fold_roundeven_f64_04() #0 {
+; CHECK-LABEL: define double @constant_fold_roundeven_f64_04(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT:    ret double -2.000000e+00
+;
+  %x = call double @llvm.roundeven.f64(double -1.5) #0
+  ret double %x
+}
+
+define double @constant_fold_roundeven_f64_05() #0 {
+; CHECK-LABEL: define double @constant_fold_roundeven_f64_05(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT:    [[X:%.*]] = call double @roundeven(double 2.500000e+00) #[[ATTR0]]
+; CHECK-NEXT:    ret double [[X]]
+;
+  %x = call double @roundeven(double 2.5) #0
+  ret double %x
+}
+
+define double @constant_fold_roundeven_f64_06() #0 {
+; CHECK-LABEL: define double @constant_fold_roundeven_f64_06(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT:    ret double -2.000000e+00
+;
+  %x = call double @llvm.roundeven.f64(double -2.5) #0
+  ret double %x
+}
+
+define double @constant_fold_roundeven_f64_07() #0 {
+; CHECK-LABEL: define double @constant_fold_roundeven_f64_07(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT:    [[X:%.*]] = call double @roundeven(double 2.700000e+00) #[[ATTR0]]
+; CHECK-NEXT:    ret double [[X]]
+;
+  %x = call double @roundeven(double 2.7) #0
+  ret double %x
+}
+
+define double @constant_fold_roundeven_f64_08() #0 {
+; CHECK-LABEL: define double @constant_fold_roundeven_f64_08(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT:    ret double -3.000000e+00
+;
+  %x = call double @llvm.roundeven.f64(double -2.7) #0
+  ret double %x
+}
+
+attributes #0 = { nounwind readnone willreturn }

``````````

</details>


https://github.com/llvm/llvm-project/pull/170688