[llvm-branch-commits] [llvm] [ConstantFolding] Non-constrained functions in strictfp (PR #190478)
Stefan Weigl-Bosker via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Sat Apr 4 15:58:05 PDT 2026
================
@@ -0,0 +1,306 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 6
+; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
+
+; These tests check constant folding of the floating-point intrinsics, when
+; they are used in strictfp functions.
+
+; floor(10.0) is folded to 10.0
+define double @floor_exact() #0 {
+; CHECK-LABEL: define double @floor_exact(
+; CHECK-SAME: ) #[[ATTR0:[0-9]+]] {
+; CHECK-NEXT: [[ENTRY:.*:]]
+; CHECK-NEXT: [[RESULT:%.*]] = call double @llvm.floor.f64(double 1.000000e+01)
+; CHECK-NEXT: ret double 1.000000e+01
+;
+entry:
+ %result = call double @llvm.floor.f64(double 1.000000e+01)
+ ret double %result
+}
+
+; floor(SNAN) is NOT folded due to 'Invalid' exception. This is required by C Standard.
+define double @floor_snan() #0 {
+; CHECK-LABEL: define double @floor_snan(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT: [[ENTRY:.*:]]
+; CHECK-NEXT: [[RESULT:%.*]] = call double @llvm.floor.f64(double 0x7FF4000000000000)
+; CHECK-NEXT: ret double [[RESULT]]
+;
+entry:
+ %result = call double @llvm.floor.f64(double 0x7ff4000000000000)
+ ret double %result
+}
+
+; floor(10.1) is folded to 10.0 despite the possible 'Inexact' exception allowed by POSIX.
+define double @floor_inexact() #0 {
+; CHECK-LABEL: define double @floor_inexact(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT: [[ENTRY:.*:]]
+; CHECK-NEXT: [[RESULT:%.*]] = call double @llvm.floor.f64(double 1.010000e+01)
+; CHECK-NEXT: ret double [[RESULT]]
+;
+entry:
+ %result = call double @llvm.floor.f64(double 1.010000e+01)
+ ret double %result
+}
+
+; floor(+0.0) is folded to +0.0
+define double @floor_poszero() #0 {
+; CHECK-LABEL: define double @floor_poszero(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT: [[ENTRY:.*:]]
+; CHECK-NEXT: [[RESULT:%.*]] = call double @llvm.floor.f64(double 0.000000e+00)
+; CHECK-NEXT: ret double 0.000000e+00
+;
+entry:
+ %result = call double @llvm.floor.f64(double 0.0)
+ ret double %result
+}
+
+; floor(-0.0) is folded to -0.0
+define double @floor_negzero() #0 {
+; CHECK-LABEL: define double @floor_negzero(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT: [[ENTRY:.*:]]
+; CHECK-NEXT: [[RESULT:%.*]] = call double @llvm.floor.f64(double -0.000000e+00)
+; CHECK-NEXT: ret double -0.000000e+00
+;
+entry:
+ %result = call double @llvm.floor.f64(double -0.0)
+ ret double %result
+}
+
+; floor(+inf) is folded to +inf
+define double @floor_posinf() #0 {
+; CHECK-LABEL: define double @floor_posinf(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT: [[ENTRY:.*:]]
+; CHECK-NEXT: [[RESULT:%.*]] = call double @llvm.floor.f64(double 0x7FF0000000000000)
+; CHECK-NEXT: ret double 0x7FF0000000000000
+;
+entry:
+ %result = call double @llvm.floor.f64(double 0x7ff0000000000000)
+ ret double %result
+}
+
+; floor(-inf) is folded to -inf
+define double @floor_neginf() #0 {
+; CHECK-LABEL: define double @floor_neginf(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT: [[ENTRY:.*:]]
+; CHECK-NEXT: [[RESULT:%.*]] = call double @llvm.floor.f64(double 0xFFF0000000000000)
+; CHECK-NEXT: ret double 0xFFF0000000000000
+;
+entry:
+ %result = call double @llvm.floor.f64(double 0xfff0000000000000)
+ ret double %result
+}
+
+; ceil(10.0) is folded to 10.0
+define double @ceil_exact() #0 {
+; CHECK-LABEL: define double @ceil_exact(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT: [[ENTRY:.*:]]
+; CHECK-NEXT: [[RESULT:%.*]] = call double @llvm.ceil.f64(double 1.000000e+01)
+; CHECK-NEXT: ret double 1.000000e+01
+;
+entry:
+ %result = call double @llvm.ceil.f64(double 1.000000e+01)
+ ret double %result
+}
+
+; ceil(SNAN) is NOT folded due to 'Invalid' exception. This is required by C Standard.
+define double @fceil_snan() #0 {
+; CHECK-LABEL: define double @fceil_snan(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT: [[ENTRY:.*:]]
+; CHECK-NEXT: [[RESULT:%.*]] = call double @llvm.ceil.f64(double 0x7FF4000000000000)
+; CHECK-NEXT: ret double [[RESULT]]
+;
+entry:
+ %result = call double @llvm.ceil.f64(double 0x7ff4000000000000)
+ ret double %result
+}
+
+; trunc(10.0) is folded to 10.0
+define double @trunc_exact() #0 {
+; CHECK-LABEL: define double @trunc_exact(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT: [[ENTRY:.*:]]
+; CHECK-NEXT: [[RESULT:%.*]] = call double @llvm.trunc.f64(double 1.000000e+01)
+; CHECK-NEXT: ret double 1.000000e+01
+;
+entry:
+ %result = call double @llvm.trunc.f64(double 1.000000e+01)
+ ret double %result
+}
+
+; trunc(SNAN) is NOT folded due to 'Invalid' exception. This is required by C Standard.
+define double @ftrunc_snan() #0 {
+; CHECK-LABEL: define double @ftrunc_snan(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT: [[ENTRY:.*:]]
+; CHECK-NEXT: [[RESULT:%.*]] = call double @llvm.trunc.f64(double 0x7FF4000000000000)
+; CHECK-NEXT: ret double [[RESULT]]
+;
+entry:
+ %result = call double @llvm.trunc.f64(double 0x7ff4000000000000)
+ ret double %result
+}
+
+; round(10.0) is folded to 10.0
+define double @round_exact() #0 {
+; CHECK-LABEL: define double @round_exact(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT: [[ENTRY:.*:]]
+; CHECK-NEXT: [[RESULT:%.*]] = call double @llvm.round.f64(double 1.000000e+01)
+; CHECK-NEXT: ret double 1.000000e+01
+;
+entry:
+ %result = call double @llvm.round.f64(double 1.000000e+01)
+ ret double %result
+}
+
+; round(SNAN) is NOT folded due to 'Invalid' exception. This is required by C Standard.
+define double @round_snan() #0 {
+; CHECK-LABEL: define double @round_snan(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT: [[ENTRY:.*:]]
+; CHECK-NEXT: [[RESULT:%.*]] = call double @llvm.round.f64(double 0x7FF4000000000000)
+; CHECK-NEXT: ret double [[RESULT]]
+;
+entry:
+ %result = call double @llvm.round.f64(double 0x7ff4000000000000)
+ ret double %result
+}
+
+; roundeven(10.0) is folded to 10.0
+define double @roundeven_exact() #0 {
+; CHECK-LABEL: define double @roundeven_exact(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT: [[ENTRY:.*:]]
+; CHECK-NEXT: [[RESULT:%.*]] = call double @llvm.roundeven.f64(double 1.000000e+01)
+; CHECK-NEXT: ret double 1.000000e+01
+;
+entry:
+ %result = call double @llvm.roundeven.f64(double 1.000000e+01)
+ ret double %result
+}
+
+; roundeven(SNAN) is NOT folded due to 'Invalid' exception. This is required by C Standard.
+define double @roundeven_snan() #0 {
+; CHECK-LABEL: define double @roundeven_snan(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT: [[ENTRY:.*:]]
+; CHECK-NEXT: [[RESULT:%.*]] = call double @llvm.roundeven.f64(double 0x7FF4000000000000)
+; CHECK-NEXT: ret double [[RESULT]]
+;
+entry:
+ %result = call double @llvm.roundeven.f64(double 0x7ff4000000000000)
+ ret double %result
+}
+
+; nearbyint(10.0) is folded to 10.0
+define double @nearbyint_exact() #0 {
+; CHECK-LABEL: define double @nearbyint_exact(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT: [[ENTRY:.*:]]
+; CHECK-NEXT: [[RESULT:%.*]] = call double @llvm.nearbyint.f64(double 1.000000e+01)
+; CHECK-NEXT: ret double 1.000000e+01
+;
+entry:
+ %result = call double @llvm.nearbyint.f64(double 1.000000e+01)
+ ret double %result
+}
+
+; nearbyint(SNAN) is NOT folded due to 'Invalid' exception. This is required by C Standard.
+define double @nearbyint_snan() #0 {
+; CHECK-LABEL: define double @nearbyint_snan(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT: [[ENTRY:.*:]]
+; CHECK-NEXT: [[RESULT:%.*]] = call double @llvm.nearbyint.f64(double 0x7FF4000000000000)
+; CHECK-NEXT: ret double [[RESULT]]
+;
+entry:
+ %result = call double @llvm.nearbyint.f64(double 0x7ff4000000000000)
+ ret double %result
+}
+
+; nearbyint(10.1) is NOT folded because rounding mode is unknown at compile time.
+define double @nearbyint_inexact() #0 {
+; CHECK-LABEL: define double @nearbyint_inexact(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT: [[ENTRY:.*:]]
+; CHECK-NEXT: [[RESULT:%.*]] = call double @llvm.nearbyint.f64(double 1.010000e+01)
+; CHECK-NEXT: ret double [[RESULT]]
+;
+entry:
+ %result = call double @llvm.nearbyint.f64(double 1.010000e+01)
+ ret double %result
+}
+
+; rint(10.0) is folded to 10.0
+define double @rint_exact() #0 {
+; CHECK-LABEL: define double @rint_exact(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT: [[ENTRY:.*:]]
+; CHECK-NEXT: [[RESULT:%.*]] = call double @llvm.rint.f64(double 1.000000e+01)
+; CHECK-NEXT: ret double 1.000000e+01
+;
+entry:
+ %result = call double @llvm.rint.f64(double 1.000000e+01)
+ ret double %result
+}
+
+; rint(SNAN) is NOT folded due to 'Invalid' exception. This is required by C Standard.
+define double @rint_snan() #0 {
+; CHECK-LABEL: define double @rint_snan(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT: [[ENTRY:.*:]]
+; CHECK-NEXT: [[RESULT:%.*]] = call double @llvm.rint.f64(double 0x7FF4000000000000)
+; CHECK-NEXT: ret double [[RESULT]]
+;
+entry:
+ %result = call double @llvm.rint.f64(double 0x7ff4000000000000)
+ ret double %result
+}
+
+; rint(10.1) is NOT folded because rounding mode is unknown at compile time.
+define double @rint_inexact() #0 {
+; CHECK-LABEL: define double @rint_inexact(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT: [[ENTRY:.*:]]
+; CHECK-NEXT: [[RESULT:%.*]] = call double @llvm.rint.f64(double 1.010000e+01)
+; CHECK-NEXT: ret double [[RESULT]]
+;
+entry:
+ %result = call double @llvm.rint.f64(double 1.010000e+01)
+ ret double %result
+}
+
+; log(1.0) is folded to 0.0, because this is an exact value.
+define double @sin_exact() #0 {
+; CHECK-LABEL: define double @sin_exact(
+; CHECK-SAME: ) #[[ATTR0]] {
+; CHECK-NEXT: [[ENTRY:.*:]]
+; CHECK-NEXT: [[RESULT:%.*]] = call double @llvm.log.f64(double 1.000000e+00)
+; CHECK-NEXT: ret double 0.000000e+00
+;
+entry:
+ %result = call double @llvm.log.f64(double 1.0)
+ ret double %result
+}
+
+; log(2.0) is NOT folded, because rounding mode is unknown at compile time.
+define double @sin_inexact() #0 {
----------------
sweiglbosker wrote:
```suggestion
define double @log_inexact() #0 {
```
same here
https://github.com/llvm/llvm-project/pull/190478
More information about the llvm-branch-commits
mailing list