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 #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 #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 #define __in_section_unique(seg) ___in_section(seg, __FILE__, __COUNTER__) 190 191 #define __in_section_unique_named(seg, name) \ 192 ___in_section(seg, __FILE__, name) 193 194 /* When using XIP, using '__ramfunc' places a function into RAM instead 195 * of FLASH. Make sure '__ramfunc' is defined only when 196 * CONFIG_ARCH_HAS_RAMFUNC_SUPPORT is defined, so that the compiler can 197 * report an error if '__ramfunc' is used but the architecture does not 198 * support it. 199 */ 200 #if !defined(CONFIG_XIP) 201 #define __ramfunc 202 #elif defined(CONFIG_ARCH_HAS_RAMFUNC_SUPPORT) 203 #if defined(CONFIG_ARM) 204 #define __ramfunc __attribute__((noinline)) \ 205 __attribute__((long_call, section(".ramfunc"))) 206 #else 207 #define __ramfunc __attribute__((noinline)) \ 208 __attribute__((section(".ramfunc"))) 209 #endif 210 #endif /* !CONFIG_XIP */ 211 212 #ifndef __fallthrough 213 #if __GNUC__ >= 7 214 #define __fallthrough __attribute__((fallthrough)) 215 #else 216 #define __fallthrough 217 #endif /* __GNUC__ >= 7 */ 218 #endif 219 220 #ifndef __packed 221 #define __packed __attribute__((__packed__)) 222 #endif 223 224 #ifndef __aligned 225 #define __aligned(x) __attribute__((__aligned__(x))) 226 #endif 227 228 #define __may_alias __attribute__((__may_alias__)) 229 230 #ifndef __printf_like 231 #ifdef CONFIG_ENFORCE_ZEPHYR_STDINT 232 #define __printf_like(f, a) __attribute__((format (printf, f, a))) 233 #else 234 /* 235 * The Zephyr stdint convention enforces int32_t = int, int64_t = long long, 236 * and intptr_t = long so that short string format length modifiers can be 237 * used universally across ILP32 and LP64 architectures. Without that it 238 * is possible for ILP32 toolchains to have int32_t = long and intptr_t = int 239 * clashing with the Zephyr convention and generating pointless warnings 240 * as they're still the same size. Inhibit the format argument type 241 * validation in that case and let the other configs do it. 242 */ 243 #define __printf_like(f, a) 244 #endif 245 #endif 246 247 #define __used __attribute__((__used__)) 248 #define __unused __attribute__((__unused__)) 249 #define __maybe_unused __attribute__((__unused__)) 250 251 #ifndef __deprecated 252 #define __deprecated __attribute__((deprecated)) 253 #endif 254 255 #ifndef __attribute_const__ 256 #define __attribute_const__ __attribute__((__const__)) 257 #endif 258 259 #ifndef __must_check 260 #define __must_check __attribute__((warn_unused_result)) 261 #endif 262 263 #define ARG_UNUSED(x) (void)(x) 264 265 #define likely(x) (__builtin_expect((bool)!!(x), true) != 0L) 266 #define unlikely(x) (__builtin_expect((bool)!!(x), false) != 0L) 267 #define POPCOUNT(x) __builtin_popcount(x) 268 269 #ifndef __no_optimization 270 #define __no_optimization __attribute__((optimize("-O0"))) 271 #endif 272 273 #ifndef __weak 274 #define __weak __attribute__((__weak__)) 275 #endif 276 277 #ifndef __attribute_nonnull 278 #define __attribute_nonnull(...) __attribute__((nonnull(__VA_ARGS__))) 279 #endif 280 281 /* Builtins with availability that depend on the compiler version. */ 282 #if __GNUC__ >= 5 283 #define HAS_BUILTIN___builtin_add_overflow 1 284 #define HAS_BUILTIN___builtin_sub_overflow 1 285 #define HAS_BUILTIN___builtin_mul_overflow 1 286 #define HAS_BUILTIN___builtin_div_overflow 1 287 #endif 288 #if __GNUC__ >= 4 289 #define HAS_BUILTIN___builtin_clz 1 290 #define HAS_BUILTIN___builtin_clzl 1 291 #define HAS_BUILTIN___builtin_clzll 1 292 #define HAS_BUILTIN___builtin_ctz 1 293 #define HAS_BUILTIN___builtin_ctzl 1 294 #define HAS_BUILTIN___builtin_ctzll 1 295 #endif 296 297 /* 298 * Be *very* careful with these. You cannot filter out __DEPRECATED_MACRO with 299 * -wno-deprecated, which has implications for -Werror. 300 */ 301 302 /* 303 * Expands to nothing and generates a warning. Used like 304 * 305 * #define FOO __WARN("Please use BAR instead") ... 306 * 307 * The warning points to the location where the macro is expanded. 308 */ 309 #define __WARN(msg) __WARN1(GCC warning msg) 310 #define __WARN1(s) _Pragma(#s) 311 312 /* Generic message */ 313 #ifndef __DEPRECATED_MACRO 314 #define __DEPRECATED_MACRO __WARN("Macro is deprecated") 315 #endif 316 317 /* These macros allow having ARM asm functions callable from thumb */ 318 319 #if defined(_ASMLANGUAGE) 320 321 #if defined(CONFIG_ARM) 322 323 #if defined(CONFIG_ASSEMBLER_ISA_THUMB2) 324 325 #define FUNC_CODE() .thumb; 326 #define FUNC_INSTR(a) 327 328 #else 329 330 #define FUNC_CODE() .code 32; 331 #define FUNC_INSTR(a) 332 333 #endif /* CONFIG_ASSEMBLER_ISA_THUMB2 */ 334 335 #else 336 337 #define FUNC_CODE() 338 #define FUNC_INSTR(a) 339 340 #endif /* CONFIG_ARM */ 341 342 #endif /* _ASMLANGUAGE */ 343 344 /* 345 * These macros are used to declare assembly language symbols that need 346 * to be typed properly(func or data) to be visible to the OMF tool. 347 * So that the build tool could mark them as an entry point to be linked 348 * correctly. This is an elfism. Use #if 0 for a.out. 349 */ 350 351 #if defined(_ASMLANGUAGE) 352 353 #if defined(CONFIG_ARM) || defined(CONFIG_NIOS2) || defined(CONFIG_RISCV) \ 354 || defined(CONFIG_XTENSA) || defined(CONFIG_ARM64) \ 355 || defined(CONFIG_MIPS) 356 #define GTEXT(sym) .global sym; .type sym, %function 357 #define GDATA(sym) .global sym; .type sym, %object 358 #define WTEXT(sym) .weak sym; .type sym, %function 359 #define WDATA(sym) .weak sym; .type sym, %object 360 #elif defined(CONFIG_ARC) 361 /* 362 * Need to use assembly macros because ';' is interpreted as the start of 363 * a single line comment in the ARC assembler. 364 */ 365 366 .macro glbl_text symbol 367 .globl \symbol 368 .type \symbol, %function 369 .endm 370 371 .macro glbl_data symbol 372 .globl \symbol 373 .type \symbol, %object 374 .endm 375 376 .macro weak_data symbol 377 .weak \symbol 378 .type \symbol, %object 379 .endm 380 381 #define GTEXT(sym) glbl_text sym 382 #define GDATA(sym) glbl_data sym 383 #define WDATA(sym) weak_data sym 384 385 #else /* !CONFIG_ARM && !CONFIG_ARC */ 386 #define GTEXT(sym) .globl sym; .type sym, @function 387 #define GDATA(sym) .globl sym; .type sym, @object 388 #endif 389 390 /* 391 * These macros specify the section in which a given function or variable 392 * resides. 393 * 394 * - SECTION_FUNC allows only one function to reside in a sub-section 395 * - SECTION_SUBSEC_FUNC allows multiple functions to reside in a sub-section 396 * This ensures that garbage collection only discards the section 397 * if all functions in the sub-section are not referenced. 398 */ 399 400 #if defined(CONFIG_ARC) 401 /* 402 * Need to use assembly macros because ';' is interpreted as the start of 403 * a single line comment in the ARC assembler. 404 * 405 * Also, '\()' is needed in the .section directive of these macros for 406 * correct substitution of the 'section' variable. 407 */ 408 409 .macro section_var section, symbol 410 .section .\section\().\symbol 411 \symbol : 412 .endm 413 414 .macro section_func section, symbol 415 .section .\section\().\symbol, "ax" 416 FUNC_CODE() 417 PERFOPT_ALIGN 418 \symbol : 419 FUNC_INSTR(\symbol) 420 .endm 421 422 .macro section_subsec_func section, subsection, symbol 423 .section .\section\().\subsection, "ax" 424 PERFOPT_ALIGN 425 \symbol : 426 .endm 427 428 #define SECTION_VAR(sect, sym) section_var sect, sym 429 #define SECTION_FUNC(sect, sym) section_func sect, sym 430 #define SECTION_SUBSEC_FUNC(sect, subsec, sym) \ 431 section_subsec_func sect, subsec, sym 432 #else /* !CONFIG_ARC */ 433 434 #define SECTION_VAR(sect, sym) .section .sect.sym; sym: 435 #define SECTION_FUNC(sect, sym) \ 436 .section .sect.sym, "ax"; \ 437 FUNC_CODE() \ 438 PERFOPT_ALIGN; sym : \ 439 FUNC_INSTR(sym) 440 #define SECTION_SUBSEC_FUNC(sect, subsec, sym) \ 441 .section .sect.subsec, "ax"; PERFOPT_ALIGN; sym : 442 443 #endif /* CONFIG_ARC */ 444 445 #endif /* _ASMLANGUAGE */ 446 447 #if defined(_ASMLANGUAGE) 448 #if defined(CONFIG_ARM) 449 #if defined(CONFIG_ASSEMBLER_ISA_THUMB2) 450 /* '.syntax unified' is a gcc-ism used in thumb-2 asm files */ 451 #define _ASM_FILE_PROLOGUE .text; .syntax unified; .thumb 452 #else 453 #define _ASM_FILE_PROLOGUE .text; .code 32 454 #endif /* CONFIG_ASSEMBLER_ISA_THUMB2 */ 455 #elif defined(CONFIG_ARM64) 456 #define _ASM_FILE_PROLOGUE .text 457 #endif /* CONFIG_ARM64 || CONFIG_ARM */ 458 #endif /* _ASMLANGUAGE */ 459 460 /* 461 * These macros generate absolute symbols for GCC 462 */ 463 464 /* create an extern reference to the absolute symbol */ 465 466 #define GEN_OFFSET_EXTERN(name) extern const char name[] 467 468 #define GEN_ABS_SYM_BEGIN(name) \ 469 EXTERN_C void name(void); \ 470 void name(void) \ 471 { 472 473 #define GEN_ABS_SYM_END } 474 475 /* 476 * Note that GEN_ABSOLUTE_SYM(), depending on the architecture 477 * and toolchain, may restrict the range of values permitted 478 * for assignment to the named symbol. 479 * 480 * For example, on x86, "value" is interpreted as signed 481 * 32-bit integer. Passing in an unsigned 32-bit integer 482 * with MSB set would result in a negative integer. 483 * Moreover, GCC would error out if an integer larger 484 * than 2^32-1 is passed as "value". 485 */ 486 487 /* 488 * GEN_ABSOLUTE_SYM_KCONFIG() is outputted by the build system 489 * to generate named symbol/value pairs for kconfigs. 490 */ 491 492 #if defined(CONFIG_ARM) 493 494 /* 495 * GNU/ARM backend does not have a proper operand modifier which does not 496 * produces prefix # followed by value, such as %0 for PowerPC, Intel, and 497 * MIPS. The workaround performed here is using %B0 which converts 498 * the value to ~(value). Thus "n"(~(value)) is set in operand constraint 499 * to output (value) in the ARM specific GEN_OFFSET macro. 500 */ 501 502 #define GEN_ABSOLUTE_SYM(name, value) \ 503 __asm__(".globl\t" #name "\n\t.equ\t" #name \ 504 ",%B0" \ 505 "\n\t.type\t" #name ",%%object" : : "n"(~(value))) 506 507 #define GEN_ABSOLUTE_SYM_KCONFIG(name, value) \ 508 __asm__(".globl\t" #name \ 509 "\n\t.equ\t" #name "," #value \ 510 "\n\t.type\t" #name ",%object") 511 512 #elif defined(CONFIG_X86) 513 514 #define GEN_ABSOLUTE_SYM(name, value) \ 515 __asm__(".globl\t" #name "\n\t.equ\t" #name \ 516 ",%c0" \ 517 "\n\t.type\t" #name ",@object" : : "n"(value)) 518 519 #define GEN_ABSOLUTE_SYM_KCONFIG(name, value) \ 520 __asm__(".globl\t" #name \ 521 "\n\t.equ\t" #name "," #value \ 522 "\n\t.type\t" #name ",@object") 523 524 #elif defined(CONFIG_ARC) || defined(CONFIG_ARM64) 525 526 #define GEN_ABSOLUTE_SYM(name, value) \ 527 __asm__(".globl\t" #name "\n\t.equ\t" #name \ 528 ",%c0" \ 529 "\n\t.type\t" #name ",@object" : : "n"(value)) 530 531 #define GEN_ABSOLUTE_SYM_KCONFIG(name, value) \ 532 __asm__(".globl\t" #name \ 533 "\n\t.equ\t" #name "," #value \ 534 "\n\t.type\t" #name ",@object") 535 536 #elif defined(CONFIG_NIOS2) || defined(CONFIG_RISCV) || \ 537 defined(CONFIG_XTENSA) || defined(CONFIG_MIPS) 538 539 /* No special prefixes necessary for constants in this arch AFAICT */ 540 #define GEN_ABSOLUTE_SYM(name, value) \ 541 __asm__(".globl\t" #name "\n\t.equ\t" #name \ 542 ",%0" \ 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_ARCH_POSIX) 551 #define GEN_ABSOLUTE_SYM(name, value) \ 552 __asm__(".globl\t" #name "\n\t.equ\t" #name \ 553 ",%c0" \ 554 "\n\t.type\t" #name ",@object" : : "n"(value)) 555 556 #define GEN_ABSOLUTE_SYM_KCONFIG(name, value) \ 557 __asm__(".globl\t" #name \ 558 "\n\t.equ\t" #name "," #value \ 559 "\n\t.type\t" #name ",@object") 560 561 #elif defined(CONFIG_SPARC) 562 #define GEN_ABSOLUTE_SYM(name, value) \ 563 __asm__(".global\t" #name "\n\t.equ\t" #name \ 564 ",%0" \ 565 "\n\t.type\t" #name ",#object" : : "n"(value)) 566 567 #define GEN_ABSOLUTE_SYM_KCONFIG(name, value) \ 568 __asm__(".globl\t" #name \ 569 "\n\t.equ\t" #name "," #value \ 570 "\n\t.type\t" #name ",#object") 571 572 #else 573 #error processor architecture not supported 574 #endif 575 576 #define compiler_barrier() do { \ 577 __asm__ __volatile__ ("" ::: "memory"); \ 578 } while (false) 579 580 /** @brief Return larger value of two provided expressions. 581 * 582 * Macro ensures that expressions are evaluated only once. 583 * 584 * @note Macro has limited usage compared to the standard macro as it cannot be 585 * used: 586 * - to generate constant integer, e.g. __aligned(Z_MAX(4,5)) 587 * - static variable, e.g. array like static uint8_t array[Z_MAX(...)]; 588 */ 589 #define Z_MAX(a, b) ({ \ 590 /* random suffix to avoid naming conflict */ \ 591 __typeof__(a) _value_a_ = (a); \ 592 __typeof__(b) _value_b_ = (b); \ 593 (_value_a_ > _value_b_) ? _value_a_ : _value_b_; \ 594 }) 595 596 /** @brief Return smaller value of two provided expressions. 597 * 598 * Macro ensures that expressions are evaluated only once. See @ref Z_MAX for 599 * macro limitations. 600 */ 601 #define Z_MIN(a, b) ({ \ 602 /* random suffix to avoid naming conflict */ \ 603 __typeof__(a) _value_a_ = (a); \ 604 __typeof__(b) _value_b_ = (b); \ 605 (_value_a_ < _value_b_) ? _value_a_ : _value_b_; \ 606 }) 607 608 /** @brief Return a value clamped to a given range. 609 * 610 * Macro ensures that expressions are evaluated only once. See @ref Z_MAX for 611 * macro limitations. 612 */ 613 #define Z_CLAMP(val, low, high) ({ \ 614 /* random suffix to avoid naming conflict */ \ 615 __typeof__(val) _value_val_ = (val); \ 616 __typeof__(low) _value_low_ = (low); \ 617 __typeof__(high) _value_high_ = (high); \ 618 (_value_val_ < _value_low_) ? _value_low_ : \ 619 (_value_val_ > _value_high_) ? _value_high_ : \ 620 _value_val_; \ 621 }) 622 623 /** 624 * @brief Calculate power of two ceiling for some nonzero value 625 * 626 * @param x Nonzero unsigned long value 627 * @return X rounded up to the next power of two 628 */ 629 #define Z_POW2_CEIL(x) \ 630 ((x) <= 2UL ? (x) : (1UL << (8 * sizeof(long) - __builtin_clzl((x) - 1)))) 631 632 /** 633 * @brief Check whether or not a value is a power of 2 634 * 635 * @param x The value to check 636 * @return true if x is a power of 2, false otherwise 637 */ 638 #define Z_IS_POW2(x) (((x) != 0) && (((x) & ((x)-1)) == 0)) 639 640 #if defined(CONFIG_ASAN) && defined(__clang__) 641 #define __noasan __attribute__((no_sanitize("address"))) 642 #else 643 #define __noasan /**/ 644 #endif 645 646 #if defined(CONFIG_UBSAN) 647 #define __noubsan __attribute__((no_sanitize("undefined"))) 648 #else 649 #define __noubsan 650 #endif 651 652 /** 653 * @brief Function attribute to disable stack protector. 654 * 655 * @note Only supported for GCC >= 11.0.0 or Clang >= 7. 656 */ 657 #if (TOOLCHAIN_GCC_VERSION >= 110000) || \ 658 (defined(TOOLCHAIN_CLANG_VERSION) && (TOOLCHAIN_CLANG_VERSION >= 70000)) 659 #define FUNC_NO_STACK_PROTECTOR __attribute__((no_stack_protector)) 660 #else 661 #define FUNC_NO_STACK_PROTECTOR 662 #endif 663 664 #define TOOLCHAIN_IGNORE_WSHADOW_BEGIN \ 665 _Pragma("GCC diagnostic push") \ 666 _Pragma("GCC diagnostic ignored \"-Wshadow\"") 667 668 #define TOOLCHAIN_IGNORE_WSHADOW_END \ 669 _Pragma("GCC diagnostic pop") 670 671 #endif /* !_LINKER */ 672 #endif /* ZEPHYR_INCLUDE_TOOLCHAIN_GCC_H_ */ 673
