[libc++] Use the using_if_exists attribute when provided

[ldionne]

Summary

As discussed on cfe-dev [1], use the using_if_exists Clang attribute when
the compiler supports it. This makes it easier to port libc++ on top of
new platforms that don't fully support the C Standard library.

Previously, libc++ would fail to build when trying to import a missing
declaration in a <cXXXX> header. With the attribute, the declaration will
simply not be imported into namespace std, and hence it won't be available
for libc++ to use. In many cases, the declarations were *not* actually
required for libc++ to work (they were only surfaced for users to use
them as std::XXXX), so not importing them into namespace std is acceptable.

The same thing could be achieved by conscious usage of #ifdef along
with platform detection, however that quickly creates a maintenance
problem as libc++ is ported to new platforms. Furthermore, this problem
is exacerbated when mixed with vendor internal-only platforms, which can
lead to difficulties maintaining a downstream fork of the library.

For the time being, we only use the using_if_exists attribute when it
is supported. At some point in the future, we will start removing #ifdef
paths that are unnecessary when the attribute is supported, and folks
who need those #ifdef paths will be required to use a compiler that
supports the attribute.

[1]: http://lists.llvm.org/pipermail/cfe-dev/2020-June/066038.html

[ldionne]

Note that once this is in, we can also start dropping existing #ifs in the headers to workaround various declarations missing in the underlying C stdlib, as long as we require a sufficiently recent Clang.

[lebedev.ri]

In D90257#2357188, @ldionne wrote:

Note that once this is in, we can also start dropping existing #ifs in the headers to workaround various declarations missing in the underlying C stdlib, as long as we require a sufficiently recent Clang.

What about other compilers?

[ldionne]

In D90257#2357223, @lebedev.ri wrote:

In D90257#2357188, @ldionne wrote:

Note that once this is in, we can also start dropping existing #ifs in the headers to workaround various declarations missing in the underlying C stdlib, as long as we require a sufficiently recent Clang.

What about other compilers?

We're not there yet -- I was just pointing to a possible future cleanup.

For other compilers: it seems reasonable to mandate that the attribute is supported on the compiler you're using if you're trying to port libc++ to a platform that doesn't provide a full standard library. It's a balance between ease-of-porting and ease-of-maintaining.

[ldionne]

Rebase onto main since the attribute has landed.

[ldionne]

After a quick grep through the sources, it seems like the following macros are the ones that currently gate using declarations:

_LIBCPP_C_HAS_NO_GETS
_LIBCPP_HAS_ALIGNED_ALLOC
_LIBCPP_HAS_NO_FGETPOS_FSETPOS
_LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
_LIBCPP_HAS_NO_LONG_LONG
_LIBCPP_HAS_NO_STDIN
_LIBCPP_HAS_NO_STDOUT
_LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
_LIBCPP_HAS_QUICK_EXIT
_LIBCPP_HAS_TIMESPEC_GET
_LIBCPP_WINDOWS_STORE_APP

If you see this review and are currently depending on one of these macros, please be aware that we will eventually stop guarding those declarations based on those macros (and in some cases that means a macro will become unused and we'll remove it). I'll do my best to communicate with vendors before that happens, however this is an early heads up.

@jasonliu @lebedev.ri @mstorsjo @danalbert @phosek for awareness.

[ldionne]

Rebase onto main

[ldionne]

Rebase and add a few usings that had been forgotten.

libcxx/include/__config

 
 #if __has_feature(cxx_explicit_conversions) || defined(__IBMCPP__) || \
     (!defined(_LIBCPP_CXX03_LANG) && defined(__GNUC__)) // All supported GCC versions
 #  define _LIBCPP_EXPLICIT explicit
 #else
 #  define _LIBCPP_EXPLICIT
 #endif
 
+#if __has_attribute(using_if_exists)
+# define _LIBCPP_USING_IF_EXISTS(...) using __VA_ARGS__ __attribute__((using_if_exists))
+#else
+# define _LIBCPP_USING_IF_EXISTS(...) using __VA_ARGS__
+#endif
+
 #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
 #  define _LIBCPP_DECLARE_STRONG_ENUM(x) struct _LIBCPP_TYPE_VIS x { enum __lx
 #  define _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(x) \
      __lx __v_; \
      _LIBCPP_INLINE_VISIBILITY x(__lx __v) : __v_(__v) {} \
      _LIBCPP_INLINE_VISIBILITY explicit x(int __v) : __v_(static_cast<__lx>(__v)) {} \
      _LIBCPP_INLINE_VISIBILITY operator int() const {return __v_;} \
      };

libcxx/include/cctype

 #ifdef tolower
 #undef tolower
 #endif
 
 #ifdef toupper
 #undef toupper
 #endif
 
-
-using ::isalnum;
-using ::isalpha;
-using ::isblank;
-using ::iscntrl;
-using ::isdigit;
-using ::isgraph;
-using ::islower;
-using ::isprint;
-using ::ispunct;
-using ::isspace;
-using ::isupper;
-using ::isxdigit;
-using ::tolower;
-using ::toupper;
+_LIBCPP_USING_IF_EXISTS(::isalnum);
+_LIBCPP_USING_IF_EXISTS(::isalpha);
+_LIBCPP_USING_IF_EXISTS(::isblank);
+_LIBCPP_USING_IF_EXISTS(::iscntrl);
+_LIBCPP_USING_IF_EXISTS(::isdigit);
+_LIBCPP_USING_IF_EXISTS(::isgraph);
+_LIBCPP_USING_IF_EXISTS(::islower);
+_LIBCPP_USING_IF_EXISTS(::isprint);
+_LIBCPP_USING_IF_EXISTS(::ispunct);
+_LIBCPP_USING_IF_EXISTS(::isspace);
+_LIBCPP_USING_IF_EXISTS(::isupper);
+_LIBCPP_USING_IF_EXISTS(::isxdigit);
+_LIBCPP_USING_IF_EXISTS(::tolower);
+_LIBCPP_USING_IF_EXISTS(::toupper);
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_CCTYPE

libcxx/include/cfenv

 #include <fenv.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-using ::fenv_t;
-using ::fexcept_t;
+_LIBCPP_USING_IF_EXISTS(::fenv_t);
+_LIBCPP_USING_IF_EXISTS(::fexcept_t);
 
-using ::feclearexcept;
-using ::fegetexceptflag;
-using ::feraiseexcept;
-using ::fesetexceptflag;
-using ::fetestexcept;
-using ::fegetround;
-using ::fesetround;
-using ::fegetenv;
-using ::feholdexcept;
-using ::fesetenv;
-using ::feupdateenv;
+_LIBCPP_USING_IF_EXISTS(::feclearexcept);
+_LIBCPP_USING_IF_EXISTS(::fegetexceptflag);
+_LIBCPP_USING_IF_EXISTS(::feraiseexcept);
+_LIBCPP_USING_IF_EXISTS(::fesetexceptflag);
+_LIBCPP_USING_IF_EXISTS(::fetestexcept);
+_LIBCPP_USING_IF_EXISTS(::fegetround);
+_LIBCPP_USING_IF_EXISTS(::fesetround);
+_LIBCPP_USING_IF_EXISTS(::fegetenv);
+_LIBCPP_USING_IF_EXISTS(::feholdexcept);
+_LIBCPP_USING_IF_EXISTS(::fesetenv);
+_LIBCPP_USING_IF_EXISTS(::feupdateenv);
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_CFENV

libcxx/include/cinttypes

 #include <inttypes.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-using::imaxdiv_t;
-using::imaxabs;
-using::imaxdiv;
-using::strtoimax;
-using::strtoumax;
-using::wcstoimax;
-using::wcstoumax;
+_LIBCPP_USING_IF_EXISTS(::imaxdiv_t);
+_LIBCPP_USING_IF_EXISTS(::imaxabs);
+_LIBCPP_USING_IF_EXISTS(::imaxdiv);
+_LIBCPP_USING_IF_EXISTS(::strtoimax);
+_LIBCPP_USING_IF_EXISTS(::strtoumax);
+_LIBCPP_USING_IF_EXISTS(::wcstoimax);
+_LIBCPP_USING_IF_EXISTS(::wcstoumax);
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_CINTTYPES

libcxx/include/clocale

 #include <locale.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-using ::lconv;
+_LIBCPP_USING_IF_EXISTS(::lconv);
 #ifndef _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
-using ::setlocale;
+_LIBCPP_USING_IF_EXISTS(::setlocale);
 #endif
-using ::localeconv;
+_LIBCPP_USING_IF_EXISTS(::localeconv);
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_CLOCALE

libcxx/include/cmath

 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-using ::signbit;
-using ::fpclassify;
-using ::isfinite;
-using ::isinf;
-using ::isnan;
-using ::isnormal;
-using ::isgreater;
-using ::isgreaterequal;
-using ::isless;
-using ::islessequal;
-using ::islessgreater;
-using ::isunordered;
-using ::isunordered;
+_LIBCPP_USING_IF_EXISTS(::signbit);
+_LIBCPP_USING_IF_EXISTS(::fpclassify);
+_LIBCPP_USING_IF_EXISTS(::isfinite);
+_LIBCPP_USING_IF_EXISTS(::isinf);
+_LIBCPP_USING_IF_EXISTS(::isnan);
+_LIBCPP_USING_IF_EXISTS(::isnormal);
+_LIBCPP_USING_IF_EXISTS(::isgreater);
+_LIBCPP_USING_IF_EXISTS(::isgreaterequal);
+_LIBCPP_USING_IF_EXISTS(::isless);
+_LIBCPP_USING_IF_EXISTS(::islessequal);
+_LIBCPP_USING_IF_EXISTS(::islessgreater);
+_LIBCPP_USING_IF_EXISTS(::isunordered);
+_LIBCPP_USING_IF_EXISTS(::isunordered);
 
-using ::float_t;
-using ::double_t;
+_LIBCPP_USING_IF_EXISTS(::float_t);
+_LIBCPP_USING_IF_EXISTS(::double_t);
 
 #ifndef _AIX
-using ::abs;
+_LIBCPP_USING_IF_EXISTS(::abs);
 #endif
 
-using ::acos;
-using ::acosf;
-using ::asin;
-using ::asinf;
-using ::atan;
-using ::atanf;
-using ::atan2;
-using ::atan2f;
-using ::ceil;
-using ::ceilf;
-using ::cos;
-using ::cosf;
-using ::cosh;
-using ::coshf;
-
-using ::exp;
-using ::expf;
-
-using ::fabs;
-using ::fabsf;
-using ::floor;
-using ::floorf;
-
-using ::fmod;
-using ::fmodf;
-
-using ::frexp;
-using ::frexpf;
-using ::ldexp;
-using ::ldexpf;
-
-using ::log;
-using ::logf;
-
-using ::log10;
-using ::log10f;
-using ::modf;
-using ::modff;
-
-using ::pow;
-using ::powf;
-
-using ::sin;
-using ::sinf;
-using ::sinh;
-using ::sinhf;
-
-using ::sqrt;
-using ::sqrtf;
-using ::tan;
-using ::tanf;
-
-using ::tanh;
-using ::tanhf;
-
-using ::acosh;
-using ::acoshf;
-using ::asinh;
-using ::asinhf;
-using ::atanh;
-using ::atanhf;
-using ::cbrt;
-using ::cbrtf;
-
-using ::copysign;
-using ::copysignf;
-
-using ::erf;
-using ::erff;
-using ::erfc;
-using ::erfcf;
-using ::exp2;
-using ::exp2f;
-using ::expm1;
-using ::expm1f;
-using ::fdim;
-using ::fdimf;
-using ::fmaf;
-using ::fma;
-using ::fmax;
-using ::fmaxf;
-using ::fmin;
-using ::fminf;
-using ::hypot;
-using ::hypotf;
-using ::ilogb;
-using ::ilogbf;
-using ::lgamma;
-using ::lgammaf;
-using ::llrint;
-using ::llrintf;
-using ::llround;
-using ::llroundf;
-using ::log1p;
-using ::log1pf;
-using ::log2;
-using ::log2f;
-using ::logb;
-using ::logbf;
-using ::lrint;
-using ::lrintf;
-using ::lround;
-using ::lroundf;
-
-using ::nan;
-using ::nanf;
-
-using ::nearbyint;
-using ::nearbyintf;
-using ::nextafter;
-using ::nextafterf;
-using ::nexttoward;
-using ::nexttowardf;
-using ::remainder;
-using ::remainderf;
-using ::remquo;
-using ::remquof;
-using ::rint;
-using ::rintf;
-using ::round;
-using ::roundf;
-using ::scalbln;
-using ::scalblnf;
-using ::scalbn;
-using ::scalbnf;
-using ::tgamma;
-using ::tgammaf;
-using ::trunc;
-using ::truncf;
-
-using ::acosl;
-using ::asinl;
-using ::atanl;
-using ::atan2l;
-using ::ceill;
-using ::cosl;
-using ::coshl;
-using ::expl;
-using ::fabsl;
-using ::floorl;
-using ::fmodl;
-using ::frexpl;
-using ::ldexpl;
-using ::logl;
-using ::log10l;
-using ::modfl;
-using ::powl;
-using ::sinl;
-using ::sinhl;
-using ::sqrtl;
-using ::tanl;
-
-using ::tanhl;
-using ::acoshl;
-using ::asinhl;
-using ::atanhl;
-using ::cbrtl;
-
-using ::copysignl;
-
-using ::erfl;
-using ::erfcl;
-using ::exp2l;
-using ::expm1l;
-using ::fdiml;
-using ::fmal;
-using ::fmaxl;
-using ::fminl;
-using ::hypotl;
-using ::ilogbl;
-using ::lgammal;
-using ::llrintl;
-using ::llroundl;
-using ::log1pl;
-using ::log2l;
-using ::logbl;
-using ::lrintl;
-using ::lroundl;
-using ::nanl;
-using ::nearbyintl;
-using ::nextafterl;
-using ::nexttowardl;
-using ::remainderl;
-using ::remquol;
-using ::rintl;
-using ::roundl;
-using ::scalblnl;
-using ::scalbnl;
-using ::tgammal;
-using ::truncl;
+_LIBCPP_USING_IF_EXISTS(::acos);
+_LIBCPP_USING_IF_EXISTS(::acosf);
+_LIBCPP_USING_IF_EXISTS(::asin);
+_LIBCPP_USING_IF_EXISTS(::asinf);
+_LIBCPP_USING_IF_EXISTS(::atan);
+_LIBCPP_USING_IF_EXISTS(::atanf);
+_LIBCPP_USING_IF_EXISTS(::atan2);
+_LIBCPP_USING_IF_EXISTS(::atan2f);
+_LIBCPP_USING_IF_EXISTS(::ceil);
+_LIBCPP_USING_IF_EXISTS(::ceilf);
+_LIBCPP_USING_IF_EXISTS(::cos);
+_LIBCPP_USING_IF_EXISTS(::cosf);
+_LIBCPP_USING_IF_EXISTS(::cosh);
+_LIBCPP_USING_IF_EXISTS(::coshf);
+
+_LIBCPP_USING_IF_EXISTS(::exp);
+_LIBCPP_USING_IF_EXISTS(::expf);
+
+_LIBCPP_USING_IF_EXISTS(::fabs);
+_LIBCPP_USING_IF_EXISTS(::fabsf);
+_LIBCPP_USING_IF_EXISTS(::floor);
+_LIBCPP_USING_IF_EXISTS(::floorf);
+
+_LIBCPP_USING_IF_EXISTS(::fmod);
+_LIBCPP_USING_IF_EXISTS(::fmodf);
+
+_LIBCPP_USING_IF_EXISTS(::frexp);
+_LIBCPP_USING_IF_EXISTS(::frexpf);
+_LIBCPP_USING_IF_EXISTS(::ldexp);
+_LIBCPP_USING_IF_EXISTS(::ldexpf);
+
+_LIBCPP_USING_IF_EXISTS(::log);
+_LIBCPP_USING_IF_EXISTS(::logf);
+
+_LIBCPP_USING_IF_EXISTS(::log10);
+_LIBCPP_USING_IF_EXISTS(::log10f);
+_LIBCPP_USING_IF_EXISTS(::modf);
+_LIBCPP_USING_IF_EXISTS(::modff);
+
+_LIBCPP_USING_IF_EXISTS(::pow);
+_LIBCPP_USING_IF_EXISTS(::powf);
+
+_LIBCPP_USING_IF_EXISTS(::sin);
+_LIBCPP_USING_IF_EXISTS(::sinf);
+_LIBCPP_USING_IF_EXISTS(::sinh);
+_LIBCPP_USING_IF_EXISTS(::sinhf);
+
+_LIBCPP_USING_IF_EXISTS(::sqrt);
+_LIBCPP_USING_IF_EXISTS(::sqrtf);
+_LIBCPP_USING_IF_EXISTS(::tan);
+_LIBCPP_USING_IF_EXISTS(::tanf);
+
+_LIBCPP_USING_IF_EXISTS(::tanh);
+_LIBCPP_USING_IF_EXISTS(::tanhf);
+
+_LIBCPP_USING_IF_EXISTS(::acosh);
+_LIBCPP_USING_IF_EXISTS(::acoshf);
+_LIBCPP_USING_IF_EXISTS(::asinh);
+_LIBCPP_USING_IF_EXISTS(::asinhf);
+_LIBCPP_USING_IF_EXISTS(::atanh);
+_LIBCPP_USING_IF_EXISTS(::atanhf);
+_LIBCPP_USING_IF_EXISTS(::cbrt);
+_LIBCPP_USING_IF_EXISTS(::cbrtf);
+
+_LIBCPP_USING_IF_EXISTS(::copysign);
+_LIBCPP_USING_IF_EXISTS(::copysignf);
+
+_LIBCPP_USING_IF_EXISTS(::erf);
+_LIBCPP_USING_IF_EXISTS(::erff);
+_LIBCPP_USING_IF_EXISTS(::erfc);
+_LIBCPP_USING_IF_EXISTS(::erfcf);
+_LIBCPP_USING_IF_EXISTS(::exp2);
+_LIBCPP_USING_IF_EXISTS(::exp2f);
+_LIBCPP_USING_IF_EXISTS(::expm1);
+_LIBCPP_USING_IF_EXISTS(::expm1f);
+_LIBCPP_USING_IF_EXISTS(::fdim);
+_LIBCPP_USING_IF_EXISTS(::fdimf);
+_LIBCPP_USING_IF_EXISTS(::fmaf);
+_LIBCPP_USING_IF_EXISTS(::fma);
+_LIBCPP_USING_IF_EXISTS(::fmax);
+_LIBCPP_USING_IF_EXISTS(::fmaxf);
+_LIBCPP_USING_IF_EXISTS(::fmin);
+_LIBCPP_USING_IF_EXISTS(::fminf);
+_LIBCPP_USING_IF_EXISTS(::hypot);
+_LIBCPP_USING_IF_EXISTS(::hypotf);
+_LIBCPP_USING_IF_EXISTS(::ilogb);
+_LIBCPP_USING_IF_EXISTS(::ilogbf);
+_LIBCPP_USING_IF_EXISTS(::lgamma);
+_LIBCPP_USING_IF_EXISTS(::lgammaf);
+_LIBCPP_USING_IF_EXISTS(::llrint);
+_LIBCPP_USING_IF_EXISTS(::llrintf);
+_LIBCPP_USING_IF_EXISTS(::llround);
+_LIBCPP_USING_IF_EXISTS(::llroundf);
+_LIBCPP_USING_IF_EXISTS(::log1p);
+_LIBCPP_USING_IF_EXISTS(::log1pf);
+_LIBCPP_USING_IF_EXISTS(::log2);
+_LIBCPP_USING_IF_EXISTS(::log2f);
+_LIBCPP_USING_IF_EXISTS(::logb);
+_LIBCPP_USING_IF_EXISTS(::logbf);
+_LIBCPP_USING_IF_EXISTS(::lrint);
+_LIBCPP_USING_IF_EXISTS(::lrintf);
+_LIBCPP_USING_IF_EXISTS(::lround);
+_LIBCPP_USING_IF_EXISTS(::lroundf);
+
+_LIBCPP_USING_IF_EXISTS(::nan);
+_LIBCPP_USING_IF_EXISTS(::nanf);
+
+_LIBCPP_USING_IF_EXISTS(::nearbyint);
+_LIBCPP_USING_IF_EXISTS(::nearbyintf);
+_LIBCPP_USING_IF_EXISTS(::nextafter);
+_LIBCPP_USING_IF_EXISTS(::nextafterf);
+_LIBCPP_USING_IF_EXISTS(::nexttoward);
+_LIBCPP_USING_IF_EXISTS(::nexttowardf);
+_LIBCPP_USING_IF_EXISTS(::remainder);
+_LIBCPP_USING_IF_EXISTS(::remainderf);
+_LIBCPP_USING_IF_EXISTS(::remquo);
+_LIBCPP_USING_IF_EXISTS(::remquof);
+_LIBCPP_USING_IF_EXISTS(::rint);
+_LIBCPP_USING_IF_EXISTS(::rintf);
+_LIBCPP_USING_IF_EXISTS(::round);
+_LIBCPP_USING_IF_EXISTS(::roundf);
+_LIBCPP_USING_IF_EXISTS(::scalbln);
+_LIBCPP_USING_IF_EXISTS(::scalblnf);
+_LIBCPP_USING_IF_EXISTS(::scalbn);
+_LIBCPP_USING_IF_EXISTS(::scalbnf);
+_LIBCPP_USING_IF_EXISTS(::tgamma);
+_LIBCPP_USING_IF_EXISTS(::tgammaf);
+_LIBCPP_USING_IF_EXISTS(::trunc);
+_LIBCPP_USING_IF_EXISTS(::truncf);
+
+_LIBCPP_USING_IF_EXISTS(::acosl);
+_LIBCPP_USING_IF_EXISTS(::asinl);
+_LIBCPP_USING_IF_EXISTS(::atanl);
+_LIBCPP_USING_IF_EXISTS(::atan2l);
+_LIBCPP_USING_IF_EXISTS(::ceill);
+_LIBCPP_USING_IF_EXISTS(::cosl);
+_LIBCPP_USING_IF_EXISTS(::coshl);
+_LIBCPP_USING_IF_EXISTS(::expl);
+_LIBCPP_USING_IF_EXISTS(::fabsl);
+_LIBCPP_USING_IF_EXISTS(::floorl);
+_LIBCPP_USING_IF_EXISTS(::fmodl);
+_LIBCPP_USING_IF_EXISTS(::frexpl);
+_LIBCPP_USING_IF_EXISTS(::ldexpl);
+_LIBCPP_USING_IF_EXISTS(::logl);
+_LIBCPP_USING_IF_EXISTS(::log10l);
+_LIBCPP_USING_IF_EXISTS(::modfl);
+_LIBCPP_USING_IF_EXISTS(::powl);
+_LIBCPP_USING_IF_EXISTS(::sinl);
+_LIBCPP_USING_IF_EXISTS(::sinhl);
+_LIBCPP_USING_IF_EXISTS(::sqrtl);
+_LIBCPP_USING_IF_EXISTS(::tanl);
+
+_LIBCPP_USING_IF_EXISTS(::tanhl);
+_LIBCPP_USING_IF_EXISTS(::acoshl);
+_LIBCPP_USING_IF_EXISTS(::asinhl);
+_LIBCPP_USING_IF_EXISTS(::atanhl);
+_LIBCPP_USING_IF_EXISTS(::cbrtl);
+
+_LIBCPP_USING_IF_EXISTS(::copysignl);
+
+_LIBCPP_USING_IF_EXISTS(::erfl);
+_LIBCPP_USING_IF_EXISTS(::erfcl);
+_LIBCPP_USING_IF_EXISTS(::exp2l);
+_LIBCPP_USING_IF_EXISTS(::expm1l);
+_LIBCPP_USING_IF_EXISTS(::fdiml);
+_LIBCPP_USING_IF_EXISTS(::fmal);
+_LIBCPP_USING_IF_EXISTS(::fmaxl);
+_LIBCPP_USING_IF_EXISTS(::fminl);
+_LIBCPP_USING_IF_EXISTS(::hypotl);
+_LIBCPP_USING_IF_EXISTS(::ilogbl);
+_LIBCPP_USING_IF_EXISTS(::lgammal);
+_LIBCPP_USING_IF_EXISTS(::llrintl);
+_LIBCPP_USING_IF_EXISTS(::llroundl);
+_LIBCPP_USING_IF_EXISTS(::log1pl);
+_LIBCPP_USING_IF_EXISTS(::log2l);
+_LIBCPP_USING_IF_EXISTS(::logbl);
+_LIBCPP_USING_IF_EXISTS(::lrintl);
+_LIBCPP_USING_IF_EXISTS(::lroundl);
+_LIBCPP_USING_IF_EXISTS(::nanl);
+_LIBCPP_USING_IF_EXISTS(::nearbyintl);
+_LIBCPP_USING_IF_EXISTS(::nextafterl);
+_LIBCPP_USING_IF_EXISTS(::nexttowardl);
+_LIBCPP_USING_IF_EXISTS(::remainderl);
+_LIBCPP_USING_IF_EXISTS(::remquol);
+_LIBCPP_USING_IF_EXISTS(::rintl);
+_LIBCPP_USING_IF_EXISTS(::roundl);
+_LIBCPP_USING_IF_EXISTS(::scalblnl);
+_LIBCPP_USING_IF_EXISTS(::scalbnl);
+_LIBCPP_USING_IF_EXISTS(::tgammal);
+_LIBCPP_USING_IF_EXISTS(::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); }
 
 template <class _A1, class _A2, class _A3>
 inline _LIBCPP_INLINE_VISIBILITY

libcxx/include/csetjmp

 #include <setjmp.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-using ::jmp_buf;
-using ::longjmp;
+_LIBCPP_USING_IF_EXISTS(::jmp_buf);
+_LIBCPP_USING_IF_EXISTS(::longjmp);
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_CSETJMP

libcxx/include/csignal

 #include <signal.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-using ::sig_atomic_t;
-using ::signal;
-using ::raise;
+_LIBCPP_USING_IF_EXISTS(::sig_atomic_t);
+_LIBCPP_USING_IF_EXISTS(::signal);
+_LIBCPP_USING_IF_EXISTS(::raise);
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_CSIGNAL

libcxx/include/cstdarg

 #include <stdarg.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-using ::va_list;
+_LIBCPP_USING_IF_EXISTS(::va_list);
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_CSTDARG

libcxx/include/cstddef

 #endif
 
 // Don't include our own <stddef.h>; we don't want to declare ::nullptr_t.
 #include_next <stddef.h>
 #include <__nullptr>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-using ::ptrdiff_t;
-using ::size_t;
+_LIBCPP_USING_IF_EXISTS(::ptrdiff_t);
+_LIBCPP_USING_IF_EXISTS(::size_t);
 
 #if !defined(_LIBCPP_CXX03_LANG)
-using ::max_align_t;
+_LIBCPP_USING_IF_EXISTS(::max_align_t);
 #endif
 
 template <class _Tp> struct __libcpp_is_integral                     { enum { value = 0 }; };
 template <>          struct __libcpp_is_integral<bool>               { enum { value = 1 }; };
 template <>          struct __libcpp_is_integral<char>               { enum { value = 1 }; };
 template <>          struct __libcpp_is_integral<signed char>        { enum { value = 1 }; };
 template <>          struct __libcpp_is_integral<unsigned char>      { enum { value = 1 }; };
 template <>          struct __libcpp_is_integral<wchar_t>            { enum { value = 1 }; };

libcxx/include/cstdint

 #include <stdint.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-using::int8_t;
-using::int16_t;
-using::int32_t;
-using::int64_t;
-
-using::uint8_t;
-using::uint16_t;
-using::uint32_t;
-using::uint64_t;
-
-using::int_least8_t;
-using::int_least16_t;
-using::int_least32_t;
-using::int_least64_t;
-
-using::uint_least8_t;
-using::uint_least16_t;
-using::uint_least32_t;
-using::uint_least64_t;
-
-using::int_fast8_t;
-using::int_fast16_t;
-using::int_fast32_t;
-using::int_fast64_t;
-
-using::uint_fast8_t;
-using::uint_fast16_t;
-using::uint_fast32_t;
-using::uint_fast64_t;
+_LIBCPP_USING_IF_EXISTS(::int8_t);
+_LIBCPP_USING_IF_EXISTS(::int16_t);
+_LIBCPP_USING_IF_EXISTS(::int32_t);
+_LIBCPP_USING_IF_EXISTS(::int64_t);
+
+_LIBCPP_USING_IF_EXISTS(::uint8_t);
+_LIBCPP_USING_IF_EXISTS(::uint16_t);
+_LIBCPP_USING_IF_EXISTS(::uint32_t);
+_LIBCPP_USING_IF_EXISTS(::uint64_t);
+
+_LIBCPP_USING_IF_EXISTS(::int_least8_t);
+_LIBCPP_USING_IF_EXISTS(::int_least16_t);
+_LIBCPP_USING_IF_EXISTS(::int_least32_t);
+_LIBCPP_USING_IF_EXISTS(::int_least64_t);
+
+_LIBCPP_USING_IF_EXISTS(::uint_least8_t);
+_LIBCPP_USING_IF_EXISTS(::uint_least16_t);
+_LIBCPP_USING_IF_EXISTS(::uint_least32_t);
+_LIBCPP_USING_IF_EXISTS(::uint_least64_t);
+
+_LIBCPP_USING_IF_EXISTS(::int_fast8_t);
+_LIBCPP_USING_IF_EXISTS(::int_fast16_t);
+_LIBCPP_USING_IF_EXISTS(::int_fast32_t);
+_LIBCPP_USING_IF_EXISTS(::int_fast64_t);
+
+_LIBCPP_USING_IF_EXISTS(::uint_fast8_t);
+_LIBCPP_USING_IF_EXISTS(::uint_fast16_t);
+_LIBCPP_USING_IF_EXISTS(::uint_fast32_t);
+_LIBCPP_USING_IF_EXISTS(::uint_fast64_t);
 
-using::intptr_t;
-using::uintptr_t;
+_LIBCPP_USING_IF_EXISTS(::intptr_t);
+_LIBCPP_USING_IF_EXISTS(::uintptr_t);
 
-using::intmax_t;
-using::uintmax_t;
+_LIBCPP_USING_IF_EXISTS(::intmax_t);
+_LIBCPP_USING_IF_EXISTS(::uintmax_t);
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_CSTDINT

libcxx/include/cstdio

 #include <stdio.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-using ::FILE;
-using ::fpos_t;
-using ::size_t;
-
-using ::fclose;
-using ::fflush;
-using ::setbuf;
-using ::setvbuf;
-using ::fprintf;
-using ::fscanf;
-using ::snprintf;
-using ::sprintf;
-using ::sscanf;
-using ::vfprintf;
-using ::vfscanf;
-using ::vsscanf;
-using ::vsnprintf;
-using ::vsprintf;
-using ::fgetc;
-using ::fgets;
-using ::fputc;
-using ::fputs;
-using ::getc;
-using ::putc;
-using ::ungetc;
-using ::fread;
-using ::fwrite;
+_LIBCPP_USING_IF_EXISTS(::FILE);
+_LIBCPP_USING_IF_EXISTS(::fpos_t);
+_LIBCPP_USING_IF_EXISTS(::size_t);
+
+_LIBCPP_USING_IF_EXISTS(::fclose);
+_LIBCPP_USING_IF_EXISTS(::fflush);
+_LIBCPP_USING_IF_EXISTS(::setbuf);
+_LIBCPP_USING_IF_EXISTS(::setvbuf);
+_LIBCPP_USING_IF_EXISTS(::fprintf);
+_LIBCPP_USING_IF_EXISTS(::fscanf);
+_LIBCPP_USING_IF_EXISTS(::snprintf);
+_LIBCPP_USING_IF_EXISTS(::sprintf);
+_LIBCPP_USING_IF_EXISTS(::sscanf);
+_LIBCPP_USING_IF_EXISTS(::vfprintf);
+_LIBCPP_USING_IF_EXISTS(::vfscanf);
+_LIBCPP_USING_IF_EXISTS(::vsscanf);
+_LIBCPP_USING_IF_EXISTS(::vsnprintf);
+_LIBCPP_USING_IF_EXISTS(::vsprintf);
+_LIBCPP_USING_IF_EXISTS(::fgetc);
+_LIBCPP_USING_IF_EXISTS(::fgets);
+_LIBCPP_USING_IF_EXISTS(::fputc);
+_LIBCPP_USING_IF_EXISTS(::fputs);
+_LIBCPP_USING_IF_EXISTS(::getc);
+_LIBCPP_USING_IF_EXISTS(::putc);
+_LIBCPP_USING_IF_EXISTS(::ungetc);
+_LIBCPP_USING_IF_EXISTS(::fread);
+_LIBCPP_USING_IF_EXISTS(::fwrite);
 #ifndef _LIBCPP_HAS_NO_FGETPOS_FSETPOS
-using ::fgetpos;
+_LIBCPP_USING_IF_EXISTS(::fgetpos);
 #endif
-using ::fseek;
+_LIBCPP_USING_IF_EXISTS(::fseek);
 #ifndef _LIBCPP_HAS_NO_FGETPOS_FSETPOS
-using ::fsetpos;
+_LIBCPP_USING_IF_EXISTS(::fsetpos);
 #endif
-using ::ftell;
-using ::rewind;
-using ::clearerr;
-using ::feof;
-using ::ferror;
-using ::perror;
+_LIBCPP_USING_IF_EXISTS(::ftell);
+_LIBCPP_USING_IF_EXISTS(::rewind);
+_LIBCPP_USING_IF_EXISTS(::clearerr);
+_LIBCPP_USING_IF_EXISTS(::feof);
+_LIBCPP_USING_IF_EXISTS(::ferror);
+_LIBCPP_USING_IF_EXISTS(::perror);
 
 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
-using ::fopen;
-using ::freopen;
-using ::remove;
-using ::rename;
-using ::tmpfile;
-using ::tmpnam;
+_LIBCPP_USING_IF_EXISTS(::fopen);
+_LIBCPP_USING_IF_EXISTS(::freopen);
+_LIBCPP_USING_IF_EXISTS(::remove);
+_LIBCPP_USING_IF_EXISTS(::rename);
+_LIBCPP_USING_IF_EXISTS(::tmpfile);
+_LIBCPP_USING_IF_EXISTS(::tmpnam);
 #endif
 
 #ifndef _LIBCPP_HAS_NO_STDIN
-using ::getchar;
+_LIBCPP_USING_IF_EXISTS(::getchar);
 #if _LIBCPP_STD_VER <= 11 && !defined(_LIBCPP_C_HAS_NO_GETS)
-using ::gets;
+_LIBCPP_USING_IF_EXISTS(::gets);
 #endif
-using ::scanf;
-using ::vscanf;
+_LIBCPP_USING_IF_EXISTS(::scanf);
+_LIBCPP_USING_IF_EXISTS(::vscanf);
 #endif
 
 #ifndef _LIBCPP_HAS_NO_STDOUT
-using ::printf;
-using ::putchar;
-using ::puts;
-using ::vprintf;
+_LIBCPP_USING_IF_EXISTS(::printf);
+_LIBCPP_USING_IF_EXISTS(::putchar);
+_LIBCPP_USING_IF_EXISTS(::puts);
+_LIBCPP_USING_IF_EXISTS(::vprintf);
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_CSTDIO

libcxx/include/cstdlib

 #ifdef __GNUC__
 #define _LIBCPP_UNREACHABLE() __builtin_unreachable()
 #else
 #define _LIBCPP_UNREACHABLE() _VSTD::abort()
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-using ::size_t;
-using ::div_t;
-using ::ldiv_t;
-#ifndef _LIBCPP_HAS_NO_LONG_LONG
-using ::lldiv_t;
-#endif // _LIBCPP_HAS_NO_LONG_LONG
-using ::atof;
-using ::atoi;
-using ::atol;
-#ifndef _LIBCPP_HAS_NO_LONG_LONG
-using ::atoll;
-#endif // _LIBCPP_HAS_NO_LONG_LONG
-using ::strtod;
-using ::strtof;
-using ::strtold;
-using ::strtol;
-#ifndef _LIBCPP_HAS_NO_LONG_LONG
-using ::strtoll;
-#endif // _LIBCPP_HAS_NO_LONG_LONG
-using ::strtoul;
-#ifndef _LIBCPP_HAS_NO_LONG_LONG
-using ::strtoull;
-#endif // _LIBCPP_HAS_NO_LONG_LONG
-using ::rand;
-using ::srand;
-using ::calloc;
-using ::free;
-using ::malloc;
-using ::realloc;
-using ::abort;
-using ::atexit;
-using ::exit;
-using ::_Exit;
+_LIBCPP_USING_IF_EXISTS(::size_t);
+_LIBCPP_USING_IF_EXISTS(::div_t);
+_LIBCPP_USING_IF_EXISTS(::ldiv_t);
+#ifndef _LIBCPP_HAS_NO_LONG_LONG
+_LIBCPP_USING_IF_EXISTS(::lldiv_t);
+#endif // _LIBCPP_HAS_NO_LONG_LONG
+_LIBCPP_USING_IF_EXISTS(::atof);
+_LIBCPP_USING_IF_EXISTS(::atoi);
+_LIBCPP_USING_IF_EXISTS(::atol);
+#ifndef _LIBCPP_HAS_NO_LONG_LONG
+_LIBCPP_USING_IF_EXISTS(::atoll);
+#endif // _LIBCPP_HAS_NO_LONG_LONG
+_LIBCPP_USING_IF_EXISTS(::strtod);
+_LIBCPP_USING_IF_EXISTS(::strtof);
+_LIBCPP_USING_IF_EXISTS(::strtold);
+_LIBCPP_USING_IF_EXISTS(::strtol);
+#ifndef _LIBCPP_HAS_NO_LONG_LONG
+_LIBCPP_USING_IF_EXISTS(::strtoll);
+#endif // _LIBCPP_HAS_NO_LONG_LONG
+_LIBCPP_USING_IF_EXISTS(::strtoul);
+#ifndef _LIBCPP_HAS_NO_LONG_LONG
+_LIBCPP_USING_IF_EXISTS(::strtoull);
+#endif // _LIBCPP_HAS_NO_LONG_LONG
+_LIBCPP_USING_IF_EXISTS(::rand);
+_LIBCPP_USING_IF_EXISTS(::srand);
+_LIBCPP_USING_IF_EXISTS(::calloc);
+_LIBCPP_USING_IF_EXISTS(::free);
+_LIBCPP_USING_IF_EXISTS(::malloc);
+_LIBCPP_USING_IF_EXISTS(::realloc);
+_LIBCPP_USING_IF_EXISTS(::abort);
+_LIBCPP_USING_IF_EXISTS(::atexit);
+_LIBCPP_USING_IF_EXISTS(::exit);
+_LIBCPP_USING_IF_EXISTS(::_Exit);
 #ifndef _LIBCPP_WINDOWS_STORE_APP
-using ::getenv;
-using ::system;
+_LIBCPP_USING_IF_EXISTS(::getenv);
+_LIBCPP_USING_IF_EXISTS(::system);
 #endif
-using ::bsearch;
-using ::qsort;
-using ::abs;
-using ::labs;
-#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
-using ::mblen;
-using ::mbtowc;
-using ::wctomb;
-using ::mbstowcs;
-using ::wcstombs;
+_LIBCPP_USING_IF_EXISTS(::bsearch);
+_LIBCPP_USING_IF_EXISTS(::qsort);
+_LIBCPP_USING_IF_EXISTS(::abs);
+_LIBCPP_USING_IF_EXISTS(::labs);
+#ifndef _LIBCPP_HAS_NO_LONG_LONG
+_LIBCPP_USING_IF_EXISTS(::llabs);
+#endif // _LIBCPP_HAS_NO_LONG_LONG
+_LIBCPP_USING_IF_EXISTS(::div);
+_LIBCPP_USING_IF_EXISTS(::ldiv);
+#ifndef _LIBCPP_HAS_NO_LONG_LONG
+_LIBCPP_USING_IF_EXISTS(::lldiv);
+#endif // _LIBCPP_HAS_NO_LONG_LONG
+_LIBCPP_USING_IF_EXISTS(::mblen);
+_LIBCPP_USING_IF_EXISTS(::mbtowc);
+_LIBCPP_USING_IF_EXISTS(::wctomb);
+_LIBCPP_USING_IF_EXISTS(::mbstowcs);
+_LIBCPP_USING_IF_EXISTS(::wcstombs);
 #if !defined(_LIBCPP_CXX03_LANG) && defined(_LIBCPP_HAS_QUICK_EXIT)
-using ::at_quick_exit;
-using ::quick_exit;
+_LIBCPP_USING_IF_EXISTS(::at_quick_exit);
+_LIBCPP_USING_IF_EXISTS(::quick_exit);
 #endif
 #if _LIBCPP_STD_VER > 14 && defined(_LIBCPP_HAS_ALIGNED_ALLOC)
-using ::aligned_alloc;
+_LIBCPP_USING_IF_EXISTS(::aligned_alloc);
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_CSTDLIB

libcxx/include/cstring

 #include <string.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-using ::size_t;
-using ::memcpy;
-using ::memmove;
-using ::strcpy;
-using ::strncpy;
-using ::strcat;
-using ::strncat;
-using ::memcmp;
-using ::strcmp;
-using ::strncmp;
-using ::strcoll;
-using ::strxfrm;
-using ::memchr;
-using ::strchr;
-using ::strcspn;
-using ::strpbrk;
-using ::strrchr;
-using ::strspn;
-using ::strstr;
+_LIBCPP_USING_IF_EXISTS(::size_t);
+_LIBCPP_USING_IF_EXISTS(::memcpy);
+_LIBCPP_USING_IF_EXISTS(::memmove);
+_LIBCPP_USING_IF_EXISTS(::strcpy);
+_LIBCPP_USING_IF_EXISTS(::strncpy);
+_LIBCPP_USING_IF_EXISTS(::strcat);
+_LIBCPP_USING_IF_EXISTS(::strncat);
+_LIBCPP_USING_IF_EXISTS(::memcmp);
+_LIBCPP_USING_IF_EXISTS(::strcmp);
+_LIBCPP_USING_IF_EXISTS(::strncmp);
+_LIBCPP_USING_IF_EXISTS(::strcoll);
+_LIBCPP_USING_IF_EXISTS(::strxfrm);
+_LIBCPP_USING_IF_EXISTS(::memchr);
+_LIBCPP_USING_IF_EXISTS(::strchr);
+_LIBCPP_USING_IF_EXISTS(::strcspn);
+_LIBCPP_USING_IF_EXISTS(::strpbrk);
+_LIBCPP_USING_IF_EXISTS(::strrchr);
+_LIBCPP_USING_IF_EXISTS(::strspn);
+_LIBCPP_USING_IF_EXISTS(::strstr);
 #ifndef _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
-using ::strtok;
+_LIBCPP_USING_IF_EXISTS(::strtok);
 #endif
-using ::memset;
-using ::strerror;
-using ::strlen;
+_LIBCPP_USING_IF_EXISTS(::memset);
+_LIBCPP_USING_IF_EXISTS(::strerror);
+_LIBCPP_USING_IF_EXISTS(::strlen);
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_CSTRING

libcxx/include/ctime

 #   include <sys/cdefs.h>
 #   if defined(_LIBCPP_HAS_TIMESPEC_GET) && (__DARWIN_C_LEVEL < __DARWIN_C_FULL)
 #       define _LIBCPP_HAS_TIMESPEC_GET_NOT_ACTUALLY_PROVIDED
 #   endif
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-using ::clock_t;
-using ::size_t;
-using ::time_t;
-using ::tm;
+_LIBCPP_USING_IF_EXISTS(::clock_t);
+_LIBCPP_USING_IF_EXISTS(::size_t);
+_LIBCPP_USING_IF_EXISTS(::time_t);
+_LIBCPP_USING_IF_EXISTS(::tm);
 #if _LIBCPP_STD_VER > 14 && defined(_LIBCPP_HAS_TIMESPEC_GET)
-using ::timespec;
+_LIBCPP_USING_IF_EXISTS(::timespec);
 #endif
-using ::clock;
-using ::difftime;
-using ::mktime;
-using ::time;
+_LIBCPP_USING_IF_EXISTS(::clock);
+_LIBCPP_USING_IF_EXISTS(::difftime);
+_LIBCPP_USING_IF_EXISTS(::mktime);
+_LIBCPP_USING_IF_EXISTS(::time);
 #ifndef _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
-using ::asctime;
-using ::ctime;
-using ::gmtime;
-using ::localtime;
+_LIBCPP_USING_IF_EXISTS(::asctime);
+_LIBCPP_USING_IF_EXISTS(::ctime);
+_LIBCPP_USING_IF_EXISTS(::gmtime);
+_LIBCPP_USING_IF_EXISTS(::localtime);
 #endif
-using ::strftime;
+_LIBCPP_USING_IF_EXISTS(::strftime);
 #if _LIBCPP_STD_VER > 14 && defined(_LIBCPP_HAS_TIMESPEC_GET) && !defined(_LIBCPP_HAS_TIMESPEC_GET_NOT_ACTUALLY_PROVIDED)
-using ::timespec_get;
+_LIBCPP_USING_IF_EXISTS(::timespec_get);
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_CTIME

libcxx/include/cwchar

 #include <wchar.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-using ::mbstate_t;
-using ::size_t;
-using ::tm;
-using ::wint_t;
-using ::FILE;
-using ::fwprintf;
-using ::fwscanf;
-using ::swprintf;
-using ::vfwprintf;
-using ::vswprintf;
-using ::swscanf;
-using ::vfwscanf;
-using ::vswscanf;
-using ::fgetwc;
-using ::fgetws;
-using ::fputwc;
-using ::fputws;
-using ::fwide;
-using ::getwc;
-using ::putwc;
-using ::ungetwc;
-using ::wcstod;
-using ::wcstof;
-using ::wcstold;
-using ::wcstol;
+_LIBCPP_USING_IF_EXISTS(::mbstate_t);
+_LIBCPP_USING_IF_EXISTS(::size_t);
+_LIBCPP_USING_IF_EXISTS(::tm);
+_LIBCPP_USING_IF_EXISTS(::wint_t);
+_LIBCPP_USING_IF_EXISTS(::FILE);
+_LIBCPP_USING_IF_EXISTS(::fwprintf);
+_LIBCPP_USING_IF_EXISTS(::fwscanf);
+_LIBCPP_USING_IF_EXISTS(::swprintf);
+_LIBCPP_USING_IF_EXISTS(::vfwprintf);
+_LIBCPP_USING_IF_EXISTS(::vswprintf);
+_LIBCPP_USING_IF_EXISTS(::swscanf);
+_LIBCPP_USING_IF_EXISTS(::vfwscanf);
+_LIBCPP_USING_IF_EXISTS(::vswscanf);
+_LIBCPP_USING_IF_EXISTS(::fgetwc);
+_LIBCPP_USING_IF_EXISTS(::fgetws);
+_LIBCPP_USING_IF_EXISTS(::fputwc);
+_LIBCPP_USING_IF_EXISTS(::fputws);
+_LIBCPP_USING_IF_EXISTS(::fwide);
+_LIBCPP_USING_IF_EXISTS(::getwc);
+_LIBCPP_USING_IF_EXISTS(::putwc);
+_LIBCPP_USING_IF_EXISTS(::ungetwc);
+_LIBCPP_USING_IF_EXISTS(::wcstod);
+_LIBCPP_USING_IF_EXISTS(::wcstof);
+_LIBCPP_USING_IF_EXISTS(::wcstold);
+_LIBCPP_USING_IF_EXISTS(::wcstol);
 #ifndef _LIBCPP_HAS_NO_LONG_LONG
-using ::wcstoll;
+_LIBCPP_USING_IF_EXISTS(::wcstoll);
 #endif // _LIBCPP_HAS_NO_LONG_LONG
-using ::wcstoul;
+_LIBCPP_USING_IF_EXISTS(::wcstoul);
 #ifndef _LIBCPP_HAS_NO_LONG_LONG
-using ::wcstoull;
+_LIBCPP_USING_IF_EXISTS(::wcstoull);
 #endif // _LIBCPP_HAS_NO_LONG_LONG
-using ::wcscpy;
-using ::wcsncpy;
-using ::wcscat;
-using ::wcsncat;
-using ::wcscmp;
-using ::wcscoll;
-using ::wcsncmp;
-using ::wcsxfrm;
-using ::wcschr;
-using ::wcspbrk;
-using ::wcsrchr;
-using ::wcsstr;
-using ::wmemchr;
-using ::wcscspn;
-using ::wcslen;
-using ::wcsspn;
-using ::wcstok;
-using ::wmemcmp;
-using ::wmemcpy;
-using ::wmemmove;
-using ::wmemset;
-using ::wcsftime;
-using ::btowc;
-using ::wctob;
-using ::mbsinit;
-using ::mbrlen;
-using ::mbrtowc;
-using ::wcrtomb;
-using ::mbsrtowcs;
-using ::wcsrtombs;
+_LIBCPP_USING_IF_EXISTS(::wcscpy);
+_LIBCPP_USING_IF_EXISTS(::wcsncpy);
+_LIBCPP_USING_IF_EXISTS(::wcscat);
+_LIBCPP_USING_IF_EXISTS(::wcsncat);
+_LIBCPP_USING_IF_EXISTS(::wcscmp);
+_LIBCPP_USING_IF_EXISTS(::wcscoll);
+_LIBCPP_USING_IF_EXISTS(::wcsncmp);
+_LIBCPP_USING_IF_EXISTS(::wcsxfrm);
+_LIBCPP_USING_IF_EXISTS(::wcschr);
+_LIBCPP_USING_IF_EXISTS(::wcspbrk);
+_LIBCPP_USING_IF_EXISTS(::wcsrchr);
+_LIBCPP_USING_IF_EXISTS(::wcsstr);
+_LIBCPP_USING_IF_EXISTS(::wmemchr);
+_LIBCPP_USING_IF_EXISTS(::wcscspn);
+_LIBCPP_USING_IF_EXISTS(::wcslen);
+_LIBCPP_USING_IF_EXISTS(::wcsspn);
+_LIBCPP_USING_IF_EXISTS(::wcstok);
+_LIBCPP_USING_IF_EXISTS(::wmemcmp);
+_LIBCPP_USING_IF_EXISTS(::wmemcpy);
+_LIBCPP_USING_IF_EXISTS(::wmemmove);
+_LIBCPP_USING_IF_EXISTS(::wmemset);
+_LIBCPP_USING_IF_EXISTS(::wcsftime);
+_LIBCPP_USING_IF_EXISTS(::btowc);
+_LIBCPP_USING_IF_EXISTS(::wctob);
+_LIBCPP_USING_IF_EXISTS(::mbsinit);
+_LIBCPP_USING_IF_EXISTS(::mbrlen);
+_LIBCPP_USING_IF_EXISTS(::mbrtowc);
+_LIBCPP_USING_IF_EXISTS(::wcrtomb);
+_LIBCPP_USING_IF_EXISTS(::mbsrtowcs);
+_LIBCPP_USING_IF_EXISTS(::wcsrtombs);
 
 #ifndef _LIBCPP_HAS_NO_STDIN
-using ::getwchar;
-using ::vwscanf;
-using ::wscanf;
+_LIBCPP_USING_IF_EXISTS(::getwchar);
+_LIBCPP_USING_IF_EXISTS(::vwscanf);
+_LIBCPP_USING_IF_EXISTS(::wscanf);
 #endif
 
 #ifndef _LIBCPP_HAS_NO_STDOUT
-using ::putwchar;
-using ::vwprintf;
-using ::wprintf;
+_LIBCPP_USING_IF_EXISTS(::putwchar);
+_LIBCPP_USING_IF_EXISTS(::vwprintf);
+_LIBCPP_USING_IF_EXISTS(::wprintf);
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_CWCHAR

libcxx/include/cwctype

 #include <wctype.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-using ::wint_t;
-using ::wctrans_t;
-using ::wctype_t;
-using ::iswalnum;
-using ::iswalpha;
-using ::iswblank;
-using ::iswcntrl;
-using ::iswdigit;
-using ::iswgraph;
-using ::iswlower;
-using ::iswprint;
-using ::iswpunct;
-using ::iswspace;
-using ::iswupper;
-using ::iswxdigit;
-using ::iswctype;
-using ::wctype;
-using ::towlower;
-using ::towupper;
-using ::towctrans;
-using ::wctrans;
+_LIBCPP_USING_IF_EXISTS(::wint_t);
+_LIBCPP_USING_IF_EXISTS(::wctrans_t);
+_LIBCPP_USING_IF_EXISTS(::wctype_t);
+_LIBCPP_USING_IF_EXISTS(::iswalnum);
+_LIBCPP_USING_IF_EXISTS(::iswalpha);
+_LIBCPP_USING_IF_EXISTS(::iswblank);
+_LIBCPP_USING_IF_EXISTS(::iswcntrl);
+_LIBCPP_USING_IF_EXISTS(::iswdigit);
+_LIBCPP_USING_IF_EXISTS(::iswgraph);
+_LIBCPP_USING_IF_EXISTS(::iswlower);
+_LIBCPP_USING_IF_EXISTS(::iswprint);
+_LIBCPP_USING_IF_EXISTS(::iswpunct);
+_LIBCPP_USING_IF_EXISTS(::iswspace);
+_LIBCPP_USING_IF_EXISTS(::iswupper);
+_LIBCPP_USING_IF_EXISTS(::iswxdigit);
+_LIBCPP_USING_IF_EXISTS(::iswctype);
+_LIBCPP_USING_IF_EXISTS(::wctype);
+_LIBCPP_USING_IF_EXISTS(::towlower);
+_LIBCPP_USING_IF_EXISTS(::towupper);
+_LIBCPP_USING_IF_EXISTS(::towctrans);
+_LIBCPP_USING_IF_EXISTS(::wctrans);
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_CWCTYPE