From patchwork Fri Apr 3 12:47:55 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Pierre-Marie de Rodat X-Patchwork-Id: 5996 Received: (qmail 78020 invoked by alias); 3 Apr 2015 12:48:02 -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 77993 invoked by uid 89); 3 Apr 2015 12:48:00 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.6 required=5.0 tests=AWL, BAYES_00, KAM_LAZY_DOMAIN_SECURITY, RCVD_IN_DNSWL_LOW autolearn=no version=3.3.2 X-HELO: smtp.eu.adacore.com Received: from mel.act-europe.fr (HELO smtp.eu.adacore.com) (194.98.77.210) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES256-GCM-SHA384 encrypted) ESMTPS; Fri, 03 Apr 2015 12:47:59 +0000 Received: from localhost (localhost [127.0.0.1]) by filtered-smtp.eu.adacore.com (Postfix) with ESMTP id C17232D4E2FA; Fri, 3 Apr 2015 14:47:55 +0200 (CEST) Received: from smtp.eu.adacore.com ([127.0.0.1]) by localhost (smtp.eu.adacore.com [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id DbScWgeRylXX; Fri, 3 Apr 2015 14:47:55 +0200 (CEST) Received: from [10.10.1.112] (cacatoes.act-europe.fr [10.10.1.112]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.eu.adacore.com (Postfix) with ESMTPSA id AC6BD2D4E2E3; Fri, 3 Apr 2015 14:47:55 +0200 (CEST) Message-ID: <551E8BFB.1010000@adacore.com> Date: Fri, 03 Apr 2015 14:47:55 +0200 From: Pierre-Marie de Rodat User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:31.0) Gecko/20100101 Thunderbird/31.5.0 MIME-Version: 1.0 To: GDB Patches CC: Joel Brobecker Subject: [PATCH 2/2] Cache all static structures and reset cache during resolution References: <551E8B6D.4070706@adacore.com> In-Reply-To: <551E8B6D.4070706@adacore.com> X-IsSubscribed: yes Here is a little cleanup after the previous patch: Currently, ada-lang.c:template_to_static_fixed_type (working on structure types only) caches its result into the unused TYPE_TARGET_TYPE field. This introduces inconsistencies when the input type is specialized, for instance during type resolution: the cached static fixed type is copied along with the original type, but it's no longer adapted to the copy once the copy is modified: template_to_static_fixed_type has to compute another static fixed type for it. This change first introduces a cache reset during type resolution for structure types so that this inconsistency does not happen anymore. It also makes template_to_static_fixed_type smarter with respect to types that do not need static fixed copies so that less computations is done in general. This inconsistency was spotted thanks to code reading, not because of any sort of failure and we did not manage to exhibit a failure yet, so no testcase for this. gdb/ChangeLog: * ada-lang.c (template_to_static_fixed_type): Return input type when it is already fixed. Cache the input type itself when not creating a static fixed copy. Make it explicit that we never molestate the input type. * gdbtypes.c (resolve_dynamic_struct): Reset the TYPE_TARGET_TYPE field for resolved copies. No regression as well on x86_64-linux. Ok to push? From d0c3ff848af86a6174ecc83022b58e5af76f4a98 Mon Sep 17 00:00:00 2001 From: Pierre-Marie de Rodat Date: Tue, 31 Mar 2015 17:18:12 +0200 Subject: [PATCH 2/2] [Ada] Cache all static structures and reset cache during resolution Currently, ada-lang.c:template_to_static_fixed_type (working on structure types only) caches its result into the unused TYPE_TARGET_TYPE field. This introduces inconsistencies when the input type is specialized, for instance during type resolution: the cached static fixed type is copied along with the original type, but it's no longer adapted to the copy once the copy is modified: template_to_static_fixed_type has to compute another static fixed type for it. This change first introduces a cache reset during type resolution for structure types so that this inconsistency does not happen anymore. It also makes template_to_static_fixed_type smarter with respect to types that do not need static fixed copies so that less computations is done in general. This inconsistency was spotted thanks to code reading, not because of any sort of failure and we did not manage to exhibit a failure yet, so no testcase for this. gdb/ChangeLog: * ada-lang.c (template_to_static_fixed_type): Return input type when it is already fixed. Cache the input type itself when not creating a static fixed copy. Make it explicit that we never molestate the input type. * gdbtypes.c (resolve_dynamic_struct): Reset the TYPE_TARGET_TYPE field for resolved copies. --- gdb/ada-lang.c | 52 ++++++++++++++++++++++++++++++++++------------------ gdb/gdbtypes.c | 4 ++++ 2 files changed, 38 insertions(+), 18 deletions(-) diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c index e147d5a..d034049 100644 --- a/gdb/ada-lang.c +++ b/gdb/ada-lang.c @@ -8171,11 +8171,21 @@ template_to_static_fixed_type (struct type *type0) int nfields; int f; + /* No need no do anything if the input type is already fixed. */ + if (TYPE_FIXED_INSTANCE (type0)) + return type0; + + /* Likewise if we already have computed the static approximation. */ if (TYPE_TARGET_TYPE (type0) != NULL) return TYPE_TARGET_TYPE (type0); - nfields = TYPE_NFIELDS (type0); + /* Don't clone TYPE0 until we are sure we are going to need a copy. */ type = type0; + nfields = TYPE_NFIELDS (type0); + + /* Whether or not we cloned TYPE0, cache the result so that we don't do + recompute all over next time. */ + TYPE_TARGET_TYPE (type0) = type; for (f = 0; f < nfields; f += 1) { @@ -8189,24 +8199,30 @@ template_to_static_fixed_type (struct type *type0) } else new_type = static_unwrap_type (field_type); - if (type == type0 && new_type != field_type) - { - TYPE_TARGET_TYPE (type0) = type = alloc_type_copy (type0); - TYPE_CODE (type) = TYPE_CODE (type0); - INIT_CPLUS_SPECIFIC (type); - TYPE_NFIELDS (type) = nfields; - TYPE_FIELDS (type) = (struct field *) - TYPE_ALLOC (type, nfields * sizeof (struct field)); - memcpy (TYPE_FIELDS (type), TYPE_FIELDS (type0), - sizeof (struct field) * nfields); - TYPE_NAME (type) = ada_type_name (type0); - TYPE_TAG_NAME (type) = NULL; - TYPE_FIXED_INSTANCE (type) = 1; - TYPE_LENGTH (type) = 0; - } - TYPE_FIELD_TYPE (type, f) = new_type; - TYPE_FIELD_NAME (type, f) = TYPE_FIELD_NAME (type0, f); + + if (new_type != field_type) + { + /* Clone TYPE0 only the first time we get a new field type. */ + if (type == type0) + { + TYPE_TARGET_TYPE (type0) = type = alloc_type_copy (type0); + TYPE_CODE (type) = TYPE_CODE (type0); + INIT_CPLUS_SPECIFIC (type); + TYPE_NFIELDS (type) = nfields; + TYPE_FIELDS (type) = (struct field *) + TYPE_ALLOC (type, nfields * sizeof (struct field)); + memcpy (TYPE_FIELDS (type), TYPE_FIELDS (type0), + sizeof (struct field) * nfields); + TYPE_NAME (type) = ada_type_name (type0); + TYPE_TAG_NAME (type) = NULL; + TYPE_FIXED_INSTANCE (type) = 1; + TYPE_LENGTH (type) = 0; + } + TYPE_FIELD_TYPE (type, f) = new_type; + TYPE_FIELD_NAME (type, f) = TYPE_FIELD_NAME (type0, f); + } } + return type; } diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index 217ec70..ff80035 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -2013,6 +2013,10 @@ resolve_dynamic_struct (struct type *type, TYPE_LENGTH (resolved_type) = (resolved_type_bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT; + /* The Ada language uses this field as a cache for static fixed types: reset + it as RESOLVED_TYPE must have its own static fixed type. */ + TYPE_TARGET_TYPE (resolved_type) = NULL; + return resolved_type; } -- 2.3.4