From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 32660 invoked by alias); 13 Jan 2014 19:57:41 -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 32651 invoked by uid 89); 13 Jan 2014 19:57:41 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-3.0 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 ESMTP; Mon, 13 Jan 2014 19:57:39 +0000 Received: from int-mx09.intmail.prod.int.phx2.redhat.com (int-mx09.intmail.prod.int.phx2.redhat.com [10.5.11.22]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id s0DJD3YM004095 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK) for ; Mon, 13 Jan 2014 14:13:03 -0500 Received: from barimba.redhat.com (ovpn-113-85.phx2.redhat.com [10.3.113.85]) by int-mx09.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id s0DJCptL016701; Mon, 13 Jan 2014 14:13:03 -0500 From: Tom Tromey To: gdb-patches@sourceware.org Cc: Tom Tromey Subject: [RFC 15/32] Add target_ops argument to to_disable_tracepoint Date: Mon, 13 Jan 2014 19:57:00 -0000 Message-Id: <1389640367-5571-16-git-send-email-tromey@redhat.com> In-Reply-To: <1389640367-5571-1-git-send-email-tromey@redhat.com> References: <1389640367-5571-1-git-send-email-tromey@redhat.com> X-SW-Source: 2014-01/txt/msg00369.txt.bz2 2014-01-08 Tom Tromey * target.h (struct target_ops) : Add argument. (target_disable_tracepoint): Add argument. * target.c (update_current_target): Update. * remote.c (remote_disable_tracepoint): Add 'self' argument. Add target_ops argument to to_trace_set_readonly_regions 2014-01-08 Tom Tromey * target.h (struct target_ops) : Add argument. (target_trace_set_readonly_regions): Add argument. * target.c (update_current_target): Update. * remote.c (remote_trace_set_readonly_regions): Add 'self' argument. Add target_ops argument to to_trace_start 2014-01-08 Tom Tromey * target.h (struct target_ops) : Add argument. (target_trace_start): Add argument. * target.c (update_current_target): Update. * remote.c (remote_trace_start): Add 'self' argument. Add target_ops argument to to_get_trace_status 2014-01-08 Tom Tromey * tracepoint.c (tfile_get_trace_status): Add 'self' argument. * target.h (struct target_ops) : Add argument. (target_get_trace_status): Add argument. * target.c (update_current_target): Update. * remote.c (remote_get_trace_status): Add 'self' argument. (remote_start_remote, remote_can_download_tracepoint): Update. * ctf.c (ctf_get_trace_status): Add 'self' argument. Add target_ops argument to to_get_tracepoint_status 2014-01-08 Tom Tromey * tracepoint.c (tfile_get_tracepoint_status): Add 'self' argument. * target.h (struct target_ops) : Add argument. (target_get_tracepoint_status): Add argument. * target.c (update_current_target): Update. * remote.c (remote_get_tracepoint_status): Add 'self' argument. Add target_ops argument to to_trace_stop 2014-01-08 Tom Tromey * target.h (struct target_ops) : Add argument. (target_trace_stop): Add argument. * target.c (update_current_target): Update. * remote.c (remote_trace_stop): Add 'self' argument. Add target_ops argument to to_trace_find 2014-01-08 Tom Tromey * tracepoint.c (tfile_trace_find): Add 'self' argument. * target.h (struct target_ops) : Add argument. (target_trace_find): Add argument. * target.c (update_current_target): Update. * remote.c (remote_trace_find): Add 'self' argument. * ctf.c (ctf_trace_find): Add 'self' argument. Add target_ops argument to to_get_trace_state_variable_value 2014-01-08 Tom Tromey * tracepoint.c (tfile_get_trace_state_variable_value): Add 'self' argument. * target.h (struct target_ops) : Add argument. (target_get_trace_state_variable_value): Add argument. * target.c (update_current_target): Update. * remote.c (remote_get_trace_state_variable_value): Add 'self' argument. * ctf.c (ctf_get_trace_state_variable_value): Add 'self' argument. Add target_ops argument to to_save_trace_data 2014-01-08 Tom Tromey * target.h (struct target_ops) : Add argument. (target_save_trace_data): Add argument. * target.c (update_current_target): Update. * remote.c (remote_save_trace_data): Add 'self' argument. Add target_ops argument to to_upload_tracepoints 2014-01-08 Tom Tromey * target.h (struct target_ops) : Add argument. (target_upload_tracepoints): Add argument. * target.c (update_current_target): Update. * remote.c (remote_upload_tracepoints): Add 'self' argument. (remote_start_remote): Update. --- gdb/ChangeLog | 88 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ gdb/ctf.c | 7 +++-- gdb/remote.c | 37 +++++++++++++----------- gdb/target.c | 22 +++++++------- gdb/target.h | 47 +++++++++++++++++------------- gdb/tracepoint.c | 10 ++++--- 6 files changed, 158 insertions(+), 53 deletions(-) diff --git a/gdb/ctf.c b/gdb/ctf.c index 239afb2..db6032b 100644 --- a/gdb/ctf.c +++ b/gdb/ctf.c @@ -1489,7 +1489,8 @@ ctf_xfer_partial (struct target_ops *ops, enum target_object object, true, otherwise return false. */ static int -ctf_get_trace_state_variable_value (int tsvnum, LONGEST *val) +ctf_get_trace_state_variable_value (struct target_ops *self, + int tsvnum, LONGEST *val) { struct bt_iter_pos *pos; int found = 0; @@ -1606,7 +1607,7 @@ ctf_get_traceframe_address (void) number in it. Return traceframe number when matched. */ static int -ctf_trace_find (enum trace_find_type type, int num, +ctf_trace_find (struct target_ops *self, enum trace_find_type type, int num, CORE_ADDR addr1, CORE_ADDR addr2, int *tpp) { int ret = -1; @@ -1801,7 +1802,7 @@ ctf_traceframe_info (void) The trace status for a file is that tracing can never be run. */ static int -ctf_get_trace_status (struct trace_status *ts) +ctf_get_trace_status (struct target_ops *self, struct trace_status *ts) { /* Other bits of trace status were collected as part of opening the trace files, so nothing to do here. */ diff --git a/gdb/remote.c b/gdb/remote.c index b81501d..8ad8409 100644 --- a/gdb/remote.c +++ b/gdb/remote.c @@ -205,9 +205,11 @@ static ptid_t read_ptid (char *buf, char **obuf); static void remote_set_permissions (void); struct remote_state; -static int remote_get_trace_status (struct trace_status *ts); +static int remote_get_trace_status (struct target_ops *self, + struct trace_status *ts); -static int remote_upload_tracepoints (struct uploaded_tp **utpp); +static int remote_upload_tracepoints (struct target_ops *self, + struct uploaded_tp **utpp); static int remote_upload_trace_state_variables (struct uploaded_tsv **utsvp); @@ -3481,7 +3483,7 @@ remote_start_remote (int from_tty, struct target_ops *target, int extended_p) /* Upload TSVs regardless of whether the target is running or not. The remote stub, such as GDBserver, may have some predefined or builtin TSVs, even if the target is not running. */ - if (remote_get_trace_status (current_trace_status ()) != -1) + if (remote_get_trace_status (target, current_trace_status ()) != -1) { struct uploaded_tsv *uploaded_tsvs = NULL; @@ -3625,14 +3627,14 @@ remote_start_remote (int from_tty, struct target_ops *target, int extended_p) /* Possibly the target has been engaged in a trace run started previously; find out where things are at. */ - if (remote_get_trace_status (current_trace_status ()) != -1) + if (remote_get_trace_status (target, current_trace_status ()) != -1) { struct uploaded_tp *uploaded_tps = NULL; if (current_trace_status ()->running) printf_filtered (_("Trace is already running on the target.\n")); - remote_upload_tracepoints (&uploaded_tps); + remote_upload_tracepoints (target, &uploaded_tps); merge_uploaded_tracepoints (&uploaded_tps); } @@ -10722,7 +10724,7 @@ remote_can_download_tracepoint (struct target_ops *self) return 0; ts = current_trace_status (); - status = remote_get_trace_status (ts); + status = remote_get_trace_status (self, ts); if (status == -1 || !ts->running_known || !ts->running) return 0; @@ -10778,7 +10780,8 @@ remote_enable_tracepoint (struct target_ops *self, } static void -remote_disable_tracepoint (struct bp_location *location) +remote_disable_tracepoint (struct target_ops *self, + struct bp_location *location) { struct remote_state *rs = get_remote_state (); char addr_buf[40]; @@ -10795,7 +10798,7 @@ remote_disable_tracepoint (struct bp_location *location) } static void -remote_trace_set_readonly_regions (void) +remote_trace_set_readonly_regions (struct target_ops *self) { asection *s; bfd *abfd = NULL; @@ -10845,7 +10848,7 @@ Too many sections for read-only sections definition packet.")); } static void -remote_trace_start (void) +remote_trace_start (struct target_ops *self) { putpkt ("QTStart"); remote_get_noisy_reply (&target_buf, &target_buf_size); @@ -10856,7 +10859,7 @@ remote_trace_start (void) } static int -remote_get_trace_status (struct trace_status *ts) +remote_get_trace_status (struct target_ops *self, struct trace_status *ts) { /* Initialize it just to avoid a GCC false warning. */ char *p = NULL; @@ -10906,7 +10909,7 @@ remote_get_trace_status (struct trace_status *ts) } static void -remote_get_tracepoint_status (struct breakpoint *bp, +remote_get_tracepoint_status (struct target_ops *self, struct breakpoint *bp, struct uploaded_tp *utp) { struct remote_state *rs = get_remote_state (); @@ -10953,7 +10956,7 @@ remote_get_tracepoint_status (struct breakpoint *bp, } static void -remote_trace_stop (void) +remote_trace_stop (struct target_ops *self) { putpkt ("QTStop"); remote_get_noisy_reply (&target_buf, &target_buf_size); @@ -10964,7 +10967,8 @@ remote_trace_stop (void) } static int -remote_trace_find (enum trace_find_type type, int num, +remote_trace_find (struct target_ops *self, + enum trace_find_type type, int num, CORE_ADDR addr1, CORE_ADDR addr2, int *tpp) { @@ -11046,7 +11050,8 @@ remote_trace_find (enum trace_find_type type, int num, } static int -remote_get_trace_state_variable_value (int tsvnum, LONGEST *val) +remote_get_trace_state_variable_value (struct target_ops *self, + int tsvnum, LONGEST *val) { struct remote_state *rs = get_remote_state (); char *reply; @@ -11070,7 +11075,7 @@ remote_get_trace_state_variable_value (int tsvnum, LONGEST *val) } static int -remote_save_trace_data (const char *filename) +remote_save_trace_data (struct target_ops *self, const char *filename) { struct remote_state *rs = get_remote_state (); char *p, *reply; @@ -11779,7 +11784,7 @@ remote_new_objfile (struct objfile *objfile) collection. */ static int -remote_upload_tracepoints (struct uploaded_tp **utpp) +remote_upload_tracepoints (struct target_ops *self, struct uploaded_tp **utpp) { struct remote_state *rs = get_remote_state (); char *p; diff --git a/gdb/target.c b/gdb/target.c index 0ef4cdc..74e79cc 100644 --- a/gdb/target.c +++ b/gdb/target.c @@ -860,34 +860,36 @@ update_current_target (void) (void (*) (struct target_ops *, struct bp_location *)) tcomplain); de_fault (to_disable_tracepoint, - (void (*) (struct bp_location *)) + (void (*) (struct target_ops *, struct bp_location *)) tcomplain); de_fault (to_trace_set_readonly_regions, - (void (*) (void)) + (void (*) (struct target_ops *)) tcomplain); de_fault (to_trace_start, - (void (*) (void)) + (void (*) (struct target_ops *)) tcomplain); de_fault (to_get_trace_status, - (int (*) (struct trace_status *)) + (int (*) (struct target_ops *, struct trace_status *)) return_minus_one); de_fault (to_get_tracepoint_status, - (void (*) (struct breakpoint *, struct uploaded_tp *)) + (void (*) (struct target_ops *, struct breakpoint *, + struct uploaded_tp *)) tcomplain); de_fault (to_trace_stop, - (void (*) (void)) + (void (*) (struct target_ops *)) tcomplain); de_fault (to_trace_find, - (int (*) (enum trace_find_type, int, CORE_ADDR, CORE_ADDR, int *)) + (int (*) (struct target_ops *, + enum trace_find_type, int, CORE_ADDR, CORE_ADDR, int *)) return_minus_one); de_fault (to_get_trace_state_variable_value, - (int (*) (int, LONGEST *)) + (int (*) (struct target_ops *, int, LONGEST *)) return_zero); de_fault (to_save_trace_data, - (int (*) (const char *)) + (int (*) (struct target_ops *, const char *)) tcomplain); de_fault (to_upload_tracepoints, - (int (*) (struct uploaded_tp **)) + (int (*) (struct target_ops *, struct uploaded_tp **)) return_zero); de_fault (to_upload_trace_state_variables, (int (*) (struct uploaded_tsv **)) diff --git a/gdb/target.h b/gdb/target.h index 31a4ce9..e8a2997 100644 --- a/gdb/target.h +++ b/gdb/target.h @@ -757,41 +757,46 @@ struct target_ops struct bp_location *location); /* Disable a tracepoint on the target. */ - void (*to_disable_tracepoint) (struct bp_location *location); + void (*to_disable_tracepoint) (struct target_ops *, + struct bp_location *location); /* Inform the target info of memory regions that are readonly (such as text sections), and so it should return data from those rather than look in the trace buffer. */ - void (*to_trace_set_readonly_regions) (void); + void (*to_trace_set_readonly_regions) (struct target_ops *); /* Start a trace run. */ - void (*to_trace_start) (void); + void (*to_trace_start) (struct target_ops *); /* Get the current status of a tracing run. */ - int (*to_get_trace_status) (struct trace_status *ts); + int (*to_get_trace_status) (struct target_ops *, struct trace_status *ts); - void (*to_get_tracepoint_status) (struct breakpoint *tp, + void (*to_get_tracepoint_status) (struct target_ops *, + struct breakpoint *tp, struct uploaded_tp *utp); /* Stop a trace run. */ - void (*to_trace_stop) (void); + void (*to_trace_stop) (struct target_ops *); /* Ask the target to find a trace frame of the given type TYPE, using NUM, ADDR1, and ADDR2 as search parameters. Returns the number of the trace frame, and also the tracepoint number at TPP. If no trace frame matches, return -1. May throw if the operation fails. */ - int (*to_trace_find) (enum trace_find_type type, int num, + int (*to_trace_find) (struct target_ops *, + enum trace_find_type type, int num, CORE_ADDR addr1, CORE_ADDR addr2, int *tpp); /* Get the value of the trace state variable number TSV, returning 1 if the value is known and writing the value itself into the location pointed to by VAL, else returning 0. */ - int (*to_get_trace_state_variable_value) (int tsv, LONGEST *val); + int (*to_get_trace_state_variable_value) (struct target_ops *, + int tsv, LONGEST *val); - int (*to_save_trace_data) (const char *filename); + int (*to_save_trace_data) (struct target_ops *, const char *filename); - int (*to_upload_tracepoints) (struct uploaded_tp **utpp); + int (*to_upload_tracepoints) (struct target_ops *, + struct uploaded_tp **utpp); int (*to_upload_trace_state_variables) (struct uploaded_tsv **utsvp); @@ -1759,34 +1764,36 @@ extern char *target_fileio_read_stralloc (const char *filename); (*current_target.to_enable_tracepoint) (¤t_target, loc) #define target_disable_tracepoint(loc) \ - (*current_target.to_disable_tracepoint) (loc) + (*current_target.to_disable_tracepoint) (¤t_target, loc) #define target_trace_start() \ - (*current_target.to_trace_start) () + (*current_target.to_trace_start) (¤t_target) #define target_trace_set_readonly_regions() \ - (*current_target.to_trace_set_readonly_regions) () + (*current_target.to_trace_set_readonly_regions) (¤t_target) #define target_get_trace_status(ts) \ - (*current_target.to_get_trace_status) (ts) + (*current_target.to_get_trace_status) (¤t_target, ts) #define target_get_tracepoint_status(tp,utp) \ - (*current_target.to_get_tracepoint_status) (tp, utp) + (*current_target.to_get_tracepoint_status) (¤t_target, tp, utp) #define target_trace_stop() \ - (*current_target.to_trace_stop) () + (*current_target.to_trace_stop) (¤t_target) #define target_trace_find(type,num,addr1,addr2,tpp) \ - (*current_target.to_trace_find) ((type), (num), (addr1), (addr2), (tpp)) + (*current_target.to_trace_find) (¤t_target, \ + (type), (num), (addr1), (addr2), (tpp)) #define target_get_trace_state_variable_value(tsv,val) \ - (*current_target.to_get_trace_state_variable_value) ((tsv), (val)) + (*current_target.to_get_trace_state_variable_value) (¤t_target, \ + (tsv), (val)) #define target_save_trace_data(filename) \ - (*current_target.to_save_trace_data) (filename) + (*current_target.to_save_trace_data) (¤t_target, filename) #define target_upload_tracepoints(utpp) \ - (*current_target.to_upload_tracepoints) (utpp) + (*current_target.to_upload_tracepoints) (¤t_target, utpp) #define target_upload_trace_state_variables(utsvp) \ (*current_target.to_upload_trace_state_variables) (utsvp) diff --git a/gdb/tracepoint.c b/gdb/tracepoint.c index a09bf37..0fde73c 100644 --- a/gdb/tracepoint.c +++ b/gdb/tracepoint.c @@ -4773,7 +4773,7 @@ tfile_files_info (struct target_ops *t) /* The trace status for a file is that tracing can never be run. */ static int -tfile_get_trace_status (struct trace_status *ts) +tfile_get_trace_status (struct target_ops *self, struct trace_status *ts) { /* Other bits of trace status were collected as part of opening the trace files, so nothing to do here. */ @@ -4782,7 +4782,8 @@ tfile_get_trace_status (struct trace_status *ts) } static void -tfile_get_tracepoint_status (struct breakpoint *tp, struct uploaded_tp *utp) +tfile_get_tracepoint_status (struct target_ops *self, + struct breakpoint *tp, struct uploaded_tp *utp) { /* Other bits of trace status were collected as part of opening the trace files, so nothing to do here. */ @@ -4827,7 +4828,7 @@ tfile_get_traceframe_address (off_t tframe_offset) each. */ static int -tfile_trace_find (enum trace_find_type type, int num, +tfile_trace_find (struct target_ops *self, enum trace_find_type type, int num, CORE_ADDR addr1, CORE_ADDR addr2, int *tpp) { short tpnum; @@ -5186,7 +5187,8 @@ tfile_xfer_partial (struct target_ops *ops, enum target_object object, block with a matching tsv number. */ static int -tfile_get_trace_state_variable_value (int tsvnum, LONGEST *val) +tfile_get_trace_state_variable_value (struct target_ops *self, + int tsvnum, LONGEST *val) { int pos; int found = 0; -- 1.8.1.4