From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 28984 invoked by alias); 18 Jul 2014 19:27:23 -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 28737 invoked by uid 89); 18 Jul 2014 19:27:22 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.8 required=5.0 tests=AWL,BAYES_00,RP_MATCHES_RCVD,SPF_HELO_PASS,SPF_PASS autolearn=ham version=3.3.2 X-HELO: mx1.redhat.com Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES256-GCM-SHA384 encrypted) ESMTPS; Fri, 18 Jul 2014 19:27:21 +0000 Received: from int-mx14.intmail.prod.int.phx2.redhat.com (int-mx14.intmail.prod.int.phx2.redhat.com [10.5.11.27]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id s6IJRKwQ028249 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK) for ; Fri, 18 Jul 2014 15:27:20 -0400 Received: from barimba.redhat.com (ovpn-113-27.phx2.redhat.com [10.3.113.27]) by int-mx14.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id s6IJRHfv019114; Fri, 18 Jul 2014 15:27:19 -0400 From: Tom Tromey To: gdb-patches@sourceware.org Cc: Tom Tromey Subject: [PATCH 3/4] add to_identity Date: Fri, 18 Jul 2014 19:45:00 -0000 Message-Id: <1405711635-1102-4-git-send-email-tromey@redhat.com> In-Reply-To: <1405711635-1102-1-git-send-email-tromey@redhat.com> References: <1405711635-1102-1-git-send-email-tromey@redhat.com> X-SW-Source: 2014-07/txt/msg00516.txt.bz2 Right now a target_ops has an odd sense of identity. Most times some identity is needed, a pointer to a static object is passed in. For example, calls to unpush_target generally work like this: unpush_target (&exec_ops); Conceptually this is a kind of "instanceof" checking. Now, consider this with "to_xclose" targets. In this case the target_ops is allocated on the heap and there's no good way to talk about the identity. Code could remember the pointer, of course, but this usually just begs the question. For example in a to_open implementation it is reasonably normal to check target_is_pushed and then do nothing if the target is pushed. However, there's no reasonable way way to do this with a to_xclose target. This patch introduces a to_identity field that just points to the "prototype" implementation of a target_ops. This lets us convert targets to to_xclose without difficulty. 2014-07-18 Tom Tromey * bfd-target.c (target_bfd_reopen): Set to_identity. * target.c (complete_target_initialization): Set to_identity. (unpush_target): Check to_identity. Call target_close on the real target. (target_is_pushed): Check to_identity. * target.h (struct target_ops) : New field. --- gdb/ChangeLog | 9 +++++++++ gdb/bfd-target.c | 1 + gdb/target.c | 8 +++++--- gdb/target.h | 6 ++++++ 4 files changed, 21 insertions(+), 3 deletions(-) diff --git a/gdb/bfd-target.c b/gdb/bfd-target.c index 519d5e7..d392762 100644 --- a/gdb/bfd-target.c +++ b/gdb/bfd-target.c @@ -98,6 +98,7 @@ target_bfd_reopen (struct bfd *abfd) t->to_xclose = target_bfd_xclose; t->to_data = data; t->to_magic = OPS_MAGIC; + t->to_identity = t; return t; } diff --git a/gdb/target.c b/gdb/target.c index 3d28f85..6a10c04 100644 --- a/gdb/target.c +++ b/gdb/target.c @@ -342,6 +342,8 @@ complete_target_initialization (struct target_ops *t) gdb_assert (t->to_can_run == NULL || (t->to_can_async_p != NULL && t->to_supports_non_stop != NULL)); + t->to_identity = t; + install_delegators (t); } @@ -602,7 +604,7 @@ unpush_target (struct target_ops *t) for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath) { - if ((*cur) == t) + if ((*cur) == t || (*cur)->to_identity == t) break; } @@ -621,7 +623,7 @@ unpush_target (struct target_ops *t) /* Finally close the target. Note we do this after unchaining, so any target method calls from within the target_close implementation don't end up in T anymore. */ - target_close (t); + target_close (tmp); return 1; } @@ -668,7 +670,7 @@ target_is_pushed (struct target_ops *t) } for (cur = target_stack; cur != NULL; cur = cur->beneath) - if (cur == t) + if (cur == t || cur->to_identity == t) return 1; return 0; diff --git a/gdb/target.h b/gdb/target.h index 92572ff..58c7b30 100644 --- a/gdb/target.h +++ b/gdb/target.h @@ -1135,6 +1135,12 @@ struct target_ops void (*to_done_generating_core) (struct target_ops *) TARGET_DEFAULT_IGNORE (); + /* This points to an "original" target_ops from which a particular + instance may have been cloned. This is usedful if a to_xclose + target clones some other target_ops, but still wants to call + target_is_pushed or unpush_target. */ + struct target_ops *to_identity; + int to_magic; /* Need sub-structure for target machine related rather than comm related? */ -- 1.9.3