[libcxx] Don't use C99 math ops in -std=c++03 mode

[rmaprath]

Summary

C99 math ops should not be available when compiling in -std=c++03 mode.

[EricWF]

We already provide many C++11 extensions in C++03 mode, why should this be an exception?

[rmaprath]

In D23926#527080, @EricWF wrote:

We already provide many C++11 extensions in C++03 mode, why should this be an exception?

This is kind of what I wanted to find out. Do we document what those extensions are?

We have quite a strict C library which is picky about what it exposes under different standards. For example, it won't expose C99 math ops if it is being used under __cplusplus < 201103L, which leads to compiler errors (when integrated with libc++ and used with -std=c++03) for a simple program like:

#include <math.h>
int x;

We could make our C library a bit more lenient to fix this, but I couldn't find it documented anywhere what stand libcxx takes on C++03 support. I also sent an email to cfe-dev about this but didn't get much attention, so I decided to start with a patch instead :)

I'm happy to document these C++03 extensions on libcxx.llvm.org if I can find out what those extensions are. Any pointers?

Cheers,

/ Asiri

[rmaprath]

Re-spinning a new patch to test the waters.

@EricWF: Does this approach look OK?

/ Asiri

[rmaprath]

Simplified the patch a little bit more.

Now, library vendors should be able to define _LIBCPP_STRICT_C99_COMPATIBILITY and libc++ will not use/test C99 math functions in C++03/98 modes. Currently it's only the math functions, we can extend this approach to other affected areas if the approach is OK. Not 100% sure about the namings, can change them as needed.

@EricWF: Gentle ping.

[mclow.lists]

We have quite a strict C library which is picky about what it exposes under different standards. For example, it won't expose C99 math ops if it is being used under __cplusplus < 201103L ...

That sounds .. odd to me, having the behavior of the C library depend on the value of __cplusplus

[EricWF]

In D23926#531226, @rmaprath wrote:

Simplified the patch a little bit more.

Now, library vendors should be able to define _LIBCPP_STRICT_C99_COMPATIBILITY and libc++ will not use/test C99 math functions in C++03/98 modes. Currently it's only the math functions, we can extend this approach to other affected areas if the approach is OK. Not 100% sure about the namings, can change them as needed.

@EricWF: Gentle ping.

Currently we rely on C++11, C99, BSD, XOPEN, and GNU extensions in all dialects in the headers. We have to do so to safely and correctly implement locales and IO. In order to support this clang++ and g++ explicitly enable the C99 standard library by defining -D_GNU_SOURCE in the driver (Heres a 10yo libstdc++ bug about it).

"strict C95 compatibly" is not a feature for our C++ users. If your C library support C99 you should enable it, not make libc++ conforming. If we have to disable a couple of <math.h> functions to make that work that's OK. However I view that as a defect not a feature.

test/std/depr/depr.c.headers/math_h.pass.cpp

753

Tests should be as portable as across standard libraries and not enabled by libc++ specific macros.
Disabling tests is OK though. ex #ifndef _LIBCPP_HAS_NO_C99_MATH.

[EricWF]

After talking with @rmaprath we have agreed to go in a different direction. Resigning as reviewer to keep my queue clean.

[rmaprath]

Abandoning: we've decided to relax our C library to expose C99 functionality in C++98/03 modes. This is more inline with upstream intentions and allows us to get rid of some fiddly downstream libc++ patches as well.

Thanks Marshall and Eric for the comments / chats.

/ Asiri

include/__config

 #define _LIBCPP_CONSTEXPR_AFTER_CXX14
 #endif
 
+// Whether to assume a C99 compatible C library in C++03/98 modes. By default,
+// libc++ provides many C++11 operations in C++03/98 modes as extensions, some
+// of these extensions rely on the underlying C library providing C99 operations
+// even in C++03/98 modes. This flag forbids libc++ from making this assumption,
+// which means disabling those C++11 extensions in C++03/98 modes. Not providing
+// those extensions is better than trying to provide them and failing to compile
+// because the underlying C library is not C99 compatible.
+#if __cplusplus < 201103L && defined(_LIBCPP_STRICT_C99_COMPATIBILITY)
+#  define _LIBCPP_USE_C99 0
+#else
+#  define _LIBCPP_USE_C99 1
+#endif
+
 #ifdef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 #  define _LIBCPP_EXPLICIT_MOVE(x) _VSTD::move(x)
 #else

include/math.h

 
 // acosh
 
-#ifndef _LIBCPP_MSVCRT
+#if !defined(_LIBCPP_MSVCRT) && _LIBCPP_USE_C99
 inline _LIBCPP_INLINE_VISIBILITY float       acosh(float __lcpp_x) _NOEXCEPT       {return acoshf(__lcpp_x);}
 inline _LIBCPP_INLINE_VISIBILITY long double acosh(long double __lcpp_x) _NOEXCEPT {return acoshl(__lcpp_x);}
 

 
 // asinh
 
-#ifndef _LIBCPP_MSVCRT
+#if !defined(_LIBCPP_MSVCRT) && _LIBCPP_USE_C99
 inline _LIBCPP_INLINE_VISIBILITY float       asinh(float __lcpp_x) _NOEXCEPT       {return asinhf(__lcpp_x);}
 inline _LIBCPP_INLINE_VISIBILITY long double asinh(long double __lcpp_x) _NOEXCEPT {return asinhl(__lcpp_x);}
 

 
 // atanh
 
-#ifndef _LIBCPP_MSVCRT
+#if !defined(_LIBCPP_MSVCRT) && _LIBCPP_USE_C99
 inline _LIBCPP_INLINE_VISIBILITY float       atanh(float __lcpp_x) _NOEXCEPT       {return atanhf(__lcpp_x);}
 inline _LIBCPP_INLINE_VISIBILITY long double atanh(long double __lcpp_x) _NOEXCEPT {return atanhl(__lcpp_x);}
 

 
 // cbrt
 
-#ifndef _LIBCPP_MSVCRT
+#if !defined(_LIBCPP_MSVCRT) && _LIBCPP_USE_C99
 inline _LIBCPP_INLINE_VISIBILITY float       cbrt(float __lcpp_x) _NOEXCEPT       {return cbrtf(__lcpp_x);}
 inline _LIBCPP_INLINE_VISIBILITY long double cbrt(long double __lcpp_x) _NOEXCEPT {return cbrtl(__lcpp_x);}
 

 
 // copysign
 
-#if !defined(_VC_CRT_MAJOR_VERSION) || (_VC_CRT_MAJOR_VERSION < 12)
+#if _LIBCPP_USE_C99 && (!defined(_VC_CRT_MAJOR_VERSION) || (_VC_CRT_MAJOR_VERSION < 12))
 inline _LIBCPP_INLINE_VISIBILITY float copysign(float __lcpp_x,
                                                 float __lcpp_y) _NOEXCEPT {
   return copysignf(__lcpp_x, __lcpp_y);

 }
 #endif
 
+#if _LIBCPP_USE_C99
 template <class _A1, class _A2>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::__lazy_enable_if

                      std::is_same<_A2, __result_type>::value)), "");
     return copysign((__result_type)__lcpp_x, (__result_type)__lcpp_y);
 }
+#endif
 
-#ifndef _LIBCPP_MSVCRT
-
+#if !defined(_LIBCPP_MSVCRT) && _LIBCPP_USE_C99
 // erf
 
 inline _LIBCPP_INLINE_VISIBILITY float       erf(float __lcpp_x) _NOEXCEPT       {return erff(__lcpp_x);}

test/std/depr/depr.c.headers/math_h.pass.cpp

     assert(isunordered(-1.0, 0.F) == false);
 }
 
+#if _LIBCPP_USE_C99
+
 void test_acosh()
 {
     static_assert((std::is_same<decltype(acosh((float)0)), float>::value), "");

     assert(trunc(1) == 1);
 }
 
+#endif
+
 int main()
 {
     test_abs();

     test_islessgreater();
     test_isnan();
     test_isunordered();
+#if _LIBCPP_USE_C99
     test_acosh();
     test_asinh();
     test_atanh();

     test_scalbn();
     test_tgamma();
     test_trunc();
+#endif
 }

test/std/numerics/c.math/cmath.pass.cpp

     assert(std::isunordered(-1.0, 0.F) == false);
 }
 
+#if _LIBCPP_USE_C99
+
 void test_acosh()
 {
     static_assert((std::is_same<decltype(std::acosh((float)0)), float>::value), "");

     assert(std::trunc(1) == 1);
 }
 
+#endif
+
 int main()
 {
     test_abs();

     test_islessgreater();
     test_isnan();
     test_isunordered();
+#if _LIBCPP_USE_C99
     test_acosh();
     test_asinh();
     test_atanh();

     test_scalbn();
     test_tgamma();
     test_trunc();
+#endif
 }

test/std/numerics/complex.number/cmplx.over/proj.pass.cpp

 test(T x, typename std::enable_if<std::is_floating_point<T>::value>::type* = 0)
 {
     static_assert((std::is_same<decltype(std::proj(x)), std::complex<T> >::value), "");
+#if _LIBCPP_USE_C99
     assert(std::proj(x) == proj(std::complex<T>(x, 0)));
+#endif
 }
 
 template <class T>

                                   !std::is_floating_point<T>::value>::type* = 0)
 {
     static_assert((std::is_same<decltype(std::proj(x)), std::complex<T> >::value), "");
+#if _LIBCPP_USE_C99
     assert(std::proj(x) == proj(std::complex<T>(x, 0)));
+#endif
 }
 
 template <class T>