From patchwork Wed Apr 25 19:39:42 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Simon Marchi X-Patchwork-Id: 26984 Received: (qmail 86030 invoked by alias); 25 Apr 2018 19:40:15 -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 86018 invoked by uid 89); 25 Apr 2018 19:40:15 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-26.1 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, SPF_PASS autolearn=ham version=3.3.2 spammy=focused, pod, robust, cwg X-HELO: sessmg23.ericsson.net Received: from sessmg23.ericsson.net (HELO sessmg23.ericsson.net) (193.180.251.45) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Wed, 25 Apr 2018 19:40:11 +0000 Received: from ESESSHC015.ericsson.se (Unknown_Domain [153.88.183.63]) by sessmg23.ericsson.net (Symantec Mail Security) with SMTP id D5.BF.26811.899D0EA5; Wed, 25 Apr 2018 21:40:08 +0200 (CEST) Received: from ESESSMB502.ericsson.se (153.88.183.163) by ESESSHC015.ericsson.se (153.88.183.63) with Microsoft SMTP Server (TLS) id 14.3.382.0; Wed, 25 Apr 2018 21:40:07 +0200 Received: from ESESSMB503.ericsson.se (153.88.183.164) by ESESSMB502.ericsson.se (153.88.183.163) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1466.3; Wed, 25 Apr 2018 21:40:07 +0200 Received: from NAM03-CO1-obe.outbound.protection.outlook.com (153.88.183.157) by ESESSMB503.ericsson.se (153.88.183.164) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1466.3 via Frontend Transport; Wed, 25 Apr 2018 21:40:07 +0200 Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=simon.marchi@ericsson.com; Received: from elxacz23q12.ericsson.se (129.192.64.65) by MW2PR1501MB2011.namprd15.prod.outlook.com (2603:10b6:302:c::11) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384_P256) id 15.20.696.15; Wed, 25 Apr 2018 19:40:03 +0000 From: Simon Marchi To: CC: Simon Marchi Subject: [PATCH 1/2] Introduce obstack_new, poison other "typed" obstack functions Date: Wed, 25 Apr 2018 15:39:42 -0400 Message-ID: <1524685183-5553-1-git-send-email-simon.marchi@ericsson.com> MIME-Version: 1.0 X-ClientProxiedBy: YTOPR0101CA0063.CANPRD01.PROD.OUTLOOK.COM (2603:10b6:b00:14::40) To MW2PR1501MB2011.namprd15.prod.outlook.com (2603:10b6:302:c::11) X-MS-PublicTrafficType: Email X-Microsoft-Antispam: UriScan:; BCL:0; PCL:0; RULEID:(7020095)(4652020)(5600026)(4534165)(4627221)(201703031133081)(201702281549075)(2017052603328)(7153060)(7193020); SRVR:MW2PR1501MB2011; X-Microsoft-Exchange-Diagnostics: 1; MW2PR1501MB2011; 3:oQb0NbOlzsqHdo3lrUOxNig72zbKt57dqOrIvpNyiyjq7oMtGdxkylAmUg6QGylsP0+e28wzyJNR5AB/Q/xWFCjYfrcmFzHpH2445Z/0JE/EuoN5CKtRUNWaoBaY0KGJ67zLQf/W9YUJCtCoZ9aYEu4a35392jai2RAZoyzjCKbvjUTDBP320mFLWV8dDcHXIIxESdpwHMZ21YfY7H0bHWB77J3cme8R+xn/Scp2yqwkAnzEElUUjyBBw/n01t+n; 25:ABcRN70Kq9nRvtLU/aZZ0HeU6YojpnI/PaiJNTQ7qRlhBTOBb/1kXW6NeNp8IdFRJVXExTbP3DSQae/EfMQKtnY5XJ0lx2vlvVShqOxtENyZGTPuFkenilMi/qlLRPcUXjdYGP9YEjCe3YZCB0UM2wuqFMLRFr1FVKdNXpw+EW3uzcQ5o9co9JQu21KCU8m8b57XhCUkzucalk4aNsljOPLMucjBxssQ2uX/BHqOItFF64mFfSfHyxCwP6fIXh/WY1lf6hJE+wSg0R0l2ujSHerpxtw7pQrgPsf8Pung6mzbKM7ZFW4IzgQjIXV9d1nDLYkkOmP0c+UZLcgxlUQNtw==; 31:nfkWqPR+ANbIWIxZzuZEoXsLA2cyxvqy41ACX6udh+dsXHn9wuHSJTxqvpuocbJQeitB86KezgHDk/jPUS+6DmApYUtQBEWSIJbyE91kIJDSRTSgsMRMRNrUydFcfqzYXN9+SyT/N139zS80XBoy+y3Do8oaf3V2eSi004MkqHOyEmHPwphr7t9voKNAjmKwaxQcB0pJvG6xMdylYJhX77gpwWSAait1xW+WaUbqz10= X-MS-TrafficTypeDiagnostic: MW2PR1501MB2011: X-Microsoft-Exchange-Diagnostics: 1; MW2PR1501MB2011; 20:If6hG/zjbI7efzzzK3LSb2nUXIFfc6FYHug7bOFRKsHJcR7TTsnkkyUBrIQc417tXJhj13hNzwQ58W5sAUriFttnv0yXzu5mfBqXc/xD5VXEelg5xepxRj9EUk6acrtnrSyjTZO5XoN8t6qpPE0pQKm0hrbjaGnEXJTGbgaOheNRXEY41wkiezQYLfS0GGY70Q21Q25KBxxK3jMiUob4Niz0GX8xua7b+0/wu98FagWQi6/r013bRgTYtWd03NmysPJaoRzzH6PddTWzf4hdMe5YqT5CcPIjb6/XFTOXr6risw3VQ3wfdfZWWe4UfCh+9DVUrcL2cdGrYfNElFgphkme0s7jZ21M9lLXqmPBhz0JIsoC/ylbdMN1ZjzdxU7Di9bj46II5+LBOmiWYk4WKTdgiVP9OEuSLbtrDFWK+VX6MC5vFJ2HzklC1fnyGOQQrx88myYVzw6VdBALTnddY3L+meY8+lJ06YNK1FdZAd6nTB4YLnlM4ffVpELHljup; 4:yr+KRoKwbvD+IGtEPLTkqa36twzEF+Ki5xc6tgqyoJ1AiuJSouu/pNWy3rU2KCJUEPxTaxu7lL+UneYkCpVEK9Xz97aB9XbWJxJqgyCir85t40AVlqFqqSwZZwpCtpeqiGavaIewryK6Zjiz7JnSStfXnckD2TwAyfTWXS1BhfnkNCBxLzagPcvM9ILlTKjxLKGeJ7L36LJlv9CcQGJwEd8Y0ZDDFrYssmZCpSesbntPIH9NcRS9tVp2BTw8Y24KXEJj7VjYdVX6VquyaOR5XA== X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:; X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(5005006)(8121501046)(93006095)(93001095)(3002001)(10201501046)(3231232)(944501410)(52105095)(6041310)(20161123558120)(20161123562045)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123564045)(20161123560045)(6072148)(201708071742011); SRVR:MW2PR1501MB2011; BCL:0; PCL:0; RULEID:; SRVR:MW2PR1501MB2011; X-Forefront-PRVS: 06530126A4 X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(396003)(346002)(366004)(376002)(39380400002)(39860400002)(189003)(199004)(54534003)(36756003)(6116002)(2351001)(50466002)(81166006)(81156014)(386003)(4326008)(69596002)(44832011)(3846002)(25786009)(50226002)(68736007)(476003)(2616005)(48376002)(51416003)(8936002)(6506007)(8676002)(486006)(956004)(52116002)(59450400001)(26005)(97736004)(47776003)(478600001)(6486002)(16526019)(6512007)(107886003)(186003)(575784001)(66066001)(316002)(106356001)(305945005)(2361001)(53936002)(2906002)(5660300001)(16586007)(105586002)(6666003)(53416004)(7736002)(6916009)(86362001); DIR:OUT; SFP:1101; SCL:1; SRVR:MW2PR1501MB2011; H:elxacz23q12.ericsson.se; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; Received-SPF: None (protection.outlook.com: ericsson.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; MW2PR1501MB2011; 23:KJLwAWX71k8cspHjLMpaud4mGu2YogRQbgydZ3+?= =?us-ascii?Q?whFhlmax/8u5E4tWKMFcq1JO2GOXH1hMugENipXDDpgfCiuhrL/Kka7vekTW?= =?us-ascii?Q?22cVDY+z/uxEghzffMu4pMwPtLZ7AQGH/fDZwHUv3vijT9QaaUxrGTasF+aF?= =?us-ascii?Q?Wt7nVYqS8BnVfLYDdpSfI2IRurfJ+SmjprXiMHSWMwRjUCwpRFgyRT7jQlsR?= =?us-ascii?Q?LT8S4Xnf/wJ+3QVvahRWm82JVSxRCPCEMEysJOUuKVVjbku340/SdB5woVlH?= =?us-ascii?Q?zp79evPm7wgRQvapzdyGVXmbLqqB9A5QNE5lmBr98hgBALEBDemzM4Qk8j3a?= =?us-ascii?Q?XJjBqLx6TvmlZmZvmUZb4i8YMy4dLVnJ4YX0ZZDCpylo1pKEsy5GiTps4fhJ?= =?us-ascii?Q?QOcCNQE9tcwFgE/K/ZInkJVXwQZ8qp42G/YOozZkUreZzAp+eDXd72XG8iEk?= =?us-ascii?Q?Od1qt+Wjn+ev+sgXV5N0uxeGYpRUxxrugU8lazRCAM3bOWDgpEh/pedX17hh?= =?us-ascii?Q?r0rJtx8nm4wk2ExtKYguN0Qe2VNzmrptfo5tHPGB0w/kT4alAo8qFCCaor3f?= =?us-ascii?Q?R2xfz28RIwYx54lOffT2ay488QwiPNimdu307MeYRoKzwi9vFLxUew3oe6xk?= =?us-ascii?Q?QzRstChOc1PknzPNqOqtXA3ZAlyDQ9a//gzjWGfAin+ZHbrcE1aGgQp0tNDk?= =?us-ascii?Q?9se4IwQ9wvzorxxDBnreCbhzWCCSCfy1ueMcSNAJ6WMILNpfR3oE1yPhh13N?= =?us-ascii?Q?fcGKj4wEbp8kA2EXaTwtllnGgrYuyebUoAs0jjrVN0jIX9KQa3ZrNcYq1ZQk?= =?us-ascii?Q?eAQrJD3A9/L9x+68Jc6+oqGG1glDxiC4mMZnO/k508H6F9paWIQXPHU2vjor?= =?us-ascii?Q?C+3JEmiEhmXP80sVT2O0kowUro/gOsE+i0iur+D5EGIWQQf/ixAQ3K2/Vmo3?= =?us-ascii?Q?F6u0UzJ4t1ngk5E9PmiLuH+VSiukBkqaZmsoDhTw9b3mrFqBbyE3nA7LAVxu?= =?us-ascii?Q?9sr5LiJClZlsJTrtZXom08cYV9n5VK2fKjf3jCbJcw/89PfA2/KdIuc66r73?= =?us-ascii?Q?K98C3tC095b7VfN4XTXWXHIrUBo5/jOslCDL/Dv4/+7VoH0dRd0gnyJjP+Xj?= =?us-ascii?Q?Kafj+EyTyMJfY7tsaRiPSoF1o0G9FArwlsJNPY4A0nFgcF6FDG3uscXLBMYQ?= =?us-ascii?Q?J6rjBndR8V5kHfsXR+Ou3npJLzg5KXkq90yW09uy1qQhTh8t391+E3tl3LTn?= =?us-ascii?Q?K+cknRCGWSYzNwd8nRlLt7QQsqnRhN3GfW6VsG6XXnNACxMblK0f1brApu+h?= =?us-ascii?Q?eeBrmBavqVHbo4yP7smSFzmA=3D?= X-Microsoft-Antispam-Message-Info: uZOLpJNGQSNRlaPx+7/8ePRt3Tr51+QqrjrJshtyZ2QeYSAYhrfLpTAupdXkONDUTCn8AQ5r6f3kWNqBRxc85SpH1hI7tGZW1j/QIfKPQptC13ZIF99xmU913oLNFsF1sdA+xteC6IwEql5VT4CkGsTXeogDA501ySsItH/P7IbeFfR3n4CouINisuFYQXir X-Microsoft-Exchange-Diagnostics: 1; MW2PR1501MB2011; 6:AS6fjbz9EhOmu+AB6XqAz5EFmyuMUV2ky4mM53JxtbuPWo3SHAQbIbVeJ9ZNEGeu6ZqwxpJB7pM4+rwEUBzu1l9a3nEI+984ZG993Xn+5sJq6TCjDVu21nL8IgkeYPTXMVHdhlMbXwFYTuA66rleLXALio096jurCga97uHpmYnY3DgUSyv+XVo9WZPQVWq3DWimvboVtC2sjkl0tkoAacmGN0hEQ2PDO/a+IvVTJycD8DoTjPXvsBVgaGrb/9lDPiD1I6J4qj5SLndNIY+l8OxfAImAlLUmyyecrwNxy6Eiug01pTv4VhUuHfdcIxFB87MKk5OWKWJj0au2L9IM8+063B79YPN4SHSF4oYFnhVi0lttJsT+eWNYhzfAs/TEu5L0YvCJCWOayU1xgPuGWXKAZuOxJdH/YmPEsS10Yt3UDUpQoZQ4f05wYKVuMIjmlNGp1Q9xCx7nzLaTkZS2cQ==; 5:SN1Wg4EmW/w2lhJO/3nkc1mfm+ZbL8wKMTT3Dgmma2Wm8TZQgNu/WSRCPyS5e8ZgzvmOndyNj9rlcUhzM3XYkzOnnr0rK5ipzguJr4qE9QgIZeq2WBs9WKMpJegTMnQVlTX6goG5ubqaiWAkZSEAlz6/rSuI8lS/kjPPaRzYzWo=; 24:MhYWnvuob9QOSb0H5Nj9RSOsu7k32y7TTYDwhCKNWXMyGdN9uH+6uVn8/kdeLpqQyvlS8AXC12cIdZipLhIWxs0lHLAODxIKyEaD85jq2pA= SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; MW2PR1501MB2011; 7:+Z6eu6ejDpdq3ljLAJVoLIXV0fJWZ1RjmWonG6du7bicLuQuq2cNLq1PMk9XVAgQZR9irBeLTh5LHXkSLQnMgMwoX6OE3mPz/i27z/YxkYLFw/X0n1T87sFFc2Iajjvz3l2jNmE2b7/+7+YpcrDeLPcPeImvN6x7QV/G4phCM7c2ltbB+DP53GyywaCApN1RDMMwwahqvo+f5upAFri4DQG/vSLTWVp6jKRBRWDuIro+qIUJnVWpBrXzjSVyUe3e X-MS-Office365-Filtering-Correlation-Id: 01241697-2a88-45c1-dd88-08d5aae45792 X-MS-Exchange-CrossTenant-OriginalArrivalTime: 25 Apr 2018 19:40:03.7082 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 01241697-2a88-45c1-dd88-08d5aae45792 X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 92e84ceb-fbfd-47ab-be52-080c6b87953f X-MS-Exchange-Transport-CrossTenantHeadersStamped: MW2PR1501MB2011 X-OriginatorOrg: ericsson.com X-IsSubscribed: yes Since we use obstacks with objects that are not default constructible, we sometimes need to manually call the constructor by hand using placement new: foo *f = obstack_alloc (obstack, sizeof (foo)); f = new (f) foo; This patch introduces a utility to make this pattern simpler: foo *f = obstack_new (); To help catch places where we would forget to call new when allocating such an object on an obstack, this patch also poisons some other methods of allocating an instance of a type on an obstack: - OBSTACK_ZALLOC/OBSTACK_CALLOC - XOBNEW/XOBNEW - GDBARCH_OBSTACK_ZALLOC/GDBARCH_OBSTACK_CALLOC Unfortunately, there's no way to catch wrong usages of obstack_alloc. By pulling on that string though, it tripped on allocating struct template_symbol using OBSTACK_ZALLOC. The criterion currently used to know whether it's safe to "malloc" an instance of a struct is whether it is a POD. Because it inherits from struct symbol, template_symbol is not a POD. This criterion is a bit too strict however, it should still safe to allocate memory for a template_symbol and memset it to 0. We didn't use is_trivially_constructible as the criterion in the first place only because it is not available in gcc < 5. So here I considered two alternatives: 1. Relax that criterion to use std::is_trivially_constructible and add a bit more glue code to make it work with gcc < 5 2. Continue pulling on the string and change how the symbol structures are allocated and initialized I managed to do both, but I decided to go with #1 to keep this patch simpler and more focused. When building with a compiler that does not have is_trivially_constructible, the check will just not be enforced. gdb/ChangeLog: * common/traits.h (HAVE_IS_TRIVIALLY_COPYABLE): Define if compiler supports std::is_trivially_constructible. * common/poison.h: Include obstack.h. (IsMallocable): Define to is_trivially_constructible if the compiler supports it, define to true_type otherwise. (xobnew): New. (XOBNEW): Redefine. (xobnewvec): New. (XOBNEWVEC): Redefine. * gdb_obstack.h (obstack_zalloc): New. (OBSTACK_ZALLOC): Redefine. (obstack_calloc): New. (OBSTACK_CALLOC): Redefine. (obstack_new): New. * dwarf2read.c (dwarf2_read_index): Use obstack_new. * gdbarch.sh: Include gdb_obstack in gdbarch.h. (gdbarch_obstack): New declaration in gdbarch.h, definition in gdbarch.c. (GDBARCH_OBSTACK_CALLOC, GDBARCH_OBSTACK_ZALLOC): Use obstack_calloc/obstack_zalloc. (gdbarch_obstack_zalloc): Remove. * target-descriptions.c (tdesc_data_init): Use obstack_new. --- gdb/common/poison.h | 31 ++++++++++++++++++++++++++++++- gdb/common/traits.h | 8 ++++++++ gdb/dwarf2read.c | 3 +-- gdb/gdb_obstack.h | 36 ++++++++++++++++++++++++++++++++---- gdb/gdbarch.c | 9 ++------- gdb/gdbarch.h | 10 +++++++--- gdb/gdbarch.sh | 21 +++++++++++---------- gdb/target-descriptions.c | 7 +------ 8 files changed, 92 insertions(+), 33 deletions(-) diff --git a/gdb/common/poison.h b/gdb/common/poison.h index c98d2b3..ddab2c1 100644 --- a/gdb/common/poison.h +++ b/gdb/common/poison.h @@ -21,6 +21,7 @@ #define COMMON_POISON_H #include "traits.h" +#include "obstack.h" /* Poison memset of non-POD types. The idea is catching invalid initialization of non-POD structs that is easy to be introduced as @@ -88,7 +89,11 @@ void *memmove (D *dest, const S *src, size_t n) = delete; objects that require new/delete. */ template -using IsMallocable = std::is_pod; +#if HAVE_IS_TRIVIALLY_CONSTRUCTIBLE +using IsMallocable = std::is_trivially_constructible; +#else +using IsMallocable = std::true_type; +#endif template using IsFreeable = gdb::Or, std::is_void>; @@ -216,4 +221,28 @@ non-POD data type."); #undef XRESIZEVAR #define XRESIZEVAR(T, P, S) xresizevar (P, S) +template +static T * +xobnew (obstack *ob) +{ + static_assert (IsMallocable::value, "Trying to use XOBNEW with a \ +non-POD data type."); + return XOBNEW (ob, T); +} + +#undef XOBNEW +#define XOBNEW(O, T) xobnew (O) + +template +static T * +xobnewvec (obstack *ob, size_t n) +{ + static_assert (IsMallocable::value, "Trying to use XOBNEWVEC with a \ +non-POD data type."); + return XOBNEWVEC (ob, T, n); +} + +#undef XOBNEWVEC +#define XOBNEWVEC(O, T, N) xobnewvec (O, N) + #endif /* COMMON_POISON_H */ diff --git a/gdb/common/traits.h b/gdb/common/traits.h index d9e6839..070ef15 100644 --- a/gdb/common/traits.h +++ b/gdb/common/traits.h @@ -33,6 +33,14 @@ # define HAVE_IS_TRIVIALLY_COPYABLE 1 #endif +/* HAVE_IS_TRIVIALLY_CONSTRUCTIBLE is defined as 1 iff + std::is_trivially_constructible is available. GCC only implemented it + in GCC 5. */ +#if (__has_feature(is_trivially_constructible) \ + || (defined __GNUC__ && __GNUC__ >= 5)) +# define HAVE_IS_TRIVIALLY_COPYABLE 1 +#endif + namespace gdb { /* Pre C++14-safe (CWG 1558) version of C++17's std::void_t. See diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c index 4207e4c..80185a9 100644 --- a/gdb/dwarf2read.c +++ b/gdb/dwarf2read.c @@ -3601,8 +3601,7 @@ dwarf2_read_index (struct dwarf2_per_objfile *dwarf2_per_objfile) create_addrmap_from_index (dwarf2_per_objfile, &local_map); - map = XOBNEW (&objfile->objfile_obstack, struct mapped_index); - map = new (map) mapped_index (); + map = obstack_new (&objfile->objfile_obstack); *map = local_map; dwarf2_per_objfile->index_table = map; diff --git a/gdb/gdb_obstack.h b/gdb/gdb_obstack.h index 1011008..29cad93 100644 --- a/gdb/gdb_obstack.h +++ b/gdb/gdb_obstack.h @@ -24,12 +24,40 @@ /* Utility macros - wrap obstack alloc into something more robust. */ -#define OBSTACK_ZALLOC(OBSTACK,TYPE) \ - ((TYPE *) memset (obstack_alloc ((OBSTACK), sizeof (TYPE)), 0, sizeof (TYPE))) +template +static inline T* +obstack_zalloc (struct obstack *ob) +{ + static_assert (IsMallocable::value, "Trying to use OBSTACK_ZALLOC with a \ +non-POD data type. Use obstack_new instead."); + return ((T *) memset (obstack_alloc (ob, sizeof (T)), 0, sizeof (T))); +} + +#define OBSTACK_ZALLOC(OBSTACK,TYPE) obstack_zalloc ((OBSTACK)) + +template +static inline T * +obstack_calloc (struct obstack *ob, size_t number) +{ + static_assert (IsMallocable::value, "Trying to use OBSTACK_CALLOC with a \ +non-POD data type. Use obstack_new instead."); + return ((T *) memset (obstack_alloc (ob, number * sizeof (T)), 0, + number * sizeof (T))); +} #define OBSTACK_CALLOC(OBSTACK,NUMBER,TYPE) \ - ((TYPE *) memset (obstack_alloc ((OBSTACK), (NUMBER) * sizeof (TYPE)), \ - 0, (NUMBER) * sizeof (TYPE))) + obstack_calloc ((OBSTACK), (NUMBER)) + +/* Allocate an object on OB and call its constructor. */ + +template +static inline T* +obstack_new (struct obstack *ob, Args&&... args) +{ + T* object = (T *) obstack_alloc (ob, sizeof (T)); + object = new (object) T (std::forward (args)...); + return object; +} /* Unless explicitly specified, GDB obstacks always use xmalloc() and xfree(). */ diff --git a/gdb/gdbarch.c b/gdb/gdbarch.c index 1359c2f..4b4ae0b 100644 --- a/gdb/gdbarch.c +++ b/gdb/gdbarch.c @@ -471,15 +471,10 @@ gdbarch_alloc (const struct gdbarch_info *info, } -/* Allocate extra space using the per-architecture obstack. */ -void * -gdbarch_obstack_zalloc (struct gdbarch *arch, long size) +obstack *gdbarch_obstack (gdbarch *arch) { - void *data = obstack_alloc (arch->obstack, size); - - memset (data, 0, size); - return data; + return arch->obstack; } /* See gdbarch.h. */ diff --git a/gdb/gdbarch.h b/gdb/gdbarch.h index 0084f19..d42e69c 100644 --- a/gdb/gdbarch.h +++ b/gdb/gdbarch.h @@ -38,6 +38,7 @@ #include #include "frame.h" #include "dis-asm.h" +#include "gdb_obstack.h" struct floatformat; struct ui_file; @@ -1705,14 +1706,17 @@ extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gd extern void gdbarch_free (struct gdbarch *); +/* Get the obstack owned by ARCH. */ + +extern obstack *gdbarch_obstack (gdbarch *arch); /* Helper function. Allocate memory from the ``struct gdbarch'' obstack. The memory is freed when the corresponding architecture is also freed. */ -extern void *gdbarch_obstack_zalloc (struct gdbarch *gdbarch, long size); -#define GDBARCH_OBSTACK_CALLOC(GDBARCH, NR, TYPE) ((TYPE *) gdbarch_obstack_zalloc ((GDBARCH), (NR) * sizeof (TYPE))) -#define GDBARCH_OBSTACK_ZALLOC(GDBARCH, TYPE) ((TYPE *) gdbarch_obstack_zalloc ((GDBARCH), sizeof (TYPE))) +#define GDBARCH_OBSTACK_CALLOC(GDBARCH, NR, TYPE) obstack_calloc (gdbarch_obstack ((GDBARCH)), (NR)) + +#define GDBARCH_OBSTACK_ZALLOC(GDBARCH, TYPE) obstack_zalloc (gdbarch_obstack((GDBARCH))) /* Duplicate STRING, returning an equivalent string that's allocated on the obstack associated with GDBARCH. The string is freed when the corresponding diff --git a/gdb/gdbarch.sh b/gdb/gdbarch.sh index 4fc54cb..ed407cb 100755 --- a/gdb/gdbarch.sh +++ b/gdb/gdbarch.sh @@ -1261,6 +1261,7 @@ cat < #include "frame.h" #include "dis-asm.h" +#include "gdb_obstack.h" struct floatformat; struct ui_file; @@ -1532,14 +1533,19 @@ extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gd extern void gdbarch_free (struct gdbarch *); +/* Get the obstack owned by ARCH. */ + +extern obstack *gdbarch_obstack (gdbarch *arch); /* Helper function. Allocate memory from the \`\`struct gdbarch'' obstack. The memory is freed when the corresponding architecture is also freed. */ -extern void *gdbarch_obstack_zalloc (struct gdbarch *gdbarch, long size); -#define GDBARCH_OBSTACK_CALLOC(GDBARCH, NR, TYPE) ((TYPE *) gdbarch_obstack_zalloc ((GDBARCH), (NR) * sizeof (TYPE))) -#define GDBARCH_OBSTACK_ZALLOC(GDBARCH, TYPE) ((TYPE *) gdbarch_obstack_zalloc ((GDBARCH), sizeof (TYPE))) +#define GDBARCH_OBSTACK_CALLOC(GDBARCH, NR, TYPE) \ + obstack_calloc (gdbarch_obstack ((GDBARCH)), (NR)) + +#define GDBARCH_OBSTACK_ZALLOC(GDBARCH, TYPE) \ + obstack_zalloc (gdbarch_obstack((GDBARCH))) /* Duplicate STRING, returning an equivalent string that's allocated on the obstack associated with GDBARCH. The string is freed when the corresponding @@ -1849,15 +1855,10 @@ EOF printf "\n" printf "\n" cat <obstack, size); - - memset (data, 0, size); - return data; + return arch->obstack; } /* See gdbarch.h. */ diff --git a/gdb/target-descriptions.c b/gdb/target-descriptions.c index 36ea4b1..61fb344 100644 --- a/gdb/target-descriptions.c +++ b/gdb/target-descriptions.c @@ -723,12 +723,7 @@ tdesc_find_type (struct gdbarch *gdbarch, const char *id) static void * tdesc_data_init (struct obstack *obstack) { - struct tdesc_arch_data *data; - - data = OBSTACK_ZALLOC (obstack, struct tdesc_arch_data); - new (data) tdesc_arch_data (); - - return data; + return obstack_new (obstack); } /* Similar, but for the temporary copy used during architecture