[libc-commits] [libc] [libc][NFC] Move `BigInt` out of the `cpp` namespace (PR #84445)
via libc-commits
libc-commits at lists.llvm.org
Fri Mar 8 00:34:54 PST 2024
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-libc
Author: Guillaume Chatelet (gchatelet)
<details>
<summary>Changes</summary>
As noted in https://github.com/llvm/llvm-project/pull/84035#discussion_r1516817755 only files under the CPP folder should be in the `cpp` namespace.
---
Patch is 33.41 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/84445.diff
17 Files Affected:
- (modified) libc/src/__support/FPUtil/dyadic_float.h (+1-1)
- (modified) libc/src/__support/UInt.h (+33-34)
- (modified) libc/src/__support/UInt128.h (+2-2)
- (modified) libc/src/__support/float_to_string.h (+33-33)
- (modified) libc/src/__support/integer_literals.h (+4-4)
- (modified) libc/src/__support/integer_to_string.h (+3-3)
- (modified) libc/src/__support/str_to_float.h (+1-1)
- (modified) libc/src/stdio/printf_core/float_dec_converter.h (+3-3)
- (modified) libc/test/UnitTest/LibcTest.cpp (+6-6)
- (modified) libc/test/UnitTest/LibcTest.h (+1-1)
- (modified) libc/test/UnitTest/StringUtils.h (+1-1)
- (modified) libc/test/UnitTest/TestLogger.cpp (+5-5)
- (modified) libc/test/src/__support/CPP/bit_test.cpp (+1-1)
- (modified) libc/test/src/__support/CPP/limits_test.cpp (+3-3)
- (modified) libc/test/src/__support/integer_literals_test.cpp (+1-1)
- (modified) libc/test/src/__support/integer_to_string_test.cpp (+1-1)
- (modified) libc/test/src/__support/uint_test.cpp (+13-13)
``````````diff
diff --git a/libc/src/__support/FPUtil/dyadic_float.h b/libc/src/__support/FPUtil/dyadic_float.h
index f25fa9b3026c1a..73fd7381c3c838 100644
--- a/libc/src/__support/FPUtil/dyadic_float.h
+++ b/libc/src/__support/FPUtil/dyadic_float.h
@@ -31,7 +31,7 @@ namespace LIBC_NAMESPACE::fputil {
// To simplify and improve the efficiency, many functions will assume that the
// inputs are normal.
template <size_t Bits> struct DyadicFloat {
- using MantissaType = LIBC_NAMESPACE::cpp::UInt<Bits>;
+ using MantissaType = LIBC_NAMESPACE::UInt<Bits>;
Sign sign = Sign::POS;
int exponent = 0;
diff --git a/libc/src/__support/UInt.h b/libc/src/__support/UInt.h
index e899a79684b739..cf0c5a669ae8dd 100644
--- a/libc/src/__support/UInt.h
+++ b/libc/src/__support/UInt.h
@@ -23,16 +23,16 @@
#include <stddef.h> // For size_t
#include <stdint.h>
-namespace LIBC_NAMESPACE::cpp {
+namespace LIBC_NAMESPACE {
namespace internal {
template <typename T> struct half_width;
-template <> struct half_width<uint64_t> : type_identity<uint32_t> {};
-template <> struct half_width<uint32_t> : type_identity<uint16_t> {};
-template <> struct half_width<uint16_t> : type_identity<uint8_t> {};
+template <> struct half_width<uint64_t> : cpp::type_identity<uint32_t> {};
+template <> struct half_width<uint32_t> : cpp::type_identity<uint16_t> {};
+template <> struct half_width<uint16_t> : cpp::type_identity<uint8_t> {};
#ifdef __SIZEOF_INT128__
-template <> struct half_width<__uint128_t> : type_identity<uint64_t> {};
+template <> struct half_width<__uint128_t> : cpp::type_identity<uint64_t> {};
#endif // __SIZEOF_INT128__
template <typename T> using half_width_t = typename half_width<T>::type;
@@ -40,7 +40,7 @@ template <typename T> using half_width_t = typename half_width<T>::type;
template <size_t Bits, bool Signed, typename WordType = uint64_t>
struct BigInt {
- static_assert(is_integral_v<WordType> && is_unsigned_v<WordType>,
+ static_assert(cpp::is_integral_v<WordType> && cpp::is_unsigned_v<WordType>,
"WordType must be unsigned integer.");
using word_type = WordType;
@@ -76,7 +76,7 @@ struct BigInt {
WordType sign = 0;
if constexpr (Signed && OtherSigned) {
sign = static_cast<WordType>(
- -static_cast<make_signed_t<WordType>>(other.is_neg()));
+ -static_cast<cpp::make_signed_t<WordType>>(other.is_neg()));
}
for (; i < WORD_COUNT; ++i)
val[i] = sign;
@@ -84,7 +84,7 @@ struct BigInt {
}
// Construct a BigInt from a C array.
- template <size_t N, enable_if_t<N <= WORD_COUNT, int> = 0>
+ template <size_t N, cpp::enable_if_t<N <= WORD_COUNT, int> = 0>
LIBC_INLINE constexpr BigInt(const WordType (&nums)[N]) {
size_t min_wordcount = N < WORD_COUNT ? N : WORD_COUNT;
size_t i = 0;
@@ -97,7 +97,7 @@ struct BigInt {
}
// Initialize the first word to |v| and the rest to 0.
- template <typename T, typename = cpp::enable_if_t<is_integral_v<T>>>
+ template <typename T, typename = cpp::enable_if_t<cpp::is_integral_v<T>>>
LIBC_INLINE constexpr BigInt(T v) {
val[0] = static_cast<WordType>(v);
@@ -406,7 +406,7 @@ struct BigInt {
// div takes another BigInt of the same size and divides this by it. The value
// of this will be set to the quotient, and the return value is the remainder.
- LIBC_INLINE constexpr optional<BigInt> div(const BigInt &other) {
+ LIBC_INLINE constexpr cpp::optional<BigInt> div(const BigInt &other) {
BigInt remainder(0);
if (*this < other) {
remainder = *this;
@@ -417,7 +417,7 @@ struct BigInt {
return remainder;
}
if (other == 0) {
- return nullopt;
+ return cpp::nullopt;
}
BigInt quotient(0);
@@ -448,12 +448,12 @@ struct BigInt {
// Since the remainder of each division step < x < 2^(WORD_SIZE / 2), the
// computation of each step is now properly contained within WordType.
// And finally we perform some extra alignment steps for the remaining bits.
- LIBC_INLINE constexpr optional<BigInt>
+ LIBC_INLINE constexpr cpp::optional<BigInt>
div_uint_half_times_pow_2(internal::half_width_t<WordType> x, size_t e) {
BigInt remainder(0);
if (x == 0) {
- return nullopt;
+ return cpp::nullopt;
}
if (e >= Bits) {
remainder = *this;
@@ -463,7 +463,7 @@ struct BigInt {
BigInt quotient(0);
WordType x_word = static_cast<WordType>(x);
- constexpr size_t LOG2_WORD_SIZE = bit_width(WORD_SIZE) - 1;
+ constexpr size_t LOG2_WORD_SIZE = cpp::bit_width(WORD_SIZE) - 1;
constexpr size_t HALF_WORD_SIZE = WORD_SIZE >> 1;
constexpr WordType HALF_MASK = ((WordType(1) << HALF_WORD_SIZE) - 1);
// lower = smallest multiple of WORD_SIZE that is >= e.
@@ -592,7 +592,7 @@ struct BigInt {
int leading_zeroes = 0;
for (auto i = val.size(); i > 0;) {
--i;
- const int zeroes = countl_zero(val[i]);
+ const int zeroes = cpp::countl_zero(val[i]);
leading_zeroes += zeroes;
if (zeroes != word_digits)
break;
@@ -605,7 +605,7 @@ struct BigInt {
constexpr int word_digits = cpp::numeric_limits<word_type>::digits;
int trailing_zeroes = 0;
for (auto word : val) {
- const int zeroes = countr_zero(word);
+ const int zeroes = cpp::countr_zero(word);
trailing_zeroes += zeroes;
if (zeroes != word_digits)
break;
@@ -913,7 +913,7 @@ template <size_t Bits>
using Int = BigInt<Bits, true, internal::WordTypeSelectorT<Bits>>;
// Provides limits of U/Int<128>.
-template <> class numeric_limits<UInt<128>> {
+template <> class cpp::numeric_limits<UInt<128>> {
public:
LIBC_INLINE static constexpr UInt<128> max() {
return UInt<128>({0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff});
@@ -924,7 +924,7 @@ template <> class numeric_limits<UInt<128>> {
LIBC_INLINE_VAR static constexpr int digits = 128;
};
-template <> class numeric_limits<Int<128>> {
+template <> class cpp::numeric_limits<Int<128>> {
public:
LIBC_INLINE static constexpr Int<128> max() {
return Int<128>({0xffff'ffff'ffff'ffff, 0x7fff'ffff'ffff'ffff});
@@ -937,7 +937,7 @@ template <> class numeric_limits<Int<128>> {
LIBC_INLINE_VAR static constexpr int digits = 128;
};
-// type traits to determine whether a T is a cpp::BigInt.
+// type traits to determine whether a T is a BigInt.
template <typename T> struct is_big_int : cpp::false_type {};
template <size_t Bits, bool Signed, typename T>
@@ -946,6 +946,8 @@ struct is_big_int<BigInt<Bits, Signed, T>> : cpp::true_type {};
template <class T>
LIBC_INLINE_VAR constexpr bool is_big_int_v = is_big_int<T>::value;
+namespace cpp {
+
// Specialization of cpp::bit_cast ('bit.h') from T to BigInt.
template <typename To, typename From>
LIBC_INLINE constexpr cpp::enable_if_t<
@@ -973,7 +975,7 @@ bit_cast(const UInt<Bits> &from) {
// Specialization of cpp::has_single_bit ('bit.h') for BigInt.
template <typename T>
-[[nodiscard]] LIBC_INLINE constexpr cpp::enable_if_t<cpp::is_big_int_v<T>, bool>
+[[nodiscard]] LIBC_INLINE constexpr cpp::enable_if_t<is_big_int_v<T>, bool>
has_single_bit(T value) {
int bits = 0;
for (auto word : value.val) {
@@ -988,21 +990,21 @@ has_single_bit(T value) {
// Specialization of cpp::countr_zero ('bit.h') for BigInt.
template <typename T>
-[[nodiscard]] LIBC_INLINE constexpr cpp::enable_if_t<cpp::is_big_int_v<T>, int>
+[[nodiscard]] LIBC_INLINE constexpr cpp::enable_if_t<is_big_int_v<T>, int>
countr_zero(const T &value) {
return value.ctz();
}
// Specialization of cpp::countl_zero ('bit.h') for BigInt.
template <typename T>
-[[nodiscard]] LIBC_INLINE constexpr cpp::enable_if_t<cpp::is_big_int_v<T>, int>
+[[nodiscard]] LIBC_INLINE constexpr cpp::enable_if_t<is_big_int_v<T>, int>
countl_zero(const T &value) {
return value.clz();
}
// Specialization of cpp::countl_one ('bit.h') for BigInt.
template <typename T>
-[[nodiscard]] LIBC_INLINE constexpr cpp::enable_if_t<cpp::is_big_int_v<T>, int>
+[[nodiscard]] LIBC_INLINE constexpr cpp::enable_if_t<is_big_int_v<T>, int>
countl_one(T value) {
// TODO : Implement a faster version not involving operator~.
return cpp::countl_zero<T>(~value);
@@ -1010,7 +1012,7 @@ countl_one(T value) {
// Specialization of cpp::countr_one ('bit.h') for BigInt.
template <typename T>
-[[nodiscard]] LIBC_INLINE constexpr cpp::enable_if_t<cpp::is_big_int_v<T>, int>
+[[nodiscard]] LIBC_INLINE constexpr cpp::enable_if_t<is_big_int_v<T>, int>
countr_one(T value) {
// TODO : Implement a faster version not involving operator~.
return cpp::countr_zero<T>(~value);
@@ -1018,19 +1020,19 @@ countr_one(T value) {
// Specialization of cpp::bit_width ('bit.h') for BigInt.
template <typename T>
-[[nodiscard]] LIBC_INLINE constexpr cpp::enable_if_t<cpp::is_big_int_v<T>, int>
+[[nodiscard]] LIBC_INLINE constexpr cpp::enable_if_t<is_big_int_v<T>, int>
bit_width(T value) {
return cpp::numeric_limits<T>::digits - cpp::countl_zero(value);
}
// Forward-declare rotr so that rotl can use it.
template <typename T>
-[[nodiscard]] LIBC_INLINE constexpr cpp::enable_if_t<cpp::is_big_int_v<T>, T>
+[[nodiscard]] LIBC_INLINE constexpr cpp::enable_if_t<is_big_int_v<T>, T>
rotr(T value, int rotate);
// Specialization of cpp::rotl ('bit.h') for BigInt.
template <typename T>
-[[nodiscard]] LIBC_INLINE constexpr cpp::enable_if_t<cpp::is_big_int_v<T>, T>
+[[nodiscard]] LIBC_INLINE constexpr cpp::enable_if_t<is_big_int_v<T>, T>
rotl(T value, int rotate) {
constexpr unsigned N = cpp::numeric_limits<T>::digits;
rotate = rotate % N;
@@ -1043,7 +1045,7 @@ rotl(T value, int rotate) {
// Specialization of cpp::rotr ('bit.h') for BigInt.
template <typename T>
-[[nodiscard]] LIBC_INLINE constexpr cpp::enable_if_t<cpp::is_big_int_v<T>, T>
+[[nodiscard]] LIBC_INLINE constexpr cpp::enable_if_t<is_big_int_v<T>, T>
rotr(T value, int rotate) {
constexpr unsigned N = cpp::numeric_limits<T>::digits;
rotate = rotate % N;
@@ -1054,13 +1056,11 @@ rotr(T value, int rotate) {
return (value >> rotate) | (value << (N - rotate));
}
-} // namespace LIBC_NAMESPACE::cpp
-
-namespace LIBC_NAMESPACE {
+} // namespace cpp
// Specialization of mask_trailing_ones ('math_extras.h') for BigInt.
template <typename T, size_t count>
-LIBC_INLINE constexpr cpp::enable_if_t<cpp::is_big_int_v<T>, T>
+LIBC_INLINE constexpr cpp::enable_if_t<is_big_int_v<T>, T>
mask_trailing_ones() {
static_assert(!T::SIGNED);
if (count == 0)
@@ -1086,8 +1086,7 @@ mask_trailing_ones() {
// Specialization of mask_leading_ones ('math_extras.h') for BigInt.
template <typename T, size_t count>
-LIBC_INLINE constexpr cpp::enable_if_t<cpp::is_big_int_v<T>, T>
-mask_leading_ones() {
+LIBC_INLINE constexpr cpp::enable_if_t<is_big_int_v<T>, T> mask_leading_ones() {
static_assert(!T::SIGNED);
if (count == 0)
return T();
diff --git a/libc/src/__support/UInt128.h b/libc/src/__support/UInt128.h
index 0558e5095f9f51..06696b7a61581e 100644
--- a/libc/src/__support/UInt128.h
+++ b/libc/src/__support/UInt128.h
@@ -15,8 +15,8 @@
using UInt128 = __uint128_t;
using Int128 = __int128_t;
#else
-using UInt128 = LIBC_NAMESPACE::cpp::UInt<128>;
-using Int128 = LIBC_NAMESPACE::cpp::Int<128>;
+using UInt128 = LIBC_NAMESPACE::UInt<128>;
+using Int128 = LIBC_NAMESPACE::Int<128>;
#endif
#endif // LLVM_LIBC_SRC___SUPPORT_UINT128_H
diff --git a/libc/src/__support/float_to_string.h b/libc/src/__support/float_to_string.h
index 27476433a94575..751f3c8cc9c216 100644
--- a/libc/src/__support/float_to_string.h
+++ b/libc/src/__support/float_to_string.h
@@ -179,7 +179,7 @@ LIBC_INLINE constexpr uint32_t length_for_num(uint32_t idx,
// TODO: Fix long doubles (needs bigger table or alternate algorithm.)
// Currently the table values are generated, which is very slow.
template <size_t INT_SIZE>
-LIBC_INLINE constexpr cpp::UInt<MID_INT_SIZE> get_table_positive(int exponent,
+LIBC_INLINE constexpr UInt<MID_INT_SIZE> get_table_positive(int exponent,
size_t i) {
// INT_SIZE is the size of int that is used for the internal calculations of
// this function. It should be large enough to hold 2^(exponent+constant), so
@@ -191,17 +191,17 @@ LIBC_INLINE constexpr cpp::UInt<MID_INT_SIZE> get_table_positive(int exponent,
if (shift_amount < 0) {
return 1;
}
- cpp::UInt<INT_SIZE> num(0);
+ UInt<INT_SIZE> num(0);
// MOD_SIZE is one of the limiting factors for how big the constant argument
// can get, since it needs to be small enough to fit in the result UInt,
// otherwise we'll get truncation on return.
- constexpr cpp::UInt<INT_SIZE> MOD_SIZE =
- (cpp::UInt<INT_SIZE>(EXP10_9)
+ constexpr UInt<INT_SIZE> MOD_SIZE =
+ (UInt<INT_SIZE>(EXP10_9)
<< (CALC_SHIFT_CONST + (IDX_SIZE > 1 ? IDX_SIZE : 0)));
- num = cpp::UInt<INT_SIZE>(1) << (shift_amount);
+ num = UInt<INT_SIZE>(1) << (shift_amount);
if (i > 0) {
- cpp::UInt<INT_SIZE> fives(EXP5_9);
+ UInt<INT_SIZE> fives(EXP5_9);
fives.pow_n(i);
num = num / fives;
}
@@ -217,7 +217,7 @@ LIBC_INLINE constexpr cpp::UInt<MID_INT_SIZE> get_table_positive(int exponent,
}
template <size_t INT_SIZE>
-LIBC_INLINE cpp::UInt<MID_INT_SIZE> get_table_positive_df(int exponent,
+LIBC_INLINE UInt<MID_INT_SIZE> get_table_positive_df(int exponent,
size_t i) {
static_assert(INT_SIZE == 256,
"Only 256 is supported as an int size right now.");
@@ -233,11 +233,11 @@ LIBC_INLINE cpp::UInt<MID_INT_SIZE> get_table_positive_df(int exponent,
return 1;
}
fputil::DyadicFloat<INT_SIZE> num(false, 0, 1);
- constexpr cpp::UInt<INT_SIZE> MOD_SIZE =
- (cpp::UInt<INT_SIZE>(EXP10_9)
+ constexpr UInt<INT_SIZE> MOD_SIZE =
+ (UInt<INT_SIZE>(EXP10_9)
<< (CALC_SHIFT_CONST + (IDX_SIZE > 1 ? IDX_SIZE : 0)));
- constexpr cpp::UInt<INT_SIZE> FIVE_EXP_MINUS_NINE_MANT{
+ constexpr UInt<INT_SIZE> FIVE_EXP_MINUS_NINE_MANT{
{0xf387295d242602a7, 0xfdd7645e011abac9, 0x31680a88f8953030,
0x89705f4136b4a597}};
@@ -251,7 +251,7 @@ LIBC_INLINE cpp::UInt<MID_INT_SIZE> get_table_positive_df(int exponent,
num = mul_pow_2(num, shift_amount);
// Adding one is part of the formula.
- cpp::UInt<INT_SIZE> int_num = static_cast<cpp::UInt<INT_SIZE>>(num) + 1;
+ UInt<INT_SIZE> int_num = static_cast<UInt<INT_SIZE>>(num) + 1;
if (int_num > MOD_SIZE) {
auto rem =
int_num
@@ -261,7 +261,7 @@ LIBC_INLINE cpp::UInt<MID_INT_SIZE> get_table_positive_df(int exponent,
int_num = rem;
}
- cpp::UInt<MID_INT_SIZE> result = int_num;
+ UInt<MID_INT_SIZE> result = int_num;
return result;
}
@@ -275,11 +275,11 @@ LIBC_INLINE cpp::UInt<MID_INT_SIZE> get_table_positive_df(int exponent,
// The formula being used looks more like this:
// floor(10^(9*(-i)) * 2^(c_0 + (-e))) % (10^9 * 2^c_0)
template <size_t INT_SIZE>
-LIBC_INLINE cpp::UInt<MID_INT_SIZE> get_table_negative(int exponent, size_t i) {
+LIBC_INLINE UInt<MID_INT_SIZE> get_table_negative(int exponent, size_t i) {
int shift_amount = CALC_SHIFT_CONST - exponent;
- cpp::UInt<INT_SIZE> num(1);
- constexpr cpp::UInt<INT_SIZE> MOD_SIZE =
- (cpp::UInt<INT_SIZE>(EXP10_9)
+ UInt<INT_SIZE> num(1);
+ constexpr UInt<INT_SIZE> MOD_SIZE =
+ (UInt<INT_SIZE>(EXP10_9)
<< (CALC_SHIFT_CONST + (IDX_SIZE > 1 ? IDX_SIZE : 0)));
size_t ten_blocks = i;
@@ -298,12 +298,12 @@ LIBC_INLINE cpp::UInt<MID_INT_SIZE> get_table_negative(int exponent, size_t i) {
}
if (five_blocks > 0) {
- cpp::UInt<INT_SIZE> fives(EXP5_9);
+ UInt<INT_SIZE> fives(EXP5_9);
fives.pow_n(five_blocks);
num = fives;
}
if (ten_blocks > 0) {
- cpp::UInt<INT_SIZE> tens(EXP10_9);
+ UInt<INT_SIZE> tens(EXP10_9);
tens.pow_n(ten_blocks);
if (five_blocks <= 0) {
num = tens;
@@ -327,7 +327,7 @@ LIBC_INLINE cpp::UInt<MID_INT_SIZE> get_table_negative(int exponent, size_t i) {
}
template <size_t INT_SIZE>
-LIBC_INLINE cpp::UInt<MID_INT_SIZE> get_table_negative_df(int exponent,
+LIBC_INLINE UInt<MID_INT_SIZE> get_table_negative_df(int exponent,
size_t i) {
static_assert(INT_SIZE == 256,
"Only 256 is supported as an int size right now.");
@@ -341,11 +341,11 @@ LIBC_INLINE cpp::UInt<MID_INT_SIZE> get_table_negative_df(int exponent,
int shift_amount = CALC_SHIFT_CONST - exponent;
fputil::DyadicFloat<INT_SIZE> num(false, 0, 1);
- constexpr cpp::UInt<INT_SIZE> MOD_SIZE =
- (cpp::UInt<INT_SIZE>(EXP10_9)
+ constexpr UInt<INT_SIZE> MOD_SIZE =
+ (UInt<INT_SIZE>(EXP10_9)
<< (CALC_SHIFT_CONST + (IDX_SIZE > 1 ? IDX_SIZE : 0)));
- constexpr cpp::UInt<INT_SIZE> TEN_EXP_NINE_MANT(EXP10_9);
+ constexpr UInt<INT_SIZE> TEN_EXP_NINE_MANT(EXP10_9);
static const fputil::DyadicFloat<INT_SIZE> TEN_EXP_NINE(false, 0,
TEN_EXP_NINE_MANT);
@@ -356,7 +356,7 @@ LIBC_INLINE cpp::UInt<MID_INT_SIZE> get_table_negative_df(int exponent,
}
num = mul_pow_2(num, shift_amount);
- cpp::UInt<INT_SIZE> int_num = static_cast<cpp::UInt<INT_SIZE>>(num);
+ UInt<INT_SIZE> int_num = static_cast<UInt<INT_SIZE>>(num);
if (int_num > MOD_SIZE) {
auto rem =
int_num
@@ -366,16 +366,16 @@ LIBC_INLINE cpp::UInt<MID_INT_SIZE> get_table_negative_df(int exponent,
int_num = rem;
}
- cpp::UInt<MID_INT_SIZE> result = int_num;
+ UInt<MID_INT_SIZE> result = int_num;
return result;
}
-LIBC_INLINE uint32_t fast_uint_mod_1e9(const cpp::UInt<MID_INT_SIZE> &val) {
+LIBC_INLINE uint32_t fast_uint_mod_1e9(const UInt<MID_INT_SIZE> &val) {
// The formula for mult_const is:
// 1 + floor((2^(bits in target integer size + log_2(divider))) / divider)
// Where divider is 10^9 and target integer size is 128.
- const cpp::UInt<MID_INT_SIZE> mult_const(
+ const UInt<MID_INT_SIZE> mult_const(
{0x31680A88F8953031u, 0x89705F4136B4A597u, 0});
const auto middle = (mult_const * val);
const uint64_t result = static_cast<uint64_t>(middle[2]);
@@ -385,9 +385,9 @@ LIBC_INLINE uint32_t fast_uint_mod_1e9(const cpp::UInt<MID_INT_SIZE> &val) {
}
LIBC_INLINE uint32_t mul_shift_mod_1e9(const FPBits::StorageType mantissa,
- const cpp::UInt<MID_INT_SIZE> &large,
+ const UInt<MID_INT_SIZE> &large,
const int32_t shift_amount) {
- cpp::UInt<MID_INT_SIZE + FPBits::STORAGE_LEN> val(large);
+ UInt<MID_INT_SIZE + FPBits::STORAGE_LEN> val(large);
val = (val * mantissa) >> shift_amount;
return static_cast<uint32_t>(
val.div_uint_half_times_pow_2(static_cast<uint32_t>(EXP10_9), 0).value());
@@ -452,7 +452,7 @@ class FloatToString {
const uint32_t pos_exp = idx * IDX_SIZE;
- cpp::UInt<MID_INT_SIZE> val;
+ UInt<MID_INT_SIZE> val;
#if defined(LIBC_COPT_FLOAT_TO_STR_USE_DYADIC_FLOAT)
// ----------------------- DYADIC FLOAT CALC MODE ------------------------
@@ -502,7 +502,7 @@ class FloatToString {
if (exponent < 0) {
const int32_t idx = -exponent / IDX_SIZE;
- cpp::UInt<MID_INT_SIZE> val;
+ UInt<MID_INT_SIZE> val;
const uint32_t pos_exp = static_cast<uint32_t>(idx * IDX_SIZE);
@@ -643,7 +643,7 @@ template <> class FloatToString<long double> {
internal::div_ceil(sizeof(long double) * CHAR_BIT, UINT_WORD_SIZE) *
UINT_WORD_SIZE;
- using wide_int = cpp::UInt<FLOAT_AS_INT_WIDTH + EXTRA_INT_WIDTH>;
+ using wide_int = UInt<FLOAT_AS_INT_WIDTH + EXTRA_INT_WIDTH>;
// float_as_fixed represents the floating point number as a fixed point number
// with the point EXTRA_INT_WIDTH bits from the left of the number. This can
@@ -658,7 +658,7 @@ template <> class FloatToString<long double> {
size_t block_buffer_valid = 0;
template <size_t Bits>
- LIBC_INLINE static constexpr BlockInt grab_digits(cpp::UInt<Bits> &int_num) {
+ LIBC_INLINE static constexpr BlockInt grab_digits(UInt<Bits> &int_num) {
auto wide_result = int_num.div_uint_half_times_pow_2(EXP5_9, 9);
// the optional only comes into effect when dividing by 0, which will
// never happen here. Thus, we just assert that it has value.
@@ -714,7 +714,7 @@ template <> cl...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/84445
More information about the libc-commits
mailing list