From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 17798 invoked by alias); 23 Oct 2013 08:29:15 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Received: (qmail 17740 invoked by uid 89); 23 Oct 2013 08:29:14 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.0 required=5.0 tests=AWL,BAYES_00 autolearn=ham version=3.3.2 X-HELO: relay1.mentorg.com Received: from relay1.mentorg.com (HELO relay1.mentorg.com) (192.94.38.131) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Wed, 23 Oct 2013 08:29:12 +0000 Received: from svr-orw-fem-01.mgc.mentorg.com ([147.34.98.93]) by relay1.mentorg.com with esmtp id 1VYtoT-0006Vb-Gt from Yao_Qi@mentor.com for gdb-patches@sourceware.org; Wed, 23 Oct 2013 01:29:09 -0700 Received: from SVR-ORW-FEM-02.mgc.mentorg.com ([147.34.96.206]) by svr-orw-fem-01.mgc.mentorg.com over TLS secured channel with Microsoft SMTPSVC(6.0.3790.4675); Wed, 23 Oct 2013 01:29:09 -0700 Received: from qiyao.dyndns.dyndns.org (147.34.91.1) by svr-orw-fem-02.mgc.mentorg.com (147.34.96.168) with Microsoft SMTP Server id 14.2.247.3; Wed, 23 Oct 2013 01:29:08 -0700 From: Yao Qi To: Subject: [PATCH 2/5] Associate target_dcache to address_space. Date: Wed, 23 Oct 2013 08:29:00 -0000 Message-ID: <1382516855-32218-3-git-send-email-yao@codesourcery.com> In-Reply-To: <1382516855-32218-1-git-send-email-yao@codesourcery.com> References: <1382516855-32218-1-git-send-email-yao@codesourcery.com> MIME-Version: 1.0 Content-Type: text/plain X-IsSubscribed: yes X-SW-Source: 2013-10/txt/msg00712.txt.bz2 Hi, Nowadays, 'target_dcache' is a global variable in GDB, which is not necessary. It can be a per-address-space variable. In this patch, we add a new structure 'target_dcache', which includes all dcaches of target and all of them are per-address-space. There is one field 'general' which is equivalent to current variable 'target_dcache'. I thought to name it 'stack', but it also cache memory regions marked by attributes, I choose 'general'. gdb: 2013-10-23 Yao Qi * progspace.h (struct address_space): Declare. (current_address_space): New macro. * target.c (target_dcache_aspace_key): New. (target_dcache): Delete. (struct target_dcache): New. (target_dcache_alloc): New function. (target_dcache_xfree): New function. (target_dcache_get): New function. (target_dcache_cleanup)): New function. (target_dcache_invalidate): Update. (memory_xfer_partial_1): Update. (initialize_targets): Initialize target_dcache_aspace_key. --- gdb/progspace.h | 4 ++ gdb/target.c | 89 ++++++++++++++++++++++++++++++++++++++++++++++++------- 2 files changed, 82 insertions(+), 11 deletions(-) diff --git a/gdb/progspace.h b/gdb/progspace.h index 3735202..c5098e5 100644 --- a/gdb/progspace.h +++ b/gdb/progspace.h @@ -32,6 +32,7 @@ struct objfile; struct inferior; struct exec; struct program_space_data; +struct address_space_data; typedef struct so_list *so_list_ptr; DEF_VEC_P (so_list_ptr); @@ -239,6 +240,9 @@ extern struct program_space *program_spaces; /* The current program space. This is always non-null. */ extern struct program_space *current_program_space; +/* The current added space. */ +#define current_address_space current_program_space->aspace + #define ALL_PSPACES(pspace) \ for ((pspace) = program_spaces; (pspace) != NULL; (pspace) = (pspace)->next) diff --git a/gdb/target.c b/gdb/target.c index 22d7fb6..2ae42a8 100644 --- a/gdb/target.c +++ b/gdb/target.c @@ -206,6 +206,72 @@ show_targetdebug (struct ui_file *file, int from_tty, static void setup_target_debug (void); +/* The target dcache is kept per-address-space. This key lets us + associate the cache with the address space. */ + +static const struct address_space_data *target_dcache_aspace_key; + +/* dcache for target memory. */ + +struct target_dcache +{ + /* Cache the memory on stack and areas specified by memory + attributes. */ + DCACHE *general; +}; + +/* Allocate an instance of struct target_dcache. */ + +static struct target_dcache * +target_dcache_alloc (void) +{ + struct target_dcache *dcache = xmalloc (sizeof (*dcache)); + + dcache->general = dcache_init (); + + return dcache; +} + +/* Free DCACHE and its fields. */ + +static void +target_dcache_xfree (struct target_dcache *dcache) +{ + if (dcache != NULL) + { + dcache_free (dcache->general); + xfree (dcache); + } +} + +/* Get an instance of struct target_dcache. */ + +static struct target_dcache * +target_dcache_get (void) +{ + struct target_dcache *dcache + = address_space_data (current_address_space, target_dcache_aspace_key); + + if (dcache == NULL) + { + dcache = target_dcache_alloc (); + + set_address_space_data (current_address_space, + target_dcache_aspace_key, dcache); + } + + return dcache; +} + +static void +target_dcache_cleanup (struct address_space *aspace, void *arg) +{ + struct target_dcache *dcache + = address_space_data (aspace, target_dcache_aspace_key); + + target_dcache_xfree (dcache); +} + /* The option sets this. */ static int stack_cache_enabled_p_1 = 1; /* And set_stack_cache_enabled_p updates this. @@ -235,15 +301,14 @@ show_stack_cache_enabled_p (struct ui_file *file, int from_tty, fprintf_filtered (file, _("Cache use for stack accesses is %s.\n"), value); } -/* Cache of memory operations, to speed up remote access. */ -static DCACHE *target_dcache; - /* Invalidate the target dcache. */ void target_dcache_invalidate (void) { - dcache_invalidate (target_dcache); + struct target_dcache *td = target_dcache_get (); + + dcache_invalidate (td->general); } /* The user just typed 'target' without the name of a target. */ @@ -1589,14 +1654,14 @@ memory_xfer_partial_1 (struct target_ops *ops, enum target_object object, || (stack_cache_enabled_p && object == TARGET_OBJECT_STACK_MEMORY))) { if (readbuf != NULL) - res = dcache_xfer_memory (ops, target_dcache, memaddr, readbuf, - reg_len, 0); + res = dcache_xfer_memory (ops, target_dcache_get ()->general, + memaddr, readbuf, reg_len, 0); else /* FIXME drow/2006-08-09: If we're going to preserve const correctness dcache_xfer_memory should take readbuf and writebuf. */ - res = dcache_xfer_memory (ops, target_dcache, memaddr, - (void *) writebuf, + res = dcache_xfer_memory (ops, target_dcache_get ()->general, + memaddr, (void *) writebuf, reg_len, 1); if (res <= 0) return -1; @@ -1641,7 +1706,8 @@ memory_xfer_partial_1 (struct target_ops *ops, enum target_object object, && stack_cache_enabled_p && object != TARGET_OBJECT_STACK_MEMORY) { - dcache_update (target_dcache, memaddr, (void *) writebuf, res); + dcache_update (target_dcache_get ()->general, memaddr, + (void *) writebuf, res); } /* If we still haven't got anything, return the last error. We @@ -5187,6 +5253,7 @@ Otherwise, any attempt to interrupt or stop will be ignored."), set_target_permissions, NULL, &setlist, &showlist); - - target_dcache = dcache_init (); + target_dcache_aspace_key + = register_address_space_data_with_cleanup (NULL, + target_dcache_cleanup); } -- 1.7.7.6