[libc++][AIX] Use C++ overloads from libc++'s math.h

[daltenty]

Summary

AIX's system header provides these C++ overloads for compatibility with older XL C++ implementations, but they can be disabled by defining __LIBC_NO_CPP_MATH_OVERLOADS__ since AIX 7.2 TL 5 SP 3.

Since D109078 landed clang will define this macro when using libc++ on AIX and we already run the lit tests with it too. This change will enable the overloads in libc++'s math.h and we'll continue to require the compiler to define the macro going forward.

[daltenty]

LGTM from the perspective of interaction with the system math.h

[jasonliu]

Ping.
@ldionne any comments?

[ldionne]

libcxx/include/math.h

300–310

We shouldn't be adding magic incantations to make a C Standard Library work the way it should. We should fix it so that it works properly instead.

The correct behavior for the C library would be to *not* provide those overloads unless explicitly requested, not the other way around. If that can't be fixed, then I suggest the compiler be fixed so that it enforces -D__COMPATMATH__ on AIX.

[hubert.reinterpretcast]

libcxx/include/math.h

300–310

The solution for the compiler to define __COMPATMATH__ would be improper. This is a documented macro associated with the IBM XL compiler. When the end-user observes that the macro is set, they have some reason to expect that the overloads are not provided.

Since some other C++ libraries on AIX expect the overloads to come from the OS headers, it looks like the direction to explore is for the OS headers to implement a path for newer versions of libc++.

[daltenty]

Update to a new version that requires the compiler to define the __LIBC_NO_CPP_MATH_OVERLOADS__ macro (which clang does).

[jsji]

@daltenty Can you please update the patch to include more *Context*, looks like the Context not available. Or use arc to update it. Thanks.

[• Quuxplusone]

In D102172#3304759, @jsji wrote:

@daltenty Can you please update the patch to include more *Context*, looks like the Context not available. Or use arc to update it. Thanks.

In case it's needed: The command I use to get context in my diffs (without using arc) is git show -U999 HEAD >filetoupload.diff (or replace HEAD with whatever-commit-hash).

[daltenty]

In D102172#3304810, @Quuxplusone wrote:

In D102172#3304759, @jsji wrote:

@daltenty Can you please update the patch to include more *Context*, looks like the Context not available. Or use arc to update it. Thanks.

In case it's needed: The command I use to get context in my diffs (without using arc) is git show -U999 HEAD >filetoupload.diff (or replace HEAD with whatever-commit-hash).

Sorry, arcanist broke for me due to an OS update recently and I haven't quite gotten used to uploading the patches manually yet. Will revise with the additional content.

[daltenty]

Add additional context

[jsji]

Thanks @daltenty ! LGTM.

but they can be disabled by defining LIBC_NO_CPP_MATH_OVERLOADS

It would be great if we can mention the TL level that start to define this in the description.

@ldionne Can you have another look too? Thanks!

[daltenty]

@ldionne gentle ping. I think we've addressed your previous concerns here. We've moved responsibility for setting the macro to suppress the AIX libc definitions to the compiler side as you suggested in D109078, so this patch should hopefully be non-controversial now.

[daltenty]

Gentle ping

[daltenty]

Rebase to retrigger CI

libcxx/include/math.h

 
 // acos
 
-#if !(defined(_AIX) || defined(__sun__))
+#if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       acos(float __lcpp_x) _NOEXCEPT       {return ::acosf(__lcpp_x);}
 inline _LIBCPP_INLINE_VISIBILITY long double acos(long double __lcpp_x) _NOEXCEPT {return ::acosl(__lcpp_x);}
 #endif

 
 // asin
 
-#if !(defined(_AIX) || defined(__sun__))
+#if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       asin(float __lcpp_x) _NOEXCEPT       {return ::asinf(__lcpp_x);}
 inline _LIBCPP_INLINE_VISIBILITY long double asin(long double __lcpp_x) _NOEXCEPT {return ::asinl(__lcpp_x);}
 #endif

 
 // atan
 
-#if !(defined(_AIX) || defined(__sun__))
+#if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       atan(float __lcpp_x) _NOEXCEPT       {return ::atanf(__lcpp_x);}
 inline _LIBCPP_INLINE_VISIBILITY long double atan(long double __lcpp_x) _NOEXCEPT {return ::atanl(__lcpp_x);}
 #endif

 
 // atan2
 
-#if !(defined(_AIX) || defined(__sun__))
+#if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       atan2(float __lcpp_y, float __lcpp_x) _NOEXCEPT             {return ::atan2f(__lcpp_y, __lcpp_x);}
 inline _LIBCPP_INLINE_VISIBILITY long double atan2(long double __lcpp_y, long double __lcpp_x) _NOEXCEPT {return ::atan2l(__lcpp_y, __lcpp_x);}
 #endif

 
 // ceil
 
-#if !(defined(_AIX) || defined(__sun__))
+#if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       ceil(float __lcpp_x) _NOEXCEPT       {return ::ceilf(__lcpp_x);}
 inline _LIBCPP_INLINE_VISIBILITY long double ceil(long double __lcpp_x) _NOEXCEPT {return ::ceill(__lcpp_x);}
 #endif

 
 // cos
 
-#if !(defined(_AIX) || defined(__sun__))
+#if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       cos(float __lcpp_x) _NOEXCEPT       {return ::cosf(__lcpp_x);}
 inline _LIBCPP_INLINE_VISIBILITY long double cos(long double __lcpp_x) _NOEXCEPT {return ::cosl(__lcpp_x);}
 #endif

 
 // cosh
 
-#if !(defined(_AIX) || defined(__sun__))
+#if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       cosh(float __lcpp_x) _NOEXCEPT       {return ::coshf(__lcpp_x);}
 inline _LIBCPP_INLINE_VISIBILITY long double cosh(long double __lcpp_x) _NOEXCEPT {return ::coshl(__lcpp_x);}
 #endif

 
 // exp
 
-#if !(defined(_AIX) || defined(__sun__))
+#if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       exp(float __lcpp_x) _NOEXCEPT       {return ::expf(__lcpp_x);}
 inline _LIBCPP_INLINE_VISIBILITY long double exp(long double __lcpp_x) _NOEXCEPT {return ::expl(__lcpp_x);}
 #endif

 
 // fabs
 
-#if !(defined(_AIX) || defined(__sun__))
+#if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       fabs(float __lcpp_x) _NOEXCEPT       {return ::fabsf(__lcpp_x);}
 inline _LIBCPP_INLINE_VISIBILITY long double fabs(long double __lcpp_x) _NOEXCEPT {return ::fabsl(__lcpp_x);}
 #endif

 
 // floor
 
-#if !(defined(_AIX) || defined(__sun__))
+#if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       floor(float __lcpp_x) _NOEXCEPT       {return ::floorf(__lcpp_x);}
 inline _LIBCPP_INLINE_VISIBILITY long double floor(long double __lcpp_x) _NOEXCEPT {return ::floorl(__lcpp_x);}
 #endif

 
 // fmod
 
-#if !(defined(_AIX) || defined(__sun__))
+#if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       fmod(float __lcpp_x, float __lcpp_y) _NOEXCEPT             {return ::fmodf(__lcpp_x, __lcpp_y);}
 inline _LIBCPP_INLINE_VISIBILITY long double fmod(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::fmodl(__lcpp_x, __lcpp_y);}
 #endif

 
 // frexp
 
-#if !(defined(_AIX) || defined(__sun__))
+#if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       frexp(float __lcpp_x, int* __lcpp_e) _NOEXCEPT       {return ::frexpf(__lcpp_x, __lcpp_e);}
 inline _LIBCPP_INLINE_VISIBILITY long double frexp(long double __lcpp_x, int* __lcpp_e) _NOEXCEPT {return ::frexpl(__lcpp_x, __lcpp_e);}
 #endif

 
 // ldexp
 
-#if !(defined(_AIX) || defined(__sun__))
+#if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       ldexp(float __lcpp_x, int __lcpp_e) _NOEXCEPT       {return ::ldexpf(__lcpp_x, __lcpp_e);}
 inline _LIBCPP_INLINE_VISIBILITY long double ldexp(long double __lcpp_x, int __lcpp_e) _NOEXCEPT {return ::ldexpl(__lcpp_x, __lcpp_e);}
 #endif

 
 // log
 
-#if !(defined(_AIX) || defined(__sun__))
+#if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       log(float __lcpp_x) _NOEXCEPT       {return ::logf(__lcpp_x);}
 inline _LIBCPP_INLINE_VISIBILITY long double log(long double __lcpp_x) _NOEXCEPT {return ::logl(__lcpp_x);}
 #endif

 
 // log10
 
-#if !(defined(_AIX) || defined(__sun__))
+#if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       log10(float __lcpp_x) _NOEXCEPT       {return ::log10f(__lcpp_x);}
 inline _LIBCPP_INLINE_VISIBILITY long double log10(long double __lcpp_x) _NOEXCEPT {return ::log10l(__lcpp_x);}
 #endif

 
 // modf
 
-#if !(defined(_AIX) || defined(__sun__))
+#if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       modf(float __lcpp_x, float* __lcpp_y) _NOEXCEPT             {return ::modff(__lcpp_x, __lcpp_y);}
 inline _LIBCPP_INLINE_VISIBILITY long double modf(long double __lcpp_x, long double* __lcpp_y) _NOEXCEPT {return ::modfl(__lcpp_x, __lcpp_y);}
 #endif
 
 // pow
 
-#if !(defined(_AIX) || defined(__sun__))
+#if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       pow(float __lcpp_x, float __lcpp_y) _NOEXCEPT             {return ::powf(__lcpp_x, __lcpp_y);}
 inline _LIBCPP_INLINE_VISIBILITY long double pow(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::powl(__lcpp_x, __lcpp_y);}
 #endif

 
 // sin
 
-#if !(defined(_AIX) || defined(__sun__))
+#if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       sin(float __lcpp_x) _NOEXCEPT       {return ::sinf(__lcpp_x);}
 inline _LIBCPP_INLINE_VISIBILITY long double sin(long double __lcpp_x) _NOEXCEPT {return ::sinl(__lcpp_x);}
 #endif

 
 // sinh
 
-#if !(defined(_AIX) || defined(__sun__))
+#if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       sinh(float __lcpp_x) _NOEXCEPT       {return ::sinhf(__lcpp_x);}
 inline _LIBCPP_INLINE_VISIBILITY long double sinh(long double __lcpp_x) _NOEXCEPT {return ::sinhl(__lcpp_x);}
 #endif

 
 // sqrt
 
-#if !(defined(_AIX) || defined(__sun__))
+#if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       sqrt(float __lcpp_x) _NOEXCEPT       {return ::sqrtf(__lcpp_x);}
 inline _LIBCPP_INLINE_VISIBILITY long double sqrt(long double __lcpp_x) _NOEXCEPT {return ::sqrtl(__lcpp_x);}
 #endif

 
 // tan
 
-#if !(defined(_AIX) || defined(__sun__))
+#if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       tan(float __lcpp_x) _NOEXCEPT       {return ::tanf(__lcpp_x);}
 inline _LIBCPP_INLINE_VISIBILITY long double tan(long double __lcpp_x) _NOEXCEPT {return ::tanl(__lcpp_x);}
 #endif

 
 // tanh
 
-#if !(defined(_AIX) || defined(__sun__))
+#if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       tanh(float __lcpp_x) _NOEXCEPT       {return ::tanhf(__lcpp_x);}
 inline _LIBCPP_INLINE_VISIBILITY long double tanh(long double __lcpp_x) _NOEXCEPT {return ::tanhl(__lcpp_x);}
 #endif

libcxx/test/libcxx/fuzzing/random.pass.cpp

 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
-// XFAIL: LIBCXX-AIX-FIXME
 
 #include <cassert>
 #include <cmath>

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

 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <math.h>
 
 #include <math.h>

libcxx/test/std/localization/locale.categories/category.time/locale.time.put.byname/put1.pass.cpp

 // NetBSD does not support LC_TIME at the moment
 // XFAIL: netbsd
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // REQUIRES: locale.en_US.UTF-8
 // REQUIRES: locale.fr_FR.UTF-8
 

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

 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <cmath>
 
 #include <cmath>

libcxx/test/std/numerics/complex.number/cmplx.over/arg.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <complex>
 
 // template<Arithmetic T>

libcxx/test/std/numerics/complex.number/cmplx.over/pow.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <complex>
 
 // template<Arithmetic T, Arithmetic U>

libcxx/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <complex>
 
 // template<class T>

libcxx/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <complex>
 
 // template<class T>

libcxx/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <complex>
 
 // template<class T>

libcxx/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <complex>
 
 // template<class T>

libcxx/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <complex>
 
 // template<class T>

libcxx/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <complex>
 
 // template<class T>

libcxx/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <complex>
 
 // template<class T>

libcxx/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <complex>
 
 // template<class T>

libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <complex>
 
 // template<class T>

libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <complex>
 
 // template<class T>

libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <complex>
 
 // template<class T>

libcxx/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <complex>
 
 // template<class T>

libcxx/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <complex>
 
 // template<class T>

libcxx/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/copy.pass.cpp

 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=68016
 // UNSUPPORTED: c++03, asan
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <functional>
 
 // template<CopyConstructible Fn, CopyConstructible... Types>