From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mx07-00178001.pphosted.com (mx08-00178001.pphosted.com [91.207.212.93]) by sourceware.org (Postfix) with ESMTPS id 229433858C52 for ; Thu, 19 Jan 2023 10:30:46 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 229433858C52 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=foss.st.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=foss.st.com Received: from pps.filterd (m0046661.ppops.net [127.0.0.1]) by mx07-00178001.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 30J9EPDI032307; Thu, 19 Jan 2023 11:30:43 +0100 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=foss.st.com; h=from : to : cc : subject : date : message-id : mime-version : content-type : content-transfer-encoding; s=selector1; bh=GYs8FNyJQS7ZKwxcbkXX4f0KBbD2G3tCF8ztG3D7QTA=; b=RdEhN7FHVgQj1y7JXyZEdxZt1bj4oNmBH6An9xR4n2C+udOp3Tm4hk9FGJi3qmxQ+Um6 YqGkwYFX/WrkRyGEmJBznSdMwZPlKMLPKcq7/4/hzhIdSPLElPXpaPKOjVhC9ER1Y9Ew d7W/WUTFgU9sbrFDBe88eLo42rXKnZ3gEeqP0pcdClfuP6YF7+EgYb8YX2wL3BsM0J8Z gHR48rGXglxIjwNVtLmM411j9MlIfpvb5K03hJ7Nrj10XrzG11IO/2DEAeUCAVFTqBAu 3y+GEKpwEgvO2hS9v9gj3pMe6haRej22CGQIJ50lF0vcWQ1Fj3WkwKEga/yzSl6kwNU7 zw== 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 3n3m5qefdx-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Thu, 19 Jan 2023 11:30:43 +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 5264D100034; Thu, 19 Jan 2023 11:30:42 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node3.st.com [10.75.129.71]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id 22074214D3F; Thu, 19 Jan 2023 11:30:42 +0100 (CET) Received: from jkgcxl0004.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.13; Thu, 19 Jan 2023 11:30:41 +0100 From: =?UTF-8?q?Torbj=C3=B6rn=20SVENSSON?= To: CC: , , =?UTF-8?q?Torbj=C3=B6rn=20SVENSSON?= , Yvan Roux Subject: [PATCH v3 1/2] gdb: dwarf2 generic implementation for caching function data Date: Thu, 19 Jan 2023 11:29:48 +0100 Message-ID: <20230119102948.3069226-1-torbjorn.svensson@foss.st.com> X-Mailer: git-send-email 2.25.1 MIME-Version: 1.0 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: 8bit X-Originating-IP: [10.210.54.218] X-ClientProxiedBy: SHFCAS1NODE2.st.com (10.75.129.73) To SHFDAG1NODE3.st.com (10.75.129.71) X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.930,Hydra:6.0.562,FMLib:17.11.122.1 definitions=2023-01-19_07,2023-01-19_01,2022-06-22_01 X-Spam-Status: No, score=-11.7 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 List-Id: v2 -> v3: Addressed comments from Tom in https://sourceware.org/pipermail/gdb-patches/2023-January/195882.html --- 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 unique cache object. Signed-off-by: Torbjörn SVENSSON Signed-off-by: Yvan Roux --- gdb/dwarf2/frame.c | 61 ++++++++++++++++++++++++++++++++++++++++++++++ gdb/dwarf2/frame.h | 37 ++++++++++++++++++++++++++-- 2 files changed, 96 insertions(+), 2 deletions(-) diff --git a/gdb/dwarf2/frame.c b/gdb/dwarf2/frame.c index bd36a6c7fb4..a81b2500cb2 100644 --- a/gdb/dwarf2/frame.c +++ b/gdb/dwarf2/frame.c @@ -831,6 +831,22 @@ dwarf2_fetch_cfa_info (struct gdbarch *gdbarch, CORE_ADDR pc, } +/* Custom function data object for architecture specific prev_register + implementation. Main purpose of this object is to allow caching of + expensive data lookups in the prev_register handling. */ + +struct dwarf2_frame_fn_data +{ + /* The cookie to identify the custom function data by. */ + fn_prev_register cookie; + + /* The custom function data. */ + void *data; + + /* Pointer to the next custom function data object for this frame. */ + struct dwarf2_frame_fn_data *next; +}; + struct dwarf2_frame_cache { /* DWARF Call Frame Address. */ @@ -862,6 +878,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 +1239,49 @@ dwarf2_frame_prev_register (frame_info_ptr this_frame, void **this_cache, } } +/* See frame.h. */ + +void *dwarf2_frame_get_fn_data (frame_info_ptr this_frame, void **this_cache, + fn_prev_register cookie) +{ + 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->cookie == cookie) + return fn_data->data; + + return nullptr; +} + +/* See frame.h. */ + +void *dwarf2_frame_allocate_fn_data (frame_info_ptr this_frame, + void **this_cache, + fn_prev_register cookie, + 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, cookie); + if (data) + return data; + + /* No object found, lets create a new instance. */ + fn_data = FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_fn_data); + fn_data->cookie = cookie; + 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 4444c153741..5643e557513 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,35 @@ 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. + + The main purpose of this custom function data object is to allow caching the + value of expensive lookups in the prev_register implementation. + + THIS_FRAME is the frame that the custom data object should be associated + with. + THIS_CACHE is the dwarf2 cache object to store the pointer on. + COOKIE is the key for the prev_function implementation. + SIZE is the size of the custom data object to allocate. */ + +extern void *dwarf2_frame_allocate_fn_data (frame_info_ptr this_frame, + void **this_cache, + fn_prev_register cookie, + unsigned long size); + +/* Retrieve the function unique data for this frame or NULL if none exists. + + The main purpose of this custom function data object is to allow caching the + value of expensive lookups in the prev_register implementation. + + THIS_FRAME is the frame that the custom data object should be associated + with. + THIS_CACHE is the dwarf2 cache object to store the pointer on. + COOKIE is the key for the prev_function implementation. */ + +extern void *dwarf2_frame_get_fn_data (frame_info_ptr this_frame, + void **this_cache, + fn_prev_register cookie); + #endif /* dwarf2-frame.h */ -- 2.25.1