From aa4c0f97839550347fdc9db47888b931e3d9cccf Mon Sep 17 00:00:00 2001 From: Michael Jones Date: Wed, 13 Dec 2023 17:03:50 -0800 Subject: [PATCH 01/12] [libc] Move printf long double to simple calc The Ryu algorithm is very fast with its table, but that table grows too large for long doubles. This patch adds a method of calculating the digits of long doubles using just wide integers and fast modulo operations. This results in significant performance improvements vs the previous int calc mode, while taking up a similar amound of peak memory. It will be slow in some %e/%g cases, but reasonable fast for %f with no loss of accuracy. --- libc/src/__support/UInt.h | 2 + libc/src/__support/float_to_string.h | 230 ++++++++++++++++++++++++--- libc/test/src/stdio/sprintf_test.cpp | 31 ++++ 3 files changed, 237 insertions(+), 26 deletions(-) diff --git a/libc/src/__support/UInt.h b/libc/src/__support/UInt.h index 947b23588fcdf..537c19df73f68 100644 --- a/libc/src/__support/UInt.h +++ b/libc/src/__support/UInt.h @@ -448,6 +448,8 @@ template struct BigInt { // pos is the index of the current 64-bit chunk that we are processing. size_t pos = WORDCOUNT; + // TODO: look into if constexpr(Bits > 256) skip leading zeroes. + for (size_t q_pos = WORDCOUNT - lower_pos; q_pos > 0; --q_pos) { // q_pos is 1 + the index of the current 64-bit chunk of the quotient // being processed. diff --git a/libc/src/__support/float_to_string.h b/libc/src/__support/float_to_string.h index ab1afbe54dfac..8f8d60874775b 100644 --- a/libc/src/__support/float_to_string.h +++ b/libc/src/__support/float_to_string.h @@ -17,6 +17,7 @@ #include "src/__support/UInt.h" #include "src/__support/common.h" #include "src/__support/libc_assert.h" +#include "src/__support/macros/attributes.h" // This file has 5 compile-time flags to allow the user to configure the float // to string behavior. These allow the user to select which 2 of the 3 useful @@ -64,6 +65,8 @@ // long doubles are rarely used and the normal Ryu Printf table is very fast // for doubles. +#undef LIBC_COPT_FLOAT_TO_STR_USE_MEGA_LONG_DOUBLE_TABLE + #ifdef LIBC_COPT_FLOAT_TO_STR_USE_MEGA_LONG_DOUBLE_TABLE #include "src/__support/ryu_long_double_constants.h" #elif !defined(LIBC_COPT_FLOAT_TO_STR_NO_TABLE) @@ -603,36 +606,208 @@ class FloatToString { #ifndef LIBC_LONG_DOUBLE_IS_FLOAT64 // --------------------------- LONG DOUBLE FUNCTIONS --------------------------- -template <> -LIBC_INLINE constexpr size_t FloatToString::get_positive_blocks() { - if (exponent >= -FRACTION_LEN) { - const uint32_t idx = - exponent < 0 - ? 0 - : static_cast(exponent + (IDX_SIZE - 1)) / IDX_SIZE; - const uint32_t len = internal::length_for_num(idx * IDX_SIZE, FRACTION_LEN); - return len; - } else { - return 0; +template <> class FloatToString { + fputil::FPBits float_bits; + bool is_negative = 0; + int exponent = 0; + FloatProp::StorageType mantissa = 0; + + static constexpr int FRACTION_LEN = fputil::FPBits::FRACTION_LEN; + static constexpr int EXP_BIAS = fputil::FPBits::EXP_BIAS; + + static constexpr size_t FLOAT_AS_INT_WIDTH = 16384; + static constexpr size_t EXTRA_INT_WIDTH = 128; + + cpp::BigInt float_as_int = 0; + int int_block_index = 0; + + static constexpr size_t BLOCK_BUFFER_LEN = 560; + BlockInt block_buffer[BLOCK_BUFFER_LEN] = {0}; + size_t block_buffer_valid = 0; + + template + LIBC_INLINE static constexpr BlockInt + grab_digits(cpp::BigInt &int_num) { + BlockInt cur_block = 0; + auto wide_result = int_num.div_uint32_times_pow_2(1953125, 9); + // the optional only comes into effect when dividing by 0, which will + // never happen here. Thus, we just assert that it has value. + LIBC_ASSERT(wide_result.has_value()); + cur_block = static_cast(wide_result.value()); + return cur_block; } -} -template <> -LIBC_INLINE constexpr size_t -FloatToString::zero_blocks_after_point() { + LIBC_INLINE static constexpr void zero_leading_digits( + cpp::BigInt &int_num) { + // 64 is the width of the numbers used to internally represent the BigInt + for (size_t i = 0; i < EXTRA_INT_WIDTH / 64; ++i) { + int_num[i + (FLOAT_AS_INT_WIDTH / 64)] = 0; + } + } + + LIBC_INLINE constexpr void init_convert() { + // This initializes float_as_int, cur_block, and block_buffer. + + float_as_int = mantissa; + + // No calculation necessary for the 0 case. + if (mantissa == 0 && exponent == 0) { + return; + } + + if (exponent > 0) { + // if the exponent is positive, then the number is fully above the decimal + // point. Shift left by exponent to get the integer representation of this + // number. + float_as_int.shift_left(exponent); + int_block_index = 0; + + while (float_as_int > 0) { + BlockInt cur_block = grab_digits(float_as_int); + block_buffer[int_block_index] = cur_block; + ++int_block_index; + } + block_buffer_valid = int_block_index; + + } else { + // if the exponent not positive, then the number is at least partially + // below the decimal point. Shift left to make the int a fixed point + // representation with the decimal point after the top EXTRA_INT_WIDTH + // bits. + const int SHIFT_AMOUNT = FLOAT_AS_INT_WIDTH + exponent; + static_assert(EXTRA_INT_WIDTH >= sizeof(long double) * 8); + float_as_int.shift_left(SHIFT_AMOUNT); + + // If there are still digits above the decimal point, handle those. + if (float_as_int.clz() < EXTRA_INT_WIDTH) { + cpp::BigInt above_decimal_point = + float_as_int >> FLOAT_AS_INT_WIDTH; + + size_t positive_int_block_index = 0; + while (above_decimal_point > 0) { + BlockInt cur_block = grab_digits(above_decimal_point); + block_buffer[positive_int_block_index] = cur_block; + ++positive_int_block_index; + } + block_buffer_valid = positive_int_block_index; + + // Zero all digits above the decimal point. + zero_leading_digits(float_as_int); + int_block_index = 0; + } + } + } + +public: + LIBC_INLINE constexpr FloatToString(long double init_float) + : float_bits(init_float) { + is_negative = float_bits.get_sign(); + exponent = float_bits.get_explicit_exponent(); + mantissa = float_bits.get_explicit_mantissa(); + + // Adjust for the width of the mantissa. + exponent -= FRACTION_LEN; + + this->init_convert(); + } + + LIBC_INLINE constexpr size_t get_positive_blocks() { + if (exponent >= -FRACTION_LEN) { + const uint32_t idx = + exponent < 0 + ? 0 + : static_cast(exponent + (IDX_SIZE - 1)) / IDX_SIZE; + const uint32_t len = internal::length_for_num(idx * IDX_SIZE, FRACTION_LEN); + return len; + } else { + return 0; + } + } + + LIBC_INLINE constexpr size_t zero_blocks_after_point() { #ifdef LIBC_COPT_FLOAT_TO_STR_USE_MEGA_LONG_DOUBLE_TABLE - return MIN_BLOCK_2[-exponent / IDX_SIZE]; + return MIN_BLOCK_2[-exponent / IDX_SIZE]; #else - return 0; - // TODO (michaelrj): Find a good algorithm for this that doesn't use a table. + if (exponent < -FRACTION_LEN) { + const int pos_exp = -exponent - 1; + const uint32_t pos_idx = + static_cast(pos_exp + (IDX_SIZE - 1)) / IDX_SIZE; + const int32_t pos_len = ((internal::ceil_log10_pow2(pos_idx * IDX_SIZE) - + internal::ceil_log10_pow2(FRACTION_LEN + 1)) / + BLOCK_SIZE) - + 1; + const uint32_t len = static_cast(pos_len > 0 ? pos_len : 0); + return len; + } + return 0; + #endif -} + } -template <> -LIBC_INLINE constexpr bool FloatToString::is_lowest_block(size_t) { - return false; -} + LIBC_INLINE constexpr bool is_lowest_block(size_t negative_block_index) { + // The decimal representation of 2**(-i) will have exactly i digits after + // the decimal point. + int num_requested_digits = + static_cast((negative_block_index + 1) * BLOCK_SIZE); + + return num_requested_digits > -exponent; + } + + LIBC_INLINE constexpr BlockInt get_positive_block(int block_index) { + if (exponent < -FRACTION_LEN) { + return 0; + } + if (block_index > static_cast(block_buffer_valid) || block_index < 0) { + return 0; + } + + return block_buffer[block_index]; + } + + LIBC_INLINE constexpr BlockInt get_negative_block(int negative_block_index) { + if (exponent >= 0) { + return 0; + } + + // negative_block_index starts at 0 with the first block after the decimal + // point, and 1 with the second and so on. This converts to the same + // block_index used everywhere else. + + int block_index = -1 - negative_block_index; + + // If we're currently after the requested block (remember these are + // negative indices) the reset the number to the start. This is only + // likely to happen in %g calls. This will also reset int_block_index. + if (block_index > int_block_index) { + init_convert(); + } + + // LIBC_ASSERT(block_index >= int_block_index); + + // If we are currently before the requested block. Step until we reach the + // requested block. This is likely to only be one step. + while (block_index < int_block_index) { + zero_leading_digits(float_as_int); + float_as_int.mul(1000000000); + --int_block_index; + } + + // We're currently on the requested block, return the current block. + BlockInt cur_block = + static_cast(float_as_int >> FLOAT_AS_INT_WIDTH); + return cur_block; + } + LIBC_INLINE constexpr BlockInt get_block(int block_index) { + if (block_index >= 0) { + return get_positive_block(block_index); + } else { + return get_negative_block(-1 - block_index); + } + } +}; + +/* template <> LIBC_INLINE constexpr BlockInt FloatToString::get_positive_block(int block_index) { @@ -725,8 +900,11 @@ FloatToString::get_negative_block(int block_index) { // ----------------------------- INT CALC MODE ----------------------------- const int32_t SHIFT_CONST = CALC_SHIFT_CONST; - const uint64_t TEN_BLOCKS = (block_index + 1) * BLOCK_SIZE; - const uint64_t MAX_INT_SIZE = internal::log2_pow5(TEN_BLOCKS); + const uint64_t NUM_FIVES = (block_index + 1) * BLOCK_SIZE; + // Round MAX_INT_SIZE up to the nearest 64 (adding 1 because log2_pow5 + // implicitly rounds down). + const uint64_t MAX_INT_SIZE = + ((internal::log2_pow5(NUM_FIVES) / 64) + 1) * 64; if (MAX_INT_SIZE < 1024) { val = internal::get_table_negative<1024>(idx * IDX_SIZE, block_index + 1); @@ -752,7 +930,7 @@ FloatToString::get_negative_block(int block_index) { return 0; } } - +*/ #endif // LIBC_LONG_DOUBLE_IS_FLOAT64 } // namespace LIBC_NAMESPACE diff --git a/libc/test/src/stdio/sprintf_test.cpp b/libc/test/src/stdio/sprintf_test.cpp index b22378b22ab12..315f9b5ec2d04 100644 --- a/libc/test/src/stdio/sprintf_test.cpp +++ b/libc/test/src/stdio/sprintf_test.cpp @@ -1056,6 +1056,37 @@ TEST_F(LlvmLibcSPrintfTest, FloatDecimalConv) { "99999999999999999996693535322073426194986990198284960792713" "91541752018669482644324418977840117055488.000000"); + written = LIBC_NAMESPACE::sprintf(buff, "%Lf", 0xd.96ed1192687859ap-24L); + ASSERT_STREQ_LEN(written, buff, "0.000001"); + + written = LIBC_NAMESPACE::sprintf(buff, "%Lf", 10000000000000000.25L); + ASSERT_STREQ_LEN(written, buff, "10000000000000000.250000"); + + written = LIBC_NAMESPACE::sprintf(buff, "%.510Lf", 0x8p-503L); + ASSERT_STREQ_LEN( + written, buff, + "0." + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000305493636349960468205197939321361769978940274057232666389361390928" + "129162652472045770185723510801522825687515269359046715531785342780428396" + "973513311420091788963072442053377285222203558881953188370081650866793017" + "948791366338993705251636497892270212003524508209121908744820211960149463" + "721109340307985507678283651836204093399373959982767701148986816406250000" + "000000"); + + written = LIBC_NAMESPACE::sprintf(buff, "%.500Lf", -4327677766926336.0L); + ASSERT_STREQ_LEN( + written, buff, + "-4327677766926336." + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000"); + written = LIBC_NAMESPACE::sprintf(big_buff, "%Lf", 1e1000L); ASSERT_STREQ_LEN( written, big_buff, From 72fb569f3497ee4d01d728b5170154c18f47ee8d Mon Sep 17 00:00:00 2001 From: Michael Jones Date: Mon, 18 Dec 2023 16:34:07 -0800 Subject: [PATCH 02/12] cleanup, adjust docs, update build systems --- libc/config/config.json | 2 +- libc/docs/dev/printf_behavior.rst | 20 +- libc/src/__support/float_to_string.h | 274 ++++++------------ .../llvm-project-overlay/libc/BUILD.bazel | 2 - 4 files changed, 107 insertions(+), 191 deletions(-) diff --git a/libc/config/config.json b/libc/config/config.json index 77d10d75f3646..6a208cc556611 100644 --- a/libc/config/config.json +++ b/libc/config/config.json @@ -13,7 +13,7 @@ "doc": "Disable handling of %n in printf format string." }, "LIBC_CONF_PRINTF_FLOAT_TO_STR_USE_MEGA_LONG_DOUBLE_TABLE": { - "value": true, + "value": false, "doc": "Use large table for better printf long double performance." } }, diff --git a/libc/docs/dev/printf_behavior.rst b/libc/docs/dev/printf_behavior.rst index 29b1b17ebaecb..52252c61b0254 100644 --- a/libc/docs/dev/printf_behavior.rst +++ b/libc/docs/dev/printf_behavior.rst @@ -87,14 +87,25 @@ are not recommended to be adjusted except by persons familiar with the Printf Ryu Algorithm. Additionally they have no effect when float conversions are disabled. +LIBC_COPT_FLOAT_TO_STR_NO_SPECIALIZE_LD +--------------------------------------- +This flag disables the separate long double conversion implementation. It is +not based on the Ryu algorithm, instead generating the digits by +multiplying/dividing the written-out number by 10^9 to get blocks. It's +significantly faster than INT_CALC, only about 10x slower than MEGA_TABLE, +and is small in binary size. Its downside is that it always calculates all +of the digits above the decimal point, making it slightly ineffecient for %e +calls with large exponents. This is the default. If this flag is not set, no +other flags will change the long double behavior. + LIBC_COPT_FLOAT_TO_STR_USE_MEGA_LONG_DOUBLE_TABLE ------------------------------------------------- When set, the float to string decimal conversion algorithm will use a larger table to accelerate long double conversions. This larger table is around 5MB of -size when compiled. This flag is enabled by default in the CMake. +size when compiled. -LIBC_COPT_FLOAT_TO_STR_USE_DYADIC_FLOAT(_LD) --------------------------------------------- +LIBC_COPT_FLOAT_TO_STR_USE_DYADIC_FLOAT +--------------------------------------- When set, the float to string decimal conversion algorithm will use dyadic floats instead of a table when performing floating point conversions. This results in ~50 digits of accuracy in the result, then zeroes for the remaining @@ -107,8 +118,7 @@ LIBC_COPT_FLOAT_TO_STR_USE_INT_CALC When set, the float to string decimal conversion algorithm will use wide integers instead of a table when performing floating point conversions. This gives the same results as the table, but is very slow at the extreme ends of -the long double range. If no flags are set this is the default behavior for -long double conversions. +the long double range. LIBC_COPT_FLOAT_TO_STR_NO_TABLE ------------------------------- diff --git a/libc/src/__support/float_to_string.h b/libc/src/__support/float_to_string.h index 8f8d60874775b..272b184094232 100644 --- a/libc/src/__support/float_to_string.h +++ b/libc/src/__support/float_to_string.h @@ -13,6 +13,7 @@ #include "src/__support/CPP/type_traits.h" #include "src/__support/FPUtil/FPBits.h" +#include "src/__support/FPUtil/FloatProperties.h" #include "src/__support/FPUtil/dyadic_float.h" #include "src/__support/UInt.h" #include "src/__support/common.h" @@ -20,12 +21,19 @@ #include "src/__support/macros/attributes.h" // This file has 5 compile-time flags to allow the user to configure the float -// to string behavior. These allow the user to select which 2 of the 3 useful -// properties they want. The useful properties are: -// 1) Speed of Evaluation -// 2) Small Size of Binary -// 3) Centered Output Value -// These are explained below with the flags that are missing each one. +// to string behavior. These were used to explore tradeoffs during the design +// phase, and can still be used to gain specific properties. Unless you +// specifically know what you're doing, you should leave all these flags off. + +// LIBC_COPT_FLOAT_TO_STR_NO_SPECIALIZE_LD +// This flag disables the separate long double conversion implementation. It is +// not based on the Ryu algorithm, instead generating the digits by +// multiplying/dividing the written-out number by 10^9 to get blocks. It's +// significantly faster than INT_CALC, only about 10x slower than MEGA_TABLE, +// and is small in binary size. Its downside is that it always calculates all +// of the digits above the decimal point, making it ineffecient for %e calls +// with large exponents. If this flag is not set, no other flags will change +// the long double behavior. // LIBC_COPT_FLOAT_TO_STR_USE_MEGA_LONG_DOUBLE_TABLE // The Mega Table is ~5 megabytes when compiled. It lists the constants needed @@ -34,16 +42,13 @@ // exchange for large binary size. // LIBC_COPT_FLOAT_TO_STR_USE_DYADIC_FLOAT -// LIBC_COPT_FLOAT_TO_STR_USE_DYADIC_FLOAT_LD // Dyadic floats are software floating point numbers, and their accuracy can be // as high as necessary. This option uses 256 bit dyadic floats to calculate // the table values that Ryu Printf needs. This is reasonably fast and very // small compared to the Mega Table, but the 256 bit floats only give accurate // results for the first ~50 digits of the output. In practice this shouldn't // be a problem since long doubles are only accurate for ~35 digits, but the -// trailing values all being 0s may cause brittle tests to fail. The _LD -// version of this flag only effects the long double calculations, and the -// other version effects both long double and double. +// trailing values all being 0s may cause brittle tests to fail. // LIBC_COPT_FLOAT_TO_STR_USE_INT_CALC // Integer Calculation uses wide integers to do the calculations for the Ryu @@ -61,11 +66,8 @@ // Default Config: // If no flags are set, doubles use the normal (and much more reasonably sized) -// Ryu Printf table and long doubles use Integer Calculation. This is because -// long doubles are rarely used and the normal Ryu Printf table is very fast -// for doubles. - -#undef LIBC_COPT_FLOAT_TO_STR_USE_MEGA_LONG_DOUBLE_TABLE +// Ryu Printf table and long doubles use their specialized implementation. This +// provides good performance and binary size. #ifdef LIBC_COPT_FLOAT_TO_STR_USE_MEGA_LONG_DOUBLE_TABLE #include "src/__support/ryu_long_double_constants.h" @@ -155,15 +157,17 @@ LIBC_INLINE constexpr uint32_t ceil_log10_pow2(const uint32_t e) { return log10_pow2(e) + 1; } +LIBC_INLINE constexpr uint32_t div_ceil(const uint32_t num, + const uint32_t denom) { + return (num + (denom - 1)) / denom; +} + // Returns the maximum number of 9 digit blocks a number described by the given // index (which is ceil(exponent/16)) and mantissa width could need. LIBC_INLINE constexpr uint32_t length_for_num(const uint32_t idx, const uint32_t mantissa_width) { - //+8 to round up when dividing by 9 - return (ceil_log10_pow2(idx) + ceil_log10_pow2(mantissa_width + 1) + - (BLOCK_SIZE - 1)) / - BLOCK_SIZE; - // return (ceil_log10_pow2(16 * idx + mantissa_width) + 8) / 9; + return div_ceil(ceil_log10_pow2(idx) + ceil_log10_pow2(mantissa_width + 1), + BLOCK_SIZE); } // The formula for the table when i is positive (or zero) is as follows: @@ -451,6 +455,8 @@ class FloatToString { // shift_amount = -(c0 - exponent) = c_0 + 16 * ceil(exponent/16) - // exponent + const uint32_t pos_exp = idx * IDX_SIZE; + cpp::UInt val; #if defined(LIBC_COPT_FLOAT_TO_STR_USE_DYADIC_FLOAT) @@ -461,24 +467,25 @@ class FloatToString { // ---------------------------- INT CALC MODE ---------------------------- const int32_t SHIFT_CONST = CALC_SHIFT_CONST; - const uint64_t MAX_POW_2_SIZE = - exponent + CALC_SHIFT_CONST - (BLOCK_SIZE * block_index); + pos_exp + CALC_SHIFT_CONST - (BLOCK_SIZE * block_index); const uint64_t MAX_POW_5_SIZE = internal::log2_pow5(BLOCK_SIZE * block_index); const uint64_t MAX_INT_SIZE = (MAX_POW_2_SIZE > MAX_POW_5_SIZE) ? MAX_POW_2_SIZE : MAX_POW_5_SIZE; if (MAX_INT_SIZE < 1024) { - val = internal::get_table_positive<1024>(IDX_SIZE * idx, block_index); + val = internal::get_table_positive<1024>(pos_exp, block_index); } else if (MAX_INT_SIZE < 2048) { - val = internal::get_table_positive<2048>(IDX_SIZE * idx, block_index); + val = internal::get_table_positive<2048>(pos_exp, block_index); } else if (MAX_INT_SIZE < 4096) { - val = internal::get_table_positive<4096>(IDX_SIZE * idx, block_index); + val = internal::get_table_positive<4096>(pos_exp, block_index); } else if (MAX_INT_SIZE < 8192) { - val = internal::get_table_positive<8192>(IDX_SIZE * idx, block_index); + val = internal::get_table_positive<8192>(pos_exp, block_index); + } else if (MAX_INT_SIZE < 16384) { + val = internal::get_table_positive<16384>(pos_exp, block_index); } else { - val = internal::get_table_positive<16384>(IDX_SIZE * idx, block_index); + val = internal::get_table_positive<16384 + 128>(pos_exp, block_index); } #else // ----------------------------- TABLE MODE ------------------------------ @@ -486,9 +493,9 @@ class FloatToString { val = POW10_SPLIT[POW10_OFFSET[idx] + block_index]; #endif - const uint32_t shift_amount = - SHIFT_CONST + (static_cast(IDX_SIZE) * idx) - exponent; - const uint32_t digits = + const uint32_t shift_amount = SHIFT_CONST + pos_exp - exponent; + + const BlockInt digits = internal::mul_shift_mod_1e9(mantissa, val, (int32_t)(shift_amount)); return digits; } else { @@ -502,35 +509,35 @@ class FloatToString { cpp::UInt val; + const uint32_t pos_exp = idx * IDX_SIZE; + #if defined(LIBC_COPT_FLOAT_TO_STR_USE_DYADIC_FLOAT) // ----------------------- DYADIC FLOAT CALC MODE ------------------------ const int32_t SHIFT_CONST = CALC_SHIFT_CONST; - val = - internal::get_table_negative_df<256>(idx * IDX_SIZE, block_index + 1); + val = internal::get_table_negative_df<256>(pos_exp, block_index + 1); #elif defined(LIBC_COPT_FLOAT_TO_STR_USE_INT_CALC) // ---------------------------- INT CALC MODE ---------------------------- const int32_t SHIFT_CONST = CALC_SHIFT_CONST; - const uint64_t TEN_BLOCKS = (block_index + 1) * BLOCK_SIZE; - const uint64_t MAX_INT_SIZE = internal::log2_pow5(TEN_BLOCKS); + + const uint64_t NUM_FIVES = (block_index + 1) * BLOCK_SIZE; + // Round MAX_INT_SIZE up to the nearest 64 (adding 1 because log2_pow5 + // implicitly rounds down). + const uint64_t MAX_INT_SIZE = + ((internal::log2_pow5(NUM_FIVES) / 64) + 1) * 64; if (MAX_INT_SIZE < 1024) { - val = - internal::get_table_negative<1024>(idx * IDX_SIZE, block_index + 1); + val = internal::get_table_negative<1024>(pos_exp, block_index + 1); } else if (MAX_INT_SIZE < 2048) { - val = - internal::get_table_negative<2048>(idx * IDX_SIZE, block_index + 1); + val = internal::get_table_negative<2048>(pos_exp, block_index + 1); } else if (MAX_INT_SIZE < 4096) { - val = - internal::get_table_negative<4096>(idx * IDX_SIZE, block_index + 1); + val = internal::get_table_negative<4096>(pos_exp, block_index + 1); } else if (MAX_INT_SIZE < 8192) { - val = - internal::get_table_negative<8192>(idx * IDX_SIZE, block_index + 1); + val = internal::get_table_negative<8192>(pos_exp, block_index + 1); } else if (MAX_INT_SIZE < 16384) { - val = internal::get_table_negative<16384>(idx * IDX_SIZE, - block_index + 1); + val = internal::get_table_negative<16384>(pos_exp, block_index + 1); } else { - val = internal::get_table_negative<32768>(idx * IDX_SIZE, - block_index + 1); + val = internal::get_table_negative<16384 + 8192>(pos_exp, + block_index + 1); } #else // ----------------------------- TABLE MODE ------------------------------ @@ -548,8 +555,8 @@ class FloatToString { val = POW10_SPLIT_2[p]; #endif const int32_t shift_amount = - SHIFT_CONST + (-exponent - (static_cast(IDX_SIZE) * idx)); - uint32_t digits = + SHIFT_CONST + (-exponent - static_cast(pos_exp)); + BlockInt digits = internal::mul_shift_mod_1e9(mantissa, val, shift_amount); return digits; } else { @@ -581,12 +588,18 @@ class FloatToString { // This takes the index of a block after the decimal point (a negative block) // and return if it's sure that all of the digits after it are zero. - LIBC_INLINE constexpr bool is_lowest_block(size_t block_index) { + LIBC_INLINE constexpr bool is_lowest_block(size_t negative_block_index) { #ifdef LIBC_COPT_FLOAT_TO_STR_NO_TABLE - return false; + // The decimal representation of 2**(-i) will have exactly i digits after + // the decimal point. + int num_requested_digits = + static_cast((negative_block_index + 1) * BLOCK_SIZE); + + return num_requested_digits > -exponent; #else const int32_t idx = -exponent / IDX_SIZE; - const size_t p = POW10_OFFSET_2[idx] + block_index - MIN_BLOCK_2[idx]; + const size_t p = + POW10_OFFSET_2[idx] + negative_block_index - MIN_BLOCK_2[idx]; // If the remaining digits are all 0, then this is the lowest block. return p >= POW10_OFFSET_2[idx + 1]; #endif @@ -594,16 +607,26 @@ class FloatToString { LIBC_INLINE constexpr size_t zero_blocks_after_point() { #ifdef LIBC_COPT_FLOAT_TO_STR_NO_TABLE + if (exponent < -MANT_WIDTH) { + const int pos_exp = -exponent - 1; + const uint32_t pos_idx = + static_cast(pos_exp + (IDX_SIZE - 1)) / IDX_SIZE; + const int32_t pos_len = ((internal::ceil_log10_pow2(pos_idx * IDX_SIZE) - + internal::ceil_log10_pow2(MANT_WIDTH + 1)) / + BLOCK_SIZE) - + 1; + const uint32_t len = static_cast(pos_len > 0 ? pos_len : 0); + return len; + } return 0; - // TODO (michaelrj): Find a good algorithm for this that doesn't use a - // table. #else return MIN_BLOCK_2[-exponent / IDX_SIZE]; #endif } }; -#ifndef LIBC_LONG_DOUBLE_IS_FLOAT64 +#if !defined(LIBC_LONG_DOUBLE_IS_FLOAT64) && \ + !defined(LIBC_COPT_FLOAT_TO_STR_NO_SPECIALIZE_LD) // --------------------------- LONG DOUBLE FUNCTIONS --------------------------- template <> class FloatToString { @@ -615,13 +638,21 @@ template <> class FloatToString { static constexpr int FRACTION_LEN = fputil::FPBits::FRACTION_LEN; static constexpr int EXP_BIAS = fputil::FPBits::EXP_BIAS; - static constexpr size_t FLOAT_AS_INT_WIDTH = 16384; - static constexpr size_t EXTRA_INT_WIDTH = 128; + // static constexpr size_t FLOAT_AS_INT_WIDTH = 16384; + static constexpr size_t FLOAT_AS_INT_WIDTH = + internal::div_ceil(fputil::FPBits::MAX_EXPONENT - + fputil::FPBits::EXPONENT_BIAS, + 64) * + 64; + // static constexpr size_t EXTRA_INT_WIDTH = 128; + static constexpr size_t EXTRA_INT_WIDTH = + internal::div_ceil(sizeof(long double) * 8, 64) * 64; cpp::BigInt float_as_int = 0; int int_block_index = 0; - static constexpr size_t BLOCK_BUFFER_LEN = 560; + static constexpr size_t BLOCK_BUFFER_LEN = + internal::div_ceil(internal::log10_pow2(FLOAT_AS_INT_WIDTH), BLOCK_SIZE); BlockInt block_buffer[BLOCK_BUFFER_LEN] = {0}; size_t block_buffer_valid = 0; @@ -782,7 +813,7 @@ template <> class FloatToString { init_convert(); } - // LIBC_ASSERT(block_index >= int_block_index); + LIBC_ASSERT(block_index <= int_block_index); // If we are currently before the requested block. Step until we reach the // requested block. This is likely to only be one step. @@ -807,131 +838,8 @@ template <> class FloatToString { } }; -/* -template <> -LIBC_INLINE constexpr BlockInt -FloatToString::get_positive_block(int block_index) { - if (exponent >= -FRACTION_LEN) { - - // idx is ceil(exponent/16) or 0 if exponent is negative. This is used to - // find the coarse section of the POW10_SPLIT table that will be used to - // calculate the 9 digit window, as well as some other related values. - const uint32_t idx = - exponent < 0 - ? 0 - : static_cast(exponent + (IDX_SIZE - 1)) / IDX_SIZE; - const uint32_t pos_exp = idx * IDX_SIZE; - - // shift_amount = -(c0 - exponent) = c_0 + 16 * ceil(exponent/16) - exponent - - cpp::UInt val; -#ifdef LIBC_COPT_FLOAT_TO_STR_USE_MEGA_LONG_DOUBLE_TABLE - // ------------------------------ TABLE MODE ------------------------------- - const int32_t SHIFT_CONST = TABLE_SHIFT_CONST; - val = POW10_SPLIT[POW10_OFFSET[idx] + block_index]; - -#elif defined(LIBC_COPT_FLOAT_TO_STR_USE_DYADIC_FLOAT) || \ - defined(LIBC_COPT_FLOAT_TO_STR_USE_DYADIC_FLOAT_LD) - // ------------------------ DYADIC FLOAT CALC MODE ------------------------- - const int32_t SHIFT_CONST = CALC_SHIFT_CONST; - val = internal::get_table_positive_df<256>(pos_exp, block_index); -#else - // ----------------------------- INT CALC MODE ----------------------------- - const int32_t SHIFT_CONST = CALC_SHIFT_CONST; - const uint64_t MAX_POW_2_SIZE = - pos_exp + CALC_SHIFT_CONST - (BLOCK_SIZE * block_index); - const uint64_t MAX_POW_5_SIZE = - internal::log2_pow5(BLOCK_SIZE * block_index); - const uint64_t MAX_INT_SIZE = - (MAX_POW_2_SIZE > MAX_POW_5_SIZE) ? MAX_POW_2_SIZE : MAX_POW_5_SIZE; - - if (MAX_INT_SIZE < 1024) { - val = internal::get_table_positive<1024>(pos_exp, block_index); - } else if (MAX_INT_SIZE < 2048) { - val = internal::get_table_positive<2048>(pos_exp, block_index); - } else if (MAX_INT_SIZE < 4096) { - val = internal::get_table_positive<4096>(pos_exp, block_index); - } else if (MAX_INT_SIZE < 8192) { - val = internal::get_table_positive<8192>(pos_exp, block_index); - } else if (MAX_INT_SIZE < 16384) { - val = internal::get_table_positive<16384>(pos_exp, block_index); - } else { - val = internal::get_table_positive<16384 + 128>(pos_exp, block_index); - } -#endif - const uint32_t shift_amount = SHIFT_CONST + pos_exp - exponent; - - const BlockInt digits = - internal::mul_shift_mod_1e9(mantissa, val, (int32_t)(shift_amount)); - return digits; - } else { - return 0; - } -} - -template <> -LIBC_INLINE constexpr BlockInt -FloatToString::get_negative_block(int block_index) { - if (exponent < 0) { - const int32_t idx = -exponent / IDX_SIZE; - - cpp::UInt val; -#ifdef LIBC_COPT_FLOAT_TO_STR_USE_MEGA_LONG_DOUBLE_TABLE - // ------------------------------ TABLE MODE ------------------------------- - const int32_t SHIFT_CONST = TABLE_SHIFT_CONST; - - // if the requested block is zero - if (block_index < MIN_BLOCK_2[idx]) { - return 0; - } - const uint32_t p = POW10_OFFSET_2[idx] + block_index - MIN_BLOCK_2[idx]; - // If every digit after the requested block is zero. - if (p >= POW10_OFFSET_2[idx + 1]) { - return 0; - } - val = POW10_SPLIT_2[p]; -#elif defined(LIBC_COPT_FLOAT_TO_STR_USE_DYADIC_FLOAT) || \ - defined(LIBC_COPT_FLOAT_TO_STR_USE_DYADIC_FLOAT_LD) - // ------------------------ DYADIC FLOAT CALC MODE ------------------------- - const int32_t SHIFT_CONST = CALC_SHIFT_CONST; - - val = internal::get_table_negative_df<256>(idx * IDX_SIZE, block_index + 1); -#else // table mode - // ----------------------------- INT CALC MODE ----------------------------- - const int32_t SHIFT_CONST = CALC_SHIFT_CONST; - - const uint64_t NUM_FIVES = (block_index + 1) * BLOCK_SIZE; - // Round MAX_INT_SIZE up to the nearest 64 (adding 1 because log2_pow5 - // implicitly rounds down). - const uint64_t MAX_INT_SIZE = - ((internal::log2_pow5(NUM_FIVES) / 64) + 1) * 64; - - if (MAX_INT_SIZE < 1024) { - val = internal::get_table_negative<1024>(idx * IDX_SIZE, block_index + 1); - } else if (MAX_INT_SIZE < 2048) { - val = internal::get_table_negative<2048>(idx * IDX_SIZE, block_index + 1); - } else if (MAX_INT_SIZE < 4096) { - val = internal::get_table_negative<4096>(idx * IDX_SIZE, block_index + 1); - } else if (MAX_INT_SIZE < 8192) { - val = internal::get_table_negative<8192>(idx * IDX_SIZE, block_index + 1); - } else if (MAX_INT_SIZE < 16384) { - val = - internal::get_table_negative<16384>(idx * IDX_SIZE, block_index + 1); - } else { - val = internal::get_table_negative<16384 + 8192>(idx * IDX_SIZE, - block_index + 1); - } -#endif - const int32_t shift_amount = - SHIFT_CONST + (-exponent - static_cast(IDX_SIZE * idx)); - BlockInt digits = internal::mul_shift_mod_1e9(mantissa, val, shift_amount); - return digits; - } else { - return 0; - } -} -*/ -#endif // LIBC_LONG_DOUBLE_IS_FLOAT64 +#endif // !LIBC_LONG_DOUBLE_IS_FLOAT64 && + // !LIBC_COPT_FLOAT_TO_STR_NO_SPECIALIZE_LD } // namespace LIBC_NAMESPACE diff --git a/utils/bazel/llvm-project-overlay/libc/BUILD.bazel b/utils/bazel/llvm-project-overlay/libc/BUILD.bazel index 6fa47c0090b87..0b95494248ccb 100644 --- a/utils/bazel/llvm-project-overlay/libc/BUILD.bazel +++ b/utils/bazel/llvm-project-overlay/libc/BUILD.bazel @@ -25,7 +25,6 @@ licenses(["notice"]) PRINTF_COPTS = [ "LIBC_COPT_STDIO_USE_SYSTEM_FILE", - "LIBC_COPT_PRINTF_DISABLE_INDEX_MODE", "LIBC_COPT_PRINTF_DISABLE_WRITE_INT", ] @@ -416,7 +415,6 @@ libc_support_library( "src/__support/ryu_constants.h", "src/__support/ryu_long_double_constants.h", ], - defines = ["LIBC_COPT_FLOAT_TO_STR_USE_MEGA_LONG_DOUBLE_TABLE"], deps = [ ":__support_common", ":__support_cpp_type_traits", From 635931bc529578709e9ce05d81f8308b7cc06291 Mon Sep 17 00:00:00 2001 From: Michael Jones Date: Wed, 20 Dec 2023 13:00:20 -0800 Subject: [PATCH 03/12] Finish rebase --- libc/src/__support/float_to_string.h | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/libc/src/__support/float_to_string.h b/libc/src/__support/float_to_string.h index 272b184094232..d5c01cfd67652 100644 --- a/libc/src/__support/float_to_string.h +++ b/libc/src/__support/float_to_string.h @@ -640,8 +640,8 @@ template <> class FloatToString { // static constexpr size_t FLOAT_AS_INT_WIDTH = 16384; static constexpr size_t FLOAT_AS_INT_WIDTH = - internal::div_ceil(fputil::FPBits::MAX_EXPONENT - - fputil::FPBits::EXPONENT_BIAS, + internal::div_ceil(fputil::FPBits::MAX_BIASED_EXPONENT - + FloatProp::EXP_BIAS, 64) * 64; // static constexpr size_t EXTRA_INT_WIDTH = 128; @@ -748,7 +748,8 @@ template <> class FloatToString { exponent < 0 ? 0 : static_cast(exponent + (IDX_SIZE - 1)) / IDX_SIZE; - const uint32_t len = internal::length_for_num(idx * IDX_SIZE, FRACTION_LEN); + const uint32_t len = + internal::length_for_num(idx * IDX_SIZE, FRACTION_LEN); return len; } else { return 0; From d627e4158cef3be5f8fd9765454459185788d651 Mon Sep 17 00:00:00 2001 From: Michael Jones Date: Thu, 21 Dec 2023 13:28:20 -0800 Subject: [PATCH 04/12] address simple comments --- libc/docs/dev/printf_behavior.rst | 7 +- libc/src/__support/float_to_string.h | 27 +- libc/test/src/stdio/sprintf_test.cpp | 1584 +++++++++++++------------- 3 files changed, 816 insertions(+), 802 deletions(-) diff --git a/libc/docs/dev/printf_behavior.rst b/libc/docs/dev/printf_behavior.rst index 52252c61b0254..ef81fd63c8f30 100644 --- a/libc/docs/dev/printf_behavior.rst +++ b/libc/docs/dev/printf_behavior.rst @@ -94,9 +94,10 @@ not based on the Ryu algorithm, instead generating the digits by multiplying/dividing the written-out number by 10^9 to get blocks. It's significantly faster than INT_CALC, only about 10x slower than MEGA_TABLE, and is small in binary size. Its downside is that it always calculates all -of the digits above the decimal point, making it slightly ineffecient for %e -calls with large exponents. This is the default. If this flag is not set, no -other flags will change the long double behavior. +of the digits above the decimal point, making it slightly inefficient for %e +calls with large exponents. This is the default. This specialization overrides +other flags, so this flag must be set for other flags to effect the long double +behavior. LIBC_COPT_FLOAT_TO_STR_USE_MEGA_LONG_DOUBLE_TABLE ------------------------------------------------- diff --git a/libc/src/__support/float_to_string.h b/libc/src/__support/float_to_string.h index d5c01cfd67652..75cf53dbb1295 100644 --- a/libc/src/__support/float_to_string.h +++ b/libc/src/__support/float_to_string.h @@ -31,9 +31,9 @@ // multiplying/dividing the written-out number by 10^9 to get blocks. It's // significantly faster than INT_CALC, only about 10x slower than MEGA_TABLE, // and is small in binary size. Its downside is that it always calculates all -// of the digits above the decimal point, making it ineffecient for %e calls -// with large exponents. If this flag is not set, no other flags will change -// the long double behavior. +// of the digits above the decimal point, making it inefficient for %e calls +// with large exponents. This specialization overrides other flags, so this +// flag must be set for other flags to effect the long double behavior. // LIBC_COPT_FLOAT_TO_STR_USE_MEGA_LONG_DOUBLE_TABLE // The Mega Table is ~5 megabytes when compiled. It lists the constants needed @@ -607,12 +607,12 @@ class FloatToString { LIBC_INLINE constexpr size_t zero_blocks_after_point() { #ifdef LIBC_COPT_FLOAT_TO_STR_NO_TABLE - if (exponent < -MANT_WIDTH) { + if (exponent < -FRACTION_LEN) { const int pos_exp = -exponent - 1; const uint32_t pos_idx = static_cast(pos_exp + (IDX_SIZE - 1)) / IDX_SIZE; const int32_t pos_len = ((internal::ceil_log10_pow2(pos_idx * IDX_SIZE) - - internal::ceil_log10_pow2(MANT_WIDTH + 1)) / + internal::ceil_log10_pow2(FRACTION_LEN + 1)) / BLOCK_SIZE) - 1; const uint32_t len = static_cast(pos_len > 0 ? pos_len : 0); @@ -638,17 +638,15 @@ template <> class FloatToString { static constexpr int FRACTION_LEN = fputil::FPBits::FRACTION_LEN; static constexpr int EXP_BIAS = fputil::FPBits::EXP_BIAS; - // static constexpr size_t FLOAT_AS_INT_WIDTH = 16384; static constexpr size_t FLOAT_AS_INT_WIDTH = internal::div_ceil(fputil::FPBits::MAX_BIASED_EXPONENT - FloatProp::EXP_BIAS, 64) * 64; - // static constexpr size_t EXTRA_INT_WIDTH = 128; static constexpr size_t EXTRA_INT_WIDTH = internal::div_ceil(sizeof(long double) * 8, 64) * 64; - cpp::BigInt float_as_int = 0; + cpp::UInt float_as_int = 0; int int_block_index = 0; static constexpr size_t BLOCK_BUFFER_LEN = @@ -657,8 +655,7 @@ template <> class FloatToString { size_t block_buffer_valid = 0; template - LIBC_INLINE static constexpr BlockInt - grab_digits(cpp::BigInt &int_num) { + LIBC_INLINE static constexpr BlockInt grab_digits(cpp::UInt &int_num) { BlockInt cur_block = 0; auto wide_result = int_num.div_uint32_times_pow_2(1953125, 9); // the optional only comes into effect when dividing by 0, which will @@ -669,8 +666,8 @@ template <> class FloatToString { } LIBC_INLINE static constexpr void zero_leading_digits( - cpp::BigInt &int_num) { - // 64 is the width of the numbers used to internally represent the BigInt + cpp::UInt &int_num) { + // 64 is the width of the numbers used to internally represent the UInt for (size_t i = 0; i < EXTRA_INT_WIDTH / 64; ++i) { int_num[i + (FLOAT_AS_INT_WIDTH / 64)] = 0; } @@ -701,7 +698,7 @@ template <> class FloatToString { block_buffer_valid = int_block_index; } else { - // if the exponent not positive, then the number is at least partially + // if the exponent is not positive, then the number is at least partially // below the decimal point. Shift left to make the int a fixed point // representation with the decimal point after the top EXTRA_INT_WIDTH // bits. @@ -711,7 +708,7 @@ template <> class FloatToString { // If there are still digits above the decimal point, handle those. if (float_as_int.clz() < EXTRA_INT_WIDTH) { - cpp::BigInt above_decimal_point = + cpp::UInt above_decimal_point = float_as_int >> FLOAT_AS_INT_WIDTH; size_t positive_int_block_index = 0; @@ -808,7 +805,7 @@ template <> class FloatToString { int block_index = -1 - negative_block_index; // If we're currently after the requested block (remember these are - // negative indices) the reset the number to the start. This is only + // negative indices) we reset the number to the start. This is only // likely to happen in %g calls. This will also reset int_block_index. if (block_index > int_block_index) { init_convert(); diff --git a/libc/test/src/stdio/sprintf_test.cpp b/libc/test/src/stdio/sprintf_test.cpp index 315f9b5ec2d04..4f867d7ce4f30 100644 --- a/libc/test/src/stdio/sprintf_test.cpp +++ b/libc/test/src/stdio/sprintf_test.cpp @@ -1036,603 +1036,243 @@ TEST_F(LlvmLibcSPrintfTest, FloatDecimalConv) { ASSERT_STREQ_LEN(written, buff, "-NAN"); #endif - // Length Modifier Tests. + // Min Width Tests. - // TODO(michaelrj): Add tests for LIBC_LONG_DOUBLE_IS_FLOAT64 and 128 bit long - // double systems. - // TODO(michaelrj): Fix the tests to only depend on the digits the long double - // is accurate for. + written = LIBC_NAMESPACE::sprintf(buff, "%15f", 1.0); + ASSERT_STREQ_LEN(written, buff, " 1.000000"); - written = LIBC_NAMESPACE::sprintf(buff, "%Lf", 1.0L); - ASSERT_STREQ_LEN(written, buff, "1.000000"); + written = LIBC_NAMESPACE::sprintf(buff, "%15f", -1.0); + ASSERT_STREQ_LEN(written, buff, " -1.000000"); - written = LIBC_NAMESPACE::sprintf(buff, "%.Lf", -2.5L); - ASSERT_STREQ_LEN(written, buff, "-2"); + written = LIBC_NAMESPACE::sprintf(buff, "%15f", 1.0e5); + ASSERT_STREQ_LEN(written, buff, " 100000.000000"); -#if defined(LIBC_LONG_DOUBLE_IS_X86_FLOAT80) + written = LIBC_NAMESPACE::sprintf(buff, "%15f", -1.0e5); + ASSERT_STREQ_LEN(written, buff, " -100000.000000"); - written = LIBC_NAMESPACE::sprintf(buff, "%Lf", 1e100L); - ASSERT_STREQ_LEN(written, buff, - "99999999999999999996693535322073426194986990198284960792713" - "91541752018669482644324418977840117055488.000000"); + written = LIBC_NAMESPACE::sprintf(buff, "%10f", 1.0e5); + ASSERT_STREQ_LEN(written, buff, "100000.000000"); - written = LIBC_NAMESPACE::sprintf(buff, "%Lf", 0xd.96ed1192687859ap-24L); - ASSERT_STREQ_LEN(written, buff, "0.000001"); + // Precision Tests. - written = LIBC_NAMESPACE::sprintf(buff, "%Lf", 10000000000000000.25L); - ASSERT_STREQ_LEN(written, buff, "10000000000000000.250000"); + written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.0); + ASSERT_STREQ_LEN(written, buff, "1.0"); - written = LIBC_NAMESPACE::sprintf(buff, "%.510Lf", 0x8p-503L); + written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 0.0); + ASSERT_STREQ_LEN(written, buff, "0.0"); + + written = LIBC_NAMESPACE::sprintf(buff, "%.0f", 0.0); + ASSERT_STREQ_LEN(written, buff, "0"); + + written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 0.1); + ASSERT_STREQ_LEN(written, buff, "0.1"); + + written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.09); + ASSERT_STREQ_LEN(written, buff, "1.1"); + + written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.04); + ASSERT_STREQ_LEN(written, buff, "1.0"); + + written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.19); + ASSERT_STREQ_LEN(written, buff, "1.2"); + + written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.99); + ASSERT_STREQ_LEN(written, buff, "2.0"); + + written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 9.99); + ASSERT_STREQ_LEN(written, buff, "10.0"); + + written = LIBC_NAMESPACE::sprintf(buff, "%.2f", 9999999999999.99); + ASSERT_STREQ_LEN(written, buff, "9999999999999.99"); + + written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 9999999999999.99); + ASSERT_STREQ_LEN(written, buff, "10000000000000.0"); + + written = LIBC_NAMESPACE::sprintf(buff, "%.5f", 1.25); + ASSERT_STREQ_LEN(written, buff, "1.25000"); + + written = LIBC_NAMESPACE::sprintf(buff, "%.0f", 1.25); + ASSERT_STREQ_LEN(written, buff, "1"); + + written = LIBC_NAMESPACE::sprintf(buff, "%.0f", 1.75); + ASSERT_STREQ_LEN(written, buff, "2"); + + written = LIBC_NAMESPACE::sprintf(buff, "%.20f", 1.234e-10); + ASSERT_STREQ_LEN(written, buff, "0.00000000012340000000"); + + written = LIBC_NAMESPACE::sprintf(buff, "%.2f", -9.99); + ASSERT_STREQ_LEN(written, buff, "-9.99"); + + written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -9.99); + ASSERT_STREQ_LEN(written, buff, "-10.0"); + + written = LIBC_NAMESPACE::sprintf(buff, "%.5f", 0.0); + ASSERT_STREQ_LEN(written, buff, "0.00000"); + + written = LIBC_NAMESPACE::sprintf(buff, "%.5f", 1.008); + ASSERT_STREQ_LEN(written, buff, "1.00800"); + + written = LIBC_NAMESPACE::sprintf(buff, "%.5f", 1.008e3); + ASSERT_STREQ_LEN(written, buff, "1008.00000"); + + // Found with the help of Fred Tydeman's tbin2dec test. + written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 0x1.1000000000006p+3); + ASSERT_STREQ_LEN(written, buff, "8.5"); + + written = LIBC_NAMESPACE::sprintf(buff, "%.0f", 0x1.1000000000006p+3); + ASSERT_STREQ_LEN(written, buff, "9"); + + // Most of these tests are checking rounding behavior when the precision is + // set. As an example, %.9f has a precision of 9, meaning it should be rounded + // to 9 digits after the decimal point. In this case, that means that it + // should be rounded up. Many of these tests have precisions divisible by 9 + // since when printing the floating point numbers are broken up into "blocks" + // of 9 digits. They often also have a 5 after the end of what's printed, + // since in round to nearest mode, that requires checking additional digits. + written = LIBC_NAMESPACE::sprintf(buff, "%.9f", 1.9999999999999514); + ASSERT_STREQ_LEN(written, buff, "2.000000000"); + + // The number continues after the literal because floating point numbers can't + // represent every value. The printed value is the closest value a double can + // represent, rounded to the requested precision. + written = LIBC_NAMESPACE::sprintf(buff, "%.238f", 1.131959884853339E-72); ASSERT_STREQ_LEN( written, buff, "0." + "000000000000000000000000000000000000000000000000000000000000000000000001" + "131959884853339045938639911360973972585316399767392273697826861241937664" + "824105639342441431495119762431744054912109728706985341609159156917030486" + "5110665559768676757812"); + + written = LIBC_NAMESPACE::sprintf(buff, "%.36f", 9.9e-77); + ASSERT_STREQ_LEN(written, buff, "0.000000000000000000000000000000000000"); + + written = + LIBC_NAMESPACE::sprintf(big_buff, "%.1071f", 2.0226568751604562E-314); + ASSERT_STREQ_LEN( + written, big_buff, + "0." "000000000000000000000000000000000000000000000000000000000000000000000000" "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000305493636349960468205197939321361769978940274057232666389361390928" - "129162652472045770185723510801522825687515269359046715531785342780428396" - "973513311420091788963072442053377285222203558881953188370081650866793017" - "948791366338993705251636497892270212003524508209121908744820211960149463" - "721109340307985507678283651836204093399373959982767701148986816406250000" - "000000"); + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000020226568751604561683387695750739190248658016786" + "876938365740768295004457513021760887468117675879956193821375945376632621" + "367998639317487303530427946024002091961988296562516210434394107910027236" + "308233439098296717697919471698168200340836487924061502604112643734560622" + "258525943451473162532620033398739382796482175564084902819878893430369431" + "907237673154867595954110791891883281880339550955455702452422857027182100" + "606009588295886640782228837851739241290179512817803196347460636150182981" + "085084829941917048152725177119574542042352896161225179181967347829576272" + "242480201291872969114441104973910102402751449901108484914924879541248714" + "939096548775588293353689592872854495101242645279589976452453829724479805" + "750016448075109469332839157162950982637994457036256790161132812"); - written = LIBC_NAMESPACE::sprintf(buff, "%.500Lf", -4327677766926336.0L); + // If no precision is specified it defaults to 6 for %f. + written = LIBC_NAMESPACE::sprintf(buff, "%f", 2325885.4901960781); + ASSERT_STREQ_LEN(written, buff, "2325885.490196"); + + // Subnormal Precision Tests + + written = LIBC_NAMESPACE::sprintf(buff, "%.310f", 0x1.0p-1022); ASSERT_STREQ_LEN( written, buff, - "-4327677766926336." + "0." "000000000000000000000000000000000000000000000000000000000000000000000000" "000000000000000000000000000000000000000000000000000000000000000000000000" "000000000000000000000000000000000000000000000000000000000000000000000000" "000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000223"); + + written = LIBC_NAMESPACE::sprintf(buff, "%.310f", 0x1.0p-1023); + ASSERT_STREQ_LEN( + written, buff, + "0." "000000000000000000000000000000000000000000000000000000000000000000000000" "000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000"); + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000111"); - written = LIBC_NAMESPACE::sprintf(big_buff, "%Lf", 1e1000L); + written = LIBC_NAMESPACE::sprintf(buff, "%.315f", 9.99999e-310); ASSERT_STREQ_LEN( - written, big_buff, - "999999999999999999973107317669562353428234857594552594925899449376328728" - "202461036775511405481186963193066642191664822065529414252060696836533522" - "387143501724276282079456797058697369889056407118642873669166717313763499" - "277025985141177344925615052465165938514140943010597323750202561187880136" - "174810574553749194614479541820148407958204853833697063267336294787191005" - "628217462261955103745349844675732989944229689277833828743730290177882029" - "042613704915899149603539993716885598351951895974316347947147507970269673" - "097709017164643598452451201499004104341931127294141495501309305995449742" - "273419524803597130450457553871345958049837885085168840317195672271085085" - "950520957945970913451088104971436093671776829538796532762184174216651692" - "640931965387852083906784898823494867055070322768919156031682291829761007" - "101483799978382119231551218582499361996919560548090784230386907125151658" - "086767207295524036170321059257942621398084478974000973622199163292708506" - "2431457550909271560663602154947063707982236377366647567795879936." - "000000"); + written, buff, + "0." + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000999999"); - written = LIBC_NAMESPACE::sprintf(big_buff, "%Lf", 1e4900L); + written = LIBC_NAMESPACE::sprintf(buff, "%.314f", 9.99999e-310); ASSERT_STREQ_LEN( - written, big_buff, - "100000000000000000002708312230690349833224052504078834346502930111959028" - "517260692666637048230414374897655201843766090626319971729765251179632020" - "313912652522792711197087872698264530532442630109549129842736280196919130" - "242615101228133188193853826983121366159061148351354364472807590931218045" - "387490935930967150336231085015126034696883068553581691802388371635128003" - "615577299166097675723780877126495909902479233742826339471026068806070433" - "075629449530819183550315434973800271862658869400009022028602967197463980" - "126881829804282202449930132940824361207087494829502385835258094836304011" - "876250359661206802659650567866176246063987902366800491980400341950657151" - "370854446585517805253310195469184699955519312761482572080479702840420595" - "377369017651259376039167277822106875560385309101650382998482652792335482" - "865443482342801545877390859444282105890147577937366066315975231014810320" - "888482059656248277607763361589359794524314002443575149260630989130103550" - "443177966380769341050735632338583912575890190136462629316287947355057647" - "111088565611192544631519843618778618820046304429723908484879583579178075" - "456701368334212923379389029311286386996015804122917416008806233549005183" - "152461084266176543129004016414959261473645240454289630182591200574019087" - "358223489767381636349719510715487188747217311279465814538495924567014916" - "238565628036285599497236493491668884212847699052761266207598941300449276" - "447201387520841811835583254242213093566548778954711633721122784159793843" - "766802019309395771984693609426401362800013936338891483689127845928572536" - "790651156184721483511507878883282891696900630100211914227950790472211403" - "392549466062537498185758854079775888444518306635752468713312357556380082" - "275500658967283696421824354930077523691855699312544373220921962817907078" - "445538421941800259027487429330768616490865438859612697367766323925013940" - "918384858952407145253573823848733994146335416209309233074165707437420756" - "438833918763109580759409985573826485055208965115587885226774453455112406" - "581351429640282227888764449360534584421929291565334894907337572527922691" - "473242328379737396430908523008687037407295838014450772162091496534584696" - "605157436893236842602956298545594095307060870397506421786236892553632163" - "491468601982681381011940409602294892199042638682530687578982576819839451" - "907594697546439533559153604700750696252355362322662219852740143212566818" - "745528402265116534684566273868361460640280523251242059850044328669692159" - "629900374576027104298177006629276014371540945261309319363704125592775129" - "543526908667388673739382491147471395192495459318806593271282662311169392" - "196897003517840025298267505925987901751541005546610016067658227181318892" - "914686508281007582655667597441346214499847364272258631922040641860333431" - "409838623713258383681350233064164940590695888300919626215847587544298023" - "636416943680102708406086295669759876682046839368574433996997648445207805" - "615784339667691231286807666753972942872019850432610318031627872612657513" - "588188267160616660825719678199868371370527508463011236193719286066916786" - "169956541349011494927225747024994619057884118692213564790598702879596058" - "672338334720925179141906809470606964896245458600635183723159228561689808" - "246141482736625197373238197777325580142168245885279594913851700941789475" - "252421784152262567254611571822468808675893407728003047921107885664474662" - "930921581384003950729114103689170603748380178682003976896397305836815761" - "717676338115866650889936516794601457549097578905329423919798362140648664" - "569177147076571576101649257502509463877402424847669830852345415301684820" - "395813946416649808062227494112874521812750160935760825922220707178083076" - "380203450993589198835885505461509442443773367592842795410339065860781804" - "024975272228687688301824830333940416256885455008512598774611538878683158" - "183931461086893832255176926531299425504132104728730288984598001187854507" - "900417184206801359847651992484444933900133130832052346600926424167009902" - "829803553087005800387704758687923428053612864451456596148162238935900033" - "917094683141205188616000211702577553792389670853917118547527592495253773" - "028135298405566315903922235989614934474805789300370437580494193066066314" - "056627605207631392651010580925826419831250810981343093764403877594495896" - "516881097415880926429607388979497471571321217205535961262051641426436441" - "668989765107456413733909427384182109285933511623871034309722437967253289" - "084018145083721513211807496392673952789642893241520398827805325610653506" - "029060153153064455898648607959013571280930834475689835845791849456112104" - "462337569019001580859906425911782967213265389744605395555069797947978230" - "708108432086217134763779632408473684293543722127232658767439906910370146" - "716836295909075482355827087389127370874842532825987593970846704144140471" - "956027276735614286138656432085771988513977140957180090146798065497158947" - "229765733489703157617307078835099906185890777007500964162371428641176460" - "739074789794941408428328217107759915202650066155868439585510978709442590" - "231934194956788626761834746430104077432547436359522462253411168467463134" - "24896.000000"); - - written = - LIBC_NAMESPACE::sprintf(big_buff, "%Lf", 0xf.fffffffffffffffp+16380L); - ASSERT_STREQ_LEN( - written, big_buff, - "118973149535723176502126385303097020516906332229462420044032373389173700" - "552297072261641029033652888285354569780749557731442744315367028843419812" - "557385374367867359320070697326320191591828296152436552951064679108661431" - "179063216977883889613478656060039914875343321145491116008867984515486651" - "285234014977303760000912547939396622315138362241783854274391783813871780" - "588948754057516822634765923557697480511372564902088485522249479139937758" - "502601177354918009979622602685950855888360815984690023564513234659447638" - "493985927645628457966177293040780660922910271504608538808795932778162298" - "682754783076808004015069494230341172895777710033571401055977524212405734" - "700738625166011082837911962300846927720096515350020847447079244384854591" - "288672300061908512647211195136146752763351956292759795725027800298079590" - "419313960302147099703527646744553092202267965628099149823208332964124103" - "850923918473478612192169721054348428704835340811304257300221642134891734" - "717423480071488075100206439051723424765600472176809648610799494341570347" - "632064355862420744350442438056613601760883747816538902780957697597728686" - "007148702828795556714140463261583262360276289631617397848425448686060994" - "827086796804807870251185893083854658422304090880599629459458620190376604" - "844679092600222541053077590106576067134720012584640695703025713896098375" - "799892695455305236856075868317922311363951946885088077187210470520395758" - "748001314313144425494391994017575316933939236688185618912993172910425292" - "123683515992232205099800167710278403536014082929639811512287776813570604" - "578934353545169653956125404884644716978689321167108722908808277835051822" - "885764606221873970285165508372099234948333443522898475123275372663606621" - "390228126470623407535207172405866507951821730346378263135339370677490195" - "019784169044182473806316282858685774143258116536404021840272491339332094" - "921949842244273042701987304453662035026238695780468200360144729199712309" - "553005720614186697485284685618651483271597448120312194675168637934309618" - "961510733006555242148519520176285859509105183947250286387163249416761380" - "499631979144187025430270675849519200883791516940158174004671147787720145" - "964446117520405945350476472180797576111172084627363927960033967047003761" - "337450955318415007379641260504792325166135484129188421134082301547330475" - "406707281876350361733290800595189632520707167390454777712968226520622565" - "143991937680440029238090311243791261477625596469422198137514696707944687" - "035800439250765945161837981185939204954403611491531078225107269148697980" - "924094677214272701240437718740921675661363493890045123235166814608932240" - "069799317601780533819184998193300841098599393876029260139091141452600372" - "028487213241195542428210183120421610446740462163533690058366460659115629" - "876474552506814500393294140413149540067760295100596225302282300363147382" - "468105964844244132486457313743759509641616804802412935187620466813563687" - "753281467553879887177183651289394719533506188500326760735438867336800207" - "438784965701457609034985757124304510203873049485425670247933932280911052" - "604153852899484920399109194612991249163328991799809438033787952209313146" - "694614970593966415237594928589096048991612194498998638483702248667224914" - "892467841020618336462741696957630763248023558797524525373703543388296086" - "275342774001633343405508353704850737454481975472222897528108302089868263" - "302028525992308416805453968791141829762998896457648276528750456285492426" - "516521775079951625966922911497778896235667095662713848201819134832168799" - "586365263762097828507009933729439678463987902491451422274252700636394232" - "799848397673998715441855420156224415492665301451550468548925862027608576" - "183712976335876121538256512963353814166394951655600026415918655485005705" - "261143195291991880795452239464962763563017858089669222640623538289853586" - "759599064700838568712381032959192649484625076899225841930548076362021508" - "902214922052806984201835084058693849381549890944546197789302911357651677" - "540623227829831403347327660395223160342282471752818181884430488092132193" - "355086987339586127607367086665237555567580317149010847732009642431878007" - "000879734603290627894355374356444885190719161645514115576193939969076741" - "515640282654366402676009508752394550734155613586793306603174472092444651" - "353236664764973540085196704077110364053815007348689179836404957060618953" - "500508984091382686953509006678332447257871219660441528492484004185093281" - "190896363417573989716659600075948780061916409485433875852065711654107226" - "099628815012314437794400874930194474433078438899570184271000480830501217" - "712356062289507626904285680004771889315808935851559386317665294808903126" - "774702966254511086154895839508779675546413794489596052797520987481383976" - "257859210575628440175934932416214833956535018919681138909184379573470326" - "940634289008780584694035245347939808067427323629788710086717580253156130" - "235606487870925986528841635097252953709111431720488774740553905400942537" - "542411931794417513706468964386151771884986701034153254238591108962471088" - "538580868883777725864856414593426212108664758848926003176234596076950884" - "9149662444156604419552086811989770240.000000"); - - written = LIBC_NAMESPACE::sprintf(big_buff, "%.10Lf", 1e-10L); - ASSERT_STREQ_LEN(written, big_buff, "0.0000000001"); - - written = LIBC_NAMESPACE::sprintf(big_buff, "%.7500Lf", 1e-4900L); - ASSERT_STREQ_LEN( - written, big_buff, + written, buff, "0." "000000000000000000000000000000000000000000000000000000000000000000000000" "000000000000000000000000000000000000000000000000000000000000000000000000" "000000000000000000000000000000000000000000000000000000000000000000000000" "000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000100000"); + + written = LIBC_NAMESPACE::sprintf(buff, "%.330f", 0x1.0p-1074); + ASSERT_STREQ_LEN( + written, buff, + "0." "000000000000000000000000000000000000000000000000000000000000000000000000" "000000000000000000000000000000000000000000000000000000000000000000000000" "000000000000000000000000000000000000000000000000000000000000000000000000" "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000099999999999999999996962764452956071352139203248614920751610856665084" - "549214352477698417183862158583009348897567779527408501588132175167211539" - "462139941448204886585901454195352527238724272760638086779284030512649793" - "039219351187928723378036480041948464946018272171365770411701020666925613" - "422460317465324758217878522666789603627480490870456508256359180089236338" - "765625231186929290294207420828927406735690318849109129700396907705735097" - "663944722727287361650042373203763784830198232253311807069225650324196304" - "532045014970637489181357566354288111205943347410488298480279857453705249" - "232862728556860184412369114663536200895729846877559808001004454634804626" - "541455540260282018142615835686583304903486353937549394736905011798466731" - "536563240053860118551127061960208467764243724656897127545613968909523389" - "577188368809623987105800147797280462974804046545425080530020901531407223" - "191237123282274818236437397994019915368657474589800678444589412286037789" - "891525464936023205313685584525510094270344601331453730179416773626565262" - "480345858564672442896904520146956686863172737711483866766404977719744767" - "834324844875237277613991088218774564658513875732403456058414595576806383" - "115554713240005982141397577420073082470139244845624915873825746771661332" - "098677966580506186966978746832443976821987300902957597498388211921362869" - "017846215557612829071692275292036211064515305528052919611691470945774714" - "135516559501572279732350629089770249554808690411603894492333360300589658" - "470898965370892774715815089075170720164713889237058574941489766701880158" - "060081295483989540170337129032188818293132770882381428397119039835946745" - "549356649433406617266370644136291924838857814675939156677910783740103207" - "523299367093130816446415259371931925208362367989095199399211644084543790" - "110432339056231037520216864358899218874658268610955002763260912337688947" - "822453100821038299301092582962825965939081817836419126254832772002214908" - "085575905761843610944187009818156363893015929300295112598059949496854566" - "638748010633726861510500653821408135845840123073754133549077708843800674" - "328440913743105608636458354618912183716456158809545183074062249922212944" - "249667793845728355381309084891765979111348980470647082269921872595470473" - "719354467594516320911964549508538492057120740224559944452120552719041944" - "961475548547884309626382512432626380881023756568143060204097921571153170" - "723817845809196253498326358439807445210362177680590181657555380795450462" - "223805222580359379367452693270553602179122419370586308101820559214330382" - "570449525088342437216896462077260223998756027453411520977536701491759878" - "422771447006016890777855573925295187921971811871399320142563330377888532" - "179817332113"); -#endif // LIBC_LONG_DOUBLE_IS_X86_FLOAT80 + "000000000000000000000000000000000004940656"); /* - written = LIBC_NAMESPACE::sprintf(buff, "%La", 0.1L); + written = LIBC_NAMESPACE::sprintf(buff, "%.1La", 0.1L); #if defined(LIBC_LONG_DOUBLE_IS_X86_FLOAT80) - ASSERT_STREQ_LEN(written, buff, "0xc.ccccccccccccccdp-7"); + ASSERT_STREQ_LEN(written, buff, "0xc.dp-7"); #elif defined(LIBC_LONG_DOUBLE_IS_FLOAT64) - ASSERT_STREQ_LEN(written, buff, "0x1.999999999999ap-4"); + ASSERT_STREQ_LEN(written, buff, "0x1.ap-4"); #else // 128 bit long double - ASSERT_STREQ_LEN(written, buff, "0x1.999999999999999999999999999ap-4"); + ASSERT_STREQ_LEN(written, buff, "0x1.ap-4"); #endif - written = LIBC_NAMESPACE::sprintf(buff, "%La", 1.0e1000L); - #if defined(LIBC_LONG_DOUBLE_IS_X86_FLOAT80) - ASSERT_STREQ_LEN(written, buff, "0xf.38db1f9dd3dac05p+3318"); + written = LIBC_NAMESPACE::sprintf(buff, "%.1La", + 0xf.fffffffffffffffp16380L); #if defined(LIBC_LONG_DOUBLE_IS_X86_FLOAT80) + ASSERT_STREQ_LEN(written, buff, "0x1.0p+16384"); #elif defined(LIBC_LONG_DOUBLE_IS_FLOAT64) ASSERT_STREQ_LEN(written, buff, "inf"); #else // 128 bit long double - ASSERT_STREQ_LEN(written, buff, "0x1.e71b63f3ba7b580af1a52d2a7379p+3321"); - #endif - - written = LIBC_NAMESPACE::sprintf(buff, "%La", 1.0e-1000L); - #if defined(LIBC_LONG_DOUBLE_IS_X86_FLOAT80) - ASSERT_STREQ_LEN(written, buff, "0x8.68a9188a89e1467p-3325"); - #elif defined(LIBC_LONG_DOUBLE_IS_FLOAT64) - ASSERT_STREQ_LEN(written, buff, "0x0p+0"); - #else // 128 bit long double - ASSERT_STREQ_LEN(written, buff, "0x1.0d152311513c28ce202627c06ec2p-3322"); + ASSERT_STREQ_LEN(written, buff, "0x2.0p+16383"); #endif */ - // Min Width Tests. + // Rounding Mode Tests. - written = LIBC_NAMESPACE::sprintf(buff, "%15f", 1.0); - ASSERT_STREQ_LEN(written, buff, " 1.000000"); + if (ForceRoundingMode r(RoundingMode::Nearest); r.success) { + written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.75); + ASSERT_STREQ_LEN(written, buff, "1.8"); - written = LIBC_NAMESPACE::sprintf(buff, "%15f", -1.0); - ASSERT_STREQ_LEN(written, buff, " -1.000000"); + written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.25); + ASSERT_STREQ_LEN(written, buff, "1.2"); - written = LIBC_NAMESPACE::sprintf(buff, "%15f", 1.0e5); - ASSERT_STREQ_LEN(written, buff, " 100000.000000"); + written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.125); + ASSERT_STREQ_LEN(written, buff, "1.1"); - written = LIBC_NAMESPACE::sprintf(buff, "%15f", -1.0e5); - ASSERT_STREQ_LEN(written, buff, " -100000.000000"); + written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.625); + ASSERT_STREQ_LEN(written, buff, "1.6"); - written = LIBC_NAMESPACE::sprintf(buff, "%10f", 1.0e5); - ASSERT_STREQ_LEN(written, buff, "100000.000000"); + written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.375); + ASSERT_STREQ_LEN(written, buff, "1.4"); - // Precision Tests. + written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.875); + ASSERT_STREQ_LEN(written, buff, "1.9"); - written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.0); - ASSERT_STREQ_LEN(written, buff, "1.0"); + written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.75); + ASSERT_STREQ_LEN(written, buff, "-1.8"); - written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 0.0); - ASSERT_STREQ_LEN(written, buff, "0.0"); + written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.25); + ASSERT_STREQ_LEN(written, buff, "-1.2"); - written = LIBC_NAMESPACE::sprintf(buff, "%.0f", 0.0); - ASSERT_STREQ_LEN(written, buff, "0"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 0.1); - ASSERT_STREQ_LEN(written, buff, "0.1"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.09); - ASSERT_STREQ_LEN(written, buff, "1.1"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.04); - ASSERT_STREQ_LEN(written, buff, "1.0"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.19); - ASSERT_STREQ_LEN(written, buff, "1.2"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.99); - ASSERT_STREQ_LEN(written, buff, "2.0"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 9.99); - ASSERT_STREQ_LEN(written, buff, "10.0"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.2f", 9999999999999.99); - ASSERT_STREQ_LEN(written, buff, "9999999999999.99"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 9999999999999.99); - ASSERT_STREQ_LEN(written, buff, "10000000000000.0"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.5f", 1.25); - ASSERT_STREQ_LEN(written, buff, "1.25000"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.0f", 1.25); - ASSERT_STREQ_LEN(written, buff, "1"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.0f", 1.75); - ASSERT_STREQ_LEN(written, buff, "2"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.20f", 1.234e-10); - ASSERT_STREQ_LEN(written, buff, "0.00000000012340000000"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.2f", -9.99); - ASSERT_STREQ_LEN(written, buff, "-9.99"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -9.99); - ASSERT_STREQ_LEN(written, buff, "-10.0"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.5f", 0.0); - ASSERT_STREQ_LEN(written, buff, "0.00000"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.5f", 1.008); - ASSERT_STREQ_LEN(written, buff, "1.00800"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.5f", 1.008e3); - ASSERT_STREQ_LEN(written, buff, "1008.00000"); - - // Found with the help of Fred Tydeman's tbin2dec test. - written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 0x1.1000000000006p+3); - ASSERT_STREQ_LEN(written, buff, "8.5"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.0f", 0x1.1000000000006p+3); - ASSERT_STREQ_LEN(written, buff, "9"); - - // Most of these tests are checking rounding behavior when the precision is - // set. As an example, %.9f has a precision of 9, meaning it should be rounded - // to 9 digits after the decimal point. In this case, that means that it - // should be rounded up. Many of these tests have precisions divisible by 9 - // since when printing the floating point numbers are broken up into "blocks" - // of 9 digits. They often also have a 5 after the end of what's printed, - // since in round to nearest mode, that requires checking additional digits. - written = LIBC_NAMESPACE::sprintf(buff, "%.9f", 1.9999999999999514); - ASSERT_STREQ_LEN(written, buff, "2.000000000"); - - // The number continues after the literal because floating point numbers can't - // represent every value. The printed value is the closest value a double can - // represent, rounded to the requested precision. - written = LIBC_NAMESPACE::sprintf(buff, "%.238f", 1.131959884853339E-72); - ASSERT_STREQ_LEN( - written, buff, - "0." - "000000000000000000000000000000000000000000000000000000000000000000000001" - "131959884853339045938639911360973972585316399767392273697826861241937664" - "824105639342441431495119762431744054912109728706985341609159156917030486" - "5110665559768676757812"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.36f", 9.9e-77); - ASSERT_STREQ_LEN(written, buff, "0.000000000000000000000000000000000000"); - - written = - LIBC_NAMESPACE::sprintf(big_buff, "%.1071f", 2.0226568751604562E-314); - ASSERT_STREQ_LEN( - written, big_buff, - "0." - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000020226568751604561683387695750739190248658016786" - "876938365740768295004457513021760887468117675879956193821375945376632621" - "367998639317487303530427946024002091961988296562516210434394107910027236" - "308233439098296717697919471698168200340836487924061502604112643734560622" - "258525943451473162532620033398739382796482175564084902819878893430369431" - "907237673154867595954110791891883281880339550955455702452422857027182100" - "606009588295886640782228837851739241290179512817803196347460636150182981" - "085084829941917048152725177119574542042352896161225179181967347829576272" - "242480201291872969114441104973910102402751449901108484914924879541248714" - "939096548775588293353689592872854495101242645279589976452453829724479805" - "750016448075109469332839157162950982637994457036256790161132812"); - - // If no precision is specified it defaults to 6 for %f. - written = LIBC_NAMESPACE::sprintf(buff, "%f", 2325885.4901960781); - ASSERT_STREQ_LEN(written, buff, "2325885.490196"); - - // Subnormal Precision Tests - - written = LIBC_NAMESPACE::sprintf(buff, "%.310f", 0x1.0p-1022); - ASSERT_STREQ_LEN( - written, buff, - "0." - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "0000000000000000000223"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.310f", 0x1.0p-1023); - ASSERT_STREQ_LEN( - written, buff, - "0." - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "0000000000000000000111"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.315f", 9.99999e-310); - ASSERT_STREQ_LEN( - written, buff, - "0." - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000999999"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.314f", 9.99999e-310); - ASSERT_STREQ_LEN( - written, buff, - "0." - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000100000"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.330f", 0x1.0p-1074); - ASSERT_STREQ_LEN( - written, buff, - "0." - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000004940656"); - - /* - written = LIBC_NAMESPACE::sprintf(buff, "%.1La", 0.1L); - #if defined(LIBC_LONG_DOUBLE_IS_X86_FLOAT80) - ASSERT_STREQ_LEN(written, buff, "0xc.dp-7"); - #elif defined(LIBC_LONG_DOUBLE_IS_FLOAT64) - ASSERT_STREQ_LEN(written, buff, "0x1.ap-4"); - #else // 128 bit long double - ASSERT_STREQ_LEN(written, buff, "0x1.ap-4"); - #endif - - written = LIBC_NAMESPACE::sprintf(buff, "%.1La", - 0xf.fffffffffffffffp16380L); #if defined(LIBC_LONG_DOUBLE_IS_X86_FLOAT80) - ASSERT_STREQ_LEN(written, buff, "0x1.0p+16384"); - #elif defined(LIBC_LONG_DOUBLE_IS_FLOAT64) - ASSERT_STREQ_LEN(written, buff, "inf"); - #else // 128 bit long double - ASSERT_STREQ_LEN(written, buff, "0x2.0p+16383"); - #endif - */ - - // Rounding Mode Tests. - - if (ForceRoundingMode r(RoundingMode::Nearest); r.success) { - written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.75); - ASSERT_STREQ_LEN(written, buff, "1.8"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.25); - ASSERT_STREQ_LEN(written, buff, "1.2"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.125); - ASSERT_STREQ_LEN(written, buff, "1.1"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.625); - ASSERT_STREQ_LEN(written, buff, "1.6"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.375); - ASSERT_STREQ_LEN(written, buff, "1.4"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.875); - ASSERT_STREQ_LEN(written, buff, "1.9"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.75); - ASSERT_STREQ_LEN(written, buff, "-1.8"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.25); - ASSERT_STREQ_LEN(written, buff, "-1.2"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.125); - ASSERT_STREQ_LEN(written, buff, "-1.1"); + written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.125); + ASSERT_STREQ_LEN(written, buff, "-1.1"); written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.625); ASSERT_STREQ_LEN(written, buff, "-1.6"); @@ -1818,11 +1458,380 @@ TEST_F(LlvmLibcSPrintfTest, FloatDecimalConv) { written = LIBC_NAMESPACE::sprintf(buff, "%20.1f", 9999999999999.99); ASSERT_STREQ_LEN(written, buff, " 10000000000000.0"); - written = LIBC_NAMESPACE::sprintf(buff, "%12.3f %-12.3f", 0.1, 256.0); - ASSERT_STREQ_LEN(written, buff, " 0.100 256.000 "); + written = LIBC_NAMESPACE::sprintf(buff, "%12.3f %-12.3f", 0.1, 256.0); + ASSERT_STREQ_LEN(written, buff, " 0.100 256.000 "); + + written = LIBC_NAMESPACE::sprintf(buff, "%+-#12.3f % 012.3f", 0.1256, 1256.0); + ASSERT_STREQ_LEN(written, buff, "+0.126 0001256.000"); +} + +// The long double tests are separated so that their performance can be directly +// measured. +TEST_F(LlvmLibcSPrintfTest, FloatDecimalLongDoubleConv) { + ForceRoundingMode r(RoundingMode::Nearest); + + char big_buff[10000]; // Used for long doubles and other extremely wide + // numbers. + + // Length Modifier Tests. + + // TODO(michaelrj): Add tests for LIBC_LONG_DOUBLE_IS_FLOAT64 and 128 bit long + // double systems. + // TODO(michaelrj): Fix the tests to only depend on the digits the long double + // is accurate for. + + written = LIBC_NAMESPACE::sprintf(buff, "%Lf", 1.0L); + ASSERT_STREQ_LEN(written, buff, "1.000000"); + + written = LIBC_NAMESPACE::sprintf(buff, "%.Lf", -2.5L); + ASSERT_STREQ_LEN(written, buff, "-2"); + +#if defined(LIBC_LONG_DOUBLE_IS_X86_FLOAT80) + + written = LIBC_NAMESPACE::sprintf(buff, "%Lf", 1e100L); + ASSERT_STREQ_LEN(written, buff, + "99999999999999999996693535322073426194986990198284960792713" + "91541752018669482644324418977840117055488.000000"); + + written = LIBC_NAMESPACE::sprintf(buff, "%Lf", 0xd.96ed1192687859ap-24L); + ASSERT_STREQ_LEN(written, buff, "0.000001"); + + written = LIBC_NAMESPACE::sprintf(buff, "%Lf", 10000000000000000.25L); + ASSERT_STREQ_LEN(written, buff, "10000000000000000.250000"); + + written = LIBC_NAMESPACE::sprintf(buff, "%.510Lf", 0x8p-503L); + ASSERT_STREQ_LEN( + written, buff, + "0." + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000305493636349960468205197939321361769978940274057232666389361390928" + "129162652472045770185723510801522825687515269359046715531785342780428396" + "973513311420091788963072442053377285222203558881953188370081650866793017" + "948791366338993705251636497892270212003524508209121908744820211960149463" + "721109340307985507678283651836204093399373959982767701148986816406250000" + "000000"); + + written = LIBC_NAMESPACE::sprintf(buff, "%.500Lf", -4327677766926336.0L); + ASSERT_STREQ_LEN( + written, buff, + "-4327677766926336." + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000"); + + written = LIBC_NAMESPACE::sprintf(big_buff, "%Lf", 1e1000L); + ASSERT_STREQ_LEN( + written, big_buff, + "999999999999999999973107317669562353428234857594552594925899449376328728" + "202461036775511405481186963193066642191664822065529414252060696836533522" + "387143501724276282079456797058697369889056407118642873669166717313763499" + "277025985141177344925615052465165938514140943010597323750202561187880136" + "174810574553749194614479541820148407958204853833697063267336294787191005" + "628217462261955103745349844675732989944229689277833828743730290177882029" + "042613704915899149603539993716885598351951895974316347947147507970269673" + "097709017164643598452451201499004104341931127294141495501309305995449742" + "273419524803597130450457553871345958049837885085168840317195672271085085" + "950520957945970913451088104971436093671776829538796532762184174216651692" + "640931965387852083906784898823494867055070322768919156031682291829761007" + "101483799978382119231551218582499361996919560548090784230386907125151658" + "086767207295524036170321059257942621398084478974000973622199163292708506" + "2431457550909271560663602154947063707982236377366647567795879936." + "000000"); + + written = LIBC_NAMESPACE::sprintf(big_buff, "%Lf", 1e4900L); + ASSERT_STREQ_LEN( + written, big_buff, + "100000000000000000002708312230690349833224052504078834346502930111959028" + "517260692666637048230414374897655201843766090626319971729765251179632020" + "313912652522792711197087872698264530532442630109549129842736280196919130" + "242615101228133188193853826983121366159061148351354364472807590931218045" + "387490935930967150336231085015126034696883068553581691802388371635128003" + "615577299166097675723780877126495909902479233742826339471026068806070433" + "075629449530819183550315434973800271862658869400009022028602967197463980" + "126881829804282202449930132940824361207087494829502385835258094836304011" + "876250359661206802659650567866176246063987902366800491980400341950657151" + "370854446585517805253310195469184699955519312761482572080479702840420595" + "377369017651259376039167277822106875560385309101650382998482652792335482" + "865443482342801545877390859444282105890147577937366066315975231014810320" + "888482059656248277607763361589359794524314002443575149260630989130103550" + "443177966380769341050735632338583912575890190136462629316287947355057647" + "111088565611192544631519843618778618820046304429723908484879583579178075" + "456701368334212923379389029311286386996015804122917416008806233549005183" + "152461084266176543129004016414959261473645240454289630182591200574019087" + "358223489767381636349719510715487188747217311279465814538495924567014916" + "238565628036285599497236493491668884212847699052761266207598941300449276" + "447201387520841811835583254242213093566548778954711633721122784159793843" + "766802019309395771984693609426401362800013936338891483689127845928572536" + "790651156184721483511507878883282891696900630100211914227950790472211403" + "392549466062537498185758854079775888444518306635752468713312357556380082" + "275500658967283696421824354930077523691855699312544373220921962817907078" + "445538421941800259027487429330768616490865438859612697367766323925013940" + "918384858952407145253573823848733994146335416209309233074165707437420756" + "438833918763109580759409985573826485055208965115587885226774453455112406" + "581351429640282227888764449360534584421929291565334894907337572527922691" + "473242328379737396430908523008687037407295838014450772162091496534584696" + "605157436893236842602956298545594095307060870397506421786236892553632163" + "491468601982681381011940409602294892199042638682530687578982576819839451" + "907594697546439533559153604700750696252355362322662219852740143212566818" + "745528402265116534684566273868361460640280523251242059850044328669692159" + "629900374576027104298177006629276014371540945261309319363704125592775129" + "543526908667388673739382491147471395192495459318806593271282662311169392" + "196897003517840025298267505925987901751541005546610016067658227181318892" + "914686508281007582655667597441346214499847364272258631922040641860333431" + "409838623713258383681350233064164940590695888300919626215847587544298023" + "636416943680102708406086295669759876682046839368574433996997648445207805" + "615784339667691231286807666753972942872019850432610318031627872612657513" + "588188267160616660825719678199868371370527508463011236193719286066916786" + "169956541349011494927225747024994619057884118692213564790598702879596058" + "672338334720925179141906809470606964896245458600635183723159228561689808" + "246141482736625197373238197777325580142168245885279594913851700941789475" + "252421784152262567254611571822468808675893407728003047921107885664474662" + "930921581384003950729114103689170603748380178682003976896397305836815761" + "717676338115866650889936516794601457549097578905329423919798362140648664" + "569177147076571576101649257502509463877402424847669830852345415301684820" + "395813946416649808062227494112874521812750160935760825922220707178083076" + "380203450993589198835885505461509442443773367592842795410339065860781804" + "024975272228687688301824830333940416256885455008512598774611538878683158" + "183931461086893832255176926531299425504132104728730288984598001187854507" + "900417184206801359847651992484444933900133130832052346600926424167009902" + "829803553087005800387704758687923428053612864451456596148162238935900033" + "917094683141205188616000211702577553792389670853917118547527592495253773" + "028135298405566315903922235989614934474805789300370437580494193066066314" + "056627605207631392651010580925826419831250810981343093764403877594495896" + "516881097415880926429607388979497471571321217205535961262051641426436441" + "668989765107456413733909427384182109285933511623871034309722437967253289" + "084018145083721513211807496392673952789642893241520398827805325610653506" + "029060153153064455898648607959013571280930834475689835845791849456112104" + "462337569019001580859906425911782967213265389744605395555069797947978230" + "708108432086217134763779632408473684293543722127232658767439906910370146" + "716836295909075482355827087389127370874842532825987593970846704144140471" + "956027276735614286138656432085771988513977140957180090146798065497158947" + "229765733489703157617307078835099906185890777007500964162371428641176460" + "739074789794941408428328217107759915202650066155868439585510978709442590" + "231934194956788626761834746430104077432547436359522462253411168467463134" + "24896.000000"); + + written = + LIBC_NAMESPACE::sprintf(big_buff, "%Lf", 0xf.fffffffffffffffp+16380L); + ASSERT_STREQ_LEN( + written, big_buff, + "118973149535723176502126385303097020516906332229462420044032373389173700" + "552297072261641029033652888285354569780749557731442744315367028843419812" + "557385374367867359320070697326320191591828296152436552951064679108661431" + "179063216977883889613478656060039914875343321145491116008867984515486651" + "285234014977303760000912547939396622315138362241783854274391783813871780" + "588948754057516822634765923557697480511372564902088485522249479139937758" + "502601177354918009979622602685950855888360815984690023564513234659447638" + "493985927645628457966177293040780660922910271504608538808795932778162298" + "682754783076808004015069494230341172895777710033571401055977524212405734" + "700738625166011082837911962300846927720096515350020847447079244384854591" + "288672300061908512647211195136146752763351956292759795725027800298079590" + "419313960302147099703527646744553092202267965628099149823208332964124103" + "850923918473478612192169721054348428704835340811304257300221642134891734" + "717423480071488075100206439051723424765600472176809648610799494341570347" + "632064355862420744350442438056613601760883747816538902780957697597728686" + "007148702828795556714140463261583262360276289631617397848425448686060994" + "827086796804807870251185893083854658422304090880599629459458620190376604" + "844679092600222541053077590106576067134720012584640695703025713896098375" + "799892695455305236856075868317922311363951946885088077187210470520395758" + "748001314313144425494391994017575316933939236688185618912993172910425292" + "123683515992232205099800167710278403536014082929639811512287776813570604" + "578934353545169653956125404884644716978689321167108722908808277835051822" + "885764606221873970285165508372099234948333443522898475123275372663606621" + "390228126470623407535207172405866507951821730346378263135339370677490195" + "019784169044182473806316282858685774143258116536404021840272491339332094" + "921949842244273042701987304453662035026238695780468200360144729199712309" + "553005720614186697485284685618651483271597448120312194675168637934309618" + "961510733006555242148519520176285859509105183947250286387163249416761380" + "499631979144187025430270675849519200883791516940158174004671147787720145" + "964446117520405945350476472180797576111172084627363927960033967047003761" + "337450955318415007379641260504792325166135484129188421134082301547330475" + "406707281876350361733290800595189632520707167390454777712968226520622565" + "143991937680440029238090311243791261477625596469422198137514696707944687" + "035800439250765945161837981185939204954403611491531078225107269148697980" + "924094677214272701240437718740921675661363493890045123235166814608932240" + "069799317601780533819184998193300841098599393876029260139091141452600372" + "028487213241195542428210183120421610446740462163533690058366460659115629" + "876474552506814500393294140413149540067760295100596225302282300363147382" + "468105964844244132486457313743759509641616804802412935187620466813563687" + "753281467553879887177183651289394719533506188500326760735438867336800207" + "438784965701457609034985757124304510203873049485425670247933932280911052" + "604153852899484920399109194612991249163328991799809438033787952209313146" + "694614970593966415237594928589096048991612194498998638483702248667224914" + "892467841020618336462741696957630763248023558797524525373703543388296086" + "275342774001633343405508353704850737454481975472222897528108302089868263" + "302028525992308416805453968791141829762998896457648276528750456285492426" + "516521775079951625966922911497778896235667095662713848201819134832168799" + "586365263762097828507009933729439678463987902491451422274252700636394232" + "799848397673998715441855420156224415492665301451550468548925862027608576" + "183712976335876121538256512963353814166394951655600026415918655485005705" + "261143195291991880795452239464962763563017858089669222640623538289853586" + "759599064700838568712381032959192649484625076899225841930548076362021508" + "902214922052806984201835084058693849381549890944546197789302911357651677" + "540623227829831403347327660395223160342282471752818181884430488092132193" + "355086987339586127607367086665237555567580317149010847732009642431878007" + "000879734603290627894355374356444885190719161645514115576193939969076741" + "515640282654366402676009508752394550734155613586793306603174472092444651" + "353236664764973540085196704077110364053815007348689179836404957060618953" + "500508984091382686953509006678332447257871219660441528492484004185093281" + "190896363417573989716659600075948780061916409485433875852065711654107226" + "099628815012314437794400874930194474433078438899570184271000480830501217" + "712356062289507626904285680004771889315808935851559386317665294808903126" + "774702966254511086154895839508779675546413794489596052797520987481383976" + "257859210575628440175934932416214833956535018919681138909184379573470326" + "940634289008780584694035245347939808067427323629788710086717580253156130" + "235606487870925986528841635097252953709111431720488774740553905400942537" + "542411931794417513706468964386151771884986701034153254238591108962471088" + "538580868883777725864856414593426212108664758848926003176234596076950884" + "9149662444156604419552086811989770240.000000"); + + written = LIBC_NAMESPACE::sprintf(big_buff, "%.10Lf", 1e-10L); + ASSERT_STREQ_LEN(written, big_buff, "0.0000000001"); + + written = LIBC_NAMESPACE::sprintf(big_buff, "%.7500Lf", 1e-4900L); + ASSERT_STREQ_LEN( + written, big_buff, + "0." + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000" + "000099999999999999999996962764452956071352139203248614920751610856665084" + "549214352477698417183862158583009348897567779527408501588132175167211539" + "462139941448204886585901454195352527238724272760638086779284030512649793" + "039219351187928723378036480041948464946018272171365770411701020666925613" + "422460317465324758217878522666789603627480490870456508256359180089236338" + "765625231186929290294207420828927406735690318849109129700396907705735097" + "663944722727287361650042373203763784830198232253311807069225650324196304" + "532045014970637489181357566354288111205943347410488298480279857453705249" + "232862728556860184412369114663536200895729846877559808001004454634804626" + "541455540260282018142615835686583304903486353937549394736905011798466731" + "536563240053860118551127061960208467764243724656897127545613968909523389" + "577188368809623987105800147797280462974804046545425080530020901531407223" + "191237123282274818236437397994019915368657474589800678444589412286037789" + "891525464936023205313685584525510094270344601331453730179416773626565262" + "480345858564672442896904520146956686863172737711483866766404977719744767" + "834324844875237277613991088218774564658513875732403456058414595576806383" + "115554713240005982141397577420073082470139244845624915873825746771661332" + "098677966580506186966978746832443976821987300902957597498388211921362869" + "017846215557612829071692275292036211064515305528052919611691470945774714" + "135516559501572279732350629089770249554808690411603894492333360300589658" + "470898965370892774715815089075170720164713889237058574941489766701880158" + "060081295483989540170337129032188818293132770882381428397119039835946745" + "549356649433406617266370644136291924838857814675939156677910783740103207" + "523299367093130816446415259371931925208362367989095199399211644084543790" + "110432339056231037520216864358899218874658268610955002763260912337688947" + "822453100821038299301092582962825965939081817836419126254832772002214908" + "085575905761843610944187009818156363893015929300295112598059949496854566" + "638748010633726861510500653821408135845840123073754133549077708843800674" + "328440913743105608636458354618912183716456158809545183074062249922212944" + "249667793845728355381309084891765979111348980470647082269921872595470473" + "719354467594516320911964549508538492057120740224559944452120552719041944" + "961475548547884309626382512432626380881023756568143060204097921571153170" + "723817845809196253498326358439807445210362177680590181657555380795450462" + "223805222580359379367452693270553602179122419370586308101820559214330382" + "570449525088342437216896462077260223998756027453411520977536701491759878" + "422771447006016890777855573925295187921971811871399320142563330377888532" + "179817332113"); +#endif // LIBC_LONG_DOUBLE_IS_X86_FLOAT80 + + /* + written = LIBC_NAMESPACE::sprintf(buff, "%La", 0.1L); + #if defined(LIBC_LONG_DOUBLE_IS_X86_FLOAT80) + ASSERT_STREQ_LEN(written, buff, "0xc.ccccccccccccccdp-7"); + #elif defined(LIBC_LONG_DOUBLE_IS_FLOAT64) + ASSERT_STREQ_LEN(written, buff, "0x1.999999999999ap-4"); + #else // 128 bit long double + ASSERT_STREQ_LEN(written, buff, "0x1.999999999999999999999999999ap-4"); + #endif + + written = LIBC_NAMESPACE::sprintf(buff, "%La", 1.0e1000L); + #if defined(LIBC_LONG_DOUBLE_IS_X86_FLOAT80) + ASSERT_STREQ_LEN(written, buff, "0xf.38db1f9dd3dac05p+3318"); + #elif defined(LIBC_LONG_DOUBLE_IS_FLOAT64) + ASSERT_STREQ_LEN(written, buff, "inf"); + #else // 128 bit long double + ASSERT_STREQ_LEN(written, buff, "0x1.e71b63f3ba7b580af1a52d2a7379p+3321"); + #endif - written = LIBC_NAMESPACE::sprintf(buff, "%+-#12.3f % 012.3f", 0.1256, 1256.0); - ASSERT_STREQ_LEN(written, buff, "+0.126 0001256.000"); + written = LIBC_NAMESPACE::sprintf(buff, "%La", 1.0e-1000L); + #if defined(LIBC_LONG_DOUBLE_IS_X86_FLOAT80) + ASSERT_STREQ_LEN(written, buff, "0x8.68a9188a89e1467p-3325"); + #elif defined(LIBC_LONG_DOUBLE_IS_FLOAT64) + ASSERT_STREQ_LEN(written, buff, "0x0p+0"); + #else // 128 bit long double + ASSERT_STREQ_LEN(written, buff, "0x1.0d152311513c28ce202627c06ec2p-3322"); + #endif + */ } TEST_F(LlvmLibcSPrintfTest, FloatExponentConv) { @@ -1896,152 +1905,6 @@ TEST_F(LlvmLibcSPrintfTest, FloatExponentConv) { written = LIBC_NAMESPACE::sprintf(buff, "%E", -nan); ASSERT_STREQ_LEN(written, buff, "-NAN"); - // Length Modifier Tests. - -#if defined(LIBC_LONG_DOUBLE_IS_X86_FLOAT80) - written = LIBC_NAMESPACE::sprintf(buff, "%.9Le", 1000000000500000000.1L); - ASSERT_STREQ_LEN(written, buff, "1.000000001e+18"); - - written = LIBC_NAMESPACE::sprintf(buff, "%.9Le", 1000000000500000000.0L); - ASSERT_STREQ_LEN(written, buff, "1.000000000e+18"); - - written = LIBC_NAMESPACE::sprintf(buff, "%Le", 0xf.fffffffffffffffp+16380L); - ASSERT_STREQ_LEN(written, buff, "1.189731e+4932"); -#endif - - // TODO: Fix long doubles (needs bigger table or alternate algorithm.) - // Currently the table values are generated, which is very slow. - /* - written = LIBC_NAMESPACE::sprintf(buff, "%Lf", 1e100L); - ASSERT_STREQ_LEN(written, buff, - "99999999999999999996693535322073426194986990198284960792713" - "91541752018669482644324418977840117055488.000000"); - - written = LIBC_NAMESPACE::sprintf(buff, "%Lf", 1.0L); - ASSERT_STREQ_LEN(written, buff, "1.000000"); - - char big_buff[10000]; - written = LIBC_NAMESPACE::sprintf(big_buff, "%Lf", 1e1000L); - ASSERT_STREQ_LEN( - written, big_buff, - "999999999999999999973107317669562353428234857594552594925899449376328728" - "202461036775511405481186963193066642191664822065529414252060696836533522" - "387143501724276282079456797058697369889056407118642873669166717313763499" - "277025985141177344925615052465165938514140943010597323750202561187880136" - "174810574553749194614479541820148407958204853833697063267336294787191005" - "628217462261955103745349844675732989944229689277833828743730290177882029" - "042613704915899149603539993716885598351951895974316347947147507970269673" - "097709017164643598452451201499004104341931127294141495501309305995449742" - "273419524803597130450457553871345958049837885085168840317195672271085085" - "950520957945970913451088104971436093671776829538796532762184174216651692" - "640931965387852083906784898823494867055070322768919156031682291829761007" - "101483799978382119231551218582499361996919560548090784230386907125151658" - "086767207295524036170321059257942621398084478974000973622199163292708506" - "2431457550909271560663602154947063707982236377366647567795879936." - "000000"); - - written = LIBC_NAMESPACE::sprintf(big_buff, "%Lf", 1e4900L); - ASSERT_STREQ_LEN( - written, big_buff, - "100000000000000000002708312230690349833224052504078834346502930111959028" - "517260692666637048230414374897655201843766090626319971729765251179632020" - "313912652522792711197087872698264530532442630109549129842736280196919130" - "242615101228133188193853826983121366159061148351354364472807590931218045" - "387490935930967150336231085015126034696883068553581691802388371635128003" - "615577299166097675723780877126495909902479233742826339471026068806070433" - "075629449530819183550315434973800271862658869400009022028602967197463980" - "126881829804282202449930132940824361207087494829502385835258094836304011" - "876250359661206802659650567866176246063987902366800491980400341950657151" - "370854446585517805253310195469184699955519312761482572080479702840420595" - "377369017651259376039167277822106875560385309101650382998482652792335482" - "865443482342801545877390859444282105890147577937366066315975231014810320" - "888482059656248277607763361589359794524314002443575149260630989130103550" - "443177966380769341050735632338583912575890190136462629316287947355057647" - "111088565611192544631519843618778618820046304429723908484879583579178075" - "456701368334212923379389029311286386996015804122917416008806233549005183" - "152461084266176543129004016414959261473645240454289630182591200574019087" - "358223489767381636349719510715487188747217311279465814538495924567014916" - "238565628036285599497236493491668884212847699052761266207598941300449276" - "447201387520841811835583254242213093566548778954711633721122784159793843" - "766802019309395771984693609426401362800013936338891483689127845928572536" - "790651156184721483511507878883282891696900630100211914227950790472211403" - "392549466062537498185758854079775888444518306635752468713312357556380082" - "275500658967283696421824354930077523691855699312544373220921962817907078" - "445538421941800259027487429330768616490865438859612697367766323925013940" - "918384858952407145253573823848733994146335416209309233074165707437420756" - "438833918763109580759409985573826485055208965115587885226774453455112406" - "581351429640282227888764449360534584421929291565334894907337572527922691" - "473242328379737396430908523008687037407295838014450772162091496534584696" - "605157436893236842602956298545594095307060870397506421786236892553632163" - "491468601982681381011940409602294892199042638682530687578982576819839451" - "907594697546439533559153604700750696252355362322662219852740143212566818" - "745528402265116534684566273868361460640280523251242059850044328669692159" - "629900374576027104298177006629276014371540945261309319363704125592775129" - "543526908667388673739382491147471395192495459318806593271282662311169392" - "196897003517840025298267505925987901751541005546610016067658227181318892" - "914686508281007582655667597441346214499847364272258631922040641860333431" - "409838623713258383681350233064164940590695888300919626215847587544298023" - "636416943680102708406086295669759876682046839368574433996997648445207805" - "615784339667691231286807666753972942872019850432610318031627872612657513" - "588188267160616660825719678199868371370527508463011236193719286066916786" - "169956541349011494927225747024994619057884118692213564790598702879596058" - "672338334720925179141906809470606964896245458600635183723159228561689808" - "246141482736625197373238197777325580142168245885279594913851700941789475" - "252421784152262567254611571822468808675893407728003047921107885664474662" - "930921581384003950729114103689170603748380178682003976896397305836815761" - "717676338115866650889936516794601457549097578905329423919798362140648664" - "569177147076571576101649257502509463877402424847669830852345415301684820" - "395813946416649808062227494112874521812750160935760825922220707178083076" - "380203450993589198835885505461509442443773367592842795410339065860781804" - "024975272228687688301824830333940416256885455008512598774611538878683158" - "183931461086893832255176926531299425504132104728730288984598001187854507" - "900417184206801359847651992484444933900133130832052346600926424167009902" - "829803553087005800387704758687923428053612864451456596148162238935900033" - "917094683141205188616000211702577553792389670853917118547527592495253773" - "028135298405566315903922235989614934474805789300370437580494193066066314" - "056627605207631392651010580925826419831250810981343093764403877594495896" - "516881097415880926429607388979497471571321217205535961262051641426436441" - "668989765107456413733909427384182109285933511623871034309722437967253289" - "084018145083721513211807496392673952789642893241520398827805325610653506" - "029060153153064455898648607959013571280930834475689835845791849456112104" - "462337569019001580859906425911782967213265389744605395555069797947978230" - "708108432086217134763779632408473684293543722127232658767439906910370146" - "716836295909075482355827087389127370874842532825987593970846704144140471" - "956027276735614286138656432085771988513977140957180090146798065497158947" - "229765733489703157617307078835099906185890777007500964162371428641176460" - "739074789794941408428328217107759915202650066155868439585510978709442590" - "231934194956788626761834746430104077432547436359522462253411168467463134" - "24896.000000"); -*/ - /* - written = LIBC_NAMESPACE::sprintf(buff, "%La", 0.1L); - #if defined(LIBC_LONG_DOUBLE_IS_X86_FLOAT80) - ASSERT_STREQ_LEN(written, buff, "0xc.ccccccccccccccdp-7"); - #elif defined(LIBC_LONG_DOUBLE_IS_FLOAT64) - ASSERT_STREQ_LEN(written, buff, "0x1.999999999999ap-4"); - #else // 128 bit long double - ASSERT_STREQ_LEN(written, buff, "0x1.999999999999999999999999999ap-4"); - #endif - - written = LIBC_NAMESPACE::sprintf(buff, "%La", 1.0e1000L); - #if defined(LIBC_LONG_DOUBLE_IS_X86_FLOAT80) - ASSERT_STREQ_LEN(written, buff, "0xf.38db1f9dd3dac05p+3318"); - #elif defined(LIBC_LONG_DOUBLE_IS_FLOAT64) - ASSERT_STREQ_LEN(written, buff, "inf"); - #else // 128 bit long double - ASSERT_STREQ_LEN(written, buff, "0x1.e71b63f3ba7b580af1a52d2a7379p+3321"); - #endif - - written = LIBC_NAMESPACE::sprintf(buff, "%La", 1.0e-1000L); - #if defined(LIBC_LONG_DOUBLE_IS_X86_FLOAT80) - ASSERT_STREQ_LEN(written, buff, "0x8.68a9188a89e1467p-3325"); - #elif defined(LIBC_LONG_DOUBLE_IS_FLOAT64) - ASSERT_STREQ_LEN(written, buff, "0x0p+0"); - #else // 128 bit long double - ASSERT_STREQ_LEN(written, buff, "0x1.0d152311513c28ce202627c06ec2p-3322"); - #endif - */ - // Min Width Tests. written = LIBC_NAMESPACE::sprintf(buff, "%15e", 1.0); @@ -2449,109 +2312,33 @@ TEST_F(LlvmLibcSPrintfTest, FloatExponentConv) { written = LIBC_NAMESPACE::sprintf(buff, "%25.13e", 9999999999999.99); ASSERT_STREQ_LEN(written, buff, " 1.0000000000000e+13"); - written = LIBC_NAMESPACE::sprintf(buff, "%25.12e", 9999999999999.99); - ASSERT_STREQ_LEN(written, buff, " 1.000000000000e+13"); - - written = LIBC_NAMESPACE::sprintf(buff, "%12.3e %-12.3e", 0.1, 256.0); - ASSERT_STREQ_LEN(written, buff, " 1.000e-01 2.560e+02 "); - - written = LIBC_NAMESPACE::sprintf(buff, "%+-#12.3e % 012.3e", 0.1256, 1256.0); - ASSERT_STREQ_LEN(written, buff, "+1.256e-01 001.256e+03"); -} - -TEST_F(LlvmLibcSPrintfTest, FloatAutoConv) { - ForceRoundingMode r(RoundingMode::Nearest); - double inf = LIBC_NAMESPACE::fputil::FPBits::inf().get_val(); - double nan = LIBC_NAMESPACE::fputil::FPBits::build_nan( - LIBC_NAMESPACE::fputil::Sign::POS, 1) - .get_val(); - - written = LIBC_NAMESPACE::sprintf(buff, "%g", 1.0); - ASSERT_STREQ_LEN(written, buff, "1"); - - written = LIBC_NAMESPACE::sprintf(buff, "%G", -1.0); - ASSERT_STREQ_LEN(written, buff, "-1"); - - written = LIBC_NAMESPACE::sprintf(buff, "%g", -1.234567); - ASSERT_STREQ_LEN(written, buff, "-1.23457"); - - written = LIBC_NAMESPACE::sprintf(buff, "%g", 0.0); - ASSERT_STREQ_LEN(written, buff, "0"); - - written = LIBC_NAMESPACE::sprintf(buff, "%g", -0.0); - ASSERT_STREQ_LEN(written, buff, "-0"); - - written = LIBC_NAMESPACE::sprintf(buff, "%g", 1.5); - ASSERT_STREQ_LEN(written, buff, "1.5"); - - written = LIBC_NAMESPACE::sprintf(buff, "%g", 1e300); - ASSERT_STREQ_LEN(written, buff, "1e+300"); - - written = LIBC_NAMESPACE::sprintf(buff, "%g", 0.1); - ASSERT_STREQ_LEN(written, buff, "0.1"); - - written = LIBC_NAMESPACE::sprintf(buff, "%g", 0.001); - ASSERT_STREQ_LEN(written, buff, "0.001"); - - written = LIBC_NAMESPACE::sprintf(buff, "%g", 0.00001); - ASSERT_STREQ_LEN(written, buff, "1e-05"); - - written = LIBC_NAMESPACE::sprintf(buff, "%g", 0.0000001); - ASSERT_STREQ_LEN(written, buff, "1e-07"); - - written = LIBC_NAMESPACE::sprintf(buff, "%g", 0.000000001); - ASSERT_STREQ_LEN(written, buff, "1e-09"); - - written = LIBC_NAMESPACE::sprintf(buff, "%g", 1.0e-20); - ASSERT_STREQ_LEN(written, buff, "1e-20"); - - written = LIBC_NAMESPACE::sprintf(buff, "%g", 1234567890123456789.0); - ASSERT_STREQ_LEN(written, buff, "1.23457e+18"); - - written = LIBC_NAMESPACE::sprintf(buff, "%g", 9999990000000.00); - ASSERT_STREQ_LEN(written, buff, "9.99999e+12"); - - written = LIBC_NAMESPACE::sprintf(buff, "%g", 9999999000000.00); - ASSERT_STREQ_LEN(written, buff, "1e+13"); - - written = LIBC_NAMESPACE::sprintf(buff, "%g", 0xa.aaaaaaaaaaaaaabp-7); - ASSERT_STREQ_LEN(written, buff, "0.0833333"); - - // Simple Subnormal Tests. - - written = LIBC_NAMESPACE::sprintf(buff, "%g", 0x1.0p-1027); - ASSERT_STREQ_LEN(written, buff, "6.95336e-310"); - - written = LIBC_NAMESPACE::sprintf(buff, "%g", 0x1.0p-1074); - ASSERT_STREQ_LEN(written, buff, "4.94066e-324"); - - // Inf/Nan Tests. - - written = LIBC_NAMESPACE::sprintf(buff, "%g", inf); - ASSERT_STREQ_LEN(written, buff, "inf"); - - written = LIBC_NAMESPACE::sprintf(buff, "%G", -inf); - ASSERT_STREQ_LEN(written, buff, "-INF"); + written = LIBC_NAMESPACE::sprintf(buff, "%25.12e", 9999999999999.99); + ASSERT_STREQ_LEN(written, buff, " 1.000000000000e+13"); - written = LIBC_NAMESPACE::sprintf(buff, "%g", nan); - ASSERT_STREQ_LEN(written, buff, "nan"); + written = LIBC_NAMESPACE::sprintf(buff, "%12.3e %-12.3e", 0.1, 256.0); + ASSERT_STREQ_LEN(written, buff, " 1.000e-01 2.560e+02 "); - written = LIBC_NAMESPACE::sprintf(buff, "%G", -nan); - ASSERT_STREQ_LEN(written, buff, "-NAN"); + written = LIBC_NAMESPACE::sprintf(buff, "%+-#12.3e % 012.3e", 0.1256, 1256.0); + ASSERT_STREQ_LEN(written, buff, "+1.256e-01 001.256e+03"); +} +TEST_F(LlvmLibcSPrintfTest, FloatExponentLongDoubleConv) { + ForceRoundingMode r(RoundingMode::Nearest); // Length Modifier Tests. #if defined(LIBC_LONG_DOUBLE_IS_X86_FLOAT80) + written = LIBC_NAMESPACE::sprintf(buff, "%.9Le", 1000000000500000000.1L); + ASSERT_STREQ_LEN(written, buff, "1.000000001e+18"); - written = LIBC_NAMESPACE::sprintf(buff, "%Lg", 0xf.fffffffffffffffp+16380L); - ASSERT_STREQ_LEN(written, buff, "1.18973e+4932"); - - written = LIBC_NAMESPACE::sprintf(buff, "%Lg", 0xa.aaaaaaaaaaaaaabp-7L); - ASSERT_STREQ_LEN(written, buff, "0.0833333"); + written = LIBC_NAMESPACE::sprintf(buff, "%.9Le", 1000000000500000000.0L); + ASSERT_STREQ_LEN(written, buff, "1.000000000e+18"); -#endif // LIBC_LONG_DOUBLE_IS_X86_FLOAT80 + written = LIBC_NAMESPACE::sprintf(buff, "%Le", 0xf.fffffffffffffffp+16380L); + ASSERT_STREQ_LEN(written, buff, "1.189731e+4932"); +#endif - // TODO: Uncomment the below tests after long double support is added + // TODO: Fix long doubles (needs bigger table or alternate algorithm.) + // Currently the table values are generated, which is very slow. /* written = LIBC_NAMESPACE::sprintf(buff, "%Lf", 1e100L); ASSERT_STREQ_LEN(written, buff, @@ -2682,6 +2469,87 @@ TEST_F(LlvmLibcSPrintfTest, FloatAutoConv) { ASSERT_STREQ_LEN(written, buff, "0x1.0d152311513c28ce202627c06ec2p-3322"); #endif */ +} + +TEST_F(LlvmLibcSPrintfTest, FloatAutoConv) { + ForceRoundingMode r(RoundingMode::Nearest); + double inf = LIBC_NAMESPACE::fputil::FPBits::inf().get_val(); + double nan = LIBC_NAMESPACE::fputil::FPBits::build_nan( + LIBC_NAMESPACE::fputil::Sign::POS, 1) + .get_val(); + + written = LIBC_NAMESPACE::sprintf(buff, "%g", 1.0); + ASSERT_STREQ_LEN(written, buff, "1"); + + written = LIBC_NAMESPACE::sprintf(buff, "%G", -1.0); + ASSERT_STREQ_LEN(written, buff, "-1"); + + written = LIBC_NAMESPACE::sprintf(buff, "%g", -1.234567); + ASSERT_STREQ_LEN(written, buff, "-1.23457"); + + written = LIBC_NAMESPACE::sprintf(buff, "%g", 0.0); + ASSERT_STREQ_LEN(written, buff, "0"); + + written = LIBC_NAMESPACE::sprintf(buff, "%g", -0.0); + ASSERT_STREQ_LEN(written, buff, "-0"); + + written = LIBC_NAMESPACE::sprintf(buff, "%g", 1.5); + ASSERT_STREQ_LEN(written, buff, "1.5"); + + written = LIBC_NAMESPACE::sprintf(buff, "%g", 1e300); + ASSERT_STREQ_LEN(written, buff, "1e+300"); + + written = LIBC_NAMESPACE::sprintf(buff, "%g", 0.1); + ASSERT_STREQ_LEN(written, buff, "0.1"); + + written = LIBC_NAMESPACE::sprintf(buff, "%g", 0.001); + ASSERT_STREQ_LEN(written, buff, "0.001"); + + written = LIBC_NAMESPACE::sprintf(buff, "%g", 0.00001); + ASSERT_STREQ_LEN(written, buff, "1e-05"); + + written = LIBC_NAMESPACE::sprintf(buff, "%g", 0.0000001); + ASSERT_STREQ_LEN(written, buff, "1e-07"); + + written = LIBC_NAMESPACE::sprintf(buff, "%g", 0.000000001); + ASSERT_STREQ_LEN(written, buff, "1e-09"); + + written = LIBC_NAMESPACE::sprintf(buff, "%g", 1.0e-20); + ASSERT_STREQ_LEN(written, buff, "1e-20"); + + written = LIBC_NAMESPACE::sprintf(buff, "%g", 1234567890123456789.0); + ASSERT_STREQ_LEN(written, buff, "1.23457e+18"); + + written = LIBC_NAMESPACE::sprintf(buff, "%g", 9999990000000.00); + ASSERT_STREQ_LEN(written, buff, "9.99999e+12"); + + written = LIBC_NAMESPACE::sprintf(buff, "%g", 9999999000000.00); + ASSERT_STREQ_LEN(written, buff, "1e+13"); + + written = LIBC_NAMESPACE::sprintf(buff, "%g", 0xa.aaaaaaaaaaaaaabp-7); + ASSERT_STREQ_LEN(written, buff, "0.0833333"); + + // Simple Subnormal Tests. + + written = LIBC_NAMESPACE::sprintf(buff, "%g", 0x1.0p-1027); + ASSERT_STREQ_LEN(written, buff, "6.95336e-310"); + + written = LIBC_NAMESPACE::sprintf(buff, "%g", 0x1.0p-1074); + ASSERT_STREQ_LEN(written, buff, "4.94066e-324"); + + // Inf/Nan Tests. + + written = LIBC_NAMESPACE::sprintf(buff, "%g", inf); + ASSERT_STREQ_LEN(written, buff, "inf"); + + written = LIBC_NAMESPACE::sprintf(buff, "%G", -inf); + ASSERT_STREQ_LEN(written, buff, "-INF"); + + written = LIBC_NAMESPACE::sprintf(buff, "%g", nan); + ASSERT_STREQ_LEN(written, buff, "nan"); + + written = LIBC_NAMESPACE::sprintf(buff, "%G", -nan); + ASSERT_STREQ_LEN(written, buff, "-NAN"); // Min Width Tests. @@ -3113,6 +2981,154 @@ TEST_F(LlvmLibcSPrintfTest, FloatAutoConv) { ASSERT_STREQ_LEN(written, buff, "+0.126 0001.26e+03"); } +TEST_F(LlvmLibcSPrintfTest, FloatAutoLongDoubleConv) { + ForceRoundingMode r(RoundingMode::Nearest); + + // Length Modifier Tests. + +#if defined(LIBC_LONG_DOUBLE_IS_X86_FLOAT80) + + written = LIBC_NAMESPACE::sprintf(buff, "%Lg", 0xf.fffffffffffffffp+16380L); + ASSERT_STREQ_LEN(written, buff, "1.18973e+4932"); + + written = LIBC_NAMESPACE::sprintf(buff, "%Lg", 0xa.aaaaaaaaaaaaaabp-7L); + ASSERT_STREQ_LEN(written, buff, "0.0833333"); + +#endif // LIBC_LONG_DOUBLE_IS_X86_FLOAT80 + + // TODO: Uncomment the below tests after long double support is added + /* + written = LIBC_NAMESPACE::sprintf(buff, "%Lf", 1e100L); + ASSERT_STREQ_LEN(written, buff, + "99999999999999999996693535322073426194986990198284960792713" + "91541752018669482644324418977840117055488.000000"); + + written = LIBC_NAMESPACE::sprintf(buff, "%Lf", 1.0L); + ASSERT_STREQ_LEN(written, buff, "1.000000"); + + char big_buff[10000]; + written = LIBC_NAMESPACE::sprintf(big_buff, "%Lf", 1e1000L); + ASSERT_STREQ_LEN( + written, big_buff, + "999999999999999999973107317669562353428234857594552594925899449376328728" + "202461036775511405481186963193066642191664822065529414252060696836533522" + "387143501724276282079456797058697369889056407118642873669166717313763499" + "277025985141177344925615052465165938514140943010597323750202561187880136" + "174810574553749194614479541820148407958204853833697063267336294787191005" + "628217462261955103745349844675732989944229689277833828743730290177882029" + "042613704915899149603539993716885598351951895974316347947147507970269673" + "097709017164643598452451201499004104341931127294141495501309305995449742" + "273419524803597130450457553871345958049837885085168840317195672271085085" + "950520957945970913451088104971436093671776829538796532762184174216651692" + "640931965387852083906784898823494867055070322768919156031682291829761007" + "101483799978382119231551218582499361996919560548090784230386907125151658" + "086767207295524036170321059257942621398084478974000973622199163292708506" + "2431457550909271560663602154947063707982236377366647567795879936." + "000000"); + + written = LIBC_NAMESPACE::sprintf(big_buff, "%Lf", 1e4900L); + ASSERT_STREQ_LEN( + written, big_buff, + "100000000000000000002708312230690349833224052504078834346502930111959028" + "517260692666637048230414374897655201843766090626319971729765251179632020" + "313912652522792711197087872698264530532442630109549129842736280196919130" + "242615101228133188193853826983121366159061148351354364472807590931218045" + "387490935930967150336231085015126034696883068553581691802388371635128003" + "615577299166097675723780877126495909902479233742826339471026068806070433" + "075629449530819183550315434973800271862658869400009022028602967197463980" + "126881829804282202449930132940824361207087494829502385835258094836304011" + "876250359661206802659650567866176246063987902366800491980400341950657151" + "370854446585517805253310195469184699955519312761482572080479702840420595" + "377369017651259376039167277822106875560385309101650382998482652792335482" + "865443482342801545877390859444282105890147577937366066315975231014810320" + "888482059656248277607763361589359794524314002443575149260630989130103550" + "443177966380769341050735632338583912575890190136462629316287947355057647" + "111088565611192544631519843618778618820046304429723908484879583579178075" + "456701368334212923379389029311286386996015804122917416008806233549005183" + "152461084266176543129004016414959261473645240454289630182591200574019087" + "358223489767381636349719510715487188747217311279465814538495924567014916" + "238565628036285599497236493491668884212847699052761266207598941300449276" + "447201387520841811835583254242213093566548778954711633721122784159793843" + "766802019309395771984693609426401362800013936338891483689127845928572536" + "790651156184721483511507878883282891696900630100211914227950790472211403" + "392549466062537498185758854079775888444518306635752468713312357556380082" + "275500658967283696421824354930077523691855699312544373220921962817907078" + "445538421941800259027487429330768616490865438859612697367766323925013940" + "918384858952407145253573823848733994146335416209309233074165707437420756" + "438833918763109580759409985573826485055208965115587885226774453455112406" + "581351429640282227888764449360534584421929291565334894907337572527922691" + "473242328379737396430908523008687037407295838014450772162091496534584696" + "605157436893236842602956298545594095307060870397506421786236892553632163" + "491468601982681381011940409602294892199042638682530687578982576819839451" + "907594697546439533559153604700750696252355362322662219852740143212566818" + "745528402265116534684566273868361460640280523251242059850044328669692159" + "629900374576027104298177006629276014371540945261309319363704125592775129" + "543526908667388673739382491147471395192495459318806593271282662311169392" + "196897003517840025298267505925987901751541005546610016067658227181318892" + "914686508281007582655667597441346214499847364272258631922040641860333431" + "409838623713258383681350233064164940590695888300919626215847587544298023" + "636416943680102708406086295669759876682046839368574433996997648445207805" + "615784339667691231286807666753972942872019850432610318031627872612657513" + "588188267160616660825719678199868371370527508463011236193719286066916786" + "169956541349011494927225747024994619057884118692213564790598702879596058" + "672338334720925179141906809470606964896245458600635183723159228561689808" + "246141482736625197373238197777325580142168245885279594913851700941789475" + "252421784152262567254611571822468808675893407728003047921107885664474662" + "930921581384003950729114103689170603748380178682003976896397305836815761" + "717676338115866650889936516794601457549097578905329423919798362140648664" + "569177147076571576101649257502509463877402424847669830852345415301684820" + "395813946416649808062227494112874521812750160935760825922220707178083076" + "380203450993589198835885505461509442443773367592842795410339065860781804" + "024975272228687688301824830333940416256885455008512598774611538878683158" + "183931461086893832255176926531299425504132104728730288984598001187854507" + "900417184206801359847651992484444933900133130832052346600926424167009902" + "829803553087005800387704758687923428053612864451456596148162238935900033" + "917094683141205188616000211702577553792389670853917118547527592495253773" + "028135298405566315903922235989614934474805789300370437580494193066066314" + "056627605207631392651010580925826419831250810981343093764403877594495896" + "516881097415880926429607388979497471571321217205535961262051641426436441" + "668989765107456413733909427384182109285933511623871034309722437967253289" + "084018145083721513211807496392673952789642893241520398827805325610653506" + "029060153153064455898648607959013571280930834475689835845791849456112104" + "462337569019001580859906425911782967213265389744605395555069797947978230" + "708108432086217134763779632408473684293543722127232658767439906910370146" + "716836295909075482355827087389127370874842532825987593970846704144140471" + "956027276735614286138656432085771988513977140957180090146798065497158947" + "229765733489703157617307078835099906185890777007500964162371428641176460" + "739074789794941408428328217107759915202650066155868439585510978709442590" + "231934194956788626761834746430104077432547436359522462253411168467463134" + "24896.000000"); +*/ + /* + written = LIBC_NAMESPACE::sprintf(buff, "%La", 0.1L); + #if defined(LIBC_LONG_DOUBLE_IS_X86_FLOAT80) + ASSERT_STREQ_LEN(written, buff, "0xc.ccccccccccccccdp-7"); + #elif defined(LIBC_LONG_DOUBLE_IS_FLOAT64) + ASSERT_STREQ_LEN(written, buff, "0x1.999999999999ap-4"); + #else // 128 bit long double + ASSERT_STREQ_LEN(written, buff, "0x1.999999999999999999999999999ap-4"); + #endif + + written = LIBC_NAMESPACE::sprintf(buff, "%La", 1.0e1000L); + #if defined(LIBC_LONG_DOUBLE_IS_X86_FLOAT80) + ASSERT_STREQ_LEN(written, buff, "0xf.38db1f9dd3dac05p+3318"); + #elif defined(LIBC_LONG_DOUBLE_IS_FLOAT64) + ASSERT_STREQ_LEN(written, buff, "inf"); + #else // 128 bit long double + ASSERT_STREQ_LEN(written, buff, "0x1.e71b63f3ba7b580af1a52d2a7379p+3321"); + #endif + + written = LIBC_NAMESPACE::sprintf(buff, "%La", 1.0e-1000L); + #if defined(LIBC_LONG_DOUBLE_IS_X86_FLOAT80) + ASSERT_STREQ_LEN(written, buff, "0x8.68a9188a89e1467p-3325"); + #elif defined(LIBC_LONG_DOUBLE_IS_FLOAT64) + ASSERT_STREQ_LEN(written, buff, "0x0p+0"); + #else // 128 bit long double + ASSERT_STREQ_LEN(written, buff, "0x1.0d152311513c28ce202627c06ec2p-3322"); + #endif + */ +} + #endif // LIBC_COPT_PRINTF_DISABLE_FLOAT #ifndef LIBC_COPT_PRINTF_DISABLE_WRITE_INT From cab9c7775a2e6a645886f7713e2148f2c673173c Mon Sep 17 00:00:00 2001 From: Michael Jones Date: Tue, 2 Jan 2024 11:34:54 -0800 Subject: [PATCH 05/12] address more comments --- libc/src/__support/UInt.h | 5 +++++ libc/src/__support/float_to_string.h | 16 ++++++++++------ libc/test/src/stdio/sprintf_test.cpp | 3 +++ 3 files changed, 18 insertions(+), 6 deletions(-) diff --git a/libc/src/__support/UInt.h b/libc/src/__support/UInt.h index 537c19df73f68..215bb214c6d0a 100644 --- a/libc/src/__support/UInt.h +++ b/libc/src/__support/UInt.h @@ -27,6 +27,11 @@ namespace LIBC_NAMESPACE::cpp { template struct BigInt { + // This being hardcoded as 64 is okay because we're using uint64_t as our + // internal type which will always be 64 bits. + LIBC_INLINE_VAR static constexpr size_t WORD_SIZE = 64; + + // TODO: Replace references to 64 with WORD_SIZE. static_assert(Bits > 0 && Bits % 64 == 0, "Number of bits in BigInt should be a multiple of 64."); LIBC_INLINE_VAR static constexpr size_t WORDCOUNT = Bits / 64; diff --git a/libc/src/__support/float_to_string.h b/libc/src/__support/float_to_string.h index 75cf53dbb1295..2f8a541ad48f1 100644 --- a/libc/src/__support/float_to_string.h +++ b/libc/src/__support/float_to_string.h @@ -668,8 +668,8 @@ template <> class FloatToString { LIBC_INLINE static constexpr void zero_leading_digits( cpp::UInt &int_num) { // 64 is the width of the numbers used to internally represent the UInt - for (size_t i = 0; i < EXTRA_INT_WIDTH / 64; ++i) { - int_num[i + (FLOAT_AS_INT_WIDTH / 64)] = 0; + for (size_t i = 0; i < EXTRA_INT_WIDTH / int_num.WORD_SIZE; ++i) { + int_num[i + (FLOAT_AS_INT_WIDTH / int_num.WORD_SIZE)] = 0; } } @@ -807,10 +807,14 @@ template <> class FloatToString { // If we're currently after the requested block (remember these are // negative indices) we reset the number to the start. This is only // likely to happen in %g calls. This will also reset int_block_index. - if (block_index > int_block_index) { - init_convert(); - } - + // if (block_index > int_block_index) { + // init_convert(); + // } + + // Printf is the only existing user of this code and it will only ever move + // downwards, except for %g but that currently creates a second + // float_to_string object so this assertion still holds. If a new user needs + // the ability to step backwards, uncomment the code above. LIBC_ASSERT(block_index <= int_block_index); // If we are currently before the requested block. Step until we reach the diff --git a/libc/test/src/stdio/sprintf_test.cpp b/libc/test/src/stdio/sprintf_test.cpp index 4f867d7ce4f30..8aef8311846d4 100644 --- a/libc/test/src/stdio/sprintf_test.cpp +++ b/libc/test/src/stdio/sprintf_test.cpp @@ -2994,6 +2994,9 @@ TEST_F(LlvmLibcSPrintfTest, FloatAutoLongDoubleConv) { written = LIBC_NAMESPACE::sprintf(buff, "%Lg", 0xa.aaaaaaaaaaaaaabp-7L); ASSERT_STREQ_LEN(written, buff, "0.0833333"); + written = LIBC_NAMESPACE::sprintf(buff, "%Lg", 9.99999999999e-100L); + ASSERT_STREQ_LEN(written, buff, "1e-99"); + #endif // LIBC_LONG_DOUBLE_IS_X86_FLOAT80 // TODO: Uncomment the below tests after long double support is added From 75469ace72f1fb1210c902bb664b1fa8db4e7961 Mon Sep 17 00:00:00 2001 From: Michael Jones Date: Wed, 3 Jan 2024 16:25:10 -0800 Subject: [PATCH 06/12] reorganize and comment to clarify design --- libc/src/__support/float_to_string.h | 43 +++++++++++++++++----------- 1 file changed, 26 insertions(+), 17 deletions(-) diff --git a/libc/src/__support/float_to_string.h b/libc/src/__support/float_to_string.h index 2f8a541ad48f1..97b6923de5a72 100644 --- a/libc/src/__support/float_to_string.h +++ b/libc/src/__support/float_to_string.h @@ -646,7 +646,10 @@ template <> class FloatToString { static constexpr size_t EXTRA_INT_WIDTH = internal::div_ceil(sizeof(long double) * 8, 64) * 64; - cpp::UInt float_as_int = 0; + // 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 + // store any number with a negative exponent. + cpp::UInt float_as_fixed = 0; int int_block_index = 0; static constexpr size_t BLOCK_BUFFER_LEN = @@ -673,11 +676,10 @@ template <> class FloatToString { } } + // init_convert initializes float_as_int, cur_block, and block_buffer based on + // the mantissa and exponent of the initial number. Calling it will always + // return the class to the starting state. LIBC_INLINE constexpr void init_convert() { - // This initializes float_as_int, cur_block, and block_buffer. - - float_as_int = mantissa; - // No calculation necessary for the 0 case. if (mantissa == 0 && exponent == 0) { return; @@ -685,8 +687,14 @@ template <> class FloatToString { if (exponent > 0) { // if the exponent is positive, then the number is fully above the decimal - // point. Shift left by exponent to get the integer representation of this - // number. + // point. In this case we represent the float as an integer, then divide + // by 10^BLOCK_SIZE and take the remainder as our next block. This + // generates the digits from right to left, but the digits will be written + // from left to right, so it caches the results so they can be read in + // reverse order. + + cpp::UInt float_as_int = mantissa; + float_as_int.shift_left(exponent); int_block_index = 0; @@ -699,17 +707,18 @@ template <> class FloatToString { } else { // if the exponent is not positive, then the number is at least partially - // below the decimal point. Shift left to make the int a fixed point - // representation with the decimal point after the top EXTRA_INT_WIDTH - // bits. + // below the decimal point. In this case we represent the float as a fixed + // point number with the decimal point after the top EXTRA_INT_WIDTH bits. + float_as_fixed = mantissa; + const int SHIFT_AMOUNT = FLOAT_AS_INT_WIDTH + exponent; static_assert(EXTRA_INT_WIDTH >= sizeof(long double) * 8); - float_as_int.shift_left(SHIFT_AMOUNT); + float_as_fixed.shift_left(SHIFT_AMOUNT); // If there are still digits above the decimal point, handle those. - if (float_as_int.clz() < EXTRA_INT_WIDTH) { + if (float_as_fixed.clz() < EXTRA_INT_WIDTH) { cpp::UInt above_decimal_point = - float_as_int >> FLOAT_AS_INT_WIDTH; + float_as_fixed >> FLOAT_AS_INT_WIDTH; size_t positive_int_block_index = 0; while (above_decimal_point > 0) { @@ -720,7 +729,7 @@ template <> class FloatToString { block_buffer_valid = positive_int_block_index; // Zero all digits above the decimal point. - zero_leading_digits(float_as_int); + zero_leading_digits(float_as_fixed); int_block_index = 0; } } @@ -820,14 +829,14 @@ template <> class FloatToString { // If we are currently before the requested block. Step until we reach the // requested block. This is likely to only be one step. while (block_index < int_block_index) { - zero_leading_digits(float_as_int); - float_as_int.mul(1000000000); + zero_leading_digits(float_as_fixed); + float_as_fixed.mul(1000000000); --int_block_index; } // We're currently on the requested block, return the current block. BlockInt cur_block = - static_cast(float_as_int >> FLOAT_AS_INT_WIDTH); + static_cast(float_as_fixed >> FLOAT_AS_INT_WIDTH); return cur_block; } From 187c90bede75b491f9ee2e079c1b8cf21c0804bd Mon Sep 17 00:00:00 2001 From: Michael Jones Date: Fri, 5 Jan 2024 14:01:37 -0800 Subject: [PATCH 07/12] clean up code style --- libc/src/__support/float_to_string.h | 81 ++++++++++++---------------- 1 file changed, 33 insertions(+), 48 deletions(-) diff --git a/libc/src/__support/float_to_string.h b/libc/src/__support/float_to_string.h index 97b6923de5a72..8ce37786dd111 100644 --- a/libc/src/__support/float_to_string.h +++ b/libc/src/__support/float_to_string.h @@ -615,8 +615,7 @@ class FloatToString { internal::ceil_log10_pow2(FRACTION_LEN + 1)) / BLOCK_SIZE) - 1; - const uint32_t len = static_cast(pos_len > 0 ? pos_len : 0); - return len; + return len = static_cast(pos_len > 0 ? pos_len : 0); } return 0; #else @@ -659,18 +658,17 @@ template <> class FloatToString { template LIBC_INLINE static constexpr BlockInt grab_digits(cpp::UInt &int_num) { - BlockInt cur_block = 0; auto wide_result = int_num.div_uint32_times_pow_2(1953125, 9); // the optional only comes into effect when dividing by 0, which will // never happen here. Thus, we just assert that it has value. LIBC_ASSERT(wide_result.has_value()); - cur_block = static_cast(wide_result.value()); - return cur_block; + return static_cast(wide_result.value()); } LIBC_INLINE static constexpr void zero_leading_digits( cpp::UInt &int_num) { - // 64 is the width of the numbers used to internally represent the UInt + // WORD_SIZE is the width of the numbers used to internally represent the + // UInt for (size_t i = 0; i < EXTRA_INT_WIDTH / int_num.WORD_SIZE; ++i) { int_num[i + (FLOAT_AS_INT_WIDTH / int_num.WORD_SIZE)] = 0; } @@ -681,9 +679,8 @@ template <> class FloatToString { // return the class to the starting state. LIBC_INLINE constexpr void init_convert() { // No calculation necessary for the 0 case. - if (mantissa == 0 && exponent == 0) { + if (mantissa == 0 && exponent == 0) return; - } if (exponent > 0) { // if the exponent is positive, then the number is fully above the decimal @@ -699,8 +696,7 @@ template <> class FloatToString { int_block_index = 0; while (float_as_int > 0) { - BlockInt cur_block = grab_digits(float_as_int); - block_buffer[int_block_index] = cur_block; + block_buffer[int_block_index] = grab_digits(float_as_int); ++int_block_index; } block_buffer_valid = int_block_index; @@ -722,8 +718,8 @@ template <> class FloatToString { size_t positive_int_block_index = 0; while (above_decimal_point > 0) { - BlockInt cur_block = grab_digits(above_decimal_point); - block_buffer[positive_int_block_index] = cur_block; + block_buffer[positive_int_block_index] = + grab_digits(above_decimal_point); ++positive_int_block_index; } block_buffer_valid = positive_int_block_index; @@ -749,36 +745,31 @@ template <> class FloatToString { } LIBC_INLINE constexpr size_t get_positive_blocks() { - if (exponent >= -FRACTION_LEN) { - const uint32_t idx = - exponent < 0 - ? 0 - : static_cast(exponent + (IDX_SIZE - 1)) / IDX_SIZE; - const uint32_t len = - internal::length_for_num(idx * IDX_SIZE, FRACTION_LEN); - return len; - } else { + if (exponent < -FRACTION_LEN) return 0; - } + + const uint32_t idx = + exponent < 0 + ? 0 + : static_cast(exponent + (IDX_SIZE - 1)) / IDX_SIZE; + return internal::length_for_num(idx * IDX_SIZE, FRACTION_LEN); } LIBC_INLINE constexpr size_t zero_blocks_after_point() { #ifdef LIBC_COPT_FLOAT_TO_STR_USE_MEGA_LONG_DOUBLE_TABLE return MIN_BLOCK_2[-exponent / IDX_SIZE]; #else - if (exponent < -FRACTION_LEN) { - const int pos_exp = -exponent - 1; - const uint32_t pos_idx = - static_cast(pos_exp + (IDX_SIZE - 1)) / IDX_SIZE; - const int32_t pos_len = ((internal::ceil_log10_pow2(pos_idx * IDX_SIZE) - - internal::ceil_log10_pow2(FRACTION_LEN + 1)) / - BLOCK_SIZE) - - 1; - const uint32_t len = static_cast(pos_len > 0 ? pos_len : 0); - return len; - } - return 0; + if (exponent >= -FRACTION_LEN) + return 0; + const int pos_exp = -exponent - 1; + const uint32_t pos_idx = + static_cast(pos_exp + (IDX_SIZE - 1)) / IDX_SIZE; + const int32_t pos_len = ((internal::ceil_log10_pow2(pos_idx * IDX_SIZE) - + internal::ceil_log10_pow2(FRACTION_LEN + 1)) / + BLOCK_SIZE) - + 1; + return static_cast(pos_len > 0 ? pos_len : 0); #endif } @@ -792,20 +783,17 @@ template <> class FloatToString { } LIBC_INLINE constexpr BlockInt get_positive_block(int block_index) { - if (exponent < -FRACTION_LEN) { + if (exponent < -FRACTION_LEN) return 0; - } - if (block_index > static_cast(block_buffer_valid) || block_index < 0) { + if (block_index > static_cast(block_buffer_valid) || block_index < 0) return 0; - } return block_buffer[block_index]; } LIBC_INLINE constexpr BlockInt get_negative_block(int negative_block_index) { - if (exponent >= 0) { + if (exponent >= 0) return 0; - } // negative_block_index starts at 0 with the first block after the decimal // point, and 1 with the second and so on. This converts to the same @@ -834,18 +822,15 @@ template <> class FloatToString { --int_block_index; } - // We're currently on the requested block, return the current block. - BlockInt cur_block = - static_cast(float_as_fixed >> FLOAT_AS_INT_WIDTH); - return cur_block; + // We're now on the requested block, return the current block. + return static_cast(float_as_fixed >> FLOAT_AS_INT_WIDTH); } LIBC_INLINE constexpr BlockInt get_block(int block_index) { - if (block_index >= 0) { + if (block_index >= 0) return get_positive_block(block_index); - } else { - return get_negative_block(-1 - block_index); - } + + return get_negative_block(-1 - block_index); } }; From 8ec9f26cc2518096ea9a6d8ed801d785363364f8 Mon Sep 17 00:00:00 2001 From: Michael Jones Date: Mon, 8 Jan 2024 15:25:07 -0800 Subject: [PATCH 08/12] Rebase and update docs --- libc/docs/dev/printf_behavior.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libc/docs/dev/printf_behavior.rst b/libc/docs/dev/printf_behavior.rst index ef81fd63c8f30..bc60aa43ee2b6 100644 --- a/libc/docs/dev/printf_behavior.rst +++ b/libc/docs/dev/printf_behavior.rst @@ -13,7 +13,7 @@ C standard and POSIX standard. If any behavior is not mentioned here, it should be assumed to follow the behavior described in those standards. The LLVM-libc codebase is under active development, and may change. This -document was last updated [August 18, 2023] by [michaelrj] and may +document was last updated [January 8, 2024] by [michaelrj] and may not be accurate after this point. The behavior of LLVM-libc's printf is heavily influenced by compile-time flags. From 746a300f3e12520a6ad87c037cf7415751ff39e3 Mon Sep 17 00:00:00 2001 From: Michael Jones Date: Mon, 8 Jan 2024 15:48:16 -0800 Subject: [PATCH 09/12] move FloatProp to FPBits --- libc/src/__support/float_to_string.h | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/libc/src/__support/float_to_string.h b/libc/src/__support/float_to_string.h index 8ce37786dd111..2b4ffe92f40e7 100644 --- a/libc/src/__support/float_to_string.h +++ b/libc/src/__support/float_to_string.h @@ -13,7 +13,6 @@ #include "src/__support/CPP/type_traits.h" #include "src/__support/FPUtil/FPBits.h" -#include "src/__support/FPUtil/FloatProperties.h" #include "src/__support/FPUtil/dyadic_float.h" #include "src/__support/UInt.h" #include "src/__support/common.h" @@ -632,14 +631,14 @@ template <> class FloatToString { fputil::FPBits float_bits; bool is_negative = 0; int exponent = 0; - FloatProp::StorageType mantissa = 0; + FPBits::StorageType mantissa = 0; static constexpr int FRACTION_LEN = fputil::FPBits::FRACTION_LEN; static constexpr int EXP_BIAS = fputil::FPBits::EXP_BIAS; static constexpr size_t FLOAT_AS_INT_WIDTH = internal::div_ceil(fputil::FPBits::MAX_BIASED_EXPONENT - - FloatProp::EXP_BIAS, + FPBits::EXP_BIAS, 64) * 64; static constexpr size_t EXTRA_INT_WIDTH = From 4e860d7ecc238bf5831079bad875fda680278c6a Mon Sep 17 00:00:00 2001 From: Michael Jones Date: Tue, 9 Jan 2024 10:53:36 -0800 Subject: [PATCH 10/12] fix more nits --- libc/src/__support/float_to_string.h | 25 ++++++++++--------------- 1 file changed, 10 insertions(+), 15 deletions(-) diff --git a/libc/src/__support/float_to_string.h b/libc/src/__support/float_to_string.h index 2b4ffe92f40e7..28e57203c7ef2 100644 --- a/libc/src/__support/float_to_string.h +++ b/libc/src/__support/float_to_string.h @@ -572,17 +572,13 @@ class FloatToString { } LIBC_INLINE constexpr size_t get_positive_blocks() { - if (exponent >= -FRACTION_LEN) { - const uint32_t idx = - exponent < 0 - ? 0 - : static_cast(exponent + (IDX_SIZE - 1)) / IDX_SIZE; - const uint32_t len = - internal::length_for_num(idx * IDX_SIZE, FRACTION_LEN); - return len; - } else { + if (exponent < -FRACTION_LEN) return 0; - } + const uint32_t idx = + exponent < 0 + ? 0 + : static_cast(exponent + (IDX_SIZE - 1)) / IDX_SIZE; + return internal::length_for_num(idx * IDX_SIZE, FRACTION_LEN); } // This takes the index of a block after the decimal point (a negative block) @@ -614,7 +610,7 @@ class FloatToString { internal::ceil_log10_pow2(FRACTION_LEN + 1)) / BLOCK_SIZE) - 1; - return len = static_cast(pos_len > 0 ? pos_len : 0); + return static_cast(pos_len > 0 ? pos_len : 0); } return 0; #else @@ -668,9 +664,8 @@ template <> class FloatToString { cpp::UInt &int_num) { // WORD_SIZE is the width of the numbers used to internally represent the // UInt - for (size_t i = 0; i < EXTRA_INT_WIDTH / int_num.WORD_SIZE; ++i) { + for (size_t i = 0; i < EXTRA_INT_WIDTH / int_num.WORD_SIZE; ++i) int_num[i + (FLOAT_AS_INT_WIDTH / int_num.WORD_SIZE)] = 0; - } } // init_convert initializes float_as_int, cur_block, and block_buffer based on @@ -775,7 +770,7 @@ template <> class FloatToString { LIBC_INLINE constexpr bool is_lowest_block(size_t negative_block_index) { // The decimal representation of 2**(-i) will have exactly i digits after // the decimal point. - int num_requested_digits = + const int num_requested_digits = static_cast((negative_block_index + 1) * BLOCK_SIZE); return num_requested_digits > -exponent; @@ -798,7 +793,7 @@ template <> class FloatToString { // point, and 1 with the second and so on. This converts to the same // block_index used everywhere else. - int block_index = -1 - negative_block_index; + const int block_index = -1 - negative_block_index; // If we're currently after the requested block (remember these are // negative indices) we reset the number to the start. This is only From 2735cfc3e21e951d9dc3964e76ffe3bfb889c195 Mon Sep 17 00:00:00 2001 From: Michael Jones Date: Fri, 19 Jan 2024 10:51:54 -0800 Subject: [PATCH 11/12] cleanup and address comments --- libc/src/__support/UInt.h | 8 ++- libc/src/__support/float_to_string.h | 93 ++++++++++++++-------------- libc/test/src/stdio/sprintf_test.cpp | 57 ----------------- 3 files changed, 53 insertions(+), 105 deletions(-) diff --git a/libc/src/__support/UInt.h b/libc/src/__support/UInt.h index 215bb214c6d0a..7726b6d88f0d2 100644 --- a/libc/src/__support/UInt.h +++ b/libc/src/__support/UInt.h @@ -29,13 +29,15 @@ template struct BigInt { // This being hardcoded as 64 is okay because we're using uint64_t as our // internal type which will always be 64 bits. - LIBC_INLINE_VAR static constexpr size_t WORD_SIZE = 64; + using word_type = uint64_t; + LIBC_INLINE_VAR static constexpr size_t WORD_SIZE = + sizeof(word_type) * CHAR_BIT; - // TODO: Replace references to 64 with WORD_SIZE. + // TODO: Replace references to 64 with WORD_SIZE, and uint64_t with word_type. static_assert(Bits > 0 && Bits % 64 == 0, "Number of bits in BigInt should be a multiple of 64."); LIBC_INLINE_VAR static constexpr size_t WORDCOUNT = Bits / 64; - cpp::array val{}; + cpp::array val{}; LIBC_INLINE_VAR static constexpr uint64_t MASK32 = 0xFFFFFFFFu; diff --git a/libc/src/__support/float_to_string.h b/libc/src/__support/float_to_string.h index 28e57203c7ef2..25fd7ffb1c44a 100644 --- a/libc/src/__support/float_to_string.h +++ b/libc/src/__support/float_to_string.h @@ -11,6 +11,7 @@ #include +#include "src/__support/CPP/limits.h" #include "src/__support/CPP/type_traits.h" #include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/dyadic_float.h" @@ -108,6 +109,8 @@ namespace LIBC_NAMESPACE { using BlockInt = uint32_t; constexpr uint32_t BLOCK_SIZE = 9; +constexpr uint64_t EXP5_9 = 1953125; +constexpr uint64_t EXP10_9 = 1000000000; using FPBits = fputil::FPBits; @@ -118,7 +121,7 @@ constexpr size_t CALC_SHIFT_CONST = 128; namespace internal { // Returns floor(log_10(2^e)); requires 0 <= e <= 42039. -LIBC_INLINE constexpr uint32_t log10_pow2(const uint64_t e) { +LIBC_INLINE constexpr uint32_t log10_pow2(uint64_t e) { LIBC_ASSERT(e <= 42039 && "Incorrect exponent to perform log10_pow2 approximation."); // This approximation is based on the float value for log_10(2). It first @@ -144,7 +147,7 @@ LIBC_INLINE constexpr uint32_t log10_pow2(const uint64_t e) { } // Same as above, but with different constants. -LIBC_INLINE constexpr uint32_t log2_pow5(const uint64_t e) { +LIBC_INLINE constexpr uint32_t log2_pow5(uint64_t e) { return static_cast((e * 0x12934f0979bll) >> 39); } @@ -152,19 +155,18 @@ LIBC_INLINE constexpr uint32_t log2_pow5(const uint64_t e) { // power of 2 was also a power of 10, but since that doesn't exist this is // always accurate. This is used to calculate the maximum number of base-10 // digits a given e-bit number could have. -LIBC_INLINE constexpr uint32_t ceil_log10_pow2(const uint32_t e) { +LIBC_INLINE constexpr uint32_t ceil_log10_pow2(uint32_t e) { return log10_pow2(e) + 1; } -LIBC_INLINE constexpr uint32_t div_ceil(const uint32_t num, - const uint32_t denom) { +LIBC_INLINE constexpr uint32_t div_ceil(uint32_t num, uint32_t denom) { return (num + (denom - 1)) / denom; } // Returns the maximum number of 9 digit blocks a number described by the given // index (which is ceil(exponent/16)) and mantissa width could need. -LIBC_INLINE constexpr uint32_t length_for_num(const uint32_t idx, - const uint32_t mantissa_width) { +LIBC_INLINE constexpr uint32_t length_for_num(uint32_t idx, + uint32_t mantissa_width) { return div_ceil(ceil_log10_pow2(idx) + ceil_log10_pow2(mantissa_width + 1), BLOCK_SIZE); } @@ -194,24 +196,21 @@ LIBC_INLINE constexpr cpp::UInt get_table_positive(int exponent, // 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 MOD_SIZE = - (cpp::UInt(1000000000) + (cpp::UInt(EXP10_9) << (CALC_SHIFT_CONST + (IDX_SIZE > 1 ? IDX_SIZE : 0))); - constexpr uint64_t FIVE_EXP_NINE = 1953125; - num = cpp::UInt(1) << (shift_amount); if (i > 0) { - cpp::UInt fives(FIVE_EXP_NINE); + cpp::UInt fives(EXP5_9); fives.pow_n(i); num = num / fives; } num = num + 1; if (num > MOD_SIZE) { - auto rem = - num.div_uint32_times_pow_2( - 1000000000, CALC_SHIFT_CONST + (IDX_SIZE > 1 ? IDX_SIZE : 0)) - .value(); + auto rem = num.div_uint32_times_pow_2( + EXP10_9, CALC_SHIFT_CONST + (IDX_SIZE > 1 ? IDX_SIZE : 0)) + .value(); num = rem; } return num; @@ -235,7 +234,7 @@ LIBC_INLINE cpp::UInt get_table_positive_df(int exponent, } fputil::DyadicFloat num(false, 0, 1); constexpr cpp::UInt MOD_SIZE = - (cpp::UInt(1000000000) + (cpp::UInt(EXP10_9) << (CALC_SHIFT_CONST + (IDX_SIZE > 1 ? IDX_SIZE : 0))); constexpr cpp::UInt FIVE_EXP_MINUS_NINE_MANT{ @@ -256,8 +255,8 @@ LIBC_INLINE cpp::UInt get_table_positive_df(int exponent, if (int_num > MOD_SIZE) { auto rem = int_num - .div_uint32_times_pow_2( - 1000000000, CALC_SHIFT_CONST + (IDX_SIZE > 1 ? IDX_SIZE : 0)) + .div_uint32_times_pow_2(EXP10_9, CALC_SHIFT_CONST + + (IDX_SIZE > 1 ? IDX_SIZE : 0)) .value(); int_num = rem; } @@ -280,11 +279,9 @@ LIBC_INLINE cpp::UInt get_table_negative(int exponent, size_t i) { int shift_amount = CALC_SHIFT_CONST - exponent; cpp::UInt num(1); constexpr cpp::UInt MOD_SIZE = - (cpp::UInt(1000000000) + (cpp::UInt(EXP10_9) << (CALC_SHIFT_CONST + (IDX_SIZE > 1 ? IDX_SIZE : 0))); - constexpr uint64_t TEN_EXP_NINE = 1000000000; - constexpr uint64_t FIVE_EXP_NINE = 1953125; size_t ten_blocks = i; size_t five_blocks = 0; if (shift_amount < 0) { @@ -301,12 +298,12 @@ LIBC_INLINE cpp::UInt get_table_negative(int exponent, size_t i) { } if (five_blocks > 0) { - cpp::UInt fives(FIVE_EXP_NINE); + cpp::UInt fives(EXP5_9); fives.pow_n(five_blocks); num = fives; } if (ten_blocks > 0) { - cpp::UInt tens(TEN_EXP_NINE); + cpp::UInt tens(EXP10_9); tens.pow_n(ten_blocks); if (five_blocks <= 0) { num = tens; @@ -321,10 +318,9 @@ LIBC_INLINE cpp::UInt get_table_negative(int exponent, size_t i) { num = num >> (-shift_amount); } if (num > MOD_SIZE) { - auto rem = - num.div_uint32_times_pow_2( - 1000000000, CALC_SHIFT_CONST + (IDX_SIZE > 1 ? IDX_SIZE : 0)) - .value(); + auto rem = num.div_uint32_times_pow_2( + EXP10_9, CALC_SHIFT_CONST + (IDX_SIZE > 1 ? IDX_SIZE : 0)) + .value(); num = rem; } return num; @@ -346,10 +342,10 @@ LIBC_INLINE cpp::UInt get_table_negative_df(int exponent, fputil::DyadicFloat num(false, 0, 1); constexpr cpp::UInt MOD_SIZE = - (cpp::UInt(1000000000) + (cpp::UInt(EXP10_9) << (CALC_SHIFT_CONST + (IDX_SIZE > 1 ? IDX_SIZE : 0))); - constexpr cpp::UInt TEN_EXP_NINE_MANT(1000000000); + constexpr cpp::UInt TEN_EXP_NINE_MANT(EXP10_9); static const fputil::DyadicFloat TEN_EXP_NINE(false, 0, TEN_EXP_NINE_MANT); @@ -364,8 +360,8 @@ LIBC_INLINE cpp::UInt get_table_negative_df(int exponent, if (int_num > MOD_SIZE) { auto rem = int_num - .div_uint32_times_pow_2( - 1000000000, CALC_SHIFT_CONST + (IDX_SIZE > 1 ? IDX_SIZE : 0)) + .div_uint32_times_pow_2(EXP10_9, CALC_SHIFT_CONST + + (IDX_SIZE > 1 ? IDX_SIZE : 0)) .value(); int_num = rem; } @@ -385,7 +381,7 @@ LIBC_INLINE uint32_t fast_uint_mod_1e9(const cpp::UInt &val) { const uint64_t result = static_cast(middle[2]); const uint64_t shifted = result >> 29; return static_cast(static_cast(val) - - (1000000000 * shifted)); + (EXP10_9 * shifted)); } LIBC_INLINE uint32_t mul_shift_mod_1e9(const FPBits::StorageType mantissa, @@ -393,8 +389,7 @@ LIBC_INLINE uint32_t mul_shift_mod_1e9(const FPBits::StorageType mantissa, const int32_t shift_amount) { cpp::UInt val(large); val = (val * mantissa) >> shift_amount; - return static_cast( - val.div_uint32_times_pow_2(1000000000, 0).value()); + return static_cast(val.div_uint32_times_pow_2(EXP10_9, 0).value()); } } // namespace internal @@ -623,6 +618,11 @@ class FloatToString { !defined(LIBC_COPT_FLOAT_TO_STR_NO_SPECIALIZE_LD) // --------------------------- LONG DOUBLE FUNCTIONS --------------------------- +// this algorithm will work exactly the same for 80 bit and 128 bit long +// doubles. They have the same max exponent, but even if they didn't the +// constants should be calculated to be correct for any provided floating point +// type. + template <> class FloatToString { fputil::FPBits float_bits; bool is_negative = 0; @@ -631,19 +631,23 @@ template <> class FloatToString { static constexpr int FRACTION_LEN = fputil::FPBits::FRACTION_LEN; static constexpr int EXP_BIAS = fputil::FPBits::EXP_BIAS; + static constexpr size_t UINT_WORD_SIZE = 64; static constexpr size_t FLOAT_AS_INT_WIDTH = internal::div_ceil(fputil::FPBits::MAX_BIASED_EXPONENT - FPBits::EXP_BIAS, - 64) * - 64; + UINT_WORD_SIZE) * + UINT_WORD_SIZE; static constexpr size_t EXTRA_INT_WIDTH = - internal::div_ceil(sizeof(long double) * 8, 64) * 64; + internal::div_ceil(sizeof(long double) * CHAR_BIT, UINT_WORD_SIZE) * + UINT_WORD_SIZE; + + using wide_int = cpp::UInt; // 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 // store any number with a negative exponent. - cpp::UInt float_as_fixed = 0; + wide_int float_as_fixed = 0; int int_block_index = 0; static constexpr size_t BLOCK_BUFFER_LEN = @@ -653,19 +657,18 @@ template <> class FloatToString { template LIBC_INLINE static constexpr BlockInt grab_digits(cpp::UInt &int_num) { - auto wide_result = int_num.div_uint32_times_pow_2(1953125, 9); + auto wide_result = int_num.div_uint32_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. LIBC_ASSERT(wide_result.has_value()); return static_cast(wide_result.value()); } - LIBC_INLINE static constexpr void zero_leading_digits( - cpp::UInt &int_num) { + LIBC_INLINE static constexpr void zero_leading_digits(wide_int &int_num) { // WORD_SIZE is the width of the numbers used to internally represent the // UInt - for (size_t i = 0; i < EXTRA_INT_WIDTH / int_num.WORD_SIZE; ++i) - int_num[i + (FLOAT_AS_INT_WIDTH / int_num.WORD_SIZE)] = 0; + for (size_t i = 0; i < EXTRA_INT_WIDTH / wide_int::WORD_SIZE; ++i) + int_num[i + (FLOAT_AS_INT_WIDTH / wide_int::WORD_SIZE)] = 0; } // init_convert initializes float_as_int, cur_block, and block_buffer based on @@ -684,7 +687,7 @@ template <> class FloatToString { // from left to right, so it caches the results so they can be read in // reverse order. - cpp::UInt float_as_int = mantissa; + wide_int float_as_int = mantissa; float_as_int.shift_left(exponent); int_block_index = 0; @@ -812,7 +815,7 @@ template <> class FloatToString { // requested block. This is likely to only be one step. while (block_index < int_block_index) { zero_leading_digits(float_as_fixed); - float_as_fixed.mul(1000000000); + float_as_fixed.mul(EXP10_9); --int_block_index; } diff --git a/libc/test/src/stdio/sprintf_test.cpp b/libc/test/src/stdio/sprintf_test.cpp index 8aef8311846d4..07501ac751fa3 100644 --- a/libc/test/src/stdio/sprintf_test.cpp +++ b/libc/test/src/stdio/sprintf_test.cpp @@ -1803,35 +1803,6 @@ TEST_F(LlvmLibcSPrintfTest, FloatDecimalLongDoubleConv) { "422771447006016890777855573925295187921971811871399320142563330377888532" "179817332113"); #endif // LIBC_LONG_DOUBLE_IS_X86_FLOAT80 - - /* - written = LIBC_NAMESPACE::sprintf(buff, "%La", 0.1L); - #if defined(LIBC_LONG_DOUBLE_IS_X86_FLOAT80) - ASSERT_STREQ_LEN(written, buff, "0xc.ccccccccccccccdp-7"); - #elif defined(LIBC_LONG_DOUBLE_IS_FLOAT64) - ASSERT_STREQ_LEN(written, buff, "0x1.999999999999ap-4"); - #else // 128 bit long double - ASSERT_STREQ_LEN(written, buff, "0x1.999999999999999999999999999ap-4"); - #endif - - written = LIBC_NAMESPACE::sprintf(buff, "%La", 1.0e1000L); - #if defined(LIBC_LONG_DOUBLE_IS_X86_FLOAT80) - ASSERT_STREQ_LEN(written, buff, "0xf.38db1f9dd3dac05p+3318"); - #elif defined(LIBC_LONG_DOUBLE_IS_FLOAT64) - ASSERT_STREQ_LEN(written, buff, "inf"); - #else // 128 bit long double - ASSERT_STREQ_LEN(written, buff, "0x1.e71b63f3ba7b580af1a52d2a7379p+3321"); - #endif - - written = LIBC_NAMESPACE::sprintf(buff, "%La", 1.0e-1000L); - #if defined(LIBC_LONG_DOUBLE_IS_X86_FLOAT80) - ASSERT_STREQ_LEN(written, buff, "0x8.68a9188a89e1467p-3325"); - #elif defined(LIBC_LONG_DOUBLE_IS_FLOAT64) - ASSERT_STREQ_LEN(written, buff, "0x0p+0"); - #else // 128 bit long double - ASSERT_STREQ_LEN(written, buff, "0x1.0d152311513c28ce202627c06ec2p-3322"); - #endif - */ } TEST_F(LlvmLibcSPrintfTest, FloatExponentConv) { @@ -2441,34 +2412,6 @@ TEST_F(LlvmLibcSPrintfTest, FloatExponentLongDoubleConv) { "231934194956788626761834746430104077432547436359522462253411168467463134" "24896.000000"); */ - /* - written = LIBC_NAMESPACE::sprintf(buff, "%La", 0.1L); - #if defined(LIBC_LONG_DOUBLE_IS_X86_FLOAT80) - ASSERT_STREQ_LEN(written, buff, "0xc.ccccccccccccccdp-7"); - #elif defined(LIBC_LONG_DOUBLE_IS_FLOAT64) - ASSERT_STREQ_LEN(written, buff, "0x1.999999999999ap-4"); - #else // 128 bit long double - ASSERT_STREQ_LEN(written, buff, "0x1.999999999999999999999999999ap-4"); - #endif - - written = LIBC_NAMESPACE::sprintf(buff, "%La", 1.0e1000L); - #if defined(LIBC_LONG_DOUBLE_IS_X86_FLOAT80) - ASSERT_STREQ_LEN(written, buff, "0xf.38db1f9dd3dac05p+3318"); - #elif defined(LIBC_LONG_DOUBLE_IS_FLOAT64) - ASSERT_STREQ_LEN(written, buff, "inf"); - #else // 128 bit long double - ASSERT_STREQ_LEN(written, buff, "0x1.e71b63f3ba7b580af1a52d2a7379p+3321"); - #endif - - written = LIBC_NAMESPACE::sprintf(buff, "%La", 1.0e-1000L); - #if defined(LIBC_LONG_DOUBLE_IS_X86_FLOAT80) - ASSERT_STREQ_LEN(written, buff, "0x8.68a9188a89e1467p-3325"); - #elif defined(LIBC_LONG_DOUBLE_IS_FLOAT64) - ASSERT_STREQ_LEN(written, buff, "0x0p+0"); - #else // 128 bit long double - ASSERT_STREQ_LEN(written, buff, "0x1.0d152311513c28ce202627c06ec2p-3322"); - #endif - */ } TEST_F(LlvmLibcSPrintfTest, FloatAutoConv) { From e179810aaa032e5a771b2f92ec2759433d018a83 Mon Sep 17 00:00:00 2001 From: Michael Jones Date: Wed, 24 Jan 2024 16:51:38 -0800 Subject: [PATCH 12/12] Fix to match new fpbits --- libc/src/__support/float_to_string.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libc/src/__support/float_to_string.h b/libc/src/__support/float_to_string.h index 25fd7ffb1c44a..4dc9d6eb3cb73 100644 --- a/libc/src/__support/float_to_string.h +++ b/libc/src/__support/float_to_string.h @@ -731,7 +731,7 @@ template <> class FloatToString { public: LIBC_INLINE constexpr FloatToString(long double init_float) : float_bits(init_float) { - is_negative = float_bits.get_sign(); + is_negative = float_bits.is_neg(); exponent = float_bits.get_explicit_exponent(); mantissa = float_bits.get_explicit_mantissa();