From: Simon Marchi Date: Fri, 24 Nov 2017 15:42:01 +0000 (-0500) Subject: Poison XNEW and friends for types that should use new/delete X-Git-Tag: users/ARM/embedded-binutils-master-2017q4~65 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=8172f16b5b8bf3007d0aafcb38964a408f0e844f;p=external%2Fbinutils.git Poison XNEW and friends for types that should use new/delete This patch (finally!) makes it so that trying to use XNEW with a type that requires "new" will cause a compilation error. The criterion I initially used to allow a type to use XNEW (which calls malloc in the end) was std::is_trivially_constructible, but then realized that gcc 4.8 did not have it. Instead, I went with: using IsMallocatable = std::is_pod; which is just a bit more strict, which doesn't hurt. A similar thing is done for macros that free instead of allocated, the criterion is: using IsFreeable = gdb::Or, std::is_void>; Trying to use XNEW on a type that requires new will result in an error like this: In file included from /home/simark/src/binutils-gdb/gdb/common/common-utils.h:26:0, from /home/simark/src/binutils-gdb/gdb/common/common-defs.h:78, from /home/simark/src/binutils-gdb/gdb/defs.h:28, from /home/simark/src/binutils-gdb/gdb/lala.c:1: /home/simark/src/binutils-gdb/gdb/common/poison.h: In instantiation of ‘T* xnew() [with T = bar]’: /home/simark/src/binutils-gdb/gdb/lala.c:13:3: required from here /home/simark/src/binutils-gdb/gdb/common/poison.h:103:3: error: static assertion failed: Trying to use XNEW with a non-POD data type. Use operator new instead. static_assert (IsMallocatable::value, "Trying to use XNEW with a non-POD\ ^~~~~~~~~~~~~ Generated-code-wise, it adds one more function call (xnew) when using XNEW and building with -O0, but it all goes away with optimizations enabled. gdb/ChangeLog: * 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. --- diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 3696c5c..1030729 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,5 +1,34 @@ 2017-11-24 Simon Marchi + * 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 + * gdbthread.h (private_thread_info): Define structure type, add virtual pure destructor. (thread_info) : Change type to unique_ptr. diff --git a/gdb/common/common-utils.c b/gdb/common/common-utils.c index 7139302..66d6161 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 4926a32..feb4790 100644 --- a/gdb/common/common-utils.h +++ b/gdb/common/common-utils.h @@ -23,6 +23,8 @@ #include #include +#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 +static void +xfree (T *ptr) +{ + static_assert (IsFreeable::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 37dd35e..1647c9c 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 +using IsMallocable = std::is_pod; + +template +using IsFreeable = gdb::Or, std::is_void>; + +template >>> +void free (T *ptr) = delete; + +template +static T * +xnew () +{ + static_assert (IsMallocable::value, "Trying to use XNEW with a non-POD \ +data type. Use operator new instead."); + return XNEW (T); +} + +#undef XNEW +#define XNEW(T) xnew() + +template +static T * +xcnew () +{ + static_assert (IsMallocable::value, "Trying to use XCNEW with a non-POD \ +data type. Use operator new instead."); + return XCNEW (T); +} + +#undef XCNEW +#define XCNEW(T) xcnew() + +template +static void +xdelete (T *p) +{ + static_assert (IsFreeable::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 +static T * +xnewvec (size_t n) +{ + static_assert (IsMallocable::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 (N) + +template +static T * +xcnewvec (size_t n) +{ + static_assert (IsMallocable::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 (N) + +template +static T * +xresizevec (T *p, size_t n) +{ + static_assert (IsMallocable::value, "Trying to use XRESIZEVEC with a \ +non-POD data type."); + return XRESIZEVEC (T, p, n); +} + +#undef XRESIZEVEC +#define XRESIZEVEC(T, P, N) xresizevec (P, N) + +template +static void +xdeletevec (T *p) +{ + static_assert (IsFreeable::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 +static T * +xnewvar (size_t s) +{ + static_assert (IsMallocable::value, "Trying to use XNEWVAR with a \ +non-POD data type."); + return XNEWVAR (T, s);; +} + +#undef XNEWVAR +#define XNEWVAR(T, S) xnewvar (S) + +template +static T * +xcnewvar (size_t s) +{ + static_assert (IsMallocable::value, "Trying to use XCNEWVAR with a \ +non-POD data type."); + return XCNEWVAR (T, s); +} + +#undef XCNEWVAR +#define XCNEWVAR(T, S) xcnewvar (S) + +template +static T * +xresizevar (T *p, size_t s) +{ + static_assert (IsMallocable::value, "Trying to use XRESIZEVAR with a \ +non-POD data type."); + return XRESIZEVAR (T, p, s); +} + +#undef XRESIZEVAR +#define XRESIZEVAR(T, P, S) xresizevar (P, S) + #endif /* COMMON_POISON_H */