Set std::numeric_limits<>::tinyness_before to true for floating point types on ARM platforms.

[resistor]

Summary

Set std::numeric_limits<>::tinyness_before to true for floating point types on ARM platforms.

Section E1.3.5 in the ARMv8 Architecture Reference Manual specifies:

Underflow. The bit is set to 1 if the absolute value of the result
of an operation, produced before rounding, is less than the minimum
positive normalized number for the destination precision, and the
rounded result is inexact.

[• Quuxplusone]

This will require at least one change to libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/tinyness_before.pass.cpp.

Is there any way for us to actually test that tinyness_before is set to the correct value for the platform's behavior? e.g. by somehow taking and modifying the sample code from cppreference? https://en.cppreference.com/w/cpp/types/numeric_limits/tinyness_before#Example

[resistor]

Update tests to account for the change in behavior, and add a
specific test that checks the value of tinyness_before against
the actual platform behavior.

[ldionne]

This looks reasonable to me but we definitely want for CI to be back and passing before shipping this one.

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/tinyness_before.pass.cpp

27

Unless this was intended?

[resistor]

Fix oversight where std::nextafter was always specialized on double rather than the type under test.

[resistor]

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/tinyness_before.pass.cpp

27

Thank for you for the catch.

[resistor]

Remove the platform verification test. Unfortunately, getting this to work consistently
across different compilers isn't really tractable given the state of strict floating point
support in various compilers/versions.

[ldionne]

In D116338#3212925, @resistor wrote:

Remove the platform verification test. Unfortunately, getting this to work consistently
across different compilers isn't really tractable given the state of strict floating point
support in various compilers/versions.

Which ones were not working? It might be reasonable to XFAIL that part of the test for non mainstream compilers? Technically we only support recent Clangs and GCCs, which I would assume should handle this properly.

[resistor]

Which ones were not working? It might be reasonable to XFAIL that part of the test for non mainstream compilers? Technically we only support recent Clangs and GCCs, which I would assume should handle this properly.

With the clang revision I tested, passing the test was dependent on optimization flags.

[majnemer]

Do we also need to test for __aarch64__? https://developer.arm.com/documentation/dui0774/g/chr1383660321827 says that __arm__ is only defined for 32-bit targets.

[resistor]

Add arch64 to detect AArch64 properly.

[resistor]

In D116338#3236613, @majnemer wrote:

Do we also need to test for __aarch64__? https://developer.arm.com/documentation/dui0774/g/chr1383660321827 says that __arm__ is only defined for 32-bit targets.

Good catch, thanks.

[majnemer]

LGTM

[resistor]

@ldionne Ping

[resistor]

Ping

[resistor]

Rebase

[resistor]

Ping

[EricWF]

libcxx/include/limits

342

Instead of each of these ifdefs could we maybe do something like

#if defined(arm or w/e)
#define _LIBCPP_TINYNESS_BEFORE true
#else
#define _LIBCPP_TINYNESS_BEFORE false
#endif

Then we can undef it at the end of the header.

[starrybusy]

This comment was removed by tstellar.

[• Avajos]

This comment was removed by tstellar.

This comment was removed by tstellar.

libcxx/include/limits

protected:
     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type signaling_NaN() _NOEXCEPT {return __builtin_nansf("");}
     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type denorm_min() _NOEXCEPT {return __FLT_DENORM_MIN__;}
 
     static _LIBCPP_CONSTEXPR const bool is_iec559 = true;
     static _LIBCPP_CONSTEXPR const bool is_bounded = true;
     static _LIBCPP_CONSTEXPR const bool is_modulo = false;
 
     static _LIBCPP_CONSTEXPR const bool traps = false;
+#if (defined(__arm__) || defined(__aarch64__))
+    static _LIBCPP_CONSTEXPR const bool tinyness_before = true;
+#else
     static _LIBCPP_CONSTEXPR const bool tinyness_before = false;
+#endif
     static _LIBCPP_CONSTEXPR const float_round_style round_style = round_to_nearest;
 };
 
 template <>
 class __libcpp_numeric_limits<double, true>
 {
 protected:
     typedef double type;
protected:
     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type signaling_NaN() _NOEXCEPT {return __builtin_nans("");}
     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type denorm_min() _NOEXCEPT {return __DBL_DENORM_MIN__;}
 
     static _LIBCPP_CONSTEXPR const bool is_iec559 = true;
     static _LIBCPP_CONSTEXPR const bool is_bounded = true;
     static _LIBCPP_CONSTEXPR const bool is_modulo = false;
 
     static _LIBCPP_CONSTEXPR const bool traps = false;
+#if (defined(__arm__) || defined(__aarch64__))
+    static _LIBCPP_CONSTEXPR const bool tinyness_before = true;
+#else
     static _LIBCPP_CONSTEXPR const bool tinyness_before = false;
+#endif
     static _LIBCPP_CONSTEXPR const float_round_style round_style = round_to_nearest;
 };
 
 template <>
 class __libcpp_numeric_limits<long double, true>
 {
 protected:
     typedef long double type;
#if (defined(__ppc__) || defined(__ppc64__))
     static _LIBCPP_CONSTEXPR const bool is_iec559 = false;
 #else
     static _LIBCPP_CONSTEXPR const bool is_iec559 = true;
 #endif
     static _LIBCPP_CONSTEXPR const bool is_bounded = true;
     static _LIBCPP_CONSTEXPR const bool is_modulo = false;
 
     static _LIBCPP_CONSTEXPR const bool traps = false;
+#if (defined(__arm__) || defined(__aarch64__))
+    static _LIBCPP_CONSTEXPR const bool tinyness_before = true;
+#else
     static _LIBCPP_CONSTEXPR const bool tinyness_before = false;
+#endif
     static _LIBCPP_CONSTEXPR const float_round_style round_style = round_to_nearest;
 };
 
 template <class _Tp>
 class _LIBCPP_TEMPLATE_VIS numeric_limits
     : private __libcpp_numeric_limits<typename remove_cv<_Tp>::type>
 {
     typedef __libcpp_numeric_limits<typename remove_cv<_Tp>::type> __base;

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/tinyness_before.pass.cpp

 test()
 {
     static_assert(std::numeric_limits<T>::tinyness_before == expected, "tinyness_before test 1");
     static_assert(std::numeric_limits<const T>::tinyness_before == expected, "tinyness_before test 2");
     static_assert(std::numeric_limits<volatile T>::tinyness_before == expected, "tinyness_before test 3");
     static_assert(std::numeric_limits<const volatile T>::tinyness_before == expected, "tinyness_before test 4");
 }
 
 int main(int, char**)
 {
     test<bool, false>();
     test<char, false>();
     test<signed char, false>();
     test<unsigned char, false>();
     test<wchar_t, false>();
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t, false>();
#endif
     test<long, false>();
     test<unsigned long, false>();
     test<long long, false>();
     test<unsigned long long, false>();
 #ifndef TEST_HAS_NO_INT128
     test<__int128_t, false>();
     test<__uint128_t, false>();
 #endif
+#if (defined(__arm__) || defined(__aarch64__))
+    test<float, true>();
+    test<double, true>();
+    test<long double, true>();
+#else
     test<float, false>();
     test<double, false>();
     test<long double, false>();
+#endif
 
   return 0;
 }