1//===---- Free-standing function to detect rounding mode --------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef LLVM_LIBC_SRC___SUPPORT_FPUTIL_ROUNDING_MODE_H
10#define LLVM_LIBC_SRC___SUPPORT_FPUTIL_ROUNDING_MODE_H
11
12#include "hdr/fenv_macros.h"
13#include "src/__support/CPP/type_traits.h" // is_constant_evaluated
14#include "src/__support/macros/attributes.h" // LIBC_INLINE
15#include "src/__support/macros/config.h"
16#include "src/__support/macros/optimization.h"
17
18namespace LIBC_NAMESPACE_DECL {
19namespace fputil {
20
21namespace generic {
22
23// Quick free-standing test whether fegetround() == FE_UPWARD.
24// Using the following observation:
25// 1.0f + 2^-25 = 1.0f for FE_TONEAREST, FE_DOWNWARD, FE_TOWARDZERO
26// = 0x1.000002f for FE_UPWARD.
27LIBC_INLINE bool fenv_is_round_up() {
28#ifdef LIBC_MATH_HAS_ASSUME_ROUND_NEAREST_ONLY
29 return false;
30#else
31 static volatile float x = 0x1.0p-25f;
32 return (1.0f + x != 1.0f);
33#endif // LIBC_MATH_HAS_ASSUME_ROUND_NEAREST_ONLY
34}
35
36// Quick free-standing test whether fegetround() == FE_DOWNWARD.
37// Using the following observation:
38// -1.0f - 2^-25 = -1.0f for FE_TONEAREST, FE_UPWARD, FE_TOWARDZERO
39// = -0x1.000002f for FE_DOWNWARD.
40LIBC_INLINE bool fenv_is_round_down() {
41#ifdef LIBC_MATH_HAS_ASSUME_ROUND_NEAREST_ONLY
42 return false;
43#else
44 static volatile float x = 0x1.0p-25f;
45 return (-1.0f - x != -1.0f);
46#endif // LIBC_MATH_HAS_ASSUME_ROUND_NEAREST_ONLY
47}
48
49// Quick free-standing test whether fegetround() == FE_TONEAREST.
50// Using the following observation:
51// 1.5f + 2^-24 = 1.5f for FE_TONEAREST, FE_DOWNWARD, FE_TOWARDZERO
52// = 0x1.100002p0f for FE_UPWARD,
53// 1.5f - 2^-24 = 1.5f for FE_TONEAREST, FE_UPWARD
54// = 0x1.0ffffep-1f for FE_DOWNWARD, FE_TOWARDZERO
55LIBC_INLINE bool fenv_is_round_to_nearest() {
56#ifdef LIBC_MATH_HAS_ASSUME_ROUND_NEAREST_ONLY
57 return true;
58#else
59 static volatile float x = 0x1.0p-24f;
60 float y = 1.5f + x;
61 return (y == 1.5f - x);
62#endif // LIBC_MATH_HAS_ASSUME_ROUND_NEAREST_ONLY
63}
64
65// Quick free-standing test whether fegetround() == FE_TOWARDZERO.
66// Using the following observation:
67// 1.0f + 2^-23 + 2^-24 = 0x1.000002p0f for FE_DOWNWARD, FE_TOWARDZERO
68// = 0x1.000004p0f for FE_TONEAREST, FE_UPWARD,
69// -1.0f - 2^-24 = -1.0f for FE_TONEAREST, FE_UPWARD, FE_TOWARDZERO
70// = -0x1.000002p0f for FE_DOWNWARD
71// So:
72// (0x1.000002p0f + 2^-24) + (-1.0f - 2^-24) = 2^-23 for FE_TOWARDZERO
73// = 2^-22 for FE_TONEAREST, FE_UPWARD
74// = 0 for FE_DOWNWARD
75LIBC_INLINE bool fenv_is_round_to_zero() {
76#ifdef LIBC_MATH_HAS_ASSUME_ROUND_NEAREST_ONLY
77 return false;
78#else
79 static volatile float x = 0x1.0p-24f;
80 float y = x;
81 return ((0x1.000002p0f + y) + (-1.0f - y) == 0x1.0p-23f);
82#endif // LIBC_MATH_HAS_ASSUME_ROUND_NEAREST_ONLY
83}
84
85// Quick free standing get rounding mode based on the above observations.
86LIBC_INLINE int quick_get_round() {
87#ifdef LIBC_MATH_HAS_ASSUME_ROUND_NEAREST_ONLY
88 return FE_TONEAREST;
89#else
90 static volatile float x = 0x1.0p-24f;
91 float y = x;
92 float z = (0x1.000002p0f + y) + (-1.0f - y);
93
94 if (z == 0.0f)
95 return FE_DOWNWARD;
96 if (z == 0x1.0p-23f)
97 return FE_TOWARDZERO;
98 return (2.0f + y == 2.0f) ? FE_TONEAREST : FE_UPWARD;
99#endif // LIBC_MATH_HAS_ASSUME_ROUND_NEAREST_ONLY
100}
101
102} // namespace generic
103
104LIBC_INLINE LIBC_CONSTEXPR_DEFAULT bool fenv_is_round_up() {
105 if (cpp::is_constant_evaluated()) {
106 return false;
107 } else {
108 return generic::fenv_is_round_up();
109 }
110}
111
112LIBC_INLINE LIBC_CONSTEXPR_DEFAULT bool fenv_is_round_down() {
113 if (cpp::is_constant_evaluated()) {
114 return false;
115 } else {
116 return generic::fenv_is_round_down();
117 }
118}
119
120LIBC_INLINE LIBC_CONSTEXPR_DEFAULT bool fenv_is_round_to_nearest() {
121 if (cpp::is_constant_evaluated()) {
122 return true;
123 } else {
124 return generic::fenv_is_round_to_nearest();
125 }
126}
127
128LIBC_INLINE LIBC_CONSTEXPR_DEFAULT bool fenv_is_round_to_zero() {
129 if (cpp::is_constant_evaluated()) {
130 return false;
131 } else {
132 return generic::fenv_is_round_to_zero();
133 }
134}
135
136// Quick free standing get rounding mode based on the above observations.
137LIBC_INLINE LIBC_CONSTEXPR_DEFAULT int quick_get_round() {
138 if (cpp::is_constant_evaluated()) {
139 return FE_TONEAREST;
140 } else {
141 return generic::quick_get_round();
142 }
143}
144
145} // namespace fputil
146} // namespace LIBC_NAMESPACE_DECL
147
148#endif // LLVM_LIBC_SRC___SUPPORT_FPUTIL_ROUNDING_MODE_H
149