From patchwork Fri Nov 18 15:52:52 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Torbjorn SVENSSON X-Patchwork-Id: 60836 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 600D5384D98B for ; Fri, 18 Nov 2022 15:54:26 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 600D5384D98B DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1668786866; bh=qJdTyUnFBrFGQyYpt/6GddPn19rNxpurYxcOUEnsCG8=; h=To:CC:Subject:Date:In-Reply-To:References:List-Id: List-Unsubscribe:List-Archive:List-Post:List-Help:List-Subscribe: From:Reply-To:From; b=jhIAKP/jJcT4mG/yCBly3zIVfn896M2ictPgjzvGTkZVfsVJMHJudV5PYAQlfbOW7 Y2Vh5jWh5Jn/oJ06KASmZaKOz6JPKKqcjZKuGPhUVJ3mC+8CdcPwDS8bmGk5iR+cKT WVBEWsN4uVq2A/CN1IBhIlwM69lxohQJs1sqPHCI= X-Original-To: gdb-patches@sourceware.org Delivered-To: gdb-patches@sourceware.org Received: from mx07-00178001.pphosted.com (mx07-00178001.pphosted.com [185.132.182.106]) by sourceware.org (Postfix) with ESMTPS id CF0AA385457F for ; Fri, 18 Nov 2022 15:53:48 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org CF0AA385457F Received: from pps.filterd (m0288072.ppops.net [127.0.0.1]) by mx07-00178001.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 2AICS16A014845; Fri, 18 Nov 2022 16:53:46 +0100 Received: from beta.dmz-eu.st.com (beta.dmz-eu.st.com [164.129.1.35]) by mx07-00178001.pphosted.com (PPS) with ESMTPS id 3kx0ph4t0c-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Fri, 18 Nov 2022 16:53:46 +0100 Received: from euls16034.sgp.st.com (euls16034.sgp.st.com [10.75.44.20]) by beta.dmz-eu.st.com (STMicroelectronics) with ESMTP id 8388C10003B; Fri, 18 Nov 2022 16:53:41 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node3.st.com [10.75.129.71]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id 7C63523C68D; Fri, 18 Nov 2022 16:53:41 +0100 (CET) Received: from jkgcxl0002.jkg.st.com (10.210.54.218) by SHFDAG1NODE3.st.com (10.75.129.71) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.6; Fri, 18 Nov 2022 16:53:40 +0100 To: CC: , , =?utf-8?q?Torbj=C3=B6rn_SVENS?= =?utf-8?q?SON?= , Yvan Roux Subject: [PATCH v2 3/4] gdb: dwarf2 generic implementation for caching function data Date: Fri, 18 Nov 2022 16:52:52 +0100 Message-ID: <20221118155252.113476-4-torbjorn.svensson@foss.st.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20221118155252.113476-1-torbjorn.svensson@foss.st.com> References: <20221118155252.113476-1-torbjorn.svensson@foss.st.com> MIME-Version: 1.0 X-Originating-IP: [10.210.54.218] X-ClientProxiedBy: EQNCAS1NODE3.st.com (10.75.129.80) To SHFDAG1NODE3.st.com (10.75.129.71) X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.895,Hydra:6.0.545,FMLib:17.11.122.1 definitions=2022-11-18_04,2022-11-18_01,2022-06-22_01 X-Spam-Status: No, score=-11.8 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, GIT_PATCH_0, RCVD_IN_DNSWL_LOW, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: =?utf-8?q?Torbj=C3=B6rn_SVENSSON_via_Gdb-patches?= From: Torbjorn SVENSSON Reply-To: =?utf-8?q?Torbj=C3=B6rn_SVENSSON?= Errors-To: gdb-patches-bounces+patchwork=sourceware.org@sourceware.org Sender: "Gdb-patches" When there is no dwarf2 data for a register, a function can be called to provide the value of this register. In some situations, it might not be trivial to determine the value to return and it would cause a performance bottleneck to do the computation each time. This patch allows the called function to have a "cache" object that it can use to store some metadata between calls to reduce the performance impact of the complex logic. The cache object is unique for each function and frame, so if there are more than one function pointer stored in the dwarf2_frame_cache->reg array, then the appropriate pointer will be supplied (the type is not known by the dwarf2 implementation). dwarf2_frame_get_fn_data can be used to retrieve the function unique cache object. dwarf2_frame_allocate_fn_data can be used to allocate and retrieve the function unqiue cache object. Signed-off-by: Torbjörn SVENSSON Signed-off-by: Yvan Roux --- gdb/dwarf2/frame.c | 48 ++++++++++++++++++++++++++++++++++++++++++++++ gdb/dwarf2/frame.h | 20 +++++++++++++++++-- 2 files changed, 66 insertions(+), 2 deletions(-) diff --git a/gdb/dwarf2/frame.c b/gdb/dwarf2/frame.c index 3f884abe1d5..bff3b706e7e 100644 --- a/gdb/dwarf2/frame.c +++ b/gdb/dwarf2/frame.c @@ -831,6 +831,14 @@ dwarf2_fetch_cfa_info (struct gdbarch *gdbarch, CORE_ADDR pc, } +struct dwarf2_frame_fn_data +{ + struct value *(*fn) (frame_info_ptr this_frame, void **this_cache, + int regnum); + void *data; + struct dwarf2_frame_fn_data* next; +}; + struct dwarf2_frame_cache { /* DWARF Call Frame Address. */ @@ -862,6 +870,8 @@ struct dwarf2_frame_cache dwarf2_tailcall_frame_unwind unwinder so this field does not apply for them. */ void *tailcall_cache; + + struct dwarf2_frame_fn_data *fn_data; }; static struct dwarf2_frame_cache * @@ -1221,6 +1231,44 @@ dwarf2_frame_prev_register (frame_info_ptr this_frame, void **this_cache, } } +void *dwarf2_frame_get_fn_data (frame_info_ptr this_frame, void **this_cache, + fn_prev_register fn) +{ + struct dwarf2_frame_fn_data *fn_data = nullptr; + struct dwarf2_frame_cache *cache + = dwarf2_frame_cache (this_frame, this_cache); + + /* Find the object for the function. */ + for (fn_data = cache->fn_data; fn_data; fn_data = fn_data->next) + if (fn_data->fn == fn) + return fn_data->data; + + return nullptr; +} + +void *dwarf2_frame_allocate_fn_data (frame_info_ptr this_frame, + void **this_cache, + fn_prev_register fn, unsigned long size) +{ + struct dwarf2_frame_fn_data *fn_data = nullptr; + struct dwarf2_frame_cache *cache + = dwarf2_frame_cache (this_frame, this_cache); + + /* First try to find an existing object. */ + void *data = dwarf2_frame_get_fn_data (this_frame, this_cache, fn); + if (data) + return data; + + /* No object found, lets create a new instance. */ + fn_data = FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_fn_data); + fn_data->fn = fn; + fn_data->data = frame_obstack_zalloc (size); + fn_data->next = cache->fn_data; + cache->fn_data = fn_data; + + return fn_data->data; +} + /* Proxy for tailcall_frame_dealloc_cache for bottom frame of a virtual tail call frames chain. */ diff --git a/gdb/dwarf2/frame.h b/gdb/dwarf2/frame.h index 06c8a10c178..444afd9f8eb 100644 --- a/gdb/dwarf2/frame.h +++ b/gdb/dwarf2/frame.h @@ -66,6 +66,9 @@ enum dwarf2_frame_reg_rule /* Register state. */ +typedef struct value *(*fn_prev_register) (frame_info_ptr this_frame, + void **this_cache, int regnum); + struct dwarf2_frame_state_reg { /* Each register save state can be described in terms of a CFA slot, @@ -78,8 +81,7 @@ struct dwarf2_frame_state_reg const gdb_byte *start; ULONGEST len; } exp; - struct value *(*fn) (frame_info_ptr this_frame, void **this_cache, - int regnum); + fn_prev_register fn; } loc; enum dwarf2_frame_reg_rule how; }; @@ -262,4 +264,18 @@ extern int dwarf2_fetch_cfa_info (struct gdbarch *gdbarch, CORE_ADDR pc, const gdb_byte **cfa_start_out, const gdb_byte **cfa_end_out); + +/* Allocate a new instance of the function unique data. */ + +extern void *dwarf2_frame_allocate_fn_data (frame_info_ptr this_frame, + void **this_cache, + fn_prev_register fn, + unsigned long size); + +/* Retrieve the function unique data for this frame. */ + +extern void *dwarf2_frame_get_fn_data (frame_info_ptr this_frame, + void **this_cache, + fn_prev_register fn); + #endif /* dwarf2-frame.h */