[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

 */
 
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #include_next <math.h>
 
 #ifdef __cplusplus
 
 // We support including .h headers inside 'extern "C"' contexts, so switch
 // back to C++ linkage before including these C++ headers.
 extern "C++" {
 
 #include <limits>
 #include <stdlib.h>
 #include <type_traits>
 
 // signbit
 
 #ifdef signbit
 
 template <class _A1>
 _LIBCPP_INLINE_VISIBILITY
 bool

 // handled in stdlib.h
 
 // div
 //
 // handled in stdlib.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
+#    endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 acos(_A1 __lcpp_x) _NOEXCEPT {return ::acos((double)__lcpp_x);}
 
 // 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
+#    endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 asin(_A1 __lcpp_x) _NOEXCEPT {return ::asin((double)__lcpp_x);}
 
 // 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
+#    endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 atan(_A1 __lcpp_x) _NOEXCEPT {return ::atan((double)__lcpp_x);}
 
 // 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
+#    endif
 
 template <class _A1, class _A2>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::__enable_if_t
 <
     std::is_arithmetic<_A1>::value &&
     std::is_arithmetic<_A2>::value,
     std::__promote<_A1, _A2>
 >::type
 atan2(_A1 __lcpp_y, _A2 __lcpp_x) _NOEXCEPT
 {
     typedef typename std::__promote<_A1, _A2>::type __result_type;
     static_assert((!(std::_IsSame<_A1, __result_type>::value &&
                      std::_IsSame<_A2, __result_type>::value)), "");
     return ::atan2((__result_type)__lcpp_y, (__result_type)__lcpp_x);
 }
 
 // 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
+#    endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 ceil(_A1 __lcpp_x) _NOEXCEPT {return ::ceil((double)__lcpp_x);}
 
 // 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
+#    endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 cos(_A1 __lcpp_x) _NOEXCEPT {return ::cos((double)__lcpp_x);}
 
 // 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
+#    endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 cosh(_A1 __lcpp_x) _NOEXCEPT {return ::cosh((double)__lcpp_x);}
 
 // 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
+#    endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 exp(_A1 __lcpp_x) _NOEXCEPT {return ::exp((double)__lcpp_x);}
 
 // 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
+#    endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 fabs(_A1 __lcpp_x) _NOEXCEPT {return ::fabs((double)__lcpp_x);}
 
 // 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
+#    endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 floor(_A1 __lcpp_x) _NOEXCEPT {return ::floor((double)__lcpp_x);}
 
 // 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
+#    endif
 
 template <class _A1, class _A2>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::__enable_if_t
 <
     std::is_arithmetic<_A1>::value &&
     std::is_arithmetic<_A2>::value,
     std::__promote<_A1, _A2>
 >::type
 fmod(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
 {
     typedef typename std::__promote<_A1, _A2>::type __result_type;
     static_assert((!(std::_IsSame<_A1, __result_type>::value &&
                      std::_IsSame<_A2, __result_type>::value)), "");
     return ::fmod((__result_type)__lcpp_x, (__result_type)__lcpp_y);
 }
 
 // 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
+#    endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 frexp(_A1 __lcpp_x, int* __lcpp_e) _NOEXCEPT {return ::frexp((double)__lcpp_x, __lcpp_e);}
 
 // 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
+#    endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 ldexp(_A1 __lcpp_x, int __lcpp_e) _NOEXCEPT {return ::ldexp((double)__lcpp_x, __lcpp_e);}
 
 // 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
+#    endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 log(_A1 __lcpp_x) _NOEXCEPT {return ::log((double)__lcpp_x);}
 
 // 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
+#    endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 log10(_A1 __lcpp_x) _NOEXCEPT {return ::log10((double)__lcpp_x);}
 
 // 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
+#    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
+#    endif
 
 template <class _A1, class _A2>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::__enable_if_t
 <
     std::is_arithmetic<_A1>::value &&
     std::is_arithmetic<_A2>::value,
     std::__promote<_A1, _A2>
 >::type
 pow(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
 {
     typedef typename std::__promote<_A1, _A2>::type __result_type;
     static_assert((!(std::_IsSame<_A1, __result_type>::value &&
                      std::_IsSame<_A2, __result_type>::value)), "");
     return ::pow((__result_type)__lcpp_x, (__result_type)__lcpp_y);
 }
 
 // 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
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 sin(_A1 __lcpp_x) _NOEXCEPT {return ::sin((double)__lcpp_x);}
 
 // 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
+#    endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 sinh(_A1 __lcpp_x) _NOEXCEPT {return ::sinh((double)__lcpp_x);}
 
 // 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
+#    endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 sqrt(_A1 __lcpp_x) _NOEXCEPT {return ::sqrt((double)__lcpp_x);}
 
 // 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
+#    endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 tan(_A1 __lcpp_x) _NOEXCEPT {return ::tan((double)__lcpp_x);}
 
 // 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
+#    endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 tanh(_A1 __lcpp_x) _NOEXCEPT {return ::tanh((double)__lcpp_x);}
 
 // acosh
 

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
-// XFAIL: LIBCXX-AIX-FIXME
 
 #include <cassert>
 #include <cmath>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
 #include <random>
 #include <type_traits>

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <math.h>
 
 #include <math.h>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "hexfloat.h"

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // 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
 
 // <locale>
 
 // template <class CharT, class OutputIterator = ostreambuf_iterator<CharT> >
 // class time_put_byname
 //     : public time_put<CharT, OutputIterator>

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <cmath>
 
 #include <cmath>
 #include <limits>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <complex>
 
 // template<Arithmetic T>
 //   T
 //   arg(T x);
 
 #include <complex>
 #include <type_traits>

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <complex>
 
 // template<Arithmetic T, Arithmetic U>
 //   complex<promote<T, U>::type>
 //   pow(const T& x, const complex<U>& y);
 
 // template<Arithmetic T, Arithmetic U>
 //   complex<promote<T, U>::type>

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <complex>
 
 // template<class T>
 //   complex<T>
 //   acos(const complex<T>& x);
 
 #include <complex>
 #include <cassert>

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <complex>
 
 // template<class T>
 //   complex<T>
 //   acosh(const complex<T>& x);
 
 #include <complex>
 #include <cassert>

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <complex>
 
 // template<class T>
 //   complex<T>
 //   asin(const complex<T>& x);
 
 #include <complex>
 #include <cassert>

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <complex>
 
 // template<class T>
 //   complex<T>
 //   asinh(const complex<T>& x);
 
 #include <complex>
 #include <cassert>

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <complex>
 
 // template<class T>
 //   complex<T>
 //   atan(const complex<T>& x);
 
 #include <complex>
 #include <cassert>

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <complex>
 
 // template<class T>
 //   complex<T>
 //   atanh(const complex<T>& x);
 
 #include <complex>
 #include <cassert>

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <complex>
 
 // template<class T>
 //   complex<T>
 //   log(const complex<T>& x);
 
 #include <complex>
 #include <cassert>

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <complex>
 
 // template<class T>
 //   complex<T>
 //   log10(const complex<T>& x);
 
 #include <complex>
 #include <cassert>

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <complex>
 
 // template<class T>
 //   complex<T>
 //   pow(const complex<T>& x, const complex<T>& y);
 
 #include <complex>
 #include <cassert>

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <complex>
 
 // template<class T>
 //   complex<T>
 //   pow(const complex<T>& x, const T& y);
 
 #include <complex>
 #include <cassert>

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <complex>
 
 // template<class T>
 //   complex<T>
 //   pow(const T& x, const complex<T>& y);
 
 #include <complex>
 #include <cassert>

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <complex>
 
 // template<class T>
 //   complex<T>
 //   sqrt(const complex<T>& x);
 
 #include <complex>
 #include <cassert>

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <complex>
 
 // template<class T>
 //   T
 //   arg(const complex<T>& x);
 
 #include <complex>
 #include <cassert>

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

 // resulting in a crash.
 // Some relevant bugs:
 // https://github.com/google/sanitizers/issues/1017
 // https://github.com/google/sanitizers/issues/619
 // https://github.com/google/sanitizers/issues/398
 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=68016
 // UNSUPPORTED: c++03, asan
 
-// XFAIL: LIBCXX-AIX-FIXME
-
 // <functional>
 
 // template<CopyConstructible Fn, CopyConstructible... Types>
 //   unspecified bind(Fn, Types...);
 // template<Returnable R, CopyConstructible Fn, CopyConstructible... Types>
 //   unspecified bind(Fn, Types...);
 
 // https://llvm.org/PR16385