From patchwork Tue Aug 14 00:11:52 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Kevin Buettner X-Patchwork-Id: 28882 Received: (qmail 92070 invoked by alias); 14 Aug 2018 00:11:57 -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 92053 invoked by uid 89); 14 Aug 2018 00:11:56 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-26.9 required=5.0 tests=BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, SPF_HELO_PASS autolearn=ham version=3.3.2 spammy= X-HELO: mx1.redhat.com Received: from mx3-rdu2.redhat.com (HELO mx1.redhat.com) (66.187.233.73) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Tue, 14 Aug 2018 00:11:55 +0000 Received: from smtp.corp.redhat.com (int-mx04.intmail.prod.int.rdu2.redhat.com [10.11.54.4]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 08785B5C5 for ; Tue, 14 Aug 2018 00:11:54 +0000 (UTC) Received: from pinnacle.lan (ovpn-116-70.phx2.redhat.com [10.3.116.70]) by smtp.corp.redhat.com (Postfix) with ESMTPS id B9EE62026D68 for ; Tue, 14 Aug 2018 00:11:53 +0000 (UTC) Date: Mon, 13 Aug 2018 17:11:52 -0700 From: Kevin Buettner To: gdb-patches@sourceware.org Subject: [PATCH v2 6/8] Introduce find_pc_partial_entry_range and use it in infrun.c Message-ID: <20180813171152.093a67aa@pinnacle.lan> In-Reply-To: <20180813165002.29ddb8dd@pinnacle.lan> References: <20180813165002.29ddb8dd@pinnacle.lan> MIME-Version: 1.0 X-IsSubscribed: yes An earlier version of this patch used the returned block in conjunction with BLOCK_ENTRY_PC to set stop_func_start in fill_in_stop_func() in infrun.c. While I think this was the correct thing to do, changes to find_inferior_partial_function could potentially end up with stop_func_end < stop_func_start, which is definitely wrong. For this case, we want to set both stop_func_start and stop_func_end to the start and end of the range containing the function's entry pc. I think that this functionality will be useful in many other places too - it probably ought to be used in all of the various prologue analyzers in GDB. The change to infrun.c was simple: the call to find_pc_partial_function was replaced with a call to find_pc_partial_entry_range. The difference between these two functions is that find_pc_partial_entry_function will (potentially) return the start and end address corresponding to the range in which PC is found, but find_pc_partial_entry_range will (again, potentially) return the start and end address of the range containing the entry pc. find_pc_partial_function has the property that *ADDRESS <= PC < *ENDADDR. This condition does not necessarily hold for the outputs of find_pc_partial_entry_range. It should be noted that for functions which contain only a single range, the outputs of find_pc_partial_{function,entry_range} are identical. I think it might happen that find_pc_partial_entry_range will come to be used in place of many of the calls to find_pc_partial_function within GDB. Care must be taken in making this change, however, since some of this code depends on the *ADDRESS <= PC < *ENDADDR property. gdb/ChangeLog: * infrun.c (fill_in_stop_func): Use find_pc_partial_entry_range in place of find_pc_partial_function. * blockframe.c (find_pc_partial_entry_range): New function. * symtab.h (find_pc_partial_entry_range): Declare and document. --- gdb/blockframe.c | 37 +++++++++++++++++++++++++++++++++++++ gdb/infrun.c | 6 ++++-- gdb/symtab.h | 20 +++++++++++++++++++- 3 files changed, 60 insertions(+), 3 deletions(-) diff --git a/gdb/blockframe.c b/gdb/blockframe.c index 05ff2aa..38006aa 100644 --- a/gdb/blockframe.c +++ b/gdb/blockframe.c @@ -345,6 +345,43 @@ find_pc_partial_function (CORE_ADDR pc, const char **name, CORE_ADDR *address, /* See symtab.h. */ +bool +find_pc_partial_entry_range (CORE_ADDR pc, const char **name, + CORE_ADDR *address, CORE_ADDR *endaddr) +{ + const struct block *block; + bool status = find_pc_partial_function (pc, name, address, endaddr, &block); + + if (status && block != nullptr && !BLOCK_CONTIGUOUS_P (block)) + { + CORE_ADDR entry_pc = BLOCK_ENTRY_PC (block); + + for (int i = 0; i < BLOCK_NRANGES (block); i++) + { + if (BLOCK_RANGE_START (block, i) <= entry_pc + && entry_pc < BLOCK_RANGE_END (block, i)) + { + if (address != nullptr) + *address = BLOCK_RANGE_START (block, i); + + if (endaddr != nullptr) + *endaddr = BLOCK_RANGE_END (block, i); + + return status; + } + } + + /* It's an internal error if we exit the above loop without finding + the range. */ + internal_error (__FILE__, __LINE__, + _("Entry block not found in find_pc_partial_entry_range")); + } + + return status; +} + +/* See symtab.h. */ + struct type * find_function_type (CORE_ADDR pc) { diff --git a/gdb/infrun.c b/gdb/infrun.c index f455af2..027de22 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -4297,10 +4297,12 @@ fill_in_stop_func (struct gdbarch *gdbarch, { if (!ecs->stop_func_filled_in) { + /* Don't care about return value; stop_func_start and stop_func_name will both be 0 if it doesn't work. */ - find_pc_partial_function (stop_pc, &ecs->stop_func_name, - &ecs->stop_func_start, &ecs->stop_func_end); + find_pc_partial_entry_range (stop_pc, &ecs->stop_func_name, + &ecs->stop_func_start, &ecs->stop_func_end); + ecs->stop_func_start += gdbarch_deprecated_function_start_offset (gdbarch); diff --git a/gdb/symtab.h b/gdb/symtab.h index e518603..ff598c6 100644 --- a/gdb/symtab.h +++ b/gdb/symtab.h @@ -1714,12 +1714,30 @@ extern struct symbol *find_symbol_at_address (CORE_ADDR); This might suggest that *ADDRESS and *ENDADDR ought to be set to the limits of the entry pc range, but that will cause the *ADDRESS <= PC < *ENDADDR condition to be violated; many of the - callers of find_pc_partial_function expect this condition to hold. */ + callers of find_pc_partial_function expect this condition to hold. + + Callers which require the start and/or end addresses for the range + containing the entry pc should instead call + find_pc_partial_entry_range. */ extern int find_pc_partial_function (CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr, const struct block **block = nullptr); +/* Like find_pc_partial_function, above, but *ADDRESS and *ENDADDR are + set to start and end addresses of the range containing the entry pc. + + Note that it is not necessarily the case that (for non-NULL ADDRESS + and ENDADDR arguments) the *ADDRESS <= PC < *ENDADDR condition will + hold. + + See comment for find_pc_partial_function, above, for further + explanation. */ + +extern bool find_pc_partial_entry_range (CORE_ADDR pc, const char **name, + CORE_ADDR *address, + CORE_ADDR *endaddr); + /* Return the type of a function with its first instruction exactly at the PC address. Return NULL otherwise. */