diff options
-rw-r--r-- | gdb/ChangeLog | 29 | ||||
-rw-r--r-- | gdb/common/common-utils.c | 7 | ||||
-rw-r--r-- | gdb/common/common-utils.h | 14 | ||||
-rw-r--r-- | gdb/common/poison.h | 132 |
4 files changed, 174 insertions, 8 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 3696c5c42b8..1030729e4d5 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,5 +1,34 @@ 2017-11-24 Simon Marchi <simon.marchi@polymtl.ca> + * common/common-utils.h: Include poison.h. + (xfree): Remove declaration, add definition with static_assert. + * common/common-utils.c (xfree): Remove. + * common/poison.h (IsMallocatable): Define. + (IsFreeable): Define. + (free): Delete for non-freeable types. + (xnew): New. + (XNEW): Undef and redefine. + (xcnew): New. + (XCNEW): Undef and redefine. + (xdelete): New. + (XDELETE): Undef and redefine. + (xnewvec): New. + (XNEWVEC): Undef and redefine. + (xcnewvec): New. + (XCNEWVEC): Undef and redefine. + (xresizevec): New. + (XRESIZEVEC): Undef and redefine. + (xdeletevec): New. + (XDELETEVEC): Undef and redefine. + (xnewvar): New. + (XNEWVAR): Undef and redefine. + (xcnewvar): New. + (XCNEWVAR): Undef and redefine. + (xresizevar): New. + (XRESIZEVAR): Undef and redefine. + +2017-11-24 Simon Marchi <simon.marchi@polymtl.ca> + * gdbthread.h (private_thread_info): Define structure type, add virtual pure destructor. (thread_info) <priv>: Change type to unique_ptr. diff --git a/gdb/common/common-utils.c b/gdb/common/common-utils.c index 71393027f7d..66d61615a9d 100644 --- a/gdb/common/common-utils.c +++ b/gdb/common/common-utils.c @@ -95,13 +95,6 @@ xzalloc (size_t size) } void -xfree (void *ptr) -{ - if (ptr != NULL) - free (ptr); /* ARI: free */ -} - -void xmalloc_failed (size_t size) { malloc_failure (size); diff --git a/gdb/common/common-utils.h b/gdb/common/common-utils.h index 4926a327192..feb4790afc8 100644 --- a/gdb/common/common-utils.h +++ b/gdb/common/common-utils.h @@ -23,6 +23,8 @@ #include <string> #include <vector> +#include "poison.h" + /* If possible, define FUNCTION_NAME, a macro containing the name of the function being defined. Since this macro may not always be defined, all uses must be protected by appropriate macro definition @@ -47,7 +49,17 @@ /* Like xmalloc, but zero the memory. */ void *xzalloc (size_t); -void xfree (void *); +template <typename T> +static void +xfree (T *ptr) +{ + static_assert (IsFreeable<T>::value, "Trying to use xfree with a non-POD \ +data type. Use operator delete instead."); + + if (ptr != NULL) + free (ptr); /* ARI: free */ +} + /* Like asprintf and vasprintf, but return the string, throw an error if no memory. */ diff --git a/gdb/common/poison.h b/gdb/common/poison.h index 37dd35e4b16..1647c9cb6fe 100644 --- a/gdb/common/poison.h +++ b/gdb/common/poison.h @@ -84,4 +84,136 @@ void *memmove (D *dest, const S *src, size_t n) = delete; #endif /* HAVE_IS_TRIVIALLY_COPYABLE */ +/* Poison XNEW and friends to catch usages of malloc-style allocations on + objects that require new/delete. */ + +template<typename T> +using IsMallocable = std::is_pod<T>; + +template<typename T> +using IsFreeable = gdb::Or<std::is_trivially_destructible<T>, std::is_void<T>>; + +template <typename T, typename = gdb::Requires<gdb::Not<IsFreeable<T>>>> +void free (T *ptr) = delete; + +template<typename T> +static T * +xnew () +{ + static_assert (IsMallocable<T>::value, "Trying to use XNEW with a non-POD \ +data type. Use operator new instead."); + return XNEW (T); +} + +#undef XNEW +#define XNEW(T) xnew<T>() + +template<typename T> +static T * +xcnew () +{ + static_assert (IsMallocable<T>::value, "Trying to use XCNEW with a non-POD \ +data type. Use operator new instead."); + return XCNEW (T); +} + +#undef XCNEW +#define XCNEW(T) xcnew<T>() + +template<typename T> +static void +xdelete (T *p) +{ + static_assert (IsFreeable<T>::value, "Trying to use XDELETE with a non-POD \ +data type. Use operator delete instead."); + XDELETE (p); +} + +#undef XDELETE +#define XDELETE(P) xdelete (p) + +template<typename T> +static T * +xnewvec (size_t n) +{ + static_assert (IsMallocable<T>::value, "Trying to use XNEWVEC with a \ +non-POD data type. Use operator new[] (or std::vector) instead."); + return XNEWVEC (T, n); +} + +#undef XNEWVEC +#define XNEWVEC(T, N) xnewvec<T> (N) + +template<typename T> +static T * +xcnewvec (size_t n) +{ + static_assert (IsMallocable<T>::value, "Trying to use XCNEWVEC with a \ +non-POD data type. Use operator new[] (or std::vector) instead."); + return XCNEWVEC (T, n); +} + +#undef XCNEWVEC +#define XCNEWVEC(T, N) xcnewvec<T> (N) + +template<typename T> +static T * +xresizevec (T *p, size_t n) +{ + static_assert (IsMallocable<T>::value, "Trying to use XRESIZEVEC with a \ +non-POD data type."); + return XRESIZEVEC (T, p, n); +} + +#undef XRESIZEVEC +#define XRESIZEVEC(T, P, N) xresizevec<T> (P, N) + +template<typename T> +static void +xdeletevec (T *p) +{ + static_assert (IsFreeable<T>::value, "Trying to use XDELETEVEC with a \ +non-POD data type. Use operator delete[] (or std::vector) instead."); + XDELETEVEC (p); +} + +#undef XDELETEVEC +#define XDELETEVEC(P) xdeletevec (P) + +template<typename T> +static T * +xnewvar (size_t s) +{ + static_assert (IsMallocable<T>::value, "Trying to use XNEWVAR with a \ +non-POD data type."); + return XNEWVAR (T, s);; +} + +#undef XNEWVAR +#define XNEWVAR(T, S) xnewvar<T> (S) + +template<typename T> +static T * +xcnewvar (size_t s) +{ + static_assert (IsMallocable<T>::value, "Trying to use XCNEWVAR with a \ +non-POD data type."); + return XCNEWVAR (T, s); +} + +#undef XCNEWVAR +#define XCNEWVAR(T, S) xcnewvar<T> (S) + +template<typename T> +static T * +xresizevar (T *p, size_t s) +{ + static_assert (IsMallocable<T>::value, "Trying to use XRESIZEVAR with a \ +non-POD data type."); + return XRESIZEVAR (T, p, s); +} + +#undef XRESIZEVAR +#define XRESIZEVAR(T, P, S) xresizevar<T> (P, S) + #endif /* COMMON_POISON_H */ |