X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fcommon%2Fmacros.hpp;h=dab6e6df014b7ee1c6976e171423c187f7ff1c91;hb=31375c424ac115fc0373237207fed795849e26ba;hp=ecaaa4cda2edbb0c6fdc273bf67c858ebaa2f2f7;hpb=f1ca0880a86b9fc2af3d246adcacfaf4554b2ecb;p=lttng-tools.git diff --git a/src/common/macros.hpp b/src/common/macros.hpp index ecaaa4cda..dab6e6df0 100644 --- a/src/common/macros.hpp +++ b/src/common/macros.hpp @@ -39,7 +39,7 @@ * memory using malloc(), we must use generic accessors for compat in order to * *not* use a function to access members and not the variable name. */ -#define LTTNG_REF(x) ((typeof(*x) *)(x)) +#define LTTNG_REF(x) ((typeof(*(x)) *) (x)) #ifdef NDEBUG /* @@ -62,9 +62,8 @@ void *zmalloc_internal(size_t size) return calloc(1, size); } -template -struct can_malloc -{ +template +struct can_malloc { /* * gcc versions before 5.0 lack some type traits defined in C++11. * Since in this instance we use the trait to prevent misuses @@ -76,64 +75,69 @@ struct can_malloc #if __GNUG__ && __GNUC__ < 5 static constexpr bool value = true; #else - static constexpr bool value = std::is_trivially_constructible::value; + static constexpr bool value = std::is_trivially_constructible::value; #endif }; /* - * Malloc and zero-initialize an object of type T, asserting that T can be + * Malloc and zero-initialize an object of type T, asserting that MallocableType can be * safely malloc-ed (is trivially constructible). */ -template -T *zmalloc() +template +MallocableType *zmalloc() { - static_assert (can_malloc::value, "type can be malloc'ed"); - return (T *) zmalloc_internal(sizeof(T)); + static_assert(can_malloc::value, "type can be malloc'ed"); + return (MallocableType *) zmalloc_internal(sizeof(MallocableType)); /* NOLINT sizeof + potentially used on a + pointer. */ } /* - * Malloc and zero-initialize a buffer of size `size`, asserting that type T + * Malloc and zero-initialize a buffer of size `size`, asserting that type AllocatedType * can be safely malloc-ed (is trivially constructible). */ -template -T *zmalloc(size_t size) +template +AllocatedType *zmalloc(size_t size) { - static_assert (can_malloc::value, "type can be malloc'ed"); - LTTNG_ASSERT(size >= sizeof(T)); - return (T *) zmalloc_internal(size); + static_assert(can_malloc::value, "type can be malloc'ed"); + LTTNG_ASSERT(size >= sizeof(AllocatedType)); + return (AllocatedType *) zmalloc_internal(size); } /* - * Malloc and zero-initialize an array of `nmemb` elements of type T, - * asserting that T can be safely malloc-ed (is trivially constructible). + * Malloc and zero-initialize an array of `nmemb` elements of type AllocatedType, + * asserting that AllocatedType can be safely malloc-ed (is trivially constructible). */ -template -T *calloc(size_t nmemb) +template +AllocatedType *calloc(size_t nmemb) { - static_assert (can_malloc::value, "type can be malloc'ed"); - return (T *) zmalloc_internal(nmemb * sizeof(T)); + static_assert(can_malloc::value, "type can be malloc'ed"); + return (AllocatedType *) zmalloc_internal(nmemb * sizeof(AllocatedType)); /* NOLINT sizeof + potentially + used on a + pointer. */ } /* - * Malloc an object of type T, asserting that T can be safely malloc-ed (is + * Malloc an object of type AllocatedType, asserting that AllocatedType can be safely malloc-ed (is * trivially constructible). */ -template -T *malloc() +template +AllocatedType *malloc() { - static_assert (can_malloc::value, "type can be malloc'ed"); - return (T *) malloc(sizeof(T)); + static_assert(can_malloc::value, "type can be malloc'ed"); + return (AllocatedType *) malloc(sizeof(AllocatedType)); } /* - * Malloc a buffer of size `size`, asserting that type T can be safely + * Malloc a buffer of size `size`, asserting that AllocatedType can be safely * malloc-ed (is trivially constructible). */ -template -T *malloc(size_t size) +template +AllocatedType *malloc(size_t size) { - static_assert (can_malloc::value, "type can be malloc'ed"); - return (T *) malloc(size); + static_assert (can_malloc::value, "type can be malloc'ed"); + return (AllocatedType *) malloc(size); } /* @@ -149,7 +153,7 @@ T *malloc(size_t size) * pointers to void, these will not be checked. */ -template +template struct can_free { /* @@ -163,21 +167,23 @@ struct can_free #if __GNUG__ && __GNUC__ < 5 static constexpr bool value = true; #else - static constexpr bool value = std::is_trivially_destructible::value || std::is_void::value; + static constexpr bool value = std::is_trivially_destructible::value || + std::is_void::value; #endif }; -template::value>::type> -void free(T *p) = delete; +template ::value>::type> +void free(FreedType *p) = delete; -template -struct can_memset -{ - static constexpr bool value = std::is_pod::value || std::is_void::value; +template +struct can_memset { + static constexpr bool value = std::is_pod::value || + std::is_void::value; }; -template ::value>::type> -void *memset(T *s, int c, size_t n) = delete; +template ::value>::type> +void *memset(InitializedType *s, int c, size_t n) = delete; template struct can_memcpy @@ -197,14 +203,14 @@ struct can_memcpy #endif }; -template ::value>::type, - typename = typename std::enable_if::value>::type> -void *memcpy(T *d, const U *s, size_t n) = delete; +template ::value>::type, + typename = typename std::enable_if::value>::type> +void *memcpy(DestinationType *d, const SourceType *s, size_t n) = delete; -template -struct can_memmove -{ +template +struct can_memmove { /* * gcc versions before 5.0 lack some type traits defined in C++11. * Since in this instance we use the trait to prevent misuses @@ -216,27 +222,20 @@ struct can_memmove #if __GNUG__ && __GNUC__ < 5 static constexpr bool value = true; #else - static constexpr bool value = std::is_trivially_copyable::value; + static constexpr bool value = std::is_trivially_copyable::value; #endif }; -template ::value>::type, - typename = typename std::enable_if::value>::type> -void *memmove(T *d, const U *s, size_t n) = delete; +template ::value>::type, + typename = typename std::enable_if::value>::type> +void *memmove(DestinationType *d, const SourceType *s, size_t n) = delete; #ifndef ARRAY_SIZE #define ARRAY_SIZE(array) (sizeof(array) / (sizeof((array)[0]))) #endif -#ifndef container_of -#define container_of(ptr, type, member) \ - ({ \ - const typeof(((type *)NULL)->member) * __ptr = (ptr); \ - (type *)((char *)__ptr - offsetof(type, member)); \ - }) -#endif - #ifndef LTTNG_PACKED #define LTTNG_PACKED __attribute__((__packed__)) #endif @@ -251,7 +250,7 @@ void *memmove(T *d, const U *s, size_t n) = delete; #define member_sizeof(type, field) sizeof(((type *) 0)->field) -#define ASSERT_LOCKED(lock) LTTNG_ASSERT(pthread_mutex_trylock(&lock)) +#define ASSERT_LOCKED(lock) LTTNG_ASSERT(pthread_mutex_trylock(&(lock))) #define ASSERT_RCU_READ_LOCKED(lock) LTTNG_ASSERT(rcu_read_ongoing()) /* Attribute suitable to tag functions as having printf()-like arguments. */ @@ -284,9 +283,13 @@ void *memmove(T *d, const U *s, size_t n) = delete; _Pragma("GCC diagnostic ignored \"-Wformat-nonliteral\"") # define DIAGNOSTIC_IGNORE_LOGICAL_OP \ _Pragma("GCC diagnostic ignored \"-Wlogical-op\"") -# define DIAGNOSTIC_IGNORE_DUPLICATED_BRANCHES \ +#if __GNUG__ && __GNUC__ >= 7 +# define DIAGNOSTIC_IGNORE_DUPLICATED_BRANCHES \ _Pragma("GCC diagnostic ignored \"-Wduplicated-branches\"") -# define DIAGNOSTIC_IGNORE_INVALID_OFFSETOF \ +#else +# define DIAGNOSTIC_IGNORE_DUPLICATED_BRANCHES +#endif /* __GNUG__ && __GNUC__ >= 7 */ +# define DIAGNOSTIC_IGNORE_INVALID_OFFSETOF \ _Pragma("GCC diagnostic ignored \"-Winvalid-offsetof\"") #endif @@ -317,4 +320,18 @@ int lttng_strncpy(char *dst, const char *src, size_t dst_len) return 0; } +namespace lttng { +namespace utils { +template +ParentType *container_of(const MemberType *member, const MemberType ParentType::*ptr_to_member) +{ + const ParentType *dummy_parent = nullptr; + auto *offset_of_member = reinterpret_cast(&(dummy_parent->*ptr_to_member)); + auto address_of_parent = reinterpret_cast(member) - offset_of_member; + + return reinterpret_cast(address_of_parent); +} +} /* namespace utils */ +} /* namespace lttng */ + #endif /* _MACROS_H */