Make libc++ headers "just work" on all Android versions.

[enh]

Summary

Many of the functions exposed by the <c*> headers weren't in Android
from the beginning. Worse, they weren't all added at the same time. This
patch adds the missing #if guards so that the libc++ headers work fine
against any Android OS version.

[ldionne]

I really want to avoid going down the road of adding more of these #ifs to our headers for importing stuff from the C library headers. It's a pain to maintain and it is very prone to creating conflicts with downstream patches. I've personally been keeping these #ifs downstream only to avoid creating too much burden on the upstream, until we have a better solution. We have been working on an implementation of the feature that was discussed here: http://lists.llvm.org/pipermail/cfe-dev/2020-June/066038.html, which would remove the need for these #ifs in the <cXXXX> headers.

I would rather wait until we have that Clang feature before we move forward.

[ldionne]

Actually, talk about timing! The Clang patch was just posted here: https://reviews.llvm.org/D90188

[danalbert]

In D87950#2354838, @ldionne wrote:

Actually, talk about timing! The Clang patch was just posted here: https://reviews.llvm.org/D90188

That's perfect, I hadn't seen that. I have no problem waiting for that.

[enh]

yeah, https://reviews.llvm.org/D90188 sounds better to me too.

libcxx/include/clocale

 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 using ::lconv;
 #ifndef _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
 using ::setlocale;
 #endif
+#if !defined(__ANDROID__) || (__ANDROID_API__ >= 21)
 using ::localeconv;
+#endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_CLOCALE

libcxx/include/cmath

 
 using ::nan;
 using ::nanf;
 
 using ::nearbyint;
 using ::nearbyintf;
 using ::nextafter;
 using ::nextafterf;
+#if !defined(__ANDROID__) || (__ANDROID_API__ >= 18)
 using ::nexttoward;
+#endif
 using ::nexttowardf;
 using ::remainder;
 using ::remainderf;
 using ::remquo;
 using ::remquof;
 using ::rint;
 using ::rintf;
 using ::round;
 using ::roundf;
+#if !defined(__ANDROID__) || (__ANDROID_API__ >= 18)
 using ::scalbln;
 using ::scalblnf;
+#endif
 using ::scalbn;
 using ::scalbnf;
 using ::tgamma;
 using ::tgammaf;
 using ::trunc;
 using ::truncf;
 
 using ::acosl;

 using ::llroundl;
 using ::log1pl;
 using ::log2l;
 using ::logbl;
 using ::lrintl;
 using ::lroundl;
 using ::nanl;
 using ::nearbyintl;
+#if !defined(__ANDROID__) || (__ANDROID_API__ >= 21)
 using ::nextafterl;
+#endif
+#if !defined(__ANDROID__) || (__ANDROID_API__ >= 18)
 using ::nexttowardl;
+#endif
 using ::remainderl;
 using ::remquol;
 using ::rintl;
 using ::roundl;
+#if !defined(__ANDROID__) || (__ANDROID_API__ >= 18)
 using ::scalblnl;
+#endif
 using ::scalbnl;
 using ::tgammal;
 using ::truncl;
 
 #if _LIBCPP_STD_VER > 14
 inline _LIBCPP_INLINE_VISIBILITY float       hypot(       float x,       float y,       float z ) { return sqrt(x*x + y*y + z*z); }
 inline _LIBCPP_INLINE_VISIBILITY double      hypot(      double x,      double y,      double z ) { return sqrt(x*x + y*y + z*z); }
 inline _LIBCPP_INLINE_VISIBILITY long double hypot( long double x, long double y, long double z ) { return sqrt(x*x + y*y + z*z); }

libcxx/include/cstdlib

 #ifndef _LIBCPP_HAS_NO_LONG_LONG
 using ::llabs;
 #endif // _LIBCPP_HAS_NO_LONG_LONG
 using ::div;
 using ::ldiv;
 #ifndef _LIBCPP_HAS_NO_LONG_LONG
 using ::lldiv;
 #endif // _LIBCPP_HAS_NO_LONG_LONG
+#if !defined(__ANDROID__) || (__ANDROID_API__ >= 26)
 using ::mblen;
+#endif
+#if !defined(__ANDROID__) || (__ANDROID_API__ >= 21)
 using ::mbtowc;
 using ::wctomb;
+#endif
 using ::mbstowcs;
 using ::wcstombs;
 #if !defined(_LIBCPP_CXX03_LANG) && defined(_LIBCPP_HAS_QUICK_EXIT)
 using ::at_quick_exit;
 using ::quick_exit;
 #endif
 #if _LIBCPP_STD_VER > 14 && defined(_LIBCPP_HAS_ALIGNED_ALLOC)
 using ::aligned_alloc;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_CSTDLIB

libcxx/include/cwctype

 using ::iswpunct;
 using ::iswspace;
 using ::iswupper;
 using ::iswxdigit;
 using ::iswctype;
 using ::wctype;
 using ::towlower;
 using ::towupper;
+#if !defined(__ANDROID__) || (__ANDROID_API__ >= 26)
 using ::towctrans;
 using ::wctrans;
+#endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_CWCTYPE

libcxx/include/math.h

 
 // div
 //
 // handled in stdlib.h
 
 // acos
 
 #if !(defined(_AIX) || 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
 
 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__))
 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
 
 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__))
 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
 
 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__))
 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
 
 template <class _A1, class _A2>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::_EnableIf
 <
     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__))
 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
 
 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__))
 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
 
 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__))
 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
 
 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
nextafter(_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 ::nextafter((__result_type)__lcpp_x, (__result_type)__lcpp_y);
 }
 
 // nexttoward
 
+#if !defined(__ANDROID__) || (__ANDROID_API__ >= 18)
 inline _LIBCPP_INLINE_VISIBILITY float       nexttoward(float __lcpp_x, long double __lcpp_y) _NOEXCEPT       {return ::nexttowardf(__lcpp_x, __lcpp_y);}
 inline _LIBCPP_INLINE_VISIBILITY long double nexttoward(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::nexttowardl(__lcpp_x, __lcpp_y);}
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 nexttoward(_A1 __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::nexttoward((double)__lcpp_x, __lcpp_y);}
+#endif
 
 // remainder
 
 inline _LIBCPP_INLINE_VISIBILITY float       remainder(float __lcpp_x, float __lcpp_y) _NOEXCEPT             {return ::remainderf(__lcpp_x, __lcpp_y);}
 inline _LIBCPP_INLINE_VISIBILITY long double remainder(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::remainderl(__lcpp_x, __lcpp_y);}
 
 template <class _A1, class _A2>
 inline _LIBCPP_INLINE_VISIBILITY

 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 round(_A1 __lcpp_x) _NOEXCEPT {return ::round((double)__lcpp_x);}
 
 // scalbln
 
+#if !defined(__ANDROID__) || (__ANDROID_API__ >= 18)
 inline _LIBCPP_INLINE_VISIBILITY float       scalbln(float __lcpp_x, long __lcpp_y) _NOEXCEPT       {return ::scalblnf(__lcpp_x, __lcpp_y);}
 inline _LIBCPP_INLINE_VISIBILITY long double scalbln(long double __lcpp_x, long __lcpp_y) _NOEXCEPT {return ::scalblnl(__lcpp_x, __lcpp_y);}
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 scalbln(_A1 __lcpp_x, long __lcpp_y) _NOEXCEPT {return ::scalbln((double)__lcpp_x, __lcpp_y);}
+#endif
 
 // scalbn
 
 inline _LIBCPP_INLINE_VISIBILITY float       scalbn(float __lcpp_x, int __lcpp_y) _NOEXCEPT       {return ::scalbnf(__lcpp_x, __lcpp_y);}
 inline _LIBCPP_INLINE_VISIBILITY long double scalbn(long double __lcpp_x, int __lcpp_y) _NOEXCEPT {return ::scalbnl(__lcpp_x, __lcpp_y);}
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY