Fix Libc++ build with MinGW64

[EricWF]

Summary

This patch corrects the build errors I encountered when building on MinGW64.

[smeenai]

@EricWF and I discussed this on IRC a bit. I'm not a fan of overloading _LIBCPP_WIN32API for this purpose, since to me that macro is meant for guarding Windows API functions, not for CRT functions. Eric suggested adding a new macro _LIBCPP_MSVCRT_LIKE, which I'd be fine with.

[bcraig]

I agree that we need to be precise in our platform detection macros. On Windows, we currently need to worry about which compiler is being used, whether we are targeting the mingw environment or the native (?) environment, and which c-runtime is being used.

For my msvc-kernel work, I'll need some amount of platform detection macros as well (I'm not expecting those to be added in this review). I believe I will represent that with some combination of a "freestanding" macro, a different name for the CRT, and detection of the MSVC compiler, but I haven't gotten that far yet.

[mati865]

I don't know if it is MSYS2 specific or general MinGW issue but liblibc++.a is created. Could you check your build?
Here is line to blame: https://github.com/llvm-mirror/libcxx/blob/master/lib/CMakeLists.txt#L246

[compnerd]

include/__locale

370

Are these really Win32? These are really more libc compatibility things I thought?

include/stdio.h

113

Again, I dont think that this is Win32 API related. This is a libc implementation detail. If I were to build libc++ against musl and Win32, these would be present, right?

include/wchar.h

169

Again not sure that this is Win32 API specific.

src/new.cpp

186

This is definitely msvcrt specific. It is possible for an alternate c library to provide definitions here.

259

Part of the change above.

src/support/win32/locale_win32.cpp

125

Would you mind using:

#if !defined(_LIBCPP_MSVCRT)

instead?

src/system_error.cpp

68

I think that MSVCRT is more appropriate here.

[smeenai]

@compnerd see my previous comment:

@EricWF and I discussed this on IRC a bit. I'm not a fan of overloading _LIBCPP_WIN32API for this purpose, since to me that macro is meant for guarding Windows API functions, not for CRT functions. Eric suggested adding a new macro _LIBCPP_MSVCRT_LIKE, which I'd be fine with.

_LIBCPP_MSVCRT isn't defined for MinGW (since they have their own CRT headers), so we need a new macro that's defined for both MSVCRT and MinGW.

[compnerd]

Sure, a _LIBCPP_MSVCRT_LIKE WFM. I just want to make sure that we don''t conflate the underlying libc implementation with the Win32 API set.

[smeenai]

In D33082#754451, @compnerd wrote:

Sure, a _LIBCPP_MSVCRT_LIKE WFM. I just want to make sure that we don''t conflate the underlying libc implementation with the Win32 API set.

Yup, that was my concern as well.

In D33082#754262, @mati865 wrote:

I don't know if it is MSYS2 specific or general MinGW issue but liblibc++.a is created. Could you check your build?
Here is line to blame: https://github.com/llvm-mirror/libcxx/blob/master/lib/CMakeLists.txt#L246

Sounds like a cmake prefix issue. We should be able to fix this by unconditionally setting CMAKE_STATIC_LIBRARY_PREFIX to lib instead of changing the output name, I think.

[martell]

I want to give some context here to dispel the confusion of what is and isn't win32 api specific.

First lets take vasprintf and asprintf which are not implemented in msvcrt.
In mingw-w64 we would just have posix implementations of both.
They are hidden behind the guard _GNU_SOURCE, we don't need to declare them in include/stdio.h in libcxx but
By default gcc doesn't pass this flag for the mingw target so we should add it in cmake within libc++.
We should be able to guard mingw to stop it from picking up the implementations in windows/support.cpp

Next example mbsnrtowcs and wcsnrtombs above
There is technically a win32api specific implementation in msvc. The mingw-w64 implementation or lack there of would rely on the MSVC implementation.
This is why a custom implementation lives in libc++ in support.cpp that is posix compliant.
Unfortunately a posix implementation might not be accepted upstream into mingw-w64 because they need to maintain compatibility with msvc, even with some bugs eek.
It generally comes down to if a bunch of projects are using it already and we should not disrupt them relying on msvc implementations/bugs.
This is probably not the case for these two functions but there are many others already in the library that follow this guideline.

A good read of this specific bug is here.
http://lists.llvm.org/pipermail/cfe-commits/Week-of-Mon-20130325/077071.html

@smeenai suggestion of _LIBCPP_MSVCRT_LIKE makes a lot of sense here because mingw-w64 is only partially posixy, this leaves room for future possible targets like midipix which uses musl libc to ignore this section of code where mingw and msvc opt in.

[EricWF]

include/__locale

370

So _LIBCPP_MSVCRT_LIKE?

include/stdio.h

113

Changing to _LIBCPP_MSVCRT_LIKE.

include/wchar.h

169

Changed to _LIBCPP_MSVCRT_LIKE.

src/system_error.cpp

68

Changed to MSVCRT_LIKE.

[EricWF]

In D33082#760516, @martell wrote:

I want to give some context here to dispel the confusion of what is and isn't win32 api specific.

First lets take vasprintf and asprintf which are not implemented in msvcrt.
In mingw-w64 we would just have posix implementations of both.
They are hidden behind the guard _GNU_SOURCE, we don't need to declare them in include/stdio.h in libcxx but
By default gcc doesn't pass this flag for the mingw target so we should add it in cmake within libc++.

Defining _GNU_SOURCE during the library build isn't enough, it's also has to be defined when people are using the headers,
and in that case we must depend on the compiler to pre-define it. Is it important that MinGW not define _GNU_SOURCE by default?

Also do you know why asprintf is declared by mingw-w64 but vasprintf isn't? At minimum I think we still need to declare vasprintf in the
headers because we can't count on _GNU_SOURCE being defined before <features.h> is first included, but we should be able to omit
the definition.

Next example mbsnrtowcs and wcsnrtombs above
There is technically a win32api specific implementation in msvc. The mingw-w64 implementation or lack there of would rely on the MSVC implementation.
This is why a custom implementation lives in libc++ in support.cpp that is posix compliant.

Good to know.

Unfortunately a posix implementation might not be accepted upstream into mingw-w64 because they need to maintain compatibility with msvc, even with some bugs eek.

I'm not personally concerned about upstreaming MinGW-w64 changes/fixes. If we can adequately solve it within libc++ without any terrible hacks I'm happy with that for now.

It generally comes down to if a bunch of projects are using it already and we should not disrupt them relying on msvc implementations/bugs.
This is probably not the case for these two functions but there are many others already in the library that follow this guideline.

Are you suggesting that libc++ should stop declaring/defining these functions, at least publically?

A good read of this specific bug is here.
http://lists.llvm.org/pipermail/cfe-commits/Week-of-Mon-20130325/077071.html

@smeenai suggestion of _LIBCPP_MSVCRT_LIKE makes a lot of sense here because mingw-w64 is only partially posixy, this leaves room for future possible targets like midipix which uses musl libc to ignore this section of code where mingw and msvc opt in.

[EricWF]

Add _LIBCPP_MSVCRT_LIKE and use it to replace _LIBCPP_WIN32API where appropriate.

[martell]

! In D33082#764617, @EricWF wrote:
Defining _GNU_SOURCE during the library build isn't enough, it's also has to be defined when people are using the headers,
and in that case we must depend on the compiler to pre-define it. Is it important that MinGW not define _GNU_SOURCE by default?

I'm not sure why this isn't the default, it could be some backwards compatibility with mingw.org.
I will ask kai the author and find out.

Also do you know why asprintf is declared by mingw-w64 but vasprintf isn't? At minimum I think we still need to declare vasprintf in the
headers because we can't count on _GNU_SOURCE being defined before <features.h> is first included, but we should be able to omit
the definition.

I believe it is in stdio.h but behind the guard __USE_MINGW_ANSI_STDIO
You are currently picking up is msvc compatable asprintf and not gnu.
Defining this will give you the gnu versions of both vasprintf, asprintf and also the GNU printf format specifiers.
You should be able use this to build libcxx just don't declare it publicly

Are you suggesting that libc++ should stop declaring/defining these functions, at least publically?

We could in the future run into real world problems with projects that work with libstdc++ fine but will have problems with libc++ if a project implements its own version but I wouldn't be too concerned about this right now because when that becomes a problem it will prompt people to get these into mingw-w64 upstream.

[bcraig]

Are you suggesting that libc++ should stop declaring/defining these functions, at least publically?

I think that we generally shouldn't be giving functions names that are already claimed elsewhere (like mbsnrtowcs and wcsnrtombs). It is my opinion that these should always be qualified as __libcpp_* symbols. We can easily run into trouble if users also defined mbsnrtowcs. They have just as much of a right to do so as we do.

That being said, I think that's a change for a different changelist.

[EricWF]

In D33082#765282, @bcraig wrote:

I think that we generally shouldn't be giving functions names that are already claimed elsewhere (like mbsnrtowcs and wcsnrtombs). It is my opinion that these should always be qualified as __libcpp_* symbols. We can easily run into trouble if users also defined mbsnrtowcs. They have just as much of a right to do so as we do.

That being said, I think that's a change for a different changelist.

Agreed. Libc++ shouldn't be stealing names it doesn't own, but fixing that is a separate change.

In D33082#765185, @martell wrote:

! In D33082#764617, @EricWF wrote:
Defining _GNU_SOURCE during the library build isn't enough, it's also has to be defined when people are using the headers,
and in that case we must depend on the compiler to pre-define it. Is it important that MinGW not define _GNU_SOURCE by default?

I'm not sure why this isn't the default, it could be some backwards compatibility with mingw.org.
I will ask kai the author and find out.

Also do you know why asprintf is declared by mingw-w64 but vasprintf isn't? At minimum I think we still need to declare vasprintf in the
headers because we can't count on _GNU_SOURCE being defined before <features.h> is first included, but we should be able to omit
the definition.

I believe it is in stdio.h but behind the guard __USE_MINGW_ANSI_STDIO
You are currently picking up is msvc compatable asprintf and not gnu.
Defining this will give you the gnu versions of both vasprintf, asprintf and also the GNU printf format specifiers.
You should be able use this to build libcxx just don't declare it publicly

Libc++ uses vasprintf in the headers, so it's not just a matter of building the library with _GNU_SOURCE.
Since we can't dependably define _GNU_SOURCE or __USE_MINGW_ANSI_STDIO in the headers we're
eventually going to have to provide our own implementations under different names. But I would rather do that as a separate commit if that's OK.

[EricWF]

• remove asprintf declaration and definition entirely. It's not used anywhere within libc++.

[martell]

LGTM but I can't speak for the area where you added #include <cstdio> and killed off the _NEWLIB_VERSION check
Seems in order based on https://sourceware.org/ml/newlib-cvs/2014-q3/msg00038.html
Maybe make a note of the minimum newlib version supported somewhere?

Others may have more specific thoughts on the diff.

[EricWF]

In D33082#765644, @martell wrote:

LGTM but I can't speak for the area where you added #include <cstdio> and killed off the _NEWLIB_VERSION check
Seems in order based on https://sourceware.org/ml/newlib-cvs/2014-q3/msg00038.html
Maybe make a note of the minimum newlib version supported somewhere?

I removed the section you're referring to because it's unneeded. <__locale> does the exact same #include dance. and <locale> includes <__locale>.
It should not have an affect on functionality.

[martell]

! In D33082#765898, @EricWF wrote:
I removed the section you're referring to because it's unneeded. <__locale> does the exact same #include dance. and <locale> includes <__locale>.
It should not have an affect on functionality.

In that case just ignore my previous comment. LGTM

[smeenai]

LGTM. Thanks for all the revisions!

include/__config

 # 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__
 
 #if defined(_WIN32)
-#  define _LIBCPP_WIN32API      1
+#  define _LIBCPP_WIN32API
 #  define _LIBCPP_LITTLE_ENDIAN 1
 #  define _LIBCPP_BIG_ENDIAN    0
 #  define _LIBCPP_SHORT_WCHAR   1
+// Both MinGW and native MSVC provide a "MSVC"-like enviroment
+#  define _LIBCPP_MSVCRT_LIKE
 // If mingw not explicitly detected, assume using MS C runtime only.
 #  ifndef __MINGW32__
 #    define _LIBCPP_MSVCRT // Using Microsoft's C Runtime library
 #  endif
 #  if (defined(_M_AMD64) || defined(__x86_64__)) || (defined(_M_ARM) || defined(__arm__))
 #    define _LIBCPP_HAS_BITSCAN64
 #  endif
 # if defined(_LIBCPP_MSVCRT)

include/__locale

 #include <__config>
 #include <string>
 #include <memory>
 #include <utility>
 #include <mutex>
 #include <cstdint>
 #include <cctype>
 #include <locale.h>
-#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
+#if defined(_LIBCPP_MSVCRT_LIKE)
 # include <support/win32/locale_win32.h>
 #elif defined(_AIX)
 # include <support/ibm/xlocale.h>
 #elif defined(__ANDROID__)
 // Android gained the locale aware functions in L (API level 21)
 # include <android/api-level.h>
 # if __ANDROID_API__ <= 20
 #  include <support/android/locale_bionic.h>
#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(_LIBCPP_MSVCRT)
+#elif defined(_LIBCPP_MSVCRT_LIKE)
     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/locale

 #include <streambuf>
 #include <iterator>
 #include <limits>
 #ifndef __APPLE__
 #include <cstdarg>
 #endif
 #include <cstdlib>
 #include <ctime>
-#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
-#include <support/win32/locale_win32.h>
-#elif defined(_NEWLIB_VERSION)
-// FIXME: replace all the uses of _NEWLIB_VERSION with __NEWLIB__ preceded by an
-// include of <sys/cdefs.h> once https://sourceware.org/ml/newlib-cvs/2014-q3/msg00038.html
-// has had a chance to bake for a bit
-#include <support/newlib/xlocale.h>
-#endif
+#include <cstdio>
 #ifdef _LIBCPP_HAS_CATOPEN
 #include <nl_types.h>
 #endif
 
 #ifdef __APPLE__
 #include <Availability.h>
 #endif
 

include/stdio.h

 #pragma GCC system_header
 #endif
 
 #include_next <stdio.h>
 
 #ifdef __cplusplus
 
 // snprintf
-#if defined(_LIBCPP_MSVCRT)
+#if defined(_LIBCPP_MSVCRT_LIKE)
 extern "C" {
 int vasprintf(char **sptr, const char *__restrict fmt, va_list ap);
-int asprintf(char **sptr, const char *__restrict fmt, ...);
 }
 #endif
 
 #undef getc
 #undef putc
 #undef clearerr
 #undef feof
 #undef ferror
 
 #endif
 
 #endif  // _LIBCPP_STDIO_H

include/support/win32/locale_win32.h

 size_t mbrtowc_l( wchar_t *__restrict pwc, const char *__restrict s,
                   size_t n, mbstate_t *__restrict ps, locale_t loc);
 size_t mbsnrtowcs_l( wchar_t *__restrict dst, const char **__restrict src,
                      size_t nms, size_t len, mbstate_t *__restrict ps, locale_t loc);
 size_t wcsnrtombs_l( char *__restrict dst, const wchar_t **__restrict src,
                      size_t nwc, size_t len, mbstate_t *__restrict ps, locale_t loc);
 wint_t btowc_l( int c, locale_t loc );
 int wctob_l( wint_t c, locale_t loc );
-inline _LIBCPP_ALWAYS_INLINE
-decltype(MB_CUR_MAX) MB_CUR_MAX_L( locale_t __l )
-{
-  return ___mb_cur_max_l_func(__l);
-}
+
+decltype(MB_CUR_MAX) MB_CUR_MAX_L( locale_t __l );
 
 // the *_l functions are prefixed on Windows, only available for msvcr80+, VS2005+
 #define mbtowc_l _mbtowc_l
 #define strtoll_l _strtoi64_l
 #define strtoull_l _strtoui64_l
-#define strtof_l _strtof_l
 #define strtod_l _strtod_l
+#if defined(_LIBCPP_MSVCRT)
+#define strtof_l _strtof_l
 #define strtold_l _strtold_l
-
+#else
+float strtof_l(const char*, char**, locale_t);
+long double strtold_l(const char*, char**, locale_t);
+#endif
 inline _LIBCPP_INLINE_VISIBILITY
 int
 islower_l(int c, _locale_t loc)
 {
  return _islower_l((int)c, loc);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY

include/wchar.h

 wchar_t* __libcpp_wmemchr(const wchar_t* __s, wchar_t __c, size_t __n) {return (wchar_t*)wmemchr(__s, __c, __n);}
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
 const wchar_t* wmemchr(const wchar_t* __s, wchar_t __c, size_t __n) {return __libcpp_wmemchr(__s, __c, __n);}
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
       wchar_t* wmemchr(      wchar_t* __s, wchar_t __c, size_t __n) {return __libcpp_wmemchr(__s, __c, __n);}
 }
 #endif
 
-#if defined(__cplusplus) && defined(_LIBCPP_MSVCRT)
+#if defined(__cplusplus) && defined(_LIBCPP_MSVCRT_LIKE)
 extern "C" {
 size_t mbsnrtowcs(wchar_t *__restrict dst, const char **__restrict src,
                   size_t nmc, size_t len, mbstate_t *__restrict ps);
 size_t wcsnrtombs(char *__restrict dst, const wchar_t **__restrict src,
                   size_t nwc, size_t len, mbstate_t *__restrict ps);
 }  // extern "C++"
 #endif  // __cplusplus && _LIBCPP_MSVCRT
 
 #endif  // _LIBCPP_WCHAR_H

src/chrono.cpp

 #endif // __ENVIRONMENT_.*_VERSION_MIN_REQUIRED__
 #else
 #define _LIBCXX_USE_CLOCK_GETTIME
 #endif // __APPLE__
 
 #if defined(_LIBCPP_WIN32API)
 #define WIN32_LEAN_AND_MEAN
 #define VC_EXTRA_LEAN
-#include <Windows.h>
+#include <windows.h>
 #if _WIN32_WINNT >= _WIN32_WINNT_WIN8
 #include <winapifamily.h>
 #endif
 #else
 #if !defined(CLOCK_REALTIME) || !defined(_LIBCXX_USE_CLOCK_GETTIME)
 #include <sys/time.h>        // for gettimeofday and timeval
 #endif // !defined(CLOCK_REALTIME)
 #endif // defined(_LIBCPP_WIN32API)

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(_LIBCPP_MSVCRT)
+#if defined(_LIBCPP_MSVCRT_LIKE)
     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();
#endif  // _LIBCPP_NO_EXCEPTIONS
     return p;
 }
 
 _LIBCPP_WEAK
 void
 operator delete(void* ptr, std::align_val_t) _NOEXCEPT
 {
     if (ptr)
-#if defined(_LIBCPP_MSVCRT)
+#if defined(_LIBCPP_MSVCRT_LIKE)
         ::_aligned_free(ptr);
 #else
         ::free(ptr);
 #endif
 }
 
 _LIBCPP_WEAK
 void

src/support/win32/locale_win32.cpp

locale_t uselocale( locale_t newloc )
     // uselocale sets the thread's locale by definition, so unconditionally use thread-local locale
     _configthreadlocale( _ENABLE_PER_THREAD_LOCALE );
     // uselocale sets all categories
     // disable setting locale on Windows temporarily because the structure is opaque (PR31516)
     //setlocale( LC_ALL, newloc->locinfo->lc_category[LC_ALL].locale );
     // uselocale returns the old locale_t
     return old_locale;
 }
+
+decltype(MB_CUR_MAX) MB_CUR_MAX_L( locale_t __l )
+{
+#if defined(_LIBCPP_MSVCRT)
+  return ___mb_cur_max_l_func(__l);
+#else
+  __libcpp_locale_guard __current(__l);
+  return MB_CUR_MAX;
+#endif
+}
+
+
 lconv *localeconv_l( locale_t loc )
 {
     __libcpp_locale_guard __current(loc);
     return localeconv();
 }
 size_t mbrlen_l( const char *__restrict s, size_t n,
                  mbstate_t *__restrict ps, locale_t loc )
 {
int asprintf_l( char **ret, locale_t loc, const char *format, ... )
     va_end(ap);
     return result;
 }
 int vasprintf_l( char **ret, locale_t loc, const char *format, va_list ap )
 {
     __libcpp_locale_guard __current(loc);
     return vasprintf( ret, format, ap );
 }
+
+#if !defined(_LIBCPP_MSVCRT)
+float strtof_l(const char* nptr, char** endptr, locale_t loc) {
+  __libcpp_locale_guard __current(loc);
+  return strtof(nptr, endptr);
+}
+
+long double strtold_l(const char* nptr, char** endptr, locale_t loc) {
+  __libcpp_locale_guard __current(loc);
+  return strtold(nptr, endptr);
+}
+#endif

src/support/win32/support.cpp

 
 #include <cstdarg> // va_start, va_end
 #include <cstddef> // size_t
 #include <cstdlib> // malloc
 #include <cstdio>  // vsprintf, vsnprintf
 #include <cstring> // strcpy, wcsncpy
 #include <cwchar>  // mbstate_t
 
-// Some of these functions aren't standard or if they conform, the name does not.
-
-int asprintf(char **sptr, const char *__restrict format, ...)
-{
-    va_list ap;
-    va_start(ap, format);
-    int result;
-    result = vasprintf(sptr, format, ap);
-    va_end(ap);
-    return result;
-}
 
 // Like sprintf, but when return value >= 0 it returns
 // a pointer to a malloc'd string in *sptr.
 // If return >= 0, use free to delete *sptr.
 int vasprintf( char **sptr, const char *__restrict format, va_list ap )
 {
     *sptr = NULL;
     // Query the count required.

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(_LIBCPP_MSVCRT)
+#if defined(_LIBCPP_MSVCRT_LIKE)
 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

 #endif // defined(__unix__) || (defined(__APPLE__) && defined(__MACH__)) || defined(__CloudABI__) || defined(__Fuchsia__)
 
 #if defined(__NetBSD__)
 #pragma weak pthread_create // Do not create libpthread dependency
 #endif
 
 #if defined(_LIBCPP_WIN32API)
 #include <windows.h>
-#endif // defined(_LIBCPP_WIN32API)
+#endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 thread::~thread()
 {
     if (!__libcpp_thread_isnull(&__t_))
         terminate();
 }