C Support in Clang

Clang implements the following published and upcoming ISO C standards:

Language Standard	Flag	Available in Clang?
C2y	`-std=c2y`	Partial
C23	`-std=c23`	Partial
C17	`-std=c17`	Partial
C11	`-std=c11`	Partial
C99	`-std=c99`	Clang 17
C89	`-std=c89`	Yes

The implementation status for C11 and C23 are currently under investigation. Any proposal whose status in Clang is currently unknown will be marked in magenta.

The Clang community is continually striving to improve C standards compliance between releases by submitting and tracking C Defect Reports and implementing resolutions as they become available.

The LLVM bug tracker uses the "c", "c99", "c11", "c17", "c23", and "c2y" labels to track known bugs with Clang's language conformance.

C2y implementation status

Clang has support for some of the features of the C standard following C23, informally referred to as C2y.

You can use Clang in C2y mode with the -std=c2y option (available in Clang 19 and later).

List of features and minimum Clang version with support

Language Feature	C2y Proposal	Available in Clang?
Sequential hexdigits	N3192	Yes
Generic selection expression with a type operand	N3260	Clang 17
Round-trip rounding	N3232	Yes
Accessing byte arrays	N3254	Yes
Slay some earthly demons I	N3244	Partial Clang does not document the implementation-defined behavior for decay of an array with the register storage class specifier. Clang does not diagnose an `extern inline` function with no definition in the TU. Clang accepts and rejects redeclarations with/without an alignment specifier, depending on the order of the declarations.
Support ++ and -- on complex values	N3259	Yes
Usability of a byte-wise copy of va_list	N3262	Yes
alignof of an incomplete array type	N3273	Clang 3.5
Remove imaginary types	N3274	Yes
Floating-point exceptions for macro replacements	N3286	Yes
Obsolete implicitly octal literals and add delimited escape sequences	N3353	Clang 21
'if' declarations, v2	N3356	No
Allowing stricter alignment for atomic types	N3312	Yes
Slay Some Earthly Demons III	N3341	Yes
Slay Some Earthly Demons IV	N3342	Yes
Slay Some Earthly Demons VI	N3344	Clang 20
Slay Some Earthly Demons VII	N3345	Yes
Slay Some Earthly Demons VIII	N3346	Yes
Introduce complex literals v. 2	N3298	Yes
Allow zero length operations on null pointers	N3322	Yes
How do you add one to something?	N3323	Yes
Give consistent wording for SNAN initialization v3	N3364	Yes
Case range expressions v3.1	N3370	Yes
_Countof operator
	N3369	Clang 21
	N3469	Clang 21
Named loops, v3	N3355	No
Slay Some Earthly Demons IX	N3347	Yes
stdarg.h wording... v3	N3363	Clang 5
Preprocessor integer expressions, v. 2	N3505	Yes
Initialization of anonymous structures and unions	N3451	Yes
Slay Some Earthly Demons X	N3409	Clang 21
Slay Some Earthly Demons XI	N3410	No
Slay Some Earthly Demons XII	N3411	Clang 21
Slay Some Earthly Demons XIII	N3478	Yes
Slay Some Earthly Demons XIV	N3418	No
Slay Some Earthly Demons XVI	N3481	Yes
Slay Some Earthly Demons XVII	N3482	Yes
Clarify the specification of the width macros	N3496	Clang 20
Complex operators	N3460	Clang 12

C23 implementation status

Clang has support for some of the features of the C standard following C17, informally referred to as C23.

You can use Clang in C23 mode with the -std=c23 option (available in Clang 18 and later) or with the -std=c2x option (available in Clang 9 and later).

List of features and minimum Clang version with support

Language Feature	C23 Proposal	Available in Clang?
Evaluation formats	N2186	Unknown
Harmonizing static_assert with C++	N2665	Clang 9
nodiscard attribute	N2267	Clang 9
maybe_unused attribute	N2270	Clang 9
TS 18661 Integration
	N2314	Unknown
	N2341	No
	N2359	No
	N2546	No
	N2640	Yes
	N2755	No
	N2931	No
	N2754	No
Preprocessor line numbers unspecified	N2322	Partial The line number associated with a macro invocation is not the line number of the first character of the macro name in the invocation. Additionally, Clang may not associate the line number of a pp-directive with the first `#` token. As these are recommended practices and not normative requirements, Clang's behavior is still conforming.
deprecated attribute	N2334	Clang 9
Attributes
	N2335	Clang 9
	N2554	Clang 9
Defining new types in offsetof	N2350	Yes
fallthrough attribute	N2408	Clang 9
Two's complement sign representation	N2412	Clang 14
Adding the u8 character prefix	N2418	Clang 15
Remove support for function definitions with identifier lists	N2432	Clang 15
Annex F.8 update for implementation extensions and rounding	N2384	Unknown
_Bool definitions for true and false	N2393	Subsumed by N2935
[[nodiscard("should have a reason")]]	N2448	Clang 10
Allowing unnamed parameters in function definitions	N2480	Clang 11
Free positioning of labels inside compound statements	N2508	Clang 18
Querying attribute support	N2553	Clang 9
Binary literals	N2549	Clang 9
Allow duplicate attributes	N2557	Clang 13
Character encoding of diagnostic text	N2563	Yes
What we think we reserve	N2572	Partial
Remove mixed wide string literal concatenation	N2594	Clang 9
Update to IEC 60559:2020	N2600	Unknown
Compatibility of Pointers to Arrays with Qualifiers	N2607	Partial Much of the proposal is implemented, but Clang lacks pedantic diagnostics in C17 and earlier regarding use of incompatible pointer types as an extension. Further, Clang does not properly compute the correct result type for the `?:` operator when the result type should be a qualified array type.
Unclear type relationship between a format specifier and its argument	N2562	Clang 16
Digit separators	N2626	Clang 13
Missing +(x) in table	N2641	Yes
Add support for preprocessing directives elifdef and elifndef	N2645	Clang 13
[[maybe_unused]] for labels	N2662	Clang 16
Zeros compare equal	N2670	Yes
Negative values	N2671	Yes
5.2.4.2.2 cleanup	N2672	Yes
Towards Integer Safety	N2683	Clang 18
Adding Fundamental Type for N-bit Integers
	N2763	Clang 15
	N2775	Clang 15
	N2969	Clang 15
	N3035	Clang 15
#warning directive	N2686	Yes
Sterile characters	N2686	Yes
Numerically equal	N2716	Yes
char16_t & char32_t string literals shall be UTF-16 & UTF-32	N2728	Yes
IEC 60559 binding	N2749	Unknown
__has_include for C	N2799	Yes
Annex F overflow and underflow	N2747	Yes
Remove UB from Incomplete Types in Function Parameters	N2770	Yes
Variably-modified types	N2778	Yes
Types do not have types	N2781	Yes
5.2.4.2.2 cleanup (N2672 update)	N2806	Yes
Allow 16-bit ptrdiff_t	N2808	Yes
Proposal to update CFP freestanding requirements	N2823	Unknown
Types and sizes	N2838	Yes
Clarifying integer terms	N2837	Yes
Clarification for max exponent macros	N2843	Subsumed by N2882
Clarification about expression transformations	N2846	Unknown
Contradiction about INFINITY macro	N2848	Clang 19
Require exact-width integer type interfaces	N2872	Yes
@, $, and ‘ in the source/execution character set	N2701	Yes
The noreturn attribute	N2764	Clang 15
*_HAS_SUBNORM==0 implies what?	N2797	Yes
Disambiguate the storage class of some compound literals	N2819	Clang 21
Add annotations for unreachable control flow v2	N2826	Clang 17
Unicode Sequences More Than 21 Bits are a Constraint Violation r0	N2828	Clang 3.6
Identifier Syntax using Unicode Standard Annex 31	N2836	Clang 15
No function declarators without prototypes	N2841	Clang 15
Remove default argument promotions for _FloatN types	N2844	No
Revised Suggestions of Change for Numerically Equal/Equivalent	N2847	Yes
5.2.4.2.2 Cleanup, Again Again (N2806 update)	N2879	Yes
char8_t: A type for UTF-8 characters and strings	N2653	Clang 19
Clarification for max exponent macros-update	N2882	Unknown
Consistent, Warningless, and Intuitive Initialization with {}
	N2900	Clang 17
	N3011	Clang 17
Not-so-magic: typeof
	N2927	Clang 16
	N2930	Clang 16
Revise spelling of keywords v7	N2934	Clang 17
Make false and true first-class language features v8	N2935	Clang 15
Properly define blocks as part of the grammar v3	N2937	Yes
Annex X (replacing Annex H) for IEC 60559 interchange	N2601	No
Indeterminate Values and Trap Representations	N2861	Yes
Remove ATOMIC_VAR_INIT v2	N2886	Clang 17
Require exact-width integer type interfaces v2	N2888	Yes
Wording Change for Variably-Modified Types	N2992	Yes
Identifier syntax fixes	N2939	Clang 15
Remove trigraphs??!	N2940	Clang 18
Improved normal enumerations	N3029	Clang 20
Relax requirements for va_start	N2975	Clang 16
Enhanced enumerations	N3030	Clang 20
Freestanding C and IEC 60559 conformance scope reduction	N2951	Unknown
Unsequenced functions	N2956	No
Comma ommission and deletion (__VA_OPT__)	N3033	Clang 12
Underspecified object definitions	N3006	No
Type inference for object declarations	N3007	Clang 18
constexpr for object definitions	N3018	Clang 19
Introduce storage class specifiers for compound literals	N3038	No
Identifier primary expressions	N3034	Yes
Introduce the nullptr constant	N3042	Clang 17
Memory layout of unions	N2929	Yes
Improved tag compatibility	N3037	No
#embed	N3017	Clang 19

C17 implementation status

There are no major changes in this edition, only technical corrections and clarifications that are tracked by Defect Report.

You can use Clang in C17 mode with the -std=c17 or -std=c18 options (available in Clang 6 and later).

C11 implementation status

Clang implements a significant portion of the ISO 9899:2011 (C11) standard, but the status of individual proposals is still under investigation.

You can use Clang in C11 mode with the -std=c11 option (use -std=c1x in Clang 3.0 and earlier).

List of features and minimum Clang version with support

Language Feature	C11 Proposal	Available in Clang?
A finer-grained specification for sequencing	N1252	Unknown
Clarification of expressions	N1282	Yes
Extending the lifetime of temporary objects (factored approach)	N1285	Clang 21
Requiring signed char to have no padding bits	N1310	Yes
Initializing static or external variables	N1311	Yes
Conversion between pointers and floating types	N1316	Yes
Adding TR 19769 to the C Standard Library	N1326	Clang 3.3
Static assertions	N1330	Yes
Parallel memory sequencing model proposal	N1349	Unknown
_Bool bit-fields	N1356	Yes
Technical corrigendum for C1X	N1359	Yes
Benign typedef redefinition	N1360	Clang 3.1
Thread-local storage	N1364	Clang 3.3
Constant expressions	N1365	Clang 16
Contractions and expression evaluation methods	N1367	Unknown
Floating-point to int/_Bool conversions	N1391	Yes
Wide function returns (alternate proposal)	N1396	Yes* Clang conforms to this paper on all targets except 32-bit x86 without SSE2. However, Clang does not claim conformance to Annex F on any target and does not intend to ever conform to Annex F on that specific target, so no changes are needed to conform to this paper.
Alignment
	N1397	Clang 3.2
	N1447	Clang 3.2
Anonymous member-structures and unions (modulo "name lookup")	N1406	Yes
Completeness of types	N1439	Yes
Generic macro facility	N1441	Yes
Dependency ordering for C memory model	N1444	Unknown
Subsetting the standard	N1460	Yes
Assumed types in F.9.2	N1468	Unknown
Supporting the 'noreturn' property in C1x	N1478	Clang 3.3
Updates to C++ memory model based on formalization	N1480	Unknown
Explicit initializers for atomics	N1482	Clang 4
Atomics proposal (minus ternary op)	N1485	Yes
UTF-8 string literals	N1488	Clang 3.3
Optimizing away infinite loops	N1509	Yes
Conditional normative status for Annex G	N1514	Yes (1)
Creation of complex value	N1464	Clang 12
Recommendations for extended identifier characters for C and C++	N1518	Clang 15
Atomic C1x/C++0x compatibility refinements (1st part only)	N1526	Yes
Atomic bitfields implementation defined	N1530	Yes
Small fix for the effect of alignment on struct/union type compatibility	N1532	Yes
Clarification for wide evaluation	N1531	Unknown

(1): Clang does not implement Annex G, so our conditional support conforms by not defining the __STDC_IEC_559_COMPLEX__ macro.

C99 implementation status

Clang implements all of the ISO 9899:1999 (C99) standard.

Note, the list of C99 features comes from the C99 committee draft. Not all C99 documents are publicly available, so the documents referenced in this section may be inaccurate, unknown, or not linked.

You can use Clang in C99 mode with the -std=c99 option.

List of features and minimum Clang version with support

Language Feature	C99 Proposal	Available in Clang?
restricted character set support via digraphs and <iso646.h>	Unknown	Yes
more precise aliasing rules via effective type	Unknown	Yes
restricted pointers	N448	Partial Clang's support for `restrict` is fully conforming but considered only partially implemented. Clang implements all of the constraints required for `restrict` support, but LLVM only supports `restrict` optimization semantics for restricted pointers used as function parameters; it does not fully support the semantics for restrict on local variables or data members.
variable length arrays	N683	Yes
flexible array members	Unknown	Yes
static and type qualifiers in parameter array declarators	Unknown	Yes
complex and imaginary support in <complex.h>	N693	Partial Clang supports `_Complex` type specifiers but does not support `_Imaginary` type specifiers. Support for `_Imaginary` is optional in C99 and Clang does not claim conformance to Annex G. `_Complex` support requires an underlying support library such as compiler-rt to provide functions like `__divsc3`. Compiler-rt isn't linked in automatically in MSVC style environments.
type-generic math macros in <tgmath.h>	N693	Yes
the long long int type	N601	Yes
increase minimum translation limits	N590	Clang 3.2
additional floating-point characteristics in <float.h>	Unknown	Clang 16
remove implicit int
	N635	Yes
	N692	Yes
	N722	Yes
reliable integer division	N617	Yes
universal character names (\u and \U)	Unknown	Yes
extended identifiers	N717	Clang 17
hexadecimal floating-point constants	N308	Yes
compound literals	N716	Yes
designated initializers	N494	Yes
// comments	N644	Yes
extended integer types and library functions in <inttypes.h> and <stdint.h>	Unknown	Yes
remove implicit function declaration	N636	Yes
preprocessor arithmetic done in intmax_t/uintmax_t	N736	Yes
mixed declarations and code	N740	Yes
new block scopes for selection and iteration statements	Unknown	Yes
integer constant type rules	N629	Yes
integer promotion rules	N725	Yes
macros with a variable number of arguments	N707	Yes
IEC 60559 support	Unknown	Partial Clang supports much of the language requirements for Annex F, but full conformance is only possible to determine when considering the compiler's language support, the C runtime library's math library support, and the target system's floating-point environment support. Clang does not currently raise an "invalid" floating-point exception on certain conversions, does not raise floating-point exceptions for arithmetic constant expressions, and other corner cases. Note, Clang does not define `__STDC_IEC_559__` because the compiler does not fully conform. However, some C standard library implementations ( glibc, musl will define the macro regardless of compiler support unless the compiler defines `__GCC_IEC_559`, which Clang does not currently define. Additionally, Clang intentionally will not conform to Annex F on 32-bit x86 without SSE2 due to the behavior of floating-point operations in x87.
trailing comma allowed in enum declaration	Unknown	Yes
inline functions	N741	Yes
boolean type in <stdbool.h>	N815	Yes
idempotent type qualifiers	N505	Yes
empty macro arguments	N570	Yes
additional predefined macro names	Unknown	Yes
_Pragma preprocessing operator	N634	Yes
standard pragmas
	N631	Yes
	N696	Yes
__func__ predefined identifier	N611	Yes
va_copy macro	N671	Yes
remove deprecation of aliased array parameters	Unknown	Yes
conversion of array to pointer not limited to lvalues	N835	Yes
relaxed constraints on aggregate and union initialization	N782	Clang 3.4
relaxed restrictions on portable header names	N772	Yes
return without an expression not permitted in function that returns a value	Unknown	Yes

C89 implementation status

Clang implements all of the ISO 9899:1990 (C89) standard.

You can use Clang in C89 mode with the -std=c89 or -std=c90 options.