xref: /third_party/FreeBSD/sys/sys/cdefs.h (revision f9f848fa)
1/*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 1991, 1993
5 *	The Regents of the University of California.  All rights reserved.
6 *
7 * This code is derived from software contributed to Berkeley by
8 * Berkeley Software Design, Inc.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 *    notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 *    notice, this list of conditions and the following disclaimer in the
17 *    documentation and/or other materials provided with the distribution.
18 * 3. Neither the name of the University nor the names of its contributors
19 *    may be used to endorse or promote products derived from this software
20 *    without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 *
34 *	@(#)cdefs.h	8.8 (Berkeley) 1/9/95
35 */
36
37#ifndef	_SYS_CDEFS_H_
38#define	_SYS_CDEFS_H_
39
40#if defined(_KERNEL) && defined(_STANDALONE)
41#error "_KERNEL and _STANDALONE are mutually exclusive"
42#endif
43
44/*
45 * Testing against Clang-specific extensions.
46 */
47#ifndef	__has_attribute
48#define	__has_attribute(x)	0
49#endif
50#ifndef	__has_extension
51#define	__has_extension		__has_feature
52#endif
53#ifndef	__has_feature
54#define	__has_feature(x)	0
55#endif
56#ifndef	__has_include
57#define	__has_include(x)	0
58#endif
59#ifndef	__has_builtin
60#define	__has_builtin(x)	0
61#endif
62
63#if defined(__cplusplus)
64#define	__BEGIN_DECLS	extern "C" {
65#define	__END_DECLS	}
66#else
67#define	__BEGIN_DECLS
68#define	__END_DECLS
69#endif
70
71/*
72 * This code has been put in place to help reduce the addition of
73 * compiler specific defines in FreeBSD code.  It helps to aid in
74 * having a compiler-agnostic source tree.
75 */
76
77#if defined(__GNUC__)
78
79#if __GNUC__ >= 3
80#define	__GNUCLIKE_ASM 3
81#define	__GNUCLIKE_MATH_BUILTIN_CONSTANTS
82#else
83#define	__GNUCLIKE_ASM 2
84#endif
85#define	__GNUCLIKE___TYPEOF 1
86#define	__GNUCLIKE___OFFSETOF 1
87#define	__GNUCLIKE___SECTION 1
88
89#define	__GNUCLIKE_CTOR_SECTION_HANDLING 1
90
91#define	__GNUCLIKE_BUILTIN_CONSTANT_P 1
92
93#if (__GNUC_MINOR__ > 95 || __GNUC__ >= 3)
94#define	__GNUCLIKE_BUILTIN_VARARGS 1
95#define	__GNUCLIKE_BUILTIN_STDARG 1
96#define	__GNUCLIKE_BUILTIN_VAALIST 1
97#endif
98
99#define	__GNUC_VA_LIST_COMPATIBILITY 1
100
101/*
102 * Compiler memory barriers, specific to gcc and clang.
103 */
104#define	__compiler_membar()	__asm __volatile(" " : : : "memory")
105
106#define	__GNUCLIKE_BUILTIN_NEXT_ARG 1
107#define	__GNUCLIKE_MATH_BUILTIN_RELOPS
108
109#define	__GNUCLIKE_BUILTIN_MEMCPY 1
110
111/* XXX: if __GNUC__ >= 2: not tested everywhere originally, where replaced */
112#define	__CC_SUPPORTS_INLINE 1
113#define	__CC_SUPPORTS___INLINE 1
114#define	__CC_SUPPORTS___INLINE__ 1
115
116#define	__CC_SUPPORTS___FUNC__ 1
117#define	__CC_SUPPORTS_WARNING 1
118
119#define	__CC_SUPPORTS_VARADIC_XXX 1 /* see varargs.h */
120
121#define	__CC_SUPPORTS_DYNAMIC_ARRAY_INIT 1
122
123#endif /* __GNUC__ */
124
125/*
126 * Macro to test if we're using a specific version of gcc or later.
127 */
128#if defined(__GNUC__)
129#define	__GNUC_PREREQ__(ma, mi)	\
130	(__GNUC__ > (ma) || __GNUC__ == (ma) && __GNUC_MINOR__ >= (mi))
131#else
132#define	__GNUC_PREREQ__(ma, mi)	0
133#endif
134
135/*
136 * The __CONCAT macro is used to concatenate parts of symbol names, e.g.
137 * with "#define OLD(foo) __CONCAT(old,foo)", OLD(foo) produces oldfoo.
138 * The __CONCAT macro is a bit tricky to use if it must work in non-ANSI
139 * mode -- there must be no spaces between its arguments, and for nested
140 * __CONCAT's, all the __CONCAT's must be at the left.  __CONCAT can also
141 * concatenate double-quoted strings produced by the __STRING macro, but
142 * this only works with ANSI C.
143 *
144 * __XSTRING is like __STRING, but it expands any macros in its argument
145 * first.  It is only available with ANSI C.
146 */
147#if defined(__STDC__) || defined(__cplusplus)
148#define	__P(protos)	protos		/* full-blown ANSI C */
149#define	__CONCAT1(x,y)	x ## y
150#define	__CONCAT(x,y)	__CONCAT1(x,y)
151#define	__STRING(x)	#x		/* stringify without expanding x */
152#define	__XSTRING(x)	__STRING(x)	/* expand x, then stringify */
153
154#define	__const		const		/* define reserved names to standard */
155#define	__signed	signed
156#define	__volatile	volatile
157#if defined(__cplusplus)
158#define	__inline	inline		/* convert to C++ keyword */
159#else
160#if !(defined(__CC_SUPPORTS___INLINE))
161#define	__inline			/* delete GCC keyword */
162#endif /* ! __CC_SUPPORTS___INLINE */
163#endif /* !__cplusplus */
164
165#else	/* !(__STDC__ || __cplusplus) */
166#define	__P(protos)	()		/* traditional C preprocessor */
167#define	__CONCAT(x,y)	x/**/y
168#define	__STRING(x)	"x"
169
170#if !defined(__CC_SUPPORTS___INLINE)
171#define	__const				/* delete pseudo-ANSI C keywords */
172#define	__inline
173#define	__signed
174#define	__volatile
175/*
176 * In non-ANSI C environments, new programs will want ANSI-only C keywords
177 * deleted from the program and old programs will want them left alone.
178 * When using a compiler other than gcc, programs using the ANSI C keywords
179 * const, inline etc. as normal identifiers should define -DNO_ANSI_KEYWORDS.
180 * When using "gcc -traditional", we assume that this is the intent; if
181 * __GNUC__ is defined but __STDC__ is not, we leave the new keywords alone.
182 */
183#ifndef	NO_ANSI_KEYWORDS
184#define	const				/* delete ANSI C keywords */
185#define	inline
186#define	signed
187#define	volatile
188#endif	/* !NO_ANSI_KEYWORDS */
189#endif	/* !__CC_SUPPORTS___INLINE */
190#endif	/* !(__STDC__ || __cplusplus) */
191
192/*
193 * Compiler-dependent macros to help declare dead (non-returning) and
194 * pure (no side effects) functions, and unused variables.  They are
195 * null except for versions of gcc that are known to support the features
196 * properly (old versions of gcc-2 supported the dead and pure features
197 * in a different (wrong) way).  If we do not provide an implementation
198 * for a given compiler, let the compile fail if it is told to use
199 * a feature that we cannot live without.
200 */
201#define	__weak_symbol	__attribute__((__weak__))
202#if !__GNUC_PREREQ__(2, 5)
203#define	__dead2
204#define	__pure2
205#define	__unused
206#endif
207#if __GNUC__ == 2 && __GNUC_MINOR__ >= 5 && __GNUC_MINOR__ < 7
208#define	__dead2		__attribute__((__noreturn__))
209#define	__pure2		__attribute__((__const__))
210#define	__unused
211/* XXX Find out what to do for __packed, __aligned and __section */
212#endif
213#if __GNUC_PREREQ__(2, 7)
214#define	__dead2		__attribute__((__noreturn__))
215#define	__pure2		__attribute__((__const__))
216#define	__unused	__attribute__((__unused__))
217#define	__used		__attribute__((__used__))
218#define	__packed	__attribute__((__packed__))
219#define	__aligned(x)	__attribute__((__aligned__(x)))
220#define	__section(x)	__attribute__((__section__(x)))
221#endif
222#if __GNUC_PREREQ__(4, 3) || __has_attribute(__alloc_size__)
223#define	__alloc_size(x)	__attribute__((__alloc_size__(x)))
224#define	__alloc_size2(n, x)	__attribute__((__alloc_size__(n, x)))
225#else
226#define	__alloc_size(x)
227#define	__alloc_size2(n, x)
228#endif
229#if __GNUC_PREREQ__(4, 9) || __has_attribute(__alloc_align__)
230#define	__alloc_align(x)	__attribute__((__alloc_align__(x)))
231#else
232#define	__alloc_align(x)
233#endif
234
235#if !__GNUC_PREREQ__(2, 95)
236#define	__alignof(x)	__offsetof(struct { char __a; x __b; }, __b)
237#endif
238
239/*
240 * Keywords added in C11.
241 */
242
243#if !defined(__STDC_VERSION__) || __STDC_VERSION__ < 201112L
244
245#if !__has_extension(c_alignas)
246#if (defined(__cplusplus) && __cplusplus >= 201103L) || \
247    __has_extension(cxx_alignas)
248#define	_Alignas(x)		alignas(x)
249#else
250/* XXX: Only emulates _Alignas(constant-expression); not _Alignas(type-name). */
251#define	_Alignas(x)		__aligned(x)
252#endif
253#endif
254
255#if defined(__cplusplus) && __cplusplus >= 201103L
256#define	_Alignof(x)		alignof(x)
257#else
258#define	_Alignof(x)		__alignof(x)
259#endif
260
261#if !defined(__cplusplus) && !__has_extension(c_atomic) && \
262	!__has_extension(cxx_atomic) && !__GNUC_PREREQ__(4, 7)
263/*
264 * No native support for _Atomic(). Place object in structure to prevent
265 * most forms of direct non-atomic access.
266 */
267#define	_Atomic(T)		struct { T volatile __val; }
268#endif
269
270#if !__has_extension(c_static_assert)
271#if (defined(__cplusplus) && __cplusplus >= 201103L) || \
272    __has_extension(cxx_static_assert)
273#define	_Static_assert(x, y)	static_assert(x, y)
274#elif __GNUC_PREREQ__(4,6) && !defined(__cplusplus)
275/* Nothing, gcc 4.6 and higher has _Static_assert built-in */
276#elif defined(__COUNTER__)
277#define	_Static_assert(x, y)	__Static_assert(x, __COUNTER__)
278#define	__Static_assert(x, y)	___Static_assert(x, y)
279#define	___Static_assert(x, y)	typedef char __assert_ ## y[(x) ? 1 : -1] \
280				__unused
281#else
282#define	_Static_assert(x, y)	struct __hack
283#endif
284#endif
285
286#if !__has_extension(c_thread_local)
287/*
288 * XXX: Some compilers (Clang 3.3, GCC 4.7) falsely announce C++11 mode
289 * without actually supporting the thread_local keyword. Don't check for
290 * the presence of C++11 when defining _Thread_local.
291 */
292#if /* (defined(__cplusplus) && __cplusplus >= 201103L) || */ \
293    __has_extension(cxx_thread_local)
294#define	_Thread_local		thread_local
295#else
296#define	_Thread_local		__thread
297#endif
298#endif
299
300#endif /* __STDC_VERSION__ || __STDC_VERSION__ < 201112L */
301
302/*
303 * Emulation of C11 _Generic().  Unlike the previously defined C11
304 * keywords, it is not possible to implement this using exactly the same
305 * syntax.  Therefore implement something similar under the name
306 * __generic().  Unlike _Generic(), this macro can only distinguish
307 * between a single type, so it requires nested invocations to
308 * distinguish multiple cases.
309 *
310 * Note that the comma operator is used to force expr to decay in
311 * order to match _Generic().
312 */
313
314#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || \
315    __has_extension(c_generic_selections)
316#define	__generic(expr, t, yes, no)					\
317	_Generic(expr, t: yes, default: no)
318#elif __GNUC_PREREQ__(3, 1) && !defined(__cplusplus)
319#define	__generic(expr, t, yes, no)					\
320	__builtin_choose_expr(						\
321	    __builtin_types_compatible_p(__typeof((0, (expr))), t), yes, no)
322#endif
323
324/*
325 * C99 Static array indices in function parameter declarations.  Syntax such as:
326 * void bar(int myArray[static 10]);
327 * is allowed in C99 but not in C++.  Define __min_size appropriately so
328 * headers using it can be compiled in either language.  Use like this:
329 * void bar(int myArray[__min_size(10)]);
330 */
331#if !defined(__cplusplus) && \
332    (defined(__clang__) || __GNUC_PREREQ__(4, 6)) && \
333    (!defined(__STDC_VERSION__) || (__STDC_VERSION__ >= 199901))
334#define __min_size(x)	static (x)
335#else
336#define __min_size(x)	(x)
337#endif
338
339#if __GNUC_PREREQ__(2, 96)
340#define	__malloc_like	__attribute__((__malloc__))
341#define	__pure		__attribute__((__pure__))
342#else
343#define	__malloc_like
344#define	__pure
345#endif
346
347#if __GNUC_PREREQ__(3, 1)
348#define	__always_inline	__attribute__((__always_inline__))
349#else
350#define	__always_inline
351#endif
352
353#if __GNUC_PREREQ__(3, 1)
354#define	__noinline	__attribute__ ((__noinline__))
355#else
356#define	__noinline
357#endif
358
359#if __GNUC_PREREQ__(3, 4)
360#define	__fastcall	__attribute__((__fastcall__))
361#define	__result_use_check	__attribute__((__warn_unused_result__))
362#else
363#define	__fastcall
364#define	__result_use_check
365#endif
366
367#if __GNUC_PREREQ__(4, 1)
368#define	__returns_twice	__attribute__((__returns_twice__))
369#else
370#define	__returns_twice
371#endif
372
373#if __GNUC_PREREQ__(4, 6) || __has_builtin(__builtin_unreachable)
374#define	__unreachable()	__builtin_unreachable()
375#else
376#define	__unreachable()	((void)0)
377#endif
378
379/* XXX: should use `#if __STDC_VERSION__ < 199901'. */
380#if !__GNUC_PREREQ__(2, 7)
381#define	__func__	NULL
382#endif
383
384#if (defined(__GNUC__) && __GNUC__ >= 2) && !defined(__STRICT_ANSI__) || __STDC_VERSION__ >= 199901
385#define	__LONG_LONG_SUPPORTED
386#endif
387
388/* C++11 exposes a load of C99 stuff */
389#if defined(__cplusplus) && __cplusplus >= 201103L
390#define	__LONG_LONG_SUPPORTED
391#ifndef	__STDC_LIMIT_MACROS
392#define	__STDC_LIMIT_MACROS
393#endif
394#ifndef	__STDC_CONSTANT_MACROS
395#define	__STDC_CONSTANT_MACROS
396#endif
397#endif
398
399/*
400 * We use `__restrict' as a way to define the `restrict' type qualifier
401 * without disturbing older software that is unaware of C99 keywords.
402 * GCC also provides `__restrict' as an extension to support C99-style
403 * restricted pointers in other language modes.
404 */
405#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901
406#define	__restrict	restrict
407#elif !__GNUC_PREREQ__(2, 95)
408#define	__restrict
409#endif
410
411/*
412 * GNU C version 2.96 adds explicit branch prediction so that
413 * the CPU back-end can hint the processor and also so that
414 * code blocks can be reordered such that the predicted path
415 * sees a more linear flow, thus improving cache behavior, etc.
416 *
417 * The following two macros provide us with a way to utilize this
418 * compiler feature.  Use __predict_true() if you expect the expression
419 * to evaluate to true, and __predict_false() if you expect the
420 * expression to evaluate to false.
421 *
422 * A few notes about usage:
423 *
424 *	* Generally, __predict_false() error condition checks (unless
425 *	  you have some _strong_ reason to do otherwise, in which case
426 *	  document it), and/or __predict_true() `no-error' condition
427 *	  checks, assuming you want to optimize for the no-error case.
428 *
429 *	* Other than that, if you don't know the likelihood of a test
430 *	  succeeding from empirical or other `hard' evidence, don't
431 *	  make predictions.
432 *
433 *	* These are meant to be used in places that are run `a lot'.
434 *	  It is wasteful to make predictions in code that is run
435 *	  seldomly (e.g. at subsystem initialization time) as the
436 *	  basic block reordering that this affects can often generate
437 *	  larger code.
438 */
439#if __GNUC_PREREQ__(2, 96)
440#define	__predict_true(exp)     __builtin_expect((exp), 1)
441#define	__predict_false(exp)    __builtin_expect((exp), 0)
442#else
443#define	__predict_true(exp)     (exp)
444#define	__predict_false(exp)    (exp)
445#endif
446
447#if __GNUC_PREREQ__(4, 0)
448#define	__null_sentinel	__attribute__((__sentinel__))
449#define	__exported	__attribute__((__visibility__("default")))
450#define	__hidden	__attribute__((__visibility__("hidden")))
451#else
452#define	__null_sentinel
453#define	__exported
454#define	__hidden
455#endif
456
457/*
458 * We define this here since <stddef.h>, <sys/queue.h>, and <sys/types.h>
459 * require it.
460 */
461#if __GNUC_PREREQ__(4, 1)
462#define	__offsetof(type, field)	 __builtin_offsetof(type, field)
463#else
464#ifndef __cplusplus
465#define	__offsetof(type, field) \
466	((__size_t)(__uintptr_t)((const volatile void *)&((type *)0)->field))
467#else
468#define	__offsetof(type, field)					\
469  (__offsetof__ (reinterpret_cast <__size_t>			\
470                 (&reinterpret_cast <const volatile char &>	\
471                  (static_cast<type *> (0)->field))))
472#endif
473#endif
474#define	__rangeof(type, start, end) \
475	(__offsetof(type, end) - __offsetof(type, start))
476
477/*
478 * Given the pointer x to the member m of the struct s, return
479 * a pointer to the containing structure.  When using GCC, we first
480 * assign pointer x to a local variable, to check that its type is
481 * compatible with member m.
482 */
483#if __GNUC_PREREQ__(3, 1)
484#define	__containerof(x, s, m) ({					\
485	const volatile __typeof(((s *)0)->m) *__x = (x);		\
486	__DEQUALIFY(s *, (const volatile char *)__x - __offsetof(s, m));\
487})
488#else
489#define	__containerof(x, s, m)						\
490	__DEQUALIFY(s *, (const volatile char *)(x) - __offsetof(s, m))
491#endif
492
493/*
494 * Compiler-dependent macros to declare that functions take printf-like
495 * or scanf-like arguments.  They are null except for versions of gcc
496 * that are known to support the features properly (old versions of gcc-2
497 * didn't permit keeping the keywords out of the application namespace).
498 */
499#if !__GNUC_PREREQ__(2, 7)
500#define	__printflike(fmtarg, firstvararg)
501#define	__scanflike(fmtarg, firstvararg)
502#define	__format_arg(fmtarg)
503#define	__strfmonlike(fmtarg, firstvararg)
504#define	__strftimelike(fmtarg, firstvararg)
505#else
506#define	__printflike(fmtarg, firstvararg) \
507	    __attribute__((__format__ (__printf__, fmtarg, firstvararg)))
508#define	__scanflike(fmtarg, firstvararg) \
509	    __attribute__((__format__ (__scanf__, fmtarg, firstvararg)))
510#define	__format_arg(fmtarg)	__attribute__((__format_arg__ (fmtarg)))
511#define	__strfmonlike(fmtarg, firstvararg) \
512	    __attribute__((__format__ (__strfmon__, fmtarg, firstvararg)))
513#define	__strftimelike(fmtarg, firstvararg) \
514	    __attribute__((__format__ (__strftime__, fmtarg, firstvararg)))
515#endif
516
517/* Compiler-dependent macros that rely on FreeBSD-specific extensions. */
518#if defined(__FreeBSD_cc_version) && __FreeBSD_cc_version >= 300001 && \
519    defined(__GNUC__)
520#define	__printf0like(fmtarg, firstvararg) \
521	    __attribute__((__format__ (__printf0__, fmtarg, firstvararg)))
522#else
523#define	__printf0like(fmtarg, firstvararg)
524#endif
525
526#if defined(__GNUC__)
527#define	__strong_reference(sym,aliassym)	\
528	extern __typeof (sym) aliassym __attribute__ ((__alias__ (#sym)))
529#ifdef __STDC__
530#define	__weak_reference(sym,alias)	\
531	__asm__(".weak " #alias);	\
532	__asm__(".equ "  #alias ", " #sym)
533#define	__warn_references(sym,msg)	\
534	__asm__(".section .gnu.warning." #sym);	\
535	__asm__(".asciz \"" msg "\"");	\
536	__asm__(".previous")
537#define	__sym_compat(sym,impl,verid)	\
538	__asm__(".symver " #impl ", " #sym "@" #verid)
539#define	__sym_default(sym,impl,verid)	\
540	__asm__(".symver " #impl ", " #sym "@@@" #verid)
541#else
542#define	__weak_reference(sym,alias)	\
543	__asm__(".weak alias");		\
544	__asm__(".equ alias, sym")
545#define	__warn_references(sym,msg)	\
546	__asm__(".section .gnu.warning.sym"); \
547	__asm__(".asciz \"msg\"");	\
548	__asm__(".previous")
549#define	__sym_compat(sym,impl,verid)	\
550	__asm__(".symver impl, sym@verid")
551#define	__sym_default(impl,sym,verid)	\
552	__asm__(".symver impl, sym@@@verid")
553#endif	/* __STDC__ */
554#endif	/* __GNUC__ */
555
556#define	__GLOBL(sym)	__asm__(".globl " __XSTRING(sym))
557#define	__WEAK(sym)	__asm__(".weak " __XSTRING(sym))
558
559#if defined(__GNUC__)
560#define	__IDSTRING(name,string)	__asm__(".ident\t\"" string "\"")
561#else
562/*
563 * The following definition might not work well if used in header files,
564 * but it should be better than nothing.  If you want a "do nothing"
565 * version, then it should generate some harmless declaration, such as:
566 *    #define	__IDSTRING(name,string)	struct __hack
567 */
568#define	__IDSTRING(name,string)	static const char name[] __unused = string
569#endif
570
571/*
572 * Embed the rcs id of a source file in the resulting library.  Note that in
573 * more recent ELF binutils, we use .ident allowing the ID to be stripped.
574 * Usage:
575 */
576#ifndef	__FBSDID
577#if !defined(STRIP_FBSDID)
578#define	__FBSDID(s)	__IDSTRING(__CONCAT(__rcsid_,__LINE__),s)
579#else
580#define	__FBSDID(s)	struct __hack
581#endif
582#endif
583
584#ifndef	__RCSID
585#ifndef	NO__RCSID
586#define	__RCSID(s)	__IDSTRING(__CONCAT(__rcsid_,__LINE__),s)
587#else
588#define	__RCSID(s)	struct __hack
589#endif
590#endif
591
592#ifndef	__RCSID_SOURCE
593#ifndef	NO__RCSID_SOURCE
594#define	__RCSID_SOURCE(s)	__IDSTRING(__CONCAT(__rcsid_source_,__LINE__),s)
595#else
596#define	__RCSID_SOURCE(s)	struct __hack
597#endif
598#endif
599
600#ifndef	__SCCSID
601#ifndef	NO__SCCSID
602#define	__SCCSID(s)	__IDSTRING(__CONCAT(__sccsid_,__LINE__),s)
603#else
604#define	__SCCSID(s)	struct __hack
605#endif
606#endif
607
608#ifndef	__COPYRIGHT
609#ifndef	NO__COPYRIGHT
610#define	__COPYRIGHT(s)	__IDSTRING(__CONCAT(__copyright_,__LINE__),s)
611#else
612#define	__COPYRIGHT(s)	struct __hack
613#endif
614#endif
615
616#ifndef	__DECONST
617#define	__DECONST(type, var)	((type)(uintptr_t)(const void *)(var))
618#endif
619
620#ifndef	__DEVOLATILE
621#define	__DEVOLATILE(type, var)	((type)(uintptr_t)(volatile void *)(var))
622#endif
623
624#ifndef	__DEQUALIFY
625#define	__DEQUALIFY(type, var)	((type)(uintptr_t)(const volatile void *)(var))
626#endif
627
628/*-
629 * The following definitions are an extension of the behavior originally
630 * implemented in <sys/_posix.h>, but with a different level of granularity.
631 * POSIX.1 requires that the macros we test be defined before any standard
632 * header file is included.
633 *
634 * Here's a quick run-down of the versions:
635 *  defined(_POSIX_SOURCE)		1003.1-1988
636 *  _POSIX_C_SOURCE == 1		1003.1-1990
637 *  _POSIX_C_SOURCE == 2		1003.2-1992 C Language Binding Option
638 *  _POSIX_C_SOURCE == 199309		1003.1b-1993
639 *  _POSIX_C_SOURCE == 199506		1003.1c-1995, 1003.1i-1995,
640 *					and the omnibus ISO/IEC 9945-1: 1996
641 *  _POSIX_C_SOURCE == 200112		1003.1-2001
642 *  _POSIX_C_SOURCE == 200809		1003.1-2008
643 *
644 * In addition, the X/Open Portability Guide, which is now the Single UNIX
645 * Specification, defines a feature-test macro which indicates the version of
646 * that specification, and which subsumes _POSIX_C_SOURCE.
647 *
648 * Our macros begin with two underscores to avoid namespace screwage.
649 */
650
651/* Deal with IEEE Std. 1003.1-1990, in which _POSIX_C_SOURCE == 1. */
652#if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE == 1
653#undef _POSIX_C_SOURCE		/* Probably illegal, but beyond caring now. */
654#define	_POSIX_C_SOURCE		199009
655#endif
656
657/* Deal with IEEE Std. 1003.2-1992, in which _POSIX_C_SOURCE == 2. */
658#if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE == 2
659#undef _POSIX_C_SOURCE
660#define	_POSIX_C_SOURCE		199209
661#endif
662
663/* Deal with various X/Open Portability Guides and Single UNIX Spec. */
664#ifdef _XOPEN_SOURCE
665#if _XOPEN_SOURCE - 0 >= 700
666#define	__XSI_VISIBLE		700
667#undef _POSIX_C_SOURCE
668#define	_POSIX_C_SOURCE		200809
669#elif _XOPEN_SOURCE - 0 >= 600
670#define	__XSI_VISIBLE		600
671#undef _POSIX_C_SOURCE
672#define	_POSIX_C_SOURCE		200112
673#elif _XOPEN_SOURCE - 0 >= 500
674#define	__XSI_VISIBLE		500
675#undef _POSIX_C_SOURCE
676#define	_POSIX_C_SOURCE		199506
677#endif
678#endif
679
680/*
681 * Deal with all versions of POSIX.  The ordering relative to the tests above is
682 * important.
683 */
684#if defined(_POSIX_SOURCE) && !defined(_POSIX_C_SOURCE)
685#define	_POSIX_C_SOURCE		198808
686#endif
687#ifdef _POSIX_C_SOURCE
688#if _POSIX_C_SOURCE >= 200809
689#define	__POSIX_VISIBLE		200809
690#define	__ISO_C_VISIBLE		1999
691#elif _POSIX_C_SOURCE >= 200112
692#define	__POSIX_VISIBLE		200112
693#define	__ISO_C_VISIBLE		1999
694#elif _POSIX_C_SOURCE >= 199506
695#define	__POSIX_VISIBLE		199506
696#define	__ISO_C_VISIBLE		1990
697#elif _POSIX_C_SOURCE >= 199309
698#define	__POSIX_VISIBLE		199309
699#define	__ISO_C_VISIBLE		1990
700#elif _POSIX_C_SOURCE >= 199209
701#define	__POSIX_VISIBLE		199209
702#define	__ISO_C_VISIBLE		1990
703#elif _POSIX_C_SOURCE >= 199009
704#define	__POSIX_VISIBLE		199009
705#define	__ISO_C_VISIBLE		1990
706#else
707#define	__POSIX_VISIBLE		198808
708#define	__ISO_C_VISIBLE		0
709#endif /* _POSIX_C_SOURCE */
710/*
711 * Both glibc and OpenBSD enable c11 features when _ISOC11_SOURCE is defined, or
712 * when compiling with -stdc=c11. A strict reading of the standard would suggest
713 * doing it only for the former. However, a strict reading also requires C99
714 * mode only, so building with C11 is already undefined. Follow glibc's and
715 * OpenBSD's lead for this non-standard configuration for maximum compatibility.
716 */
717#if _ISOC11_SOURCE || (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L)
718#undef __ISO_C_VISIBLE
719#define __ISO_C_VISIBLE		2011
720#endif
721#else
722/*-
723 * Deal with _ANSI_SOURCE:
724 * If it is defined, and no other compilation environment is explicitly
725 * requested, then define our internal feature-test macros to zero.  This
726 * makes no difference to the preprocessor (undefined symbols in preprocessing
727 * expressions are defined to have value zero), but makes it more convenient for
728 * a test program to print out the values.
729 *
730 * If a program mistakenly defines _ANSI_SOURCE and some other macro such as
731 * _POSIX_C_SOURCE, we will assume that it wants the broader compilation
732 * environment (and in fact we will never get here).
733 */
734#if defined(_ANSI_SOURCE)	/* Hide almost everything. */
735#define	__POSIX_VISIBLE		0
736#define	__XSI_VISIBLE		0
737#define	__BSD_VISIBLE		0
738#define	__ISO_C_VISIBLE		1990
739#define	__EXT1_VISIBLE		0
740#elif defined(_C99_SOURCE)	/* Localism to specify strict C99 env. */
741#define	__POSIX_VISIBLE		0
742#define	__XSI_VISIBLE		0
743#define	__BSD_VISIBLE		0
744#define	__ISO_C_VISIBLE		1999
745#define	__EXT1_VISIBLE		0
746#elif defined(_C11_SOURCE)	/* Localism to specify strict C11 env. */
747#define	__POSIX_VISIBLE		0
748#define	__XSI_VISIBLE		0
749#define	__BSD_VISIBLE		0
750#define	__ISO_C_VISIBLE		2011
751#define	__EXT1_VISIBLE		0
752#else				/* Default environment: show everything. */
753#define	__POSIX_VISIBLE		200809
754#define	__XSI_VISIBLE		700
755#define	__BSD_VISIBLE		1
756#define	__ISO_C_VISIBLE		2011
757#define	__EXT1_VISIBLE		1
758#endif
759#endif
760
761/* User override __EXT1_VISIBLE */
762#if defined(__STDC_WANT_LIB_EXT1__)
763#undef	__EXT1_VISIBLE
764#if __STDC_WANT_LIB_EXT1__
765#define	__EXT1_VISIBLE		1
766#else
767#define	__EXT1_VISIBLE		0
768#endif
769#endif /* __STDC_WANT_LIB_EXT1__ */
770
771/*
772 * Old versions of GCC use non-standard ARM arch symbols; acle-compat.h
773 * translates them to __ARM_ARCH and the modern feature symbols defined by ARM.
774 */
775#if defined(__arm__) && !defined(__ARM_ARCH)
776#include <machine/acle-compat.h>
777#endif
778
779/*
780 * Nullability qualifiers: currently only supported by Clang.
781 */
782#if !(defined(__clang__) && __has_feature(nullability))
783#define	_Nonnull
784#define	_Nullable
785#define	_Null_unspecified
786#define	__NULLABILITY_PRAGMA_PUSH
787#define	__NULLABILITY_PRAGMA_POP
788#else
789#define	__NULLABILITY_PRAGMA_PUSH _Pragma("clang diagnostic push")	\
790	_Pragma("clang diagnostic ignored \"-Wnullability-completeness\"")
791#define	__NULLABILITY_PRAGMA_POP _Pragma("clang diagnostic pop")
792#endif
793
794/*
795 * Type Safety Checking
796 *
797 * Clang provides additional attributes to enable checking type safety
798 * properties that cannot be enforced by the C type system.
799 */
800
801#if __has_attribute(__argument_with_type_tag__) && \
802    __has_attribute(__type_tag_for_datatype__)
803#define	__arg_type_tag(arg_kind, arg_idx, type_tag_idx) \
804	    __attribute__((__argument_with_type_tag__(arg_kind, arg_idx, type_tag_idx)))
805#define	__datatype_type_tag(kind, type) \
806	    __attribute__((__type_tag_for_datatype__(kind, type)))
807#else
808#define	__arg_type_tag(arg_kind, arg_idx, type_tag_idx)
809#define	__datatype_type_tag(kind, type)
810#endif
811
812/*
813 * Lock annotations.
814 *
815 * Clang provides support for doing basic thread-safety tests at
816 * compile-time, by marking which locks will/should be held when
817 * entering/leaving a functions.
818 *
819 * Furthermore, it is also possible to annotate variables and structure
820 * members to enforce that they are only accessed when certain locks are
821 * held.
822 */
823
824#if __has_extension(c_thread_safety_attributes)
825#define	__lock_annotate(x)	__attribute__((x))
826#else
827#define	__lock_annotate(x)
828#endif
829
830/* Structure implements a lock. */
831#define	__lockable		__lock_annotate(lockable)
832
833/* Function acquires an exclusive or shared lock. */
834#define	__locks_exclusive(...) \
835	__lock_annotate(exclusive_lock_function(__VA_ARGS__))
836#define	__locks_shared(...) \
837	__lock_annotate(shared_lock_function(__VA_ARGS__))
838
839/* Function attempts to acquire an exclusive or shared lock. */
840#define	__trylocks_exclusive(...) \
841	__lock_annotate(exclusive_trylock_function(__VA_ARGS__))
842#define	__trylocks_shared(...) \
843	__lock_annotate(shared_trylock_function(__VA_ARGS__))
844
845/* Function releases a lock. */
846#define	__unlocks(...)		__lock_annotate(unlock_function(__VA_ARGS__))
847
848/* Function asserts that an exclusive or shared lock is held. */
849#define	__asserts_exclusive(...) \
850	__lock_annotate(assert_exclusive_lock(__VA_ARGS__))
851#define	__asserts_shared(...) \
852	__lock_annotate(assert_shared_lock(__VA_ARGS__))
853
854/* Function requires that an exclusive or shared lock is or is not held. */
855#define	__requires_exclusive(...) \
856	__lock_annotate(exclusive_locks_required(__VA_ARGS__))
857#define	__requires_shared(...) \
858	__lock_annotate(shared_locks_required(__VA_ARGS__))
859#define	__requires_unlocked(...) \
860	__lock_annotate(locks_excluded(__VA_ARGS__))
861
862/* Function should not be analyzed. */
863#define	__no_lock_analysis	__lock_annotate(no_thread_safety_analysis)
864
865/*
866 * Function or variable should not be sanitized, e.g., by AddressSanitizer.
867 * GCC has the nosanitize attribute, but as a function attribute only, and
868 * warns on use as a variable attribute.
869 */
870#if __has_attribute(no_sanitize) && defined(__clang__)
871#ifdef _KERNEL
872#define __nosanitizeaddress	__attribute__((no_sanitize("kernel-address")))
873#define __nosanitizememory	__attribute__((no_sanitize("kernel-memory")))
874#else
875#define __nosanitizeaddress	__attribute__((no_sanitize("address")))
876#define __nosanitizememory	__attribute__((no_sanitize("memory")))
877#endif
878#define __nosanitizethread	__attribute__((no_sanitize("thread")))
879#else
880#define __nosanitizeaddress
881#define __nosanitizememory
882#define __nosanitizethread
883#endif
884
885/* Guard variables and structure members by lock. */
886#define	__guarded_by(x)		__lock_annotate(guarded_by(x))
887#define	__pt_guarded_by(x)	__lock_annotate(pt_guarded_by(x))
888
889/* Alignment builtins for better type checking and improved code generation. */
890/* Provide fallback versions for other compilers (GCC/Clang < 10): */
891#if !__has_builtin(__builtin_is_aligned)
892#define __builtin_is_aligned(x, align)	\
893	(((__uintptr_t)x & ((align) - 1)) == 0)
894#endif
895#if !__has_builtin(__builtin_align_up)
896#define __builtin_align_up(x, align)	\
897	((__typeof__(x))(((__uintptr_t)(x)+((align)-1))&(~((align)-1))))
898#endif
899#if !__has_builtin(__builtin_align_down)
900#define __builtin_align_down(x, align)	\
901	((__typeof__(x))((x)&(~((align)-1))))
902#endif
903
904#define __align_up(x, y) __builtin_align_up(x, y)
905#define __align_down(x, y) __builtin_align_down(x, y)
906#define __is_aligned(x, y) __builtin_is_aligned(x, y)
907
908#ifdef LOSCFG_LIBC_NEWLIB
909#undef _SYS_CDEFS_H_
910#include_next <sys/cdefs.h>
911#endif
912
913#endif /* !_SYS_CDEFS_H_ */
914