[Headers] Replace __need_STDDEF_H_misc with specific __need_ macros

[iana]

Summary

Apple needs __need_ macros for rsize_t and offsetof. Add those, and also ones for nullptr_t, unreachable, max_align_t.

[efriedma]

clang/lib/Headers/stddef.h

111–112

I think this code was pulled into the __need_NULL conditional by accident; I doubt anyone actually depends on the precise interaction here. Just move to the same place as the other __need_ defines.

[iana]

Don't define nullptr_t in C++ if __need_NULL is set without __need_nullptr_t

[iana]

clang/lib/Headers/stddef.h

111–112

👍

[efriedma]

LGTM

[iana]

clang/test/Headers/stddef.c

20–23

Does anyone know a trick to catch the note from stddef.h?

clang/test/Headers/stddefneeds.c

35–37

(same here)

85–87

(and the error here)

[efriedma]

clang/test/Headers/stddef.c

20–23

I think the syntax is something like expected-warning@stddef.h:10? See rGfcc699ae , There's also a wildcard syntax; see rG05eedf1f.

[iana]

clang/test/Headers/stddef.c

20–23

Ah ha!

[iana]

Update the tests to handle diagnostics from stddef.h
Fix stddef.h to support defining __STDC_WANT_LIB_EXT1__ if stddef.h has already been included

[iana]

Let the Phabricator linter update stddef.h

[aaron.ballman]

clang/lib/Headers/stddef.h

16

C23 K.3.1.1p2: The functions, macros, and types declared or defined in K.3 and its subclauses are declared and defined by their respective headers if STDC_WANT_LIB_EXT1 is defined as a macro which expands to the integer constant 1 at the point in the source file where the appropriate header is first included.

So I don't think this should be >= 1. Same below. (Though I notice we seem to do this in other places, so perhaps that's more of a general cleanup we should make?)

116–120

Related:

https://github.com/llvm/llvm-project/issues/37564
https://cplusplus.github.io/LWG/issue3484

CC @ldionne

clang/test/Headers/stddef.c

2–4

Are the triples necessary? Better if we can remove them.

8

At least one of these unknown errors should be fully spelled out (the rest can then be assumed to be the same wording as the long-form).

clang/test/Headers/stddefneeds.c

2–3

Do we need the triples?

9

Should spell out one of these.

[iana]

Review fixes

[iana]

clang/lib/Headers/stddef.h

16

>=1 is what stddef.h was already doing, so I'd vote do this later as general cleanup.

clang/test/Headers/stddef.c

2–4

They shouldn't be, I just copied them from stddefneeds.cpp, let me try getting rid of them

8

Let me know how this looks, I can just fully expand all of them if you prefer. I was going by stddefneeds.cpp as an example.

clang/test/Headers/stddefneeds.c

2–3

Looks like no.

[aaron.ballman]

LGTM but I'm adding libc++ as a blocking reviewer because there are questions about how well this interacts with their stddef.h (especially the nullptr_t bits): https://github.com/llvm/llvm-project/blob/main/libcxx/include/stddef.h

clang/lib/Headers/stddef.h

16

That sounds reasonable to me!

clang/test/Headers/stddef.c

8

This works fine -- I would have also been happy if only ptrdiff_t was fully spelled out and the rest used unknown (we can infer they're all the same diagnostic from that).

[philnik]

I think these changes would allow us to drop the stddef.h compat header from libc++, which would be really nice.

clang/lib/Headers/stddef.h

35–50

116–123

[iana]

In D157757#4592766, @philnik wrote:

I think these changes would allow us to drop the stddef.h compat header from libc++, which would be really nice.

I'd really rather not change how nullptr_t gets declared in this change, can we do these in another one?

clang/lib/Headers/stddef.h

116–120

I don't _think_ this change actually changes the way nullptr_t gets defined in C++, does it?

[iana]

Rebase

[iana]

In D157757#4592794, @iana wrote:

In D157757#4592766, @philnik wrote:

I think these changes would allow us to drop the stddef.h compat header from libc++, which would be really nice.

I'd really rather not change how nullptr_t gets declared in this change, can we do these in another one?

Also my preference would be that we take the c++ stuff _out_ of this header and put it in the libc++ one, but I'm guessing that would cause issues for libstdc++?

[ldionne]

This is going to be really naive, but can someone explain why we need these __need_XXXXX macros? Why doesn't <stddef.h> simply always declare what it should declare? Also, does anybody understand the expected relationship between the C Standard Library headers and these Clang builtin headers? Who defines what?

Everyone I've spoken to so far about this (and myself) was extremely confused. At some point I thought these macros were only needed for compatibility with old glibcs but that wouldn't even be needed anymore, but I'm not certain.

clang/lib/Headers/stddef.h

116–120

I think we absolutely don't want to touch std::nullptr_t from this header. It's libc++'s responsibility to define that, and in fact we define it in std::__1, so this is even an ABI break (or I guess it would be a compiler error, not sure).

[iana]

In D157757#4600357, @ldionne wrote:

This is going to be really naive, but can someone explain why we need these __need_XXXXX macros? Why doesn't <stddef.h> simply always declare what it should declare? Also, does anybody understand the expected relationship between the C Standard Library headers and these Clang builtin headers? Who defines what?

Everyone I've spoken to so far about this (and myself) was extremely confused. At some point I thought these macros were only needed for compatibility with old glibcs but that wouldn't even be needed anymore, but I'm not certain.

The __need_ macros are to support some strict mostly POSIX behaviors like <sys/types.h> is supposed to provide size_t but none of the other things in <stddef.h>. Apple has headers like <sys/_types/_rsize_t.h> and <sys/_types/_offsetof.h> that are expected to provide those types and nothing else. Right now they're redeclaring the types, and if you're using clang modules with the right flags, that's an error. So I need to switch those to doing something like this.

#define __need_rsize_t
#include <stddef.h>

The relationship between clang's stddef.h and the C Standard Library stddef.h is that there is no relationship. clang's header doesn't #include_next, and it is in the search path before the OS's cstdlib.

clang/lib/Headers/stddef.h

116–120

I'm really not touching it though. All I did is move it from __need_NULL to __need_nullptr_t.

The old behavior is that std::nullptr_t would only be touched if (no __need_ macros were set or if __need_NULL was set), and (_MSC_EXTENSIONS and _NATIVE_NULLPTR_SUPPORTED are defined).

The new behavior is that std::nullptr_t will only be touched if ((no __need_ macros are set) and (_MSC_EXTENSIONS and _NATIVE_NULLPTR_SUPPORTED are defined)) or (the new __need_nullptr_t macro is set)

So the only change is that C++ code that previously set __need_NULL will no longer get std::nullptr_t. @efriedma felt like that was a fine change.

[aaron.ballman]

clang/lib/Headers/stddef.h

116–120

Does libc++ provide the symbols for a freestanding compilation?

I was pointing out those links specifically because the C++ standard currently says that stddef.h (the C standard library header) needs to provide a definition of std::nullptr_t, but that LWG thinks that's perhaps not the right way to do that and may be removing that requirement.

[iana]

clang/lib/Headers/stddef.h

116–120

It is weird the standard puts that in stddef.h and not cstddef. I think libc++ could provide that in their stddef.h anyway, but the intent in this review is to not rock the boat and only do the minimal change discussed above.

[aaron.ballman]

clang/lib/Headers/stddef.h

116–120

Yeah, this discussion is to figure out whether we have an existing bug we need to address and if so, where to address it (libc++, clang, or the C++ standard). I don't think your changes are exacerbating anything, more just that they've potentially pointed out something related.

[iana]

clang/lib/Headers/stddef.h

116–120

👍

[ldionne]

clang/lib/Headers/stddef.h

1

Making a thread out of this:

The relationship between clang's stddef.h and the C Standard Library stddef.h is that there is no relationship. clang's header doesn't #include_next, and it is in the search path before the OS's cstdlib.

So in that case what is the purpose of the SDK/system providing a <stddef.h> header? They basically all provide one and it's never used?

116–120

Does libc++ provide the symbols for a freestanding compilation?

I don't think we do. We basically don't support -ffreestanding right now (we support embedded and funky platforms via other mechanisms).

But regardless, <stddef.h> should never define something in namespace std, that should be libc++'s responsibility IMO. What we could do here instead is just

#ifdef __cplusplus
typedef decltype(nullptr) nullptr_t;
#else
typedef typeof(nullptr) nullptr_t;
#endif

and then let libc++'s <cstddef> do

_LIBCPP_BEGIN_NAMESPACE_STD
using ::nullptr_t;
_LIBCPP_END_NAMESPACE_STD

If Clang's <stddef.h> did define ::nullptr_t, we could likely remove libc++'s <stddef.h> and that might simplify things.

[aaron.ballman]

clang/lib/Headers/stddef.h

1

The compiler provides <stddef.h> for the same reason it provides <limits.h> and others: the compiler is responsible for defining these interfaces because it's the only thing that knows the correct definitions it expects. The system might know some of it, but for example, size_t relates to the maximum size of an object, which is something only the compiler knows the answer to.

116–120

Does libc++ provide the symbols for a freestanding compilation?

I don't think we do. We basically don't support -ffreestanding right now (we support embedded and funky platforms via other mechanisms).

Okay, that's what I thought as well. Thanks!

But regardless, <stddef.h> should never define something in namespace std, that should be libc++'s responsibility IMO. What we could do here instead is just

Ah, so you're thinking stddef.h should provide the global nullptr_t and cstddef should provide the std::nullptr_t. I was thinking stddef.h should not define nullptr_t in C++ mode at all; it's a C header, not a C++ header. That led me to thinking about what the behavior should be in C23 given that it supports nullptr_t.

Were it not for the current requirement that stddef.h provide nullptr_t, I think stddef.h should do:

typedef typeof(nullptr) nullptr_t;

in C23 mode and not do anything special for C++ at all. C's nullptr_t needs to be ABI compatible with C++'s nullptr_t, so a C++ user including the C header should not get any problems linking against a C++ library. However, this would mean that C++ users cannot include stddef.h to get nullptr_t; they'd need to include cstddef to be assured they'd get it. But because of the ABI compatibility, perhaps the solution is to expose the above in both C and C++ modes from stddef.h, then libc++ can do the dance to import it into namespace std?

[iana]

clang/lib/Headers/stddef.h

1

I think the purpose is for the SDK/system to support compilers that don't provide <stddef.h>. In the early Apple days that was CodeWarrior, maybe gcc didn't used to provide that header? I don't know.

But basically yes, they all provide one and it's practically never used.

[iana]

Only define nullptr_t in C++ if _MSC_EXTENSIONS is defined, even if __need_nullptr_t is explicitly set.

clang/lib/Headers/stddef.h

116–120

Actually I think I did change it after all. If a C header does something like this

// It's assumed that only C23 or later is supported, or C++
#define __need_nullptr_t
#include <stddef.h>

If such a header got included in a C++ program, we wouldn't want to declare std::nullptr_t. I think we need to keep the _MSC_EXTENSIONS check in there and never declare it if that isn't set, even if the includer asked for nullptr_t. That matches the behavior of wchar_t in this header, and I think for similar reasons.

Otherwise clang's stddef.h would step on the nullptr_t declared by libc++'s stddef.h (modules would probably complain about a duplicate/conflicting declaration)

[ldionne]

clang/lib/Headers/stddef.h

116–120

@aaron.ballman Ok, I follow your train of thought. So in that case what we would do is this:

// <stddef.h> from the Clang builtin headers:
#if we-are-in-C23
typedef typeof(nullptr) nullptr_t;
#endif
// never do anything special for C++

// <cstddef> from libc++:
#include <stddef.h>

#if we-are-in-whatever-C++-standard-synced-with-C23
  _LIBCPP_BEGIN_NAMESPACE_STD
  using ::nullptr_t; // use the C23 ::nullptr_t as defined in <stddef.h>
  _LIBCPP_END_NAMESPACE_STD
#else
  _LIBCPP_BEGIN_NAMESPACE_STD
  typedef decltype(nullptr) nullptr_t; // declare our own nullptr_t from scratch since C doesn't have a notion of it
  _LIBCPP_END_NAMESPACE_STD
#endif

This way:

1. Libc++ doesn't need to have <stddef.h> anymore
2. The Clang builtin headers are pure C
3. std::nullptr_t and ::nullptr_t are always the same thing when both are defined

However in this world ::nullptr_t would not be defined when including <stddef.h> in C++ prior to whatever version is synced with C23 (that's not a problem IMO, but it is a behavior change).

Does this make sense to everyone?

[aaron.ballman]

clang/lib/Headers/stddef.h

116–120

Does this make sense to everyone?

I think it makes sense, yes (thank you for spelling it out so clearly!). I agree that it's a behavior change, but it's one I'm hoping we can argue for in LWG when discussing https://cplusplus.github.io/LWG/issue3484 -- but that said, I'm not certain if this behavior change will cause problems for significant third-party library or system headers.

[ldionne]

LGTM. I think what we discussed in https://reviews.llvm.org/D157757#inline-1534166 makes sense and we should do it, but it belongs to a different patch for sure. Anybody wants to take that task?

clang/lib/Headers/stddef.h

111–112

You could reduce the diff by not reformatting this.

[ldionne]

Also we should figure out why the Clang modules build is failing on top of this, it doesn't look like a false positive.

[iana]

clang/lib/Headers/stddef.h

111–112

That's what I did initially, but the CI failed its formatting check.

[iana]

In D157757#4611425, @ldionne wrote:

Also we should figure out why the Clang modules build is failing on top of this, it doesn't look like a false positive.

Where do you see that failure?

[iana]

In D157757#4611492, @iana wrote:

In D157757#4611425, @ldionne wrote:

Also we should figure out why the Clang modules build is failing on top of this, it doesn't look like a false positive.

Where do you see that failure?

Never mind, I see it now.

[iana]

Rebase

[iana]

Try rebasing one more time

[iana]

Windows succeeding earlier, I'm pretty confident that the current crash isn't due to this review, so I'm going to go ahead and land.

clang/lib/Headers/stddef.h

 /*===---- stddef.h - Basic type definitions --------------------------------===
  *
  * 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(__STDDEF_H) || defined(__need_ptrdiff_t) ||                       \
-    defined(__need_size_t) || defined(__need_wchar_t) ||                       \
-    defined(__need_NULL) || defined(__need_wint_t)
+    defined(__need_size_t) || defined(__need_rsize_t) ||                       \
+    defined(__need_wchar_t) || defined(__need_NULL) ||                         \
+    defined(__need_nullptr_t) || defined(__need_unreachable) ||                \
+    defined(__need_max_align_t) || defined(__need_offsetof) ||                 \
+    defined(__need_wint_t)
 
 #if !defined(__need_ptrdiff_t) && !defined(__need_size_t) &&                   \
-    !defined(__need_wchar_t) && !defined(__need_NULL) &&                       \
-    !defined(__need_wint_t)
+    !defined(__need_rsize_t) && !defined(__need_wchar_t) &&                    \
+    !defined(__need_NULL) && !defined(__need_nullptr_t) &&                     \
+    !defined(__need_unreachable) && !defined(__need_max_align_t) &&            \
+    !defined(__need_offsetof) && !defined(__need_wint_t)
 /* Always define miscellaneous pieces when modules are available. */
 #if !__has_feature(modules)
 #define __STDDEF_H
 #endif
 #define __need_ptrdiff_t
 #define __need_size_t
+/* ISO9899:2011 7.20 (C11 Annex K): Define rsize_t if __STDC_WANT_LIB_EXT1__ is
+ * enabled. */
+#if defined(__STDC_WANT_LIB_EXT1__) && __STDC_WANT_LIB_EXT1__ >= 1
+#define __need_rsize_t
+#endif
 #define __need_wchar_t
 #define __need_NULL
-#define __need_STDDEF_H_misc
-/* __need_wint_t is intentionally not defined here. */
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L) ||              \
+    (defined(__cplusplus) && defined(_MSC_EXTENSIONS) && defined(_NATIVE_NULLPTR_SUPPORTED))
+#define __need_nullptr_t
+#endif
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
+#define __need_unreachable
+#endif
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) ||              \
+    (defined(__cplusplus) && __cplusplus >= 201103L)
+#define __need_max_align_t
+#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
 #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
 #undef __need_size_t
 #endif /*defined(__need_size_t) */
 
-#if defined(__need_STDDEF_H_misc)
-/* ISO9899:2011 7.20 (C11 Annex K): Define rsize_t if __STDC_WANT_LIB_EXT1__ is
- * enabled. */
-#if (defined(__STDC_WANT_LIB_EXT1__) && __STDC_WANT_LIB_EXT1__ >= 1 && \
-     !defined(_RSIZE_T)) || __has_feature(modules)
+#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
-#endif /* defined(__need_STDDEF_H_misc) */
+#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)

 #ifdef __cplusplus
 #  if !defined(__MINGW32__) && !defined(_MSC_VER)
 #    define NULL __null
 #  else
 #    define NULL 0
 #  endif
 #else
 #  define NULL ((void*)0)
 #endif
-#ifdef __cplusplus
-#if defined(_MSC_EXTENSIONS) && defined(_NATIVE_NULLPTR_SUPPORTED)
-namespace std { typedef decltype(nullptr) nullptr_t; }
-using ::std::nullptr_t;
-#endif
-#endif
 #undef __need_NULL
 #endif /* defined(__need_NULL) */
 
-#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
+#if defined(__need_nullptr_t)
+#ifdef __cplusplus
+namespace std { typedef decltype(nullptr) nullptr_t; }
+using ::std::nullptr_t;
+#else
 typedef typeof(nullptr) nullptr_t;
-#endif /* defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L */
+#endif
+#undef __need_nullptr_t
+#endif /* defined(__need_nullptr_t) */
 
-#if defined(__need_STDDEF_H_misc) && defined(__STDC_VERSION__) &&              \
-    __STDC_VERSION__ >= 202311L
+#if defined(__need_unreachable)
 #define unreachable() __builtin_unreachable()
-#endif /* defined(__need_STDDEF_H_misc) && >= C23 */
+#undef __need_unreachable
+#endif /* defined(__need_unreachable) */
 
-#if defined(__need_STDDEF_H_misc)
-#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) ||              \
-    (defined(__cplusplus) && __cplusplus >= 201103L)
+#if defined(__need_max_align_t)
 #include "__stddef_max_align_t.h"
-#endif
+#undef __need_max_align_t
+#endif /* defined(__need_max_align_t) */
+
+#if defined(__need_offsetof)
 #define offsetof(t, d) __builtin_offsetof(t, d)
-#undef __need_STDDEF_H_misc
-#endif  /* defined(__need_STDDEF_H_misc) */
+#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
 #undef __need_wint_t
 #endif /* __need_wint_t */
 
 #endif

clang/test/Headers/stddef.c

+// RUN: %clang_cc1 -fsyntax-only -triple x86_64-apple-macosx10.9.0 -verify=c99 -std=c99 %s
+// RUN: %clang_cc1 -fsyntax-only -triple x86_64-apple-macosx10.9.0 -verify=c11 -std=c11 %s
+// RUN: %clang_cc1 -fsyntax-only -triple x86_64-apple-macosx10.9.0 -verify=c23 -std=c23 %s
+
+struct astruct { char member; };
+
+ptrdiff_t p0; // c99-error{{unknown}} c11-error{{unknown}} c23-error{{unknown}}
+size_t s0; // c99-error{{unknown}} c11-error{{unknown}} c23-error{{unknown}}
+rsize_t r0; // c99-error{{unknown}} c11-error{{unknown}} c23-error{{unknown}}
+wchar_t wc0; // c99-error{{unknown}} c11-error{{unknown}} c23-error{{unknown}}
+void *v0 = NULL; // c99-error{{undeclared}} c11-error{{undeclared}} c23-error{{undeclared}}
+nullptr_t n0; // c99-error{{unknown}} c11-error{{unknown}} c23-error{{unknown}}
+static void f0(void) { unreachable(); } // c99-error{{undeclared}} c11-error{{undeclared}} c23-error{{undeclared}}
+max_align_t m0; // c99-error{{unknown}} c11-error{{unknown}} c23-error{{unknown}}
+size_t o0 = offsetof(struct astruct, member); // c99-error{{unknown}} c99-error{{undeclared}} c99-error{{expected expression}} c99-error{{undeclared}} \
+                                                 c11-error{{unknown}} c11-error{{undeclared}} c11-error{{expected expression}} c11-error{{undeclared}} \
+                                                 c23-error{{unknown}} c23-error{{undeclared}} c23-error{{expected expression}} c23-error{{undeclared}}
+wint_t wi0; // c99-error{{unknown}} c11-error{{unknown}} c23-error{{unknown}}
+
+// rsize_t will only be defined if __STDC_WANT_LIB_EXT1__ is set to >= 1.
+// It would be nice to test the default undefined behavior, but that emits
+// a note coming from stddef.h "rsize_t, did you mean size_t?" that can't be
+// `c99-note`d away.
+#define __STDC_WANT_LIB_EXT1__ 1
+#include <stddef.h>
+
+ptrdiff_t p1;
+size_t s1;
+rsize_t r1;
+wchar_t wc1;
+void *v1 = NULL;
+nullptr_t n1; // c99-error{{unknown}} c11-error{{unknown}}
+static void f1(void) { unreachable(); } // c99-error{{undeclared}} c11-error{{undeclared}}
+max_align_t m1; // c99-error{{unknown}}
+size_t o1 = offsetof(struct astruct, member);
+wint_t wi1; // c99-error{{unknown}} c11-error{{unknown}} c23-error{{unknown}}

clang/test/Headers/stddefneeds.c

+// RUN: %clang_cc1 -fsyntax-only -triple x86_64-apple-macosx10.9.0 -verify=c99 -std=c99 %s
+// RUN: %clang_cc1 -fsyntax-only -triple x86_64-apple-macosx10.9.0 -verify=c23 -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}} c23-error{{unknown}}
+size_t s0; // c99-error{{unknown}} c23-error{{unknown}}
+rsize_t r0; // c99-error{{unknown}} c23-error{{unknown}}
+wchar_t wc0; // c99-error{{unknown}} c23-error{{unknown}}
+void *v0 = NULL; // c99-error{{undeclared}} c23-error{{undeclared}}
+nullptr_t n0; // c99-error{{unknown}} c23-error{{unknown}}
+static void f0(void) { unreachable(); } // c99-error{{undeclared}} c23-error{{undeclared}}
+max_align_t m0; // c99-error{{unknown}} c23-error{{unknown}}
+size_t o0 = offsetof(struct astruct, member); // c99-error{{unknown}} c99-error{{undeclared}} c99-error{{expected expression}} c99-error{{undeclared}} \
+                                                 c23-error{{unknown}} c23-error{{undeclared}} c23-error{{expected expression}} c23-error{{undeclared}}
+wint_t wi0; // c99-error{{unknown}} c23-error{{unknown}}
+
+#define __need_ptrdiff_t
+#include <stddef.h>
+
+ptrdiff_t p1;
+size_t s1; // c99-error{{unknown}} c23-error{{unknown}}
+rsize_t r1; // c99-error{{unknown}} c23-error{{unknown}}
+wchar_t wc1; // c99-error{{unknown}} c23-error{{unknown}}
+void *v1 = NULL; // c99-error{{undeclared}} c23-error{{undeclared}}
+nullptr_t n1; // c99-error{{unknown}} c23-error{{unknown}}
+static void f1(void) { unreachable(); } // c99-error{{undeclared}} c23-error{{undeclared}}
+max_align_t m1; // c99-error{{unknown}} c23-error{{unknown}}
+size_t o1 = offsetof(struct astruct, member); // c99-error{{unknown}} c99-error{{undeclared}} c99-error{{expected expression}} \
+                                                 c23-error{{unknown}} c23-error{{undeclared}} c23-error{{expected expression}} c23-error{{undeclared}}
+wint_t wi1; // c99-error{{unknown}} c23-error{{unknown}}
+
+// If you do these individually, the compiler will add a note
+// coming from stddef.h "rsize_t, did you mean size_t?" that
+// can't be `c99-note`d away.
+#define __need_size_t
+#define __need_rsize_t
+#include <stddef.h>
+
+ptrdiff_t p2;
+size_t s2;
+rsize_t r2;
+wchar_t wc2; // c99-error{{unknown}} c23-error{{unknown}}
+void *v2 = NULL; // c99-error{{undeclared}} c23-error{{undeclared}}
+nullptr_t n2; // c99-error{{unknown}} c23-error{{unknown}}
+static void f2(void) { unreachable(); } // c99-error{{undeclared}} c23-error{{undeclared}}
+max_align_t m2; // c99-error{{unknown}} c23-error{{unknown}}
+size_t o2 = offsetof(struct astruct, member); // c99-error{{undeclared}} c99-error{{expected expression}} \
+                                                 c23-error{{undeclared}} c23-error{{expected expression}} c23-error{{undeclared}}
+wint_t wi2; // c99-error{{unknown}} c23-error{{unknown}}
+
+#define __need_wchar_t
+#include <stddef.h>
+
+ptrdiff_t p3;
+size_t s3;
+rsize_t r3;
+wchar_t wc3;
+void *v3 = NULL; // c99-error{{undeclared}} c23-error{{undeclared}}
+nullptr_t n3; // c99-error{{unknown}} c23-error{{unknown}}
+static void f3(void) { unreachable(); } // c99-error{{undeclared}} c23-error{{undeclared}}
+max_align_t m3; // c99-error{{unknown}} c23-error{{unknown}}
+size_t o3 = offsetof(struct astruct, member); // c99-error{{undeclared}} c99-error{{expected expression}} \
+                                                 c23-error{{undeclared}} c23-error{{expected expression}} c23-error{{undeclared}}
+wint_t wi3; // c99-error{{unknown}} c23-error{{unknown}}
+
+#define __need_NULL
+#include <stddef.h>
+
+ptrdiff_t p4;
+size_t s4;
+rsize_t r4;
+wchar_t wc4;
+void *v4 = NULL;
+nullptr_t n4; // c99-error{{unknown}} c23-error{{unknown}}
+static void f4(void) { unreachable(); } // c99-error{{undeclared}} c23-error{{undeclared}}
+max_align_t m4; // c99-error{{unknown}} c23-error{{unknown}}
+size_t o4 = offsetof(struct astruct, member); // c99-error{{undeclared}} c99-error{{expected expression}} \
+                                                 c23-error{{undeclared}} c23-error{{expected expression}} c23-error{{undeclared}}
+wint_t wi4; // c99-error{{unknown}} c23-error{{unknown}}
+
+#if __STDC_VERSION__ >= 202311L
+// __need_nullptr_t generates an error in <C23 because its definition
+// depends on nullptr, but the error gets attributed to the declaration
+// in stddef.h so it can't be `c99-error`d.
+#define __need_nullptr_t
+#include <stddef.h>
+
+ptrdiff_t p5;
+size_t s5;
+rsize_t r5;
+wchar_t wc5;
+void *v5 = NULL;
+nullptr_t n5; // c99-error{{unknown}}
+static void f5(void) { unreachable(); } // c99-error{{undeclared}} c23-error{{undeclared}}
+max_align_t m5; // c99-error{{unknown}} c23-error{{unknown}}
+size_t o5 = offsetof(struct astruct, member); // c99-error{{undeclared}} c99-error{{expected expression}} \
+                                                 c23-error{{undeclared}} c23-error{{expected expression}} c23-error{{undeclared}}
+wint_t wi5; // c99-error{{unknown}} c23-error{{unknown}}
+#endif
+
+#define __need_unreachable
+#include <stddef.h>
+
+ptrdiff_t p6;
+size_t s6;
+rsize_t r6;
+wchar_t wc6;
+void *v6 = NULL;
+nullptr_t n6; // c99-error{{unknown}}
+static void f6(void) { unreachable(); }
+max_align_t m6; // c99-error{{unknown}} c23-error{{unknown}}
+size_t o6 = offsetof(struct astruct, member); // c99-error{{undeclared}} c99-error{{expected expression}} \
+                                                 c23-error{{undeclared}} c23-error{{expected expression}} c23-error{{undeclared}}
+wint_t wi6; // c99-error{{unknown}} c23-error{{unknown}}
+
+#define __need_max_align_t
+#include <stddef.h>
+
+ptrdiff_t p7;
+size_t s7;
+rsize_t r7;
+wchar_t wc7;
+void *v7 = NULL;
+nullptr_t n7; // c99-error{{unknown}}
+static void f7(void) { unreachable(); }
+max_align_t m7;
+size_t o7 = offsetof(struct astruct, member); // c99-error{{undeclared}} c99-error{{expected expression}} \
+                                                 c23-error{{undeclared}} c23-error{{expected expression}} c23-error{{undeclared}}
+wint_t wi7; // c99-error{{unknown}} c23-error{{unknown}}
+
+#define __need_offsetof
+#include <stddef.h>
+
+ptrdiff_t p8;
+size_t s8;
+rsize_t r8;
+nullptr_t n8; // c99-error{{unknown}}
+static void f8(void) { unreachable(); }
+wchar_t wc8;
+void *v8 = NULL;
+max_align_t m8;
+size_t o8 = offsetof(struct astruct, member);
+wint_t wi8; // c99-error{{unknown}} c23-error{{unknown}}
+
+#define __need_wint_t
+#include <stddef.h>
+
+ptrdiff_t p9;
+size_t s9;
+rsize_t r9;
+wchar_t wc9;
+void *v9 = NULL;
+nullptr_t n9; // c99-error{{unknown}}
+static void f9(void) { unreachable(); }
+max_align_t m9;
+size_t o9 = offsetof(struct astruct, member);
+wint_t wi9;