From patchwork Fri Nov 24 04:34:16 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Simon Marchi X-Patchwork-Id: 24487 Received: (qmail 18334 invoked by alias); 24 Nov 2017 04:34:39 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 18254 invoked by uid 89); 24 Nov 2017 04:34:38 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-26.0 required=5.0 tests=BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KB_WAM_FROM_NAME_SINGLEWORD, RCVD_IN_DNSWL_NONE, SPF_SOFTFAIL autolearn=ham version=3.3.2 spammy= X-HELO: barracuda.ebox.ca Received: from barracuda.ebox.ca (HELO barracuda.ebox.ca) (96.127.255.19) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Fri, 24 Nov 2017 04:34:36 +0000 X-ASG-Debug-ID: 1511498074-0c856e65d43caa430001-fS2M51 Received: from smtp.ebox.ca (smtp.electronicbox.net [96.127.255.82]) by barracuda.ebox.ca with ESMTP id j11EJBw0PiqsbEDh (version=TLSv1 cipher=DHE-RSA-AES256-SHA bits=256 verify=NO); Thu, 23 Nov 2017 23:34:34 -0500 (EST) X-Barracuda-Envelope-From: simon.marchi@polymtl.ca X-Barracuda-RBL-Trusted-Forwarder: 96.127.255.82 Received: from simark.lan (192-222-251-162.qc.cable.ebox.net [192.222.251.162]) by smtp.ebox.ca (Postfix) with ESMTP id 0D11A441D64; Thu, 23 Nov 2017 23:34:32 -0500 (EST) From: Simon Marchi X-Barracuda-Effective-Source-IP: 192-222-251-162.qc.cable.ebox.net[192.222.251.162] X-Barracuda-Apparent-Source-IP: 192.222.251.162 X-Barracuda-RBL-IP: 192.222.251.162 To: gdb-patches@sourceware.org Cc: Simon Marchi Subject: [PATCH v2 4/4] Poison XNEW and friends for types that should use new/delete Date: Thu, 23 Nov 2017 23:34:16 -0500 X-ASG-Orig-Subj: [PATCH v2 4/4] Poison XNEW and friends for types that should use new/delete Message-Id: <20171124043416.20706-4-simon.marchi@polymtl.ca> In-Reply-To: <20171124043416.20706-1-simon.marchi@polymtl.ca> References: <20171124043416.20706-1-simon.marchi@polymtl.ca> MIME-Version: 1.0 X-Barracuda-Connect: smtp.electronicbox.net[96.127.255.82] X-Barracuda-Start-Time: 1511498074 X-Barracuda-Encrypted: DHE-RSA-AES256-SHA X-Barracuda-URL: https://96.127.255.19:443/cgi-mod/mark.cgi X-Barracuda-Scan-Msg-Size: 9248 X-Barracuda-BRTS-Status: 1 X-Barracuda-Spam-Score: 0.00 X-Barracuda-Spam-Status: No, SCORE=0.00 using global scores of TAG_LEVEL=1000.0 QUARANTINE_LEVEL=1000.0 KILL_LEVEL=8.0 tests= X-Barracuda-Spam-Report: Code version 3.2, rules version 3.2.3.45158 Rule breakdown below pts rule name description ---- ---------------------- -------------------------------------------------- X-IsSubscribed: yes New in v2: - IsMallocatable -> IsMallocable - Formatting 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 IsMallocable = 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>; For simplicity, we could also do for std::is_pod for IsFreeable as well, if you prefer. I chose to put static_assert in the functions, instead of using gdb::Requires in the template as SFINAE, because it allows to put a message, which I think makes the compiler error more understandable. With gdb::Requires, the error is: 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/lala.c: In function ‘void foo()’: /home/simark/src/binutils-gdb/gdb/common/poison.h:108:25: error: no matching function for call to ‘xnew()’ #define XNEW(T) xnew() ^ /home/simark/src/binutils-gdb/gdb/lala.c:13:3: note: in expansion of macro ‘XNEW’ XNEW(bar); ^~~~ /home/simark/src/binutils-gdb/gdb/common/poison.h:101:1: note: candidate: template::value, void>::type > T* xnew() xnew () ^~~~ /home/simark/src/binutils-gdb/gdb/common/poison.h:101:1: note: template argument deduction/substitution failed: /home/simark/src/binutils-gdb/gdb/common/poison.h:108:25: note: couldn't deduce template parameter ‘’ #define XNEW(T) xnew() ^ /home/simark/src/binutils-gdb/gdb/lala.c:13:3: note: in expansion of macro ‘XNEW’ XNEW(bar); ^~~~ and with static_assert: 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 (IsMallocable::value, "Trying to use XNEW with a non-POD\ ^~~~~~~~~~~~~ I think the first one is more likely to just make people yell at their screen, especially those less used to C++. 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 (IsMallocable): 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. --- gdb/common/common-utils.c | 7 --- gdb/common/common-utils.h | 14 ++++- gdb/common/poison.h | 132 ++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 145 insertions(+), 8 deletions(-) diff --git a/gdb/common/common-utils.c b/gdb/common/common-utils.c index 71393027f7..66d61615a9 100644 --- a/gdb/common/common-utils.c +++ b/gdb/common/common-utils.c @@ -94,13 +94,6 @@ xzalloc (size_t size) return xcalloc (1, size); } -void -xfree (void *ptr) -{ - if (ptr != NULL) - free (ptr); /* ARI: free */ -} - void xmalloc_failed (size_t size) { diff --git a/gdb/common/common-utils.h b/gdb/common/common-utils.h index 4926a32719..feb4790afc 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 37dd35e4b1..1647c9cb6f 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 */