Line data Source code
1 1 : /*
2 : * Copyright (c) 2010-2014,2017 Wind River Systems, Inc.
3 : *
4 : * SPDX-License-Identifier: Apache-2.0
5 : */
6 :
7 : #ifndef ZEPHYR_INCLUDE_TOOLCHAIN_GCC_H_
8 : #define ZEPHYR_INCLUDE_TOOLCHAIN_GCC_H_
9 :
10 : #ifndef ZEPHYR_INCLUDE_TOOLCHAIN_H_
11 : #error Please do not include toolchain-specific headers directly, use <zephyr/toolchain.h> instead
12 : #endif
13 :
14 : /**
15 : * @file
16 : * @brief GCC toolchain abstraction
17 : *
18 : * Macros to abstract compiler capabilities for GCC toolchain.
19 : */
20 :
21 0 : #define TOOLCHAIN_GCC_VERSION \
22 : ((__GNUC__ * 10000) + (__GNUC_MINOR__ * 100) + __GNUC_PATCHLEVEL__)
23 :
24 : /* GCC supports #pragma diagnostics since 4.6.0 */
25 : #if !defined(TOOLCHAIN_HAS_PRAGMA_DIAG) && (TOOLCHAIN_GCC_VERSION >= 40600)
26 : #define TOOLCHAIN_HAS_PRAGMA_DIAG 1
27 : #endif
28 :
29 : #if !defined(TOOLCHAIN_HAS_C_GENERIC) && (TOOLCHAIN_GCC_VERSION >= 40900)
30 : #define TOOLCHAIN_HAS_C_GENERIC 1
31 : #endif
32 :
33 : #if !defined(TOOLCHAIN_HAS_C_AUTO_TYPE) && (TOOLCHAIN_GCC_VERSION >= 40900)
34 : #define TOOLCHAIN_HAS_C_AUTO_TYPE 1
35 : #endif
36 :
37 0 : #define TOOLCHAIN_HAS_ZLA 1
38 :
39 : /*
40 : * Older versions of GCC do not define __BYTE_ORDER__, so it must be manually
41 : * detected and defined using arch-specific definitions.
42 : */
43 :
44 : #ifndef _LINKER
45 :
46 : #ifndef __ORDER_BIG_ENDIAN__
47 : #define __ORDER_BIG_ENDIAN__ (1)
48 : #endif
49 :
50 : #ifndef __ORDER_LITTLE_ENDIAN__
51 : #define __ORDER_LITTLE_ENDIAN__ (2)
52 : #endif
53 :
54 : #ifndef __BYTE_ORDER__
55 : #if defined(__BIG_ENDIAN__) || defined(__ARMEB__) || \
56 : defined(__THUMBEB__) || defined(__AARCH64EB__) || \
57 : defined(__MIPSEB__) || defined(__TC32EB__)
58 :
59 : #define __BYTE_ORDER__ __ORDER_BIG_ENDIAN__
60 :
61 : #elif defined(__LITTLE_ENDIAN__) || defined(__ARMEL__) || \
62 : defined(__THUMBEL__) || defined(__AARCH64EL__) || \
63 : defined(__MIPSEL__) || defined(__TC32EL__)
64 :
65 : #define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__
66 :
67 : #else
68 : #error "__BYTE_ORDER__ is not defined and cannot be automatically resolved"
69 : #endif
70 : #endif
71 :
72 :
73 : #undef BUILD_ASSERT /* clear out common version */
74 : /* C++11 has static_assert built in */
75 : #if defined(__cplusplus) && (__cplusplus >= 201103L)
76 : #define BUILD_ASSERT(EXPR, MSG...) static_assert(EXPR, "" MSG)
77 :
78 : /*
79 : * GCC 4.6 and higher have the C11 _Static_assert built in and its
80 : * output is easier to understand than the common BUILD_ASSERT macros.
81 : * Don't use this in C++98 mode though (which we can hit, as
82 : * static_assert() is not available)
83 : */
84 : #elif !defined(__cplusplus) && \
85 : (((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6))) || \
86 : (__STDC_VERSION__) >= 201100)
87 : #define BUILD_ASSERT(EXPR, MSG...) _Static_assert((EXPR), "" MSG)
88 : #else
89 : #define BUILD_ASSERT(EXPR, MSG...)
90 : #endif
91 :
92 : #ifdef __cplusplus
93 : #define ZRESTRICT __restrict
94 : #else
95 : #define ZRESTRICT restrict
96 : #endif
97 :
98 : #include <zephyr/toolchain/common.h>
99 : #include <stdbool.h>
100 :
101 : #define ALIAS_OF(of) __attribute__((alias(#of)))
102 :
103 : #define FUNC_ALIAS(real_func, new_alias, return_type) \
104 : return_type new_alias() ALIAS_OF(real_func)
105 :
106 : #if defined(CONFIG_ARCH_POSIX) && !defined(_ASMLANGUAGE)
107 : #include <zephyr/arch/posix/posix_trace.h>
108 :
109 : /*let's not segfault if this were to happen for some reason*/
110 : #define CODE_UNREACHABLE \
111 : {\
112 : posix_print_error_and_exit("CODE_UNREACHABLE reached from %s:%d\n",\
113 : __FILE__, __LINE__);\
114 : __builtin_unreachable(); \
115 : }
116 : #else
117 : #define CODE_UNREACHABLE __builtin_unreachable()
118 : #endif
119 : #define FUNC_NORETURN __attribute__((__noreturn__))
120 :
121 : /* The GNU assembler for Cortex-M3 uses # for immediate values, not
122 : * comments, so the @nobits# trick does not work.
123 : */
124 : #if defined(CONFIG_ARM) || defined(CONFIG_ARM64)
125 : #define _NODATA_SECTION(segment) __attribute__((section(#segment)))
126 : #else
127 : #define _NODATA_SECTION(segment) \
128 : __attribute__((section(#segment ",\"wa\",@nobits#")))
129 : #endif
130 :
131 : /* Unaligned access */
132 : #define UNALIGNED_GET(g) \
133 : __extension__ ({ \
134 : struct __attribute__((__packed__)) { \
135 : __typeof__(*(g)) __v; \
136 : } *__g = (__typeof__(__g)) (g); \
137 : __g->__v; \
138 : })
139 :
140 :
141 : #if (__GNUC__ >= 7) && (defined(CONFIG_ARM) || defined(CONFIG_ARM64))
142 :
143 : /* Version of UNALIGNED_PUT() which issues a compiler_barrier() after
144 : * the store. It is required to workaround an apparent optimization
145 : * bug in GCC for ARM Cortex-M3 and higher targets, when multiple
146 : * byte, half-word and word stores (strb, strh, str instructions),
147 : * which support unaligned access, can be coalesced into store double
148 : * (strd) instruction, which doesn't support unaligned access (the
149 : * compilers in question do this optimization ignoring __packed__
150 : * attribute).
151 : */
152 : #define UNALIGNED_PUT(v, p) \
153 : do { \
154 : struct __attribute__((__packed__)) { \
155 : __typeof__(*p) __v; \
156 : } *__p = (__typeof__(__p)) (p); \
157 : __p->__v = (v); \
158 : compiler_barrier(); \
159 : } while (false)
160 :
161 : #else
162 :
163 : #define UNALIGNED_PUT(v, p) \
164 : do { \
165 : struct __attribute__((__packed__)) { \
166 : __typeof__(*p) __v; \
167 : } *__p = (__typeof__(__p)) (p); \
168 : __p->__v = (v); \
169 : } while (false)
170 :
171 : #endif
172 :
173 : /* Double indirection to ensure section names are expanded before
174 : * stringification
175 : */
176 : #define __GENERIC_SECTION(segment) __attribute__((section(STRINGIFY(segment))))
177 : #define Z_GENERIC_SECTION(segment) __GENERIC_SECTION(segment)
178 :
179 : #define __GENERIC_DOT_SECTION(segment) \
180 : __attribute__((section("." STRINGIFY(segment))))
181 : #define Z_GENERIC_DOT_SECTION(segment) __GENERIC_DOT_SECTION(segment)
182 :
183 : #define ___in_section(a, b, c) \
184 : __attribute__((section("." Z_STRINGIFY(a) \
185 : "." Z_STRINGIFY(b) \
186 : "." Z_STRINGIFY(c))))
187 : #define __in_section(a, b, c) ___in_section(a, b, c)
188 :
189 : #ifndef __in_section_unique
190 : #define __in_section_unique(seg) ___in_section(seg, __FILE__, __COUNTER__)
191 : #endif
192 :
193 : #ifndef __in_section_unique_named
194 : #define __in_section_unique_named(seg, name) \
195 : ___in_section(seg, __FILE__, name)
196 : #endif
197 :
198 : /* When using XIP, using '__ramfunc' places a function into RAM instead
199 : * of FLASH. Make sure '__ramfunc' is defined only when
200 : * CONFIG_ARCH_HAS_RAMFUNC_SUPPORT is defined, so that the compiler can
201 : * report an error if '__ramfunc' is used but the architecture does not
202 : * support it.
203 : */
204 : #if !defined(CONFIG_XIP)
205 : #define __ramfunc
206 : #elif defined(CONFIG_ARCH_HAS_RAMFUNC_SUPPORT)
207 : #if defined(CONFIG_ARM)
208 : #define __ramfunc __attribute__((noinline)) \
209 : __attribute__((long_call, section(".ramfunc")))
210 : #else
211 : #define __ramfunc __attribute__((noinline)) \
212 : __attribute__((section(".ramfunc")))
213 : #endif
214 : #endif /* !CONFIG_XIP */
215 :
216 : #ifndef __fallthrough
217 : #if __GNUC__ >= 7
218 : #define __fallthrough __attribute__((fallthrough))
219 : #else
220 : #define __fallthrough
221 : #endif /* __GNUC__ >= 7 */
222 : #endif
223 :
224 : #ifndef __packed
225 : #define __packed __attribute__((__packed__))
226 : #endif
227 :
228 : #ifndef __aligned
229 : #define __aligned(x) __attribute__((__aligned__(x)))
230 : #endif
231 :
232 : #ifndef __noinline
233 : #define __noinline __attribute__((noinline))
234 : #endif
235 :
236 : #define __may_alias __attribute__((__may_alias__))
237 :
238 : #ifndef __printf_like
239 : #ifdef CONFIG_ENFORCE_ZEPHYR_STDINT
240 : #define __printf_like(f, a) __attribute__((format (printf, f, a)))
241 : #else
242 : /*
243 : * The Zephyr stdint convention enforces int32_t = int, int64_t = long long,
244 : * and intptr_t = long so that short string format length modifiers can be
245 : * used universally across ILP32 and LP64 architectures. Without that it
246 : * is possible for ILP32 toolchains to have int32_t = long and intptr_t = int
247 : * clashing with the Zephyr convention and generating pointless warnings
248 : * as they're still the same size. Inhibit the format argument type
249 : * validation in that case and let the other configs do it.
250 : */
251 : #define __printf_like(f, a)
252 : #endif
253 : #endif
254 :
255 : #define __used __attribute__((__used__))
256 : #define __unused __attribute__((__unused__))
257 : #define __maybe_unused __attribute__((__unused__))
258 :
259 : #ifndef __deprecated
260 : #define __deprecated __attribute__((deprecated))
261 : /* When adding this, remember to follow the instructions in
262 : * https://docs.zephyrproject.org/latest/develop/api/api_lifecycle.html#deprecated
263 : */
264 : #endif
265 :
266 : #ifndef __attribute_const__
267 : #define __attribute_const__ __attribute__((__const__))
268 : #endif
269 :
270 : #ifndef __must_check
271 : #define __must_check __attribute__((warn_unused_result))
272 : #endif
273 :
274 : #define ARG_UNUSED(x) (void)(x)
275 :
276 : #define likely(x) (__builtin_expect((bool)!!(x), true) != 0L)
277 : #define unlikely(x) (__builtin_expect((bool)!!(x), false) != 0L)
278 : #define POPCOUNT(x) __builtin_popcount(x)
279 :
280 : #ifndef __no_optimization
281 : #define __no_optimization __attribute__((optimize("-O0")))
282 : #endif
283 :
284 : #ifndef __weak
285 : #define __weak __attribute__((__weak__))
286 : #endif
287 :
288 : #ifndef __attribute_nonnull
289 : #define __attribute_nonnull(...) __attribute__((nonnull(__VA_ARGS__)))
290 : #endif
291 :
292 : /* Builtins with availability that depend on the compiler version. */
293 : #if __GNUC__ >= 5
294 : #define HAS_BUILTIN___builtin_add_overflow 1
295 : #define HAS_BUILTIN___builtin_sub_overflow 1
296 : #define HAS_BUILTIN___builtin_mul_overflow 1
297 : #define HAS_BUILTIN___builtin_div_overflow 1
298 : #endif
299 : #if __GNUC__ >= 4
300 : #define HAS_BUILTIN___builtin_clz 1
301 : #define HAS_BUILTIN___builtin_clzl 1
302 : #define HAS_BUILTIN___builtin_clzll 1
303 : #define HAS_BUILTIN___builtin_ctz 1
304 : #define HAS_BUILTIN___builtin_ctzl 1
305 : #define HAS_BUILTIN___builtin_ctzll 1
306 : #endif
307 :
308 : /*
309 : * Be *very* careful with these. You cannot filter out __DEPRECATED_MACRO with
310 : * -wno-deprecated, which has implications for -Werror.
311 : */
312 :
313 : /*
314 : * Expands to nothing and generates a warning. Used like
315 : *
316 : * #define FOO __WARN("Please use BAR instead") ...
317 : *
318 : * The warning points to the location where the macro is expanded.
319 : */
320 : #define __WARN(msg) __WARN1(GCC warning msg)
321 : #define __WARN1(s) _Pragma(#s)
322 :
323 : /* Generic message */
324 : #ifndef __DEPRECATED_MACRO
325 : #define __DEPRECATED_MACRO __WARN("Macro is deprecated")
326 : /* When adding this, remember to follow the instructions in
327 : * https://docs.zephyrproject.org/latest/develop/api/api_lifecycle.html#deprecated
328 : */
329 : #endif
330 :
331 : /* These macros allow having ARM asm functions callable from thumb */
332 :
333 : #if defined(_ASMLANGUAGE)
334 :
335 : #if defined(CONFIG_ARM)
336 :
337 : #if defined(CONFIG_ASSEMBLER_ISA_THUMB2)
338 :
339 : #define FUNC_CODE() .thumb;
340 : #define FUNC_INSTR(a)
341 :
342 : #else
343 :
344 : #define FUNC_CODE() .code 32;
345 : #define FUNC_INSTR(a)
346 :
347 : #endif /* CONFIG_ASSEMBLER_ISA_THUMB2 */
348 :
349 : #else
350 :
351 : #define FUNC_CODE()
352 : #define FUNC_INSTR(a)
353 :
354 : #endif /* CONFIG_ARM */
355 :
356 : #endif /* _ASMLANGUAGE */
357 :
358 : /*
359 : * These macros are used to declare assembly language symbols that need
360 : * to be typed properly(func or data) to be visible to the OMF tool.
361 : * So that the build tool could mark them as an entry point to be linked
362 : * correctly. This is an elfism. Use #if 0 for a.out.
363 : */
364 :
365 : #if defined(_ASMLANGUAGE)
366 :
367 : #if defined(CONFIG_ARM) || defined(CONFIG_NIOS2) || defined(CONFIG_RISCV) \
368 : || defined(CONFIG_XTENSA) || defined(CONFIG_ARM64) \
369 : || defined(CONFIG_MIPS)
370 : #define GTEXT(sym) .global sym; .type sym, %function
371 : #define GDATA(sym) .global sym; .type sym, %object
372 : #define WTEXT(sym) .weak sym; .type sym, %function
373 : #define WDATA(sym) .weak sym; .type sym, %object
374 : #elif defined(CONFIG_ARC)
375 : /*
376 : * Need to use assembly macros because ';' is interpreted as the start of
377 : * a single line comment in the ARC assembler.
378 : */
379 :
380 : .macro glbl_text symbol
381 : .globl \symbol
382 : .type \symbol, %function
383 : .endm
384 :
385 : .macro glbl_data symbol
386 : .globl \symbol
387 : .type \symbol, %object
388 : .endm
389 :
390 : .macro weak_data symbol
391 : .weak \symbol
392 : .type \symbol, %object
393 : .endm
394 :
395 : #define GTEXT(sym) glbl_text sym
396 : #define GDATA(sym) glbl_data sym
397 : #define WDATA(sym) weak_data sym
398 :
399 : #else /* !CONFIG_ARM && !CONFIG_ARC */
400 : #define GTEXT(sym) .globl sym; .type sym, @function
401 : #define GDATA(sym) .globl sym; .type sym, @object
402 : #endif
403 :
404 : /*
405 : * These macros specify the section in which a given function or variable
406 : * resides.
407 : *
408 : * - SECTION_FUNC allows only one function to reside in a sub-section
409 : * - SECTION_SUBSEC_FUNC allows multiple functions to reside in a sub-section
410 : * This ensures that garbage collection only discards the section
411 : * if all functions in the sub-section are not referenced.
412 : */
413 :
414 : #if defined(CONFIG_ARC)
415 : /*
416 : * Need to use assembly macros because ';' is interpreted as the start of
417 : * a single line comment in the ARC assembler.
418 : *
419 : * Also, '\()' is needed in the .section directive of these macros for
420 : * correct substitution of the 'section' variable.
421 : */
422 :
423 : .macro section_var section, symbol
424 : .section .\section\().\symbol
425 : \symbol :
426 : .endm
427 :
428 : .macro section_func section, symbol
429 : .section .\section\().\symbol, "ax"
430 : FUNC_CODE()
431 : PERFOPT_ALIGN
432 : \symbol :
433 : FUNC_INSTR(\symbol)
434 : .endm
435 :
436 : .macro section_subsec_func section, subsection, symbol
437 : .section .\section\().\subsection, "ax"
438 : PERFOPT_ALIGN
439 : \symbol :
440 : .endm
441 :
442 : #define SECTION_VAR(sect, sym) section_var sect, sym
443 : #define SECTION_FUNC(sect, sym) section_func sect, sym
444 : #define SECTION_SUBSEC_FUNC(sect, subsec, sym) \
445 : section_subsec_func sect, subsec, sym
446 : #else /* !CONFIG_ARC */
447 :
448 : #define SECTION_VAR(sect, sym) .section .sect.sym; sym:
449 : #define SECTION_FUNC(sect, sym) \
450 : .section .sect.sym, "ax"; \
451 : FUNC_CODE() \
452 : PERFOPT_ALIGN; sym : \
453 : FUNC_INSTR(sym)
454 : #define SECTION_SUBSEC_FUNC(sect, subsec, sym) \
455 : .section .sect.subsec, "ax"; PERFOPT_ALIGN; sym :
456 :
457 : #endif /* CONFIG_ARC */
458 :
459 : #endif /* _ASMLANGUAGE */
460 :
461 : #if defined(_ASMLANGUAGE)
462 : #if defined(CONFIG_ARM)
463 : #if defined(CONFIG_ASSEMBLER_ISA_THUMB2)
464 : /* '.syntax unified' is a gcc-ism used in thumb-2 asm files */
465 : #define _ASM_FILE_PROLOGUE .text; .syntax unified; .thumb
466 : #else
467 : #define _ASM_FILE_PROLOGUE .text; .code 32
468 : #endif /* CONFIG_ASSEMBLER_ISA_THUMB2 */
469 : #elif defined(CONFIG_ARM64)
470 : #define _ASM_FILE_PROLOGUE .text
471 : #endif /* CONFIG_ARM64 || CONFIG_ARM */
472 : #endif /* _ASMLANGUAGE */
473 :
474 : /*
475 : * These macros generate absolute symbols for GCC
476 : */
477 :
478 : /* create an extern reference to the absolute symbol */
479 :
480 : #define GEN_OFFSET_EXTERN(name) extern const char name[]
481 :
482 : #define GEN_ABS_SYM_BEGIN(name) \
483 : EXTERN_C void name(void); \
484 : void name(void) \
485 : {
486 :
487 : #define GEN_ABS_SYM_END }
488 :
489 : /*
490 : * Note that GEN_ABSOLUTE_SYM(), depending on the architecture
491 : * and toolchain, may restrict the range of values permitted
492 : * for assignment to the named symbol.
493 : *
494 : * For example, on x86, "value" is interpreted as signed
495 : * 32-bit integer. Passing in an unsigned 32-bit integer
496 : * with MSB set would result in a negative integer.
497 : * Moreover, GCC would error out if an integer larger
498 : * than 2^32-1 is passed as "value".
499 : */
500 :
501 : /*
502 : * GEN_ABSOLUTE_SYM_KCONFIG() is outputted by the build system
503 : * to generate named symbol/value pairs for kconfigs.
504 : */
505 :
506 : #if defined(CONFIG_ARM)
507 :
508 : /*
509 : * GNU/ARM backend does not have a proper operand modifier which does not
510 : * produces prefix # followed by value, such as %0 for PowerPC, Intel, and
511 : * MIPS. The workaround performed here is using %B0 which converts
512 : * the value to ~(value). Thus "n"(~(value)) is set in operand constraint
513 : * to output (value) in the ARM specific GEN_OFFSET macro.
514 : */
515 :
516 : #define GEN_ABSOLUTE_SYM(name, value) \
517 : __asm__(".globl\t" #name "\n\t.equ\t" #name \
518 : ",%B0" \
519 : "\n\t.type\t" #name ",%%object" : : "n"(~(value)))
520 :
521 : #define GEN_ABSOLUTE_SYM_KCONFIG(name, value) \
522 : __asm__(".globl\t" #name \
523 : "\n\t.equ\t" #name "," #value \
524 : "\n\t.type\t" #name ",%object")
525 :
526 : #elif defined(CONFIG_X86)
527 :
528 : #define GEN_ABSOLUTE_SYM(name, value) \
529 : __asm__(".globl\t" #name "\n\t.equ\t" #name \
530 : ",%c0" \
531 : "\n\t.type\t" #name ",@object" : : "n"(value))
532 :
533 : #define GEN_ABSOLUTE_SYM_KCONFIG(name, value) \
534 : __asm__(".globl\t" #name \
535 : "\n\t.equ\t" #name "," #value \
536 : "\n\t.type\t" #name ",@object")
537 :
538 : #elif defined(CONFIG_ARC) || defined(CONFIG_ARM64)
539 :
540 : #define GEN_ABSOLUTE_SYM(name, value) \
541 : __asm__(".globl\t" #name "\n\t.equ\t" #name \
542 : ",%c0" \
543 : "\n\t.type\t" #name ",@object" : : "n"(value))
544 :
545 : #define GEN_ABSOLUTE_SYM_KCONFIG(name, value) \
546 : __asm__(".globl\t" #name \
547 : "\n\t.equ\t" #name "," #value \
548 : "\n\t.type\t" #name ",@object")
549 :
550 : #elif defined(CONFIG_NIOS2) || defined(CONFIG_RISCV) || \
551 : defined(CONFIG_XTENSA) || defined(CONFIG_MIPS)
552 :
553 : /* No special prefixes necessary for constants in this arch AFAICT */
554 : #define GEN_ABSOLUTE_SYM(name, value) \
555 : __asm__(".globl\t" #name "\n\t.equ\t" #name \
556 : ",%0" \
557 : "\n\t.type\t" #name ",%%object" : : "n"(value))
558 :
559 : #define GEN_ABSOLUTE_SYM_KCONFIG(name, value) \
560 : __asm__(".globl\t" #name \
561 : "\n\t.equ\t" #name "," #value \
562 : "\n\t.type\t" #name ",%object")
563 :
564 : #elif defined(CONFIG_ARCH_POSIX)
565 : #define GEN_ABSOLUTE_SYM(name, value) \
566 : __asm__(".globl\t" #name "\n\t.equ\t" #name \
567 : ",%c0" \
568 : "\n\t.type\t" #name ",@object" : : "n"(value))
569 :
570 : #define GEN_ABSOLUTE_SYM_KCONFIG(name, value) \
571 : __asm__(".globl\t" #name \
572 : "\n\t.equ\t" #name "," #value \
573 : "\n\t.type\t" #name ",@object")
574 :
575 : #elif defined(CONFIG_SPARC)
576 : #define GEN_ABSOLUTE_SYM(name, value) \
577 : __asm__(".global\t" #name "\n\t.equ\t" #name \
578 : ",%0" \
579 : "\n\t.type\t" #name ",#object" : : "n"(value))
580 :
581 : #define GEN_ABSOLUTE_SYM_KCONFIG(name, value) \
582 : __asm__(".globl\t" #name \
583 : "\n\t.equ\t" #name "," #value \
584 : "\n\t.type\t" #name ",#object")
585 :
586 : #else
587 : #error processor architecture not supported
588 : #endif
589 :
590 : #define compiler_barrier() do { \
591 : __asm__ __volatile__ ("" ::: "memory"); \
592 : } while (false)
593 :
594 : /** @brief Return larger value of two provided expressions.
595 : *
596 : * Macro ensures that expressions are evaluated only once.
597 : *
598 : * @note Macro has limited usage compared to the standard macro as it cannot be
599 : * used:
600 : * - to generate constant integer, e.g. __aligned(Z_MAX(4,5))
601 : * - static variable, e.g. array like static uint8_t array[Z_MAX(...)];
602 : */
603 : #define Z_MAX(a, b) ({ \
604 : /* random suffix to avoid naming conflict */ \
605 : __typeof__(a) _value_a_ = (a); \
606 : __typeof__(b) _value_b_ = (b); \
607 : (_value_a_ > _value_b_) ? _value_a_ : _value_b_; \
608 : })
609 :
610 : /** @brief Return smaller value of two provided expressions.
611 : *
612 : * Macro ensures that expressions are evaluated only once. See @ref Z_MAX for
613 : * macro limitations.
614 : */
615 : #define Z_MIN(a, b) ({ \
616 : /* random suffix to avoid naming conflict */ \
617 : __typeof__(a) _value_a_ = (a); \
618 : __typeof__(b) _value_b_ = (b); \
619 : (_value_a_ < _value_b_) ? _value_a_ : _value_b_; \
620 : })
621 :
622 : /** @brief Return a value clamped to a given range.
623 : *
624 : * Macro ensures that expressions are evaluated only once. See @ref Z_MAX for
625 : * macro limitations.
626 : */
627 : #define Z_CLAMP(val, low, high) ({ \
628 : /* random suffix to avoid naming conflict */ \
629 : __typeof__(val) _value_val_ = (val); \
630 : __typeof__(low) _value_low_ = (low); \
631 : __typeof__(high) _value_high_ = (high); \
632 : (_value_val_ < _value_low_) ? _value_low_ : \
633 : (_value_val_ > _value_high_) ? _value_high_ : \
634 : _value_val_; \
635 : })
636 :
637 : /**
638 : * @brief Calculate power of two ceiling for some nonzero value
639 : *
640 : * @param x Nonzero unsigned long value
641 : * @return X rounded up to the next power of two
642 : */
643 : #define Z_POW2_CEIL(x) \
644 : ((x) <= 2UL ? (x) : (1UL << (8 * sizeof(long) - __builtin_clzl((x) - 1))))
645 :
646 : /**
647 : * @brief Check whether or not a value is a power of 2
648 : *
649 : * @param x The value to check
650 : * @return true if x is a power of 2, false otherwise
651 : */
652 : #define Z_IS_POW2(x) (((x) != 0) && (((x) & ((x)-1)) == 0))
653 :
654 : #if defined(CONFIG_ASAN) && defined(__clang__)
655 : #define __noasan __attribute__((no_sanitize("address")))
656 : #else
657 : #define __noasan /**/
658 : #endif
659 :
660 : #if defined(CONFIG_UBSAN)
661 : #define __noubsan __attribute__((no_sanitize("undefined")))
662 : #else
663 : #define __noubsan
664 : #endif
665 :
666 : /**
667 : * @brief Function attribute to disable stack protector.
668 : *
669 : * @note Only supported for GCC >= 11.0.0 or Clang >= 7.
670 : */
671 : #if (TOOLCHAIN_GCC_VERSION >= 110000) || \
672 : (defined(TOOLCHAIN_CLANG_VERSION) && (TOOLCHAIN_CLANG_VERSION >= 70000))
673 : #define FUNC_NO_STACK_PROTECTOR __attribute__((no_stack_protector))
674 : #else
675 : #define FUNC_NO_STACK_PROTECTOR
676 : #endif
677 :
678 : #define TOOLCHAIN_IGNORE_WSHADOW_BEGIN \
679 : _Pragma("GCC diagnostic push") \
680 : _Pragma("GCC diagnostic ignored \"-Wshadow\"")
681 :
682 : #define TOOLCHAIN_IGNORE_WSHADOW_END \
683 : _Pragma("GCC diagnostic pop")
684 :
685 : #endif /* !_LINKER */
686 : #endif /* ZEPHYR_INCLUDE_TOOLCHAIN_GCC_H_ */
|
