Skip to content

Commit f64a057

Browse files
gchateletgchatelet
authored
[libc][NFC] Implement FPBits in terms of FloatProperties to reduce clutter (#75196)
Also make type naming consistent: - `UIntType` instead of `intU_t` - `FPBits` instead of `FPBits_t`, `FPB`
1 parent 60eca67 commit f64a057

File tree

17 files changed

+190
-191
lines changed

17 files changed

+190
-191
lines changed

‎libc/src/__support/FPUtil/FPBits.h

Lines changed: 34 additions & 34 deletions
Original file line numberDiff line numberDiff line change
@@ -36,71 +36,74 @@ template <typename T> struct ExponentWidth {
3636
// floating numbers. On x86 platforms however, the 'long double' type maps to
3737
// an x87 floating point format. This format is an IEEE 754 extension format.
3838
// It is handled as an explicit specialization of this class.
39-
template <typename T> struct FPBits {
39+
template <typename T> struct FPBits : private FloatProperties<T> {
4040
static_assert(cpp::is_floating_point_v<T>,
4141
"FPBits instantiated with invalid type.");
42+
using typename FloatProperties<T>::UIntType;
43+
using FloatProperties<T>::BIT_WIDTH;
44+
using FloatProperties<T>::EXP_MANT_MASK;
45+
using FloatProperties<T>::EXPONENT_MASK;
46+
using FloatProperties<T>::EXPONENT_BIAS;
47+
using FloatProperties<T>::EXPONENT_WIDTH;
48+
using FloatProperties<T>::MANTISSA_MASK;
49+
using FloatProperties<T>::MANTISSA_WIDTH;
50+
using FloatProperties<T>::QUIET_NAN_MASK;
51+
using FloatProperties<T>::SIGN_MASK;
4252

4353
// Reinterpreting bits as an integer value and interpreting the bits of an
4454
// integer value as a floating point value is used in tests. So, a convenient
4555
// type is provided for such reinterpretations.
46-
using FloatProp = FloatProperties<T>;
47-
using UIntType = typename FloatProp::UIntType;
48-
4956
UIntType bits;
5057

5158
LIBC_INLINE constexpr void set_mantissa(UIntType mantVal) {
52-
mantVal &= (FloatProp::MANTISSA_MASK);
53-
bits &= ~(FloatProp::MANTISSA_MASK);
59+
mantVal &= MANTISSA_MASK;
60+
bits &= ~MANTISSA_MASK;
5461
bits |= mantVal;
5562
}
5663

5764
LIBC_INLINE constexpr UIntType get_mantissa() const {
58-
return bits & FloatProp::MANTISSA_MASK;
65+
return bits & MANTISSA_MASK;
5966
}
6067

6168
LIBC_INLINE constexpr void set_biased_exponent(UIntType expVal) {
62-
expVal = (expVal << (FloatProp::MANTISSA_WIDTH)) & FloatProp::EXPONENT_MASK;
63-
bits &= ~(FloatProp::EXPONENT_MASK);
69+
expVal = (expVal << MANTISSA_WIDTH) & EXPONENT_MASK;
70+
bits &= ~EXPONENT_MASK;
6471
bits |= expVal;
6572
}
6673

6774
LIBC_INLINE constexpr uint16_t get_biased_exponent() const {
68-
return uint16_t((bits & FloatProp::EXPONENT_MASK) >>
69-
(FloatProp::MANTISSA_WIDTH));
75+
return uint16_t((bits & EXPONENT_MASK) >> MANTISSA_WIDTH);
7076
}
7177

7278
// The function return mantissa with the implicit bit set iff the current
7379
// value is a valid normal number.
7480
LIBC_INLINE constexpr UIntType get_explicit_mantissa() {
7581
return ((get_biased_exponent() > 0 && !is_inf_or_nan())
76-
? (FloatProp::MANTISSA_MASK + 1)
82+
? (MANTISSA_MASK + 1)
7783
: 0) |
78-
(FloatProp::MANTISSA_MASK & bits);
84+
(MANTISSA_MASK & bits);
7985
}
8086

8187
LIBC_INLINE constexpr void set_sign(bool signVal) {
82-
bits |= FloatProp::SIGN_MASK;
88+
bits |= SIGN_MASK;
8389
if (!signVal)
84-
bits -= FloatProp::SIGN_MASK;
90+
bits -= SIGN_MASK;
8591
}
8692

8793
LIBC_INLINE constexpr bool get_sign() const {
88-
return (bits & FloatProp::SIGN_MASK) != 0;
94+
return (bits & SIGN_MASK) != 0;
8995
}
9096

9197
static_assert(sizeof(T) == sizeof(UIntType),
9298
"Data type and integral representation have different sizes.");
9399

94-
static constexpr int EXPONENT_BIAS = (1 << (ExponentWidth<T>::VALUE - 1)) - 1;
95-
static constexpr int MAX_EXPONENT = (1 << ExponentWidth<T>::VALUE) - 1;
100+
static constexpr int MAX_EXPONENT = (1 << EXPONENT_WIDTH) - 1;
96101

97102
static constexpr UIntType MIN_SUBNORMAL = UIntType(1);
98-
static constexpr UIntType MAX_SUBNORMAL =
99-
(UIntType(1) << MantissaWidth<T>::VALUE) - 1;
100-
static constexpr UIntType MIN_NORMAL =
101-
(UIntType(1) << MantissaWidth<T>::VALUE);
103+
static constexpr UIntType MAX_SUBNORMAL = (UIntType(1) << MANTISSA_WIDTH) - 1;
104+
static constexpr UIntType MIN_NORMAL = (UIntType(1) << MANTISSA_WIDTH);
102105
static constexpr UIntType MAX_NORMAL =
103-
((UIntType(MAX_EXPONENT) - 1) << MantissaWidth<T>::VALUE) | MAX_SUBNORMAL;
106+
((UIntType(MAX_EXPONENT) - 1) << MANTISSA_WIDTH) | MAX_SUBNORMAL;
104107

105108
// We don't want accidental type promotions/conversions, so we require exact
106109
// type match.
@@ -151,32 +154,29 @@ template <typename T> struct FPBits {
151154
}
152155

153156
LIBC_INLINE constexpr bool is_inf() const {
154-
return (bits & FloatProp::EXP_MANT_MASK) == FloatProp::EXPONENT_MASK;
157+
return (bits & EXP_MANT_MASK) == EXPONENT_MASK;
155158
}
156159

157160
LIBC_INLINE constexpr bool is_nan() const {
158-
return (bits & FloatProp::EXP_MANT_MASK) > FloatProp::EXPONENT_MASK;
161+
return (bits & EXP_MANT_MASK) > EXPONENT_MASK;
159162
}
160163

161164
LIBC_INLINE constexpr bool is_quiet_nan() const {
162-
return (bits & FloatProp::EXP_MANT_MASK) ==
163-
(FloatProp::EXPONENT_MASK | FloatProp::QUIET_NAN_MASK);
165+
return (bits & EXP_MANT_MASK) == (EXPONENT_MASK | QUIET_NAN_MASK);
164166
}
165167

166168
LIBC_INLINE constexpr bool is_inf_or_nan() const {
167-
return (bits & FloatProp::EXPONENT_MASK) == FloatProp::EXPONENT_MASK;
169+
return (bits & EXPONENT_MASK) == EXPONENT_MASK;
168170
}
169171

170172
LIBC_INLINE static constexpr T zero(bool sign = false) {
171-
return FPBits(sign ? FloatProp::SIGN_MASK : UIntType(0)).get_val();
173+
return FPBits(sign ? SIGN_MASK : UIntType(0)).get_val();
172174
}
173175

174176
LIBC_INLINE static constexpr T neg_zero() { return zero(true); }
175177

176178
LIBC_INLINE static constexpr T inf(bool sign = false) {
177-
return FPBits((sign ? FloatProp::SIGN_MASK : UIntType(0)) |
178-
FloatProp::EXPONENT_MASK)
179-
.get_val();
179+
return FPBits((sign ? SIGN_MASK : UIntType(0)) | EXPONENT_MASK).get_val();
180180
}
181181

182182
LIBC_INLINE static constexpr T neg_inf() { return inf(true); }
@@ -204,7 +204,7 @@ template <typename T> struct FPBits {
204204
}
205205

206206
LIBC_INLINE static constexpr T build_quiet_nan(UIntType v) {
207-
return build_nan(FloatProp::QUIET_NAN_MASK | v);
207+
return build_nan(QUIET_NAN_MASK | v);
208208
}
209209

210210
// The function convert integer number and unbiased exponent to proper float
@@ -220,7 +220,7 @@ template <typename T> struct FPBits {
220220
LIBC_INLINE static constexpr FPBits<T> make_value(UIntType number, int ep) {
221221
FPBits<T> result;
222222
// offset: +1 for sign, but -1 for implicit first bit
223-
int lz = cpp::countl_zero(number) - FloatProp::EXPONENT_WIDTH;
223+
int lz = cpp::countl_zero(number) - EXPONENT_WIDTH;
224224
number <<= lz;
225225
ep -= lz;
226226

‎libc/src/__support/FPUtil/Hypot.h

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -104,14 +104,14 @@ template <> struct DoubleLength<uint64_t> {
104104
//
105105
template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
106106
LIBC_INLINE T hypot(T x, T y) {
107-
using FPBits_t = FPBits<T>;
108-
using UIntType = typename FPBits<T>::UIntType;
107+
using FPBits = FPBits<T>;
108+
using UIntType = typename FPBits::UIntType;
109109
using DUIntType = typename DoubleLength<UIntType>::Type;
110110

111-
FPBits_t x_bits(x), y_bits(y);
111+
FPBits x_bits(x), y_bits(y);
112112

113113
if (x_bits.is_inf() || y_bits.is_inf()) {
114-
return T(FPBits_t::inf());
114+
return T(FPBits::inf());
115115
}
116116
if (x_bits.is_nan()) {
117117
return x;
@@ -193,11 +193,11 @@ LIBC_INLINE T hypot(T x, T y) {
193193
sticky_bits = sticky_bits || ((sum & 0x3U) != 0);
194194
sum >>= 2;
195195
++out_exp;
196-
if (out_exp >= FPBits_t::MAX_EXPONENT) {
196+
if (out_exp >= FPBits::MAX_EXPONENT) {
197197
if (int round_mode = quick_get_round();
198198
round_mode == FE_TONEAREST || round_mode == FE_UPWARD)
199-
return T(FPBits_t::inf());
200-
return T(FPBits_t(FPBits_t::MAX_NORMAL));
199+
return T(FPBits::inf());
200+
return T(FPBits(FPBits::MAX_NORMAL));
201201
}
202202
} else {
203203
// For denormal result, we simply move the leading bit of the result to
@@ -251,10 +251,10 @@ LIBC_INLINE T hypot(T x, T y) {
251251
if (y_new >= (ONE >> 1)) {
252252
y_new -= ONE >> 1;
253253
++out_exp;
254-
if (out_exp >= FPBits_t::MAX_EXPONENT) {
254+
if (out_exp >= FPBits::MAX_EXPONENT) {
255255
if (round_mode == FE_TONEAREST || round_mode == FE_UPWARD)
256-
return T(FPBits_t::inf());
257-
return T(FPBits_t(FPBits_t::MAX_NORMAL));
256+
return T(FPBits::inf());
257+
return T(FPBits(FPBits::MAX_NORMAL));
258258
}
259259
}
260260

‎libc/src/__support/FPUtil/generic/FMod.h

Lines changed: 37 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -123,9 +123,9 @@ template <typename T> struct FModExceptionalInputHandler {
123123
"FModCStandardWrapper instantiated with invalid type.");
124124

125125
LIBC_INLINE static bool pre_check(T x, T y, T &out) {
126-
using FPB = fputil::FPBits<T>;
127-
const T quiet_nan = FPB::build_quiet_nan(0);
128-
FPB sx(x), sy(y);
126+
using FPBits = fputil::FPBits<T>;
127+
const T quiet_nan = FPBits::build_quiet_nan(0);
128+
FPBits sx(x), sy(y);
129129
if (LIBC_LIKELY(!sy.is_zero() && !sy.is_inf_or_nan() &&
130130
!sx.is_inf_or_nan())) {
131131
return false;
@@ -167,11 +167,11 @@ template <typename T> struct FModFastMathWrapper {
167167

168168
template <typename T> class FModDivisionSimpleHelper {
169169
private:
170-
using intU_t = typename FPBits<T>::UIntType;
170+
using UIntType = typename FPBits<T>::UIntType;
171171

172172
public:
173-
LIBC_INLINE constexpr static intU_t
174-
execute(int exp_diff, int sides_zeroes_count, intU_t m_x, intU_t m_y) {
173+
LIBC_INLINE constexpr static UIntType
174+
execute(int exp_diff, int sides_zeroes_count, UIntType m_x, UIntType m_y) {
175175
while (exp_diff > sides_zeroes_count) {
176176
exp_diff -= sides_zeroes_count;
177177
m_x <<= sides_zeroes_count;
@@ -185,24 +185,24 @@ template <typename T> class FModDivisionSimpleHelper {
185185

186186
template <typename T> class FModDivisionInvMultHelper {
187187
private:
188-
using FPB = FPBits<T>;
189-
using intU_t = typename FPB::UIntType;
188+
using FPBits = FPBits<T>;
189+
using UIntType = typename FPBits::UIntType;
190190

191191
public:
192-
LIBC_INLINE constexpr static intU_t
193-
execute(int exp_diff, int sides_zeroes_count, intU_t m_x, intU_t m_y) {
192+
LIBC_INLINE constexpr static UIntType
193+
execute(int exp_diff, int sides_zeroes_count, UIntType m_x, UIntType m_y) {
194194
if (exp_diff > sides_zeroes_count) {
195-
intU_t inv_hy = (cpp::numeric_limits<intU_t>::max() / m_y);
195+
UIntType inv_hy = (cpp::numeric_limits<UIntType>::max() / m_y);
196196
while (exp_diff > sides_zeroes_count) {
197197
exp_diff -= sides_zeroes_count;
198-
intU_t hd =
199-
(m_x * inv_hy) >> (FPB::FloatProp::BIT_WIDTH - sides_zeroes_count);
198+
UIntType hd =
199+
(m_x * inv_hy) >> (FPBits::BIT_WIDTH - sides_zeroes_count);
200200
m_x <<= sides_zeroes_count;
201201
m_x -= hd * m_y;
202202
while (LIBC_UNLIKELY(m_x > m_y))
203203
m_x -= m_y;
204204
}
205-
intU_t hd = (m_x * inv_hy) >> (FPB::FloatProp::BIT_WIDTH - exp_diff);
205+
UIntType hd = (m_x * inv_hy) >> (FPBits::BIT_WIDTH - exp_diff);
206206
m_x <<= exp_diff;
207207
m_x -= hd * m_y;
208208
while (LIBC_UNLIKELY(m_x > m_y))
@@ -222,44 +222,44 @@ class FMod {
222222
"FMod instantiated with invalid type.");
223223

224224
private:
225-
using FPB = FPBits<T>;
226-
using intU_t = typename FPB::UIntType;
225+
using FPBits = FPBits<T>;
226+
using UIntType = typename FPBits::UIntType;
227227

228-
LIBC_INLINE static constexpr FPB eval_internal(FPB sx, FPB sy) {
228+
LIBC_INLINE static constexpr FPBits eval_internal(FPBits sx, FPBits sy) {
229229

230230
if (LIBC_LIKELY(sx.uintval() <= sy.uintval())) {
231231
if (sx.uintval() < sy.uintval())
232-
return sx; // |x|<|y| return x
233-
return FPB(FPB::zero()); // |x|=|y| return 0.0
232+
return sx; // |x|<|y| return x
233+
return FPBits(FPBits::zero()); // |x|=|y| return 0.0
234234
}
235235

236236
int e_x = sx.get_biased_exponent();
237237
int e_y = sy.get_biased_exponent();
238238

239239
// Most common case where |y| is "very normal" and |x/y| < 2^EXPONENT_WIDTH
240-
if (LIBC_LIKELY(e_y > int(FPB::FloatProp::MANTISSA_WIDTH) &&
241-
e_x - e_y <= int(FPB::FloatProp::EXPONENT_WIDTH))) {
242-
intU_t m_x = sx.get_explicit_mantissa();
243-
intU_t m_y = sy.get_explicit_mantissa();
244-
intU_t d = (e_x == e_y) ? (m_x - m_y) : (m_x << (e_x - e_y)) % m_y;
240+
if (LIBC_LIKELY(e_y > int(FPBits::MANTISSA_WIDTH) &&
241+
e_x - e_y <= int(FPBits::EXPONENT_WIDTH))) {
242+
UIntType m_x = sx.get_explicit_mantissa();
243+
UIntType m_y = sy.get_explicit_mantissa();
244+
UIntType d = (e_x == e_y) ? (m_x - m_y) : (m_x << (e_x - e_y)) % m_y;
245245
if (d == 0)
246-
return FPB(FPB::zero());
246+
return FPBits(FPBits::zero());
247247
// iy - 1 because of "zero power" for number with power 1
248-
return FPB::make_value(d, e_y - 1);
248+
return FPBits::make_value(d, e_y - 1);
249249
}
250250
/* Both subnormal special case. */
251251
if (LIBC_UNLIKELY(e_x == 0 && e_y == 0)) {
252-
FPB d;
252+
FPBits d;
253253
d.set_mantissa(sx.uintval() % sy.uintval());
254254
return d;
255255
}
256256

257257
// Note that hx is not subnormal by conditions above.
258-
intU_t m_x = sx.get_explicit_mantissa();
258+
UIntType m_x = sx.get_explicit_mantissa();
259259
e_x--;
260260

261-
intU_t m_y = sy.get_explicit_mantissa();
262-
int lead_zeros_m_y = FPB::FloatProp::EXPONENT_WIDTH;
261+
UIntType m_y = sy.get_explicit_mantissa();
262+
int lead_zeros_m_y = FPBits::EXPONENT_WIDTH;
263263
if (LIBC_LIKELY(e_y > 0)) {
264264
e_y--;
265265
} else {
@@ -282,34 +282,34 @@ class FMod {
282282

283283
{
284284
// Shift hx left until the end or n = 0
285-
int left_shift = exp_diff < int(FPB::FloatProp::EXPONENT_WIDTH)
285+
int left_shift = exp_diff < int(FPBits::EXPONENT_WIDTH)
286286
? exp_diff
287-
: FPB::FloatProp::EXPONENT_WIDTH;
287+
: FPBits::EXPONENT_WIDTH;
288288
m_x <<= left_shift;
289289
exp_diff -= left_shift;
290290
}
291291

292292
m_x %= m_y;
293293
if (LIBC_UNLIKELY(m_x == 0))
294-
return FPB(FPB::zero());
294+
return FPBits(FPBits::zero());
295295

296296
if (exp_diff == 0)
297-
return FPB::make_value(m_x, e_y);
297+
return FPBits::make_value(m_x, e_y);
298298

299299
/* hx next can't be 0, because hx < hy, hy % 2 == 1 hx * 2^i % hy != 0 */
300300
m_x = DivisionHelper::execute(exp_diff, sides_zeroes_count, m_x, m_y);
301-
return FPB::make_value(m_x, e_y);
301+
return FPBits::make_value(m_x, e_y);
302302
}
303303

304304
public:
305305
LIBC_INLINE static T eval(T x, T y) {
306306
if (T out; Wrapper::pre_check(x, y, out))
307307
return out;
308-
FPB sx(x), sy(y);
308+
FPBits sx(x), sy(y);
309309
bool sign = sx.get_sign();
310310
sx.set_sign(false);
311311
sy.set_sign(false);
312-
FPB result = eval_internal(sx, sy);
312+
FPBits result = eval_internal(sx, sy);
313313
result.set_sign(sign);
314314
return result.get_val();
315315
}

0 commit comments

Comments
 (0)