From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 2564 invoked by alias); 18 Aug 2013 19:07:14 -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 2555 invoked by uid 89); 18 Aug 2013 19:07:13 -0000 X-Spam-SWARE-Status: No, score=-7.7 required=5.0 tests=AWL,BAYES_00,RCVD_IN_HOSTKARMA_W,RCVD_IN_HOSTKARMA_WL,RP_MATCHES_RCVD,SPF_HELO_PASS,SPF_PASS autolearn=ham version=3.3.2 Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.84/v0.84-167-ge50287c) with ESMTP; Sun, 18 Aug 2013 19:07:12 +0000 Received: from int-mx11.intmail.prod.int.phx2.redhat.com (int-mx11.intmail.prod.int.phx2.redhat.com [10.5.11.24]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id r7IJ7B7j001062 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK); Sun, 18 Aug 2013 15:07:11 -0400 Received: from host2.jankratochvil.net (ovpn-116-37.ams2.redhat.com [10.36.116.37]) by int-mx11.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id r7IJ74P2009929 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES128-SHA bits=128 verify=NO); Sun, 18 Aug 2013 15:07:07 -0400 Date: Sun, 18 Aug 2013 19:07:00 -0000 From: Jan Kratochvil To: Markus Metzger Cc: gdb-patches@sourceware.org Subject: Re: [patch v4 09/24] btrace: add replay position to btrace thread info Message-ID: <20130818190704.GG24153@host2.jankratochvil.net> References: <1372842874-28951-1-git-send-email-markus.t.metzger@intel.com> <1372842874-28951-10-git-send-email-markus.t.metzger@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <1372842874-28951-10-git-send-email-markus.t.metzger@intel.com> User-Agent: Mutt/1.5.21 (2010-09-15) X-IsSubscribed: yes X-SW-Source: 2013-08/txt/msg00463.txt.bz2 On Wed, 03 Jul 2013 11:14:19 +0200, Markus Metzger wrote: > Add a branch trace instruction iterator pointing to the current replay position > to the branch trace thread info struct. > > Free the iterator when btrace is cleared. > > Start at the replay position for the instruction and function-call histories. > > 2013-07-03 Markus Metzger > > * btrace.h (replay) : New. > (btrace_is_replaying): New. > * btrace.c (btrace_clear): Free replay iterator. > (btrace_is_replaying): New. > * record-btrace.c (record_btrace_is_replaying): New. > (record_btrace_info): Print insn number if replaying. > (record_btrace_insn_history): Start at replay position. > (record_btrace_call_history): Start at replay position. > (init_record_btrace_ops): Init to_record_is_replaying. > > > --- > gdb/btrace.c | 10 ++++++ > gdb/btrace.h | 6 ++++ > gdb/record-btrace.c | 80 +++++++++++++++++++++++++++++++++++++++++++++----- > 3 files changed, 88 insertions(+), 8 deletions(-) > > diff --git a/gdb/btrace.c b/gdb/btrace.c > index 006deaa..0bec2cf 100644 > --- a/gdb/btrace.c > +++ b/gdb/btrace.c > @@ -771,9 +771,11 @@ btrace_clear (struct thread_info *tp) > > xfree (btinfo->insn_history); > xfree (btinfo->call_history); > + xfree (btinfo->replay); > > btinfo->insn_history = NULL; > btinfo->call_history = NULL; > + btinfo->replay = NULL; > } > > /* See btrace.h. */ > @@ -1371,3 +1373,11 @@ btrace_set_call_history (struct btrace_thread_info *btinfo, > btinfo->call_history->begin = *begin; > btinfo->call_history->end = *end; > } > + > +/* See btrace.h. */ > + > +int > +btrace_is_replaying (struct thread_info *tp) > +{ > + return tp->btrace.replay != NULL; > +} > diff --git a/gdb/btrace.h b/gdb/btrace.h > index a3322d2..5a5b297 100644 > --- a/gdb/btrace.h > +++ b/gdb/btrace.h > @@ -181,6 +181,9 @@ struct btrace_thread_info > > /* The function call history iterator. */ > struct btrace_call_history *call_history; > + > + /* The current replay position. NULL if not replaying. */ > + struct btrace_insn_iterator *replay; > }; > > /* Enable branch tracing for a thread. */ > @@ -301,4 +304,7 @@ extern void btrace_set_call_history (struct btrace_thread_info *, > const struct btrace_call_iterator *begin, > const struct btrace_call_iterator *end); > > +/* Determine if branch tracing is currently replaying TP. */ > +extern int btrace_is_replaying (struct thread_info *tp); > + > #endif /* BTRACE_H */ > diff --git a/gdb/record-btrace.c b/gdb/record-btrace.c > index c7d6e9f..5e41b20 100644 > --- a/gdb/record-btrace.c > +++ b/gdb/record-btrace.c > @@ -237,6 +237,10 @@ record_btrace_info (void) > printf_unfiltered (_("Recorded %u instructions in %u functions for thread " > "%d (%s).\n"), insns, calls, tp->num, > target_pid_to_str (tp->ptid)); > + > + if (btrace_is_replaying (tp)) > + printf_unfiltered (_("Replay in progress. At instruction %u.\n"), > + btrace_insn_number (btinfo->replay)); > } > > /* Print an unsigned int. */ > @@ -301,13 +305,34 @@ record_btrace_insn_history (int size, int flags) > history = btinfo->insn_history; > if (history == NULL) > { > - /* No matter the direction, we start with the tail of the trace. */ > - btrace_insn_end (&begin, btinfo); > - end = begin; > + struct btrace_insn_iterator *replay; > > DEBUG ("insn-history (0x%x): %d", flags, size); > > - covered = btrace_insn_prev (&begin, context); > + /* If we're replaying, we start at the replay position. Otherwise, we > + start at the tail of the trace. */ > + replay = btinfo->replay; > + if (replay != NULL) > + begin = *replay; > + else > + btrace_insn_end (&begin, btinfo); > + > + /* We start from here and expand in the requested direction. Then we > + expand in the other direction, as well, to fill up any remaining > + context. */ > + end = begin; > + if (size < 0) > + { > + /* We want the current position covered, as well. */ > + covered = btrace_insn_next (&end, 1); > + covered += btrace_insn_prev (&begin, context - covered); > + covered += btrace_insn_next (&end, context - covered); > + } > + else > + { > + covered = btrace_insn_next (&end, context); > + covered += btrace_insn_prev (&begin, context - covered); > + } These two COVERED calculations do not seem right to me, pointer is moving NEXT and PREV so the directions should be both added and subtracted. > } > else > { > @@ -562,13 +587,37 @@ record_btrace_call_history (int size, int flags) > history = btinfo->call_history; > if (history == NULL) > { > - /* No matter the direction, we start with the tail of the trace. */ > - btrace_call_end (&begin, btinfo); > - end = begin; > + struct btrace_insn_iterator *replay; > > DEBUG ("call-history (0x%x): %d", flags, size); > > - covered = btrace_call_prev (&begin, context); > + /* If we're replaying, we start at the replay position. Otherwise, we > + start at the tail of the trace. */ > + replay = btinfo->replay; > + if (replay != NULL) > + { > + begin.function = replay->function; > + begin.btinfo = btinfo; > + } > + else > + btrace_call_end (&begin, btinfo); > + > + /* We start from here and expand in the requested direction. Then we > + expand in the other direction, as well, to fill up any remaining > + context. */ > + end = begin; > + if (size < 0) > + { > + /* We want the current position covered, as well. */ > + covered = btrace_call_next (&end, 1); > + covered += btrace_call_prev (&begin, context - covered); > + covered += btrace_call_next (&end, context - covered); > + } > + else > + { > + covered = btrace_call_next (&end, context); > + covered += btrace_call_prev (&begin, context- covered); > + } These two COVERED calculations do not seem right to me, pointer is moving NEXT and PREV so the directions should be both added and subtracted. > } > else > { > @@ -689,6 +738,20 @@ record_btrace_call_history_from (ULONGEST from, int size, int flags) > record_btrace_call_history_range (begin, end, flags); > } > > +/* The to_record_is_replaying method of target record-btrace. */ > + > +static int > +record_btrace_is_replaying (void) > +{ > + struct thread_info *tp; > + > + ALL_THREADS (tp) > + if (btrace_is_replaying (tp)) > + return 1; > + > + return 0; > +} > + > /* Initialize the record-btrace target ops. */ > > static void > @@ -715,6 +778,7 @@ init_record_btrace_ops (void) > ops->to_call_history = record_btrace_call_history; > ops->to_call_history_from = record_btrace_call_history_from; > ops->to_call_history_range = record_btrace_call_history_range; > + ops->to_record_is_replaying = record_btrace_is_replaying; > ops->to_stratum = record_stratum; > ops->to_magic = OPS_MAGIC; > } > -- > 1.7.1