clean up use of _WIN32

[compnerd]

Summary

Replace the use of _WIN32 in libc++. Replace most use with a C runtime check _LIBCPP_MSVCRT or the new _LIBCPP_WIN32 to indicate that we are using the Win32 API. Use a new _LIBCPP_WCHAR_IS_UCS2 to indicate that we are on an environment that has a short wchar_t.

[smeenai]

Sweet.

include/__config

158

Perhaps _LIBCPP_WIN32API instead, to be clear that this is specific to the usage of Win32 APIs, rather than just a general catch-all libc++ on Windows macro?

798

Windows has catopen?

include/type_traits

1684

Might be cleaner to have a _LIBCPP_COFF macro (both here and for the similar __config change), to make the intent clearer?

[kimgr]

I don't think wchar_t is UCS-2 anymore, I read somewhere that they switched to UTF-16 as of Windows 2000.

Is it the actual encoding you're interested in, or the element size? Judging from the diff, it looks like both, but the code appears to assume UCS-2, so it could already be broken.

Maybe you could phrase it as _LIBCPP_16BIT_WCHAR or _LIBCPP_SHORT_WCHAR instead?

[EricWF]

include/__config

158

+1 for that name, since it is self documenting.

798

This is nested in a block that already excludes windows.

include/type_traits

1684

+1 for _LIBCPP_COFF or similar. I would rather explicitly exclude coff than include a list of supported formats.

src/thread.cpp

27

I wonder if the drivers on solaris define __unix__.

[compnerd]

include/__config

158

Yeah, I like WIN32API better too. Ill change that.

798

What @EricWF said :-).

include/type_traits

1684

WFM, Ill introduce a _LIBCPP_ELF, _LIBCPP_MACHO, and _LIBCPP_COFF.

[compnerd]

I figured that using the explicit encoding is nicer since it means that its more documenting. I dont have a problem with _LIBCPP_SHORT_WCHAR as that maps quite well to -fshort-wchar.

[compnerd]

Update for _LIBCPP_WIN32API and addition of _LIBCPP_OBJECT_FORMAT_COFF, _LIBCPP_OBJECT_FORMAT_ELF, _LIBCPP_OBJECT_FORMAT_MACHO

[smeenai]

In D28223#634199, @compnerd wrote:

I figured that using the explicit encoding is nicer since it means that its more documenting.

I think @kimgr's point was that if you're using an explicit encoding, it should be UTF-16 rather than UCS-2 :)

[kimgr]

@smeenai I think I tried to make a jumbled mess of points :-)

1. Associating an encoding with a char/element type seems wrong; any number of encodings can use wchar_t.
2. Windows allegedly uses UTF-16 now, not UCS-2
3. There might be a bug in locale.cpp if it actually does UCS-2 -> UTF-8 conversion and Windows no longer uses UCS-2 (though I think they overlap for a lot of code-points)

@compnerd _LIBCPP_SHORT_WCHAR sounds good to me, especially in light of the front-end flag (didn't know that existed.)

[compnerd]

Switch to _LIBCPP_SHORT_WCHAR.

[kimgr]

Another belated thought: it all depends on the intended meaning of the symbol:

• Does it say anything about the element size (i.e. sizeof(wchar_t)?
• Does it specify the native encoding of wide-char strings for a platform (i.e. UTF-16 on Windows)?

It looks like the same symbol is now used for both things, which may not be a good idea.

[compnerd]

I think that it will suffice for now. We can change the flag to be more granular in the future. I think that this is going well beyond the original intent of cleaning up the usage of the _WIN32 macros at this point.

[kimgr]

I agree. Since the current set of encodings all have different element sizes and this is not likely to change, this looks good.

[smeenai]

include/support/win32/support.h

113

Windows wouldn't have __LP64__ defined (since it's LLP64 anyway). According to MSDN _BitScanForward64 is available on x64 and ARM, so the conditional should reflect that (i.e. the existing conditional was incorrect, but since you're changing it you may as well fix it).

153

Same __LP64__ comment here.

[mclow.lists]

I like this. A lot.

I'm a bit concerned about @smeenai 's comments about __LP64_, and @EricWF 's comment about solaris.

This patch accomplishes (or maybe just moves closer, I need to check) to a goal of mine, which is to have no references to _WIN32 in any header files other that <__config> (and maybe in support/)

[compnerd]

fix __LP64__ usage as pointed out by @smeenai

[mclow.lists]

LGTM. My comment is a suggestion, not a requirement.

include/support/win32/support.h

112

I would be tempted to add another macro here. Something like:

#if (defined(_M_ARM) || defined(__arm__)) ||                 \
      (defined(_M_AMD64) || defined(__x86_64__))
#define _LIBCPP_WIN_HAS_BITSCAN
#endif

to avoid repeating the "four-armed combo"

[compnerd]

SVN r290910. I like your idea for an additional BITSCAN macro. I think that Id rather do that in a follow up.

include/__config

 #   define _LIBCPP_BIG_ENDIAN    0
 # else  // _BYTE_ORDER == _LITTLE_ENDIAN
 #   define _LIBCPP_LITTLE_ENDIAN 0
 #   define _LIBCPP_BIG_ENDIAN    1
 # endif  // _BYTE_ORDER == _LITTLE_ENDIAN
 # define _LIBCPP_HAS_QUICK_EXIT
 #endif  // __NetBSD__
 
-#ifdef _WIN32
+#if defined(_WIN32)
+#  define _LIBCPP_WIN32API      1
 #  define _LIBCPP_LITTLE_ENDIAN 1
 #  define _LIBCPP_BIG_ENDIAN    0
+#  define _LIBCPP_SHORT_WCHAR   1
 // Compiler intrinsics (MSVC)
-#if defined(_MSC_VER) && _MSC_VER >= 1400
+#  if defined(_MSC_VER) && _MSC_VER >= 1400
 #    define _LIBCPP_HAS_IS_BASE_OF
 #  endif
 #  if defined(_MSC_VER) && !defined(__clang__)
 #    define _LIBCPP_MSVC // Using Microsoft Visual C++ compiler
 #    define _LIBCPP_TOSTRING2(x) #x
 #    define _LIBCPP_TOSTRING(x) _LIBCPP_TOSTRING2(x)
 #    define _LIBCPP_WARNING(x) __pragma(message(__FILE__ "(" _LIBCPP_TOSTRING(__LINE__) ") : warning note: " x))
 #  endif
-#  // If mingw not explicitly detected, assume using MS C runtime only.
+// If mingw not explicitly detected, assume using MS C runtime only.
 #  ifndef __MINGW32__
 #    define _LIBCPP_MSVCRT // Using Microsoft's C Runtime library
 #  endif
-#endif  // _WIN32
+#endif // defined(_WIN32)
 
 #ifdef __sun__
 # include <sys/isa_defs.h>
 # ifdef _LITTLE_ENDIAN
 #   define _LIBCPP_LITTLE_ENDIAN 1
 #   define _LIBCPP_BIG_ENDIAN    0
 # else
 #   define _LIBCPP_LITTLE_ENDIAN 0
 #   define _LIBCPP_BIG_ENDIAN    1
 # endif
 #endif // __sun__
 
 #if defined(__CloudABI__)
   // Certain architectures provide arc4random(). Prefer using
   // arc4random() over /dev/{u,}random to make it possible to obtain
   // random data even when using sandboxing mechanisms such as chroots,
   // Capsicum, etc.
 # define _LIBCPP_USING_ARC4_RANDOM
 #elif defined(__native_client__)
   // NaCl's sandbox (which PNaCl also runs in) doesn't allow filesystem access,
   // including accesses to the special files under /dev. C++11's
   // std::random_device is instead exposed through a NaCl syscall.
 # define _LIBCPP_USING_NACL_RANDOM
-#elif defined(_WIN32)
+#elif defined(_LIBCPP_WIN32API)
 # define _LIBCPP_USING_WIN32_RANDOM
 #else
 # define _LIBCPP_USING_DEV_RANDOM
 #endif
 
 #if !defined(_LIBCPP_LITTLE_ENDIAN) || !defined(_LIBCPP_BIG_ENDIAN)
 # include <endian.h>
 # if __BYTE_ORDER == __LITTLE_ENDIAN
namespace std {
   inline namespace _LIBCPP_NAMESPACE {
   }
 }
 
 #define _LIBCPP_HAS_NO_ASAN
 
 #endif // __clang__ || __GNUC__ || _MSC_VER || __IBMCPP__
 
+#if defined(__ELF__)
+#define _LIBCPP_OBJECT_FORMAT_ELF   1
+#elif defined(__MACH__)
+#define _LIBCPP_OBJECT_FORMAT_MACHO 1
+#else
+#define _LIBCPP_OBJECT_FORMAT_COFF  1
+#endif
 
-#ifdef _WIN32
+#if defined(_LIBCPP_OBJECT_FORMAT_COFF)
 #if defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
 # define _LIBCPP_DLL_VIS
 # define _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS
 # define _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS
 # define _LIBCPP_OVERRIDABLE_FUNC_VIS
 #elif defined(_LIBCPP_BUILDING_LIBRARY)
 # define _LIBCPP_DLL_VIS __declspec(dllexport)
 # define _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS
 # define _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS _LIBCPP_DLL_VIS
 # define _LIBCPP_OVERRIDABLE_FUNC_VIS _LIBCPP_DLL_VIS
 #else
 # define _LIBCPP_DLL_VIS __declspec(dllimport)
 # define _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS _LIBCPP_DLL_VIS
 # define _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS
 # define _LIBCPP_OVERRIDABLE_FUNC_VIS
 #endif
 
 #define _LIBCPP_TYPE_VIS            _LIBCPP_DLL_VIS
 #define _LIBCPP_FUNC_VIS            _LIBCPP_DLL_VIS
 #define _LIBCPP_EXCEPTION_ABI       _LIBCPP_DLL_VIS
 #define _LIBCPP_HIDDEN
 #define _LIBCPP_TYPE_VIS_ONLY
 #define _LIBCPP_FUNC_VIS_ONLY
 #define _LIBCPP_ENUM_VIS
+
 #if defined(_LIBCPP_MSVC)
 # define _LIBCPP_INLINE_VISIBILITY __forceinline
 # define _LIBCPP_ALWAYS_INLINE     __forceinline
 # define _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY __forceinline
 #else
 # define _LIBCPP_INLINE_VISIBILITY __attribute__ ((__always_inline__))
 # define _LIBCPP_ALWAYS_INLINE     __attribute__ ((__always_inline__))
 # define _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY __attribute__ ((__always_inline__))
 #endif
-#endif // _WIN32
+#endif // defined(_LIBCPP_OBJECT_FORMAT_COFF)
 
 #ifndef _LIBCPP_HIDDEN
 #if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
 #define _LIBCPP_HIDDEN __attribute__ ((__visibility__("hidden")))
 #else
 #define _LIBCPP_HIDDEN
 #endif
 #endif

 #ifndef _LIBCPP_EXTERN_TEMPLATE2
 #define _LIBCPP_EXTERN_TEMPLATE2(...) extern template __VA_ARGS__;
 #endif
 
 #if defined(__APPLE__) && defined(__LP64__) && !defined(__x86_64__)
 #define _LIBCPP_NONUNIQUE_RTTI_BIT (1ULL << 63)
 #endif
 
-#if defined(__APPLE__) || defined(__FreeBSD__) || defined(_WIN32) || \
+#if defined(__APPLE__) || defined(__FreeBSD__) || defined(_LIBCPP_MSVCRT) ||   \
     defined(__sun__) || defined(__NetBSD__) || defined(__CloudABI__)
 #define _LIBCPP_LOCALE__L_EXTENSIONS 1
 #endif
 
 #if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
 // Most unix variants have catopen.  These are the specific ones that don't.
-#if !defined(_WIN32) && !defined(__BIONIC__) && !defined(_NEWLIB_VERSION)
+#if !defined(__BIONIC__) && !defined(_NEWLIB_VERSION)
 #define _LIBCPP_HAS_CATOPEN 1
 #endif
 #endif
 
 #ifdef __FreeBSD__
 #define _DECLARE_C99_LDBL_MATH 1
 #endif
 

 #define _LIBCPP_SAFE_STATIC
 #endif
 
 #if !__has_builtin(__builtin_addressof) && _GNUC_VER < 700
 #define _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS)
-#if defined(_WIN32) || defined(_NEWLIB_VERSION)
+#if defined(_LIBCPP_MSVCRT) || defined(_NEWLIB_VERSION)
 #define _LIBCPP_HAS_NO_OFF_T_FUNCTIONS
 #endif
 #endif
 
 #endif // __cplusplus
 
 #endif // _LIBCPP_CONFIG

include/__locale

#if defined(__GLIBC__)
     static const mask cntrl  = _IScntrl;
     static const mask upper  = _ISupper;
     static const mask lower  = _ISlower;
     static const mask alpha  = _ISalpha;
     static const mask digit  = _ISdigit;
     static const mask punct  = _ISpunct;
     static const mask xdigit = _ISxdigit;
     static const mask blank  = _ISblank;
-#elif defined(_WIN32)
+#elif defined(_LIBCPP_MSVCRT)
     typedef unsigned short mask;
     static const mask space  = _SPACE;
     static const mask print  = _BLANK|_PUNCT|_ALPHA|_DIGIT;
     static const mask cntrl  = _CONTROL;
     static const mask upper  = _UPPER;
     static const mask lower  = _LOWER;
     static const mask alpha  = _ALPHA;
     static const mask digit  = _DIGIT;

include/support/win32/support.h

 }
 
 // Returns the number of trailing 0-bits in x, starting at the least significant
 // bit position. If x is 0, the result is undefined.
 _LIBCPP_ALWAYS_INLINE int __builtin_ctzll(unsigned long long mask)
 {
   unsigned long where;
 // Search from LSB to MSB for first set bit.
 // Returns zero if no set bit is found.
-#if defined(_WIN64)
+#if defined(__LP64__)
   if (_BitScanForward64(&where, mask))
     return static_cast<int>(where);
-#elif defined(_WIN32)
+#else
   // Win32 doesn't have _BitScanForward64 so emulate it with two 32 bit calls.
   // Scan the Low Word.
   if (_BitScanForward(&where, static_cast<unsigned long>(mask)))
     return static_cast<int>(where);
   // Scan the High Word.
   if (_BitScanForward(&where, static_cast<unsigned long>(mask >> 32)))
     return static_cast<int>(where + 32); // Create a bit offset from the LSB.
-#else
-#error "Implementation of __builtin_ctzll required"
 #endif
   return 64;
 }
 
 _LIBCPP_ALWAYS_INLINE int __builtin_ctzl(unsigned long mask)
 {
   unsigned long where;
   // Search from LSB to MSB for first set bit.

 
 // Returns the number of leading 0-bits in x, starting at the most significant
 // bit position. If x is 0, the result is undefined.
 _LIBCPP_ALWAYS_INLINE int __builtin_clzll(unsigned long long mask)
 {
   unsigned long where;
 // BitScanReverse scans from MSB to LSB for first set bit.
 // Returns 0 if no set bit is found.
-#if defined(_WIN64)
+#if defined(__LP64__)
   if (_BitScanReverse64(&where, mask))
     return static_cast<int>(63 - where);
-#elif defined(_WIN32)
+#else
   // Scan the high 32 bits.
   if (_BitScanReverse(&where, static_cast<unsigned long>(mask >> 32)))
     return static_cast<int>(63 -
                             (where + 32)); // Create a bit offset from the MSB.
   // Scan the low 32 bits.
   if (_BitScanReverse(&where, static_cast<unsigned long>(mask)))
     return static_cast<int>(63 - where);
-#else
-#error "Implementation of __builtin_clzll required"
 #endif
   return 64; // Undefined Behavior.
 }
 
 _LIBCPP_ALWAYS_INLINE int __builtin_clzl(unsigned long mask)
 {
   unsigned long where;
   // Search from LSB to MSB for first set bit.

include/type_traits

 _CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x80);
 _CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x100);
 _CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x200);
 _CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x400);
 _CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x800);
 _CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x1000);
 _CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x2000);
 // PE/COFF does not support alignment beyond 8192 (=0x2000)
-#if !defined(_WIN32)
+#if !defined(_LIBCPP_OBJECT_FORMAT_COFF)
 _CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x4000);
-#endif // !_WIN32
+#endif // !defined(_LIBCPP_OBJECT_FORMAT_COFF)
 
 #undef _CREATE_ALIGNED_STORAGE_SPECIALIZATION
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
 // aligned_union
 
 template <size_t _I0, size_t ..._In>

src/chrono.cpp

 //===------------------------- chrono.cpp ---------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "chrono"
 #include "cerrno"        // errno
 #include "system_error"  // __throw_system_error
 #include <time.h>        // clock_gettime, CLOCK_MONOTONIC and CLOCK_REALTIME
 
-#if defined(_WIN32)
+#if defined(_LIBCPP_WIN32API)
 #define WIN32_LEAN_AND_MEAN
 #define VC_EXTRA_LEAN
 #include <Windows.h>
 #if _WIN32_WINNT >= _WIN32_WINNT_WIN8
 #include <winapifamily.h>
 #endif
 #else
 #if !defined(CLOCK_REALTIME)
 #include <sys/time.h>        // for gettimeofday and timeval
-#endif
-#endif
+#endif // !defined(CLOCK_REALTIME)
+#endif // defined(_LIBCPP_WIN32API)
 
 #if !defined(_LIBCPP_HAS_NO_MONOTONIC_CLOCK)
 #if __APPLE__
 #include <mach/mach_time.h>  // mach_absolute_time, mach_timebase_info_data_t
-#elif !defined(_WIN32) && !defined(CLOCK_MONOTONIC)
+#elif !defined(_LIBCPP_WIN32API) && !defined(CLOCK_MONOTONIC)
 #error "Monotonic clock not implemented"
 #endif
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace chrono
 {
 
 // system_clock
 
 const bool system_clock::is_steady;
 
 system_clock::time_point
 system_clock::now() _NOEXCEPT
 {
-#if defined(_WIN32)
+#if defined(_LIBCPP_WIN32API)
   // FILETIME is in 100ns units
   using filetime_duration =
       _VSTD::chrono::duration<__int64,
                               _VSTD::ratio_multiply<_VSTD::ratio<100, 1>,
                                                     nanoseconds::period>>;
 
   // The Windows epoch is Jan 1 1601, the Unix epoch Jan 1 1970.
   static _LIBCPP_CONSTEXPR const seconds nt_to_unix_epoch{11644473600};

 
 steady_clock::time_point
 steady_clock::now() _NOEXCEPT
 {
     static FP fp = init_steady_clock();
     return time_point(duration(fp()));
 }
 
-#elif defined(_WIN32)
+#elif defined(_LIBCPP_WIN32API)
 
 steady_clock::time_point
 steady_clock::now() _NOEXCEPT
 {
   static LARGE_INTEGER freq;
   static BOOL initialized = FALSE;
   if (!initialized)
     initialized = QueryPerformanceFrequency(&freq); // always succceeds

src/include/config_elast.h

 //===----------------------- config_elast.h -------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP_CONFIG_ELAST
 #define _LIBCPP_CONFIG_ELAST
 
-#if defined(_WIN32)
+#if defined(_LIBCPP_MSCVRT)
 #include <stdlib.h>
 #else
 #include <errno.h>
 #endif
 
 #if defined(ELAST)
 #define _LIBCPP_ELAST ELAST
 #elif defined(_NEWLIB_VERSION)
 #define _LIBCPP_ELAST __ELASTERROR
 #elif defined(__Fuchsia__)
 // No _LIBCPP_ELAST needed on Fuchsia
 #elif defined(__linux__)
 #define _LIBCPP_ELAST 4095
 #elif defined(__APPLE__)
 // No _LIBCPP_ELAST needed on Apple
 #elif defined(__sun__)
 #define _LIBCPP_ELAST ESTALE
-#elif defined(_WIN32)
+#elif defined(_LIBCPP_MSCVRT)
 #define _LIBCPP_ELAST _sys_nerr
 #else
 // Warn here so that the person doing the libcxx port has an easier time:
 #warning ELAST for this platform not yet implemented
 #endif
 
 #endif // _LIBCPP_CONFIG_ELAST

src/locale.cpp

 
 // __codecvt_utf8<wchar_t>
 
 __codecvt_utf8<wchar_t>::result
 __codecvt_utf8<wchar_t>::do_out(state_type&,
     const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
     extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
 {
-#if _WIN32
+#if defined(_LIBCPP_SHORT_WCHAR)
     const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
     const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
     const uint16_t* _frm_nxt = _frm;
 #else
     const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
     const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
     const uint32_t* _frm_nxt = _frm;
 #endif
     uint8_t* _to = reinterpret_cast<uint8_t*>(to);
     uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
     uint8_t* _to_nxt = _to;
-#if _WIN32
+#if defined(_LIBCPP_SHORT_WCHAR)
     result r = ucs2_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
                             _Maxcode_, _Mode_);
 #else
     result r = ucs4_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
                             _Maxcode_, _Mode_);
 #endif
     frm_nxt = frm + (_frm_nxt - _frm);
     to_nxt = to + (_to_nxt - _to);
     return r;
 }
 
 __codecvt_utf8<wchar_t>::result
 __codecvt_utf8<wchar_t>::do_in(state_type&,
     const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
     intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
 {
     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
     const uint8_t* _frm_nxt = _frm;
-#if _WIN32
+#if defined(_LIBCPP_SHORT_WCHAR)
     uint16_t* _to = reinterpret_cast<uint16_t*>(to);
     uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
     uint16_t* _to_nxt = _to;
     result r = utf8_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
                             _Maxcode_, _Mode_);
 #else
     uint32_t* _to = reinterpret_cast<uint32_t*>(to);
     uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);

src/new.cpp

 void *
 operator new(std::size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC
 {
     if (size == 0)
         size = 1;
     if (static_cast<size_t>(alignment) < sizeof(void*))
       alignment = std::align_val_t(sizeof(void*));
     void* p;
-#if defined(_WIN32)
+#if defined(_LIBCPP_MSVCRT)
     while ((p = _aligned_malloc(size, static_cast<size_t>(alignment))) == nullptr)
 #else
     while (::posix_memalign(&p, static_cast<size_t>(alignment), size) != 0)
 #endif
     {
         // If posix_memalign fails and there is a new_handler,
         // call it to try free up memory.
         std::new_handler nh = std::get_new_handler();

src/system_error.cpp

 #if !defined(_LIBCPP_HAS_NO_THREADS)
 namespace {
 
 //  GLIBC also uses 1024 as the maximum buffer size internally.
 constexpr size_t strerror_buff_size = 1024;
 
 string do_strerror_r(int ev);
 
-#if defined(_WIN32)
+#if defined(_LIBCPP_MSVCRT)
 string do_strerror_r(int ev) {
   char buffer[strerror_buff_size];
   if (::strerror_s(buffer, strerror_buff_size, ev) == 0)
     return string(buffer);
   std::snprintf(buffer, strerror_buff_size, "unknown error %d", ev);
   return string(buffer);
 }
 #elif defined(__linux__) && !defined(_LIBCPP_HAS_MUSL_LIBC) &&                 \

src/thread.cpp

 
 #if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
 # include <sys/param.h>
 # if defined(BSD)
 #   include <sys/sysctl.h>
 # endif // defined(BSD)
 #endif // defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
 
-#if !defined(_WIN32)
+#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
 # include <unistd.h>
-#endif // !_WIN32
+#endif // defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
 
 #if defined(__NetBSD__)
 #pragma weak pthread_create // Do not create libpthread dependency
 #endif
-#if defined(_WIN32)
+
+#if defined(_LIBCPP_WIN32API)
 #include <windows.h>
-#endif
+#endif // defined(_LIBCPP_WIN32API)
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 thread::~thread()
 {
     if (__t_ != 0)
         terminate();
 }
#elif defined(_SC_NPROCESSORS_ONLN)
     long result = sysconf(_SC_NPROCESSORS_ONLN);
     // sysconf returns -1 if the name is invalid, the option does not exist or
     // does not have a definite limit.
     // if sysconf returns some other negative number, we have no idea
     // what is going on. Default to something safe.
     if (result < 0)
         return 0;
     return static_cast<unsigned>(result);
-#elif defined(_WIN32)
+#elif defined(_LIBCPP_WIN32API)
     SYSTEM_INFO info;
     GetSystemInfo(&info);
     return info.dwNumberOfProcessors;
 #else  // defined(CTL_HW) && defined(HW_NCPU)
     // TODO: grovel through /proc or check cpuid on x86 and similar
     // instructions on other architectures.
 #   if defined(_MSC_VER) && ! defined(__clang__)
         _LIBCPP_WARNING("hardware_concurrency not yet implemented")