[Headers][Modules] Make separate headers for the stdarg.h and stddef.h pieces so that they can be modularized

[iana]

Summary

stdarg.h and stddef.h have to be textual headers in their upcoming modules to support their __needs_xxx macros. That means that they won't get precompiled into their modules' pcm, and instead their declarations will go into every other pcm that uses them. For now that's ok since the type merger can handle the declarations in these headers, but it's suboptimal at best. Make separate headers for all of the pieces so that they can be properly modularized.

[iana]

Fixed the failing test

[iana]

Rebase

[aaron.ballman]

I'm a bit concerned about the impact on (non-modules) build time performance. This splits stddef.h and stdarg.h into needing to open 14 different files instead of 2. Hopefully that's not a lot of overhead, but given that stddef.h is included in approximately every TU and that sometimes external forces cause files to be slow to open (network drives, AV software, etc), I think we should be cautious and measure the impact. I also really do not like how poorly this scales -- the fact that this is only needed for these two files helps a bit, but this is a lot of C++-specific hoops to jump through for C standard library headers.

[iana]

In D158709#4617295, @aaron.ballman wrote:

I'm a bit concerned about the impact on (non-modules) build time performance. This splits stddef.h and stdarg.h into needing to open 14 different files instead of 2. Hopefully that's not a lot of overhead, but given that stddef.h is included in approximately every TU and that sometimes external forces cause files to be slow to open (network drives, AV software, etc), I think we should be cautious and measure the impact. I also really do not like how poorly this scales -- the fact that this is only needed for these two files helps a bit, but this is a lot of C++-specific hoops to jump through for C standard library headers.

This is in support of clang modules, not C++ modules. The plan is to make modules like this.

module _Builtin_stddef [system] {
  textual header "stddef.h"

  explicit module max_align_t {
    header "__stddef_max_align_t.h"
    export *
  }

  explicit module null {
    header "__stddef_null.h"
    export *
  }
  ...
}

I do agree it's a bit of a file explosion, but I can't really think of any better alternatives. It's tough to measure build time performance impact. If you have a slow enough file system (and the fs on our builders at Apple is quite slow), and you aren't using modules or pch's, and you have quite a lot of source files, then possibly this would be noticeable? I still don't know what we could really do about it besides have #if !__has_feature(modules) and inline the contents in that case. That seems like a maintenance headache and a half though. I would hope that most sizable projects either use clang modules or pch's?

[iana]

Modules don't support the #include #undef #include pattern to redefine macros, the second include has no effect. Move the #undef of NULL into __stddef_null.h so that the textual behavior is preserved, but the module behavior doesn't leave NULL undefined.

[aaron.ballman]

In D158709#4617783, @iana wrote:

In D158709#4617295, @aaron.ballman wrote:

I'm a bit concerned about the impact on (non-modules) build time performance. This splits stddef.h and stdarg.h into needing to open 14 different files instead of 2. Hopefully that's not a lot of overhead, but given that stddef.h is included in approximately every TU and that sometimes external forces cause files to be slow to open (network drives, AV software, etc), I think we should be cautious and measure the impact. I also really do not like how poorly this scales -- the fact that this is only needed for these two files helps a bit, but this is a lot of C++-specific hoops to jump through for C standard library headers.

This is in support of clang modules, not C++ modules.

Ah, good to know, thank you!

The plan is to make modules like this.

module _Builtin_stddef [system] {
  textual header "stddef.h"

  explicit module max_align_t {
    header "__stddef_max_align_t.h"
    export *
  }

  explicit module null {
    header "__stddef_null.h"
    export *
  }
  ...
}

I do agree it's a bit of a file explosion, but I can't really think of any better alternatives. It's tough to measure build time performance impact. If you have a slow enough file system (and the fs on our builders at Apple is quite slow), and you aren't using modules or pch's, and you have quite a lot of source files, then possibly this would be noticeable? I still don't know what we could really do about it besides have #if !__has_feature(modules) and inline the contents in that case. That seems like a maintenance headache and a half though. I would hope that most sizable projects either use clang modules or pch's?

Yeah, measuring file system impacts is always tricky. :-( The reason I'm concerned is actually because a fair number of projects explicitly don't use PCH or Clang modules (or C++ modules), especially in C. Because of how fast compilations go in C, it's possible that the extra filesystem overhead really will be noticeable by users. However, I also can't think of a way around this in code...

At a high-level (not just for this patch, but for the entire series): is this need specific to your downstream or is this a more general need? e.g., should this complexity be kept downstream until we've got a second platform needing it?

[iana]

In D158709#4621199, @aaron.ballman wrote:

At a high-level (not just for this patch, but for the entire series): is this need specific to your downstream or is this a more general need? e.g., should this complexity be kept downstream until we've got a second platform needing it?

I think it's a general need to properly modularize the clang headers, I don't think it's really Apple specific.

[aaron.ballman]

In D158709#4622006, @iana wrote:

In D158709#4621199, @aaron.ballman wrote:

At a high-level (not just for this patch, but for the entire series): is this need specific to your downstream or is this a more general need? e.g., should this complexity be kept downstream until we've got a second platform needing it?

I think it's a general need to properly modularize the clang headers, I don't think it's really Apple specific.

Good to know (that was my understanding as well). I'd say let's move forward with this approach given there's not a clearly better way to go about this. LGTM!

[ChuanqiXu]

LGTM too.

[aheejin]

The added space in ((void *)0) in __stddef_null.h broke Emscripten CI, which uses musl (https://www.musl-libc.org/). I added the space back in D159312.

clang-tools-extra/clang-include-fixer/find-all-symbols/STLPostfixHeaderMap.cpp

 //===-- STLPostfixHeaderMap.h - hardcoded STL header map --------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "STLPostfixHeaderMap.h"
 
 namespace clang {
 namespace find_all_symbols {
 
 const HeaderMapCollector::RegexHeaderMap *getSTLPostfixHeaderMap() {
   static const HeaderMapCollector::RegexHeaderMap STLPostfixHeaderMap = {
+      {"include/__stdarg___gnuc_va_list.h$", "<cstdarg>"},
+      {"include/__stdarg___va_copy.h$", "<cstdarg>"},
+      {"include/__stdarg_va_arg.h$", "<cstdarg>"},
+      {"include/__stdarg_va_copy.h$", "<cstdarg>"},
+      {"include/__stdarg_va_list.h$", "<cstdarg>"},
       {"include/__stddef_max_align_t.h$", "<cstddef>"},
+      {"include/__stddef_null.h$", "<cstddef>"},
+      {"include/__stddef_nullptr_t.h$", "<cstddef>"},
+      {"include/__stddef_offsetof.h$", "<cstddef>"},
+      {"include/__stddef_ptrdiff_t.h$", "<cstddef>"},
+      {"include/__stddef_rsize_t.h$", "<cstddef>"},
+      {"include/__stddef_size_t.h$", "<cstddef>"},
+      {"include/__stddef_unreachable.h$", "<cstddef>"},
+      {"include/__stddef_wchar_t.h$", "<cstddef>"},
+      {"include/__stddef_wint_t.h$", "<cstddef>"},
       {"include/__wmmintrin_aes.h$", "<wmmintrin.h>"},
       {"include/__wmmintrin_pclmul.h$", "<wmmintrin.h>"},
       {"include/adxintrin.h$", "<immintrin.h>"},
       {"include/ammintrin.h$", "<ammintrin.h>"},
       {"include/avx2intrin.h$", "<immintrin.h>"},
       {"include/avx512bwintrin.h$", "<immintrin.h>"},
       {"include/avx512cdintrin.h$", "<immintrin.h>"},
       {"include/avx512dqintrin.h$", "<immintrin.h>"},

clang-tools-extra/clangd/index/CanonicalIncludes.cpp

 #include "clang/Basic/LangOptions.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Path.h"
 
 namespace clang {
 namespace clangd {
 namespace {
 const std::pair<llvm::StringRef, llvm::StringRef> IncludeMappings[] = {
+    {"include/__stdarg___gnuc_va_list.h", "<cstdarg>"},
+    {"include/__stdarg___va_copy.h", "<cstdarg>"},
+    {"include/__stdarg_va_arg.h", "<cstdarg>"},
+    {"include/__stdarg_va_copy.h", "<cstdarg>"},
+    {"include/__stdarg_va_list.h", "<cstdarg>"},
     {"include/__stddef_max_align_t.h", "<cstddef>"},
+    {"include/__stddef_null.h", "<cstddef>"},
+    {"include/__stddef_nullptr_t.h", "<cstddef>"},
+    {"include/__stddef_offsetof.h", "<cstddef>"},
+    {"include/__stddef_ptrdiff_t.h", "<cstddef>"},
+    {"include/__stddef_rsize_t.h", "<cstddef>"},
+    {"include/__stddef_size_t.h", "<cstddef>"},
+    {"include/__stddef_unreachable.h", "<cstddef>"},
+    {"include/__stddef_wchar_t.h", "<cstddef>"},
+    {"include/__stddef_wint_t.h", "<cstddef>"},
     {"include/__wmmintrin_aes.h", "<wmmintrin.h>"},
     {"include/__wmmintrin_pclmul.h", "<wmmintrin.h>"},
     {"include/adxintrin.h", "<immintrin.h>"},
     {"include/ammintrin.h", "<ammintrin.h>"},
     {"include/avx2intrin.h", "<immintrin.h>"},
     {"include/avx512bwintrin.h", "<immintrin.h>"},
     {"include/avx512cdintrin.h", "<immintrin.h>"},
     {"include/avx512dqintrin.h", "<immintrin.h>"},

clang/lib/Headers/CMakeLists.txt

 # core_files list contains the headers shared by all platforms.
 # Please consider adding new platform specific headers
 # to platform specific lists below.
 set(core_files
   builtins.h
   float.h
   inttypes.h
   iso646.h
   limits.h
   module.modulemap
   stdalign.h
   stdarg.h
+  __stdarg___gnuc_va_list.h
+  __stdarg___va_copy.h
+  __stdarg_va_arg.h
+  __stdarg_va_copy.h
+  __stdarg_va_list.h
   stdatomic.h
   stdbool.h
   stddef.h
   __stddef_max_align_t.h
+  __stddef_null.h
+  __stddef_nullptr_t.h
+  __stddef_offsetof.h
+  __stddef_ptrdiff_t.h
+  __stddef_rsize_t.h
+  __stddef_size_t.h
+  __stddef_unreachable.h
+  __stddef_wchar_t.h
+  __stddef_wint_t.h
   stdint.h
   stdnoreturn.h
   tgmath.h
   unwind.h
   varargs.h
   )
 
 set(arm_common_files

clang/lib/Headers/__stdarg___gnuc_va_list.h

+/*===---- __stdarg___gnuc_va_list.h - Definition of __gnuc_va_list ---------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __GNUC_VA_LIST
+#define __GNUC_VA_LIST
+typedef __builtin_va_list __gnuc_va_list;
+#endif

clang/lib/Headers/__stdarg___va_copy.h

+/*===---- __stdarg___va_copy.h - Definition of __va_copy -------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __va_copy
+#define __va_copy(d, s) __builtin_va_copy(d, s)
+#endif

clang/lib/Headers/__stdarg_va_arg.h

+/*===---- __stdarg_va_arg.h - Definitions of va_start, va_arg, va_end-------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef va_arg
+
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
+/* C23 does not require the second parameter for va_start. */
+#define va_start(ap, ...) __builtin_va_start(ap, 0)
+#else
+/* Versions before C23 do require the second parameter. */
+#define va_start(ap, param) __builtin_va_start(ap, param)
+#endif
+#define va_end(ap) __builtin_va_end(ap)
+#define va_arg(ap, type) __builtin_va_arg(ap, type)
+
+#endif

clang/lib/Headers/__stdarg_va_copy.h

+/*===---- __stdarg_va_copy.h - Definition of va_copy------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef va_copy
+#define va_copy(dest, src) __builtin_va_copy(dest, src)
+#endif

clang/lib/Headers/__stdarg_va_list.h

+/*===---- __stdarg_va_list.h - Definition of va_list -----------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef _VA_LIST
+#define _VA_LIST
+typedef __builtin_va_list va_list;
+#endif

clang/lib/Headers/__stddef_null.h

+/*===---- __stddef_null.h - Definition of NULL -----------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#undef NULL
+#ifdef __cplusplus
+#if !defined(__MINGW32__) && !defined(_MSC_VER)
+#define NULL __null
+#else
+#define NULL 0
+#endif
+#else
+#define NULL ((void *)0)
+#endif

clang/lib/Headers/__stddef_nullptr_t.h

+/*===---- __stddef_nullptr_t.h - Definition of nullptr_t -------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#if !defined(_NULLPTR_T) || __has_feature(modules)
+/* Always define nullptr_t when modules are available. */
+#if !__has_feature(modules)
+#define _NULLPTR_T
+#endif
+#ifdef __cplusplus
+#if defined(_MSC_EXTENSIONS) && defined(_NATIVE_NULLPTR_SUPPORTED)
+namespace std {
+typedef decltype(nullptr) nullptr_t;
+}
+using ::std::nullptr_t;
+#endif
+#else
+typedef typeof(nullptr) nullptr_t;
+#endif
+#endif

clang/lib/Headers/__stddef_offsetof.h

+/*===---- __stddef_offsetof.h - Definition of offsetof ---------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#if !defined(offsetof) || __has_feature(modules)
+/* Always define offsetof when modules are available. */
+#define offsetof(t, d) __builtin_offsetof(t, d)
+#endif

clang/lib/Headers/__stddef_ptrdiff_t.h

+/*===---- __stddef_ptrdiff_t.h - Definition of ptrdiff_t -------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#if !defined(_PTRDIFF_T) || __has_feature(modules)
+/* Always define ptrdiff_t when modules are available. */
+#if !__has_feature(modules)
+#define _PTRDIFF_T
+#endif
+typedef __PTRDIFF_TYPE__ ptrdiff_t;
+#endif

clang/lib/Headers/__stddef_rsize_t.h

+/*===---- __stddef_rsize_t.h - Definition of rsize_t -----------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#if !defined(_RSIZE_T) || __has_feature(modules)
+/* Always define rsize_t when modules are available. */
+#if !__has_feature(modules)
+#define _RSIZE_T
+#endif
+typedef __SIZE_TYPE__ rsize_t;
+#endif

clang/lib/Headers/__stddef_size_t.h

+/*===---- __stddef_size_t.h - Definition of size_t -------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#if !defined(_SIZE_T) || __has_feature(modules)
+/* Always define size_t when modules are available. */
+#if !__has_feature(modules)
+#define _SIZE_T
+#endif
+typedef __SIZE_TYPE__ size_t;
+#endif

clang/lib/Headers/__stddef_unreachable.h

+/*===---- __stddef_unreachable.h - Definition of unreachable ---------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#if !defined(unreachable) || __has_feature(modules)
+/* Always define unreachable when modules are available. */
+#define unreachable() __builtin_unreachable()
+#endif

clang/lib/Headers/__stddef_wchar_t.h

+/*===---- __stddef_wchar.h - Definition of wchar_t -------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#if !defined(__cplusplus) || (defined(_MSC_VER) && !_NATIVE_WCHAR_T_DEFINED)
+/* Always define wchar_t when modules are available. */
+#if !defined(_WCHAR_T) || __has_feature(modules)
+#if !__has_feature(modules)
+#define _WCHAR_T
+#if defined(_MSC_EXTENSIONS)
+#define _WCHAR_T_DEFINED
+#endif
+#endif
+typedef __WCHAR_TYPE__ wchar_t;
+#endif
+#endif

clang/lib/Headers/__stddef_wint_t.h

+/*===---- __stddef_wint.h - Definition of wint_t ---------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+/* Always define wint_t when modules are available. */
+#if !defined(_WINT_T) || __has_feature(modules)
+#if !__has_feature(modules)
+#define _WINT_T
+#endif
+typedef __WINT_TYPE__ wint_t;
+#endif

clang/lib/Headers/stdarg.h

 #if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) ||              \
     (defined(__cplusplus) && __cplusplus >= 201103L) ||                        \
     !defined(__STRICT_ANSI__)
 #define __need_va_copy
 #endif
 #endif
 
 #ifdef __need___va_list
-#ifndef __GNUC_VA_LIST
-#define __GNUC_VA_LIST
-typedef __builtin_va_list __gnuc_va_list;
-#endif
+#include <__stdarg___gnuc_va_list.h>
 #undef __need___va_list
 #endif /* defined(__need___va_list) */
 
 #ifdef __need_va_list
-#ifndef _VA_LIST
-typedef __builtin_va_list va_list;
-#define _VA_LIST
-#endif
+#include <__stdarg_va_list.h>
 #undef __need_va_list
 #endif /* defined(__need_va_list) */
 
 #ifdef __need_va_arg
-#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
-/* C23 does not require the second parameter for va_start. */
-#define va_start(ap, ...) __builtin_va_start(ap, 0)
-#else
-/* Versions before C23 do require the second parameter. */
-#define va_start(ap, param) __builtin_va_start(ap, param)
-#endif
-#define va_end(ap)          __builtin_va_end(ap)
-#define va_arg(ap, type)    __builtin_va_arg(ap, type)
+#include <__stdarg_va_arg.h>
 #undef __need_va_arg
 #endif /* defined(__need_va_arg) */
 
 #ifdef __need___va_copy
-#define __va_copy(d,s) __builtin_va_copy(d,s)
+#include <__stdarg___va_copy.h>
 #undef __need___va_copy
 #endif /* defined(__need___va_copy) */
 
 #ifdef __need_va_copy
-#define va_copy(dest, src)  __builtin_va_copy(dest, src)
+#include <__stdarg_va_copy.h>
 #undef __need_va_copy
 #endif /* defined(__need_va_copy) */
 
 #endif

clang/lib/Headers/stddef.h

 #endif
 #define __need_offsetof
 /* wint_t is provided by <wchar.h> and not <stddef.h>. It's here
  * for compatibility, but must be explicitly requested. Therefore
  * __need_wint_t is intentionally not defined here. */
 #endif
 
 #if defined(__need_ptrdiff_t)
-#if !defined(_PTRDIFF_T) || __has_feature(modules)
-/* Always define ptrdiff_t when modules are available. */
-#if !__has_feature(modules)
-#define _PTRDIFF_T
-#endif
-typedef __PTRDIFF_TYPE__ ptrdiff_t;
-#endif
+#include <__stddef_ptrdiff_t.h>
 #undef __need_ptrdiff_t
 #endif /* defined(__need_ptrdiff_t) */
 
 #if defined(__need_size_t)
-#if !defined(_SIZE_T) || __has_feature(modules)
-/* Always define size_t when modules are available. */
-#if !__has_feature(modules)
-#define _SIZE_T
-#endif
-typedef __SIZE_TYPE__ size_t;
-#endif
+#include <__stddef_size_t.h>
 #undef __need_size_t
 #endif /*defined(__need_size_t) */
 
 #if defined(__need_rsize_t)
-#if !defined(_RSIZE_T) || __has_feature(modules)
-/* Always define rsize_t when modules are available. */
-#if !__has_feature(modules)
-#define _RSIZE_T
-#endif
-typedef __SIZE_TYPE__ rsize_t;
-#endif
+#include <__stddef_rsize_t.h>
 #undef __need_rsize_t
 #endif /* defined(__need_rsize_t) */
 
 #if defined(__need_wchar_t)
-#if !defined(__cplusplus) || (defined(_MSC_VER) && !_NATIVE_WCHAR_T_DEFINED)
-/* Always define wchar_t when modules are available. */
-#if !defined(_WCHAR_T) || __has_feature(modules)
-#if !__has_feature(modules)
-#define _WCHAR_T
-#if defined(_MSC_EXTENSIONS)
-#define _WCHAR_T_DEFINED
-#endif
-#endif
-typedef __WCHAR_TYPE__ wchar_t;
-#endif
-#endif
+#include <__stddef_wchar_t.h>
 #undef __need_wchar_t
 #endif /* defined(__need_wchar_t) */
 
 #if defined(__need_NULL)
-#undef NULL
-#ifdef __cplusplus
-#  if !defined(__MINGW32__) && !defined(_MSC_VER)
-#    define NULL __null
-#  else
-#    define NULL 0
-#  endif
-#else
-#  define NULL ((void*)0)
-#endif
+#include <__stddef_null.h>
 #undef __need_NULL
 #endif /* defined(__need_NULL) */
 
 #if defined(__need_nullptr_t)
-#ifdef __cplusplus
-#if defined(_MSC_EXTENSIONS) && defined(_NATIVE_NULLPTR_SUPPORTED)
-namespace std {
-typedef decltype(nullptr) nullptr_t;
-}
-using ::std::nullptr_t;
-#endif
-#else
-typedef typeof(nullptr) nullptr_t;
-#endif
+#include <__stddef_nullptr_t.h>
 #undef __need_nullptr_t
 #endif /* defined(__need_nullptr_t) */
 
 #if defined(__need_unreachable)
-#define unreachable() __builtin_unreachable()
+#include <__stddef_unreachable.h>
 #undef __need_unreachable
 #endif /* defined(__need_unreachable) */
 
 #if defined(__need_max_align_t)
-#include "__stddef_max_align_t.h"
+#include <__stddef_max_align_t.h>
 #undef __need_max_align_t
 #endif /* defined(__need_max_align_t) */
 
 #if defined(__need_offsetof)
-#define offsetof(t, d) __builtin_offsetof(t, d)
+#include <__stddef_offsetof.h>
 #undef __need_offsetof
 #endif /* defined(__need_offsetof) */
 
 /* Some C libraries expect to see a wint_t here. Others (notably MinGW) will use
 __WINT_TYPE__ directly; accommodate both by requiring __need_wint_t */
 #if defined(__need_wint_t)
-/* Always define wint_t when modules are available. */
-#if !defined(_WINT_T) || __has_feature(modules)
-#if !__has_feature(modules)
-#define _WINT_T
-#endif
-typedef __WINT_TYPE__ wint_t;
-#endif
+#include <__stddef_wint_t.h>
 #undef __need_wint_t
 #endif /* __need_wint_t */
 
 #endif

clang/test/Headers/stddef.c

size_t o0 = offsetof(struct astruct, member); // c99-error{{unknown type name 'size_t'}} c99-error{{call to undeclared function 'offsetof'}} c99-error{{expected expression}} c99-error{{use of undeclared identifier 'member'}} \
                                                  c23-error{{unknown type}} c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}}
 wint_t wi0; // c99-error{{unknown type name 'wint_t'}} c11-error{{unknown type}} c23-error{{unknown type}}
 
 #include <stddef.h>
 
 ptrdiff_t p1;
 size_t s1;
 rsize_t r1; // c99-error{{unknown type}} c11-error{{unknown type}} c23-error{{unknown type}}
-            // c99-note@stddef.h:*{{'size_t' declared here}} c11-note@stddef.h:*{{'size_t' declared here}} c23-note@stddef.h:*{{'size_t' declared here}}
+            // c99-note@__stddef_size_t.h:*{{'size_t' declared here}} c11-note@__stddef_size_t.h:*{{'size_t' declared here}} c23-note@__stddef_size_t.h:*{{'size_t' declared here}}
 wchar_t wc1;
 void *v1 = NULL;
 nullptr_t n1; // c99-error{{unknown type}} c11-error{{unknown type}}
 static void f1(void) { unreachable(); } // c99-error{{undeclared function}} c11-error{{undeclared function}}
 max_align_t m1; // c99-error{{unknown type}}
 size_t o1 = offsetof(struct astruct, member);
 wint_t wi1; // c99-error{{unknown type}} c11-error{{unknown type}} c23-error{{unknown type}}
 

clang/test/Headers/stddefneeds.c

 wint_t wi1; // c99-error{{unknown type}} c23-error{{unknown type}}
 
 #define __need_size_t
 #include <stddef.h>
 
 ptrdiff_t p2;
 size_t s2;
 rsize_t r2; // c99-error{{unknown type}} c23-error{{unknown type}}
-            // c99-note@stddef.h:*{{'size_t' declared here}} c23-note@stddef.h:*{{'size_t' declared here}}
+            // c99-note@__stddef_size_t.h:*{{'size_t' declared here}} c23-note@__stddef_size_t.h:*{{'size_t' declared here}}
 wchar_t wc2; // c99-error{{unknown type}} c23-error{{unknown type}}
 void *v2 = NULL; // c99-error{{undeclared identifier}} c23-error{{undeclared identifier}}
 nullptr_t n2; // c99-error{{unknown type}} c23-error{{unknown type}}
 static void f2(void) { unreachable(); } // c99-error{{undeclared function}} c23-error{{undeclared identifier}}
 max_align_t m2; // c99-error{{unknown type}} c23-error{{unknown type}}
 size_t o2 = offsetof(struct astruct, member); // c99-error{{expected expression}} c99-error{{undeclared identifier}} \
                                                  c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}}
 wint_t wi2; // c99-error{{unknown type}} c23-error{{unknown type}}

 max_align_t m5; // c99-error{{unknown type}} c23-error{{unknown type}}
 size_t o5 = offsetof(struct astruct, member); // c99-error{{expected expression}} c99-error{{undeclared identifier}} \
                                                  c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}}
 wint_t wi5; // c99-error{{unknown type}} c23-error{{unknown type}}
 
 // __need_nullptr_t generates an error in <C23 because its definition
 // depends on nullptr.
 #define __need_nullptr_t
-#include <stddef.h> // c99-error@stddef.h:*{{expected function body}}
+#include <stddef.h> // c99-error@__stddef_nullptr_t.h:*{{expected function body}}
 
 ptrdiff_t p6;
 size_t s6;
 rsize_t r6;
 wchar_t wc6;
 void *v6 = NULL;
 nullptr_t n6; // c99-error{{unknown type}}
 static void f6(void) { unreachable(); } // c99-error{{undeclared function}} c23-error{{undeclared identifier}}

clang/test/Modules/stddef.c

 // RUN: rm -rf %t
 // RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/StdDef %s -verify -fno-modules-error-recovery
 
 #include "ptrdiff_t.h"
 
 ptrdiff_t pdt;
 
 size_t st; // expected-error {{missing '#include "include_again.h"'; 'size_t' must be declared before it is used}}
-// expected-note@stddef.h:* {{here}}
+// expected-note@__stddef_size_t.h:* {{here}}
 
 #include "include_again.h"
 
 size_t st2;

compiler-rt/lib/gwp_asan/guarded_pool_allocator.h

 #include "gwp_asan/options.h"
 #include "gwp_asan/platform_specific/guarded_pool_allocator_fuchsia.h" // IWYU pragma: keep
 #include "gwp_asan/platform_specific/guarded_pool_allocator_posix.h" // IWYU pragma: keep
 #include "gwp_asan/platform_specific/guarded_pool_allocator_tls.h"
 
 #include <stddef.h>
 #include <stdint.h>
 // IWYU pragma: no_include <__stddef_max_align_t.h>
+// IWYU pragma: no_include <__stddef_null.h>
+// IWYU pragma: no_include <__stddef_nullptr_t.h>
+// IWYU pragma: no_include <__stddef_offsetof.h>
+// IWYU pragma: no_include <__stddef_ptrdiff_t.h>
+// IWYU pragma: no_include <__stddef_rsize_t.h>
+// IWYU pragma: no_include <__stddef_size_t.h>
+// IWYU pragma: no_include <__stddef_unreachable.h>
+// IWYU pragma: no_include <__stddef_wchar_t.h>
+// IWYU pragma: no_include <__stddef_wint_t.h>
 
 namespace gwp_asan {
 // This class is the primary implementation of the allocator portion of GWP-
 // ASan. It is the sole owner of the pool of sequentially allocated guarded
 // slots. It should always be treated as a singleton.
 
 // Functions in the public interface of this class are thread-compatible until
 // init() is called, at which point they become thread-safe (unless specified

llvm/utils/gn/secondary/clang/lib/Headers/BUILD.gn

sources = [
     "__clang_cuda_math_forward_declares.h",
     "__clang_cuda_runtime_wrapper.h",
     "__clang_cuda_texture_intrinsics.h",
     "__clang_hip_cmath.h",
     "__clang_hip_libdevice_declares.h",
     "__clang_hip_math.h",
     "__clang_hip_runtime_wrapper.h",
     "__clang_hip_stdlib.h",
+    "__stdarg___gnuc_va_list.h",
+    "__stdarg___va_copy.h",
+    "__stdarg_va_arg.h",
+    "__stdarg_va_copy.h",
+    "__stdarg_va_list.h",
     "__stddef_max_align_t.h",
+    "__stddef_null.h",
+    "__stddef_nullptr_t.h",
+    "__stddef_offsetof.h",
+    "__stddef_ptrdiff_t.h",
+    "__stddef_rsize_t.h",
+    "__stddef_size_t.h",
+    "__stddef_unreachable.h",
+    "__stddef_wchar_t.h",
+    "__stddef_wint_t.h",
     "__wmmintrin_aes.h",
     "__wmmintrin_pclmul.h",
     "adxintrin.h",
     "altivec.h",
     "ammintrin.h",
     "amxcomplexintrin.h",
     "amxfp16intrin.h",
     "amxintrin.h",