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