[libc] add rounding modes to printf float conv

[michaelrj]

Summary

This adds functionality for rounding towards negative inf, positive inf,
and zero to the float hex conversion (%a).

[lntue]

libc/test/src/stdio/sprintf_test.cpp

716

It is better to use ForceRoundingMode that was refactored in https://reviews.llvm.org/D129685. You can do something like:

{
  ForceRoundingMode r(RoundingMode::Nearest);

  <tests>
}

without worrying about changing current / default rounding modes.

[michaelrj]

move to using ForceRoundingMode for rounding mode testing.

[michaelrj]

fix formatting

libc/src/stdio/printf_core/CMakeLists.txt

HDRS
     ptr_converter.h
     oct_converter.h
     write_int_converter.h
     float_hex_converter.h
   DEPENDS
     .writer
     .core_structs
     libc.src.__support.CPP.limits
+    libc.src.__support.FPUtil.fputil
 )
 
 
 add_object_library(
   printf_main
   SRCS
     printf_main.cpp
   HDRS

libc/src/stdio/printf_core/float_hex_converter.h

 //===-- Hexadecimal Converter for printf ------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_STDIO_PRINTF_CORE_FLOAT_HEX_CONVERTER_H
 #define LLVM_LIBC_SRC_STDIO_PRINTF_CORE_FLOAT_HEX_CONVERTER_H
 
+#include "src/__support/FPUtil/FEnvImpl.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/stdio/printf_core/converter_utils.h"
 #include "src/stdio/printf_core/core_structs.h"
 #include "src/stdio/printf_core/writer.h"
 
 #include <inttypes.h>
 #include <stddef.h>
 
const size_t shift_amount =
         (mant_len - intended_digits) * BITS_IN_HEX_DIGIT;
 
     const MantissaInt truncated_bits =
         mantissa & ((MantissaInt(1) << shift_amount) - 1);
     const MantissaInt halfway_const = MantissaInt(1) << (shift_amount - 1);
 
     mantissa >>= shift_amount;
 
+    switch (fputil::get_round()) {
+    case FE_TONEAREST:
       // Round to nearest, if it's exactly halfway then round to even.
       if (truncated_bits > halfway_const)
         ++mantissa;
       else if (truncated_bits == halfway_const)
         mantissa = mantissa + (mantissa & 1);
+      break;
+    case FE_DOWNWARD:
+      if (truncated_bits > 0 && is_negative)
+        ++mantissa;
+      break;
+    case FE_UPWARD:
+      if (truncated_bits > 0 && !is_negative)
+        ++mantissa;
+      break;
+    case FE_TOWARDZERO:
+      break;
+    }
 
     // If the rounding caused an overflow, shift the mantissa and adjust the
     // exponent to match.
     if (mantissa >= (MantissaInt(1) << (intended_digits * BITS_IN_HEX_DIGIT))) {
       mantissa >>= BITS_IN_HEX_DIGIT;
       exponent += BITS_IN_HEX_DIGIT;
     }
 

libc/test/src/stdio/CMakeLists.txt

 add_libc_unittest(
   printf_test
   SUITE
     libc_stdio_unittests
   SRCS
     printf_test.cpp
   DEPENDS
     libc.src.stdio.printf
+    libc.src.fenv.fesetround
+    libc.src.__support.FPUtil.fputil
 )
 
 add_subdirectory(printf_core)
 
 add_subdirectory(testdata)

libc/test/src/stdio/sprintf_test.cpp

 //===-- Unittests for sprintf ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/stdio/sprintf.h"
 
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/FPUtil/PlatformDefs.h"
 #include "utils/UnitTest/Test.h"
+#include "utils/testutils/RoundingModeUtils.h"
+
+class LlvmLibcSPrintfTest : public __llvm_libc::testing::Test {
+protected:
+  char buff[64];
+  int written;
+};
 
 // Subtract 1 from sizeof(expected_str) to account for the null byte.
 #define ASSERT_STREQ_LEN(actual_written, actual_str, expected_str)             \
   EXPECT_EQ(actual_written, static_cast<int>(sizeof(expected_str) - 1));       \
   EXPECT_STREQ(actual_str, expected_str);
 
 TEST(LlvmLibcSPrintfTest, SimpleNoConv) {
   char buff[64];
TEST(LlvmLibcSPrintfTest, OctConv) {
 
   written = __llvm_libc::sprintf(buff, "%04hho %#.5llo %-6.3zo", 256 + 077,
                                  01000000000000ll, size_t(2));
   EXPECT_EQ(written, 26);
   ASSERT_STREQ(buff, "0077 01000000000000 002   ");
 }
 
 #ifndef LLVM_LIBC_PRINTF_DISABLE_FLOAT
-TEST(LlvmLibcSPrintfTest, FloatHexExpConv) {
-  char buff[64];
-  int written;
+
+TEST_F(LlvmLibcSPrintfTest, FloatHexExpConv) {
+  __llvm_libc::testutils::ForceRoundingMode r(
+      __llvm_libc::testutils::RoundingMode::Nearest);
   double inf = __llvm_libc::fputil::FPBits<double>::inf().get_val();
   double nan = __llvm_libc::fputil::FPBits<double>::build_nan(1);
 
   written = __llvm_libc::sprintf(buff, "%a", 1.0);
   ASSERT_STREQ_LEN(written, buff, "0x1p+0");
 
   written = __llvm_libc::sprintf(buff, "%A", -1.0);
   ASSERT_STREQ_LEN(written, buff, "-0X1P+0");

 #if defined(SPECIAL_X86_LONG_DOUBLE)
   ASSERT_STREQ_LEN(written, buff, "0x1.0p+16384");
 #elif defined(LONG_DOUBLE_IS_DOUBLE)
   ASSERT_STREQ_LEN(written, buff, "inf");
 #else // 128 bit long double
   ASSERT_STREQ_LEN(written, buff, "0x2.0p+16383");
 #endif
 
+  // Rounding Mode Tests.
+
+  {
+    __llvm_libc::testutils::ForceRoundingMode r(
+        __llvm_libc::testutils::RoundingMode::Nearest);
+
+    written = __llvm_libc::sprintf(buff, "%.1a", 0x1.08p0);
+    ASSERT_STREQ_LEN(written, buff, "0x1.0p+0");
+
+    written = __llvm_libc::sprintf(buff, "%.1a", 0x1.18p0);
+    ASSERT_STREQ_LEN(written, buff, "0x1.2p+0");
+
+    written = __llvm_libc::sprintf(buff, "%.1a", 0x1.04p0);
+    ASSERT_STREQ_LEN(written, buff, "0x1.0p+0");
+
+    written = __llvm_libc::sprintf(buff, "%.1a", 0x1.14p0);
+    ASSERT_STREQ_LEN(written, buff, "0x1.1p+0");
+
+    written = __llvm_libc::sprintf(buff, "%.1a", -0x1.08p0);
+    ASSERT_STREQ_LEN(written, buff, "-0x1.0p+0");
+
+    written = __llvm_libc::sprintf(buff, "%.1a", -0x1.18p0);
+    ASSERT_STREQ_LEN(written, buff, "-0x1.2p+0");
+
+    written = __llvm_libc::sprintf(buff, "%.1a", -0x1.04p0);
+    ASSERT_STREQ_LEN(written, buff, "-0x1.0p+0");
+
+    written = __llvm_libc::sprintf(buff, "%.1a", -0x1.14p0);
+    ASSERT_STREQ_LEN(written, buff, "-0x1.1p+0");
+  }
+
+  {
+    __llvm_libc::testutils::ForceRoundingMode r(
+        __llvm_libc::testutils::RoundingMode::Upward);
+
+    written = __llvm_libc::sprintf(buff, "%.1a", 0x1.08p0);
+    ASSERT_STREQ_LEN(written, buff, "0x1.1p+0");
+
+    written = __llvm_libc::sprintf(buff, "%.1a", 0x1.18p0);
+    ASSERT_STREQ_LEN(written, buff, "0x1.2p+0");
+
+    written = __llvm_libc::sprintf(buff, "%.1a", 0x1.04p0);
+    ASSERT_STREQ_LEN(written, buff, "0x1.1p+0");
+
+    written = __llvm_libc::sprintf(buff, "%.1a", 0x1.14p0);
+    ASSERT_STREQ_LEN(written, buff, "0x1.2p+0");
+
+    written = __llvm_libc::sprintf(buff, "%.1a", -0x1.08p0);
+    ASSERT_STREQ_LEN(written, buff, "-0x1.0p+0");
+
+    written = __llvm_libc::sprintf(buff, "%.1a", -0x1.18p0);
+    ASSERT_STREQ_LEN(written, buff, "-0x1.1p+0");
+
+    written = __llvm_libc::sprintf(buff, "%.1a", -0x1.04p0);
+    ASSERT_STREQ_LEN(written, buff, "-0x1.0p+0");
+
+    written = __llvm_libc::sprintf(buff, "%.1a", -0x1.14p0);
+    ASSERT_STREQ_LEN(written, buff, "-0x1.1p+0");
+  }
+
+  {
+    __llvm_libc::testutils::ForceRoundingMode r(
+        __llvm_libc::testutils::RoundingMode::Downward);
+
+    written = __llvm_libc::sprintf(buff, "%.1a", 0x1.08p0);
+    ASSERT_STREQ_LEN(written, buff, "0x1.0p+0");
+
+    written = __llvm_libc::sprintf(buff, "%.1a", 0x1.18p0);
+    ASSERT_STREQ_LEN(written, buff, "0x1.1p+0");
+
+    written = __llvm_libc::sprintf(buff, "%.1a", 0x1.04p0);
+    ASSERT_STREQ_LEN(written, buff, "0x1.0p+0");
+
+    written = __llvm_libc::sprintf(buff, "%.1a", 0x1.14p0);
+    ASSERT_STREQ_LEN(written, buff, "0x1.1p+0");
+
+    written = __llvm_libc::sprintf(buff, "%.1a", -0x1.08p0);
+    ASSERT_STREQ_LEN(written, buff, "-0x1.1p+0");
+
+    written = __llvm_libc::sprintf(buff, "%.1a", -0x1.18p0);
+    ASSERT_STREQ_LEN(written, buff, "-0x1.2p+0");
+
+    written = __llvm_libc::sprintf(buff, "%.1a", -0x1.04p0);
+    ASSERT_STREQ_LEN(written, buff, "-0x1.1p+0");
+
+    written = __llvm_libc::sprintf(buff, "%.1a", -0x1.14p0);
+    ASSERT_STREQ_LEN(written, buff, "-0x1.2p+0");
+  }
+
+  {
+    __llvm_libc::testutils::ForceRoundingMode r(
+        __llvm_libc::testutils::RoundingMode::TowardZero);
+
+    written = __llvm_libc::sprintf(buff, "%.1a", 0x1.08p0);
+    ASSERT_STREQ_LEN(written, buff, "0x1.0p+0");
+
+    written = __llvm_libc::sprintf(buff, "%.1a", 0x1.18p0);
+    ASSERT_STREQ_LEN(written, buff, "0x1.1p+0");
+
+    written = __llvm_libc::sprintf(buff, "%.1a", 0x1.04p0);
+    ASSERT_STREQ_LEN(written, buff, "0x1.0p+0");
+
+    written = __llvm_libc::sprintf(buff, "%.1a", 0x1.14p0);
+    ASSERT_STREQ_LEN(written, buff, "0x1.1p+0");
+
+    written = __llvm_libc::sprintf(buff, "%.1a", -0x1.08p0);
+    ASSERT_STREQ_LEN(written, buff, "-0x1.0p+0");
+
+    written = __llvm_libc::sprintf(buff, "%.1a", -0x1.18p0);
+    ASSERT_STREQ_LEN(written, buff, "-0x1.1p+0");
+
+    written = __llvm_libc::sprintf(buff, "%.1a", -0x1.04p0);
+    ASSERT_STREQ_LEN(written, buff, "-0x1.0p+0");
+
+    written = __llvm_libc::sprintf(buff, "%.1a", -0x1.14p0);
+    ASSERT_STREQ_LEN(written, buff, "-0x1.1p+0");
+  }
+
   // Flag Tests.
 
   written = __llvm_libc::sprintf(buff, "%+a", nan);
   ASSERT_STREQ_LEN(written, buff, "+nan");
 
   written = __llvm_libc::sprintf(buff, "% A", inf);
   ASSERT_STREQ_LEN(written, buff, " INF");