[libcxx] Provide #include_next alternative for MSVC

[bcraig]

Summary

Visual Studio 2015 and 2017 don't implement include_next, so we'll use a combination of a computed include and CMAKE inputs to make it work. Also, retrofit all the existing invocations of #include_next that we could hit in a hypothetical MSVC build.

This relies on implementation defined behavior in the MSVC preprocessor.
See C11, 6.10.2.4 ("Source file inclusion") for the statement on implementation defined vs. undefined.

[halyavin]

Here is how we solved this problem in our libc++ fork:

#define _LIBCPP_UCRT_INCLUDE(x) <../ucrt/x>
#define _LIBCPP_MSVC_INCLUDE(x) <../../VC/include/x>

#ifdef _LIBCPP_COMPILER_MSVC
#include _LIBCPP_UCRT_INCLUDE(wchar.h)
#else
#include_next <wchar.h>
#endif

As far as I understand neither solution resolves the problem with original paths not excluded. Watch out for cycling dependencies created by MSVC includes using other includes which point right back to libc++ instead.

Also, there is a problem with errno macro. I solved it like this:

#ifdef _LIBCPP_COMPILER_MSVC
// errno is defined in several files so we can't use #ifndef errno here
#ifdef errno
// undefine errno to avoid substitution in errno.h include file name.
#pragma push_macro("errno")
#undef errno
#include _LIBCPP_UCRT_INCLUDE(errno.h)
#pragma pop_macro("errno")
#else
#include _LIBCPP_UCRT_INCLUDE(errno.h)
#endif
#else
#include_next <errno.h>
#endif

[halyavin]

BTW, the list of include files which are located in [PROGRAM_FILES]\Microsoft Visual Studio 14.0\VC\include directory is

• stdbool.h
• limits.h
• stdint.h
• setjmp.h

The rest is in [PROGRAM_FILES]\Windows Kits\10\Include\10.0.whatever.0\ucrt directory. Which directory @_LIBCPP_INCLUDE_NEXT@ is supposed to point to?

[bcraig]

In D32411#735128, @halyavin wrote:

BTW, the list of include files which are located in [PROGRAM_FILES]\Microsoft Visual Studio 14.0\VC\include directory is

• stdbool.h
• limits.h
• stdint.h
• setjmp.h

The rest is in [PROGRAM_FILES]\Windows Kits\10\Include\10.0.whatever.0\ucrt directory. Which directory @_LIBCPP_INCLUDE_NEXT@ is supposed to point to?

My immediate goal is getting a sort-of freestanding implementation of libc++ to work in the Windows kernel. That means that I have _LIBCPP_INCLUDE_NEXT defined as ../../km/crt.

I'll have to stew on what I want the solution to this to be. I don't feel bad at all switching between one compiler extension (#include_next) and another (computed includes). I would feel a little bad cooking in more knowledge of the MSVC directory layout though. Maybe that's just the cost to pay though. There is some pretty deep knowledge of glibc headers in libc++, so it wouldn't be terribly unusual to have similar knowledge of the MSVC CRT.

The errno changes you are suggesting may be fine, but I wasn't planning on addressing them with this patch.

[bcraig]

I'm still working on this.

Things I've learned: A clang install is bundled with re-implementations of several of these headers. The default #include_next behavior ends up pulling in lots of those.

I have been able to get things working with a VC include path and a UCRT include path, but the default include paths set by the compiler driver cause the clang versions of stdarg.h and vadefs.h to get pulled in. The combination of clang include path and ucrt include path also works.

I did end up running into the same errno problems that were mentioned earlier, and ended up coming to the same workaround.

[bcraig]

ping

[bcraig]

ping

[smeenai]

Sorry, I've been meaning to respond for a while.

This is kinda ugly, but I can't think of a better way to do it. I'm fine with this, but given that it's a pretty invasive change, I'm not comfortable accepting. You may wanna ping @EricWF and @mclow.lists directly.

[mclow.lists]

@smeenai wrote:

This is kinda ugly, but I can't think of a better way to do it. I'm fine with this, but given that it's a pretty invasive change, I'm not comfortable accepting. You may wanna ping @EricWF and @mclow.lists directly.

I'll be meeting with the MS compiler engineers next week; I'll see when/if they plan on implemementing include_next.

[halyavin]

In D32411#799878, @mclow.lists wrote:

@smeenai wrote:

This is kinda ugly, but I can't think of a better way to do it. I'm fine with this, but given that it's a pretty invasive change, I'm not comfortable accepting. You may wanna ping @EricWF and @mclow.lists directly.

I'll be meeting with the MS compiler engineers next week; I'll see when/if they plan on implemementing include_next.

How was a meeting in Toronto? Did they say anything about #include_next?

[bcraig]

ping

[bcraig]

ping

[bcraig]

Talked with mclow and some Microsoft devs in Albuquerque. I'm not expecting include_next to show up in MSVC. Sometime in the next month I hope to rebase this change.

[bcraig]

Rebased

[EricWF]

I spoke to STL on the MSVC team a while ago, and he stated that if we produced a paper describing why we need #include_next and the rational behind it, and they would pass that on to the front-end team. They didn't guarantee that they would implement it, but that seems like a good first step.

[bcraig]

In D32411#1056381, @EricWF wrote:

I spoke to STL on the MSVC team a while ago, and he stated that if we produced a paper describing why we need #include_next and the rational behind it, and they would pass that on to the front-end team. They didn't guarantee that they would implement it, but that seems like a good first step.

You had mentioned as much to me a year or so back in IRC. docs/DesignDocs/IncludeNextEmulation.rst is intended to be that document, but I can't find any emails where I actually sent that off.

However, there is also my earlier comment...

Talked with mclow and some Microsoft devs in Albuquerque. I'm not expecting include_next to show up in MSVC.

CMakeLists.txt

 config_define_if_not(LIBCXX_ENABLE_MONOTONIC_CLOCK _LIBCPP_HAS_NO_MONOTONIC_CLOCK)
 config_define_if_not(LIBCXX_ENABLE_THREAD_UNSAFE_C_FUNCTIONS _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS)
 
 config_define_if(LIBCXX_HAS_PTHREAD_API _LIBCPP_HAS_THREAD_API_PTHREAD)
 config_define_if(LIBCXX_HAS_EXTERNAL_THREAD_API _LIBCPP_HAS_THREAD_API_EXTERNAL)
 config_define_if(LIBCXX_BUILD_EXTERNAL_THREAD_LIBRARY _LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL)
 config_define_if(LIBCXX_HAS_MUSL_LIBC _LIBCPP_HAS_MUSL_LIBC)
 
+# The Windows headers are split between Visual Studio and the Windows SDK's
+# universal CRT.  Allow clients to specify both.
+if (LIBCXX_INCLUDE_NEXT_VC)
+  # Example for MSVC 2017: -D LIBCXX_INCLUDE_NEXT_VC=../../../MSVC/14.10.25017/include
+  config_define(${LIBCXX_INCLUDE_NEXT_VC} _LIBCPP_INCLUDE_NEXT_VC)
+endif()
+if (LIBCXX_INCLUDE_NEXT_UCRT)
+  # Example for Windows 10 SDK: -D LIBCXX_INCLUDE_NEXT_UCRT=../ucrt
+  config_define(${LIBCXX_INCLUDE_NEXT_UCRT} _LIBCPP_INCLUDE_NEXT_UCRT)
+endif()
+
 # By default libc++ on Windows expects to use a shared library, which requires
 # the headers to use DLL import/export semantics. However when building a
 # static library only we modify the headers to disable DLL import/export.
 if (DEFINED WIN32 AND LIBCXX_ENABLE_STATIC AND NOT LIBCXX_ENABLE_SHARED)
   message(STATUS "Generating custom __config for non-DLL Windows build")
   config_define(ON _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
 endif()
 

docs/DesignDocs/IncludeNextEmulation.rst

+=======================
+Emulating #include_next
+=======================
+Why #include_next at all?
+-------------------------
+Libc++ does not come with a C library.  It is intended to work with many different C libraries.  The C++ standard also requires the <cname> wrappers around the C library headers [headers] and compatibility wrappers for the <name.h> headers [depr.c.headers].
+
+The straightforward way to implement these wrappers is to have the C++ headers use the preprocessor extension #include_next in order to get access to the C version of the headers.  For example, the C++ <math.h> and <cmath> will need something like #include_next <math.h> in order to get the C version of math.h, rather than recursively include the C++ math.h.
+
+Why emulate #include_next?
+--------------------------
+#include_next isn't part of the C++ standard.  It is a compiler extension that both GCC and Clang implement.  Notably, Microsoft Visual Studio 2017 and earlier don't implement it (Visual Studio 2017 is the most current version as of the writing of this document).  Libc++ still needs access to the underlying C libraries though.
+
+How does one emulate #include_next?
+-----------------------------------
+Emulating #include_next requires extra knowledge about the file system layout of your headers.  Suppose you're file system was laid out this way...
+
+::
+
+ /
+   libcxx/
+     include/
+       math.h
+       cmath
+   vc/
+     include/
+       math.h
+
+We could then reach the vc/include/math.h include using a relative path include.
+
+::
+
+ #include <../../vc/include/math.h>
+
+The "vc/include" portion of the #include makes it impossible to pull in the math.h from libcxx/include.
+
+This has the obvious disadvantage of hard-coding C-library paths into multiple source code locations.  This can be solved by relying on implementation defined behavior of the preprocessor (C11, 6.10.2.4 ["Source file inclusion"]).  We will use what is referred to as a "computed include".
+
+::
+
+ #define _MY_INCLUDE_NEXT(header) <../../vc/include/header>
+ #include _MY_INCLUDE_NEXT(math.h)
+
+Libc++ goes an extra step with the computed includes.  __config_site.in allows those building libc++ to specify the relative path on the command line.
+
+::
+
+ #cmakedefine _MY_INCLUDE_NEXT(header) <@_MY_INCLUDE_NEXT@/header>
+
+This works reasonably well for most headers.  <errno.h> is trouble though.  If the order of #includes is just right, then the token 'errno' will already be defined as a macro before we get to the #include _MY_INCLUDE_NEXT(errno.h) line.  In a normal #include <errno.h> or #include "errno.h", the 'errno' macro isn't expanded.  But in #include _MY_INCLUDE_NEXT(errno.h), the 'errno' macro will be expanded.  For this situation, we undef errno inside a #pragma push_macro / pop_macro block, and hope that we didn't overwrite a 'better' errno definition.
+
+What is the right relative path for my version of Microsoft Visual Studio?
+--------------------------------------------------------------------------
+That depends on the header, and on the version of Microsoft Visual Studio.
+My Visual Studio 2017 installation places most of the C headers in the "universal CRT":
+
+::
+
+ C:\Program Files (x86)\Windows Kits\10\Include\10.0.14393.0\ucrt
+
+A few of the C headers (stdbool.h, limits.h, stdint.h, and setjmp.h) are found here though:
+
+::
+
+ C:\Program Files (x86)\Microsoft Visual Studio\2017\Professional\VC\Tools\MSVC\14.10.25017\include
+
+In Visual Studio 2015, most of the C headers could still be found in the universal crt, but the remainders are here:
+
+::
+
+ C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\include
+
+The universal crt was introduced in Microsoft Visual Studio 2015.  Prior to that, most of C headers could be found in the corresponding installation's VC\include directory.
+
+Over the past three major versions of Microsoft Visual Studio, the locations for headers have changed three times.  Given that the path in Microsoft Visual Studio 2017 has a very specific version in the path (14.10.25017), it is reasonable to assume that the required relative path will change along with patches and updates.
+
+Since the C headers in Microsoft Visual Studio 2017 aren't all located in one place, the Libc++ implementation uses multiple macros and multiple relative paths to find the right headers.  I have had some success with these paths:
+
+::
+
+ LIBCXX_INCLUDE_NEXT_VC=../../../MSVC/14.10.25017/include \
+ LIBCXX_INCLUDE_NEXT_UCRT=../ucrt \
+
+
+How does Libc++ emulate #include_next?
+--------------------------------------
+Each use of #include_next is guarded with a check of _LIBCPP_HAS_NO_INCLUDE_NEXT.  When include_next isn't present, we use the emulation macros instead, and either #include _LIBCPP_INCLUDE_NEXT_UCRT(name.h) or #include _LIBCPP_INCLUDE_NEXT_VC(name.h).
+
+If the Microsoft Visual Studio headers change location again, in a way that doesn't put them all in the same location (e.g. all under ucrt), then more emulation macros will need to be added, possibly one macro per header.

include/__config

 
 #if !defined(_LIBCPP_HAS_NO_ASAN) && !__has_feature(address_sanitizer)
 #define _LIBCPP_HAS_NO_ASAN
 #endif
 
 // Allow for build-time disabling of unsigned integer sanitization
 #if !defined(_LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK) && __has_attribute(no_sanitize)
 #define _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK __attribute__((__no_sanitize__("unsigned-integer-overflow")))
-#endif 
+#endif
 
 #elif defined(_LIBCPP_COMPILER_GCC)
 
 #define _ALIGNAS(x) __attribute__((__aligned__(x)))
 #define _ALIGNAS_TYPE(x) __attribute__((__aligned__(__alignof(x))))
 
 #define _LIBCPP_NORETURN __attribute__((noreturn))
 

 #if !__has_keyword(__is_aggregate) && (_GNUC_VER_NEW < 7001)
 # define _LIBCPP_HAS_NO_IS_AGGREGATE
 #endif
 
 #if !defined(__cpp_coroutines) || __cpp_coroutines < 201703L
 # define _LIBCPP_HAS_NO_COROUTINES
 #endif
 
+#if defined(_LIBCPP_COMPILER_MSVC)
+#  define _LIBCPP_HAS_NO_INCLUDE_NEXT
+#endif
+
 #endif // __cplusplus
 
 // Decide whether to use availability macros.
 #if !defined(_LIBCPP_BUILDING_LIBRARY) &&                                      \
     !defined(_LIBCPP_DISABLE_AVAILABILITY) &&                                  \
     __has_feature(attribute_availability_with_strict) &&                       \
     __has_feature(attribute_availability_in_templates)
 #ifdef __APPLE__

include/__config_site.in

 #cmakedefine _LIBCPP_HAS_NO_THREADS
 #cmakedefine _LIBCPP_HAS_NO_MONOTONIC_CLOCK
 #cmakedefine _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
 #cmakedefine _LIBCPP_HAS_MUSL_LIBC
 #cmakedefine _LIBCPP_HAS_THREAD_API_PTHREAD
 #cmakedefine _LIBCPP_HAS_THREAD_API_EXTERNAL
 #cmakedefine _LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL
 #cmakedefine _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS
+#cmakedefine _LIBCPP_INCLUDE_NEXT_VC(header) <@_LIBCPP_INCLUDE_NEXT_VC@/header>
+#cmakedefine _LIBCPP_INCLUDE_NEXT_UCRT(header) <@_LIBCPP_INCLUDE_NEXT_UCRT@/header>
 
 #endif // _LIBCPP_CONFIG_SITE

include/complex.h

 #endif
 
 #ifdef __cplusplus
 
 #include <ccomplex>
 
 #else  // __cplusplus
 
+#if defined(_LIBCPP_HAS_NO_INCLUDE_NEXT)
+#include _LIBCPP_INCLUDE_NEXT_UCRT(complex.h)
+#else
 #include_next <complex.h>
+#endif
 
 #endif  // __cplusplus
 
 #endif  // _LIBCPP_COMPLEX_H

include/cstddef

 
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 // Don't include our own <stddef.h>; we don't want to declare ::nullptr_t.
+#if defined(_LIBCPP_HAS_NO_INCLUDE_NEXT)
+#include _LIBCPP_INCLUDE_NEXT_UCRT(stddef.h)
+#else
 #include_next <stddef.h>
+#endif
 #include <__nullptr>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 using ::ptrdiff_t;
 using ::size_t;
 
 #if defined(__CLANG_MAX_ALIGN_T_DEFINED) || defined(_GCC_MAX_ALIGN_T) || \

 constexpr byte  operator| (byte  __lhs, byte __rhs) noexcept
 { return         byte(static_cast<unsigned char>(__lhs) | static_cast<unsigned char>(__rhs)); }
 
 constexpr byte& operator&=(byte& __lhs, byte __rhs) noexcept
 { return __lhs = byte(static_cast<unsigned char>(__lhs) & static_cast<unsigned char>(__rhs)); }
 constexpr byte  operator& (byte  __lhs, byte __rhs) noexcept
 { return         byte(static_cast<unsigned char>(__lhs) & static_cast<unsigned char>(__rhs)); }
 
-constexpr byte& operator^=(byte& __lhs, byte __rhs) noexcept 
+constexpr byte& operator^=(byte& __lhs, byte __rhs) noexcept
 { return __lhs = byte(static_cast<unsigned char>(__lhs) ^ static_cast<unsigned char>(__rhs)); }
 constexpr byte  operator^ (byte  __lhs, byte __rhs) noexcept
 { return         byte(static_cast<unsigned char>(__lhs) ^ static_cast<unsigned char>(__rhs)); }
 
 constexpr byte  operator~ (byte __b) noexcept
 { return  byte(~static_cast<unsigned char>(__b)); }
 
 }
 
 #include <type_traits>  // rest of byte
 #endif
 
 #endif  // _LIBCPP_CSTDDEF

include/ctype.h

 */
 
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
+#if defined(_LIBCPP_HAS_NO_INCLUDE_NEXT)
+#include _LIBCPP_INCLUDE_NEXT_UCRT(ctype.h)
+#else
 #include_next <ctype.h>
+#endif
 
 #ifdef __cplusplus
 
 #undef isalnum
 #undef isalpha
 #undef isblank
 #undef iscntrl
 #undef isdigit

include/errno.h

 */
 
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
+#if defined(_LIBCPP_HAS_NO_INCLUDE_NEXT)
+    #ifdef errno
+       #pragma push_macro("errno")
+       #undef errno
+       #include _LIBCPP_INCLUDE_NEXT_UCRT(errno.h)
+       #pragma pop_macro("errno")
+    #else
+       #include _LIBCPP_INCLUDE_NEXT_UCRT(errno.h)
+    #endif
+#else
 #include_next <errno.h>
+#endif
 
 #ifdef __cplusplus
 
 #if !defined(EOWNERDEAD) || !defined(ENOTRECOVERABLE)
 
 #ifdef ELAST
 
 static const int __elast1 = ELAST+1;

include/float.h

 */
 
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
+#if defined(_LIBCPP_HAS_NO_INCLUDE_NEXT)
+#include _LIBCPP_INCLUDE_NEXT_UCRT(float.h)
+#else
 #include_next <float.h>
+#endif
 
 #ifdef __cplusplus
 
 #ifndef FLT_EVAL_METHOD
 #define FLT_EVAL_METHOD __FLT_EVAL_METHOD__
 #endif
 
 #ifndef DECIMAL_DIG
 #define DECIMAL_DIG __DECIMAL_DIG__
 #endif
 
 #endif // __cplusplus
 
 #endif  // _LIBCPP_FLOAT_H

include/inttypes.h

 
 /* C99 stdlib (e.g. glibc < 2.18) does not provide format macros needed
    for C++11 unless __STDC_FORMAT_MACROS is defined
 */
 #if defined(__cplusplus) && !defined(__STDC_FORMAT_MACROS)
 #   define __STDC_FORMAT_MACROS
 #endif
 
+#if defined(_LIBCPP_HAS_NO_INCLUDE_NEXT)
+#include _LIBCPP_INCLUDE_NEXT_UCRT(inttypes.h)
+#else
 #include_next <inttypes.h>
+#endif
 
 #ifdef __cplusplus
 
 #include <stdint.h>
 
 #undef imaxabs
 #undef imaxdiv
 
 #endif // __cplusplus
 
 #endif  // _LIBCPP_INTTYPES_H

include/limits.h

 
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 #ifndef __GNUC__
+#if defined(_LIBCPP_HAS_NO_INCLUDE_NEXT)
+#include _LIBCPP_INCLUDE_NEXT_VC(limits.h)
+#else
 #include_next <limits.h>
+#endif
 #else
 // GCC header limits.h recursively includes itself through another header called
 // syslimits.h for some reason. This setup breaks down if we directly
 // #include_next GCC's limits.h (reasons not entirely clear to me). Therefore,
 // we manually re-create the necessary include sequence below:
 
 // Get the system limits.h defines (force recurse into the next level)
 #define _GCC_LIMITS_H_

include/locale.h

 */
 
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
+#if defined(_LIBCPP_HAS_NO_INCLUDE_NEXT)
+#include _LIBCPP_INCLUDE_NEXT_UCRT(locale.h)
+#else
 #include_next <locale.h>
+#endif
 
 #endif  // _LIBCPP_LOCALE_H

include/math.h

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

include/setjmp.h

 */
 
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
+#if defined(_LIBCPP_HAS_NO_INCLUDE_NEXT)
+#include _LIBCPP_INCLUDE_NEXT_VC(setjmp.h)
+#else
 #include_next <setjmp.h>
+#endif
 
 #ifdef __cplusplus
 
 #ifndef setjmp
 #define setjmp(env) setjmp(env)
 #endif
 
 #endif // __cplusplus
 
 #endif  // _LIBCPP_SETJMP_H

include/stdbool.h

 */
 
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
+#if defined(_LIBCPP_HAS_NO_INCLUDE_NEXT)
+#include _LIBCPP_INCLUDE_NEXT_VC(stdbool.h)
+#else
 #include_next <stdbool.h>
+#endif
 
 #ifdef __cplusplus
 #undef bool
 #undef true
 #undef false
 #undef __bool_true_false_are_defined
 #define __bool_true_false_are_defined 1
 #endif
 
 #endif  // _LIBCPP_STDBOOL_H

include/stddef.h

 
 #if defined(__need_ptrdiff_t) || defined(__need_size_t) || \
     defined(__need_wchar_t) || defined(__need_NULL) || defined(__need_wint_t)
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
+#if defined(_LIBCPP_HAS_NO_INCLUDE_NEXT)
+#include _LIBCPP_INCLUDE_NEXT_UCRT(stddef.h)
+#else
 #include_next <stddef.h>
+#endif
 
 #elif !defined(_LIBCPP_STDDEF_H)
 #define _LIBCPP_STDDEF_H
 
 /*
     stddef.h synopsis
 
 Macros:

 */
 
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
+#if defined(_LIBCPP_HAS_NO_INCLUDE_NEXT)
+#include _LIBCPP_INCLUDE_NEXT_UCRT(stddef.h)
+#else
 #include_next <stddef.h>
+#endif
 
 #ifdef __cplusplus
 
 extern "C++" {
 #include <__nullptr>
 using std::nullptr_t;
 }
 

include/stdint.h

 */
 #if defined(__cplusplus) && !defined(__STDC_LIMIT_MACROS)
 #   define __STDC_LIMIT_MACROS
 #endif
 #if defined(__cplusplus) && !defined(__STDC_CONSTANT_MACROS)
 #   define __STDC_CONSTANT_MACROS
 #endif
 
+#if defined(_LIBCPP_HAS_NO_INCLUDE_NEXT)
+#include _LIBCPP_INCLUDE_NEXT_VC(stdint.h)
+#else
 #include_next <stdint.h>
+#endif
 
 #endif  // _LIBCPP_STDINT_H

include/stdio.h

 // -*- C++ -*-
 //===---------------------------- stdio.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.
 //
 //===----------------------------------------------------------------------===//
 
 #if defined(__need_FILE) || defined(__need___FILE)
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
+#if defined(_LIBCPP_HAS_NO_INCLUDE_NEXT)
+#include _LIBCPP_INCLUDE_NEXT_UCRT(stdio.h)
+#else
 #include_next <stdio.h>
+#endif
 
 #elif !defined(_LIBCPP_STDIO_H)
 #define _LIBCPP_STDIO_H
 
 /*
     stdio.h synopsis
 
 Macros:

 */
 
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
+#if defined(_LIBCPP_HAS_NO_INCLUDE_NEXT)
+#include _LIBCPP_INCLUDE_NEXT_UCRT(stdio.h)
+#else
 #include_next <stdio.h>
+#endif
 
 #ifdef __cplusplus
 
 // snprintf
 #if defined(_LIBCPP_MSVCRT)
 extern "C" {
 int vasprintf(char **sptr, const char *__restrict fmt, va_list ap);
 int asprintf(char **sptr, const char *__restrict fmt, ...);

include/stdlib.h

 // -*- C++ -*-
 //===--------------------------- stdlib.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.
 //
 //===----------------------------------------------------------------------===//
 
 #if defined(__need_malloc_and_calloc)
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
+#if defined(_LIBCPP_HAS_NO_INCLUDE_NEXT)
+#include _LIBCPP_INCLUDE_NEXT_UCRT(stdlib.h)
+#else
 #include_next <stdlib.h>
+#endif
 
 #elif !defined(_LIBCPP_STDLIB_H)
 #define _LIBCPP_STDLIB_H
 
 /*
     stdlib.h synopsis
 
 Macros:

 */
 
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
+#if defined(_LIBCPP_HAS_NO_INCLUDE_NEXT)
+#include _LIBCPP_INCLUDE_NEXT_UCRT(stdlib.h)
+#else
 #include_next <stdlib.h>
+#endif
 
 #ifdef __cplusplus
 
 extern "C++" {
 
 #undef abs
 #undef div
 #undef labs

include/string.h

 */
 
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
+#if defined(_LIBCPP_HAS_NO_INCLUDE_NEXT)
+#include _LIBCPP_INCLUDE_NEXT_UCRT(string.h)
+#else
 #include_next <string.h>
+#endif
 
 // MSVCRT, GNU libc and its derivates may already have the correct prototype in
 // <string.h>. This macro can be defined by users if their C library provides
 // the right signature.
 #if defined(__CORRECT_ISO_CPP_STRING_H_PROTO) || defined(_LIBCPP_MSVCRT) || \
     defined(__sun__) || defined(_STRING_H_CPLUSPLUS_98_CONFORMANCE_)
 #define _LIBCPP_STRING_H_HAS_CONST_OVERLOADS
 #endif

include/wchar.h

 // -*- C++ -*-
 //===--------------------------- wchar.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.
 //
 //===----------------------------------------------------------------------===//
 
 #if defined(__need_wint_t) || defined(__need_mbstate_t)
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
+#if defined(_LIBCPP_HAS_NO_INCLUDE_NEXT)
+#include _LIBCPP_INCLUDE_NEXT_UCRT(wchar.h)
+#else
 #include_next <wchar.h>
+#endif
 
 #elif !defined(_LIBCPP_WCHAR_H)
 #define _LIBCPP_WCHAR_H
 
 /*
     wchar.h synopsis
 
 Macros:

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 #ifdef __cplusplus
 #define __CORRECT_ISO_CPP_WCHAR_H_PROTO
 #endif
 
+#if defined(_LIBCPP_HAS_NO_INCLUDE_NEXT)
+#include _LIBCPP_INCLUDE_NEXT_UCRT(wchar.h)
+#else
 #include_next <wchar.h>
+#endif
 
 // Determine whether we have const-correct overloads for wcschr and friends.
 #if defined(_WCHAR_H_CPLUSPLUS_98_CONFORMANCE_)
 #  define _LIBCPP_WCHAR_H_HAS_CONST_OVERLOADS 1
 #elif defined(__GLIBC_PREREQ)
 #  if __GLIBC_PREREQ(2, 10)
 #    define _LIBCPP_WCHAR_H_HAS_CONST_OVERLOADS 1
 #  endif

include/wctype.h

 */
 
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
+#if defined(_LIBCPP_HAS_NO_INCLUDE_NEXT)
+#include _LIBCPP_INCLUDE_NEXT_UCRT(wctype.h)
+#else
 #include_next <wctype.h>
+#endif
 
 #ifdef __cplusplus
 
 #undef iswalnum
 #undef iswalpha
 #undef iswblank
 #undef iswcntrl
 #undef iswdigit

utils/libcxx/test/config.py

def parse_config_site_and_add_features(self, header):
         # The __config_site header should be non-empty. Otherwise it should
         # have never been emitted by CMake.
         assert len(feature_macros) > 0
         # Transform each macro name into the feature name used in the tests.
         # Ex. _LIBCPP_HAS_NO_THREADS -> libcpp-has-no-threads
         for m in feature_macros:
             if m == '_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS':
                 continue
+            if m.startswith('_LIBCPP_INCLUDE_NEXT'):
+                continue
             if m == '_LIBCPP_ABI_VERSION':
                 self.config.available_features.add('libcpp-abi-version-v%s'
                     % feature_macros[m])
                 continue
             assert m.startswith('_LIBCPP_HAS_') or m == '_LIBCPP_ABI_UNSTABLE'
             m = m.lower()[1:].replace('_', '-')
             self.config.available_features.add(m)
         return feature_macros