This is an archive of the discontinued LLVM Phabricator instance.

Differential D152873

[libc] Enable hermetic floating point tests again.
ClosedPublic

Authored by lntue on Jun 13 2023, 5:45 PM.

Details

Reviewers
michaelrj
sivachandra
jhuber6
Commits
rG055be3c30c78: [libc] Enable hermetic floating point tests again.
Summary

Fixing an issue with LLVM libc's fenv.h defined rounding mode macros
differently from system libc, making get_round() return different values from
fegetround(). Also letting math tests to skip rounding modes that cannot be
set. This should allow math tests to be run on platforms in which fenv.h is not
implemented yet.

This allows us to re-enable hermatic floating point tests in
https://reviews.llvm.org/D151123 and reverting https://reviews.llvm.org/D152742.

Diff Detail

Event Timeline

lntue created this revision.Jun 13 2023, 5:45 PM
Herald added projects: Restricted Project, Restricted Project. · View Herald TranscriptJun 13 2023, 5:45 PM
lntue requested review of this revision.Jun 13 2023, 5:45 PM
Harbormaster completed remote builds in B238660: Diff 531125.Jun 13 2023, 5:52 PM
jhuber6 added a comment.Jun 13 2023, 6:30 PM

With this patch I get the following failures on my AMDGPU machine. I'm not sure if it's something we haven't yet implemented on the GPU or not.

FAILED: libc/test/src/__support/FPUtil/CMakeFiles/libc.test.src.__support.FPUtil.rounding_mode_test.__hermetic__ /home/jhuber/Documents/llvm/llvm-project/build/runtimes/runtimes-bins/libc/test/src/__support/FPUtil/CMakeFiles/libc.test.src.__support.FPUtil.rounding_mode_test.__hermetic__ 
cd /home/jhuber/Documents/llvm/llvm-project/build/runtimes/runtimes-bins/libc/test/src/__support/FPUtil && /home/jhuber/Documents/llvm/llvm-project/build/runtimes/runtimes-bins/libc/utils/gpu/loader/amdgpu/amdhsa_loader /home/jhuber/Documents/llvm/llvm-project/build/runtimes/runtimes-bins/libc/test/src/__support/FPUtil/libc.test.src.__support.FPUtil.rounding_mode_test.__hermetic__.__build__
[ RUN      ] LlvmLibcFEnvImplTest.QuickRoundingUpTest
/home/jhuber/Documents/llvm/llvm-project/libc/test/src/__support/FPUtil/rounding_mode_test.cpp:22: FAILURE
      Expected: (fenv_is_round_up())
      Which is: 0
To be equal to: true
      Which is: 1
[  FAILED  ] LlvmLibcFEnvImplTest.QuickRoundingUpTest
[ RUN      ] LlvmLibcFEnvImplTest.QuickRoundingDownTest
/home/jhuber/Documents/llvm/llvm-project/libc/test/src/__support/FPUtil/rounding_mode_test.cpp:46: FAILURE
      Expected: (fenv_is_round_down())
      Which is: 0
To be equal to: true
      Which is: 1
[  FAILED  ] LlvmLibcFEnvImplTest.QuickRoundingDownTest
[ RUN      ] LlvmLibcFEnvImplTest.QuickRoundingNearestTest
/home/jhuber/Documents/llvm/llvm-project/libc/test/src/__support/FPUtil/rounding_mode_test.cpp:62: FAILURE
      Expected: (fenv_is_round_to_nearest())
      Which is: 1
To be equal to: false
      Which is: 0
[  FAILED  ] LlvmLibcFEnvImplTest.QuickRoundingNearestTest
[ RUN      ] LlvmLibcFEnvImplTest.QuickRoundingTowardZeroTest
/home/jhuber/Documents/llvm/llvm-project/libc/test/src/__support/FPUtil/rounding_mode_test.cpp:94: FAILURE
      Expected: (fenv_is_round_to_zero())
      Which is: 0
To be equal to: true
      Which is: 1
[  FAILED  ] LlvmLibcFEnvImplTest.QuickRoundingTowardZeroTest
[ RUN      ] LlvmLibcFEnvImplTest.QuickGetRoundTest
/home/jhuber/Documents/llvm/llvm-project/libc/test/src/__support/FPUtil/rounding_mode_test.cpp:102: FAILURE
      Expected: quick_get_round()
      Which is: 0
To be equal to: 0x800
      Which is: 2048
[  FAILED  ] LlvmLibcFEnvImplTest.QuickGetRoundTest
Ran 5 tests.  PASS: 0  FAIL: 5
lntue updated this revision to Diff 531164.Jun 13 2023, 8:59 PM

Let math tests skip rounding modes that cannot be set.

lntue edited the summary of this revision. (Show Details)Jun 13 2023, 9:03 PM
Harbormaster completed remote builds in B238689: Diff 531164.Jun 13 2023, 9:06 PM
jhuber6 accepted this revision.Jun 14 2023, 4:56 AM

Passes on my machine, thanks.

This revision is now accepted and ready to land.Jun 14 2023, 4:56 AM
Closed by commit rG055be3c30c78: [libc] Enable hermetic floating point tests again. (authored by lntue). · Explain WhyJun 14 2023, 7:54 AM
This revision was automatically updated to reflect the committed changes.
lntue added a commit: rG055be3c30c78: [libc] Enable hermetic floating point tests again..

Revision Contents

PathSize
libc/
include/
llvm-libc-macros/
8 lines
src/
__support/
FPUtil/
6 lines
test/
UnitTest/
1 line
12 lines
1 line
14 lines
src/
6 lines
__support/
FPUtil/
42 lines
60 lines
fenv/
2 lines
math/
26 lines
exhaustive/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
3 lines
3 lines
3 lines
48 lines
stdio/
95 lines
utils/
MPFRWrapper/
40 lines
utils/
bazel/
llvm-project-overlay/
libc/
test/
UnitTest/
2 lines

Diff 531337

libc/include/llvm-libc-macros/fenv-macros.h

Show All 11 Lines
#define FE_DIVBYZERO 1 #define FE_DIVBYZERO 1
#define FE_INEXACT 2 #define FE_INEXACT 2
#define FE_INVALID 4 #define FE_INVALID 4
#define FE_OVERFLOW 8 #define FE_OVERFLOW 8
#define FE_UNDERFLOW 16 #define FE_UNDERFLOW 16
#define FE_ALL_EXCEPT \ #define FE_ALL_EXCEPT \
(FE_DIVBYZERO | FE_INEXACT | FE_INVALID | FE_OVERFLOW | FE_UNDERFLOW) (FE_DIVBYZERO | FE_INEXACT | FE_INVALID | FE_OVERFLOW | FE_UNDERFLOW)
#define FE_DOWNWARD 1 #define FE_DOWNWARD 0x400
#define FE_TONEAREST 2 #define FE_TONEAREST 0
#define FE_TOWARDZERO 4 #define FE_TOWARDZERO 0xC00
#define FE_UPWARD 8 #define FE_UPWARD 0x800
#define FE_DFL_ENV ((fenv_t *)-1) #define FE_DFL_ENV ((fenv_t *)-1)
#endif // __LLVM_LIBC_MACROS_FENV_MACROS_H #endif // __LLVM_LIBC_MACROS_FENV_MACROS_H

libc/src/__support/FPUtil/FEnvImpl.h

Show All 36 Lines
namespace __llvm_libc::fputil { namespace __llvm_libc::fputil {
// All dummy functions silently succeed. // All dummy functions silently succeed.
LIBC_INLINE int clear_except(int) { return 0; } LIBC_INLINE int clear_except(int) { return 0; }
LIBC_INLINE int test_except(int) { return 0; } LIBC_INLINE int test_except(int) { return 0; }
LIBC_INLINE int get_except() { return 0; }
LIBC_INLINE int set_except(int) { return 0; } LIBC_INLINE int set_except(int) { return 0; }
LIBC_INLINE int raise_except(int) { return 0; } LIBC_INLINE int raise_except(int) { return 0; }
LIBC_INLINE int enable_except(int) { return 0; } LIBC_INLINE int enable_except(int) { return 0; }
LIBC_INLINE int disable_except(int) { return 0; } LIBC_INLINE int disable_except(int) { return 0; }
LIBC_INLINE int get_round() { return FE_TONEAREST; } LIBC_INLINE int get_round() { return FE_TONEAREST; }
LIBC_INLINE int set_round(int) { return 0; } LIBC_INLINE int set_round(int rounding_mode) {
return (rounding_mode == FE_TONEAREST) ? 0 : 1;
}
LIBC_INLINE int get_env(fenv_t *) { return 0; } LIBC_INLINE int get_env(fenv_t *) { return 0; }
LIBC_INLINE int set_env(const fenv_t *) { return 0; } LIBC_INLINE int set_env(const fenv_t *) { return 0; }
} // namespace __llvm_libc::fputil } // namespace __llvm_libc::fputil
#endif #endif
Show All 22 Lines

libc/test/UnitTest/CMakeLists.txt

Show First 20 Lines • Show All 104 Lines • ▼ Show 20 Lines HDRS
FPMatcher.h FPMatcher.h
RoundingModeUtils.h RoundingModeUtils.h
DEPENDS DEPENDS
LibcTest LibcTest
libc.test.UnitTest.string_utils libc.test.UnitTest.string_utils
libc.src.__support.FPUtil.fp_bits libc.src.__support.FPUtil.fp_bits
libc.src.__support.FPUtil.fpbits_str libc.src.__support.FPUtil.fpbits_str
libc.src.__support.FPUtil.fenv_impl libc.src.__support.FPUtil.fenv_impl
libc.src.__support.FPUtil.rounding_mode
) )
add_unittest_framework_library( add_unittest_framework_library(
LibcFPExceptionHelpers LibcFPExceptionHelpers
SRCS SRCS
FPExceptMatcher.cpp FPExceptMatcher.cpp
HDRS HDRS
FPExceptMatcher.h FPExceptMatcher.h
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

libc/test/UnitTest/FPMatcher.h

Show First 20 Lines • Show All 158 Lines • ▼ Show 20 Lines if (math_errhandling & MATH_ERREXCEPT) { \
__llvm_libc::fputil::clear_except(FE_ALL_EXCEPT); \ __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT); \
} \ } \
} while (0) } while (0)
#define EXPECT_FP_EQ_ALL_ROUNDING(expected, actual) \ #define EXPECT_FP_EQ_ALL_ROUNDING(expected, actual) \
do { \ do { \
using namespace __llvm_libc::fputil::testing; \ using namespace __llvm_libc::fputil::testing; \
ForceRoundingMode __r1(RoundingMode::Nearest); \ ForceRoundingMode __r1(RoundingMode::Nearest); \
if (__r1.success) \
EXPECT_FP_EQ((expected), (actual)); \ EXPECT_FP_EQ((expected), (actual)); \
ForceRoundingMode __r2(RoundingMode::Upward); \ ForceRoundingMode __r2(RoundingMode::Upward); \
if (__r2.success) \
EXPECT_FP_EQ((expected), (actual)); \ EXPECT_FP_EQ((expected), (actual)); \
ForceRoundingMode __r3(RoundingMode::Downward); \ ForceRoundingMode __r3(RoundingMode::Downward); \
if (__r3.success) \
EXPECT_FP_EQ((expected), (actual)); \ EXPECT_FP_EQ((expected), (actual)); \
ForceRoundingMode __r4(RoundingMode::TowardZero); \ ForceRoundingMode __r4(RoundingMode::TowardZero); \
if (__r4.success) \
EXPECT_FP_EQ((expected), (actual)); \ EXPECT_FP_EQ((expected), (actual)); \
} while (0) } while (0)
#endif // LLVM_LIBC_UTILS_UNITTEST_FPMATCHER_H #endif // LLVM_LIBC_UTILS_UNITTEST_FPMATCHER_H

libc/test/UnitTest/RoundingModeUtils.h

Show All 17 Lines
enum class RoundingMode : uint8_t { Upward, Downward, TowardZero, Nearest }; enum class RoundingMode : uint8_t { Upward, Downward, TowardZero, Nearest };
struct ForceRoundingMode { struct ForceRoundingMode {
ForceRoundingMode(RoundingMode); ForceRoundingMode(RoundingMode);
~ForceRoundingMode(); ~ForceRoundingMode();
int old_rounding_mode; int old_rounding_mode;
int rounding_mode; int rounding_mode;
bool success;
}; };
template <RoundingMode R> struct ForceRoundingModeTest : ForceRoundingMode { template <RoundingMode R> struct ForceRoundingModeTest : ForceRoundingMode {
ForceRoundingModeTest() : ForceRoundingMode(R) {} ForceRoundingModeTest() : ForceRoundingMode(R) {}
}; };
} // namespace testing } // namespace testing
} // namespace fputil } // namespace fputil
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_UTILS_TESTUTILS_ROUNDINGMODEUTILS_H #endif // LLVM_LIBC_UTILS_TESTUTILS_ROUNDINGMODEUTILS_H

libc/test/UnitTest/RoundingModeUtils.cpp

//===-- RoundingModeUtils.cpp ---------------------------------------------===// //===-- RoundingModeUtils.cpp ---------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "RoundingModeUtils.h" #include "RoundingModeUtils.h"
#include "src/__support/FPUtil/FEnvImpl.h"
#include "src/__support/FPUtil/rounding_mode.h"
#include <fenv.h> #include <fenv.h>
namespace __llvm_libc { namespace __llvm_libc {
namespace fputil { namespace fputil {
namespace testing { namespace testing {
int get_fe_rounding(RoundingMode mode) { int get_fe_rounding(RoundingMode mode) {
Show All 11 Lines case RoundingMode::Nearest:
return FE_TONEAREST; return FE_TONEAREST;
break; break;
default: default:
__builtin_unreachable(); __builtin_unreachable();
} }
} }
ForceRoundingMode::ForceRoundingMode(RoundingMode mode) { ForceRoundingMode::ForceRoundingMode(RoundingMode mode) {
old_rounding_mode = fegetround(); old_rounding_mode = quick_get_round();
rounding_mode = get_fe_rounding(mode); rounding_mode = get_fe_rounding(mode);
if (old_rounding_mode != rounding_mode) if (old_rounding_mode != rounding_mode) {
fesetround(rounding_mode); int status = set_round(rounding_mode);
success = (status == 0);
} else {
success = true;
}
} }
ForceRoundingMode::~ForceRoundingMode() { ForceRoundingMode::~ForceRoundingMode() {
if (old_rounding_mode != rounding_mode) if (old_rounding_mode != rounding_mode)
fesetround(old_rounding_mode); set_round(old_rounding_mode);
} }
} // namespace testing } // namespace testing
} // namespace fputil } // namespace fputil
} // namespace __llvm_libc } // namespace __llvm_libc

libc/test/src/CMakeLists.txt

function(add_fp_unittest name) function(add_fp_unittest name)
cmake_parse_arguments( cmake_parse_arguments(
"MATH_UNITTEST" "MATH_UNITTEST"
"NEED_MPFR;HERMETIC_TEST_ONLY" # Optional arguments "NEED_MPFR;UNIT_TEST_ONLY;HERMETIC_TEST_ONLY" # Optional arguments
"" # Single value arguments "" # Single value arguments
"LINK_LIBRARIES" # Multi-value arguments "LINK_LIBRARIES" # Multi-value arguments
${ARGN} ${ARGN}
) )
if(MATH_UNITTEST_NEED_MPFR) if(MATH_UNITTEST_NEED_MPFR)
if(NOT LIBC_TESTS_CAN_USE_MPFR) if(NOT LIBC_TESTS_CAN_USE_MPFR)
message(VERBOSE "Math test ${name} will be skipped as MPFR library is not available.") message(VERBOSE "Math test ${name} will be skipped as MPFR library is not available.")
return() return()
endif() endif()
endif() endif()
if(MATH_UNITTEST_HERMETIC_TEST_ONLY) if(MATH_UNITTEST_HERMETIC_TEST_ONLY)
set(test_type HERMETIC_TEST_ONLY) set(test_type HERMETIC_TEST_ONLY)
elseif(MATH_UNITTEST_UNIT_TEST_ONLY)
set(test_type UNIT_TEST_ONLY)
endif() endif()
if(MATH_UNITTEST_NEED_MPFR) if(MATH_UNITTEST_NEED_MPFR)
if(MATH_UNITTEST_HERMETIC_TEST_ONLY) if(MATH_UNITTEST_HERMETIC_TEST_ONLY)
message(FATAL "Hermetic math test cannot require MPFR.") message(FATAL "Hermetic math test cannot require MPFR.")
endif() endif()
set(test_type UNIT_TEST_ONLY) set(test_type UNIT_TEST_ONLY)
list(APPEND MATH_UNITTEST_LINK_LIBRARIES libcMPFRWrapper libc_math_test_utils -lmpfr -lgmp) list(APPEND MATH_UNITTEST_LINK_LIBRARIES libcMPFRWrapper libc_math_test_utils -lmpfr -lgmp)
endif() endif()
list(APPEND MATH_UNITTEST_LINK_LIBRARIES LibcFPTestHelpers) list(APPEND MATH_UNITTEST_LINK_LIBRARIES LibcFPTestHelpers)
add_libc_unittest( add_libc_test(
${name} ${name}
${test_type} ${test_type}
LINK_LIBRARIES "${MATH_UNITTEST_LINK_LIBRARIES}" LINK_LIBRARIES "${MATH_UNITTEST_LINK_LIBRARIES}"
"${MATH_UNITTEST_UNPARSED_ARGUMENTS}" "${MATH_UNITTEST_UNPARSED_ARGUMENTS}"
) )
endfunction(add_fp_unittest) endfunction(add_fp_unittest)
add_subdirectory(__support) add_subdirectory(__support)
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

libc/test/src/__support/FPUtil/CMakeLists.txt

add_custom_target(libc-fputil-tests) add_custom_target(libc-fputil-tests)
if(NOT LIBC_TARGET_ARCHITECTURE_IS_GPU)
add_fp_unittest( add_fp_unittest(
dyadic_float_test dyadic_float_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc-fputil-tests libc-fputil-tests
SRCS SRCS
dyadic_float_test.cpp dyadic_float_test.cpp
DEPENDS DEPENDS
libc.src.__support.FPUtil.dyadic_float libc.src.__support.FPUtil.dyadic_float
) )
endif()
add_libc_test( add_libc_test(
fpbits_test fpbits_test
SUITE SUITE
libc-fputil-tests libc-fputil-tests
SRCS SRCS
fpbits_test.cpp fpbits_test.cpp
DEPENDS DEPENDS
libc.src.__support.FPUtil.fp_bits libc.src.__support.FPUtil.fp_bits
libc.src.__support.FPUtil.fpbits_str libc.src.__support.FPUtil.fpbits_str
) )
if(NOT LIBC_TARGET_ARCHITECTURE_IS_GPU)
add_fp_unittest( add_fp_unittest(
rounding_mode_test rounding_mode_test
SUITE SUITE
libc-fputil-tests libc-fputil-tests
SRCS SRCS
rounding_mode_test.cpp rounding_mode_test.cpp
DEPENDS DEPENDS
libc.src.__support.FPUtil.rounding_mode libc.src.__support.FPUtil.rounding_mode
) )
endif()

libc/test/src/__support/FPUtil/rounding_mode_test.cpp

Show All 13 Lines
using __llvm_libc::testing::mpfr::ForceRoundingMode; using __llvm_libc::testing::mpfr::ForceRoundingMode;
using __llvm_libc::testing::mpfr::RoundingMode; using __llvm_libc::testing::mpfr::RoundingMode;
TEST(LlvmLibcFEnvImplTest, QuickRoundingUpTest) { TEST(LlvmLibcFEnvImplTest, QuickRoundingUpTest) {
using __llvm_libc::fputil::fenv_is_round_up; using __llvm_libc::fputil::fenv_is_round_up;
{ {
ForceRoundingMode __r(RoundingMode::Upward); ForceRoundingMode __r(RoundingMode::Upward);
if (__r.success)
ASSERT_TRUE(fenv_is_round_up()); ASSERT_TRUE(fenv_is_round_up());
} }
{ {
ForceRoundingMode __r(RoundingMode::Downward); ForceRoundingMode __r(RoundingMode::Downward);
if (__r.success)
ASSERT_FALSE(fenv_is_round_up()); ASSERT_FALSE(fenv_is_round_up());
} }
{ {
ForceRoundingMode __r(RoundingMode::Nearest); ForceRoundingMode __r(RoundingMode::Nearest);
if (__r.success)
ASSERT_FALSE(fenv_is_round_up()); ASSERT_FALSE(fenv_is_round_up());
} }
{ {
ForceRoundingMode __r(RoundingMode::TowardZero); ForceRoundingMode __r(RoundingMode::TowardZero);
if (__r.success)
ASSERT_FALSE(fenv_is_round_up()); ASSERT_FALSE(fenv_is_round_up());
} }
} }
TEST(LlvmLibcFEnvImplTest, QuickRoundingDownTest) { TEST(LlvmLibcFEnvImplTest, QuickRoundingDownTest) {
using __llvm_libc::fputil::fenv_is_round_down; using __llvm_libc::fputil::fenv_is_round_down;
{ {
ForceRoundingMode __r(RoundingMode::Upward); ForceRoundingMode __r(RoundingMode::Upward);
if (__r.success)
ASSERT_FALSE(fenv_is_round_down()); ASSERT_FALSE(fenv_is_round_down());
} }
{ {
ForceRoundingMode __r(RoundingMode::Downward); ForceRoundingMode __r(RoundingMode::Downward);
if (__r.success)
ASSERT_TRUE(fenv_is_round_down()); ASSERT_TRUE(fenv_is_round_down());
} }
{ {
ForceRoundingMode __r(RoundingMode::Nearest); ForceRoundingMode __r(RoundingMode::Nearest);
if (__r.success)
ASSERT_FALSE(fenv_is_round_down()); ASSERT_FALSE(fenv_is_round_down());
} }
{ {
ForceRoundingMode __r(RoundingMode::TowardZero); ForceRoundingMode __r(RoundingMode::TowardZero);
if (__r.success)
ASSERT_FALSE(fenv_is_round_down()); ASSERT_FALSE(fenv_is_round_down());
} }
} }
TEST(LlvmLibcFEnvImplTest, QuickRoundingNearestTest) { TEST(LlvmLibcFEnvImplTest, QuickRoundingNearestTest) {
using __llvm_libc::fputil::fenv_is_round_to_nearest; using __llvm_libc::fputil::fenv_is_round_to_nearest;
{ {
ForceRoundingMode __r(RoundingMode::Upward); ForceRoundingMode __r(RoundingMode::Upward);
if (__r.success)
ASSERT_FALSE(fenv_is_round_to_nearest()); ASSERT_FALSE(fenv_is_round_to_nearest());
} }
{ {
ForceRoundingMode __r(RoundingMode::Downward); ForceRoundingMode __r(RoundingMode::Downward);
if (__r.success)
ASSERT_FALSE(fenv_is_round_to_nearest()); ASSERT_FALSE(fenv_is_round_to_nearest());
} }
{ {
ForceRoundingMode __r(RoundingMode::Nearest); ForceRoundingMode __r(RoundingMode::Nearest);
if (__r.success)
ASSERT_TRUE(fenv_is_round_to_nearest()); ASSERT_TRUE(fenv_is_round_to_nearest());
} }
{ {
ForceRoundingMode __r(RoundingMode::TowardZero); ForceRoundingMode __r(RoundingMode::TowardZero);
if (__r.success)
ASSERT_FALSE(fenv_is_round_to_nearest()); ASSERT_FALSE(fenv_is_round_to_nearest());
} }
} }
TEST(LlvmLibcFEnvImplTest, QuickRoundingTowardZeroTest) { TEST(LlvmLibcFEnvImplTest, QuickRoundingTowardZeroTest) {
using __llvm_libc::fputil::fenv_is_round_to_zero; using __llvm_libc::fputil::fenv_is_round_to_zero;
{ {
ForceRoundingMode __r(RoundingMode::Upward); ForceRoundingMode __r(RoundingMode::Upward);
if (__r.success)
ASSERT_FALSE(fenv_is_round_to_zero()); ASSERT_FALSE(fenv_is_round_to_zero());
} }
{ {
ForceRoundingMode __r(RoundingMode::Downward); ForceRoundingMode __r(RoundingMode::Downward);
if (__r.success)
ASSERT_FALSE(fenv_is_round_to_zero()); ASSERT_FALSE(fenv_is_round_to_zero());
} }
{ {
ForceRoundingMode __r(RoundingMode::Nearest); ForceRoundingMode __r(RoundingMode::Nearest);
if (__r.success)
ASSERT_FALSE(fenv_is_round_to_zero()); ASSERT_FALSE(fenv_is_round_to_zero());
} }
{ {
ForceRoundingMode __r(RoundingMode::TowardZero); ForceRoundingMode __r(RoundingMode::TowardZero);
if (__r.success)
ASSERT_TRUE(fenv_is_round_to_zero()); ASSERT_TRUE(fenv_is_round_to_zero());
} }
} }
TEST(LlvmLibcFEnvImplTest, QuickGetRoundTest) { TEST(LlvmLibcFEnvImplTest, QuickGetRoundTest) {
using __llvm_libc::fputil::quick_get_round; using __llvm_libc::fputil::quick_get_round;
{ {
ForceRoundingMode __r(RoundingMode::Upward); ForceRoundingMode __r(RoundingMode::Upward);
if (__r.success)
ASSERT_EQ(quick_get_round(), FE_UPWARD); ASSERT_EQ(quick_get_round(), FE_UPWARD);
} }
{ {
ForceRoundingMode __r(RoundingMode::Downward); ForceRoundingMode __r(RoundingMode::Downward);
if (__r.success)
ASSERT_EQ(quick_get_round(), FE_DOWNWARD); ASSERT_EQ(quick_get_round(), FE_DOWNWARD);
} }
{ {
ForceRoundingMode __r(RoundingMode::Nearest); ForceRoundingMode __r(RoundingMode::Nearest);
if (__r.success)
ASSERT_EQ(quick_get_round(), FE_TONEAREST); ASSERT_EQ(quick_get_round(), FE_TONEAREST);
} }
{ {
ForceRoundingMode __r(RoundingMode::TowardZero); ForceRoundingMode __r(RoundingMode::TowardZero);
if (__r.success)
ASSERT_EQ(quick_get_round(), FE_TOWARDZERO); ASSERT_EQ(quick_get_round(), FE_TOWARDZERO);
} }
} }

libc/test/src/fenv/CMakeLists.txt

Show First 20 Lines • Show All 88 Lines • ▼ Show 20 Linesif (NOT (LLVM_USE_SANITIZER OR (${LIBC_TARGET_OS} STREQUAL "windows")
OR (${LIBC_TARGET_OS} STREQUAL "darwin"))) OR (${LIBC_TARGET_OS} STREQUAL "darwin")))
# Sanitizers don't like SIGFPE. So, we will run the # Sanitizers don't like SIGFPE. So, we will run the
# tests which raise SIGFPE only in non-sanitizer builds. # tests which raise SIGFPE only in non-sanitizer builds.
# The tests are also disabled for Windows and MacOS as they fail currently. # The tests are also disabled for Windows and MacOS as they fail currently.
# TODO: Investigate and fix the windows failures and enable them for Windows # TODO: Investigate and fix the windows failures and enable them for Windows
# and MacOS. # and MacOS.
add_fp_unittest( add_fp_unittest(
enabled_exceptions_test enabled_exceptions_test
UNIT_TEST_ONLY
SUITE SUITE
libc_fenv_unittests libc_fenv_unittests
SRCS SRCS
enabled_exceptions_test.cpp enabled_exceptions_test.cpp
DEPENDS DEPENDS
libc.include.signal libc.include.signal
libc.src.fenv.feclearexcept libc.src.fenv.feclearexcept
libc.src.fenv.feraiseexcept libc.src.fenv.feraiseexcept
libc.src.fenv.fetestexcept libc.src.fenv.fetestexcept
libc.src.__support.FPUtil.fenv_impl libc.src.__support.FPUtil.fenv_impl
LINK_LIBRARIES LINK_LIBRARIES
LibcFPExceptionHelpers LibcFPExceptionHelpers
) )
add_fp_unittest( add_fp_unittest(
feholdexcept_test feholdexcept_test
UNIT_TEST_ONLY
SUITE SUITE
libc_fenv_unittests libc_fenv_unittests
SRCS SRCS
feholdexcept_test.cpp feholdexcept_test.cpp
DEPENDS DEPENDS
libc.include.fenv libc.include.fenv
libc.src.fenv.feholdexcept libc.src.fenv.feholdexcept
libc.src.__support.FPUtil.fenv_impl libc.src.__support.FPUtil.fenv_impl
LINK_LIBRARIES LINK_LIBRARIES
LibcFPExceptionHelpers LibcFPExceptionHelpers
) )
endif() endif()

libc/test/src/math/SqrtTest.h

Show All 35 Lines void test_special_numbers(SqrtFunc func) {
ASSERT_FP_EQ(T(2.0), func(T(4.0))); ASSERT_FP_EQ(T(2.0), func(T(4.0)));
ASSERT_FP_EQ(T(3.0), func(T(9.0))); ASSERT_FP_EQ(T(3.0), func(T(9.0)));
} }
void test_denormal_values(SqrtFunc func) { void test_denormal_values(SqrtFunc func) {
for (UIntType mant = 1; mant < HIDDEN_BIT; mant <<= 1) { for (UIntType mant = 1; mant < HIDDEN_BIT; mant <<= 1) {
FPBits denormal(T(0.0)); FPBits denormal(T(0.0));
denormal.set_mantissa(mant); denormal.set_mantissa(mant);
T x = T(denormal);
test_all_rounding_modes(func, T(denormal)); EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Sqrt, x, func(x), 0.5);
} }
constexpr UIntType COUNT = 200'001; constexpr UIntType COUNT = 200'001;
constexpr UIntType STEP = HIDDEN_BIT / COUNT; constexpr UIntType STEP = HIDDEN_BIT / COUNT;
for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = __llvm_libc::cpp::bit_cast<T>(v); T x = __llvm_libc::cpp::bit_cast<T>(v);
test_all_rounding_modes(func, x); EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Sqrt, x, func(x), 0.5);
} }
} }
void test_normal_range(SqrtFunc func) { void test_normal_range(SqrtFunc func) {
constexpr UIntType COUNT = 200'001; constexpr UIntType COUNT = 200'001;
constexpr UIntType STEP = UIntType(-1) / COUNT; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = __llvm_libc::cpp::bit_cast<T>(v); T x = __llvm_libc::cpp::bit_cast<T>(v);
if (isnan(x) || (x < 0)) { if (isnan(x) || (x < 0)) {
continue; continue;
} }
test_all_rounding_modes(func, x); EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Sqrt, x, func(x), 0.5);
}
} }
void test_all_rounding_modes(SqrtFunc func, T x) {
mpfr::ForceRoundingMode r1(mpfr::RoundingMode::Nearest);
EXPECT_MPFR_MATCH(mpfr::Operation::Sqrt, x, func(x), 0.5,
mpfr::RoundingMode::Nearest);
mpfr::ForceRoundingMode r2(mpfr::RoundingMode::Upward);
EXPECT_MPFR_MATCH(mpfr::Operation::Sqrt, x, func(x), 0.5,
mpfr::RoundingMode::Upward);
mpfr::ForceRoundingMode r3(mpfr::RoundingMode::Downward);
EXPECT_MPFR_MATCH(mpfr::Operation::Sqrt, x, func(x), 0.5,
mpfr::RoundingMode::Downward);
mpfr::ForceRoundingMode r4(mpfr::RoundingMode::TowardZero);
EXPECT_MPFR_MATCH(mpfr::Operation::Sqrt, x, func(x), 0.5,
mpfr::RoundingMode::TowardZero);
} }
}; };
#define LIST_SQRT_TESTS(T, func) \ #define LIST_SQRT_TESTS(T, func) \
using LlvmLibcSqrtTest = SqrtTest<T>; \ using LlvmLibcSqrtTest = SqrtTest<T>; \
TEST_F(LlvmLibcSqrtTest, SpecialNumbers) { test_special_numbers(&func); } \ TEST_F(LlvmLibcSqrtTest, SpecialNumbers) { test_special_numbers(&func); } \
TEST_F(LlvmLibcSqrtTest, DenormalValues) { test_denormal_values(&func); } \ TEST_F(LlvmLibcSqrtTest, DenormalValues) { test_denormal_values(&func); } \
TEST_F(LlvmLibcSqrtTest, NormalRange) { test_normal_range(&func); } TEST_F(LlvmLibcSqrtTest, NormalRange) { test_normal_range(&func); }

libc/test/src/math/exhaustive/acosf_test.cpp

Show All 15 Lines
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcAcosfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcAcosfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
if (!r.success)
return true;
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPBits xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= TEST_MPFR_MATCH(mpfr::Operation::Acos, x, __llvm_libc::acosf(x), result &= TEST_MPFR_MATCH(mpfr::Operation::Acos, x, __llvm_libc::acosf(x),
0.5, rounding); 0.5, rounding);
} while (bits++ < stop); } while (bits++ < stop);
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

libc/test/src/math/exhaustive/acoshf_test.cpp

Show All 15 Lines
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcAcoshfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcAcoshfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
if (!r.success)
return true;
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPBits xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= TEST_MPFR_MATCH(mpfr::Operation::Acosh, x, result &= TEST_MPFR_MATCH(mpfr::Operation::Acosh, x,
__llvm_libc::acoshf(x), 0.5, rounding); __llvm_libc::acoshf(x), 0.5, rounding);
} while (bits++ < stop); } while (bits++ < stop);
Show All 25 Lines

libc/test/src/math/exhaustive/asinf_test.cpp

Show All 15 Lines
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcAsinfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcAsinfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
if (!r.success)
return true;
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPBits xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= TEST_MPFR_MATCH(mpfr::Operation::Asin, x, __llvm_libc::asinf(x), result &= TEST_MPFR_MATCH(mpfr::Operation::Asin, x, __llvm_libc::asinf(x),
0.5, rounding); 0.5, rounding);
// if (!result) break; // if (!result) break;
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

libc/test/src/math/exhaustive/asinhf_test.cpp

Show All 15 Lines
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcAsinhfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcAsinhfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
if (!r.success)
return true;
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPBits xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= TEST_MPFR_MATCH(mpfr::Operation::Asinh, x, result &= TEST_MPFR_MATCH(mpfr::Operation::Asinh, x,
__llvm_libc::asinhf(x), 0.5, rounding); __llvm_libc::asinhf(x), 0.5, rounding);
} while (bits++ < stop); } while (bits++ < stop);
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

libc/test/src/math/exhaustive/atanf_test.cpp

Show All 15 Lines
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcAtanfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcAtanfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
if (!r.success)
return true;
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPBits xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= TEST_MPFR_MATCH(mpfr::Operation::Atan, x, __llvm_libc::atanf(x), result &= TEST_MPFR_MATCH(mpfr::Operation::Atan, x, __llvm_libc::atanf(x),
0.5, rounding); 0.5, rounding);
} while (bits++ < stop); } while (bits++ < stop);
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

libc/test/src/math/exhaustive/atanhf_test.cpp

Show All 15 Lines
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcAtanhfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcAtanhfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
if (!r.success)
return true;
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPBits xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= TEST_MPFR_MATCH(mpfr::Operation::Atanh, x, result &= TEST_MPFR_MATCH(mpfr::Operation::Atanh, x,
__llvm_libc::atanhf(x), 0.5, rounding); __llvm_libc::atanhf(x), 0.5, rounding);
} while (bits++ < stop); } while (bits++ < stop);
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

libc/test/src/math/exhaustive/cosf_test.cpp

Show All 16 Lines
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcCosfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcCosfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
if (!r.success)
return true;
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPBits xbits(bits);
float x = float(xbits); float x = float(xbits);
bool r = TEST_MPFR_MATCH(mpfr::Operation::Cos, x, __llvm_libc::cosf(x), bool r = TEST_MPFR_MATCH(mpfr::Operation::Cos, x, __llvm_libc::cosf(x),
0.5, rounding); 0.5, rounding);
result &= r; result &= r;
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

libc/test/src/math/exhaustive/coshf_test.cpp

Show All 16 Lines
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcCoshfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcCoshfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
if (!r.success)
return true;
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPBits xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= TEST_MPFR_MATCH(mpfr::Operation::Cosh, x, __llvm_libc::coshf(x), result &= TEST_MPFR_MATCH(mpfr::Operation::Cosh, x, __llvm_libc::coshf(x),
0.5, rounding); 0.5, rounding);
} while (bits++ < stop); } while (bits++ < stop);
Show All 23 Lines

libc/test/src/math/exhaustive/exp10f_test.cpp

Show All 16 Lines
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcExp10fExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcExp10fExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
if (!r.success)
return true;
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPBits xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= TEST_MPFR_MATCH(mpfr::Operation::Exp10, x, result &= TEST_MPFR_MATCH(mpfr::Operation::Exp10, x,
__llvm_libc::exp10f(x), 0.5, rounding); __llvm_libc::exp10f(x), 0.5, rounding);
} while (bits++ < stop); } while (bits++ < stop);
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

libc/test/src/math/exhaustive/exp2f_test.cpp

Show All 14 Lines
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcExp2fExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcExp2fExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
if (!r.success)
return true;
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPBits xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= TEST_MPFR_MATCH(mpfr::Operation::Exp2, x, __llvm_libc::exp2f(x), result &= TEST_MPFR_MATCH(mpfr::Operation::Exp2, x, __llvm_libc::exp2f(x),
0.5, rounding); 0.5, rounding);
} while (bits++ < stop); } while (bits++ < stop);
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

libc/test/src/math/exhaustive/expf_test.cpp

Show All 16 Lines
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcExpfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcExpfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
if (!r.success)
return true;
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPBits xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= TEST_MPFR_MATCH(mpfr::Operation::Exp, x, __llvm_libc::expf(x), result &= TEST_MPFR_MATCH(mpfr::Operation::Exp, x, __llvm_libc::expf(x),
0.5, rounding); 0.5, rounding);
} while (bits++ < stop); } while (bits++ < stop);
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

libc/test/src/math/exhaustive/expm1f_test.cpp

Show All 15 Lines
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcExpm1fExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcExpm1fExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
if (!r.success)
return true;
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
uint32_t bits = stop; uint32_t bits = stop;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPBits xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= TEST_MPFR_MATCH(mpfr::Operation::Expm1, x, result &= TEST_MPFR_MATCH(mpfr::Operation::Expm1, x,
__llvm_libc::expm1f(x), 0.5, rounding); __llvm_libc::expm1f(x), 0.5, rounding);
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

libc/test/src/math/exhaustive/hypotf_test.cpp

Show All 19 Lines
struct LlvmLibcHypotfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcHypotfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
// Range of the second input: [2^37, 2^48). // Range of the second input: [2^37, 2^48).
constexpr uint32_t Y_START = (37U + 127U) << 23; constexpr uint32_t Y_START = (37U + 127U) << 23;
constexpr uint32_t Y_STOP = (48U + 127U) << 23; constexpr uint32_t Y_STOP = (48U + 127U) << 23;
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
if (!r.success)
return true;
uint32_t xbits = start; uint32_t xbits = start;
bool result = true; bool result = true;
do { do {
float x = float(FPBits(xbits)); float x = float(FPBits(xbits));
uint32_t ybits = Y_START; uint32_t ybits = Y_START;
do { do {
float y = float(FPBits(ybits)); float y = float(FPBits(ybits));
result &= TEST_FP_EQ(__llvm_libc::fputil::hypot(x, y), result &= TEST_FP_EQ(__llvm_libc::fputil::hypot(x, y),
Show All 31 Lines

libc/test/src/math/exhaustive/log10f_test.cpp

Show All 14 Lines
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcLog10fExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcLog10fExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
if (!r.success)
return true;
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPBits xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= TEST_MPFR_MATCH(mpfr::Operation::Log10, x, result &= TEST_MPFR_MATCH(mpfr::Operation::Log10, x,
__llvm_libc::log10f(x), 0.5, rounding); __llvm_libc::log10f(x), 0.5, rounding);
} while (bits++ < stop); } while (bits++ < stop);
Show All 25 Lines

libc/test/src/math/exhaustive/log1pf_test.cpp

Show All 14 Lines
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcLog1pfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcLog1pfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
if (!r.success)
return true;
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPBits xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= TEST_MPFR_MATCH(mpfr::Operation::Log1p, x, result &= TEST_MPFR_MATCH(mpfr::Operation::Log1p, x,
__llvm_libc::log1pf(x), 0.5, rounding); __llvm_libc::log1pf(x), 0.5, rounding);
} while (bits++ < stop); } while (bits++ < stop);
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

libc/test/src/math/exhaustive/log2f_test.cpp

Show All 14 Lines
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcLog2fExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcLog2fExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
if (!r.success)
return true;
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPBits xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= TEST_MPFR_MATCH(mpfr::Operation::Log2, x, __llvm_libc::log2f(x), result &= TEST_MPFR_MATCH(mpfr::Operation::Log2, x, __llvm_libc::log2f(x),
0.5, rounding); 0.5, rounding);
} while (bits++ < stop); } while (bits++ < stop);
Show All 23 Lines

libc/test/src/math/exhaustive/logf_test.cpp

Show All 14 Lines
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcLogfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcLogfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
if (!r.success)
return true;
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPBits xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= TEST_MPFR_MATCH(mpfr::Operation::Log, x, __llvm_libc::logf(x), result &= TEST_MPFR_MATCH(mpfr::Operation::Log, x, __llvm_libc::logf(x),
0.5, rounding); 0.5, rounding);
} while (bits++ < stop); } while (bits++ < stop);
Show All 23 Lines

libc/test/src/math/exhaustive/sincosf_test.cpp

Show All 16 Lines
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcSinCosfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcSinCosfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
if (!r.success)
return true;
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPBits xbits(bits);
float x = float(xbits); float x = float(xbits);
float sinx, cosx; float sinx, cosx;
__llvm_libc::sincosf(x, &sinx, &cosx); __llvm_libc::sincosf(x, &sinx, &cosx);
result &= TEST_MPFR_MATCH(mpfr::Operation::Sin, x, sinx, 0.5, rounding); result &= TEST_MPFR_MATCH(mpfr::Operation::Sin, x, sinx, 0.5, rounding);
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

libc/test/src/math/exhaustive/sinf_test.cpp

Show All 16 Lines
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcSinfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcSinfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
if (!r.success)
return true;
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPBits xbits(bits);
float x = float(xbits); float x = float(xbits);
bool r = TEST_MPFR_MATCH(mpfr::Operation::Sin, x, __llvm_libc::sinf(x), bool r = TEST_MPFR_MATCH(mpfr::Operation::Sin, x, __llvm_libc::sinf(x),
0.5, rounding); 0.5, rounding);
result &= r; result &= r;
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

libc/test/src/math/exhaustive/sinhf_test.cpp

Show All 16 Lines
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcSinhfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcSinhfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
if (!r.success)
return true;
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPBits xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= TEST_MPFR_MATCH(mpfr::Operation::Sinh, x, __llvm_libc::sinhf(x), result &= TEST_MPFR_MATCH(mpfr::Operation::Sinh, x, __llvm_libc::sinhf(x),
0.5, rounding); 0.5, rounding);
} while (bits++ < stop); } while (bits++ < stop);
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

libc/test/src/math/exhaustive/tanf_test.cpp

Show All 19 Lines
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
static constexpr int TOLERANCE = 3; static constexpr int TOLERANCE = 3;
struct LlvmLibcTanfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcTanfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
if (!r.success)
return true;
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
int tol = TOLERANCE; int tol = TOLERANCE;
do { do {
FPBits xbits(bits); FPBits xbits(bits);
float x = float(xbits); float x = float(xbits);
bool r = TEST_MPFR_MATCH(mpfr::Operation::Tan, x, __llvm_libc::tanf(x), bool r = TEST_MPFR_MATCH(mpfr::Operation::Tan, x, __llvm_libc::tanf(x),
0.5, rounding); 0.5, rounding);
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

libc/test/src/math/exhaustive/tanhf_test.cpp

Show All 15 Lines
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
struct LlvmLibcTanhfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> { struct LlvmLibcTanhfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
bool check(uint32_t start, uint32_t stop, bool check(uint32_t start, uint32_t stop,
mpfr::RoundingMode rounding) override { mpfr::RoundingMode rounding) override {
mpfr::ForceRoundingMode r(rounding); mpfr::ForceRoundingMode r(rounding);
if (!r.success)
return true;
uint32_t bits = start; uint32_t bits = start;
bool result = true; bool result = true;
do { do {
FPBits xbits(bits); FPBits xbits(bits);
float x = float(xbits); float x = float(xbits);
result &= TEST_MPFR_MATCH(mpfr::Operation::Tanh, x, __llvm_libc::tanhf(x), result &= TEST_MPFR_MATCH(mpfr::Operation::Tanh, x, __llvm_libc::tanhf(x),
0.5, rounding); 0.5, rounding);
} while (bits++ < stop); } while (bits++ < stop);
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

libc/test/src/math/log10_test.cpp

Show First 20 Lines • Show All 81 Lines • ▼ Show 20 LinesTEST(LlvmLibcLog10Test, InDoubleRange) {
constexpr uint64_t START = 0x3FD0'0000'0000'0000ULL; // 0.25 constexpr uint64_t START = 0x3FD0'0000'0000'0000ULL; // 0.25
constexpr uint64_t STOP = 0x4010'0000'0000'0000ULL; // 4.0 constexpr uint64_t STOP = 0x4010'0000'0000'0000ULL; // 4.0
// constexpr uint64_t START = 0x3FF0'0000'0000'0000ULL; // 1.0 // constexpr uint64_t START = 0x3FF0'0000'0000'0000ULL; // 1.0
// constexpr uint64_t STOP = 0x4000'0000'0000'0000ULL; // 2.0 // constexpr uint64_t STOP = 0x4000'0000'0000'0000ULL; // 2.0
constexpr uint64_t STEP = (STOP - START) / COUNT; constexpr uint64_t STEP = (STOP - START) / COUNT;
auto test = [&](mpfr::RoundingMode rounding_mode) { auto test = [&](mpfr::RoundingMode rounding_mode) {
mpfr::ForceRoundingMode __r(rounding_mode); mpfr::ForceRoundingMode __r(rounding_mode);
if (!__r.success)
return;
uint64_t fails = 0; uint64_t fails = 0;
uint64_t count = 0; uint64_t count = 0;
uint64_t cc = 0; uint64_t cc = 0;
double mx, mr = 0.0; double mx, mr = 0.0;
double tol = 0.5; double tol = 0.5;
for (uint64_t i = 0, v = START; i <= COUNT; ++i, v += STEP) { for (uint64_t i = 0, v = START; i <= COUNT; ++i, v += STEP) {
double x = FPBits(v).get_val(); double x = FPBits(v).get_val();
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

libc/test/src/math/log1p_test.cpp

Show First 20 Lines • Show All 80 Lines • ▼ Show 20 Lines
} }
TEST(LlvmLibcLog1pTest, InDoubleRange) { TEST(LlvmLibcLog1pTest, InDoubleRange) {
constexpr uint64_t COUNT = 4501; constexpr uint64_t COUNT = 4501;
auto test = [&](uint64_t start, uint64_t stop, auto test = [&](uint64_t start, uint64_t stop,
mpfr::RoundingMode rounding_mode) { mpfr::RoundingMode rounding_mode) {
mpfr::ForceRoundingMode __r(rounding_mode); mpfr::ForceRoundingMode __r(rounding_mode);
if (!__r.success)
return;
uint64_t fails = 0; uint64_t fails = 0;
uint64_t count = 0; uint64_t count = 0;
uint64_t cc = 0; uint64_t cc = 0;
double mx, mr = 0.0; double mx, mr = 0.0;
double tol = 0.5; double tol = 0.5;
uint64_t step = (stop - start) / COUNT; uint64_t step = (stop - start) / COUNT;
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

libc/test/src/math/log2_test.cpp

Show First 20 Lines • Show All 81 Lines • ▼ Show 20 LinesTEST(LlvmLibcLog2Test, InDoubleRange) {
constexpr uint64_t START = 0x3FD0'0000'0000'0000ULL; // 0.25 constexpr uint64_t START = 0x3FD0'0000'0000'0000ULL; // 0.25
constexpr uint64_t STOP = 0x4010'0000'0000'0000ULL; // 4.0 constexpr uint64_t STOP = 0x4010'0000'0000'0000ULL; // 4.0
// constexpr uint64_t START = 0x3FF0'0000'0000'0000ULL; // 1.0 // constexpr uint64_t START = 0x3FF0'0000'0000'0000ULL; // 1.0
// constexpr uint64_t STOP = 0x4000'0000'0000'0000ULL; // 2.0 // constexpr uint64_t STOP = 0x4000'0000'0000'0000ULL; // 2.0
constexpr uint64_t STEP = (STOP - START) / COUNT; constexpr uint64_t STEP = (STOP - START) / COUNT;
auto test = [&](mpfr::RoundingMode rounding_mode) { auto test = [&](mpfr::RoundingMode rounding_mode) {
mpfr::ForceRoundingMode __r(rounding_mode); mpfr::ForceRoundingMode __r(rounding_mode);
if (!__r.success)
return;
uint64_t fails = 0; uint64_t fails = 0;
uint64_t count = 0; uint64_t count = 0;
uint64_t cc = 0; uint64_t cc = 0;
double mx, mr = 0.0; double mx, mr = 0.0;
double tol = 0.5; double tol = 0.5;
for (uint64_t i = 0, v = START; i <= COUNT; ++i, v += STEP) { for (uint64_t i = 0, v = START; i <= COUNT; ++i, v += STEP) {
double x = FPBits(v).get_val(); double x = FPBits(v).get_val();
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

libc/test/src/math/log_test.cpp

Show First 20 Lines • Show All 81 Lines • ▼ Show 20 LinesTEST(LlvmLibcLogTest, InDoubleRange) {
constexpr uint64_t START = 0x3FD0'0000'0000'0000ULL; // 0.25 constexpr uint64_t START = 0x3FD0'0000'0000'0000ULL; // 0.25
constexpr uint64_t STOP = 0x4010'0000'0000'0000ULL; // 4.0 constexpr uint64_t STOP = 0x4010'0000'0000'0000ULL; // 4.0
// constexpr uint64_t START = 0x3FF0'0000'0000'0000ULL; // 1.0 // constexpr uint64_t START = 0x3FF0'0000'0000'0000ULL; // 1.0
// constexpr uint64_t STOP = 0x4000'0000'0000'0000ULL; // 2.0 // constexpr uint64_t STOP = 0x4000'0000'0000'0000ULL; // 2.0
constexpr uint64_t STEP = (STOP - START) / COUNT; constexpr uint64_t STEP = (STOP - START) / COUNT;
auto test = [&](mpfr::RoundingMode rounding_mode) { auto test = [&](mpfr::RoundingMode rounding_mode) {
mpfr::ForceRoundingMode __r(rounding_mode); mpfr::ForceRoundingMode __r(rounding_mode);
if (!__r.success)
return;
uint64_t fails = 0; uint64_t fails = 0;
uint64_t count = 0; uint64_t count = 0;
uint64_t cc = 0; uint64_t cc = 0;
double mx, mr = 0.0; double mx, mr = 0.0;
double tol = 0.5; double tol = 0.5;
for (uint64_t i = 0, v = START; i <= COUNT; ++i, v += STEP) { for (uint64_t i = 0, v = START; i <= COUNT; ++i, v += STEP) {
double x = FPBits(v).get_val(); double x = FPBits(v).get_val();
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

libc/test/src/math/sincosf_test.cpp

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
} }
#define EXPECT_SINCOS_MATCH_ALL_ROUNDING(input) \ #define EXPECT_SINCOS_MATCH_ALL_ROUNDING(input) \
{ \ { \
float sin, cos; \ float sin, cos; \
namespace mpfr = __llvm_libc::testing::mpfr; \ namespace mpfr = __llvm_libc::testing::mpfr; \
\ \
mpfr::ForceRoundingMode __r1(mpfr::RoundingMode::Nearest); \ mpfr::ForceRoundingMode __r1(mpfr::RoundingMode::Nearest); \
if (__r1.success) { \
__llvm_libc::sincosf(input, &sin, &cos); \ __llvm_libc::sincosf(input, &sin, &cos); \
EXPECT_MPFR_MATCH(mpfr::Operation::Sin, input, sin, 0.5, \ EXPECT_MPFR_MATCH(mpfr::Operation::Sin, input, sin, 0.5, \
mpfr::RoundingMode::Nearest); \ mpfr::RoundingMode::Nearest); \
EXPECT_MPFR_MATCH(mpfr::Operation::Cos, input, cos, 0.5, \ EXPECT_MPFR_MATCH(mpfr::Operation::Cos, input, cos, 0.5, \
mpfr::RoundingMode::Nearest); \ mpfr::RoundingMode::Nearest); \
} \
\ \
mpfr::ForceRoundingMode __r2(mpfr::RoundingMode::Upward); \ mpfr::ForceRoundingMode __r2(mpfr::RoundingMode::Upward); \
if (__r2.success) { \
__llvm_libc::sincosf(input, &sin, &cos); \ __llvm_libc::sincosf(input, &sin, &cos); \
EXPECT_MPFR_MATCH(mpfr::Operation::Sin, input, sin, 0.5, \ EXPECT_MPFR_MATCH(mpfr::Operation::Sin, input, sin, 0.5, \
mpfr::RoundingMode::Upward); \ mpfr::RoundingMode::Upward); \
EXPECT_MPFR_MATCH(mpfr::Operation::Cos, input, cos, 0.5, \ EXPECT_MPFR_MATCH(mpfr::Operation::Cos, input, cos, 0.5, \
mpfr::RoundingMode::Upward); \ mpfr::RoundingMode::Upward); \
} \
\ \
mpfr::ForceRoundingMode __r3(mpfr::RoundingMode::Downward); \ mpfr::ForceRoundingMode __r3(mpfr::RoundingMode::Downward); \
if (__r3.success) { \
__llvm_libc::sincosf(input, &sin, &cos); \ __llvm_libc::sincosf(input, &sin, &cos); \
EXPECT_MPFR_MATCH(mpfr::Operation::Sin, input, sin, 0.5, \ EXPECT_MPFR_MATCH(mpfr::Operation::Sin, input, sin, 0.5, \
mpfr::RoundingMode::Downward); \ mpfr::RoundingMode::Downward); \
EXPECT_MPFR_MATCH(mpfr::Operation::Cos, input, cos, 0.5, \ EXPECT_MPFR_MATCH(mpfr::Operation::Cos, input, cos, 0.5, \
mpfr::RoundingMode::Downward); \ mpfr::RoundingMode::Downward); \
} \
\ \
mpfr::ForceRoundingMode __r4(mpfr::RoundingMode::TowardZero); \ mpfr::ForceRoundingMode __r4(mpfr::RoundingMode::TowardZero); \
if (__r4.success) { \
__llvm_libc::sincosf(input, &sin, &cos); \ __llvm_libc::sincosf(input, &sin, &cos); \
EXPECT_MPFR_MATCH(mpfr::Operation::Sin, input, sin, 0.5, \ EXPECT_MPFR_MATCH(mpfr::Operation::Sin, input, sin, 0.5, \
mpfr::RoundingMode::TowardZero); \ mpfr::RoundingMode::TowardZero); \
EXPECT_MPFR_MATCH(mpfr::Operation::Cos, input, cos, 0.5, \ EXPECT_MPFR_MATCH(mpfr::Operation::Cos, input, cos, 0.5, \
mpfr::RoundingMode::TowardZero); \ mpfr::RoundingMode::TowardZero); \
} \
} }
TEST(LlvmLibcSinCosfTest, InFloatRange) { TEST(LlvmLibcSinCosfTest, InFloatRange) {
constexpr uint32_t COUNT = 1'001; constexpr uint32_t COUNT = 1'001;
constexpr uint32_t STEP = UINT32_MAX / COUNT; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits((v))); float x = float(FPBits((v)));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

libc/test/src/stdio/sprintf_test.cpp

Show All 18 Lines
// } // }
class LlvmLibcSPrintfTest : public __llvm_libc::testing::Test { class LlvmLibcSPrintfTest : public __llvm_libc::testing::Test {
protected: protected:
char buff[1000]; char buff[1000];
int written; int written;
}; };
using __llvm_libc::fputil::testing::ForceRoundingMode;
using __llvm_libc::fputil::testing::RoundingMode;
// Subtract 1 from sizeof(expected_str) to account for the null byte. // Subtract 1 from sizeof(expected_str) to account for the null byte.
#define ASSERT_STREQ_LEN(actual_written, actual_str, expected_str) \ #define ASSERT_STREQ_LEN(actual_written, actual_str, expected_str) \
EXPECT_EQ(actual_written, static_cast<int>(sizeof(expected_str) - 1)); \ EXPECT_EQ(actual_written, static_cast<int>(sizeof(expected_str) - 1)); \
EXPECT_STREQ(actual_str, expected_str); EXPECT_STREQ(actual_str, expected_str);
TEST(LlvmLibcSPrintfTest, SimpleNoConv) { TEST(LlvmLibcSPrintfTest, SimpleNoConv) {
char buff[64]; char buff[64];
int written; int written;
▲ Show 20 Lines • Show All 465 Lines • ▼ Show 20 Lines written = __llvm_libc::sprintf(buff, "%04hho %#.5llo %-6.3zo", 256 + 077,
01000000000000ll, size_t(2)); 01000000000000ll, size_t(2));
EXPECT_EQ(written, 26); EXPECT_EQ(written, 26);
ASSERT_STREQ(buff, "0077 01000000000000 002 "); ASSERT_STREQ(buff, "0077 01000000000000 002 ");
} }
#ifndef LIBC_COPT_PRINTF_DISABLE_FLOAT #ifndef LIBC_COPT_PRINTF_DISABLE_FLOAT
TEST_F(LlvmLibcSPrintfTest, FloatHexExpConv) { TEST_F(LlvmLibcSPrintfTest, FloatHexExpConv) {
__llvm_libc::fputil::testing::ForceRoundingMode r( ForceRoundingMode r(RoundingMode::Nearest);
__llvm_libc::fputil::testing::RoundingMode::Nearest);
double inf = __llvm_libc::fputil::FPBits<double>::inf().get_val(); double inf = __llvm_libc::fputil::FPBits<double>::inf().get_val();
double nan = __llvm_libc::fputil::FPBits<double>::build_nan(1); double nan = __llvm_libc::fputil::FPBits<double>::build_nan(1);
written = __llvm_libc::sprintf(buff, "%a", 1.0); written = __llvm_libc::sprintf(buff, "%a", 1.0);
ASSERT_STREQ_LEN(written, buff, "0x1p+0"); ASSERT_STREQ_LEN(written, buff, "0x1p+0");
written = __llvm_libc::sprintf(buff, "%A", -1.0); written = __llvm_libc::sprintf(buff, "%A", -1.0);
ASSERT_STREQ_LEN(written, buff, "-0X1P+0"); ASSERT_STREQ_LEN(written, buff, "-0X1P+0");
▲ Show 20 Lines • Show All 182 Lines • ▼ Show 20 Lines
#elif defined(LONG_DOUBLE_IS_DOUBLE) #elif defined(LONG_DOUBLE_IS_DOUBLE)
ASSERT_STREQ_LEN(written, buff, "inf"); ASSERT_STREQ_LEN(written, buff, "inf");
#else // 128 bit long double #else // 128 bit long double
ASSERT_STREQ_LEN(written, buff, "0x2.0p+16383"); ASSERT_STREQ_LEN(written, buff, "0x2.0p+16383");
#endif #endif
// Rounding Mode Tests. // Rounding Mode Tests.
{ if (ForceRoundingMode r(RoundingMode::Nearest); r.success) {
__llvm_libc::fputil::testing::ForceRoundingMode r(
__llvm_libc::fputil::testing::RoundingMode::Nearest);
written = __llvm_libc::sprintf(buff, "%.1a", 0x1.08p0); written = __llvm_libc::sprintf(buff, "%.1a", 0x1.08p0);
ASSERT_STREQ_LEN(written, buff, "0x1.0p+0"); ASSERT_STREQ_LEN(written, buff, "0x1.0p+0");
written = __llvm_libc::sprintf(buff, "%.1a", 0x1.18p0); written = __llvm_libc::sprintf(buff, "%.1a", 0x1.18p0);
ASSERT_STREQ_LEN(written, buff, "0x1.2p+0"); ASSERT_STREQ_LEN(written, buff, "0x1.2p+0");
written = __llvm_libc::sprintf(buff, "%.1a", 0x1.04p0); written = __llvm_libc::sprintf(buff, "%.1a", 0x1.04p0);
ASSERT_STREQ_LEN(written, buff, "0x1.0p+0"); ASSERT_STREQ_LEN(written, buff, "0x1.0p+0");
Show All 9 Lines if (ForceRoundingMode r(RoundingMode::Nearest); r.success) {
written = __llvm_libc::sprintf(buff, "%.1a", -0x1.04p0); written = __llvm_libc::sprintf(buff, "%.1a", -0x1.04p0);
ASSERT_STREQ_LEN(written, buff, "-0x1.0p+0"); ASSERT_STREQ_LEN(written, buff, "-0x1.0p+0");
written = __llvm_libc::sprintf(buff, "%.1a", -0x1.14p0); written = __llvm_libc::sprintf(buff, "%.1a", -0x1.14p0);
ASSERT_STREQ_LEN(written, buff, "-0x1.1p+0"); ASSERT_STREQ_LEN(written, buff, "-0x1.1p+0");
} }
{ if (ForceRoundingMode r(RoundingMode::Upward); r.success) {
__llvm_libc::fputil::testing::ForceRoundingMode r(
__llvm_libc::fputil::testing::RoundingMode::Upward);
written = __llvm_libc::sprintf(buff, "%.1a", 0x1.08p0); written = __llvm_libc::sprintf(buff, "%.1a", 0x1.08p0);
ASSERT_STREQ_LEN(written, buff, "0x1.1p+0"); ASSERT_STREQ_LEN(written, buff, "0x1.1p+0");
written = __llvm_libc::sprintf(buff, "%.1a", 0x1.18p0); written = __llvm_libc::sprintf(buff, "%.1a", 0x1.18p0);
ASSERT_STREQ_LEN(written, buff, "0x1.2p+0"); ASSERT_STREQ_LEN(written, buff, "0x1.2p+0");
written = __llvm_libc::sprintf(buff, "%.1a", 0x1.04p0); written = __llvm_libc::sprintf(buff, "%.1a", 0x1.04p0);
ASSERT_STREQ_LEN(written, buff, "0x1.1p+0"); ASSERT_STREQ_LEN(written, buff, "0x1.1p+0");
Show All 9 Lines if (ForceRoundingMode r(RoundingMode::Upward); r.success) {
written = __llvm_libc::sprintf(buff, "%.1a", -0x1.04p0); written = __llvm_libc::sprintf(buff, "%.1a", -0x1.04p0);
ASSERT_STREQ_LEN(written, buff, "-0x1.0p+0"); ASSERT_STREQ_LEN(written, buff, "-0x1.0p+0");
written = __llvm_libc::sprintf(buff, "%.1a", -0x1.14p0); written = __llvm_libc::sprintf(buff, "%.1a", -0x1.14p0);
ASSERT_STREQ_LEN(written, buff, "-0x1.1p+0"); ASSERT_STREQ_LEN(written, buff, "-0x1.1p+0");
} }
{ if (ForceRoundingMode r(RoundingMode::Downward); r.success) {
__llvm_libc::fputil::testing::ForceRoundingMode r(
__llvm_libc::fputil::testing::RoundingMode::Downward);
written = __llvm_libc::sprintf(buff, "%.1a", 0x1.08p0); written = __llvm_libc::sprintf(buff, "%.1a", 0x1.08p0);
ASSERT_STREQ_LEN(written, buff, "0x1.0p+0"); ASSERT_STREQ_LEN(written, buff, "0x1.0p+0");
written = __llvm_libc::sprintf(buff, "%.1a", 0x1.18p0); written = __llvm_libc::sprintf(buff, "%.1a", 0x1.18p0);
ASSERT_STREQ_LEN(written, buff, "0x1.1p+0"); ASSERT_STREQ_LEN(written, buff, "0x1.1p+0");
written = __llvm_libc::sprintf(buff, "%.1a", 0x1.04p0); written = __llvm_libc::sprintf(buff, "%.1a", 0x1.04p0);
ASSERT_STREQ_LEN(written, buff, "0x1.0p+0"); ASSERT_STREQ_LEN(written, buff, "0x1.0p+0");
Show All 9 Lines if (ForceRoundingMode r(RoundingMode::Downward); r.success) {
written = __llvm_libc::sprintf(buff, "%.1a", -0x1.04p0); written = __llvm_libc::sprintf(buff, "%.1a", -0x1.04p0);
ASSERT_STREQ_LEN(written, buff, "-0x1.1p+0"); ASSERT_STREQ_LEN(written, buff, "-0x1.1p+0");
written = __llvm_libc::sprintf(buff, "%.1a", -0x1.14p0); written = __llvm_libc::sprintf(buff, "%.1a", -0x1.14p0);
ASSERT_STREQ_LEN(written, buff, "-0x1.2p+0"); ASSERT_STREQ_LEN(written, buff, "-0x1.2p+0");
} }
{ if (ForceRoundingMode r(RoundingMode::TowardZero); r.success) {
__llvm_libc::fputil::testing::ForceRoundingMode r(
__llvm_libc::fputil::testing::RoundingMode::TowardZero);
written = __llvm_libc::sprintf(buff, "%.1a", 0x1.08p0); written = __llvm_libc::sprintf(buff, "%.1a", 0x1.08p0);
ASSERT_STREQ_LEN(written, buff, "0x1.0p+0"); ASSERT_STREQ_LEN(written, buff, "0x1.0p+0");
written = __llvm_libc::sprintf(buff, "%.1a", 0x1.18p0); written = __llvm_libc::sprintf(buff, "%.1a", 0x1.18p0);
ASSERT_STREQ_LEN(written, buff, "0x1.1p+0"); ASSERT_STREQ_LEN(written, buff, "0x1.1p+0");
written = __llvm_libc::sprintf(buff, "%.1a", 0x1.04p0); written = __llvm_libc::sprintf(buff, "%.1a", 0x1.04p0);
ASSERT_STREQ_LEN(written, buff, "0x1.0p+0"); ASSERT_STREQ_LEN(written, buff, "0x1.0p+0");
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Lines#endif
written = __llvm_libc::sprintf(buff, "%12.3a %-12.3A", 0.1, 256.0); written = __llvm_libc::sprintf(buff, "%12.3a %-12.3A", 0.1, 256.0);
ASSERT_STREQ_LEN(written, buff, " 0x1.99ap-4 0X1.000P+8 "); ASSERT_STREQ_LEN(written, buff, " 0x1.99ap-4 0X1.000P+8 ");
written = __llvm_libc::sprintf(buff, "%+-#12.3a % 012.3a", 0.1256, 1256.0); written = __llvm_libc::sprintf(buff, "%+-#12.3a % 012.3a", 0.1256, 1256.0);
ASSERT_STREQ_LEN(written, buff, "+0x1.014p-3 0x1.3a0p+10"); ASSERT_STREQ_LEN(written, buff, "+0x1.014p-3 0x1.3a0p+10");
} }
TEST_F(LlvmLibcSPrintfTest, FloatDecimalConv) { TEST_F(LlvmLibcSPrintfTest, FloatDecimalConv) {
__llvm_libc::fputil::testing::ForceRoundingMode r( ForceRoundingMode r(RoundingMode::Nearest);
__llvm_libc::fputil::testing::RoundingMode::Nearest);
double inf = __llvm_libc::fputil::FPBits<double>::inf().get_val(); double inf = __llvm_libc::fputil::FPBits<double>::inf().get_val();
double nan = __llvm_libc::fputil::FPBits<double>::build_nan(1); double nan = __llvm_libc::fputil::FPBits<double>::build_nan(1);
written = __llvm_libc::sprintf(buff, "%f", 1.0); written = __llvm_libc::sprintf(buff, "%f", 1.0);
ASSERT_STREQ_LEN(written, buff, "1.000000"); ASSERT_STREQ_LEN(written, buff, "1.000000");
written = __llvm_libc::sprintf(buff, "%F", -1.0); written = __llvm_libc::sprintf(buff, "%F", -1.0);
ASSERT_STREQ_LEN(written, buff, "-1.000000"); ASSERT_STREQ_LEN(written, buff, "-1.000000");
▲ Show 20 Lines • Show All 456 Lines • ▼ Show 20 Lines #elif defined(LONG_DOUBLE_IS_DOUBLE)
ASSERT_STREQ_LEN(written, buff, "inf"); ASSERT_STREQ_LEN(written, buff, "inf");
#else // 128 bit long double #else // 128 bit long double
ASSERT_STREQ_LEN(written, buff, "0x2.0p+16383"); ASSERT_STREQ_LEN(written, buff, "0x2.0p+16383");
#endif #endif
*/ */
// Rounding Mode Tests. // Rounding Mode Tests.
{ if (ForceRoundingMode r(RoundingMode::Nearest); r.success) {
__llvm_libc::fputil::testing::ForceRoundingMode r(
__llvm_libc::fputil::testing::RoundingMode::Nearest);
written = __llvm_libc::sprintf(buff, "%.1f", 1.75); written = __llvm_libc::sprintf(buff, "%.1f", 1.75);
ASSERT_STREQ_LEN(written, buff, "1.8"); ASSERT_STREQ_LEN(written, buff, "1.8");
written = __llvm_libc::sprintf(buff, "%.1f", 1.25); written = __llvm_libc::sprintf(buff, "%.1f", 1.25);
ASSERT_STREQ_LEN(written, buff, "1.2"); ASSERT_STREQ_LEN(written, buff, "1.2");
written = __llvm_libc::sprintf(buff, "%.1f", 1.125); written = __llvm_libc::sprintf(buff, "%.1f", 1.125);
ASSERT_STREQ_LEN(written, buff, "1.1"); ASSERT_STREQ_LEN(written, buff, "1.1");
Show All 21 Lines if (ForceRoundingMode r(RoundingMode::Nearest); r.success) {
written = __llvm_libc::sprintf(buff, "%.1f", -1.375); written = __llvm_libc::sprintf(buff, "%.1f", -1.375);
ASSERT_STREQ_LEN(written, buff, "-1.4"); ASSERT_STREQ_LEN(written, buff, "-1.4");
written = __llvm_libc::sprintf(buff, "%.1f", -1.875); written = __llvm_libc::sprintf(buff, "%.1f", -1.875);
ASSERT_STREQ_LEN(written, buff, "-1.9"); ASSERT_STREQ_LEN(written, buff, "-1.9");
} }
{ if (ForceRoundingMode r(RoundingMode::Upward); r.success) {
__llvm_libc::fputil::testing::ForceRoundingMode r(
__llvm_libc::fputil::testing::RoundingMode::Upward);
written = __llvm_libc::sprintf(buff, "%.1f", 1.75); written = __llvm_libc::sprintf(buff, "%.1f", 1.75);
ASSERT_STREQ_LEN(written, buff, "1.8"); ASSERT_STREQ_LEN(written, buff, "1.8");
written = __llvm_libc::sprintf(buff, "%.1f", 1.25); written = __llvm_libc::sprintf(buff, "%.1f", 1.25);
ASSERT_STREQ_LEN(written, buff, "1.3"); ASSERT_STREQ_LEN(written, buff, "1.3");
written = __llvm_libc::sprintf(buff, "%.1f", 1.125); written = __llvm_libc::sprintf(buff, "%.1f", 1.125);
ASSERT_STREQ_LEN(written, buff, "1.2"); ASSERT_STREQ_LEN(written, buff, "1.2");
Show All 21 Lines if (ForceRoundingMode r(RoundingMode::Upward); r.success) {
written = __llvm_libc::sprintf(buff, "%.1f", -1.375); written = __llvm_libc::sprintf(buff, "%.1f", -1.375);
ASSERT_STREQ_LEN(written, buff, "-1.3"); ASSERT_STREQ_LEN(written, buff, "-1.3");
written = __llvm_libc::sprintf(buff, "%.1f", -1.875); written = __llvm_libc::sprintf(buff, "%.1f", -1.875);
ASSERT_STREQ_LEN(written, buff, "-1.8"); ASSERT_STREQ_LEN(written, buff, "-1.8");
} }
{ if (ForceRoundingMode r(RoundingMode::Downward); r.success) {
__llvm_libc::fputil::testing::ForceRoundingMode r(
__llvm_libc::fputil::testing::RoundingMode::Downward);
written = __llvm_libc::sprintf(buff, "%.1f", 1.75); written = __llvm_libc::sprintf(buff, "%.1f", 1.75);
ASSERT_STREQ_LEN(written, buff, "1.7"); ASSERT_STREQ_LEN(written, buff, "1.7");
written = __llvm_libc::sprintf(buff, "%.1f", 1.25); written = __llvm_libc::sprintf(buff, "%.1f", 1.25);
ASSERT_STREQ_LEN(written, buff, "1.2"); ASSERT_STREQ_LEN(written, buff, "1.2");
written = __llvm_libc::sprintf(buff, "%.1f", 1.125); written = __llvm_libc::sprintf(buff, "%.1f", 1.125);
ASSERT_STREQ_LEN(written, buff, "1.1"); ASSERT_STREQ_LEN(written, buff, "1.1");
Show All 21 Lines if (ForceRoundingMode r(RoundingMode::Downward); r.success) {
written = __llvm_libc::sprintf(buff, "%.1f", -1.375); written = __llvm_libc::sprintf(buff, "%.1f", -1.375);
ASSERT_STREQ_LEN(written, buff, "-1.4"); ASSERT_STREQ_LEN(written, buff, "-1.4");
written = __llvm_libc::sprintf(buff, "%.1f", -1.875); written = __llvm_libc::sprintf(buff, "%.1f", -1.875);
ASSERT_STREQ_LEN(written, buff, "-1.9"); ASSERT_STREQ_LEN(written, buff, "-1.9");
} }
{ if (ForceRoundingMode r(RoundingMode::TowardZero); r.success) {
__llvm_libc::fputil::testing::ForceRoundingMode r(
__llvm_libc::fputil::testing::RoundingMode::TowardZero);
written = __llvm_libc::sprintf(buff, "%.1f", 1.75); written = __llvm_libc::sprintf(buff, "%.1f", 1.75);
ASSERT_STREQ_LEN(written, buff, "1.7"); ASSERT_STREQ_LEN(written, buff, "1.7");
written = __llvm_libc::sprintf(buff, "%.1f", 1.25); written = __llvm_libc::sprintf(buff, "%.1f", 1.25);
ASSERT_STREQ_LEN(written, buff, "1.2"); ASSERT_STREQ_LEN(written, buff, "1.2");
written = __llvm_libc::sprintf(buff, "%.1f", 1.125); written = __llvm_libc::sprintf(buff, "%.1f", 1.125);
ASSERT_STREQ_LEN(written, buff, "1.1"); ASSERT_STREQ_LEN(written, buff, "1.1");
▲ Show 20 Lines • Show All 89 Lines • ▼ Show 20 Lines#endif // SPECIAL_X86_LONG_DOUBLE
written = __llvm_libc::sprintf(buff, "%12.3f %-12.3f", 0.1, 256.0); written = __llvm_libc::sprintf(buff, "%12.3f %-12.3f", 0.1, 256.0);
ASSERT_STREQ_LEN(written, buff, " 0.100 256.000 "); ASSERT_STREQ_LEN(written, buff, " 0.100 256.000 ");
written = __llvm_libc::sprintf(buff, "%+-#12.3f % 012.3f", 0.1256, 1256.0); written = __llvm_libc::sprintf(buff, "%+-#12.3f % 012.3f", 0.1256, 1256.0);
ASSERT_STREQ_LEN(written, buff, "+0.126 0001256.000"); ASSERT_STREQ_LEN(written, buff, "+0.126 0001256.000");
} }
TEST_F(LlvmLibcSPrintfTest, FloatExponentConv) { TEST_F(LlvmLibcSPrintfTest, FloatExponentConv) {
__llvm_libc::fputil::testing::ForceRoundingMode r( ForceRoundingMode r(RoundingMode::Nearest);
__llvm_libc::fputil::testing::RoundingMode::Nearest);
double inf = __llvm_libc::fputil::FPBits<double>::inf().get_val(); double inf = __llvm_libc::fputil::FPBits<double>::inf().get_val();
double nan = __llvm_libc::fputil::FPBits<double>::build_nan(1); double nan = __llvm_libc::fputil::FPBits<double>::build_nan(1);
written = __llvm_libc::sprintf(buff, "%e", 1.0); written = __llvm_libc::sprintf(buff, "%e", 1.0);
ASSERT_STREQ_LEN(written, buff, "1.000000e+00"); ASSERT_STREQ_LEN(written, buff, "1.000000e+00");
written = __llvm_libc::sprintf(buff, "%E", -1.0); written = __llvm_libc::sprintf(buff, "%E", -1.0);
ASSERT_STREQ_LEN(written, buff, "-1.000000E+00"); ASSERT_STREQ_LEN(written, buff, "-1.000000E+00");
▲ Show 20 Lines • Show All 336 Lines • ▼ Show 20 Lines #elif defined(LONG_DOUBLE_IS_DOUBLE)
ASSERT_STREQ_LEN(written, buff, "inf"); ASSERT_STREQ_LEN(written, buff, "inf");
#else // 128 bit long double #else // 128 bit long double
ASSERT_STREQ_LEN(written, buff, "0x2.0p+16383"); ASSERT_STREQ_LEN(written, buff, "0x2.0p+16383");
#endif #endif
*/ */
// Rounding Mode Tests. // Rounding Mode Tests.
{ if (ForceRoundingMode r(RoundingMode::Nearest); r.success) {
__llvm_libc::fputil::testing::ForceRoundingMode r(
__llvm_libc::fputil::testing::RoundingMode::Nearest);
written = __llvm_libc::sprintf(buff, "%.1e", 1.75); written = __llvm_libc::sprintf(buff, "%.1e", 1.75);
ASSERT_STREQ_LEN(written, buff, "1.8e+00"); ASSERT_STREQ_LEN(written, buff, "1.8e+00");
written = __llvm_libc::sprintf(buff, "%.1e", 1.25); written = __llvm_libc::sprintf(buff, "%.1e", 1.25);
ASSERT_STREQ_LEN(written, buff, "1.2e+00"); ASSERT_STREQ_LEN(written, buff, "1.2e+00");
written = __llvm_libc::sprintf(buff, "%.1e", 1.125); written = __llvm_libc::sprintf(buff, "%.1e", 1.125);
ASSERT_STREQ_LEN(written, buff, "1.1e+00"); ASSERT_STREQ_LEN(written, buff, "1.1e+00");
Show All 21 Lines if (ForceRoundingMode r(RoundingMode::Nearest); r.success) {
written = __llvm_libc::sprintf(buff, "%.1e", -1.375); written = __llvm_libc::sprintf(buff, "%.1e", -1.375);
ASSERT_STREQ_LEN(written, buff, "-1.4e+00"); ASSERT_STREQ_LEN(written, buff, "-1.4e+00");
written = __llvm_libc::sprintf(buff, "%.1e", -1.875); written = __llvm_libc::sprintf(buff, "%.1e", -1.875);
ASSERT_STREQ_LEN(written, buff, "-1.9e+00"); ASSERT_STREQ_LEN(written, buff, "-1.9e+00");
} }
{ if (ForceRoundingMode r(RoundingMode::Upward); r.success) {
__llvm_libc::fputil::testing::ForceRoundingMode r(
__llvm_libc::fputil::testing::RoundingMode::Upward);
written = __llvm_libc::sprintf(buff, "%.1e", 1.75); written = __llvm_libc::sprintf(buff, "%.1e", 1.75);
ASSERT_STREQ_LEN(written, buff, "1.8e+00"); ASSERT_STREQ_LEN(written, buff, "1.8e+00");
written = __llvm_libc::sprintf(buff, "%.1e", 1.25); written = __llvm_libc::sprintf(buff, "%.1e", 1.25);
ASSERT_STREQ_LEN(written, buff, "1.3e+00"); ASSERT_STREQ_LEN(written, buff, "1.3e+00");
written = __llvm_libc::sprintf(buff, "%.1e", 1.125); written = __llvm_libc::sprintf(buff, "%.1e", 1.125);
ASSERT_STREQ_LEN(written, buff, "1.2e+00"); ASSERT_STREQ_LEN(written, buff, "1.2e+00");
Show All 21 Lines if (ForceRoundingMode r(RoundingMode::Upward); r.success) {
written = __llvm_libc::sprintf(buff, "%.1e", -1.375); written = __llvm_libc::sprintf(buff, "%.1e", -1.375);
ASSERT_STREQ_LEN(written, buff, "-1.3e+00"); ASSERT_STREQ_LEN(written, buff, "-1.3e+00");
written = __llvm_libc::sprintf(buff, "%.1e", -1.875); written = __llvm_libc::sprintf(buff, "%.1e", -1.875);
ASSERT_STREQ_LEN(written, buff, "-1.8e+00"); ASSERT_STREQ_LEN(written, buff, "-1.8e+00");
} }
{ if (ForceRoundingMode r(RoundingMode::Downward); r.success) {
__llvm_libc::fputil::testing::ForceRoundingMode r(
__llvm_libc::fputil::testing::RoundingMode::Downward);
written = __llvm_libc::sprintf(buff, "%.1e", 1.75); written = __llvm_libc::sprintf(buff, "%.1e", 1.75);
ASSERT_STREQ_LEN(written, buff, "1.7e+00"); ASSERT_STREQ_LEN(written, buff, "1.7e+00");
written = __llvm_libc::sprintf(buff, "%.1e", 1.25); written = __llvm_libc::sprintf(buff, "%.1e", 1.25);
ASSERT_STREQ_LEN(written, buff, "1.2e+00"); ASSERT_STREQ_LEN(written, buff, "1.2e+00");
written = __llvm_libc::sprintf(buff, "%.1e", 1.125); written = __llvm_libc::sprintf(buff, "%.1e", 1.125);
ASSERT_STREQ_LEN(written, buff, "1.1e+00"); ASSERT_STREQ_LEN(written, buff, "1.1e+00");
Show All 21 Lines if (ForceRoundingMode r(RoundingMode::Downward); r.success) {
written = __llvm_libc::sprintf(buff, "%.1e", -1.375); written = __llvm_libc::sprintf(buff, "%.1e", -1.375);
ASSERT_STREQ_LEN(written, buff, "-1.4e+00"); ASSERT_STREQ_LEN(written, buff, "-1.4e+00");
written = __llvm_libc::sprintf(buff, "%.1e", -1.875); written = __llvm_libc::sprintf(buff, "%.1e", -1.875);
ASSERT_STREQ_LEN(written, buff, "-1.9e+00"); ASSERT_STREQ_LEN(written, buff, "-1.9e+00");
} }
{ if (ForceRoundingMode r(RoundingMode::TowardZero); r.success) {
__llvm_libc::fputil::testing::ForceRoundingMode r(
__llvm_libc::fputil::testing::RoundingMode::TowardZero);
written = __llvm_libc::sprintf(buff, "%.1e", 1.75); written = __llvm_libc::sprintf(buff, "%.1e", 1.75);
ASSERT_STREQ_LEN(written, buff, "1.7e+00"); ASSERT_STREQ_LEN(written, buff, "1.7e+00");
written = __llvm_libc::sprintf(buff, "%.1e", 1.25); written = __llvm_libc::sprintf(buff, "%.1e", 1.25);
ASSERT_STREQ_LEN(written, buff, "1.2e+00"); ASSERT_STREQ_LEN(written, buff, "1.2e+00");
written = __llvm_libc::sprintf(buff, "%.1e", 1.125); written = __llvm_libc::sprintf(buff, "%.1e", 1.125);
ASSERT_STREQ_LEN(written, buff, "1.1e+00"); ASSERT_STREQ_LEN(written, buff, "1.1e+00");
▲ Show 20 Lines • Show All 98 Lines • ▼ Show 20 Lines*/
written = __llvm_libc::sprintf(buff, "%12.3e %-12.3e", 0.1, 256.0); written = __llvm_libc::sprintf(buff, "%12.3e %-12.3e", 0.1, 256.0);
ASSERT_STREQ_LEN(written, buff, " 1.000e-01 2.560e+02 "); ASSERT_STREQ_LEN(written, buff, " 1.000e-01 2.560e+02 ");
written = __llvm_libc::sprintf(buff, "%+-#12.3e % 012.3e", 0.1256, 1256.0); written = __llvm_libc::sprintf(buff, "%+-#12.3e % 012.3e", 0.1256, 1256.0);
ASSERT_STREQ_LEN(written, buff, "+1.256e-01 001.256e+03"); ASSERT_STREQ_LEN(written, buff, "+1.256e-01 001.256e+03");
} }
TEST_F(LlvmLibcSPrintfTest, FloatAutoConv) { TEST_F(LlvmLibcSPrintfTest, FloatAutoConv) {
__llvm_libc::fputil::testing::ForceRoundingMode r( ForceRoundingMode r(RoundingMode::Nearest);
__llvm_libc::fputil::testing::RoundingMode::Nearest);
double inf = __llvm_libc::fputil::FPBits<double>::inf().get_val(); double inf = __llvm_libc::fputil::FPBits<double>::inf().get_val();
double nan = __llvm_libc::fputil::FPBits<double>::build_nan(1); double nan = __llvm_libc::fputil::FPBits<double>::build_nan(1);
written = __llvm_libc::sprintf(buff, "%g", 1.0); written = __llvm_libc::sprintf(buff, "%g", 1.0);
ASSERT_STREQ_LEN(written, buff, "1"); ASSERT_STREQ_LEN(written, buff, "1");
written = __llvm_libc::sprintf(buff, "%G", -1.0); written = __llvm_libc::sprintf(buff, "%G", -1.0);
ASSERT_STREQ_LEN(written, buff, "-1"); ASSERT_STREQ_LEN(written, buff, "-1");
▲ Show 20 Lines • Show All 360 Lines • ▼ Show 20 Lines #elif defined(LONG_DOUBLE_IS_DOUBLE)
ASSERT_STREQ_LEN(written, buff, "inf"); ASSERT_STREQ_LEN(written, buff, "inf");
#else // 128 bit long double #else // 128 bit long double
ASSERT_STREQ_LEN(written, buff, "0x2.0p+16383"); ASSERT_STREQ_LEN(written, buff, "0x2.0p+16383");
#endif #endif
*/ */
// Rounding Mode Tests. // Rounding Mode Tests.
{ if (ForceRoundingMode r(RoundingMode::Nearest); r.success) {
__llvm_libc::fputil::testing::ForceRoundingMode r(
__llvm_libc::fputil::testing::RoundingMode::Nearest);
written = __llvm_libc::sprintf(buff, "%.2g", 1.75); written = __llvm_libc::sprintf(buff, "%.2g", 1.75);
ASSERT_STREQ_LEN(written, buff, "1.8"); ASSERT_STREQ_LEN(written, buff, "1.8");
written = __llvm_libc::sprintf(buff, "%.2g", 1.25); written = __llvm_libc::sprintf(buff, "%.2g", 1.25);
ASSERT_STREQ_LEN(written, buff, "1.2"); ASSERT_STREQ_LEN(written, buff, "1.2");
written = __llvm_libc::sprintf(buff, "%.2g", 1.125); written = __llvm_libc::sprintf(buff, "%.2g", 1.125);
ASSERT_STREQ_LEN(written, buff, "1.1"); ASSERT_STREQ_LEN(written, buff, "1.1");
Show All 21 Lines if (ForceRoundingMode r(RoundingMode::Nearest); r.success) {
written = __llvm_libc::sprintf(buff, "%.2g", -1.375); written = __llvm_libc::sprintf(buff, "%.2g", -1.375);
ASSERT_STREQ_LEN(written, buff, "-1.4"); ASSERT_STREQ_LEN(written, buff, "-1.4");
written = __llvm_libc::sprintf(buff, "%.2g", -1.875); written = __llvm_libc::sprintf(buff, "%.2g", -1.875);
ASSERT_STREQ_LEN(written, buff, "-1.9"); ASSERT_STREQ_LEN(written, buff, "-1.9");
} }
{ if (ForceRoundingMode r(RoundingMode::Upward); r.success) {
__llvm_libc::fputil::testing::ForceRoundingMode r(
__llvm_libc::fputil::testing::RoundingMode::Upward);
written = __llvm_libc::sprintf(buff, "%.2g", 1.75); written = __llvm_libc::sprintf(buff, "%.2g", 1.75);
ASSERT_STREQ_LEN(written, buff, "1.8"); ASSERT_STREQ_LEN(written, buff, "1.8");
written = __llvm_libc::sprintf(buff, "%.2g", 1.25); written = __llvm_libc::sprintf(buff, "%.2g", 1.25);
ASSERT_STREQ_LEN(written, buff, "1.3"); ASSERT_STREQ_LEN(written, buff, "1.3");
written = __llvm_libc::sprintf(buff, "%.2g", 1.125); written = __llvm_libc::sprintf(buff, "%.2g", 1.125);
ASSERT_STREQ_LEN(written, buff, "1.2"); ASSERT_STREQ_LEN(written, buff, "1.2");
Show All 21 Lines if (ForceRoundingMode r(RoundingMode::Upward); r.success) {
written = __llvm_libc::sprintf(buff, "%.2g", -1.375); written = __llvm_libc::sprintf(buff, "%.2g", -1.375);
ASSERT_STREQ_LEN(written, buff, "-1.3"); ASSERT_STREQ_LEN(written, buff, "-1.3");
written = __llvm_libc::sprintf(buff, "%.2g", -1.875); written = __llvm_libc::sprintf(buff, "%.2g", -1.875);
ASSERT_STREQ_LEN(written, buff, "-1.8"); ASSERT_STREQ_LEN(written, buff, "-1.8");
} }
{ if (ForceRoundingMode r(RoundingMode::Downward); r.success) {
__llvm_libc::fputil::testing::ForceRoundingMode r(
__llvm_libc::fputil::testing::RoundingMode::Downward);
written = __llvm_libc::sprintf(buff, "%.2g", 1.75); written = __llvm_libc::sprintf(buff, "%.2g", 1.75);
ASSERT_STREQ_LEN(written, buff, "1.7"); ASSERT_STREQ_LEN(written, buff, "1.7");
written = __llvm_libc::sprintf(buff, "%.2g", 1.25); written = __llvm_libc::sprintf(buff, "%.2g", 1.25);
ASSERT_STREQ_LEN(written, buff, "1.2"); ASSERT_STREQ_LEN(written, buff, "1.2");
written = __llvm_libc::sprintf(buff, "%.2g", 1.125); written = __llvm_libc::sprintf(buff, "%.2g", 1.125);
ASSERT_STREQ_LEN(written, buff, "1.1"); ASSERT_STREQ_LEN(written, buff, "1.1");
Show All 21 Lines if (ForceRoundingMode r(RoundingMode::Downward); r.success) {
written = __llvm_libc::sprintf(buff, "%.2g", -1.375); written = __llvm_libc::sprintf(buff, "%.2g", -1.375);
ASSERT_STREQ_LEN(written, buff, "-1.4"); ASSERT_STREQ_LEN(written, buff, "-1.4");
written = __llvm_libc::sprintf(buff, "%.2g", -1.875); written = __llvm_libc::sprintf(buff, "%.2g", -1.875);
ASSERT_STREQ_LEN(written, buff, "-1.9"); ASSERT_STREQ_LEN(written, buff, "-1.9");
} }
{ if (ForceRoundingMode r(RoundingMode::TowardZero); r.success) {
__llvm_libc::fputil::testing::ForceRoundingMode r(
__llvm_libc::fputil::testing::RoundingMode::TowardZero);
written = __llvm_libc::sprintf(buff, "%.2g", 1.75); written = __llvm_libc::sprintf(buff, "%.2g", 1.75);
ASSERT_STREQ_LEN(written, buff, "1.7"); ASSERT_STREQ_LEN(written, buff, "1.7");
written = __llvm_libc::sprintf(buff, "%.2g", 1.25); written = __llvm_libc::sprintf(buff, "%.2g", 1.25);
ASSERT_STREQ_LEN(written, buff, "1.2"); ASSERT_STREQ_LEN(written, buff, "1.2");
written = __llvm_libc::sprintf(buff, "%.2g", 1.125); written = __llvm_libc::sprintf(buff, "%.2g", 1.125);
ASSERT_STREQ_LEN(written, buff, "1.1"); ASSERT_STREQ_LEN(written, buff, "1.1");
▲ Show 20 Lines • Show All 171 Lines • Show Last 20 Lines

libc/utils/MPFRWrapper/MPFRUtils.h

Show First 20 Lines • Show All 348 Lines • ▼ Show 20 Lines#define TEST_MPFR_MATCH(...) \
GET_MPFR_MACRO(__VA_ARGS__, TEST_MPFR_MATCH_ROUNDING, \ GET_MPFR_MACRO(__VA_ARGS__, TEST_MPFR_MATCH_ROUNDING, \
EXPECT_MPFR_MATCH_DEFAULT, GET_MPFR_DUMMY_ARG) \ EXPECT_MPFR_MATCH_DEFAULT, GET_MPFR_DUMMY_ARG) \
(__VA_ARGS__) (__VA_ARGS__)
#define EXPECT_MPFR_MATCH_ALL_ROUNDING(op, input, match_value, ulp_tolerance) \ #define EXPECT_MPFR_MATCH_ALL_ROUNDING(op, input, match_value, ulp_tolerance) \
{ \ { \
namespace mpfr = __llvm_libc::testing::mpfr; \ namespace mpfr = __llvm_libc::testing::mpfr; \
mpfr::ForceRoundingMode __r1(mpfr::RoundingMode::Nearest); \ mpfr::ForceRoundingMode __r1(mpfr::RoundingMode::Nearest); \
if (__r1.success) \
EXPECT_MPFR_MATCH(op, input, match_value, ulp_tolerance, \ EXPECT_MPFR_MATCH(op, input, match_value, ulp_tolerance, \
mpfr::RoundingMode::Nearest); \ mpfr::RoundingMode::Nearest); \
mpfr::ForceRoundingMode __r2(mpfr::RoundingMode::Upward); \ mpfr::ForceRoundingMode __r2(mpfr::RoundingMode::Upward); \
if (__r2.success) \
EXPECT_MPFR_MATCH(op, input, match_value, ulp_tolerance, \ EXPECT_MPFR_MATCH(op, input, match_value, ulp_tolerance, \
mpfr::RoundingMode::Upward); \ mpfr::RoundingMode::Upward); \
mpfr::ForceRoundingMode __r3(mpfr::RoundingMode::Downward); \ mpfr::ForceRoundingMode __r3(mpfr::RoundingMode::Downward); \
if (__r3.success) \
EXPECT_MPFR_MATCH(op, input, match_value, ulp_tolerance, \ EXPECT_MPFR_MATCH(op, input, match_value, ulp_tolerance, \
mpfr::RoundingMode::Downward); \ mpfr::RoundingMode::Downward); \
mpfr::ForceRoundingMode __r4(mpfr::RoundingMode::TowardZero); \ mpfr::ForceRoundingMode __r4(mpfr::RoundingMode::TowardZero); \
if (__r4.success) \
EXPECT_MPFR_MATCH(op, input, match_value, ulp_tolerance, \ EXPECT_MPFR_MATCH(op, input, match_value, ulp_tolerance, \
mpfr::RoundingMode::TowardZero); \ mpfr::RoundingMode::TowardZero); \
} }
#define TEST_MPFR_MATCH_ROUNDING_SILENTLY(op, input, match_value, \ #define TEST_MPFR_MATCH_ROUNDING_SILENTLY(op, input, match_value, \
ulp_tolerance, rounding) \ ulp_tolerance, rounding) \
__llvm_libc::testing::mpfr::get_silent_mpfr_matcher<op>( \ __llvm_libc::testing::mpfr::get_silent_mpfr_matcher<op>( \
input, match_value, ulp_tolerance, rounding) \ input, match_value, ulp_tolerance, rounding) \
.match(match_value) .match(match_value)
Show All 12 Lines#define ASSERT_MPFR_MATCH(...) \
GET_MPFR_MACRO(__VA_ARGS__, ASSERT_MPFR_MATCH_ROUNDING, \ GET_MPFR_MACRO(__VA_ARGS__, ASSERT_MPFR_MATCH_ROUNDING, \
ASSERT_MPFR_MATCH_DEFAULT, GET_MPFR_DUMMY_ARG) \ ASSERT_MPFR_MATCH_DEFAULT, GET_MPFR_DUMMY_ARG) \
(__VA_ARGS__) (__VA_ARGS__)
#define ASSERT_MPFR_MATCH_ALL_ROUNDING(op, input, match_value, ulp_tolerance) \ #define ASSERT_MPFR_MATCH_ALL_ROUNDING(op, input, match_value, ulp_tolerance) \
{ \ { \
namespace mpfr = __llvm_libc::testing::mpfr; \ namespace mpfr = __llvm_libc::testing::mpfr; \
mpfr::ForceRoundingMode __r1(mpfr::RoundingMode::Nearest); \ mpfr::ForceRoundingMode __r1(mpfr::RoundingMode::Nearest); \
if (__r1.success) \
ASSERT_MPFR_MATCH(op, input, match_value, ulp_tolerance, \ ASSERT_MPFR_MATCH(op, input, match_value, ulp_tolerance, \
mpfr::RoundingMode::Nearest); \ mpfr::RoundingMode::Nearest); \
mpfr::ForceRoundingMode __r2(mpfr::RoundingMode::Upward); \ mpfr::ForceRoundingMode __r2(mpfr::RoundingMode::Upward); \
if (__r2.success) \
ASSERT_MPFR_MATCH(op, input, match_value, ulp_tolerance, \ ASSERT_MPFR_MATCH(op, input, match_value, ulp_tolerance, \
mpfr::RoundingMode::Upward); \ mpfr::RoundingMode::Upward); \
mpfr::ForceRoundingMode __r3(mpfr::RoundingMode::Downward); \ mpfr::ForceRoundingMode __r3(mpfr::RoundingMode::Downward); \
if (__r3.success) \
ASSERT_MPFR_MATCH(op, input, match_value, ulp_tolerance, \ ASSERT_MPFR_MATCH(op, input, match_value, ulp_tolerance, \
mpfr::RoundingMode::Downward); \ mpfr::RoundingMode::Downward); \
mpfr::ForceRoundingMode __r4(mpfr::RoundingMode::TowardZero); \ mpfr::ForceRoundingMode __r4(mpfr::RoundingMode::TowardZero); \
if (__r4.success) \
ASSERT_MPFR_MATCH(op, input, match_value, ulp_tolerance, \ ASSERT_MPFR_MATCH(op, input, match_value, ulp_tolerance, \
mpfr::RoundingMode::TowardZero); \ mpfr::RoundingMode::TowardZero); \
} }
#endif // LLVM_LIBC_UTILS_TESTUTILS_MPFRUTILS_H #endif // LLVM_LIBC_UTILS_TESTUTILS_MPFRUTILS_H

utils/bazel/llvm-project-overlay/libc/test/UnitTest/BUILD.bazel

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines deps = [
"//libc:__support_cpp_bit", "//libc:__support_cpp_bit",
"//libc:__support_cpp_bitset", "//libc:__support_cpp_bitset",
"//libc:__support_cpp_span", "//libc:__support_cpp_span",
"//libc:__support_cpp_string", "//libc:__support_cpp_string",
"//libc:__support_cpp_string_view", "//libc:__support_cpp_string_view",
"//libc:__support_cpp_type_traits", "//libc:__support_cpp_type_traits",
"//libc:__support_fputil_fp_bits", "//libc:__support_fputil_fp_bits",
"//libc:__support_fputil_fpbits_str", "//libc:__support_fputil_fpbits_str",
"//libc:__support_fputil_rounding_mode",
"//libc:__support_macros_properties_architectures", "//libc:__support_macros_properties_architectures",
"//libc:__support_stringutil", "//libc:__support_stringutil",
"//libc:__support_uint128", "//libc:__support_uint128",
"//libc:errno", "//libc:errno",
"//libc:libc_root", "//libc:libc_root",
"//llvm:Support", "//llvm:Support",
], ],
) )
Show All 14 Lines deps = [
":string_utils", ":string_utils",
"//libc:__support_cpp_bit", "//libc:__support_cpp_bit",
"//libc:__support_cpp_bitset", "//libc:__support_cpp_bitset",
"//libc:__support_cpp_span", "//libc:__support_cpp_span",
"//libc:__support_cpp_type_traits", "//libc:__support_cpp_type_traits",
"//libc:__support_fputil_fenv_impl", "//libc:__support_fputil_fenv_impl",
"//libc:__support_fputil_fp_bits", "//libc:__support_fputil_fp_bits",
"//libc:__support_fputil_fpbits_str", "//libc:__support_fputil_fpbits_str",
"//libc:__support_fputil_rounding_mode",
"//libc:libc_root", "//libc:libc_root",
], ],
) )
cc_library( cc_library(
name = "memory_matcher", name = "memory_matcher",
srcs = [ srcs = [
"MemoryMatcher.cpp", "MemoryMatcher.cpp",
Show All 39 Lines