X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fcommon%2Fmacros.hpp;h=a4ff6504d078807056330c4fd8f3e25b3a05f2ad;hb=f12e33ba4926d519a81baa388384fc54afde3985;hp=d2b78200e7ebab9e7e6faffd16749f2a88082bae;hpb=c9e313bc594f40a86eed237dce222c0fc99c957f;p=lttng-tools.git

diff --git a/src/common/macros.hpp b/src/common/macros.hpp
index d2b78200e..a4ff6504d 100644
--- a/src/common/macros.hpp
+++ b/src/common/macros.hpp
@@ -9,10 +9,13 @@
 #ifndef _MACROS_H
 #define _MACROS_H
 
-#include <stdlib.h>
+#include <common/compat/string.hpp>
+
 #include <stddef.h>
+#include <stdlib.h>
 #include <string.h>
-#include <common/compat/string.hpp>
+
+#include <type_traits>
 
 /*
  * Takes a pointer x and transform it so we can use it to access members
@@ -36,15 +39,190 @@
  */
 #define LTTNG_REF(x) ((typeof(*x) *)(x))
 
+#ifdef NDEBUG
+/*
+* Force usage of the assertion condition to prevent unused variable warnings
+* when `assert()` are disabled by the `NDEBUG` definition.
+*/
+# define LTTNG_ASSERT(_cond) ((void) sizeof((void) (_cond), 0))
+#else
+# include <assert.h>
+# define LTTNG_ASSERT(_cond) assert(_cond)
+#endif
+
 /*
  * Memory allocation zeroed
  */
+
 static inline
-void *zmalloc(size_t len)
+void *zmalloc_internal(size_t size)
 {
-	return calloc(1, len);
+	return calloc(1, size);
 }
 
+template <typename T>
+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
+	 * of malloc (and statically assert) and not to generate different
+	 * code based on this property, simply set value to true and allow
+	 * the code to compile. Anyone using a contemporary compiler will
+	 * catch the error.
+	 */
+#if __GNUG__ && __GNUC__ < 5
+	static constexpr bool value = true;
+#else
+	static constexpr bool value = std::is_trivially_constructible<T>::value;
+#endif
+};
+
+/*
+ * Malloc and zero-initialize an object of type T, asserting that T can be
+ * safely malloc-ed (is trivially constructible).
+ */
+template<typename T>
+T *zmalloc()
+{
+	static_assert (can_malloc<T>::value, "type can be malloc'ed");
+	return (T *) zmalloc_internal(sizeof(T));
+}
+
+/*
+ * Malloc and zero-initialize a buffer of size `size`, asserting that type T
+ * can be safely malloc-ed (is trivially constructible).
+ */
+template<typename T>
+T *zmalloc(size_t size)
+{
+	static_assert (can_malloc<T>::value, "type can be malloc'ed");
+	LTTNG_ASSERT(size >= sizeof(T));
+	return (T *) 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).
+ */
+template<typename T>
+T *calloc(size_t nmemb)
+{
+	static_assert (can_malloc<T>::value, "type can be malloc'ed");
+	return (T *) zmalloc_internal(nmemb * sizeof(T));
+}
+
+/*
+ * Malloc an object of type T, asserting that T can be safely malloc-ed (is
+ * trivially constructible).
+ */
+template<typename T>
+T *malloc()
+{
+	static_assert (can_malloc<T>::value, "type can be malloc'ed");
+	return (T *) malloc(sizeof(T));
+}
+
+/*
+ * Malloc a buffer of size `size`, asserting that type T can be safely
+ * malloc-ed (is trivially constructible).
+ */
+template<typename T>
+T *malloc(size_t size)
+{
+	static_assert (can_malloc<T>::value, "type can be malloc'ed");
+	return (T *) malloc(size);
+}
+
+/*
+ * Prevent using `free` on types that are non-POD.
+ *
+ * Declare a delete prototype of free if the parameter type is not safe to free
+ * (non-POD).
+ *
+ * If the parameter is a pointer to void, we can't check if what is pointed
+ * to is safe to free or not, as we don't know what is pointed to.  Ideally,
+ * all calls to free would be with a typed pointer, but there are too many
+ * instances of passing a pointer to void to enforce that right now.  So allow
+ * pointers to void, these will not be checked.
+ */
+
+template<typename T>
+struct can_free
+{
+	/*
+	 * gcc versions before 5.0 lack some type traits defined in C++11.
+	 * Since in this instance we use the trait to prevent misuses
+	 * of free (and statically assert) and not to generate different
+	 * code based on this property, simply set value to true and allow
+	 * the code to compile. Anyone using a contemporary compiler will
+	 * catch the error.
+	 */
+#if __GNUG__ && __GNUC__ < 5
+	static constexpr bool value = true;
+#else
+	static constexpr bool value = std::is_trivially_destructible<T>::value || std::is_void<T>::value;
+#endif
+};
+
+template<typename T, typename = typename std::enable_if<!can_free<T>::value>::type>
+void free(T *p) = delete;
+
+template<typename T>
+struct can_memset
+{
+	static constexpr bool value = std::is_pod<T>::value || std::is_void<T>::value;
+};
+
+template <typename T, typename = typename std::enable_if<!can_memset<T>::value>::type>
+void *memset(T *s, int c, size_t n) = delete;
+
+template<typename T>
+struct can_memcpy
+{
+	/*
+	 * gcc versions before 5.0 lack some type traits defined in C++11.
+	 * Since in this instance we use the trait to prevent misuses
+	 * of memcpy (and statically assert) and not to generate different
+	 * code based on this property, simply set value to true and allow
+	 * the code to compile. Anyone using a contemporary compiler will
+	 * catch the error.
+	 */
+#if __GNUG__ && __GNUC__ < 5
+	static constexpr bool value = true;
+#else
+	static constexpr bool value = std::is_trivially_copyable<T>::value;
+#endif
+};
+
+template <typename T, typename U,
+		typename = typename std::enable_if<!can_memcpy<T>::value>::type,
+		typename = typename std::enable_if<!can_memcpy<U>::value>::type>
+void *memcpy(T *d, const U *s, size_t n) = delete;
+
+template<typename T>
+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
+	 * of memmove (and statically assert) and not to generate different
+	 * code based on this property, simply set value to true and allow
+	 * the code to compile. Anyone using a contemporary compiler will
+	 * catch the error.
+	 */
+#if __GNUG__ && __GNUC__ < 5
+	static constexpr bool value = true;
+#else
+	static constexpr bool value = std::is_trivially_copyable<T>::value;
+#endif
+};
+
+template <typename T, typename U,
+		typename = typename std::enable_if<!can_memmove<T>::value>::type,
+		typename = typename std::enable_if<!can_memmove<U>::value>::type>
+void *memmove(T *d, const U *s, size_t n) = delete;
+
 #ifndef ARRAY_SIZE
 #define ARRAY_SIZE(array)   (sizeof(array) / (sizeof((array)[0])))
 #endif
@@ -130,15 +308,4 @@ int lttng_strncpy(char *dst, const char *src, size_t dst_len)
 	return 0;
 }
 
-#ifdef NDEBUG
-/*
-* Force usage of the assertion condition to prevent unused variable warnings
-* when `assert()` are disabled by the `NDEBUG` definition.
-*/
-# define LTTNG_ASSERT(_cond) ((void) sizeof((void) (_cond), 0))
-#else
-# include <assert.h>
-# define LTTNG_ASSERT(_cond) assert(_cond)
-#endif
-
 #endif /* _MACROS_H */