X-Git-Url: http://git.liburcu.org/?p=urcu.git;a=blobdiff_plain;f=include%2Furcu%2Fcompiler.h;h=34eb564bb77795e9e77d21983240c3327b3401d1;hp=4806ee338a99706ae5bb9eedb503fdc54e00c661;hb=HEAD;hpb=ddec79fd4f75b5ae0c49ee25c843220cf060cb96;ds=sidebyside diff --git a/include/urcu/compiler.h b/include/urcu/compiler.h index 4806ee3..197656c 100644 --- a/include/urcu/compiler.h +++ b/include/urcu/compiler.h @@ -1,30 +1,30 @@ +// SPDX-FileCopyrightText: 2009 Mathieu Desnoyers +// +// SPDX-License-Identifier: LGPL-2.1-or-later + #ifndef _URCU_COMPILER_H #define _URCU_COMPILER_H /* - * compiler.h - * * Compiler definitions. - * - * Copyright (c) 2009 Mathieu Desnoyers - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. */ #include /* for offsetof */ +#if defined __cplusplus +# include /* for std::remove_cv */ +#endif + +#include + #define caa_likely(x) __builtin_expect(!!(x), 1) #define caa_unlikely(x) __builtin_expect(!!(x), 0) -#define cmm_barrier() __asm__ __volatile__ ("" : : : "memory") +#ifdef CONFIG_RCU_USE_ATOMIC_BUILTINS +# define cmm_barrier() __atomic_signal_fence(__ATOMIC_SEQ_CST) +#else +# define cmm_barrier() __asm__ __volatile__ ("" : : : "memory") +#endif /* * Instruct the compiler to perform only a single access to a variable @@ -70,6 +70,23 @@ (type *)((char *)__ptr - offsetof(type, member)); \ }) +/* + * caa_container_of_check_null - Get the address of an object containing a field. + * + * @ptr: pointer to the field. + * @type: type of the object. + * @member: name of the field within the object. + * + * Return the address of the object containing the field. Return NULL if + * @ptr is NULL. + */ +#define caa_container_of_check_null(ptr, type, member) \ + __extension__ \ + ({ \ + const __typeof__(((type *) NULL)->member) * __ptr = (ptr); \ + (__ptr) ? (type *)((char *)__ptr - offsetof(type, member)) : NULL; \ + }) + #define CAA_BUILD_BUG_ON_ZERO(cond) (sizeof(struct { int:-!!(cond); })) #define CAA_BUILD_BUG_ON(cond) ((void)CAA_BUILD_BUG_ON_ZERO(cond)) @@ -82,7 +99,7 @@ #define __rcu #ifdef __cplusplus -#define URCU_FORCE_CAST(type, arg) (reinterpret_cast(arg)) +#define URCU_FORCE_CAST(_type, arg) (reinterpret_cast::type>(arg)) #else #define URCU_FORCE_CAST(type, arg) ((type) (arg)) #endif @@ -108,10 +125,104 @@ #define CAA_ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) -#ifdef __GNUC__ +/* + * URCU_GCC_VERSION is used to blacklist specific GCC versions with known + * bugs, clang also defines these macros to an equivalent GCC version it + * claims to support, so exclude it. + */ +#if defined(__GNUC__) && !defined(__clang__) # define URCU_GCC_VERSION (__GNUC__ * 10000 \ + __GNUC_MINOR__ * 100 \ + __GNUC_PATCHLEVEL__) #endif +#ifdef __cplusplus +#define caa_unqual_scalar_typeof(x) \ + std::remove_cv::type>::type +#else +#define caa_scalar_type_to_expr(type) \ + unsigned type: (unsigned type)0, \ + signed type: (signed type)0 + +/* + * Use C11 _Generic to express unqualified type from expression. This removes + * volatile qualifier from expression type. + */ +#define caa_unqual_scalar_typeof(x) \ + __typeof__( \ + _Generic((x), \ + char: (char)0, \ + caa_scalar_type_to_expr(char), \ + caa_scalar_type_to_expr(short), \ + caa_scalar_type_to_expr(int), \ + caa_scalar_type_to_expr(long), \ + caa_scalar_type_to_expr(long long), \ + default: (x) \ + ) \ + ) +#endif + +/* + * Allow user to manually define CMM_SANITIZE_THREAD if their toolchain is not + * supported by this check. + */ +#ifndef CMM_SANITIZE_THREAD +# if defined(__GNUC__) && defined(__SANITIZE_THREAD__) +# define CMM_SANITIZE_THREAD +# elif defined(__clang__) && defined(__has_feature) +# if __has_feature(thread_sanitizer) +# define CMM_SANITIZE_THREAD +# endif +# endif +#endif /* !CMM_SANITIZE_THREAD */ + +/* + * Helper to add the volatile qualifier to a pointer. + */ +#if defined __cplusplus +template +volatile T cmm_cast_volatile(T t) +{ + return static_cast(t); +} +#else +# define cmm_cast_volatile(ptr) \ + __extension__ \ + ({ \ + (volatile __typeof__(ptr))(ptr); \ + }) +#endif + +/* + * Compile time assertion. + * - predicate: boolean expression to evaluate, + * - msg: string to print to the user on failure when `static_assert()` is + * supported, + * - c_identifier_msg: message to be included in the typedef to emulate a + * static assertion. This parameter must be a valid C identifier as it will + * be used as a typedef name. + */ +#ifdef __cplusplus +#define urcu_static_assert(predicate, msg, c_identifier_msg) \ + static_assert(predicate, msg) +#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) +#define urcu_static_assert(predicate, msg, c_identifier_msg) \ + _Static_assert(predicate, msg) +#else +/* + * Evaluates the predicate and emit a compilation error on failure. + * + * If the predicate evaluates to true, this macro emits a function + * prototype with an argument type which is an array of size 0. + * + * If the predicate evaluates to false, this macro emits a function + * prototype with an argument type which is an array of negative size + * which is invalid in C and forces a compiler error. The + * c_identifier_msg parameter is used as the argument identifier so it + * is printed to the user when the error is reported. + */ +#define urcu_static_assert(predicate, msg, c_identifier_msg) \ + void urcu_static_assert_proto(char c_identifier_msg[2*!!(predicate)-1]) +#endif + #endif /* _URCU_COMPILER_H */