diff options
Diffstat (limited to 'gl/cdefs.h')
-rw-r--r-- | gl/cdefs.h | 704 |
1 files changed, 704 insertions, 0 deletions
diff --git a/gl/cdefs.h b/gl/cdefs.h new file mode 100644 index 00000000..ab57d4a0 --- /dev/null +++ b/gl/cdefs.h | |||
@@ -0,0 +1,704 @@ | |||
1 | /* Copyright (C) 1992-2021 Free Software Foundation, Inc. | ||
2 | Copyright The GNU Toolchain Authors. | ||
3 | This file is part of the GNU C Library. | ||
4 | |||
5 | The GNU C Library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Lesser General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2.1 of the License, or (at your option) any later version. | ||
9 | |||
10 | The GNU C Library is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with the GNU C Library; if not, see | ||
17 | <https://www.gnu.org/licenses/>. */ | ||
18 | |||
19 | #ifndef _SYS_CDEFS_H | ||
20 | #define _SYS_CDEFS_H 1 | ||
21 | |||
22 | /* We are almost always included from features.h. */ | ||
23 | #ifndef _FEATURES_H | ||
24 | # include <features.h> | ||
25 | #endif | ||
26 | |||
27 | /* The GNU libc does not support any K&R compilers or the traditional mode | ||
28 | of ISO C compilers anymore. Check for some of the combinations not | ||
29 | supported anymore. */ | ||
30 | #if defined __GNUC__ && !defined __STDC__ | ||
31 | # error "You need a ISO C conforming compiler to use the glibc headers" | ||
32 | #endif | ||
33 | |||
34 | /* Some user header file might have defined this before. */ | ||
35 | #undef __P | ||
36 | #undef __PMT | ||
37 | |||
38 | /* Compilers that lack __has_attribute may object to | ||
39 | #if defined __has_attribute && __has_attribute (...) | ||
40 | even though they do not need to evaluate the right-hand side of the &&. | ||
41 | Similarly for __has_builtin, etc. */ | ||
42 | #if (defined __has_attribute \ | ||
43 | && (!defined __clang_minor__ \ | ||
44 | || 3 < __clang_major__ + (5 <= __clang_minor__))) | ||
45 | # define __glibc_has_attribute(attr) __has_attribute (attr) | ||
46 | #else | ||
47 | # define __glibc_has_attribute(attr) 0 | ||
48 | #endif | ||
49 | #ifdef __has_builtin | ||
50 | # define __glibc_has_builtin(name) __has_builtin (name) | ||
51 | #else | ||
52 | # define __glibc_has_builtin(name) 0 | ||
53 | #endif | ||
54 | #ifdef __has_extension | ||
55 | # define __glibc_has_extension(ext) __has_extension (ext) | ||
56 | #else | ||
57 | # define __glibc_has_extension(ext) 0 | ||
58 | #endif | ||
59 | |||
60 | #if defined __GNUC__ || defined __clang__ | ||
61 | |||
62 | /* All functions, except those with callbacks or those that | ||
63 | synchronize memory, are leaf functions. */ | ||
64 | # if __GNUC_PREREQ (4, 6) && !defined _LIBC | ||
65 | # define __LEAF , __leaf__ | ||
66 | # define __LEAF_ATTR __attribute__ ((__leaf__)) | ||
67 | # else | ||
68 | # define __LEAF | ||
69 | # define __LEAF_ATTR | ||
70 | # endif | ||
71 | |||
72 | /* GCC can always grok prototypes. For C++ programs we add throw() | ||
73 | to help it optimize the function calls. But this only works with | ||
74 | gcc 2.8.x and egcs. For gcc 3.4 and up we even mark C functions | ||
75 | as non-throwing using a function attribute since programs can use | ||
76 | the -fexceptions options for C code as well. */ | ||
77 | # if !defined __cplusplus \ | ||
78 | && (__GNUC_PREREQ (3, 4) || __glibc_has_attribute (__nothrow__)) | ||
79 | # define __THROW __attribute__ ((__nothrow__ __LEAF)) | ||
80 | # define __THROWNL __attribute__ ((__nothrow__)) | ||
81 | # define __NTH(fct) __attribute__ ((__nothrow__ __LEAF)) fct | ||
82 | # define __NTHNL(fct) __attribute__ ((__nothrow__)) fct | ||
83 | # else | ||
84 | # if defined __cplusplus && (__GNUC_PREREQ (2,8) || __clang_major >= 4) | ||
85 | # if __cplusplus >= 201103L | ||
86 | # define __THROW noexcept (true) | ||
87 | # else | ||
88 | # define __THROW throw () | ||
89 | # endif | ||
90 | # define __THROWNL __THROW | ||
91 | # define __NTH(fct) __LEAF_ATTR fct __THROW | ||
92 | # define __NTHNL(fct) fct __THROW | ||
93 | # else | ||
94 | # define __THROW | ||
95 | # define __THROWNL | ||
96 | # define __NTH(fct) fct | ||
97 | # define __NTHNL(fct) fct | ||
98 | # endif | ||
99 | # endif | ||
100 | |||
101 | #else /* Not GCC or clang. */ | ||
102 | |||
103 | # if (defined __cplusplus \ | ||
104 | || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L)) | ||
105 | # define __inline inline | ||
106 | # else | ||
107 | # define __inline /* No inline functions. */ | ||
108 | # endif | ||
109 | |||
110 | # define __THROW | ||
111 | # define __THROWNL | ||
112 | # define __NTH(fct) fct | ||
113 | |||
114 | #endif /* GCC || clang. */ | ||
115 | |||
116 | /* These two macros are not used in glibc anymore. They are kept here | ||
117 | only because some other projects expect the macros to be defined. */ | ||
118 | #define __P(args) args | ||
119 | #define __PMT(args) args | ||
120 | |||
121 | /* For these things, GCC behaves the ANSI way normally, | ||
122 | and the non-ANSI way under -traditional. */ | ||
123 | |||
124 | #define __CONCAT(x,y) x ## y | ||
125 | #define __STRING(x) #x | ||
126 | |||
127 | /* This is not a typedef so `const __ptr_t' does the right thing. */ | ||
128 | #define __ptr_t void * | ||
129 | |||
130 | |||
131 | /* C++ needs to know that types and declarations are C, not C++. */ | ||
132 | #ifdef __cplusplus | ||
133 | # define __BEGIN_DECLS extern "C" { | ||
134 | # define __END_DECLS } | ||
135 | #else | ||
136 | # define __BEGIN_DECLS | ||
137 | # define __END_DECLS | ||
138 | #endif | ||
139 | |||
140 | |||
141 | /* Fortify support. */ | ||
142 | #define __bos(ptr) __builtin_object_size (ptr, __USE_FORTIFY_LEVEL > 1) | ||
143 | #define __bos0(ptr) __builtin_object_size (ptr, 0) | ||
144 | |||
145 | /* Use __builtin_dynamic_object_size at _FORTIFY_SOURCE=3 when available. */ | ||
146 | #if __USE_FORTIFY_LEVEL == 3 && __glibc_clang_prereq (9, 0) | ||
147 | # define __glibc_objsize0(__o) __builtin_dynamic_object_size (__o, 0) | ||
148 | # define __glibc_objsize(__o) __builtin_dynamic_object_size (__o, 1) | ||
149 | #else | ||
150 | # define __glibc_objsize0(__o) __bos0 (__o) | ||
151 | # define __glibc_objsize(__o) __bos (__o) | ||
152 | #endif | ||
153 | |||
154 | /* Compile time conditions to choose between the regular, _chk and _chk_warn | ||
155 | variants. These conditions should get evaluated to constant and optimized | ||
156 | away. */ | ||
157 | |||
158 | #define __glibc_safe_len_cond(__l, __s, __osz) ((__l) <= (__osz) / (__s)) | ||
159 | #define __glibc_unsigned_or_positive(__l) \ | ||
160 | ((__typeof (__l)) 0 < (__typeof (__l)) -1 \ | ||
161 | || (__builtin_constant_p (__l) && (__l) > 0)) | ||
162 | |||
163 | /* Length is known to be safe at compile time if the __L * __S <= __OBJSZ | ||
164 | condition can be folded to a constant and if it is true. The -1 check is | ||
165 | redundant because since it implies that __glibc_safe_len_cond is true. */ | ||
166 | #define __glibc_safe_or_unknown_len(__l, __s, __osz) \ | ||
167 | (__glibc_unsigned_or_positive (__l) \ | ||
168 | && __builtin_constant_p (__glibc_safe_len_cond ((__SIZE_TYPE__) (__l), \ | ||
169 | __s, __osz)) \ | ||
170 | && __glibc_safe_len_cond ((__SIZE_TYPE__) (__l), __s, __osz)) | ||
171 | |||
172 | /* Conversely, we know at compile time that the length is safe if the | ||
173 | __L * __S <= __OBJSZ condition can be folded to a constant and if it is | ||
174 | false. */ | ||
175 | #define __glibc_unsafe_len(__l, __s, __osz) \ | ||
176 | (__glibc_unsigned_or_positive (__l) \ | ||
177 | && __builtin_constant_p (__glibc_safe_len_cond ((__SIZE_TYPE__) (__l), \ | ||
178 | __s, __osz)) \ | ||
179 | && !__glibc_safe_len_cond ((__SIZE_TYPE__) (__l), __s, __osz)) | ||
180 | |||
181 | /* Fortify function f. __f_alias, __f_chk and __f_chk_warn must be | ||
182 | declared. */ | ||
183 | |||
184 | #define __glibc_fortify(f, __l, __s, __osz, ...) \ | ||
185 | (__glibc_safe_or_unknown_len (__l, __s, __osz) \ | ||
186 | ? __ ## f ## _alias (__VA_ARGS__) \ | ||
187 | : (__glibc_unsafe_len (__l, __s, __osz) \ | ||
188 | ? __ ## f ## _chk_warn (__VA_ARGS__, __osz) \ | ||
189 | : __ ## f ## _chk (__VA_ARGS__, __osz))) \ | ||
190 | |||
191 | /* Fortify function f, where object size argument passed to f is the number of | ||
192 | elements and not total size. */ | ||
193 | |||
194 | #define __glibc_fortify_n(f, __l, __s, __osz, ...) \ | ||
195 | (__glibc_safe_or_unknown_len (__l, __s, __osz) \ | ||
196 | ? __ ## f ## _alias (__VA_ARGS__) \ | ||
197 | : (__glibc_unsafe_len (__l, __s, __osz) \ | ||
198 | ? __ ## f ## _chk_warn (__VA_ARGS__, (__osz) / (__s)) \ | ||
199 | : __ ## f ## _chk (__VA_ARGS__, (__osz) / (__s)))) \ | ||
200 | |||
201 | #if __GNUC_PREREQ (4,3) | ||
202 | # define __warnattr(msg) __attribute__((__warning__ (msg))) | ||
203 | # define __errordecl(name, msg) \ | ||
204 | extern void name (void) __attribute__((__error__ (msg))) | ||
205 | #else | ||
206 | # define __warnattr(msg) | ||
207 | # define __errordecl(name, msg) extern void name (void) | ||
208 | #endif | ||
209 | |||
210 | /* Support for flexible arrays. | ||
211 | Headers that should use flexible arrays only if they're "real" | ||
212 | (e.g. only if they won't affect sizeof()) should test | ||
213 | #if __glibc_c99_flexarr_available. */ | ||
214 | #if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L && !defined __HP_cc | ||
215 | # define __flexarr [] | ||
216 | # define __glibc_c99_flexarr_available 1 | ||
217 | #elif __GNUC_PREREQ (2,97) || defined __clang__ | ||
218 | /* GCC 2.97 and clang support C99 flexible array members as an extension, | ||
219 | even when in C89 mode or compiling C++ (any version). */ | ||
220 | # define __flexarr [] | ||
221 | # define __glibc_c99_flexarr_available 1 | ||
222 | #elif defined __GNUC__ | ||
223 | /* Pre-2.97 GCC did not support C99 flexible arrays but did have | ||
224 | an equivalent extension with slightly different notation. */ | ||
225 | # define __flexarr [0] | ||
226 | # define __glibc_c99_flexarr_available 1 | ||
227 | #else | ||
228 | /* Some other non-C99 compiler. Approximate with [1]. */ | ||
229 | # define __flexarr [1] | ||
230 | # define __glibc_c99_flexarr_available 0 | ||
231 | #endif | ||
232 | |||
233 | |||
234 | /* __asm__ ("xyz") is used throughout the headers to rename functions | ||
235 | at the assembly language level. This is wrapped by the __REDIRECT | ||
236 | macro, in order to support compilers that can do this some other | ||
237 | way. When compilers don't support asm-names at all, we have to do | ||
238 | preprocessor tricks instead (which don't have exactly the right | ||
239 | semantics, but it's the best we can do). | ||
240 | |||
241 | Example: | ||
242 | int __REDIRECT(setpgrp, (__pid_t pid, __pid_t pgrp), setpgid); */ | ||
243 | |||
244 | #if (defined __GNUC__ && __GNUC__ >= 2) || (__clang_major__ >= 4) | ||
245 | |||
246 | # define __REDIRECT(name, proto, alias) name proto __asm__ (__ASMNAME (#alias)) | ||
247 | # ifdef __cplusplus | ||
248 | # define __REDIRECT_NTH(name, proto, alias) \ | ||
249 | name proto __THROW __asm__ (__ASMNAME (#alias)) | ||
250 | # define __REDIRECT_NTHNL(name, proto, alias) \ | ||
251 | name proto __THROWNL __asm__ (__ASMNAME (#alias)) | ||
252 | # else | ||
253 | # define __REDIRECT_NTH(name, proto, alias) \ | ||
254 | name proto __asm__ (__ASMNAME (#alias)) __THROW | ||
255 | # define __REDIRECT_NTHNL(name, proto, alias) \ | ||
256 | name proto __asm__ (__ASMNAME (#alias)) __THROWNL | ||
257 | # endif | ||
258 | # define __ASMNAME(cname) __ASMNAME2 (__USER_LABEL_PREFIX__, cname) | ||
259 | # define __ASMNAME2(prefix, cname) __STRING (prefix) cname | ||
260 | |||
261 | /* | ||
262 | #elif __SOME_OTHER_COMPILER__ | ||
263 | |||
264 | # define __REDIRECT(name, proto, alias) name proto; \ | ||
265 | _Pragma("let " #name " = " #alias) | ||
266 | */ | ||
267 | #endif | ||
268 | |||
269 | /* GCC and clang have various useful declarations that can be made with | ||
270 | the '__attribute__' syntax. All of the ways we use this do fine if | ||
271 | they are omitted for compilers that don't understand it. */ | ||
272 | #if !(defined __GNUC__ || defined __clang__) | ||
273 | # define __attribute__(xyz) /* Ignore */ | ||
274 | #endif | ||
275 | |||
276 | /* At some point during the gcc 2.96 development the `malloc' attribute | ||
277 | for functions was introduced. We don't want to use it unconditionally | ||
278 | (although this would be possible) since it generates warnings. */ | ||
279 | #if __GNUC_PREREQ (2,96) || __glibc_has_attribute (__malloc__) | ||
280 | # define __attribute_malloc__ __attribute__ ((__malloc__)) | ||
281 | #else | ||
282 | # define __attribute_malloc__ /* Ignore */ | ||
283 | #endif | ||
284 | |||
285 | /* Tell the compiler which arguments to an allocation function | ||
286 | indicate the size of the allocation. */ | ||
287 | #if __GNUC_PREREQ (4, 3) | ||
288 | # define __attribute_alloc_size__(params) \ | ||
289 | __attribute__ ((__alloc_size__ params)) | ||
290 | #else | ||
291 | # define __attribute_alloc_size__(params) /* Ignore. */ | ||
292 | #endif | ||
293 | |||
294 | /* Tell the compiler which argument to an allocation function | ||
295 | indicates the alignment of the allocation. */ | ||
296 | #if __GNUC_PREREQ (4, 9) || __glibc_has_attribute (__alloc_align__) | ||
297 | # define __attribute_alloc_align__(param) \ | ||
298 | __attribute__ ((__alloc_align__ param)) | ||
299 | #else | ||
300 | # define __attribute_alloc_align__(param) /* Ignore. */ | ||
301 | #endif | ||
302 | |||
303 | /* At some point during the gcc 2.96 development the `pure' attribute | ||
304 | for functions was introduced. We don't want to use it unconditionally | ||
305 | (although this would be possible) since it generates warnings. */ | ||
306 | #if __GNUC_PREREQ (2,96) || __glibc_has_attribute (__pure__) | ||
307 | # define __attribute_pure__ __attribute__ ((__pure__)) | ||
308 | #else | ||
309 | # define __attribute_pure__ /* Ignore */ | ||
310 | #endif | ||
311 | |||
312 | /* This declaration tells the compiler that the value is constant. */ | ||
313 | #if __GNUC_PREREQ (2,5) || __glibc_has_attribute (__const__) | ||
314 | # define __attribute_const__ __attribute__ ((__const__)) | ||
315 | #else | ||
316 | # define __attribute_const__ /* Ignore */ | ||
317 | #endif | ||
318 | |||
319 | #if __GNUC_PREREQ (2,7) || __glibc_has_attribute (__unused__) | ||
320 | # define __attribute_maybe_unused__ __attribute__ ((__unused__)) | ||
321 | #else | ||
322 | # define __attribute_maybe_unused__ /* Ignore */ | ||
323 | #endif | ||
324 | |||
325 | /* At some point during the gcc 3.1 development the `used' attribute | ||
326 | for functions was introduced. We don't want to use it unconditionally | ||
327 | (although this would be possible) since it generates warnings. */ | ||
328 | #if __GNUC_PREREQ (3,1) || __glibc_has_attribute (__used__) | ||
329 | # define __attribute_used__ __attribute__ ((__used__)) | ||
330 | # define __attribute_noinline__ __attribute__ ((__noinline__)) | ||
331 | #else | ||
332 | # define __attribute_used__ __attribute__ ((__unused__)) | ||
333 | # define __attribute_noinline__ /* Ignore */ | ||
334 | #endif | ||
335 | |||
336 | /* Since version 3.2, gcc allows marking deprecated functions. */ | ||
337 | #if __GNUC_PREREQ (3,2) || __glibc_has_attribute (__deprecated__) | ||
338 | # define __attribute_deprecated__ __attribute__ ((__deprecated__)) | ||
339 | #else | ||
340 | # define __attribute_deprecated__ /* Ignore */ | ||
341 | #endif | ||
342 | |||
343 | /* Since version 4.5, gcc also allows one to specify the message printed | ||
344 | when a deprecated function is used. clang claims to be gcc 4.2, but | ||
345 | may also support this feature. */ | ||
346 | #if __GNUC_PREREQ (4,5) \ | ||
347 | || __glibc_has_extension (__attribute_deprecated_with_message__) | ||
348 | # define __attribute_deprecated_msg__(msg) \ | ||
349 | __attribute__ ((__deprecated__ (msg))) | ||
350 | #else | ||
351 | # define __attribute_deprecated_msg__(msg) __attribute_deprecated__ | ||
352 | #endif | ||
353 | |||
354 | /* At some point during the gcc 2.8 development the `format_arg' attribute | ||
355 | for functions was introduced. We don't want to use it unconditionally | ||
356 | (although this would be possible) since it generates warnings. | ||
357 | If several `format_arg' attributes are given for the same function, in | ||
358 | gcc-3.0 and older, all but the last one are ignored. In newer gccs, | ||
359 | all designated arguments are considered. */ | ||
360 | #if __GNUC_PREREQ (2,8) || __glibc_has_attribute (__format_arg__) | ||
361 | # define __attribute_format_arg__(x) __attribute__ ((__format_arg__ (x))) | ||
362 | #else | ||
363 | # define __attribute_format_arg__(x) /* Ignore */ | ||
364 | #endif | ||
365 | |||
366 | /* At some point during the gcc 2.97 development the `strfmon' format | ||
367 | attribute for functions was introduced. We don't want to use it | ||
368 | unconditionally (although this would be possible) since it | ||
369 | generates warnings. */ | ||
370 | #if __GNUC_PREREQ (2,97) || __glibc_has_attribute (__format__) | ||
371 | # define __attribute_format_strfmon__(a,b) \ | ||
372 | __attribute__ ((__format__ (__strfmon__, a, b))) | ||
373 | #else | ||
374 | # define __attribute_format_strfmon__(a,b) /* Ignore */ | ||
375 | #endif | ||
376 | |||
377 | /* The nonnull function attribute marks pointer parameters that | ||
378 | must not be NULL. This has the name __nonnull in glibc, | ||
379 | and __attribute_nonnull__ in files shared with Gnulib to avoid | ||
380 | collision with a different __nonnull in DragonFlyBSD 5.9. */ | ||
381 | #ifndef __attribute_nonnull__ | ||
382 | # if __GNUC_PREREQ (3,3) || __glibc_has_attribute (__nonnull__) | ||
383 | # define __attribute_nonnull__(params) __attribute__ ((__nonnull__ params)) | ||
384 | # else | ||
385 | # define __attribute_nonnull__(params) | ||
386 | # endif | ||
387 | #endif | ||
388 | #ifndef __nonnull | ||
389 | # define __nonnull(params) __attribute_nonnull__ (params) | ||
390 | #endif | ||
391 | |||
392 | /* The returns_nonnull function attribute marks the return type of the function | ||
393 | as always being non-null. */ | ||
394 | #ifndef __returns_nonnull | ||
395 | # if __GNUC_PREREQ (4, 9) || __glibc_has_attribute (__returns_nonnull__) | ||
396 | # define __returns_nonnull __attribute__ ((__returns_nonnull__)) | ||
397 | # else | ||
398 | # define __returns_nonnull | ||
399 | # endif | ||
400 | #endif | ||
401 | |||
402 | /* If fortification mode, we warn about unused results of certain | ||
403 | function calls which can lead to problems. */ | ||
404 | #if __GNUC_PREREQ (3,4) || __glibc_has_attribute (__warn_unused_result__) | ||
405 | # define __attribute_warn_unused_result__ \ | ||
406 | __attribute__ ((__warn_unused_result__)) | ||
407 | # if defined __USE_FORTIFY_LEVEL && __USE_FORTIFY_LEVEL > 0 | ||
408 | # define __wur __attribute_warn_unused_result__ | ||
409 | # endif | ||
410 | #else | ||
411 | # define __attribute_warn_unused_result__ /* empty */ | ||
412 | #endif | ||
413 | #ifndef __wur | ||
414 | # define __wur /* Ignore */ | ||
415 | #endif | ||
416 | |||
417 | /* Forces a function to be always inlined. */ | ||
418 | #if __GNUC_PREREQ (3,2) || __glibc_has_attribute (__always_inline__) | ||
419 | /* The Linux kernel defines __always_inline in stddef.h (283d7573), and | ||
420 | it conflicts with this definition. Therefore undefine it first to | ||
421 | allow either header to be included first. */ | ||
422 | # undef __always_inline | ||
423 | # define __always_inline __inline __attribute__ ((__always_inline__)) | ||
424 | #else | ||
425 | # undef __always_inline | ||
426 | # define __always_inline __inline | ||
427 | #endif | ||
428 | |||
429 | /* Associate error messages with the source location of the call site rather | ||
430 | than with the source location inside the function. */ | ||
431 | #if __GNUC_PREREQ (4,3) || __glibc_has_attribute (__artificial__) | ||
432 | # define __attribute_artificial__ __attribute__ ((__artificial__)) | ||
433 | #else | ||
434 | # define __attribute_artificial__ /* Ignore */ | ||
435 | #endif | ||
436 | |||
437 | /* GCC 4.3 and above with -std=c99 or -std=gnu99 implements ISO C99 | ||
438 | inline semantics, unless -fgnu89-inline is used. Using __GNUC_STDC_INLINE__ | ||
439 | or __GNUC_GNU_INLINE is not a good enough check for gcc because gcc versions | ||
440 | older than 4.3 may define these macros and still not guarantee GNU inlining | ||
441 | semantics. | ||
442 | |||
443 | clang++ identifies itself as gcc-4.2, but has support for GNU inlining | ||
444 | semantics, that can be checked for by using the __GNUC_STDC_INLINE_ and | ||
445 | __GNUC_GNU_INLINE__ macro definitions. */ | ||
446 | #if (!defined __cplusplus || __GNUC_PREREQ (4,3) \ | ||
447 | || (defined __clang__ && (defined __GNUC_STDC_INLINE__ \ | ||
448 | || defined __GNUC_GNU_INLINE__))) | ||
449 | # if defined __GNUC_STDC_INLINE__ || defined __cplusplus | ||
450 | # define __extern_inline extern __inline __attribute__ ((__gnu_inline__)) | ||
451 | # define __extern_always_inline \ | ||
452 | extern __always_inline __attribute__ ((__gnu_inline__)) | ||
453 | # else | ||
454 | # define __extern_inline extern __inline | ||
455 | # define __extern_always_inline extern __always_inline | ||
456 | # endif | ||
457 | #endif | ||
458 | |||
459 | #ifdef __extern_always_inline | ||
460 | # define __fortify_function __extern_always_inline __attribute_artificial__ | ||
461 | #endif | ||
462 | |||
463 | /* GCC 4.3 and above allow passing all anonymous arguments of an | ||
464 | __extern_always_inline function to some other vararg function. */ | ||
465 | #if __GNUC_PREREQ (4,3) | ||
466 | # define __va_arg_pack() __builtin_va_arg_pack () | ||
467 | # define __va_arg_pack_len() __builtin_va_arg_pack_len () | ||
468 | #endif | ||
469 | |||
470 | /* It is possible to compile containing GCC extensions even if GCC is | ||
471 | run in pedantic mode if the uses are carefully marked using the | ||
472 | `__extension__' keyword. But this is not generally available before | ||
473 | version 2.8. */ | ||
474 | #if !(__GNUC_PREREQ (2,8) || defined __clang__) | ||
475 | # define __extension__ /* Ignore */ | ||
476 | #endif | ||
477 | |||
478 | /* __restrict is known in EGCS 1.2 and above, and in clang. | ||
479 | It works also in C++ mode (outside of arrays), but only when spelled | ||
480 | as '__restrict', not 'restrict'. */ | ||
481 | #if !(__GNUC_PREREQ (2,92) || __clang_major__ >= 3) | ||
482 | # if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L | ||
483 | # define __restrict restrict | ||
484 | # else | ||
485 | # define __restrict /* Ignore */ | ||
486 | # endif | ||
487 | #endif | ||
488 | |||
489 | /* ISO C99 also allows to declare arrays as non-overlapping. The syntax is | ||
490 | array_name[restrict] | ||
491 | GCC 3.1 and clang support this. | ||
492 | This syntax is not usable in C++ mode. */ | ||
493 | #if (__GNUC_PREREQ (3,1) || __clang_major__ >= 3) && !defined __cplusplus | ||
494 | # define __restrict_arr __restrict | ||
495 | #else | ||
496 | # ifdef __GNUC__ | ||
497 | # define __restrict_arr /* Not supported in old GCC. */ | ||
498 | # else | ||
499 | # if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L | ||
500 | # define __restrict_arr restrict | ||
501 | # else | ||
502 | /* Some other non-C99 compiler. */ | ||
503 | # define __restrict_arr /* Not supported. */ | ||
504 | # endif | ||
505 | # endif | ||
506 | #endif | ||
507 | |||
508 | #if (__GNUC__ >= 3) || __glibc_has_builtin (__builtin_expect) | ||
509 | # define __glibc_unlikely(cond) __builtin_expect ((cond), 0) | ||
510 | # define __glibc_likely(cond) __builtin_expect ((cond), 1) | ||
511 | #else | ||
512 | # define __glibc_unlikely(cond) (cond) | ||
513 | # define __glibc_likely(cond) (cond) | ||
514 | #endif | ||
515 | |||
516 | #if (!defined _Noreturn \ | ||
517 | && (defined __STDC_VERSION__ ? __STDC_VERSION__ : 0) < 201112 \ | ||
518 | && !(__GNUC_PREREQ (4,7) \ | ||
519 | || (3 < __clang_major__ + (5 <= __clang_minor__)))) | ||
520 | # if __GNUC_PREREQ (2,8) | ||
521 | # define _Noreturn __attribute__ ((__noreturn__)) | ||
522 | # else | ||
523 | # define _Noreturn | ||
524 | # endif | ||
525 | #endif | ||
526 | |||
527 | #if __GNUC_PREREQ (8, 0) | ||
528 | /* Describes a char array whose address can safely be passed as the first | ||
529 | argument to strncpy and strncat, as the char array is not necessarily | ||
530 | a NUL-terminated string. */ | ||
531 | # define __attribute_nonstring__ __attribute__ ((__nonstring__)) | ||
532 | #else | ||
533 | # define __attribute_nonstring__ | ||
534 | #endif | ||
535 | |||
536 | /* Undefine (also defined in libc-symbols.h). */ | ||
537 | #undef __attribute_copy__ | ||
538 | #if __GNUC_PREREQ (9, 0) | ||
539 | /* Copies attributes from the declaration or type referenced by | ||
540 | the argument. */ | ||
541 | # define __attribute_copy__(arg) __attribute__ ((__copy__ (arg))) | ||
542 | #else | ||
543 | # define __attribute_copy__(arg) | ||
544 | #endif | ||
545 | |||
546 | #if (!defined _Static_assert && !defined __cplusplus \ | ||
547 | && (defined __STDC_VERSION__ ? __STDC_VERSION__ : 0) < 201112 \ | ||
548 | && (!(__GNUC_PREREQ (4, 6) || __clang_major__ >= 4) \ | ||
549 | || defined __STRICT_ANSI__)) | ||
550 | # define _Static_assert(expr, diagnostic) \ | ||
551 | extern int (*__Static_assert_function (void)) \ | ||
552 | [!!sizeof (struct { int __error_if_negative: (expr) ? 2 : -1; })] | ||
553 | #endif | ||
554 | |||
555 | /* Gnulib avoids including these, as they don't work on non-glibc or | ||
556 | older glibc platforms. */ | ||
557 | #ifndef __GNULIB_CDEFS | ||
558 | # include <bits/wordsize.h> | ||
559 | # include <bits/long-double.h> | ||
560 | #endif | ||
561 | |||
562 | #if __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1 | ||
563 | # ifdef __REDIRECT | ||
564 | |||
565 | /* Alias name defined automatically. */ | ||
566 | # define __LDBL_REDIR(name, proto) ... unused__ldbl_redir | ||
567 | # define __LDBL_REDIR_DECL(name) \ | ||
568 | extern __typeof (name) name __asm (__ASMNAME ("__" #name "ieee128")); | ||
569 | |||
570 | /* Alias name defined automatically, with leading underscores. */ | ||
571 | # define __LDBL_REDIR2_DECL(name) \ | ||
572 | extern __typeof (__##name) __##name \ | ||
573 | __asm (__ASMNAME ("__" #name "ieee128")); | ||
574 | |||
575 | /* Alias name defined manually. */ | ||
576 | # define __LDBL_REDIR1(name, proto, alias) ... unused__ldbl_redir1 | ||
577 | # define __LDBL_REDIR1_DECL(name, alias) \ | ||
578 | extern __typeof (name) name __asm (__ASMNAME (#alias)); | ||
579 | |||
580 | # define __LDBL_REDIR1_NTH(name, proto, alias) \ | ||
581 | __REDIRECT_NTH (name, proto, alias) | ||
582 | # define __REDIRECT_NTH_LDBL(name, proto, alias) \ | ||
583 | __LDBL_REDIR1_NTH (name, proto, __##alias##ieee128) | ||
584 | |||
585 | /* Unused. */ | ||
586 | # define __REDIRECT_LDBL(name, proto, alias) ... unused__redirect_ldbl | ||
587 | # define __LDBL_REDIR_NTH(name, proto) ... unused__ldbl_redir_nth | ||
588 | |||
589 | # else | ||
590 | _Static_assert (0, "IEEE 128-bits long double requires redirection on this platform"); | ||
591 | # endif | ||
592 | #elif defined __LONG_DOUBLE_MATH_OPTIONAL && defined __NO_LONG_DOUBLE_MATH | ||
593 | # define __LDBL_COMPAT 1 | ||
594 | # ifdef __REDIRECT | ||
595 | # define __LDBL_REDIR1(name, proto, alias) __REDIRECT (name, proto, alias) | ||
596 | # define __LDBL_REDIR(name, proto) \ | ||
597 | __LDBL_REDIR1 (name, proto, __nldbl_##name) | ||
598 | # define __LDBL_REDIR1_NTH(name, proto, alias) __REDIRECT_NTH (name, proto, alias) | ||
599 | # define __LDBL_REDIR_NTH(name, proto) \ | ||
600 | __LDBL_REDIR1_NTH (name, proto, __nldbl_##name) | ||
601 | # define __LDBL_REDIR2_DECL(name) \ | ||
602 | extern __typeof (__##name) __##name __asm (__ASMNAME ("__nldbl___" #name)); | ||
603 | # define __LDBL_REDIR1_DECL(name, alias) \ | ||
604 | extern __typeof (name) name __asm (__ASMNAME (#alias)); | ||
605 | # define __LDBL_REDIR_DECL(name) \ | ||
606 | extern __typeof (name) name __asm (__ASMNAME ("__nldbl_" #name)); | ||
607 | # define __REDIRECT_LDBL(name, proto, alias) \ | ||
608 | __LDBL_REDIR1 (name, proto, __nldbl_##alias) | ||
609 | # define __REDIRECT_NTH_LDBL(name, proto, alias) \ | ||
610 | __LDBL_REDIR1_NTH (name, proto, __nldbl_##alias) | ||
611 | # endif | ||
612 | #endif | ||
613 | #if (!defined __LDBL_COMPAT && __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 0) \ | ||
614 | || !defined __REDIRECT | ||
615 | # define __LDBL_REDIR1(name, proto, alias) name proto | ||
616 | # define __LDBL_REDIR(name, proto) name proto | ||
617 | # define __LDBL_REDIR1_NTH(name, proto, alias) name proto __THROW | ||
618 | # define __LDBL_REDIR_NTH(name, proto) name proto __THROW | ||
619 | # define __LDBL_REDIR2_DECL(name) | ||
620 | # define __LDBL_REDIR_DECL(name) | ||
621 | # ifdef __REDIRECT | ||
622 | # define __REDIRECT_LDBL(name, proto, alias) __REDIRECT (name, proto, alias) | ||
623 | # define __REDIRECT_NTH_LDBL(name, proto, alias) \ | ||
624 | __REDIRECT_NTH (name, proto, alias) | ||
625 | # endif | ||
626 | #endif | ||
627 | |||
628 | /* __glibc_macro_warning (MESSAGE) issues warning MESSAGE. This is | ||
629 | intended for use in preprocessor macros. | ||
630 | |||
631 | Note: MESSAGE must be a _single_ string; concatenation of string | ||
632 | literals is not supported. */ | ||
633 | #if __GNUC_PREREQ (4,8) || __glibc_clang_prereq (3,5) | ||
634 | # define __glibc_macro_warning1(message) _Pragma (#message) | ||
635 | # define __glibc_macro_warning(message) \ | ||
636 | __glibc_macro_warning1 (GCC warning message) | ||
637 | #else | ||
638 | # define __glibc_macro_warning(msg) | ||
639 | #endif | ||
640 | |||
641 | /* Generic selection (ISO C11) is a C-only feature, available in GCC | ||
642 | since version 4.9. Previous versions do not provide generic | ||
643 | selection, even though they might set __STDC_VERSION__ to 201112L, | ||
644 | when in -std=c11 mode. Thus, we must check for !defined __GNUC__ | ||
645 | when testing __STDC_VERSION__ for generic selection support. | ||
646 | On the other hand, Clang also defines __GNUC__, so a clang-specific | ||
647 | check is required to enable the use of generic selection. */ | ||
648 | #if !defined __cplusplus \ | ||
649 | && (__GNUC_PREREQ (4, 9) \ | ||
650 | || __glibc_has_extension (c_generic_selections) \ | ||
651 | || (!defined __GNUC__ && defined __STDC_VERSION__ \ | ||
652 | && __STDC_VERSION__ >= 201112L)) | ||
653 | # define __HAVE_GENERIC_SELECTION 1 | ||
654 | #else | ||
655 | # define __HAVE_GENERIC_SELECTION 0 | ||
656 | #endif | ||
657 | |||
658 | #if __GNUC_PREREQ (10, 0) | ||
659 | /* Designates a 1-based positional argument ref-index of pointer type | ||
660 | that can be used to access size-index elements of the pointed-to | ||
661 | array according to access mode, or at least one element when | ||
662 | size-index is not provided: | ||
663 | access (access-mode, <ref-index> [, <size-index>]) */ | ||
664 | # define __attr_access(x) __attribute__ ((__access__ x)) | ||
665 | /* For _FORTIFY_SOURCE == 3 we use __builtin_dynamic_object_size, which may | ||
666 | use the access attribute to get object sizes from function definition | ||
667 | arguments, so we can't use them on functions we fortify. Drop the object | ||
668 | size hints for such functions. */ | ||
669 | # if __USE_FORTIFY_LEVEL == 3 | ||
670 | # define __fortified_attr_access(a, o, s) __attribute__ ((__access__ (a, o))) | ||
671 | # else | ||
672 | # define __fortified_attr_access(a, o, s) __attr_access ((a, o, s)) | ||
673 | # endif | ||
674 | # if __GNUC_PREREQ (11, 0) | ||
675 | # define __attr_access_none(argno) __attribute__ ((__access__ (__none__, argno))) | ||
676 | # else | ||
677 | # define __attr_access_none(argno) | ||
678 | # endif | ||
679 | #else | ||
680 | # define __fortified_attr_access(a, o, s) | ||
681 | # define __attr_access(x) | ||
682 | # define __attr_access_none(argno) | ||
683 | #endif | ||
684 | |||
685 | #if __GNUC_PREREQ (11, 0) | ||
686 | /* Designates dealloc as a function to call to deallocate objects | ||
687 | allocated by the declared function. */ | ||
688 | # define __attr_dealloc(dealloc, argno) \ | ||
689 | __attribute__ ((__malloc__ (dealloc, argno))) | ||
690 | # define __attr_dealloc_free __attr_dealloc (__builtin_free, 1) | ||
691 | #else | ||
692 | # define __attr_dealloc(dealloc, argno) | ||
693 | # define __attr_dealloc_free | ||
694 | #endif | ||
695 | |||
696 | /* Specify that a function such as setjmp or vfork may return | ||
697 | twice. */ | ||
698 | #if __GNUC_PREREQ (4, 1) | ||
699 | # define __attribute_returns_twice__ __attribute__ ((__returns_twice__)) | ||
700 | #else | ||
701 | # define __attribute_returns_twice__ /* Ignore. */ | ||
702 | #endif | ||
703 | |||
704 | #endif /* sys/cdefs.h */ | ||