4ceff30f95
While GCC's __nonnull__ attribute is generally useful to prevent misuse of some functions it also tends to do rather dangerous "optimizations". Now that we have replaced (r312934) all such uses with the clang nullability qualifiers, the GCC attribute is unnecessary. Remove the definition completely to prevent its use in system's headers.
873 lines
28 KiB
C
873 lines
28 KiB
C
/*-
|
|
* 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.
|
|
* 4. 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.
|
|
*
|
|
* @(#)cdefs.h 8.8 (Berkeley) 1/9/95
|
|
* $FreeBSD$
|
|
*/
|
|
|
|
#ifndef _SYS_CDEFS_H_
|
|
#define _SYS_CDEFS_H_
|
|
|
|
/*
|
|
* Testing against Clang-specific extensions.
|
|
*/
|
|
#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.
|
|
*/
|
|
|
|
#if defined(__GNUC__) || defined(__INTEL_COMPILER)
|
|
|
|
#if __GNUC__ >= 3 || defined(__INTEL_COMPILER)
|
|
#define __GNUCLIKE_ASM 3
|
|
#define __GNUCLIKE_MATH_BUILTIN_CONSTANTS
|
|
#else
|
|
#define __GNUCLIKE_ASM 2
|
|
#endif
|
|
#define __GNUCLIKE___TYPEOF 1
|
|
#define __GNUCLIKE___OFFSETOF 1
|
|
#define __GNUCLIKE___SECTION 1
|
|
|
|
#ifndef __INTEL_COMPILER
|
|
#define __GNUCLIKE_CTOR_SECTION_HANDLING 1
|
|
#endif
|
|
|
|
#define __GNUCLIKE_BUILTIN_CONSTANT_P 1
|
|
#if defined(__INTEL_COMPILER) && defined(__cplusplus) && \
|
|
__INTEL_COMPILER < 800
|
|
#undef __GNUCLIKE_BUILTIN_CONSTANT_P
|
|
#endif
|
|
|
|
#if (__GNUC_MINOR__ > 95 || __GNUC__ >= 3)
|
|
#define __GNUCLIKE_BUILTIN_VARARGS 1
|
|
#define __GNUCLIKE_BUILTIN_STDARG 1
|
|
#define __GNUCLIKE_BUILTIN_VAALIST 1
|
|
#endif
|
|
|
|
#if defined(__GNUC__)
|
|
#define __GNUC_VA_LIST_COMPATIBILITY 1
|
|
#endif
|
|
|
|
/*
|
|
* Compiler memory barriers, specific to gcc and clang.
|
|
*/
|
|
#if defined(__GNUC__)
|
|
#define __compiler_membar() __asm __volatile(" " : : : "memory")
|
|
#endif
|
|
|
|
#ifndef __INTEL_COMPILER
|
|
#define __GNUCLIKE_BUILTIN_NEXT_ARG 1
|
|
#define __GNUCLIKE_MATH_BUILTIN_RELOPS
|
|
#endif
|
|
|
|
#define __GNUCLIKE_BUILTIN_MEMCPY 1
|
|
|
|
/* XXX: if __GNUC__ >= 2: not tested everywhere originally, where replaced */
|
|
#define __CC_SUPPORTS_INLINE 1
|
|
#define __CC_SUPPORTS___INLINE 1
|
|
#define __CC_SUPPORTS___INLINE__ 1
|
|
|
|
#define __CC_SUPPORTS___FUNC__ 1
|
|
#define __CC_SUPPORTS_WARNING 1
|
|
|
|
#define __CC_SUPPORTS_VARADIC_XXX 1 /* see varargs.h */
|
|
|
|
#define __CC_SUPPORTS_DYNAMIC_ARRAY_INIT 1
|
|
|
|
#endif /* __GNUC__ || __INTEL_COMPILER */
|
|
|
|
/*
|
|
* Macro to test if we're using a specific version of gcc or later.
|
|
*/
|
|
#if defined(__GNUC__) && !defined(__INTEL_COMPILER)
|
|
#define __GNUC_PREREQ__(ma, mi) \
|
|
(__GNUC__ > (ma) || __GNUC__ == (ma) && __GNUC_MINOR__ >= (mi))
|
|
#else
|
|
#define __GNUC_PREREQ__(ma, mi) 0
|
|
#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 __const const /* define reserved names to standard */
|
|
#define __signed signed
|
|
#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)
|
|
#define __const /* delete pseudo-ANSI C keywords */
|
|
#define __inline
|
|
#define __signed
|
|
#define __volatile
|
|
/*
|
|
* In non-ANSI C environments, new programs will want ANSI-only C keywords
|
|
* deleted from the program and old programs will want them left alone.
|
|
* When using a compiler other than gcc, programs using the ANSI C keywords
|
|
* const, inline etc. as normal identifiers should define -DNO_ANSI_KEYWORDS.
|
|
* When using "gcc -traditional", we assume that this is the intent; if
|
|
* __GNUC__ is defined but __STDC__ is not, we leave the new keywords alone.
|
|
*/
|
|
#ifndef NO_ANSI_KEYWORDS
|
|
#define const /* delete ANSI C keywords */
|
|
#define inline
|
|
#define signed
|
|
#define volatile
|
|
#endif /* !NO_ANSI_KEYWORDS */
|
|
#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. They are
|
|
* null except for versions of gcc that are known to support the features
|
|
* properly (old versions of gcc-2 supported the dead and pure features
|
|
* in a different (wrong) way). If we do not provide an implementation
|
|
* for a given compiler, let the compile fail if it is told to use
|
|
* a feature that we cannot live without.
|
|
*/
|
|
#ifdef lint
|
|
#define __dead2
|
|
#define __pure2
|
|
#define __unused
|
|
#define __packed
|
|
#define __aligned(x)
|
|
#define __alloc_align(x)
|
|
#define __alloc_size(x)
|
|
#define __section(x)
|
|
#define __weak_symbol
|
|
#else
|
|
#define __weak_symbol __attribute__((__weak__))
|
|
#if !__GNUC_PREREQ__(2, 5) && !defined(__INTEL_COMPILER)
|
|
#define __dead2
|
|
#define __pure2
|
|
#define __unused
|
|
#endif
|
|
#if __GNUC__ == 2 && __GNUC_MINOR__ >= 5 && __GNUC_MINOR__ < 7 && !defined(__INTEL_COMPILER)
|
|
#define __dead2 __attribute__((__noreturn__))
|
|
#define __pure2 __attribute__((__const__))
|
|
#define __unused
|
|
/* XXX Find out what to do for __packed, __aligned and __section */
|
|
#endif
|
|
#if __GNUC_PREREQ__(2, 7) || defined(__INTEL_COMPILER)
|
|
#define __dead2 __attribute__((__noreturn__))
|
|
#define __pure2 __attribute__((__const__))
|
|
#define __unused __attribute__((__unused__))
|
|
#define __used __attribute__((__used__))
|
|
#define __packed __attribute__((__packed__))
|
|
#define __aligned(x) __attribute__((__aligned__(x)))
|
|
#define __section(x) __attribute__((__section__(x)))
|
|
#endif
|
|
#if __GNUC_PREREQ__(4, 3) || __has_attribute(__alloc_size__)
|
|
#define __alloc_size(x) __attribute__((__alloc_size__(x)))
|
|
#else
|
|
#define __alloc_size(x)
|
|
#endif
|
|
#if __GNUC_PREREQ__(4, 9) || __has_attribute(__alloc_align__)
|
|
#define __alloc_align(x) __attribute__((__alloc_align__(x)))
|
|
#else
|
|
#define __alloc_align(x)
|
|
#endif
|
|
#endif /* lint */
|
|
|
|
#if !__GNUC_PREREQ__(2, 95)
|
|
#define __alignof(x) __offsetof(struct { char __a; x __b; }, __b)
|
|
#endif
|
|
|
|
/*
|
|
* Keywords added in C11.
|
|
*/
|
|
|
|
#if !defined(__STDC_VERSION__) || __STDC_VERSION__ < 201112L || defined(lint)
|
|
|
|
#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) && !__has_extension(c_atomic) && \
|
|
!__has_extension(cxx_atomic)
|
|
/*
|
|
* No native support for _Atomic(). Place object in structure to prevent
|
|
* most forms of direct non-atomic access.
|
|
*/
|
|
#define _Atomic(T) struct { T volatile __val; }
|
|
#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)
|
|
#elif __GNUC_PREREQ__(4,6)
|
|
/* Nothing, gcc 4.6 and higher has _Static_assert built-in */
|
|
#elif defined(__COUNTER__)
|
|
#define _Static_assert(x, y) __Static_assert(x, __COUNTER__)
|
|
#define __Static_assert(x, y) ___Static_assert(x, y)
|
|
#define ___Static_assert(x, y) typedef char __assert_ ## y[(x) ? 1 : -1] \
|
|
__unused
|
|
#else
|
|
#define _Static_assert(x, y) struct __hack
|
|
#endif
|
|
#endif
|
|
|
|
#if !__has_extension(c_thread_local)
|
|
/*
|
|
* XXX: Some compilers (Clang 3.3, GCC 4.7) falsely announce C++11 mode
|
|
* without actually supporting the thread_local keyword. Don't check for
|
|
* the presence of C++11 when defining _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.
|
|
*/
|
|
|
|
#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 __GNUC_PREREQ__(3, 1) && !defined(__cplusplus)
|
|
#define __generic(expr, t, yes, no) \
|
|
__builtin_choose_expr( \
|
|
__builtin_types_compatible_p(__typeof(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
|
|
|
|
#if __GNUC_PREREQ__(2, 96)
|
|
#define __malloc_like __attribute__((__malloc__))
|
|
#define __pure __attribute__((__pure__))
|
|
#else
|
|
#define __malloc_like
|
|
#define __pure
|
|
#endif
|
|
|
|
#if __GNUC_PREREQ__(3, 1) || (defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 800)
|
|
#define __always_inline __attribute__((__always_inline__))
|
|
#else
|
|
#define __always_inline
|
|
#endif
|
|
|
|
#if __GNUC_PREREQ__(3, 1)
|
|
#define __noinline __attribute__ ((__noinline__))
|
|
#else
|
|
#define __noinline
|
|
#endif
|
|
|
|
#if __GNUC_PREREQ__(3, 4)
|
|
#define __fastcall __attribute__((__fastcall__))
|
|
#define __result_use_check __attribute__((__warn_unused_result__))
|
|
#else
|
|
#define __fastcall
|
|
#define __result_use_check
|
|
#endif
|
|
|
|
#if __GNUC_PREREQ__(4, 1)
|
|
#define __returns_twice __attribute__((__returns_twice__))
|
|
#else
|
|
#define __returns_twice
|
|
#endif
|
|
|
|
#if __GNUC_PREREQ__(4, 6) || __has_builtin(__builtin_unreachable)
|
|
#define __unreachable() __builtin_unreachable()
|
|
#else
|
|
#define __unreachable() ((void)0)
|
|
#endif
|
|
|
|
/* XXX: should use `#if __STDC_VERSION__ < 199901'. */
|
|
#if !__GNUC_PREREQ__(2, 7) && !defined(__INTEL_COMPILER)
|
|
#define __func__ NULL
|
|
#endif
|
|
|
|
#if (defined(__INTEL_COMPILER) || (defined(__GNUC__) && __GNUC__ >= 2)) && !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
|
|
|
|
/*
|
|
* GCC 2.95 provides `__restrict' as an extension to C90 to support the
|
|
* C99-specific `restrict' type qualifier. We happen to use `__restrict' as
|
|
* a way to define the `restrict' type qualifier without disturbing older
|
|
* software that is unaware of C99 keywords.
|
|
*/
|
|
#if !(__GNUC__ == 2 && __GNUC_MINOR__ == 95)
|
|
#if !defined(__STDC_VERSION__) || __STDC_VERSION__ < 199901 || defined(lint)
|
|
#define __restrict
|
|
#else
|
|
#define __restrict restrict
|
|
#endif
|
|
#endif
|
|
|
|
/*
|
|
* GNU C version 2.96 adds explicit branch prediction so that
|
|
* the CPU back-end can hint 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.
|
|
*
|
|
* The following two macros provide us with a way to utilize this
|
|
* compiler feature. Use __predict_true() if you expect the expression
|
|
* to evaluate to true, and __predict_false() if you expect the
|
|
* expression to evaluate to false.
|
|
*
|
|
* A few notes about usage:
|
|
*
|
|
* * Generally, __predict_false() error condition checks (unless
|
|
* you have some _strong_ reason to do otherwise, in which case
|
|
* document it), and/or __predict_true() `no-error' condition
|
|
* checks, assuming you want to optimize for the no-error case.
|
|
*
|
|
* * Other than that, if you don't know the likelihood of a test
|
|
* succeeding from empirical or other `hard' evidence, don't
|
|
* make predictions.
|
|
*
|
|
* * These are meant to be used in places that are run `a lot'.
|
|
* It is wasteful to make predictions in code that is run
|
|
* seldomly (e.g. at subsystem initialization time) as the
|
|
* basic block reordering that this affects can often generate
|
|
* larger code.
|
|
*/
|
|
#if __GNUC_PREREQ__(2, 96)
|
|
#define __predict_true(exp) __builtin_expect((exp), 1)
|
|
#define __predict_false(exp) __builtin_expect((exp), 0)
|
|
#else
|
|
#define __predict_true(exp) (exp)
|
|
#define __predict_false(exp) (exp)
|
|
#endif
|
|
|
|
#if __GNUC_PREREQ__(4, 0)
|
|
#define __null_sentinel __attribute__((__sentinel__))
|
|
#define __exported __attribute__((__visibility__("default")))
|
|
#define __hidden __attribute__((__visibility__("hidden")))
|
|
#else
|
|
#define __null_sentinel
|
|
#define __exported
|
|
#define __hidden
|
|
#endif
|
|
|
|
/*
|
|
* We define this here since <stddef.h>, <sys/queue.h>, and <sys/types.h>
|
|
* require it.
|
|
*/
|
|
#if __GNUC_PREREQ__(4, 1)
|
|
#define __offsetof(type, field) __builtin_offsetof(type, field)
|
|
#else
|
|
#ifndef __cplusplus
|
|
#define __offsetof(type, field) \
|
|
((__size_t)(__uintptr_t)((const volatile void *)&((type *)0)->field))
|
|
#else
|
|
#define __offsetof(type, field) \
|
|
(__offsetof__ (reinterpret_cast <__size_t> \
|
|
(&reinterpret_cast <const volatile char &> \
|
|
(static_cast<type *> (0)->field))))
|
|
#endif
|
|
#endif
|
|
#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.
|
|
*/
|
|
#if __GNUC_PREREQ__(3, 1)
|
|
#define __containerof(x, s, m) ({ \
|
|
const volatile __typeof(((s *)0)->m) *__x = (x); \
|
|
__DEQUALIFY(s *, (const volatile char *)__x - __offsetof(s, m));\
|
|
})
|
|
#else
|
|
#define __containerof(x, s, m) \
|
|
__DEQUALIFY(s *, (const volatile char *)(x) - __offsetof(s, m))
|
|
#endif
|
|
|
|
/*
|
|
* Compiler-dependent macros to declare that functions take printf-like
|
|
* or scanf-like arguments. They are null except for versions of gcc
|
|
* that are known to support the features properly (old versions of gcc-2
|
|
* didn't permit keeping the keywords out of the application namespace).
|
|
*/
|
|
#if !__GNUC_PREREQ__(2, 7) && !defined(__INTEL_COMPILER)
|
|
#define __printflike(fmtarg, firstvararg)
|
|
#define __scanflike(fmtarg, firstvararg)
|
|
#define __format_arg(fmtarg)
|
|
#define __strfmonlike(fmtarg, firstvararg)
|
|
#define __strftimelike(fmtarg, firstvararg)
|
|
#else
|
|
#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)))
|
|
#endif
|
|
|
|
/* Compiler-dependent macros that rely on FreeBSD-specific extensions. */
|
|
#if defined(__FreeBSD_cc_version) && __FreeBSD_cc_version >= 300001 && \
|
|
defined(__GNUC__) && !defined(__INTEL_COMPILER)
|
|
#define __printf0like(fmtarg, firstvararg) \
|
|
__attribute__((__format__ (__printf0__, fmtarg, firstvararg)))
|
|
#else
|
|
#define __printf0like(fmtarg, firstvararg)
|
|
#endif
|
|
|
|
#if defined(__GNUC__) || defined(__INTEL_COMPILER)
|
|
#ifndef __INTEL_COMPILER
|
|
#define __strong_reference(sym,aliassym) \
|
|
extern __typeof (sym) aliassym __attribute__ ((__alias__ (#sym)))
|
|
#endif
|
|
#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")
|
|
#define __sym_compat(sym,impl,verid) \
|
|
__asm__(".symver " #impl ", " #sym "@" #verid)
|
|
#define __sym_default(sym,impl,verid) \
|
|
__asm__(".symver " #impl ", " #sym "@@" #verid)
|
|
#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")
|
|
#define __sym_compat(sym,impl,verid) \
|
|
__asm__(".symver impl, sym@verid")
|
|
#define __sym_default(impl,sym,verid) \
|
|
__asm__(".symver impl, sym@@verid")
|
|
#endif /* __STDC__ */
|
|
#endif /* __GNUC__ || __INTEL_COMPILER */
|
|
|
|
#define __GLOBL1(sym) __asm__(".globl " #sym)
|
|
#define __GLOBL(sym) __GLOBL1(sym)
|
|
|
|
#if defined(__GNUC__) || defined(__INTEL_COMPILER)
|
|
#define __IDSTRING(name,string) __asm__(".ident\t\"" string "\"")
|
|
#else
|
|
/*
|
|
* The following definition might not work well if used in header files,
|
|
* but it should be better than nothing. If you want a "do nothing"
|
|
* version, then it should generate some harmless declaration, such as:
|
|
* #define __IDSTRING(name,string) struct __hack
|
|
*/
|
|
#define __IDSTRING(name,string) static const char name[] __unused = string
|
|
#endif
|
|
|
|
/*
|
|
* 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:
|
|
* __FBSDID("$FreeBSD$");
|
|
*/
|
|
#ifndef __FBSDID
|
|
#if !defined(lint) && !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
|
|
|
|
/*-
|
|
* The following definitions are an extension of the behavior originally
|
|
* implemented in <sys/_posix.h>, 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:
|
|
* defined(_POSIX_SOURCE) 1003.1-1988
|
|
* _POSIX_C_SOURCE == 1 1003.1-1990
|
|
* _POSIX_C_SOURCE == 2 1003.2-1992 C Language Binding Option
|
|
* _POSIX_C_SOURCE == 199309 1003.1b-1993
|
|
* _POSIX_C_SOURCE == 199506 1003.1c-1995, 1003.1i-1995,
|
|
* and the omnibus ISO/IEC 9945-1: 1996
|
|
* _POSIX_C_SOURCE == 200112 1003.1-2001
|
|
* _POSIX_C_SOURCE == 200809 1003.1-2008
|
|
*
|
|
* 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. */
|
|
#ifdef _XOPEN_SOURCE
|
|
#if _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
|
|
#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 >= 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 */
|
|
#else
|
|
/*-
|
|
* 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
|
|
#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
|
|
#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
|
|
#else /* Default environment: show everything. */
|
|
#define __POSIX_VISIBLE 200809
|
|
#define __XSI_VISIBLE 700
|
|
#define __BSD_VISIBLE 1
|
|
#define __ISO_C_VISIBLE 2011
|
|
#endif
|
|
#endif
|
|
|
|
#if defined(__mips) || defined(__powerpc64__) || defined(__riscv__)
|
|
#define __NO_TLS 1
|
|
#endif
|
|
|
|
/*
|
|
* Old versions of GCC use non-standard ARM arch symbols; acle-compat.h
|
|
* translates them to __ARM_ARCH and the modern feature symbols defined by ARM.
|
|
*/
|
|
#if defined(__arm__) && !defined(__ARM_ARCH)
|
|
#include <machine/acle-compat.h>
|
|
#endif
|
|
|
|
/*
|
|
* 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__) && !defined(lint)
|
|
#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)
|
|
|
|
/* 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))
|
|
|
|
#endif /* !_SYS_CDEFS_H_ */
|