1 /*- 2 * Copyright (c) 1991, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * This code is derived from software contributed to Berkeley by 6 * Berkeley Software Design, Inc. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 4. Neither the name of the University nor the names of its contributors 17 * may be used to endorse or promote products derived from this software 18 * without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30 * SUCH DAMAGE. 31 * 32 * @(#)cdefs.h 8.8 (Berkeley) 1/9/95 33 * $FreeBSD$ 34 */ 35 #ifndef _FBSD_COMPAT_SYS_CDEFS_H_ 36 #define _FBSD_COMPAT_SYS_CDEFS_H_ 37 38 39 #include <posix/sys/cdefs.h> 40 41 42 #if 0 43 #define __FBSDID(str) static const char __fbsdid[] = str 44 #else 45 #define __FBSDID(str) 46 #endif 47 48 /* 49 * This code has been put in place to help reduce the addition of 50 * compiler specific defines in FreeBSD code. It helps to aid in 51 * having a compiler-agnostic source tree. 52 */ 53 54 #if defined(__GNUC__) || defined(__INTEL_COMPILER) 55 56 #if __GNUC__ >= 3 || defined(__INTEL_COMPILER) 57 #define __GNUCLIKE_ASM 3 58 #define __GNUCLIKE_MATH_BUILTIN_CONSTANTS 59 #else 60 #define __GNUCLIKE_ASM 2 61 #endif 62 #define __GNUCLIKE___TYPEOF 1 63 #define __GNUCLIKE___OFFSETOF 1 64 #define __GNUCLIKE___SECTION 1 65 66 #define __GNUCLIKE_ATTRIBUTE_MODE_DI 1 67 68 #ifndef __INTEL_COMPILER 69 # define __GNUCLIKE_CTOR_SECTION_HANDLING 1 70 #endif 71 72 #define __GNUCLIKE_BUILTIN_CONSTANT_P 1 73 # if defined(__INTEL_COMPILER) && defined(__cplusplus) \ 74 && __INTEL_COMPILER < 800 75 # undef __GNUCLIKE_BUILTIN_CONSTANT_P 76 # endif 77 78 #if (__GNUC_MINOR__ > 95 || __GNUC__ >= 3) && !defined(__INTEL_COMPILER) 79 # define __GNUCLIKE_BUILTIN_VARARGS 1 80 # define __GNUCLIKE_BUILTIN_STDARG 1 81 # define __GNUCLIKE_BUILTIN_VAALIST 1 82 #endif 83 84 #if defined(__GNUC__) 85 # define __GNUC_VA_LIST_COMPATIBILITY 1 86 #endif 87 88 /* 89 * Compiler memory barriers, specific to gcc and clang. 90 */ 91 #if defined(__GNUC__) 92 #define __compiler_membar() __asm __volatile(" " : : : "memory") 93 #endif 94 95 #ifndef __INTEL_COMPILER 96 # define __GNUCLIKE_BUILTIN_NEXT_ARG 1 97 # define __GNUCLIKE_MATH_BUILTIN_RELOPS 98 #endif 99 100 #define __GNUCLIKE_BUILTIN_MEMCPY 1 101 102 /* XXX: if __GNUC__ >= 2: not tested everywhere originally, where replaced */ 103 #define __CC_SUPPORTS_INLINE 1 104 #define __CC_SUPPORTS___INLINE 1 105 #define __CC_SUPPORTS___INLINE__ 1 106 107 #define __CC_SUPPORTS___FUNC__ 1 108 #define __CC_SUPPORTS_WARNING 1 109 110 #define __CC_SUPPORTS_VARADIC_XXX 1 /* see varargs.h */ 111 112 #define __CC_SUPPORTS_DYNAMIC_ARRAY_INIT 1 113 114 #endif /* __GNUC__ || __INTEL_COMPILER */ 115 116 117 /* 118 * Macro to test if we're using a specific version of gcc or later. 119 */ 120 #if defined(__GNUC__) && !defined(__INTEL_COMPILER) 121 #define __GNUC_PREREQ__(ma, mi) \ 122 (__GNUC__ > (ma) || __GNUC__ == (ma) && __GNUC_MINOR__ >= (mi)) 123 #else 124 #define __GNUC_PREREQ__(ma, mi) 0 125 #endif 126 127 /* 128 * GNU C version 2.96 adds explicit branch prediction so that 129 * the CPU back-end can hint the processor and also so that 130 * code blocks can be reordered such that the predicted path 131 * sees a more linear flow, thus improving cache behavior, etc. 132 * 133 * The following two macros provide us with a way to utilize this 134 * compiler feature. Use __predict_true() if you expect the expression 135 * to evaluate to true, and __predict_false() if you expect the 136 * expression to evaluate to false. 137 * 138 * A few notes about usage: 139 * 140 * * Generally, __predict_false() error condition checks (unless 141 * you have some _strong_ reason to do otherwise, in which case 142 * document it), and/or __predict_true() `no-error' condition 143 * checks, assuming you want to optimize for the no-error case. 144 * 145 * * Other than that, if you don't know the likelihood of a test 146 * succeeding from empirical or other `hard' evidence, don't 147 * make predictions. 148 * 149 * * These are meant to be used in places that are run `a lot'. 150 * It is wasteful to make predictions in code that is run 151 * seldomly (e.g. at subsystem initialization time) as the 152 * basic block reordering that this affects can often generate 153 * larger code. 154 */ 155 #if __GNUC_PREREQ__(2, 96) 156 #define __predict_true(exp) __builtin_expect((exp), 1) 157 #define __predict_false(exp) __builtin_expect((exp), 0) 158 #else 159 #define __predict_true(exp) (exp) 160 #define __predict_false(exp) (exp) 161 #endif 162 163 /* 164 * We define this here since <stddef.h>, <sys/queue.h>, and <sys/types.h> 165 * require it. 166 */ 167 #if __GNUC_PREREQ__(4, 1) 168 #define __offsetof(type, field) __builtin_offsetof(type, field) 169 #else 170 #ifndef __cplusplus 171 #define __offsetof(type, field) ((size_t)(&((type *)0)->field)) 172 #else 173 #define __offsetof(type, field) \ 174 ((reinterpret_cast <size_t> \ 175 (&reinterpret_cast <const volatile char &> \ 176 (static_cast<type *> (0)->field)))) 177 #endif 178 #endif 179 #define __rangeof(type, start, end) \ 180 (__offsetof(type, end) - __offsetof(type, start)) 181 182 /* 183 * Given the pointer x to the member m of the struct s, return 184 * a pointer to the containing structure. When using GCC, we first 185 * assign pointer x to a local variable, to check that its type is 186 * compatible with member m. 187 */ 188 #if __GNUC_PREREQ__(3, 1) 189 #define __containerof(x, s, m) ({ \ 190 const volatile __typeof(((s *)0)->m) *__x = (x); \ 191 __DEQUALIFY(s *, (const volatile char *)__x - __offsetof(s, m));\ 192 }) 193 #else 194 #define __containerof(x, s, m) \ 195 __DEQUALIFY(s *, (const volatile char *)(x) - __offsetof(s, m)) 196 #endif 197 198 /* 199 * Compiler-dependent macros to help declare dead (non-returning) and 200 * pure (no side effects) functions, and unused variables. They are 201 * null except for versions of gcc that are known to support the features 202 * properly (old versions of gcc-2 supported the dead and pure features 203 * in a different (wrong) way). If we do not provide an implementation 204 * for a given compiler, let the compile fail if it is told to use 205 * a feature that we cannot live without. 206 */ 207 /* 208 * Compiler-dependent macros to help declare dead (non-returning) and 209 * pure (no side effects) functions, and unused variables. They are 210 * null except for versions of gcc that are known to support the features 211 * properly (old versions of gcc-2 supported the dead and pure features 212 * in a different (wrong) way). If we do not provide an implementation 213 * for a given compiler, let the compile fail if it is told to use 214 * a feature that we cannot live without. 215 */ 216 #define __weak_symbol __attribute__((__weak__)) 217 #if !__GNUC_PREREQ__(2, 5) && !defined(__INTEL_COMPILER) 218 #define __dead2 219 #define __pure2 220 #define __unused 221 #endif 222 #if __GNUC__ == 2 && __GNUC_MINOR__ >= 5 && __GNUC_MINOR__ < 7 && !defined(__INTEL_COMPILER) 223 #define __dead2 __attribute__((__noreturn__)) 224 #define __pure2 __attribute__((__const__)) 225 #define __unused 226 /* XXX Find out what to do for __packed, __aligned and __section */ 227 #endif 228 #if __GNUC_PREREQ__(2, 7) || defined(__INTEL_COMPILER) 229 #undef __dead2 230 #define __dead2 __attribute__((__noreturn__)) 231 #define __pure2 __attribute__((__const__)) 232 #define __unused __attribute__((__unused__)) 233 #define __used __attribute__((__used__)) 234 #define __packed __attribute__((__packed__)) 235 #define __aligned(x) __attribute__((__aligned__(x))) 236 #define __section(x) __attribute__((__section__(x))) 237 #endif 238 #if __GNUC_PREREQ__(4, 3) 239 #define __alloc_size(x) __attribute__((__alloc_size__(x))) 240 #define __alloc_size2(n, x) __attribute__((__alloc_size__(n, x))) 241 #else 242 #define __alloc_size(x) 243 #define __alloc_size2(n, x) 244 #endif 245 #if __GNUC_PREREQ__(4, 9) 246 #define __alloc_align(x) __attribute__((__alloc_align__(x))) 247 #else 248 #define __alloc_align(x) 249 #endif 250 251 /* 252 * Compiler-dependent macros to declare that functions take printf-like 253 * or scanf-like arguments. They are null except for versions of gcc 254 * that are known to support the features properly (old versions of gcc-2 255 * didn't permit keeping the keywords out of the application namespace). 256 */ 257 #if !__GNUC_PREREQ__(2, 7) && !defined(__INTEL_COMPILER) 258 #define __printflike(fmtarg, firstvararg) 259 #define __scanflike(fmtarg, firstvararg) 260 #define __format_arg(fmtarg) 261 #else 262 #define __printflike(fmtarg, firstvararg) \ 263 __attribute__((__format__ (__printf__, fmtarg, firstvararg))) 264 #define __scanflike(fmtarg, firstvararg) \ 265 __attribute__((__format__ (__scanf__, fmtarg, firstvararg))) 266 #define __format_arg(fmtarg) __attribute__((__format_arg__ (fmtarg))) 267 #endif 268 269 /* 270 * C99 Static array indices in function parameter declarations. Syntax such as: 271 * void bar(int myArray[static 10]); 272 * is allowed in C99 but not in C++. Define __min_size appropriately so 273 * headers using it can be compiled in either language. Use like this: 274 * void bar(int myArray[__min_size(10)]); 275 */ 276 #if !defined(__cplusplus) && \ 277 (defined(__clang__) || __GNUC_PREREQ__(4, 6)) && \ 278 (!defined(__STDC_VERSION__) || (__STDC_VERSION__ >= 199901)) 279 #define __min_size(x) static (x) 280 #else 281 #define __min_size(x) (x) 282 #endif 283 284 #if __GNUC_PREREQ__(3, 1) 285 #define __noinline __attribute__ ((__noinline__)) 286 #else 287 #define __noinline 288 #endif 289 290 #if __GNUC_PREREQ__(3, 3) 291 #define __nonnull(x) __attribute__((__nonnull__(x))) 292 #else 293 #define __nonnull(x) 294 #endif 295 296 /* 297 * The __CONCAT macro is used to concatenate parts of symbol names, e.g. 298 * with "#define OLD(foo) __CONCAT(old,foo)", OLD(foo) produces oldfoo. 299 * The __CONCAT macro is a bit tricky to use if it must work in non-ANSI 300 * mode -- there must be no spaces between its arguments, and for nested 301 * __CONCAT's, all the __CONCAT's must be at the left. __CONCAT can also 302 * concatenate double-quoted strings produced by the __STRING macro, but 303 * this only works with ANSI C. 304 * 305 * __XSTRING is like __STRING, but it expands any macros in its argument 306 * first. It is only available with ANSI C. 307 */ 308 #if defined(__STDC__) || defined(__cplusplus) 309 #define __XSTRING(x) __STRING(x) /* expand x, then stringify */ 310 311 #define __const const /* define reserved names to standard */ 312 #define __signed signed 313 #define __volatile volatile 314 #if defined(__cplusplus) 315 #define __inline inline /* convert to C++ keyword */ 316 #else 317 #if !(defined(__CC_SUPPORTS___INLINE)) 318 #define __inline /* delete GCC keyword */ 319 #endif /* ! __CC_SUPPORTS___INLINE */ 320 #endif /* !__cplusplus */ 321 322 #else /* !(__STDC__ || __cplusplus) */ 323 324 #if !defined(__CC_SUPPORTS___INLINE) 325 #define __const /* delete pseudo-ANSI C keywords */ 326 #define __inline 327 #define __signed 328 #define __volatile 329 /* 330 * In non-ANSI C environments, new programs will want ANSI-only C keywords 331 * deleted from the program and old programs will want them left alone. 332 * When using a compiler other than gcc, programs using the ANSI C keywords 333 * const, inline etc. as normal identifiers should define -DNO_ANSI_KEYWORDS. 334 * When using "gcc -traditional", we assume that this is the intent; if 335 * __GNUC__ is defined but __STDC__ is not, we leave the new keywords alone. 336 */ 337 #ifndef NO_ANSI_KEYWORDS 338 #define const /* delete ANSI C keywords */ 339 #define inline 340 #define signed 341 #define volatile 342 #endif /* !NO_ANSI_KEYWORDS */ 343 #endif /* !__CC_SUPPORTS___INLINE */ 344 #endif /* !(__STDC__ || __cplusplus) */ 345 346 #ifndef __DECONST 347 #define __DECONST(type, var) ((type)(uintptr_t)(const void *)(var)) 348 #endif 349 350 #ifndef __UNCONST 351 #define __UNCONST(var) ((void*)(uintptr_t)(const void *)(var)) 352 #endif 353 354 #ifndef __DEVOLATILE 355 #define __DEVOLATILE(type, var) ((type)(uintptr_t)(volatile void *)(var)) 356 #endif 357 358 #ifndef __DEQUALIFY 359 #define __DEQUALIFY(type, var) ((type)(uintptr_t)(const volatile void *)(var)) 360 #endif 361 362 #if __GNUC_PREREQ__(4,6) && !defined(__cplusplus) 363 /* Nothing, gcc 4.6 and higher has _Static_assert built-in */ 364 #elif defined(__COUNTER__) 365 #define _Static_assert(x, y) __Static_assert(x, __COUNTER__) 366 #define __Static_assert(x, y) ___Static_assert(x, y) 367 #define ___Static_assert(x, y) typedef char __assert_ ## y[(x) ? 1 : -1] \ 368 __unused 369 #else 370 #define _Static_assert(x, y) 371 #endif 372 373 #endif 374