From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 15195 invoked by alias); 2 May 2013 12:03:54 -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 15153 invoked by uid 89); 2 May 2013 12:03:54 -0000 X-Spam-SWARE-Status: No, score=-8.5 required=5.0 tests=AWL,BAYES_00,KHOP_RCVD_UNTRUST,KHOP_THREADED,RCVD_IN_HOSTKARMA_W,RCVD_IN_HOSTKARMA_WL,RP_MATCHES_RCVD autolearn=ham version=3.3.1 Received: from mga14.intel.com (HELO mga14.intel.com) (143.182.124.37) by sourceware.org (qpsmtpd/0.84/v0.84-167-ge50287c) with ESMTP; Thu, 02 May 2013 12:03:53 +0000 Received: from fmsmga001.fm.intel.com ([10.253.24.23]) by azsmga102.ch.intel.com with ESMTP; 02 May 2013 05:03:52 -0700 X-ExtLoop1: 1 Received: from irvmail001.ir.intel.com ([163.33.26.43]) by fmsmga001.fm.intel.com with ESMTP; 02 May 2013 05:03:43 -0700 Received: from ulslx001.iul.intel.com (ulslx001.iul.intel.com [172.28.207.63]) by irvmail001.ir.intel.com (8.14.3/8.13.6/MailSET/Hub) with ESMTP id r42C3esn019537; Thu, 2 May 2013 13:03:41 +0100 Received: from ulslx001.iul.intel.com (localhost [127.0.0.1]) by ulslx001.iul.intel.com with ESMTP id r42C3dE2021521; Thu, 2 May 2013 14:03:39 +0200 Received: (from mmetzger@localhost) by ulslx001.iul.intel.com with id r42C3dTq021517; Thu, 2 May 2013 14:03:39 +0200 From: Markus Metzger To: jan.kratochvil@redhat.com Cc: gdb-patches@sourceware.org Subject: [PATCH 07/15] btrace: add replay position to btrace thread info Date: Thu, 02 May 2013 12:03:00 -0000 Message-Id: <1367496216-21217-8-git-send-email-markus.t.metzger@intel.com> In-Reply-To: <1367496216-21217-1-git-send-email-markus.t.metzger@intel.com> References: <1367496216-21217-1-git-send-email-markus.t.metzger@intel.com> X-SW-Source: 2013-05/txt/msg00021.txt.bz2 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-05-02 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 | 77 +++++++++++++++++++++++++++++++++++++++++++++----- 3 files changed, 85 insertions(+), 8 deletions(-) diff --git a/gdb/btrace.c b/gdb/btrace.c index 9478350..bb2e051 100644 --- a/gdb/btrace.c +++ b/gdb/btrace.c @@ -750,9 +750,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. */ @@ -1158,3 +1160,11 @@ btrace_set_call_history (struct btrace_thread_info *btinfo, history->begin = begin; 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 ac7acdb..cb7a8b6 100644 --- a/gdb/btrace.h +++ b/gdb/btrace.h @@ -160,6 +160,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. */ @@ -242,4 +245,7 @@ extern void btrace_set_call_history (struct btrace_thread_info *, struct btrace_function *begin, struct btrace_function *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 ebb26ad..56eccab 100644 --- a/gdb/record-btrace.c +++ b/gdb/record-btrace.c @@ -231,6 +231,10 @@ record_btrace_info (void) printf_unfiltered (_("Recorded %u instructions in %u functions for thread " "%d (%s).\n"), insts, funcs, 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. */ @@ -296,11 +300,32 @@ 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; + + /* 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); - covered = btrace_insn_prev (&begin, context); + /* 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); + } } else { @@ -608,11 +633,32 @@ 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. */ - begin = btinfo->end; - end = begin; + struct btrace_insn_iterator *replay; + + /* 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->function; + else + begin = btinfo->end; - covered = btrace_func_prev (&begin, context); + /* 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_func_next (&end, 1); + covered += btrace_func_prev (&begin, context - covered); + covered += btrace_func_next (&end, context - covered); + } + else + { + covered = btrace_func_next (&end, context); + covered += btrace_func_prev (&begin, context- covered); + } } else { @@ -729,6 +775,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 @@ -755,6 +815,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