[Modules] Make clang modules for the C standard library headers

[iana]

Summary

Make top level modules for all the C standard library headers.

The __stddef implementation headers need header guards now that they're all modular. stdarg.h and stddef.h will be textual headers in the builtin modules, and so need to be repeatedly included in both the system and builtin module case. Define their header guards for consistency, but ignore them when building with modules.

__stddef_null.h needs to ignore its header guard when modules aren't being used to fulfill its redefinition obligation.
__stddef_nullptr_t.h needs to add a guard for C23 so that _Builtin_stddef can compile in C17 and earlier modes. _Builtin_stddef.nullptr_t can't require C23 because it also needs to be usable from C++.

[iana]

Remove the module cache before running the stdarg/stddef unit tests in module mode

[iana]

Add @import tests for all of the new modules

clang/lib/Headers/__stddef_null.h

14

I couldn't come up with anything clever to support this in modules. If I get rid of the guard, NULL still doesn't get redefined in modules. If I move the undef to stddef.h then NULL gets undefined, but not redefined. So I think precompiled modules must inherently have #pragma once semantics. If we really had to, we could move this back into stddef.h and let it be textual, but it's distasteful that NULL gets defined in every single module that includes stddef.h and has to be merged later.

clang/test/Headers/stdarg.c

5

I think it's fine to use these same tests to validate that modules mode makes the same things visible as non-modules mode depending on the standard and set __need_ macros?

[dexonsmith]

clang/lib/Headers/__stddef_null.h

14

Modules are, in a way, stronger than #pragma once. Each module is a separate translation unit. If there's a module around __stddef_null.h, then it will only be compiled once, and any definitions imported from there. Other importing TUs get those definitions per the context the module was compiled in (they don't re-compile the code in their own context...).

It seems like a regression for NULL to degrade from ((void *)0) to 0 since it loses type safety, which is rather rare and precious in C code. Maybe this header should remain textual when deployed to platforms that rely on this dance.

[benlangmuir]

clang/lib/Headers/module.modulemap

156

Is the assumption here that directly @import _Builtin_stddef_max_align_t is unsupported so we don't need to provide a shim to keep this working?

[iana]

clang/lib/Headers/__stddef_null.h

14

Sure, but I was a little surprised that this doesn't work.

@import _Builtin_stddef.null;
undef NULL
@import _Builtin_stddef.null;
// NULL is undefined

It makes perfect sense that the module doesn't get re-compiled on the second import (and maybe not even the first), and that when it does get precompiled it doesn't see anything that the importing code did with NULL. But I am a bit surprised that re-importing the module doesn't re-expose everything from it.

I guess if we really need to, we could unifdef the module map in case some platforms need this to be textual, and then lose the guard.

clang/lib/Headers/module.modulemap

156

Yes that is the assumption, but if someone knows different please let me know!

[dexonsmith]

clang/lib/Headers/__stddef_null.h

14

Yeah, subsequent imports have no effect. I can see how it's confusing in that situation, but it's important that they are redundant.

I guess if we really need to, we could unifdef the module map in case some platforms need this to be textual, and then lose the guard.

This makes sense to me, have it be either textual or a submodule depending on configuration for the platform. Maybe someone involved in supporting clang modules on Linux has an opinion though.

[iana]

The nullptr_t submodule can't require c23 because it needs to be used in C++ in some cases too. Remove the requires from the module map and add a C23 guard to the header.

[iana]

Update Module::directlyUses

[iana]

Ah, the tests are failing because some of them are putting the builtin headers in other modules. This is going to need the "optionally ignore the builtin modules" change first then. I almost have that one finished.

[iana]

Rebase on top of D159483

[iana]

clang/lib/Headers/module.modulemap

269

Arguably this should be textual since stddef.h shouldn't own wint_t and it's just here for compatibility. Otherwise I think the ODR would force wchar.h to define need_wint and include stddef.h which is kind of weird?

[iana]

Fix formatting issue

[iana]

Rebase

[iana]

Rebase

[ldionne]

Unfortunately I am too backed up with libc++ stuff to review with the PR transition, so I'm resigning from this one.

[benlangmuir]

clang/test/Modules/Inputs/System/usr/include/stdint.h

2

Why do we need all this code now (I assume this is copied from the real header)?

[iana]

clang/test/Modules/Inputs/System/usr/include/stdint.h

2

It's to support the tests I added to Modules/compiler_builtins.m. stdatomic.h and inttypes.h rely on stdint.h contents from the C library, and on complex.h and inttypes.h and math.h being present. I could just test the modules with -ffreestanding I think, would that be better?

2

(and yes I just copied it from the builtin header)

[benlangmuir]

Other than the giant header in the test we're still discussing, this basically LGTM.

clang/test/Modules/Inputs/System/usr/include/stdint.h

2

I'm not sure what the best approach is here, but this seems heavy for a test. Do we expect to need to keep this up to date? If so maybe ffreestanding for the specific test cases this affects would be a better tradeoff. Maybe someone else has a suggestion here

[dexonsmith]

clang/test/Modules/Inputs/System/usr/include/stdint.h

2

This reflects *most* of the content in stdint.h.

One idea would be to copy the full header over during the test setup and fix it up, either:

• strip out the header/footer or
• sed -e "s/__STDC_HOSTED__/0/g"

so that it always provides content (even when not freestanding).

[iana]

clang/test/Modules/Inputs/System/usr/include/stdint.h

2

IMO it doesn't need to be that sophisticated, the types just have to exist for stdtomic.h to compile. I could chop all the comments and define everything to int and I think that'd be fine too.

[iana]

Try deleting the module cache to fix the failing tests

[iana]

Add the header guard comment to __stddef_null.h

[iana]

• Drop the -verify off the new tests so that I can get the full errors

[iana]

• Drop the -verify off the stddef tests so that I can get the full errors

[iana]

Adjust for the changes in D159483.

Mostly the header guards that were added in that review have moved to this one, the stdarg module needs to always be allowed, and a few tests needed to adjust for the stdarg/stddef implemenetation header being always modular.

[iana]

Actually allow the stdarg module

[iana]

clang/lib/Headers/module.modulemap

269

wint_t doesn't need to be textual, it can just be split out of stddef so that it doesn't get precompiled, and won't be see at all normally.

[iana]

Update clang/test/Modules/stddef.c: it doesn't need a different verify label for -fbuiltin-headers-in-system-modules, allow the diagnostic to suggest either definer of size_t, add another test to make sure that size_t still works when both declarations are seen

[vsapsai]

Still going through the patch and through the discussion. But wanted to ask if there are any complications in reverting this change? For libc++ we've discussed that we don't really know the perf impact of multiple small modules. So I want to make sure we aren't making decisions that make it impossible to revert the change later.

[iana]

In D159064#4647709, @vsapsai wrote:

Still going through the patch and through the discussion. But wanted to ask if there are any complications in reverting this change? For libc++ we've discussed that we don't really know the perf impact of multiple small modules. So I want to make sure we aren't making decisions that make it impossible to revert the change later.

I don't think we can really revert the C stdlib headers each being in their own module; there isn't any other way around the module layering maze. libc++ is a bit different, it's not just the C stdlib headers that are each in their own module, it's every one of the ~1000 headers right now. I have misgivings about that, I made D155141 to reduce that closer to 150 modules instead of 1000 but it was poorly received. I might try to address some of the concerns after I get this one worked through.

[Bigcheese]

This change looks good with the stdint.h comments resolved.

clang/test/Modules/Inputs/System/usr/include/stdint.h

2

Looking at stdatomic.h I think this approach would be fine. It just wants the types to exist.

[dexonsmith]

clang/test/Modules/Inputs/System/usr/include/stdint.h

2

SGTM.

[iana]

Minimize the testing stdint.h

[iana]

clang/test/Modules/Inputs/System/usr/include/stdint.h

2

Mostly copied clang/test/Modules/Inputs/libc-libcxx/sysroot/usr/include/stdint.h

[mib]

Hey @iana, I think this broke the lldb bot https://green.lab.llvm.org/green/view/LLDB/job/as-lldb-cmake/6698/

Can you take a look ?

clang/lib/Basic/Module.cpp

bool Module::directlyUses(const Module *Requested) {
   if (Requested->isSubModuleOf(Top))
     return true;
 
   for (auto *Use : Top->DirectUses)
     if (Requested->isSubModuleOf(Use))
       return true;
 
   // Anyone is allowed to use our builtin stddef.h and its accompanying module.
-  if (!Requested->Parent && Requested->Name == "_Builtin_stddef_max_align_t")
+  if (!Requested->Parent && Requested->Name == "_Builtin_stddef")
     return true;
 
   if (NoUndeclaredIncludes)
     UndeclaredUses.insert(Requested);
 
   return false;
 }
 

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
  *
  *===-----------------------------------------------------------------------===
  */
 
+/* See stddef.h for an explanation of builtin_headers_in_system_modules. */
+#if !defined(NULL) || __has_feature(builtin_headers_in_system_modules) ||      \
+    !__has_feature(modules)
+
+/* linux/stddef.h will define NULL to 0. glibc (and other) headers then define
+ * __need_NULL and rely on stddef.h to redefine NULL to the correct value again.
+ * Modules don't support redefining macros like that, but support that pattern
+ * in the non-modules case.
+ */
 #undef NULL
+
 #ifdef __cplusplus
 #if !defined(__MINGW32__) && !defined(_MSC_VER)
 #define NULL __null
 #else
 #define NULL 0
 #endif
 #else
 #define NULL ((void*)0)
 #endif
+
+#endif

clang/lib/Headers/__stddef_nullptr_t.h

 
 #ifdef __cplusplus
 #if defined(_MSC_EXTENSIONS) && defined(_NATIVE_NULLPTR_SUPPORTED)
 namespace std {
 typedef decltype(nullptr) nullptr_t;
 }
 using ::std::nullptr_t;
 #endif
-#else
+#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
 typedef typeof(nullptr) nullptr_t;
 #endif
 
 #endif

clang/lib/Headers/module.modulemap

explicit module systemz {
 
     explicit module zvector {
       requires zvector, vx
       header "vecintrin.h"
     }
   }
 }
 
-module _Builtin_stddef_max_align_t [system] [extern_c] {
+module _Builtin_float [system] {
+  header "float.h"
+  export *
+}
+
+module _Builtin_inttypes [system] {
+  header "inttypes.h"
+  export *
+}
+
+module _Builtin_iso646 [system] {
+  header "iso646.h"
+  export *
+}
+
+module _Builtin_limits [system] {
+  header "limits.h"
+  export *
+}
+
+module _Builtin_stdalign [system] {
+  header "stdalign.h"
+  export *
+}
+
+module _Builtin_stdarg [system] {
+  textual header "stdarg.h"
+
+  explicit module __gnuc_va_list {
+    header "__stdarg___gnuc_va_list.h"
+    export *
+  }
+
+  explicit module __va_copy {
+    header "__stdarg___va_copy.h"
+    export *
+  }
+
+  explicit module va_arg {
+    header "__stdarg_va_arg.h"
+    export *
+  }
+
+  explicit module va_copy {
+    header "__stdarg_va_copy.h"
+    export *
+  }
+
+  explicit module va_list {
+    header "__stdarg_va_list.h"
+    export *
+  }
+}
+
+module _Builtin_stdatomic [system] {
+  header "stdatomic.h"
+  export *
+}
+
+module _Builtin_stdbool [system] {
+  header "stdbool.h"
+  export *
+}
+
+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 *
+  }
+
+  explicit module nullptr_t {
+    header "__stddef_nullptr_t.h"
+    export *
+  }
+
+  explicit module offsetof {
+    header "__stddef_offsetof.h"
+    export *
+  }
+
+  explicit module ptrdiff_t {
+    header "__stddef_ptrdiff_t.h"
+    export *
+  }
+
+  explicit module rsize_t {
+    header "__stddef_rsize_t.h"
+    export *
+  }
+
+  explicit module size_t {
+    header "__stddef_size_t.h"
+    export *
+  }
+
+  explicit module unreachable {
+    header "__stddef_unreachable.h"
+    export *
+  }
+
+  explicit module wchar_t {
+    header "__stddef_wchar_t.h"
+    export *
+  }
+
+  explicit module wint_t {
+    header "__stddef_wint_t.h"
+    export *
+  }
+}
+
+module _Builtin_stdint [system] {
+  header "stdint.h"
+  export *
+}
+
+module _Builtin_stdnoreturn [system] {
+  header "stdnoreturn.h"
+  export *
+}
+
+module _Builtin_tgmath [system] {
+  header "tgmath.h"
+  export *
+}
+
+module _Builtin_unwind [system] {
+  header "unwind.h"
+  export *
 }
 
 module opencl_c {
   requires opencl
   header "opencl-c.h"
   header "opencl-c-base.h"
 }

clang/test/Headers/stdarg.c

+// RUN: rm -fR %t
 // RUN: split-file %s %t
 // RUN: %clang_cc1 -fsyntax-only -verify=c89 -Werror=implicit-function-declaration -std=c89 %t/stdarg0.c
 // RUN: %clang_cc1 -fsyntax-only -verify=c99 -Werror=implicit-function-declaration -std=c99 %t/stdarg0.c
+// RUN: %clang_cc1 -fsyntax-only -verify=c89-modules -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Werror=implicit-function-declaration -std=c89 %t/stdarg0.c
+// RUN: %clang_cc1 -fsyntax-only -verify=c99-modules -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Werror=implicit-function-declaration -std=c99 %t/stdarg0.c
 // RUN: %clang_cc1 -fsyntax-only -verify=c89 -Werror=implicit-function-declaration -std=c89 %t/stdarg1.c
 // RUN: %clang_cc1 -fsyntax-only -verify=c99 -Werror=implicit-function-declaration -std=c99 %t/stdarg1.c
+// RUN: %clang_cc1 -fsyntax-only -verify=c89-modules -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Werror=implicit-function-declaration -std=c89 %t/stdarg1.c
+// RUN: %clang_cc1 -fsyntax-only -verify=c99-modules -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Werror=implicit-function-declaration -std=c99 %t/stdarg1.c
 
 // Split the file so that the "implicitly declaring library function" errors get repeated.
 
 //--- stdarg0.c
 static void f(int p, ...) {
-    __gnuc_va_list g; // c89-error{{undeclared identifier '__gnuc_va_list'}} c99-error{{undeclared identifier}}
-    va_list v; // c89-error{{undeclared identifier 'va_list'}} c99-error{{undeclared identifier}}
+    __gnuc_va_list g; // c89-error{{undeclared identifier '__gnuc_va_list'}} c99-error{{undeclared identifier}} \
+                         c89-modules-error{{undeclared identifier}} c99-modules-error{{undeclared identifier}}
+    va_list v; // c89-error{{undeclared identifier 'va_list'}} c99-error{{undeclared identifier}} \
+                  c89-modules-error{{undeclared identifier}} c99-modules-error{{undeclared identifier}}
     va_start(v, p); // c89-error{{implicitly declaring library function 'va_start'}} c89-note{{include the header <stdarg.h> or explicitly provide a declaration for 'va_start'}} c89-error{{undeclared identifier 'v'}} \
-                       c99-error{{call to undeclared library function 'va_start'}} c99-note{{provide a declaration}} c99-error{{undeclared identifier}}
+                       c99-error{{call to undeclared library function 'va_start'}} c99-note{{provide a declaration}} c99-error{{undeclared identifier}} \
+                       c89-modules-error{{implicitly declaring library function}} c89-modules-note{{provide a declaration}} c89-modules-error{{undeclared identifier}} \
+                       c99-modules-error{{undeclared library function}} c99-modules-note{{provide a declaration}} c99-modules-error{{undeclared identifier}}
     int i = va_arg(v, int); // c89-error{{implicit declaration of function 'va_arg'}} c89-error{{expected expression}} c89-error{{use of undeclared identifier 'v'}} \
-                               c99-error{{call to undeclared function 'va_arg'}} c99-error{{expected expression}} c99-error{{undeclared identifier}}
+                               c99-error{{call to undeclared function 'va_arg'}} c99-error{{expected expression}} c99-error{{undeclared identifier}} \
+                               c89-modules-error{{implicit declaration of function}} c89-modules-error{{expected expression}} c89-modules-error{{undeclared identifier}} \
+                               c99-modules-error{{undeclared function}} c99-modules-error{{expected expression}} c99-modules-error{{undeclared identifier}}
     va_end(v); // c89-error{{implicitly declaring library function 'va_end'}} c89-note{{include the header <stdarg.h> or explicitly provide a declaration for 'va_end'}} c89-error{{undeclared identifier 'v'}} \
-                  c99-error{{call to undeclared library function 'va_end'}} c99-note{{provide a declaration}} c99-error{{undeclared identifier}}
+                  c99-error{{call to undeclared library function 'va_end'}} c99-note{{provide a declaration}} c99-error{{undeclared identifier}} \
+                  c89-modules-error{{implicitly declaring library function}} c89-modules-note{{provide a declaration}} c89-modules-error{{undeclared identifier}} \
+                  c99-modules-error{{undeclared library function}} c99-modules-note{{provide a declaration}} c99-modules-error{{undeclared identifier}}
     __va_copy(g, v); // c89-error{{implicit declaration of function '__va_copy'}} c89-error{{use of undeclared identifier 'g'}} c89-error{{use of undeclared identifier 'v'}} \
-                        c99-error{{call to undeclared function '__va_copy'}} c99-error{{undeclared identifier}} c99-error{{undeclared identifier}}
+                        c99-error{{call to undeclared function '__va_copy'}} c99-error{{undeclared identifier}} c99-error{{undeclared identifier}} \
+                        c89-modules-error{{implicit declaration of function}} c89-modules-error{{undeclared identifier}} c89-modules-error{{undeclared identifier}} \
+                        c99-modules-error{{undeclared function}} c99-modules-error{{undeclared identifier}} c99-modules-error{{undeclared identifier}}
     va_copy(g, v); // c89-error{{implicitly declaring library function 'va_copy'}} c89-note{{include the header <stdarg.h> or explicitly provide a declaration for 'va_copy'}} c89-error{{use of undeclared identifier 'g'}} c89-error{{use of undeclared identifier 'v'}} \
-                      c99-error{{call to undeclared library function 'va_copy'}} c99-note{{provide a declaration}} c99-error{{undeclared identifier}} c99-error{{undeclared identifier}}
+                      c99-error{{call to undeclared library function 'va_copy'}} c99-note{{provide a declaration}} c99-error{{undeclared identifier}} c99-error{{undeclared identifier}} \
+                      c89-modules-error{{implicitly declaring library function}} c89-modules-note{{provide a declaration}} c89-modules-error{{undeclared identifier}} c89-modules-error{{undeclared identifier}} \
+                      c99-modules-error{{undeclared library function}} c99-modules-note{{provide a declaration}} c99-modules-error{{undeclared identifier}} c99-modules-error{{undeclared identifier}}
 }
 
 //--- stdarg1.c
 // c99-no-diagnostics
+// c99-modules-no-diagnostics
 
 #include <stdarg.h>
 static void f(int p, ...) {
     __gnuc_va_list g;
     va_list v;
     va_start(v, p);
     int i = va_arg(v, int);
     va_end(v);
     __va_copy(g, v);
-    va_copy(g, v); // c89-error{{implicitly declaring library function}} c89-note{{provide a declaration}}
+    va_copy(g, v); // c89-error{{implicitly declaring library function}} c89-note{{provide a declaration}} \
+                      c89-modules-error{{implicitly declaring library function}} c89-modules-note{{provide a declaration}}
 }

clang/test/Headers/stdargneeds.c

+// RUN: rm -fR %t
 // RUN: split-file %s %t
 // RUN: %clang_cc1 -fsyntax-only -verify -Werror=implicit-function-declaration -std=c89 %t/stdargneeds0.c
+// RUN: %clang_cc1 -fsyntax-only -verify=expected-modules -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Werror=implicit-function-declaration -std=c89 %t/stdargneeds0.c
 // RUN: %clang_cc1 -fsyntax-only -verify -Werror=implicit-function-declaration -std=c89 %t/stdargneeds1.c
+// RUN: %clang_cc1 -fsyntax-only -verify=expected-modules -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Werror=implicit-function-declaration -std=c89 %t/stdargneeds1.c
 // RUN: %clang_cc1 -fsyntax-only -verify -Werror=implicit-function-declaration -std=c89 %t/stdargneeds2.c
+// RUN: %clang_cc1 -fsyntax-only -verify=expected-modules -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Werror=implicit-function-declaration -std=c89 %t/stdargneeds2.c
 // RUN: %clang_cc1 -fsyntax-only -verify -Werror=implicit-function-declaration -std=c89 %t/stdargneeds3.c
+// RUN: %clang_cc1 -fsyntax-only -verify=expected-modules -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Werror=implicit-function-declaration -std=c89 %t/stdargneeds3.c
 // RUN: %clang_cc1 -fsyntax-only -verify -Werror=implicit-function-declaration -std=c89 %t/stdargneeds4.c
+// RUN: %clang_cc1 -fsyntax-only -verify=expected-modules -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Werror=implicit-function-declaration -std=c89 %t/stdargneeds4.c
 // RUN: %clang_cc1 -fsyntax-only -verify -Werror=implicit-function-declaration -std=c89 %t/stdargneeds5.c
+// RUN: %clang_cc1 -fsyntax-only -verify=expected-modules -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Werror=implicit-function-declaration -std=c89 %t/stdargneeds5.c
 
 // Split the file so that the "implicitly declaring library function" errors get repeated.
 // Use C89 to verify that __need_ can be used to get types that wouldn't normally be available.
 
 //--- stdargneeds0.c
 static void f(int p, ...) {
-    __gnuc_va_list g; // expected-error{{undeclared identifier '__gnuc_va_list'}}
-    va_list v; // expected-error{{undeclared identifier 'va_list'}}
-    va_start(v, p); // expected-error{{implicitly declaring library function 'va_start'}} expected-note{{include the header <stdarg.h> or explicitly provide a declaration for 'va_start'}} expected-error{{undeclared identifier 'v'}}
-    int i = va_arg(v, int); // expected-error{{implicit declaration of function 'va_arg'}} expected-error{{expected expression}} expected-error{{use of undeclared identifier 'v'}}
-    va_end(v); // expected-error{{implicitly declaring library function 'va_end'}} expected-note{{include the header <stdarg.h> or explicitly provide a declaration for 'va_end'}} expected-error{{undeclared identifier 'v'}}
-    __va_copy(g, v); // expected-error{{implicit declaration of function '__va_copy'}} expected-error{{use of undeclared identifier 'g'}} expected-error{{use of undeclared identifier 'v'}}
-    va_copy(g, v); // expected-error{{implicitly declaring library function 'va_copy'}} expected-note{{include the header <stdarg.h> or explicitly provide a declaration for 'va_copy'}} expected-error{{use of undeclared identifier 'g'}} expected-error{{use of undeclared identifier 'v'}}
+    __gnuc_va_list g; // expected-error{{undeclared identifier '__gnuc_va_list'}} expected-modules-error{{undeclared identifier}}
+    va_list v; // expected-error{{undeclared identifier 'va_list'}} expected-modules-error{{undeclared identifier}}
+    va_start(v, p); // expected-error{{implicitly declaring library function 'va_start'}} expected-note{{include the header <stdarg.h> or explicitly provide a declaration for 'va_start'}} expected-error{{undeclared identifier 'v'}} \
+                       expected-modules-error{{implicitly declaring library function}} expected-modules-note{{provide a declaration}} expected-modules-error{{undeclared identifier}}
+    int i = va_arg(v, int); // expected-error{{implicit declaration of function 'va_arg'}} expected-error{{expected expression}} expected-error{{use of undeclared identifier 'v'}} \
+                               expected-modules-error{{implicit declaration of function}} expected-modules-error{{expected expression}} expected-modules-error{{undeclared identifier}}
+    va_end(v); // expected-error{{implicitly declaring library function 'va_end'}} expected-note{{include the header <stdarg.h> or explicitly provide a declaration for 'va_end'}} expected-error{{undeclared identifier 'v'}} \
+                  expected-modules-error{{implicitly declaring library function}} expected-modules-note{{provide a declaration}} expected-modules-error{{undeclared identifier}}
+    __va_copy(g, v); // expected-error{{implicit declaration of function '__va_copy'}} expected-error{{use of undeclared identifier 'g'}} expected-error{{use of undeclared identifier 'v'}} \
+                        expected-modules-error{{implicit declaration of function}} expected-modules-error{{undeclared identifier}} expected-modules-error{{undeclared identifier}}
+    va_copy(g, v); // expected-error{{implicitly declaring library function 'va_copy'}} expected-note{{include the header <stdarg.h> or explicitly provide a declaration for 'va_copy'}} expected-error{{use of undeclared identifier 'g'}} expected-error{{use of undeclared identifier 'v'}} \
+                      expected-modules-error{{implicitly declaring library function}} expected-modules-note{{provide a declaration}} expected-modules-error{{undeclared identifier}} expected-modules-error{{undeclared identifier}}
 }
 
 //--- stdargneeds1.c
 #define __need___va_list
 #include <stdarg.h>
 static void f(int p, ...) {
     __gnuc_va_list g;
-    va_list v; // expected-error{{undeclared identifier}}
-    va_start(v, p); // expected-error{{implicitly declaring library function}} expected-note{{provide a declaration}} expected-error{{undeclared identifier}}
-    int i = va_arg(v, int); // expected-error{{implicit declaration of function}} expected-error{{expected expression}} expected-error{{undeclared identifier}}
-    va_end(v); // expected-error{{implicitly declaring library function}} expected-note{{provide a declaration}} expected-error{{undeclared identifier}}
-    __va_copy(g, v); // expected-error{{implicit declaration of function}} expected-error{{undeclared identifier}}
-    va_copy(g, v); // expected-error{{implicitly declaring library function}} expected-note{{provide a declaration}} expected-error{{undeclared identifier}}
+    va_list v; // expected-error{{undeclared identifier}} \
+                  expected-modules-error{{'va_list' must be declared before it is used}} expected-modules-note@__stdarg_va_list.h:*{{declaration here is not visible}}
+    va_start(v, p); // expected-error{{implicitly declaring library function}} expected-note{{provide a declaration}} expected-error{{undeclared identifier}} \
+                       expected-modules-error{{implicitly declaring library function}} expected-modules-note{{provide a declaration}}
+    int i = va_arg(v, int); // expected-error{{implicit declaration of function}} expected-error{{expected expression}} expected-error{{undeclared identifier}} \
+                               expected-modules-error{{implicit declaration of function}} expected-modules-error{{expected expression}}
+    va_end(v); // expected-error{{implicitly declaring library function}} expected-note{{provide a declaration}} expected-error{{undeclared identifier}} \
+                  expected-modules-error{{implicitly declaring library function}} expected-modules-note{{provide a declaration}}
+    __va_copy(g, v); // expected-error{{implicit declaration of function}} expected-error{{undeclared identifier}} \
+                        expected-modules-error{{implicit declaration of function}}
+    va_copy(g, v); // expected-error{{implicitly declaring library function}} expected-note{{provide a declaration}} expected-error{{undeclared identifier}} \
+                      expected-modules-error{{implicitly declaring library function}} expected-modules-note{{provide a declaration}}
 }
 
 //--- stdargneeds2.c
 #define __need_va_list
 #include <stdarg.h>
 static void f(int p, ...) {
-    __gnuc_va_list g; // expected-error{{undeclared identifier}}
+    __gnuc_va_list g; // expected-error{{undeclared identifier}} \
+                         expected-modules-error{{'__gnuc_va_list' must be declared before it is used}} expected-modules-note@__stdarg___gnuc_va_list.h:*{{declaration here is not visible}}
     va_list v;
-    va_start(v, p); // expected-error{{implicitly declaring library function}} expected-note{{provide a declaration}}
-    int i = va_arg(v, int); // expected-error{{implicit declaration of function}} expected-error{{expected expression}}
-    va_end(v); // expected-error{{implicitly declaring library function}} expected-note{{provide a declaration}}
-    __va_copy(g, v); // expected-error{{implicit declaration of function}} expected-error{{undeclared identifier}}
-    va_copy(g, v); // expected-error{{implicitly declaring library function}} expected-note{{provide a declaration}} expected-error{{undeclared identifier}}
+    va_start(v, p); // expected-error{{implicitly declaring library function}} expected-note{{provide a declaration}} \
+                       expected-modules-error{{implicitly declaring library function}} expected-modules-note{{provide a declaration}}
+    int i = va_arg(v, int); // expected-error{{implicit declaration of function}} expected-error{{expected expression}} \
+                               expected-modules-error{{implicit declaration of function}} expected-modules-error{{expected expression}}
+    va_end(v); // expected-error{{implicitly declaring library function}} expected-note{{provide a declaration}} \
+                  expected-modules-error{{implicitly declaring library function}} expected-modules-note{{provide a declaration}}
+    __va_copy(g, v); // expected-error{{implicit declaration of function}} expected-error{{undeclared identifier}} \
+                        expected-modules-error{{implicit declaration of function}}
+    va_copy(g, v); // expected-error{{implicitly declaring library function}} expected-note{{provide a declaration}} expected-error{{undeclared identifier}} \
+                      expected-modules-error{{implicitly declaring library function}} expected-modules-note{{provide a declaration}}
 }
 
 //--- stdargneeds3.c
 #define __need_va_list
 #define __need_va_arg
 #include <stdarg.h>
 static void f(int p, ...) {
-    __gnuc_va_list g; // expected-error{{undeclared identifier}}
+    __gnuc_va_list g; // expected-error{{undeclared identifier}} \
+                         expected-modules-error{{'__gnuc_va_list' must be declared before it is used}} expected-modules-note@__stdarg___gnuc_va_list.h:*{{declaration here is not visible}}
     va_list v;
     va_start(v, p);
     int i = va_arg(v, int);
     va_end(v);
-    __va_copy(g, v); // expected-error{{implicit declaration of function}} expected-error{{undeclared identifier}}
-    va_copy(g, v); // expected-error{{implicitly declaring library function}} expected-note{{provide a declaration}} expected-error{{undeclared identifier}}
+    __va_copy(g, v); // expected-error{{implicit declaration of function}} expected-error{{undeclared identifier}} \
+                        expected-modules-error{{implicit declaration of function}}
+    va_copy(g, v); // expected-error{{implicitly declaring library function}} expected-note{{provide a declaration}} expected-error{{undeclared identifier}} \
+                      expected-modules-error{{implicitly declaring library function}} expected-modules-note{{provide a declaration}}
 }
 
 //--- stdargneeds4.c
 #define __need___va_list
 #define __need_va_list
 #define __need___va_copy
 #include <stdarg.h>
 static void f(int p, ...) {
     __gnuc_va_list g;
     va_list v;
-    va_start(v, p); // expected-error{{implicitly declaring library function}} expected-note{{provide a declaration}}
-    int i = va_arg(v, int); // expected-error{{implicit declaration of function}} expected-error{{expected expression}}
-    va_end(v); // expected-error{{implicitly declaring library function}} expected-note{{provide a declaration}}
+    va_start(v, p); // expected-error{{implicitly declaring library function}} expected-note{{provide a declaration}} \
+                       expected-modules-error{{implicitly declaring library function}} expected-modules-note{{provide a declaration}}
+    int i = va_arg(v, int); // expected-error{{implicit declaration of function}} expected-error{{expected expression}} \
+                               expected-modules-error{{implicit declaration of function}} expected-modules-error{{expected expression}}
+    va_end(v); // expected-error{{implicitly declaring library function}} expected-note{{provide a declaration}} \
+                  expected-modules-error{{implicitly declaring library function}} expected-modules-note{{provide a declaration}}
     __va_copy(g, v);
-    va_copy(g, v); // expected-error{{implicitly declaring library function}} expected-note{{provide a declaration}}
+    va_copy(g, v); // expected-error{{implicitly declaring library function}} expected-note{{provide a declaration}} \
+                      expected-modules-error{{implicitly declaring library function}} expected-modules-note{{provide a declaration}}
 }
 
 //--- stdargneeds5.c
 #define __need___va_list
 #define __need_va_list
 #define __need_va_copy
 #include <stdarg.h>
 static void f(int p, ...) {
     __gnuc_va_list g;
     va_list v;
-    va_start(v, p); // expected-error{{implicitly declaring library function}} expected-note{{provide a declaration}}
-    int i = va_arg(v, int); // expected-error{{implicit declaration of function}} expected-error{{expected expression}}
-    va_end(v); // expected-error{{implicitly declaring library function}} expected-note{{provide a declaration}}
-    __va_copy(g, v); // expected-error{{implicit declaration of function}}
+    va_start(v, p); // expected-error{{implicitly declaring library function}} expected-note{{provide a declaration}} \
+                       expected-modules-error{{implicitly declaring library function}} expected-modules-note{{provide a declaration}}
+    int i = va_arg(v, int); // expected-error{{implicit declaration of function}} expected-error{{expected expression}} \
+                               expected-modules-error{{implicit declaration of function}} expected-modules-error{{expected expression}}
+    va_end(v); // expected-error{{implicitly declaring library function}} expected-note{{provide a declaration}} \
+                  expected-modules-error{{implicitly declaring library function}} expected-modules-note{{provide a declaration}}
+    __va_copy(g, v); // expected-error{{implicit declaration of function}} expected-modules-error{{implicit declaration of function}}
     va_copy(g, v);
 }

clang/test/Headers/stddef.c

+// RUN: rm -fR %t
 // RUN: %clang_cc1 -fsyntax-only -verify=c99 -std=c99 %s
 // RUN: %clang_cc1 -fsyntax-only -verify=c11 -std=c11 %s
 // RUN: %clang_cc1 -fsyntax-only -verify=c23 -std=c23 %s
+// RUN: %clang_cc1 -fsyntax-only -verify=c99-modules -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -std=c99 %s
+// RUN: %clang_cc1 -fsyntax-only -verify=c11-modules -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -std=c11 %s
+// RUN: %clang_cc1 -fsyntax-only -verify=c23-modules -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -std=c23 %s
 
 struct astruct { char member; };
 
-ptrdiff_t p0; // c99-error{{unknown type name 'ptrdiff_t'}} c11-error{{unknown type}} c23-error{{unknown type}}
-size_t s0; // c99-error{{unknown type name 'size_t'}} c11-error{{unknown type}} c23-error{{unknown type}}
-rsize_t r0; // c99-error{{unknown type name 'rsize_t'}} c11-error{{unknown type}} c23-error{{unknown type}}
-wchar_t wc0; // c99-error{{unknown type name 'wchar_t'}} c11-error{{unknown type}} c23-error{{unknown type}}
-void *v0 = NULL; // c99-error{{use of undeclared identifier 'NULL'}} c11-error{{undeclared identifier}} c23-error{{undeclared identifier}}
-nullptr_t n0; // c99-error{{unknown type name 'nullptr_t'}} c11-error{{unknown type}} c23-error{{unknown type}}
-static void f0(void) { unreachable(); } // c99-error{{call to undeclared function 'unreachable'}} c11-error{{undeclared function}} c23-error{{undeclared identifier}}
-max_align_t m0; // c99-error{{unknown type name 'max_align_t'}} c11-error{{unknown type}} c23-error{{unknown type}}
+ptrdiff_t p0; // c99-error{{unknown type name 'ptrdiff_t'}} c11-error{{unknown type}} c23-error{{unknown type}} \
+                 c99-modules-error{{unknown type}} c11-modules-error{{unknown type}} c23-modules-error{{unknown type}}
+size_t s0; // c99-error{{unknown type name 'size_t'}} c11-error{{unknown type}} c23-error{{unknown type}} \
+              c99-modules-error{{unknown type}} c11-modules-error{{unknown type}} c23-modules-error{{unknown type}}
+rsize_t r0; // c99-error{{unknown type name 'rsize_t'}} c11-error{{unknown type}} c23-error{{unknown type}} \
+               c99-modules-error{{unknown type}} c11-modules-error{{unknown type}} c23-modules-error{{unknown type}}
+wchar_t wc0; // c99-error{{unknown type name 'wchar_t'}} c11-error{{unknown type}} c23-error{{unknown type}} \
+                c99-modules-error{{unknown type}} c11-modules-error{{unknown type}} c23-modules-error{{unknown type}}
+void *v0 = NULL; // c99-error{{use of undeclared identifier 'NULL'}} c11-error{{undeclared identifier}} c23-error{{undeclared identifier}} \
+                    c99-modules-error{{undeclared identifier}} c11-modules-error{{undeclared identifier}} c23-modules-error{{undeclared identifier}}
+nullptr_t n0; // c99-error{{unknown type name 'nullptr_t'}} c11-error{{unknown type}} c23-error{{unknown type}} \
+                 c99-modules-error{{unknown type}} c11-modules-error{{unknown type}} c23-modules-error{{unknown type}}
+static void f0(void) { unreachable(); } // c99-error{{call to undeclared function 'unreachable'}} c11-error{{undeclared function}} c23-error{{undeclared identifier}} \
+                                           c99-modules-error{{undeclared function}} c11-modules-error{{undeclared function}} c23-modules-error{{undeclared identifier}}
+max_align_t m0; // c99-error{{unknown type name 'max_align_t'}} c11-error{{unknown type}} c23-error{{unknown type}} \
+                   c99-modules-error{{unknown type}} c11-modules-error{{unknown type}} c23-modules-error{{unknown type}}
 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'}} \
                                                  c11-error{{unknown type}} c11-error{{undeclared function}} c11-error{{expected expression}} c11-error{{undeclared identifier}} \
-                                                 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}}
+                                                 c23-error{{unknown type}} c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}} \
+                                                 c99-modules-error{{unknown type}} c99-modules-error{{undeclared function}} c99-modules-error{{expected expression}} c99-modules-error{{undeclared identifier}} \
+                                                 c11-modules-error{{unknown type}} c11-modules-error{{undeclared function}} c11-modules-error{{expected expression}} c11-modules-error{{undeclared identifier}} \
+                                                 c23-modules-error{{unknown type}} c23-modules-error{{undeclared identifier}} c23-modules-error{{expected expression}} c23-modules-error{{undeclared identifier}}
+wint_t wi0; // c99-error{{unknown type name 'wint_t'}} c11-error{{unknown type}} c23-error{{unknown type}} \
+               c99-modules-error{{unknown type name 'wint_t'}} c11-modules-error{{unknown type}} c23-modules-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_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}}
+rsize_t r1; // c99-error{{unknown type}} c11-error{{unknown type}} c23-error{{unknown type}} \
+               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}} \
+               c99-modules-error{{'rsize_t' must be declared before it is used}} c11-modules-error{{must be declared}} c23-modules-error{{must be declared}} \
+               c99-modules-note@__stddef_rsize_t.h:*{{declaration here is not visible}} c11-modules-note@__stddef_rsize_t.h:*{{declaration here is not visible}} c23-modules-note@__stddef_rsize_t.h:*{{declaration here is not visible}}
 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}}
+nullptr_t n1; // c99-error{{unknown type}} c11-error{{unknown type}} \
+                 c99-modules-error{{unknown type}} c11-modules-error{{unknown type}}
+static void f1(void) { unreachable(); } // c99-error{{undeclared function}} c11-error{{undeclared function}} \
+                                           c99-modules-error{{undeclared function}} c11-modules-error{{undeclared function}}
+max_align_t m1; // c99-error{{unknown type}} c99-modules-error{{'max_align_t' must be declared before it is used}} \
+                   c99-modules-note@__stddef_max_align_t.h:*{{declaration here is not visible}}
 size_t o1 = offsetof(struct astruct, member);
-wint_t wi1; // c99-error{{unknown type}} c11-error{{unknown type}} c23-error{{unknown type}}
+wint_t wi1; // c99-error{{unknown type}} c11-error{{unknown type}} c23-error{{unknown type}} \
+               c99-modules-error{{'wint_t' must be declared before it is used}} c11-modules-error{{must be declared}} c23-modules-error{{must be declared}}
 
 // rsize_t needs to be opted into via __STDC_WANT_LIB_EXT1__ >= 1.
 #define __STDC_WANT_LIB_EXT1__ 1
 #include <stddef.h>
 ptrdiff_t p2;
 size_t s2;
 rsize_t r2;
 wchar_t wc2;
 void *v2 = NULL;
-nullptr_t n2; // c99-error{{unknown type}} c11-error{{unknown type}}
-static void f2(void) { unreachable(); } // c99-error{{undeclared function}} c11-error{{undeclared function}}
+nullptr_t n2; // c99-error{{unknown type}} c11-error{{unknown type}} \
+                 c99-modules-error{{unknown type}} c11-modules-error{{unknown type}}
+static void f2(void) { unreachable(); } // c99-error{{undeclared function}} c11-error{{undeclared function}} \
+                                           c99-modules-error{{undeclared function}} c11-modules-error{{undeclared function}}
 max_align_t m2; // c99-error{{unknown type}}
 size_t o2 = offsetof(struct astruct, member);
-wint_t wi2; // c99-error{{unknown type}} c11-error{{unknown type}} c23-error{{unknown type}}
+wint_t wi2; // c99-error{{unknown type}} c11-error{{unknown type}} c23-error{{unknown type}} \
+               c99-modules-note@__stddef_wint_t.h:*{{declaration here is not visible}} c11-modules-note@__stddef_wint_t.h:*{{declaration here is not visible}} c23-modules-note@__stddef_wint_t.h:*{{declaration here is not visible}}
+
+// m2 and wi2 don't generate errors in modules, the "must be declared before used"
+// errors are only emitted the first time the known-but-not-visible type is seen.

clang/test/Headers/stddefneeds.c

+// RUN: rm -fR %t
 // RUN: %clang_cc1 -fsyntax-only -verify=c99 -std=c99 %s
 // RUN: %clang_cc1 -fsyntax-only -verify=c23 -std=c23 %s
+// RUN: %clang_cc1 -fsyntax-only -verify=c99-modules -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -std=c99 %s
+// RUN: %clang_cc1 -fsyntax-only -verify=c23-modules -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -std=c23 %s
 
 // Use C99 to verify that __need_ can be used to get types that wouldn't normally be available.
 
 struct astruct { char member; };
 
-ptrdiff_t p0; // c99-error{{unknown type name 'ptrdiff_t'}} c23-error{{unknown type}}
-size_t s0; // c99-error{{unknown type name 'size_t'}} c23-error{{unknown type}}
-rsize_t r0; // c99-error{{unknown type name 'rsize_t'}} c23-error{{unknown type}}
-wchar_t wc0; // c99-error{{unknown type name 'wchar_t'}} c23-error{{unknown type}}
-void *v0 = NULL; // c99-error{{use of undeclared identifier 'NULL'}} c23-error{{undeclared identifier}}
-nullptr_t n0; // c99-error{{unknown type name 'nullptr_t'}} c23-error{{unknown type}}
-static void f0(void) { unreachable(); } // c99-error{{call to undeclared function 'unreachable'}} c23-error{{undeclared identifier 'unreachable'}}
-max_align_t m0; // c99-error{{unknown type name 'max_align_t'}} c23-error{{unknown type}}
+ptrdiff_t p0; // c99-error{{unknown type name 'ptrdiff_t'}} c23-error{{unknown type}} \
+                 c99-modules-error{{unknown type}} c23-modules-error{{unknown type}}
+size_t s0; // c99-error{{unknown type name 'size_t'}} c23-error{{unknown type}} \
+              c99-modules-error{{unknown type}} c23-modules-error{{unknown type}}
+rsize_t r0; // c99-error{{unknown type name 'rsize_t'}} c23-error{{unknown type}} \
+               c99-modules-error{{unknown type}} c23-modules-error{{unknown type}}
+wchar_t wc0; // c99-error{{unknown type name 'wchar_t'}} c23-error{{unknown type}} \
+                c99-modules-error{{unknown type}} c23-modules-error{{unknown type}}
+void *v0 = NULL; // c99-error{{use of undeclared identifier 'NULL'}} c23-error{{undeclared identifier}} \
+                    c99-modules-error{{undeclared identifier}} c23-modules-error{{undeclared identifier}}
+nullptr_t n0; // c99-error{{unknown type name 'nullptr_t'}} c23-error{{unknown type}} \
+                 c99-modules-error{{unknown type}} c23-modules-error{{unknown type}}
+static void f0(void) { unreachable(); } // c99-error{{call to undeclared function 'unreachable'}} c23-error{{undeclared identifier 'unreachable'}} \
+                                           c99-modules-error{{undeclared function}} c23-modules-error{{undeclared identifier}}
+max_align_t m0; // c99-error{{unknown type name 'max_align_t'}} c23-error{{unknown type}} \
+                   c99-modules-error{{unknown type}} c23-modules-error{{unknown type}}
 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 name 'size_t'}} c23-error{{undeclared identifier 'offsetof'}} c23-error{{expected expression}} c23-error{{use of undeclared identifier 'member'}}
-wint_t wi0; // c99-error{{unknown type name 'wint_t'}} c23-error{{unknown type}}
+                                                 c23-error{{unknown type name 'size_t'}} c23-error{{undeclared identifier 'offsetof'}} c23-error{{expected expression}} c23-error{{use of undeclared identifier 'member'}} \
+                                                 c99-modules-error{{unknown type}} c99-modules-error{{undeclared function}} c99-modules-error{{expected expression}} c99-modules-error{{undeclared identifier}} \
+                                                 c23-modules-error{{unknown type}} c23-modules-error{{undeclared identifier}} c23-modules-error{{expected expression}} c23-modules-error{{undeclared identifier}}
+wint_t wi0; // c99-error{{unknown type name 'wint_t'}} c23-error{{unknown type}} \
+               c99-modules-error{{unknown type}} c23-modules-error{{unknown type}}
 
 #define __need_ptrdiff_t
 #include <stddef.h>
 
 ptrdiff_t p1;
-size_t s1; // c99-error{{unknown type}} c23-error{{unknown type}}
-rsize_t r1; // c99-error{{unknown type}} c23-error{{unknown type}}
-wchar_t wc1; // c99-error{{unknown type}} c23-error{{unknown type}}
-void *v1 = NULL; // c99-error{{undeclared identifier}} c23-error{{undeclared identifier}}
-nullptr_t n1; // c99-error{{unknown type}} c23-error{{unknown type}}
-static void f1(void) { unreachable(); } // c99-error{{undeclared function}} c23-error{{undeclared identifier}}
-max_align_t m1; // c99-error{{unknown type}} c23-error{{unknown type}}
+size_t s1; // c99-error{{unknown type}} c23-error{{unknown type}} \
+              c99-modules-error{{'size_t' must be declared before it is used}} c23-modules-error{{must be declared}} \
+              c99-modules-note@__stddef_size_t.h:*{{declaration here is not visible}} c23-modules-note@__stddef_size_t.h:*{{declaration here is not visible}}
+rsize_t r1; // c99-error{{unknown type}} c23-error{{unknown type}} \
+               c99-modules-error{{'rsize_t' must be declared before it is used}} c23-modules-error{{must be declared}} \
+               c99-modules-note@__stddef_rsize_t.h:*{{declaration here is not visible}} c23-modules-note@__stddef_rsize_t.h:*{{declaration here is not visible}}
+wchar_t wc1; // c99-error{{unknown type}} c23-error{{unknown type}} \
+                c99-modules-error{{'wchar_t' must be declared before it is used}} c23-modules-error{{must be declared}} \
+                c99-modules-note@__stddef_wchar_t.h:*{{declaration here is not visible}} c23-modules-note@__stddef_wchar_t.h:*{{declaration here is not visible}}
+void *v1 = NULL; // c99-error{{undeclared identifier}} c23-error{{undeclared identifier}} \
+                    c99-modules-error{{undeclared identifier}} c23-modules-error{{undeclared identifier}}
+nullptr_t n1; // c99-error{{unknown type}} c23-error{{unknown type}} \
+                 c99-modules-error{{unknown type}} c23-modules-error{{'nullptr_t' must be declared before it is used}} \
+                 c23-modules-note@__stddef_nullptr_t.h:*{{declaration here is not visible}}
+static void f1(void) { unreachable(); } // c99-error{{undeclared function}} c23-error{{undeclared identifier}} \
+                                           c99-modules-error{{undeclared function}} c23-modules-error{{undeclared identifier}}
+max_align_t m1; // c99-error{{unknown type}} c23-error{{unknown type}} \
+                   c99-modules-error{{'max_align_t' must be declared before it is used}} c23-modules-error{{must be declared}} \
+                   c99-modules-note@__stddef_max_align_t.h:*{{declaration here is not visible}} c23-modules-note@__stddef_max_align_t.h:*{{declaration here is not visible}}
 size_t o1 = offsetof(struct astruct, member); // c99-error{{unknown type}} c99-error{{expected expression}} c99-error{{undeclared identifier}} \
-                                                 c23-error{{unknown type}} c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}}
-wint_t wi1; // c99-error{{unknown type}} c23-error{{unknown type}}
+                                                 c23-error{{unknown type}} c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}} \
+                                                 c99-modules-error{{expected expression}} c99-modules-error{{undeclared identifier}} \
+                                                 c23-modules-error{{undeclared identifier}} c23-modules-error{{expected expression}} c23-modules-error{{undeclared identifier}}
+wint_t wi1; // c99-error{{unknown type}} c23-error{{unknown type}} \
+               c99-modules-error{{'wint_t' must be declared before it is used}} c23-modules-error{{must be declared}} \
+               c99-modules-note@__stddef_wint_t.h:*{{declaration here is not visible}} c23-modules-note@__stddef_wint_t.h:*{{declaration here is not visible}}
+
+// The "must be declared before used" errors are only emitted the first time a
+// known-but-not-visible type is seen. At this point the _Builtin_stddef module
+// has been built and all of the types tried, so most of the errors won't be
+// repeated below in modules. The types still aren't available, just the errors
+// aren't repeated. e.g. rsize_t still isn't available, if r1 above got deleted,
+// its error would move to r2 below.
 
 #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_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}}
+void *v2 = NULL; // c99-error{{undeclared identifier}} c23-error{{undeclared identifier}} \
+                    c99-modules-error{{undeclared identifier}} c23-modules-error{{undeclared identifier}}
+nullptr_t n2; // c99-error{{unknown type}} c23-error{{unknown type}} \
+                 c99-modules-error{{unknown type}}
+static void f2(void) { unreachable(); } // c99-error{{undeclared function}} c23-error{{undeclared identifier}} \
+                                           c99-modules-error{{undeclared function}} c23-modules-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}}
+                                                 c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}} \
+                                                 c99-modules-error{{expected expression}} c99-modules-error{{undeclared identifier}} \
+                                                 c23-modules-error{{undeclared identifier}} c23-modules-error{{expected expression}} c23-modules-error{{undeclared identifier}}
 wint_t wi2; // c99-error{{unknown type}} c23-error{{unknown type}}
 
 #define __need_rsize_t
 #include <stddef.h>
 
 ptrdiff_t p3;
 size_t s3;
 rsize_t r3;
 wchar_t wc3; // c99-error{{unknown type}} c23-error{{unknown type}}
-void *v3 = NULL; // c99-error{{undeclared identifier}} c23-error{{undeclared identifier}}
-nullptr_t n3; // c99-error{{unknown type}} c23-error{{unknown type}}
-static void f3(void) { unreachable(); } // c99-error{{undeclared function}} c23-error{{undeclared identifier}}
+void *v3 = NULL; // c99-error{{undeclared identifier}} c23-error{{undeclared identifier}} \
+                    c99-modules-error{{undeclared identifier}} c23-modules-error{{undeclared identifier}}
+nullptr_t n3; // c99-error{{unknown type}} c23-error{{unknown type}} \
+                 c99-modules-error{{unknown type}}
+static void f3(void) { unreachable(); } // c99-error{{undeclared function}} c23-error{{undeclared identifier}} \
+                                           c99-modules-error{{undeclared function}} c23-modules-error{{undeclared identifier}}
 max_align_t m3; // c99-error{{unknown type}} c23-error{{unknown type}}
 size_t o3 = offsetof(struct astruct, member); // c99-error{{expected expression}} c99-error{{undeclared identifier}} \
-                                                 c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}}
+                                                 c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}} \
+                                                 c99-modules-error{{expected expression}} c99-modules-error{{undeclared identifier}} \
+                                                 c23-modules-error{{undeclared identifier}} c23-modules-error{{expected expression}} c23-modules-error{{undeclared identifier}}
 wint_t wi3; // c99-error{{unknown type}} c23-error{{unknown type}}
 
 #define __need_wchar_t
 #include <stddef.h>
 
 ptrdiff_t p4;
 size_t s4;
 rsize_t r4;
 wchar_t wc4;
-void *v4 = NULL; // c99-error{{undeclared identifier}} c23-error{{undeclared identifier}}
-nullptr_t n4; // c99-error{{unknown type}} c23-error{{unknown type}}
-static void f4(void) { unreachable(); } // c99-error{{undeclared function}} c23-error{{undeclared identifier}}
+void *v4 = NULL; // c99-error{{undeclared identifier}} c23-error{{undeclared identifier}} \
+                    c99-modules-error{{undeclared identifier}} c23-modules-error{{undeclared identifier}}
+nullptr_t n4; // c99-error{{unknown type}} c23-error{{unknown type}} \
+                 c99-modules-error{{unknown type}}
+static void f4(void) { unreachable(); } // c99-error{{undeclared function}} c23-error{{undeclared identifier}} \
+                                           c99-modules-error{{undeclared function}} c23-modules-error{{undeclared identifier}}
 max_align_t m4; // c99-error{{unknown type}} c23-error{{unknown type}}
 size_t o4 = offsetof(struct astruct, member); // c99-error{{expected expression}} c99-error{{undeclared identifier}} \
-                                                 c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}}
+                                                 c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}} \
+                                                 c99-modules-error{{expected expression}} c99-modules-error{{undeclared identifier}} \
+                                                 c23-modules-error{{undeclared identifier}} c23-modules-error{{expected expression}} c23-modules-error{{undeclared identifier}}
 wint_t wi4; // c99-error{{unknown type}} c23-error{{unknown type}}
 
 #define __need_NULL
 #include <stddef.h>
 
 ptrdiff_t p5;
 size_t s5;
 rsize_t r5;
 wchar_t wc5;
 void *v5 = NULL;
-nullptr_t n5; // c99-error{{unknown type}} c23-error{{unknown type}}
-static void f5(void) { unreachable(); } // c99-error{{undeclared function}} c23-error{{undeclared identifier}}
+nullptr_t n5; // c99-error{{unknown type}} c23-error{{unknown type}} \
+                 c99-modules-error{{unknown type}}
+static void f5(void) { unreachable(); } // c99-error{{undeclared function}} c23-error{{undeclared identifier}} \
+                                           c99-modules-error{{undeclared function}} c23-modules-error{{undeclared identifier}}
 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}}
+                                                 c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}} \
+                                                 c99-modules-error{{expected expression}} c99-modules-error{{undeclared identifier}} \
+                                                 c23-modules-error{{undeclared identifier}} c23-modules-error{{expected expression}} c23-modules-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
+// nullptr_t doesn't get declared before C23 because its definition
 // depends on nullptr.
 #define __need_nullptr_t
-#include <stddef.h> // c99-error@__stddef_nullptr_t.h:*{{expected function body}}
+#include <stddef.h>
 
 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}}
+nullptr_t n6; // c99-error{{unknown type}} c99-modules-error{{unknown type}}
+static void f6(void) { unreachable(); } // c99-error{{undeclared function}} c23-error{{undeclared identifier}} \
+                                           c99-modules-error{{undeclared function}} c23-modules-error{{undeclared identifier}}
 max_align_t m6; // c99-error{{unknown type}} c23-error{{unknown type}}
 size_t o6 = offsetof(struct astruct, member); // c99-error{{expected expression}} c99-error{{undeclared identifier}} \
-                                                 c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}}
+                                                 c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}} \
+                                                 c99-modules-error{{expected expression}} c99-modules-error{{undeclared identifier}} \
+                                                 c23-modules-error{{undeclared identifier}} c23-modules-error{{expected expression}} c23-modules-error{{undeclared identifier}}
 wint_t wi6; // c99-error{{unknown type}} c23-error{{unknown type}}
 
 #define __need_unreachable
 #include <stddef.h>
 
 ptrdiff_t p7;
 size_t s7;
 rsize_t r7;
 wchar_t wc7;
 void *v7 = NULL;
-nullptr_t n7 ; // c99-error{{unknown type}}
+nullptr_t n7 ; // c99-error{{unknown type}} c99-modules-error{{unknown type}}
 static void f7(void) { unreachable(); }
 max_align_t m7; // c99-error{{unknown type}} c23-error{{unknown type}}
 size_t o7 = offsetof(struct astruct, member); // c99-error{{expected expression}} c99-error{{undeclared identifier}} \
-                                                 c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}}
+                                                 c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}} \
+                                                 c99-modules-error{{expected expression}} c99-modules-error{{undeclared identifier}} \
+                                                 c23-modules-error{{undeclared identifier}} c23-modules-error{{expected expression}} c23-modules-error{{undeclared identifier}}
 wint_t wi7; // c99-error{{unknown type}} c23-error{{unknown type}}
 
 #define __need_max_align_t
 #include <stddef.h>
 
 ptrdiff_t p8;
 size_t s8;
 rsize_t r8;
 wchar_t wc8;
 void *v8 = NULL;
-nullptr_t n8; // c99-error{{unknown type}}
+nullptr_t n8; // c99-error{{unknown type}} c99-modules-error{{unknown type}}
 static void f8(void) { unreachable(); }
 max_align_t m8;
 size_t o8 = offsetof(struct astruct, member); // c99-error{{expected expression}} c99-error{{undeclared identifier}} \
-                                                 c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}}
+                                                 c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}} \
+                                                 c99-modules-error{{expected expression}} c99-modules-error{{undeclared identifier}} \
+                                                 c23-modules-error{{undeclared identifier}} c23-modules-error{{expected expression}} c23-modules-error{{undeclared identifier}}
 wint_t wi8; // c99-error{{unknown type}} c23-error{{unknown type}}
 
 #define __need_offsetof
 #include <stddef.h>
 
 ptrdiff_t p9;
 size_t s9;
 rsize_t r9;
-nullptr_t n9; // c99-error{{unknown type}}
+nullptr_t n9; // c99-error{{unknown type}} c99-modules-error{{unknown type}}
 static void f9(void) { unreachable(); }
 wchar_t wc9;
 void *v9 = NULL;
 max_align_t m9;
 size_t o9 = offsetof(struct astruct, member);
 wint_t wi9; // c99-error{{unknown type}} c23-error{{unknown type}}
 
 #define __need_wint_t
 #include <stddef.h>
 
 ptrdiff_t p10;
 size_t s10;
 rsize_t r10;
 wchar_t wc10;
 void *v10 = NULL;
-nullptr_t n10; // c99-error{{unknown type}}
+nullptr_t n10; // c99-error{{unknown type}} c99-modules-error{{unknown type}}
 static void f10(void) { unreachable(); }
 max_align_t m10;
 size_t o10 = offsetof(struct astruct, member);
 wint_t wi10;

clang/test/Modules/Inputs/System/usr/include/module.map

 module cstd [system] {
+  // Only in system headers directory
+  module complex {
+    header "complex.h"
+  }
+
   // Only in compiler support directory
   module float_constants {
     header "float.h"
   }
 
+  // In both directories (compiler support version wins, forwards)
+  module inttypes {
+    header "inttypes.h"
+  }
+
+  // Only in system headers directory
+  module math {
+    header "math.h"
+  }
+
   // Only in system headers directory
   module stdio {
     header "stdio.h"
   }
 
   // In both directories (compiler support version wins, does not forward)
   module stdbool {
     header "stdbool.h"

clang/test/Modules/Inputs/System/usr/include/stdint.h

 typedef int my_awesome_nonstandard_integer_type;
+
+/* C99 7.18.1.1 Exact-width integer types.
+ * C99 7.18.1.2 Minimum-width integer types.
+ * C99 7.18.1.3 Fastest minimum-width integer types.
+ *
+ * The standard requires that exact-width type be defined for 8-, 16-, 32-, and
+ * 64-bit types if they are implemented. Other exact width types are optional.
+ * This implementation defines an exact-width types for every integer width
+ * that is represented in the standard integer types.
+ *
+ * The standard also requires minimum-width types be defined for 8-, 16-, 32-,
+ * and 64-bit widths regardless of whether there are corresponding exact-width
+ * types.
+ *
+ * To accommodate targets that are missing types that are exactly 8, 16, 32, or
+ * 64 bits wide, this implementation takes an approach of cascading
+ * redefinitions, redefining __int_leastN_t to successively smaller exact-width
+ * types. It is therefore important that the types are defined in order of
+ * descending widths.
+ *
+ * We currently assume that the minimum-width types and the fastest
+ * minimum-width types are the same. This is allowed by the standard, but is
+ * suboptimal.
+ *
+ * In violation of the standard, some targets do not implement a type that is
+ * wide enough to represent all of the required widths (8-, 16-, 32-, 64-bit).
+ * To accommodate these targets, a required minimum-width type is only
+ * defined if there exists an exact-width type of equal or greater width.
+ */
+
+#ifdef __INT64_TYPE__
+# ifndef __int8_t_defined /* glibc sys/types.h also defines int64_t*/
+typedef __INT64_TYPE__ int64_t;
+# endif /* __int8_t_defined */
+typedef __UINT64_TYPE__ uint64_t;
+# undef __int_least64_t
+# define __int_least64_t int64_t
+# undef __uint_least64_t
+# define __uint_least64_t uint64_t
+# undef __int_least32_t
+# define __int_least32_t int64_t
+# undef __uint_least32_t
+# define __uint_least32_t uint64_t
+# undef __int_least16_t
+# define __int_least16_t int64_t
+# undef __uint_least16_t
+# define __uint_least16_t uint64_t
+# undef __int_least8_t
+# define __int_least8_t int64_t
+# undef __uint_least8_t
+# define __uint_least8_t uint64_t
+#endif /* __INT64_TYPE__ */
+
+#ifdef __int_least64_t
+typedef __int_least64_t int_least64_t;
+typedef __uint_least64_t uint_least64_t;
+typedef __int_least64_t int_fast64_t;
+typedef __uint_least64_t uint_fast64_t;
+#endif /* __int_least64_t */
+
+#ifdef __INT56_TYPE__
+typedef __INT56_TYPE__ int56_t;
+typedef __UINT56_TYPE__ uint56_t;
+typedef int56_t int_least56_t;
+typedef uint56_t uint_least56_t;
+typedef int56_t int_fast56_t;
+typedef uint56_t uint_fast56_t;
+# undef __int_least32_t
+# define __int_least32_t int56_t
+# undef __uint_least32_t
+# define __uint_least32_t uint56_t
+# undef __int_least16_t
+# define __int_least16_t int56_t
+# undef __uint_least16_t
+# define __uint_least16_t uint56_t
+# undef __int_least8_t
+# define __int_least8_t int56_t
+# undef __uint_least8_t
+# define __uint_least8_t uint56_t
+#endif /* __INT56_TYPE__ */
+
+
+#ifdef __INT48_TYPE__
+typedef __INT48_TYPE__ int48_t;
+typedef __UINT48_TYPE__ uint48_t;
+typedef int48_t int_least48_t;
+typedef uint48_t uint_least48_t;
+typedef int48_t int_fast48_t;
+typedef uint48_t uint_fast48_t;
+# undef __int_least32_t
+# define __int_least32_t int48_t
+# undef __uint_least32_t
+# define __uint_least32_t uint48_t
+# undef __int_least16_t
+# define __int_least16_t int48_t
+# undef __uint_least16_t
+# define __uint_least16_t uint48_t
+# undef __int_least8_t
+# define __int_least8_t int48_t
+# undef __uint_least8_t
+# define __uint_least8_t uint48_t
+#endif /* __INT48_TYPE__ */
+
+
+#ifdef __INT40_TYPE__
+typedef __INT40_TYPE__ int40_t;
+typedef __UINT40_TYPE__ uint40_t;
+typedef int40_t int_least40_t;
+typedef uint40_t uint_least40_t;
+typedef int40_t int_fast40_t;
+typedef uint40_t uint_fast40_t;
+# undef __int_least32_t
+# define __int_least32_t int40_t
+# undef __uint_least32_t
+# define __uint_least32_t uint40_t
+# undef __int_least16_t
+# define __int_least16_t int40_t
+# undef __uint_least16_t
+# define __uint_least16_t uint40_t
+# undef __int_least8_t
+# define __int_least8_t int40_t
+# undef __uint_least8_t
+# define __uint_least8_t uint40_t
+#endif /* __INT40_TYPE__ */
+
+
+#ifdef __INT32_TYPE__
+
+# ifndef __int8_t_defined /* glibc sys/types.h also defines int32_t*/
+typedef __INT32_TYPE__ int32_t;
+# endif /* __int8_t_defined */
+
+# ifndef __uint32_t_defined  /* more glibc compatibility */
+# define __uint32_t_defined
+typedef __UINT32_TYPE__ uint32_t;
+# endif /* __uint32_t_defined */
+
+# undef __int_least32_t
+# define __int_least32_t int32_t
+# undef __uint_least32_t
+# define __uint_least32_t uint32_t
+# undef __int_least16_t
+# define __int_least16_t int32_t
+# undef __uint_least16_t
+# define __uint_least16_t uint32_t
+# undef __int_least8_t
+# define __int_least8_t int32_t
+# undef __uint_least8_t
+# define __uint_least8_t uint32_t
+#endif /* __INT32_TYPE__ */
+
+#ifdef __int_least32_t
+typedef __int_least32_t int_least32_t;
+typedef __uint_least32_t uint_least32_t;
+typedef __int_least32_t int_fast32_t;
+typedef __uint_least32_t uint_fast32_t;
+#endif /* __int_least32_t */
+
+#ifdef __INT24_TYPE__
+typedef __INT24_TYPE__ int24_t;
+typedef __UINT24_TYPE__ uint24_t;
+typedef int24_t int_least24_t;
+typedef uint24_t uint_least24_t;
+typedef int24_t int_fast24_t;
+typedef uint24_t uint_fast24_t;
+# undef __int_least16_t
+# define __int_least16_t int24_t
+# undef __uint_least16_t
+# define __uint_least16_t uint24_t
+# undef __int_least8_t
+# define __int_least8_t int24_t
+# undef __uint_least8_t
+# define __uint_least8_t uint24_t
+#endif /* __INT24_TYPE__ */
+
+#ifdef __INT16_TYPE__
+#ifndef __int8_t_defined /* glibc sys/types.h also defines int16_t*/
+typedef __INT16_TYPE__ int16_t;
+#endif /* __int8_t_defined */
+typedef __UINT16_TYPE__ uint16_t;
+# undef __int_least16_t
+# define __int_least16_t int16_t
+# undef __uint_least16_t
+# define __uint_least16_t uint16_t
+# undef __int_least8_t
+# define __int_least8_t int16_t
+# undef __uint_least8_t
+# define __uint_least8_t uint16_t
+#endif /* __INT16_TYPE__ */
+
+#ifdef __int_least16_t
+typedef __int_least16_t int_least16_t;
+typedef __uint_least16_t uint_least16_t;
+typedef __int_least16_t int_fast16_t;
+typedef __uint_least16_t uint_fast16_t;
+#endif /* __int_least16_t */
+
+
+#ifdef __INT8_TYPE__
+#ifndef __int8_t_defined  /* glibc sys/types.h also defines int8_t*/
+typedef __INT8_TYPE__ int8_t;
+#endif /* __int8_t_defined */
+typedef __UINT8_TYPE__ uint8_t;
+# undef __int_least8_t
+# define __int_least8_t int8_t
+# undef __uint_least8_t
+# define __uint_least8_t uint8_t
+#endif /* __INT8_TYPE__ */
+
+#ifdef __int_least8_t
+typedef __int_least8_t int_least8_t;
+typedef __uint_least8_t uint_least8_t;
+typedef __int_least8_t int_fast8_t;
+typedef __uint_least8_t uint_fast8_t;
+#endif /* __int_least8_t */
+
+/* prevent glibc sys/types.h from defining conflicting types */
+#ifndef __int8_t_defined
+# define __int8_t_defined
+#endif /* __int8_t_defined */
+
+/* C99 7.18.1.4 Integer types capable of holding object pointers.
+ */
+#define __stdint_join3(a,b,c) a ## b ## c
+
+#ifndef _INTPTR_T
+#ifndef __intptr_t_defined
+typedef __INTPTR_TYPE__ intptr_t;
+#define __intptr_t_defined
+#define _INTPTR_T
+#endif
+#endif
+
+#ifndef _UINTPTR_T
+typedef __UINTPTR_TYPE__ uintptr_t;
+#define _UINTPTR_T
+#endif
+
+/* C99 7.18.1.5 Greatest-width integer types.
+ */
+typedef __INTMAX_TYPE__  intmax_t;
+typedef __UINTMAX_TYPE__ uintmax_t;

clang/test/Modules/compiler_builtins.m

 // RUN: rm -rf %t
-// RUN: %clang_cc1 -fsyntax-only -fmodules -fimplicit-module-maps -fmodules-cache-path=%t %s -I%S/Inputs/System/usr/include -verify
-// RUN: %clang_cc1 -fsyntax-only -std=c99 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t %s -I%S/Inputs/System/usr/include -verify
-// RUN: %clang_cc1 -fsyntax-only -fmodules -fmodule-map-file=%resource_dir/module.modulemap -fmodules-cache-path=%t %s -I%S/Inputs/System/usr/include -verify
+// RUN: %clang_cc1 -fsyntax-only -fmodules -fimplicit-module-maps -fmodules-cache-path=%t %s -internal-isystem %S/Inputs/System/usr/include -verify
+// RUN: %clang_cc1 -fsyntax-only -std=c99 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t %s -internal-isystem %S/Inputs/System/usr/include -verify
+// RUN: %clang_cc1 -fsyntax-only -fmodules -fmodule-map-file=%resource_dir/module.modulemap -fmodules-cache-path=%t %s -I%S/Inputs/System/usr/include -DNO_SYSTEM_MODULES -verify
 // expected-no-diagnostics
 
 #ifdef __SSE__
 @import _Builtin_intrinsics.intel.sse;
 #endif
 
 #ifdef __AVX2__
 @import _Builtin_intrinsics.intel.avx2;
 #endif
+
+#ifndef NO_SYSTEM_MODULES
+@import _Builtin_float;
+@import _Builtin_inttypes;
+@import _Builtin_iso646;
+@import _Builtin_limits;
+@import _Builtin_stdalign;
+@import _Builtin_stdarg;
+@import _Builtin_stdatomic;
+@import _Builtin_stdbool;
+@import _Builtin_stddef;
+@import _Builtin_stdint;
+@import _Builtin_stdnoreturn;
+@import _Builtin_tgmath;
+@import _Builtin_unwind;
+#endif

clang/test/Modules/stddef.c

 // RUN: rm -rf %t
-// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fbuiltin-headers-in-system-modules -fmodules-cache-path=%t -I%S/Inputs/StdDef %s -verify -fno-modules-error-recovery
+// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fbuiltin-headers-in-system-modules -fmodules-cache-path=%t -I%S/Inputs/StdDef %s -verify=no-stddef-module -fno-modules-error-recovery
+// RUN: rm -rf %t
+// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/StdDef %s -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_size_t.h:* {{here}}
+// When builtin headers join system modules, stddef.h and its sub-headers have no
+// header guards, and so are seen last by include_again.h, which takes all of their
+// declarations including size_t even though size_t.h previously declared it.
+// When builtin headers don't join the system modules and instead get their own
+// modules, none of the stddef.h declarations go in the StdDef test module. size_t
+// is then declared in both StdDef.SizeT and _Builtin_stddef.size_t. For the
+// purposes of this test it doesn't matter which one gets reported, just as long
+// as it isn't other.h or include_again.h.
+size_t st; // no-stddef-module-error {{missing '#include "include_again.h"'; 'size_t' must be declared before it is used}} \
+              yes-stddef-module-error {{missing '#include "size_t.h"'; 'size_t' must be declared before it is used}}
+// no-stddef-module-note@__stddef_size_t.h:* {{here}}
+// yes-stddef-module-note@size_t.h:* {{here}}
 
 #include "include_again.h"
 
 size_t st2;

clang/test/Modules/stddef.m

 @import StdDef.Other;
 
 size_t getSize(void);
 
 // RUN: rm -rf %t
 // RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fbuiltin-headers-in-system-modules -fmodules-cache-path=%t -I %S/Inputs/StdDef %s -verify
+// RUN: rm -rf %t
+// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs/StdDef %s
 // expected-no-diagnostics