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