diff --git a/share/man/man9/cdefs.9 b/share/man/man9/cdefs.9 index 0edd6e8392ca..b9821c70f2a1 100644 --- a/share/man/man9/cdefs.9 +++ b/share/man/man9/cdefs.9 @@ -1,469 +1,474 @@ .\"- .\" Copyright (c) 2024 M. Warner Losh .\" .\" SPDX-License-Identifier: BSD-2-Clause .\" -.Dd November 20, 2024 +.Dd December 6, 2024 .Dt CDEFS 9 .Os .Sh NAME .Nm cdefs .Nd compiler portability macro definitions .Sh DESCRIPTION .In sys/cdefs.h defines macros for compiler, C language standard portability, POSIX standards compliance and symbol visibility. It defines programming interfaces for the system header files to adopt to the many environments .Fx supports compilation for. It defines convenience macros for the .Fx sources, tailored to the base system's needs. .Pp Most of these macros are for use inside the .Fx sources only. They are not intended as a general portability layer. .Sh Supported Compilers .Bl -tag -offset 2n -width 0 .It Compilers supported for building programs on Fx : .Bl -column -offset 0n indent-two .It Sy Compiler Ta Sy Versions .It gcc Ta 9, 10, 11, 12, 13, 14 .It clang Ta 10, 11, 12, 13, 14, 15, 16, 17, 18 .It TinyC (tcc) Ta 0.9 .It pcc Ta 1.1 .El .Pp Due to testing constraints, tcc and pcc may not always work. .It Compilers supported for building Fx itself: .Bl -column -offset 0n indent-two .It Sy Compiler Ta Sy Major Versions Supported .It gcc Ta 12, 13, 14 .It clang Ta 16, 17, 18 .El .Pp Please note: Not every single minor versions of these compilers will work or are supported. .El .Sh Macros and Magic for Programming Environment .Nm defines (or refrains from defining) a number of macros to increase portability of compiled programs. These are to allow more advanced language features to appear in header files. The header files assume a compiler that accepts C prototype function declarations. They also assume that the compiler accepts ANSI C89 keywords for all language dialects. .Ss General Macros General macros that facilitate multiple language environments and language dialects. .Bl -column "---------------" .It Sy Macro Ta Sy Description .It Dv __volatile Ta expands to volatile in C++ and C89 and newer environments, __volatile in pre-ANSI environments that support this extension or nothing otherwise. .It Dv __inline Ta expands to inline in C++ and C89 and newer environments, __inline in pre-ANSI environments that support this extension or nothing otherwise. .It Dv __restrict Ta expands to restrict in C99 and newer environments, or __restrict otherwise. .It Dv __CONCAT Ta used to paste two pre-processor tokens. .It Dv __STRING Ta used to convert the argument to a string. .It Dv __BEGIN_DECLS Ta Start a group of functions. .It Dv __END_DECLS Ta End a group of functions. In a C environment, these are defined as nothing. In a C++ environment, these declare the functions to have .Dq C linkage. .El .Ss Function, Structure and Variable Modifiers .Bl -column "---------------" .It Sy Macro Ta Sy Description .It Sy __weak_symbol Ta Declare the symbol to be a weak symbol .It Sy __dead2 Ta Function will not return .It Sy __pure2 Ta Function has no side effects .It Sy __unused Ta To Variable may be unused (usually arguments), so do not warn about it .It Sy __used Ta Function really is used, so emit it even if it appears unused. .It Sy __deprecated Ta Function interface has been deprecated, and clients should migrate to a new interface. A warning will be issued for clients of this interface. +.It Sy __deprecated1(msg) Ta Function interface has been deprecated, and clients +should migrate to a new interface. +The string +.Fa msg +will be included in a warning issued for clients of this interface. .It Sy __packed Ta \&Do not have space between structure elements for natural alignment. Used when communicating with external protocols. .It Sy __aligned(x) Ta Specify in bytes the minimum alignment for the specified field, structure or variable .It Sy __section(x) Ta Place function or variable in section Fa x .It Sy __writeonly Ta Hint that the variable is only assigned to, but do not warn about it. Useful for macros and other places the eventual use of the result is unknown. .It Sy __alloc_size(x) Ta The function always returns at least the number of bytes determined by argument number Fa x .It Sy __alloc_size2(x,n) Ta The function always returns an array, whose size is at least the number of bytes determined by argument number Fa x times the number of elements specified by argument number Fa n .It Sy __alloc_align(x) Ta Function either returns a pointer aligned to Fa x bytes or Dv NULL. .It Sy __min_size Ta Declare the array to have a certain, minimum size .It Sy __malloc_like Ta Function behaves like the .Dq malloc family of functions. .It Sy __pure Ta Function has no side effects .It Sy __always_inline Ta Always inline this function when called .It Sy __fastcall Ta Use the .Dq fastcall ABI to call and name mangle this function. .It Sy __result_use_check Ta Warn if function caller does not use it's return value .It Sy __result_use_or_ignore_check Ta Warn if function caller does not use it's return value. Allows the value to be explicitly ignored with a (void) cast. .It Sy __returns_twice Ta Returns multiple times, like .Xr fork 2 .It Sy __unreachable Ta This code is not reachable at runtime .It Sy __predict_true(x) Ta Hint to the compiler that .Fa x is true most of the time. Should only be used when performance is improved for a frequently called bit of code. .It Sy __predict_false(x) Ta Hint to the compiler that .Fa x is false most of the time. Should only be used when performance is improved for a frequently called bit of code. .It Sy __null_sentinel Ta The varadic function contains a parameter that is a NULL sentinel to mark the end of its arguments. .It Sy __exported Ta .It Sy __hidden Ta .It Sy __printflike(fmtarg,firstvararg) Ta Function is similar to .Fn printf which specifies the format argument with .Fa fmtarg and where the arguments formatted by that format start with the .Fa firstvararg , with 0 meaning that .Dv va_arg is used and cannot be checked. .It Sy __scanflike(fmtarg,firstvararg) Ta Function is similar to .Fn scanf which specifies the format argument with .Fa fmtarg and where the arguments formatted by that format start with the .Fa firstvararg , with 0 meaning that .Dv va_arg is used and cannot be checked. .It Sy __format_arg(f) Ta Specifies that arg .Fa f contains a string that will be passed to a function like .Fn printf or .Fa scanf after being translated in some way. .It Sy __strfmonlike(fmtarg,firstvararg) Ta Function is similar to .Fn scanf which specifies the format argument with .Fa fmtarg and where the arguments formatted by that format start with the .Fa firstvararg , with 0 meaning that .Dv va_arg is used and cannot be checked. .It Sy __strtimelike(fmtarg,firstvararg) Ta Function is similar to .Fn scanf which specifies the format argument with .Fa fmtarg and where the arguments formatted by that format start with the .Fa firstvararg , with 0 meaning that .Dv va_arg is used and cannot be checked. .It Sy __printf0like(fmtarg,firstvararg) Ta Exactly the same as .Sy __printflike except .Fa fmtarg may be .Dv NULL. .It Sy __strong_reference(sym,aliassym) Ta .It Sy __weak_reference(sym,alias) Ta .It Sy __warn_references(sym,msg) Ta .It Sy __sym_compat(sym,impl,verid) Ta .It Sy __sym_default(sym,impl,verid) Ta .It Sy __GLOBAL(sym) Ta .It Sy __WEAK(sym) Ta .It Sy __DECONST(type,var) Ta .It Sy __DEVOLATILE(type,var) Ta .It Sy __DEQUALIFY(type,var) Ta .It Sy __RENAME(x) Ta .It Sy __arg_type_tag Ta .It Sy __datatype_type_tag Ta .It Sy __align_up(x,y) Ta .It Sy __align_down(x,y) Ta .It Sy __is_aligned(x,y) Ta .El .Ss Locking and Debugging Macros Macros for lock annotation and debugging, as well as some general debugging macros for address sanitizers. .Bl -column "---------------" .It Sy __lock_annotate(x) Ta .It Sy __lockable Ta .It Sy __locks_exclusive Ta .It Sy __locks_shared Ta .It Sy __trylocks_exclusive Ta .It Sy __trylocks_shared Ta .It Sy __unlocks Ta .It Sy __asserts_exclusive Ta .It Sy __asserts_shared Ta .It Sy __requires_exclusive Ta .It Sy __requires_shared Ta .It Sy __requires_unlocked Ta .It Sy __no_lock_analysis Ta .It Sy __nosanitizeaddress Ta .It Sy __nosanitizememory Ta .It Sy __nosanitizethread Ta .It Sy __nostackprotector Ta .It Sy __guarded_by(x) Ta .It Sy __pt_guarded_by(x) Ta .El .Ss Emulated Keywords As C evolves, many of the old macros we once used have been incorporated into the standard language. As this happens, we add support for these keywords as macros for older compilation environments. Sometimes this results in a nop in the older environment. .Bl -column "---------------" .It Sy Keyword Ta Sy Description .It Sy _Alignas(x) Ta .It Sy _Alignof(x) Ta .It Sy _Noreturn Ta Expands to .Dq [[noreturn]] in C++-11 and newer compilation environments, otherwise .Dq __dead2 .It Sy _Static_assert(x, y) Ta Compile time assertion that .Fa x is true, otherwise emit .Fa y as the error message. .It Sy _Thread_local Ta Designate variable as thread local storage .It Sy __generic Ta implement _Generic-like features which aren't entirely possible to emulate the _Generic keyword .It Sy __noexcept Ta to emulate the C++11 argument-less noexcept form .It Sy __noexcept_if Ta to emulate the C++11 conditional noexcept form .It Sy _Nonnull Ta .It Sy _Nullable Ta .It Sy _Null_unspecified Ta .El .Ss Support Macros The following macros are defined, or have specific values, to denote certain things about the build environment. .Bl -column "---------------" .It Sy Macro Ta Sy Description .It Sy __LONG_LONG_SUPPORTED Ta Variables may be declared .Dq long long . This is defined for C99 or newer and C++ environments. .It Sy __STDC_LIMIT_MACROS Ta .It Sy __STDC_CONSTANT_MACROS Ta .El .Ss Convenience Macros These macros make it easier to do a number of things, even though strictly speaking the standard places their normal form in another header. .Bl -column "---------------" .It Sy Macro Ta Sy Description .It Sy __offsetof(type,field) Ta .It Sy __rangeof(type,start,end) Ta .It Sy __containerof(x,s,m) Ta .El .Ss ID Strings This section is deprecated, but is kept around because too much contrib software still uses these. .Bl -column "---------------" .It Sy Macro Ta Sy Description .It Sy __IDSTRING(name,string) Ta .It Sy __FBSDID(s) Ta .It Sy __RCSID(s) Ta .It Sy __RCSID_SOURCE(s) Ta .It Sy __SCCSID(s) Ta .It Sy __COPYRIGHT(s) Ta .El .Sh Supported C Environments .Fx supports a number C standard environments. Selection of the language dialect is a compiler-dependent command line option, though it is usually .Fl std=XX where XX is the standard to set for compiling, such as c89 or c23. .Fx provides a number of selection macros to control visibility of symbols. Please see the section on Selection Macros for the specifics. .Pp .Bl -tag .It K \*(Am R Pre-ANSI Kernighan and Ritchie C. Sometimes called .Dq knr or .Dq C78 to distinguish it from newer standards. Support for this compilation environment is dependent on compilers supporting this configuration. Most of the old forms of C have been deprecated or removed in .St -isoC-2024 . Compilers make compiling in this mode increasingly difficult and support for it may ultimately be removed from the tree. .It St -ansiC .Dv __STDC__ is defined, however .Dv __STDC_VERSION__ is not. .Pp Strict environment selected with .Dv _ANSI_SOURCE . .It St -isoC-99 .Dv __STDC_VERSION__ = 199901L .Pp Strict environment selected with .Dv _C99_SOURCE . .It St -isoC-2011 .Dv __STDC_VERSION__ = 201112L .Pp Strict environment selected with .Dv _C11_SOURCE . .It ISO/IEC 9899:2018 (“ISO C17”) .Dv __STDC_VERSION__ = 201710L .Pp Strict environment selected with .Dv _C11_SOURCE since there are no new C17 only symbols or macros. .Pp This version of the standard did not introduce any new features, only made minor, technical corrections. .It St -isoC-2024 .Dv __STDC_VERSION__ = 202311L Strict environment selected with .Dv _C23_SOURCE though ISO C23 support is only partially implemented. .El .Pp For more information on C standards, see .Xr c 7 . .Ss Programming Environment Selection Macros Defining the macros outlined below requests that the system header files provide only the functions, structures and macros (symbols) defined by the appropriate standard, while suppressing all extensions. However, system headers not defined by that standard may define extensions. .Bl -column "---------------" .It Sy Macro Ta Sy Environment .It Dv _POSIX_SOURCE Ta St -p1003.1-88 including St -ansiC .It Dv _POSIX_C_SOURCE = 1 Ta St -p1003.1-88 including St -ansiC .It Dv _POSIX_C_SOURCE = 2 Ta St -p1003.1-90 including St -ansiC .It Dv _POSIX_C_SOURCE = 199309 Ta St -p1003.1b-93 including St -ansiC .It Dv _POSIX_C_SOURCE = 199506 Ta St -p1003.1c-95 including St -ansiC .It Dv _POSIX_C_SOURCE = 200112 Ta St -p1003.1-2001 including St -isoC-99 .It Dv _POSIX_C_SOURCE = 200809 Ta St -p1003.1-2008 including St -isoC-99 .It Dv _POSIX_C_SOURCE = 202405 Ta St -p1003.1-2024 including ISO/IEC 9899:2018 ("ISO C17"), .It Dv _XOPEN_SOURCE defined Ta St -p1003.1-90 with XPG Extensions to St -susv1 including St -ansiC . However, .Fx implements this as a NOP because too much software breaks with the correct strict environment. .It Dv _XOPEN_SOURCE = 500 Ta St -p1003.1c-95 and XPG extensions to St -susv2 including St -ansiC .It Dv _XOPEN_SOURCE = 600 Ta St -p1003.1-2001 and XPG extensions to St -susv3 including St -isoC-99 .It Dv _XOPEN_SOURCE = 700 Ta St -p1003.1-2008 and XPG extensions to St -susv4 including St -isoC-99 .It Dv _XOPEN_SOURCE = 800 Ta St -p1003.1-2024 and XPG extensions to Version 5 of the Single UNIX Specification (“SUSv5”) including ISO/IEC 9899:2018 (“ISO C17”) .It Dv _ANSI_SOURCE Ta St -ansiC .It Dv _C99_SOURCE Ta St -isoC-99 .It Dv _C11_SOURCE Ta St -isoC-2011 .It Dv _C23_SOURCE Ta St -isoC-2024 .It Dv _BSD_SOURCE Ta Everything, including Fx extensions .El .Pp Note: .St -p1003.1-2024 and XPG extensions to Version 5 of the Single UNIX Specification ("SUSv5") support is incomplete. .Pp When both POSIX and C environments are selected, the POSIX environment selects which C environment is used. However, when C11 dialect is selected with .St -p1003.1-2008 , definitions for .St -isoC-2011 are also included. Likewise, when C23 dialog is selected with .St -p1003.1-2008 or .St -p1003.1-2024 , definitions for .St -isoC-2024 are also included. .Ss Header Visibility Macros These macros are set by .Nm to control the visibility of different standards. Users should not use these, but they are documented here for developers. .Bl -column "---------------" .It Dv __XSI_VISIBLE Ta Restricts the visibility of XOPEN Single Unix Standard version. Possible values are 500, 600, 700 or 800, corresponding to Issue 5, 6, 7, or 8 of the Single Unix Standard. These are extra functions in addition to the normal POSIX ones. .It Dv __POSIX_VISIBLE Ta Make symbols associated with certain standards versions visible. Set to the value assigned to .Dv _POSIX_C_SOURCE by convention with 199009 for .St -p1003.1-88 and 199209 .St -p1003.1-90 . .It Dv __ISO_C_VISIBLE Ta The C level that's visible. Possible values include 1990, 1999, 2011, 2017 and 2023 for .St -isoC-90 , .St -isoC-99 , .St -isoC-2011 , ISO/IEC 9899:2018 ("ISO C17"), and .St -isoC-2024 , respectively. .It Dv __BSD_VISIBLE Ta 1 if the .Fx extensions are visible, 0 otherwise. .It Dv __EXT1_VISIBLE Ta 1 if the .St -isoC-2011 Appendix K 3.7.4.1 extensions are visible, 0 otherwise. .El .Sh Supported C++ Environments .Fx supports C++11 and newer standards fully. .Bl -tag .It ISO/IEC 14882:1998 ("C++98") .Dv __cplusplus = 199711 .Pp The first standardized version of C++. Unlike K \*(Am R support in C, compilers dropped support for versions of the language prior to C++98. .It ISO/IEC 14882:2003 ("C++03") .Dv __cplusplus = 199711 .Pp Note, this is the same value as C++98. C++03 did not define a new value for .Dv __cplusplus . There is no way, at compile time, to detect the difference. The standard resolved a number of defect reports and slightly expanded value initialization. Most compilers support it the same as C++98. .It ISO/IEC 14882:2011 ("C++11") .Dv __cplusplus = 201103 .It ISO/IEC 14882:2014 ("C++14") .Dv __cplusplus = 201402 .It ISO/IEC 14882:2017 ("C++17") .Dv __cplusplus = 201703 .It ISO/IEC 14882:2020 ("C++20") .Dv __cplusplus = 202002 .It ISO/IEC 14882:2023 ("C++23") .Dv __cplusplus = 202302 .El .Pp .Fx uses llvm project's libc++. However, they are removing support for C++ prior to C++11. While programs can still build with earlier environments for now, these changes mean that .Fl pedantic-errors cannot be reliably enabled for standards older than C++11. .Sh HISTORY .In sys/cdefs.h first appeared in .Bx 4.3 NET/2 . diff --git a/sys/sys/cdefs.h b/sys/sys/cdefs.h index 4f4f09a3d763..c46be9f35842 100644 --- a/sys/sys/cdefs.h +++ b/sys/sys/cdefs.h @@ -1,808 +1,809 @@ /*- * SPDX-License-Identifier: BSD-3-Clause * * Copyright (c) 1991, 1993 * The Regents of the University of California. All rights reserved. * * This code is derived from software contributed to Berkeley by * Berkeley Software Design, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #ifndef _SYS_CDEFS_H_ #define _SYS_CDEFS_H_ #if defined(_KERNEL) && defined(_STANDALONE) #error "_KERNEL and _STANDALONE are mutually exclusive" #endif /* * Provide clang-compatible testing macros. All supported versions of gcc (10+) * provide all of these except has_feature and has_extension which are new in * gcc 14. Keep the older ifndefs, though, for non-gcc compilers that may lack * them like tcc and pcc. */ #ifndef __has_attribute #define __has_attribute(x) 0 #endif #ifndef __has_extension #define __has_extension __has_feature #endif #ifndef __has_feature #define __has_feature(x) 0 #endif #ifndef __has_include #define __has_include(x) 0 #endif #ifndef __has_builtin #define __has_builtin(x) 0 #endif #if defined(__cplusplus) #define __BEGIN_DECLS extern "C" { #define __END_DECLS } #else #define __BEGIN_DECLS #define __END_DECLS #endif /* * This code has been put in place to help reduce the addition of * compiler specific defines in FreeBSD code. It helps to aid in * having a compiler-agnostic source tree. */ /* * Macro to test if we're using a specific version of gcc or later. */ #if defined(__GNUC__) #define __GNUC_PREREQ__(ma, mi) \ (__GNUC__ > (ma) || __GNUC__ == (ma) && __GNUC_MINOR__ >= (mi)) #else #define __GNUC_PREREQ__(ma, mi) 0 #endif #if defined(__GNUC__) /* * Compiler memory barriers, specific to gcc and clang. */ #define __compiler_membar() __asm __volatile(" " : : : "memory") #define __CC_SUPPORTS___INLINE 1 #define __CC_SUPPORTS_SYMVER 1 #endif /* __GNUC__ */ /* * TinyC pretends to be gcc 9.3. This is generally good enough to support * everything FreeBSD... except for the .symver assembler directive. */ #ifdef __TINYC__ #undef __CC_SUPPORTS_SYMVER #endif /* * The __CONCAT macro is used to concatenate parts of symbol names, e.g. * with "#define OLD(foo) __CONCAT(old,foo)", OLD(foo) produces oldfoo. * The __CONCAT macro is a bit tricky to use if it must work in non-ANSI * mode -- there must be no spaces between its arguments, and for nested * __CONCAT's, all the __CONCAT's must be at the left. __CONCAT can also * concatenate double-quoted strings produced by the __STRING macro, but * this only works with ANSI C. * * __XSTRING is like __STRING, but it expands any macros in its argument * first. It is only available with ANSI C. */ #if defined(__STDC__) || defined(__cplusplus) #define __P(protos) protos /* full-blown ANSI C */ #define __CONCAT1(x,y) x ## y #define __CONCAT(x,y) __CONCAT1(x,y) #define __STRING(x) #x /* stringify without expanding x */ #define __XSTRING(x) __STRING(x) /* expand x, then stringify */ #define __volatile volatile #if defined(__cplusplus) #define __inline inline /* convert to C++ keyword */ #else #if !(defined(__CC_SUPPORTS___INLINE)) #define __inline /* delete GCC keyword */ #endif /* ! __CC_SUPPORTS___INLINE */ #endif /* !__cplusplus */ #else /* !(__STDC__ || __cplusplus) */ #define __P(protos) () /* traditional C preprocessor */ #define __CONCAT(x,y) x/**/y #define __STRING(x) "x" #if !defined(__CC_SUPPORTS___INLINE) /* Just delete these in a K&R environment */ #define __inline #define __volatile #endif /* !__CC_SUPPORTS___INLINE */ #endif /* !(__STDC__ || __cplusplus) */ /* * Compiler-dependent macros to help declare dead (non-returning) and pure (no * side effects) functions, and unused variables. These attributes are supported * by all current compilers, even pcc. */ #define __weak_symbol __attribute__((__weak__)) #define __dead2 __attribute__((__noreturn__)) #define __pure2 __attribute__((__const__)) #define __unused __attribute__((__unused__)) #define __used __attribute__((__used__)) #define __deprecated __attribute__((__deprecated__)) +#define __deprecated1(msg) __attribute__((__deprecated__(msg))) #define __packed __attribute__((__packed__)) #define __aligned(x) __attribute__((__aligned__(x))) #define __section(x) __attribute__((__section__(x))) #define __writeonly __unused #define __alloc_size(x) __attribute__((__alloc_size__(x))) #define __alloc_size2(n, x) __attribute__((__alloc_size__(n, x))) #define __alloc_align(x) __attribute__((__alloc_align__(x))) /* * Keywords added in C11. */ #if !defined(__STDC_VERSION__) || __STDC_VERSION__ < 201112L #if !__has_extension(c_alignas) #if (defined(__cplusplus) && __cplusplus >= 201103L) || \ __has_extension(cxx_alignas) #define _Alignas(x) alignas(x) #else /* XXX: Only emulates _Alignas(constant-expression); not _Alignas(type-name). */ #define _Alignas(x) __aligned(x) #endif #endif #if defined(__cplusplus) && __cplusplus >= 201103L #define _Alignof(x) alignof(x) #else #define _Alignof(x) __alignof(x) #endif #if defined(__cplusplus) && __cplusplus >= 201103L #define _Noreturn [[noreturn]] #else #define _Noreturn __dead2 #endif #if !__has_extension(c_static_assert) #if (defined(__cplusplus) && __cplusplus >= 201103L) || \ __has_extension(cxx_static_assert) #define _Static_assert(x, y) static_assert(x, y) #endif #endif #if !__has_extension(c_thread_local) #if (defined(__cplusplus) && __cplusplus >= 201103L) || \ __has_extension(cxx_thread_local) #define _Thread_local thread_local #else #define _Thread_local __thread #endif #endif #endif /* __STDC_VERSION__ || __STDC_VERSION__ < 201112L */ /* * Emulation of C11 _Generic(). Unlike the previously defined C11 * keywords, it is not possible to implement this using exactly the same * syntax. Therefore implement something similar under the name * __generic(). Unlike _Generic(), this macro can only distinguish * between a single type, so it requires nested invocations to * distinguish multiple cases. * * Note that the comma operator is used to force expr to decay in * order to match _Generic(). */ #if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || \ __has_extension(c_generic_selections) #define __generic(expr, t, yes, no) \ _Generic(expr, t: yes, default: no) #elif !defined(__cplusplus) #define __generic(expr, t, yes, no) \ __builtin_choose_expr(__builtin_types_compatible_p( \ __typeof(((void)0, (expr))), t), yes, no) #endif /* * C99 Static array indices in function parameter declarations. Syntax such as: * void bar(int myArray[static 10]); * is allowed in C99 but not in C++. Define __min_size appropriately so * headers using it can be compiled in either language. Use like this: * void bar(int myArray[__min_size(10)]); */ #if !defined(__cplusplus) && \ (!defined(__STDC_VERSION__) || (__STDC_VERSION__ >= 199901)) #define __min_size(x) static (x) #else #define __min_size(x) (x) #endif #define __malloc_like __attribute__((__malloc__)) #define __pure __attribute__((__pure__)) #define __always_inline __inline __attribute__((__always_inline__)) #define __noinline __attribute__ ((__noinline__)) #define __fastcall __attribute__((__fastcall__)) #define __result_use_check __attribute__((__warn_unused_result__)) #ifdef __clang__ /* * clang and gcc have different semantics for __warn_unused_result__: the latter * does not permit the use of a void cast to suppress the warning. Use * __result_use_or_ignore_check in places where a void cast is acceptable. * This can be implemented by [[nodiscard]] from C23. */ #define __result_use_or_ignore_check __result_use_check #else #define __result_use_or_ignore_check #endif /* !__clang__ */ #define __returns_twice __attribute__((__returns_twice__)) #define __unreachable() __builtin_unreachable() #if !defined(__STRICT_ANSI__) || __STDC_VERSION__ >= 199901 #define __LONG_LONG_SUPPORTED #endif /* C++11 exposes a load of C99 stuff */ #if defined(__cplusplus) && __cplusplus >= 201103L #define __LONG_LONG_SUPPORTED #ifndef __STDC_LIMIT_MACROS #define __STDC_LIMIT_MACROS #endif #ifndef __STDC_CONSTANT_MACROS #define __STDC_CONSTANT_MACROS #endif #endif /* * noexcept keyword added in C++11. */ #if defined(__cplusplus) && __cplusplus >= 201103L #define __noexcept noexcept #define __noexcept_if(__c) noexcept(__c) #else #define __noexcept #define __noexcept_if(__c) #endif /* * We use `__restrict' as a way to define the `restrict' type qualifier * without disturbing older software that is unaware of C99 keywords. * GCC also provides `__restrict' as an extension to support C99-style * restricted pointers in other language modes. */ #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901 #define __restrict restrict #endif /* * All modern compilers have explicit branch prediction so that the CPU back-end * can hint to the processor and also so that code blocks can be reordered such * that the predicted path sees a more linear flow, thus improving cache * behavior, etc. Use sparingly, except in performance critical code where * they make things measurably faster. */ #define __predict_true(exp) __builtin_expect((exp), 1) #define __predict_false(exp) __builtin_expect((exp), 0) #define __null_sentinel __attribute__((__sentinel__)) #define __exported __attribute__((__visibility__("default"))) #define __hidden __attribute__((__visibility__("hidden"))) /* * We define this here since , , and * require it. */ #define __offsetof(type, field) __builtin_offsetof(type, field) #define __rangeof(type, start, end) \ (__offsetof(type, end) - __offsetof(type, start)) /* * Given the pointer x to the member m of the struct s, return * a pointer to the containing structure. When using GCC, we first * assign pointer x to a local variable, to check that its type is * compatible with member m. */ #define __containerof(x, s, m) ({ \ const volatile __typeof(((s *)0)->m) *__x = (x); \ __DEQUALIFY(s *, (const volatile char *)__x - __offsetof(s, m));\ }) /* * Compiler-dependent macros to declare that functions take printf-like * or scanf-like arguments. */ #define __printflike(fmtarg, firstvararg) \ __attribute__((__format__ (__printf__, fmtarg, firstvararg))) #define __scanflike(fmtarg, firstvararg) \ __attribute__((__format__ (__scanf__, fmtarg, firstvararg))) #define __format_arg(fmtarg) __attribute__((__format_arg__ (fmtarg))) #define __strfmonlike(fmtarg, firstvararg) \ __attribute__((__format__ (__strfmon__, fmtarg, firstvararg))) #define __strftimelike(fmtarg, firstvararg) \ __attribute__((__format__ (__strftime__, fmtarg, firstvararg))) /* * Like __printflike, but allows fmtarg to be NULL. FreeBSD invented 'printf0' * for this because older versions of gcc issued warnings for NULL first args. * Clang has always had printf and printf0 as aliases. gcc 11.0 now follows * clang. So now this is an alias for __printflike, or nothing. In the future * _Nullable or _Nonnull will replace this. * XXX Except that doesn't work, so for now revert to printf0 for clang and * the FreeBSD gcc until I can work this out. */ #if defined(__clang__) || (defined(__GNUC__) && defined (__FreeBSD_cc_version)) #define __printf0like(fmtarg, firstvararg) \ __attribute__((__format__ (__printf0__, fmtarg, firstvararg))) #else #define __printf0like(fmtarg, firstvararg) #endif #define __strong_reference(sym,aliassym) \ extern __typeof (sym) aliassym __attribute__ ((__alias__ (#sym))) #ifdef __STDC__ #define __weak_reference(sym,alias) \ __asm__(".weak " #alias); \ __asm__(".equ " #alias ", " #sym) #define __warn_references(sym,msg) \ __asm__(".section .gnu.warning." #sym); \ __asm__(".asciz \"" msg "\""); \ __asm__(".previous") #ifdef __CC_SUPPORTS_SYMVER #define __sym_compat(sym,impl,verid) \ __asm__(".symver " #impl ", " #sym "@" #verid) #define __sym_default(sym,impl,verid) \ __asm__(".symver " #impl ", " #sym "@@@" #verid) #endif #else #define __weak_reference(sym,alias) \ __asm__(".weak alias"); \ __asm__(".equ alias, sym") #define __warn_references(sym,msg) \ __asm__(".section .gnu.warning.sym"); \ __asm__(".asciz \"msg\""); \ __asm__(".previous") #ifdef __CC_SUPPORTS_SYMVER #define __sym_compat(sym,impl,verid) \ __asm__(".symver impl, sym@verid") #define __sym_default(impl,sym,verid) \ __asm__(".symver impl, sym@@@verid") #endif #endif /* __STDC__ */ #define __GLOBL(sym) __asm__(".globl " __XSTRING(sym)) #define __WEAK(sym) __asm__(".weak " __XSTRING(sym)) #define __IDSTRING(name,string) __asm__(".ident\t\"" string "\"") /* * Embed the rcs id of a source file in the resulting library. Note that in * more recent ELF binutils, we use .ident allowing the ID to be stripped. * Usage: */ #ifndef __FBSDID #if !defined(STRIP_FBSDID) #define __FBSDID(s) __IDSTRING(__CONCAT(__rcsid_,__LINE__),s) #else #define __FBSDID(s) struct __hack #endif #endif #ifndef __RCSID #ifndef NO__RCSID #define __RCSID(s) __IDSTRING(__CONCAT(__rcsid_,__LINE__),s) #else #define __RCSID(s) struct __hack #endif #endif #ifndef __RCSID_SOURCE #ifndef NO__RCSID_SOURCE #define __RCSID_SOURCE(s) __IDSTRING(__CONCAT(__rcsid_source_,__LINE__),s) #else #define __RCSID_SOURCE(s) struct __hack #endif #endif #ifndef __SCCSID #ifndef NO__SCCSID #define __SCCSID(s) __IDSTRING(__CONCAT(__sccsid_,__LINE__),s) #else #define __SCCSID(s) struct __hack #endif #endif #ifndef __COPYRIGHT #ifndef NO__COPYRIGHT #define __COPYRIGHT(s) __IDSTRING(__CONCAT(__copyright_,__LINE__),s) #else #define __COPYRIGHT(s) struct __hack #endif #endif #ifndef __DECONST #define __DECONST(type, var) ((type)(__uintptr_t)(const void *)(var)) #endif #ifndef __DEVOLATILE #define __DEVOLATILE(type, var) ((type)(__uintptr_t)(volatile void *)(var)) #endif #ifndef __DEQUALIFY #define __DEQUALIFY(type, var) ((type)(__uintptr_t)(const volatile void *)(var)) #endif #if !defined(_STANDALONE) && !defined(_KERNEL) #define __RENAME(x) __asm(__STRING(x)) #else /* _STANDALONE || _KERNEL */ #define __RENAME(x) no renaming in kernel/standalone environment #endif /*- * The following definitions are an extension of the behavior originally * implemented in , but with a different level of granularity. * POSIX.1 requires that the macros we test be defined before any standard * header file is included. * * Here's a quick run-down of the versions (and some informal names) * defined(_POSIX_SOURCE) 1003.1-1988 * encoded as 198808 below * _POSIX_C_SOURCE == 1 1003.1-1990 * encoded as 199009 below * _POSIX_C_SOURCE == 2 1003.2-1992 C Language Binding Option * encoded as 199209 below * _POSIX_C_SOURCE == 199309 1003.1b-1993 * (1003.1 Issue 4, Single Unix Spec v1, Unix 93) * _POSIX_C_SOURCE == 199506 1003.1c-1995, 1003.1i-1995, * and the omnibus ISO/IEC 9945-1: 1996 * (1003.1 Issue 5, Single Unix Spec v2, Unix 95) * _POSIX_C_SOURCE == 200112 1003.1-2001 (1003.1 Issue 6, Unix 03) * with _XOPEN_SOURCE=600 * _POSIX_C_SOURCE == 200809 1003.1-2008 (1003.1 Issue 7) * IEEE Std 1003.1-2017 (Rev of 1003.1-2008) is * 1003.1-2008 with two TCs applied and * _XOPEN_SOURCE=700 * _POSIX_C_SOURCE == 202405 1003.1-2004 (1003.1 Issue 8), IEEE Std 1003.1-2024 * with _XOPEN_SOURCE=800 * * In addition, the X/Open Portability Guide, which is now the Single UNIX * Specification, defines a feature-test macro which indicates the version of * that specification, and which subsumes _POSIX_C_SOURCE. * * Our macros begin with two underscores to avoid namespace screwage. */ /* Deal with IEEE Std. 1003.1-1990, in which _POSIX_C_SOURCE == 1. */ #if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE == 1 #undef _POSIX_C_SOURCE /* Probably illegal, but beyond caring now. */ #define _POSIX_C_SOURCE 199009 #endif /* Deal with IEEE Std. 1003.2-1992, in which _POSIX_C_SOURCE == 2. */ #if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE == 2 #undef _POSIX_C_SOURCE #define _POSIX_C_SOURCE 199209 #endif /* * Deal with various X/Open Portability Guides and Single UNIX Spec. We use the * '- 0' construct so software that defines _XOPEN_SOURCE to nothing doesn't * cause errors. X/Open CAE Specification, August 1994, System Interfaces and * Headers, Issue 4, Version 2 section 2.2 states an empty definition means the * same thing as _POSIX_C_SOURCE == 2. This broadly mirrors "System V Interface * Definition, Fourth Edition", but earlier editions suggest some ambiguity. * However, FreeBSD has histoically implemented this as a NOP, so we just * document what it should be for now to not break ports gratuitously. */ #ifdef _XOPEN_SOURCE #if _XOPEN_SOURCE - 0 >= 800 #define __XSI_VISIBLE 800 #undef _POSIX_C_SOURCE #define _POSIX_C_SOURCE 202405 #elif _XOPEN_SOURCE - 0 >= 700 #define __XSI_VISIBLE 700 #undef _POSIX_C_SOURCE #define _POSIX_C_SOURCE 200809 #elif _XOPEN_SOURCE - 0 >= 600 #define __XSI_VISIBLE 600 #undef _POSIX_C_SOURCE #define _POSIX_C_SOURCE 200112 #elif _XOPEN_SOURCE - 0 >= 500 #define __XSI_VISIBLE 500 #undef _POSIX_C_SOURCE #define _POSIX_C_SOURCE 199506 #else /* #define _POSIX_C_SOURCE 199209 */ #endif #endif /* * Deal with all versions of POSIX. The ordering relative to the tests above is * important. */ #if defined(_POSIX_SOURCE) && !defined(_POSIX_C_SOURCE) #define _POSIX_C_SOURCE 198808 #endif #ifdef _POSIX_C_SOURCE #if _POSIX_C_SOURCE >= 202405 #define __POSIX_VISIBLE 202405 #define __ISO_C_VISIBLE 2017 #elif _POSIX_C_SOURCE >= 200809 #define __POSIX_VISIBLE 200809 #define __ISO_C_VISIBLE 1999 #elif _POSIX_C_SOURCE >= 200112 #define __POSIX_VISIBLE 200112 #define __ISO_C_VISIBLE 1999 #elif _POSIX_C_SOURCE >= 199506 #define __POSIX_VISIBLE 199506 #define __ISO_C_VISIBLE 1990 #elif _POSIX_C_SOURCE >= 199309 #define __POSIX_VISIBLE 199309 #define __ISO_C_VISIBLE 1990 #elif _POSIX_C_SOURCE >= 199209 #define __POSIX_VISIBLE 199209 #define __ISO_C_VISIBLE 1990 #elif _POSIX_C_SOURCE >= 199009 #define __POSIX_VISIBLE 199009 #define __ISO_C_VISIBLE 1990 #else #define __POSIX_VISIBLE 198808 #define __ISO_C_VISIBLE 0 #endif /* _POSIX_C_SOURCE */ /* * When we've explicitly asked for a newer C version, make the C variable * visible by default. Also honor the glibc _ISOC{11,23}_SOURCE macros * extensions. Both glibc and OpenBSD do this, even when a more strict * _POSIX_C_SOURCE has been requested, and it makes good sense (especially for * pre POSIX 2024, since C11 is much nicer than the old C99 base). Continue the * practice with C23, though don't do older standards. Also, GLIBC doesn't have * a _ISOC17_SOURCE, so it's not implemented here. glibc has earlier ISOCxx defines, * but we don't implement those as they are not relevant enough. */ #if _ISOC23_SOURCE || (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L) #undef __ISO_C_VISIBLE #define __ISO_C_VISIBLE 2023 #elif _ISOC11_SOURCE || (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) #undef __ISO_C_VISIBLE #define __ISO_C_VISIBLE 2011 #endif #else /* _POSIX_C_SOURCE */ /*- * Deal with _ANSI_SOURCE: * If it is defined, and no other compilation environment is explicitly * requested, then define our internal feature-test macros to zero. This * makes no difference to the preprocessor (undefined symbols in preprocessing * expressions are defined to have value zero), but makes it more convenient for * a test program to print out the values. * * If a program mistakenly defines _ANSI_SOURCE and some other macro such as * _POSIX_C_SOURCE, we will assume that it wants the broader compilation * environment (and in fact we will never get here). */ #if defined(_ANSI_SOURCE) /* Hide almost everything. */ #define __POSIX_VISIBLE 0 #define __XSI_VISIBLE 0 #define __BSD_VISIBLE 0 #define __ISO_C_VISIBLE 1990 #define __EXT1_VISIBLE 0 #elif defined(_C99_SOURCE) /* Localism to specify strict C99 env. */ #define __POSIX_VISIBLE 0 #define __XSI_VISIBLE 0 #define __BSD_VISIBLE 0 #define __ISO_C_VISIBLE 1999 #define __EXT1_VISIBLE 0 #elif defined(_C11_SOURCE) /* Localism to specify strict C11 env. */ #define __POSIX_VISIBLE 0 #define __XSI_VISIBLE 0 #define __BSD_VISIBLE 0 #define __ISO_C_VISIBLE 2011 #define __EXT1_VISIBLE 0 #elif defined(_C23_SOURCE) /* Localism to specify strict C23 env. */ #define __POSIX_VISIBLE 0 #define __XSI_VISIBLE 0 #define __BSD_VISIBLE 0 #define __ISO_C_VISIBLE 2023 #define __EXT1_VISIBLE 0 #else /* Default environment: show everything. */ #define __POSIX_VISIBLE 202405 #define __XSI_VISIBLE 800 #define __BSD_VISIBLE 1 #define __ISO_C_VISIBLE 2023 #define __EXT1_VISIBLE 1 #endif #endif /* _POSIX_C_SOURCE */ /* User override __EXT1_VISIBLE */ #if defined(__STDC_WANT_LIB_EXT1__) #undef __EXT1_VISIBLE #if __STDC_WANT_LIB_EXT1__ #define __EXT1_VISIBLE 1 #else #define __EXT1_VISIBLE 0 #endif #endif /* __STDC_WANT_LIB_EXT1__ */ /* * Nullability qualifiers: currently only supported by Clang. */ #if !(defined(__clang__) && __has_feature(nullability)) #define _Nonnull #define _Nullable #define _Null_unspecified #define __NULLABILITY_PRAGMA_PUSH #define __NULLABILITY_PRAGMA_POP #else #define __NULLABILITY_PRAGMA_PUSH _Pragma("clang diagnostic push") \ _Pragma("clang diagnostic ignored \"-Wnullability-completeness\"") #define __NULLABILITY_PRAGMA_POP _Pragma("clang diagnostic pop") #endif /* * Type Safety Checking * * Clang provides additional attributes to enable checking type safety * properties that cannot be enforced by the C type system. */ #if __has_attribute(__argument_with_type_tag__) && \ __has_attribute(__type_tag_for_datatype__) #define __arg_type_tag(arg_kind, arg_idx, type_tag_idx) \ __attribute__((__argument_with_type_tag__(arg_kind, arg_idx, type_tag_idx))) #define __datatype_type_tag(kind, type) \ __attribute__((__type_tag_for_datatype__(kind, type))) #else #define __arg_type_tag(arg_kind, arg_idx, type_tag_idx) #define __datatype_type_tag(kind, type) #endif /* * Lock annotations. * * Clang provides support for doing basic thread-safety tests at * compile-time, by marking which locks will/should be held when * entering/leaving a functions. * * Furthermore, it is also possible to annotate variables and structure * members to enforce that they are only accessed when certain locks are * held. */ #if __has_extension(c_thread_safety_attributes) #define __lock_annotate(x) __attribute__((x)) #else #define __lock_annotate(x) #endif /* Structure implements a lock. */ #define __lockable __lock_annotate(lockable) /* Function acquires an exclusive or shared lock. */ #define __locks_exclusive(...) \ __lock_annotate(exclusive_lock_function(__VA_ARGS__)) #define __locks_shared(...) \ __lock_annotate(shared_lock_function(__VA_ARGS__)) /* Function attempts to acquire an exclusive or shared lock. */ #define __trylocks_exclusive(...) \ __lock_annotate(exclusive_trylock_function(__VA_ARGS__)) #define __trylocks_shared(...) \ __lock_annotate(shared_trylock_function(__VA_ARGS__)) /* Function releases a lock. */ #define __unlocks(...) __lock_annotate(unlock_function(__VA_ARGS__)) /* Function asserts that an exclusive or shared lock is held. */ #define __asserts_exclusive(...) \ __lock_annotate(assert_exclusive_lock(__VA_ARGS__)) #define __asserts_shared(...) \ __lock_annotate(assert_shared_lock(__VA_ARGS__)) /* Function requires that an exclusive or shared lock is or is not held. */ #define __requires_exclusive(...) \ __lock_annotate(exclusive_locks_required(__VA_ARGS__)) #define __requires_shared(...) \ __lock_annotate(shared_locks_required(__VA_ARGS__)) #define __requires_unlocked(...) \ __lock_annotate(locks_excluded(__VA_ARGS__)) /* Function should not be analyzed. */ #define __no_lock_analysis __lock_annotate(no_thread_safety_analysis) /* * Function or variable should not be sanitized, e.g., by AddressSanitizer. * GCC has the nosanitize attribute, but as a function attribute only, and * warns on use as a variable attribute. */ #if __has_feature(address_sanitizer) && defined(__clang__) #ifdef _KERNEL #define __nosanitizeaddress __attribute__((no_sanitize("kernel-address"))) #else #define __nosanitizeaddress __attribute__((no_sanitize("address"))) #endif #else #define __nosanitizeaddress #endif #if __has_feature(coverage_sanitizer) && defined(__clang__) #define __nosanitizecoverage __attribute__((no_sanitize("coverage"))) #else #define __nosanitizecoverage #endif #if __has_feature(memory_sanitizer) && defined(__clang__) #ifdef _KERNEL #define __nosanitizememory __attribute__((no_sanitize("kernel-memory"))) #else #define __nosanitizememory __attribute__((no_sanitize("memory"))) #endif #else #define __nosanitizememory #endif #if __has_feature(thread_sanitizer) && defined(__clang__) #define __nosanitizethread __attribute__((no_sanitize("thread"))) #else #define __nosanitizethread #endif /* * Make it possible to opt out of stack smashing protection. */ #if __has_attribute(no_stack_protector) #define __nostackprotector __attribute__((no_stack_protector)) #else #define __nostackprotector \ __attribute__((__optimize__("-fno-stack-protector"))) #endif /* Guard variables and structure members by lock. */ #define __guarded_by(x) __lock_annotate(guarded_by(x)) #define __pt_guarded_by(x) __lock_annotate(pt_guarded_by(x)) /* Alignment builtins for better type checking and improved code generation. */ /* Provide fallback versions for other compilers (GCC/Clang < 10): */ #if !__has_builtin(__builtin_is_aligned) #define __builtin_is_aligned(x, align) \ (((__uintptr_t)(x) & ((align) - 1)) == 0) #endif #if !__has_builtin(__builtin_align_up) #define __builtin_align_up(x, align) \ ((__typeof__(x))(((__uintptr_t)(x)+((align)-1))&(~((align)-1)))) #endif #if !__has_builtin(__builtin_align_down) #define __builtin_align_down(x, align) \ ((__typeof__(x))((x)&(~((align)-1)))) #endif #define __align_up(x, y) __builtin_align_up(x, y) #define __align_down(x, y) __builtin_align_down(x, y) #define __is_aligned(x, y) __builtin_is_aligned(x, y) #endif /* !_SYS_CDEFS_H_ */