From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 31534 invoked by alias); 14 May 2013 19:10:59 -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 31522 invoked by uid 89); 14 May 2013 19:10:59 -0000 X-Spam-SWARE-Status: No, score=-8.0 required=5.0 tests=AWL,BAYES_00,KHOP_THREADED,RCVD_IN_HOSTKARMA_W,RCVD_IN_HOSTKARMA_WL,RP_MATCHES_RCVD,SPF_HELO_PASS,SPF_PASS,TW_CP autolearn=ham version=3.3.1 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; Tue, 14 May 2013 19:10:58 +0000 Received: from int-mx10.intmail.prod.int.phx2.redhat.com (int-mx10.intmail.prod.int.phx2.redhat.com [10.5.11.23]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id r4EJAu58014936 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK) for ; Tue, 14 May 2013 15:10:56 -0400 Received: from brno.lan (ovpn01.gateway.prod.ext.ams2.redhat.com [10.39.146.11]) by int-mx10.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id r4EJAtJm018455 for ; Tue, 14 May 2013 15:10:55 -0400 Subject: [PATCH 4/5] range stepping: gdbserver (x86 GNU/Linux) To: gdb-patches@sourceware.org From: Pedro Alves Date: Tue, 14 May 2013 19:10:00 -0000 Message-ID: <20130514191054.13213.58686.stgit@brno.lan> In-Reply-To: <20130514191026.13213.39574.stgit@brno.lan> References: <20130514191026.13213.39574.stgit@brno.lan> User-Agent: StGit/0.16 MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: 7bit X-SW-Source: 2013-05/txt/msg00489.txt.bz2 This patch adds support for range stepping to GDBserver, teaching it about vCont;r. It'd be easy to enable it for all hardware single-step targets without needing the linux_target_ops hook, however, at least PPC needs special care, due to the fact that PPC atomic sequences can't be hardware single-stepped through, a thing which GDBserver doesn't know about. So this leaves the support limited to x86/x86_64, just like in Yao's original series. v3: - lift the limitation that only a one r action was handled per vCont, making the step range part of 'struct thread_resume'. - Moved step range bits out of gdbthread.h/inferiors.c into linux-low.c. - The stepping range of a thread that is quiesced because some other thread is reporting an event is no longer left stale. - Added NEWS entry for GDBserver. - Many tweaks. gdb/ 2013-05-14 Pedro Alves * NEWS: Mention GDBserver range stepping support. gdb/gdbserver/ 2013-05-14 Yao Qi Pedro Alves * linux-low.c (lwp_in_step_range): New function. (linux_wait_1): If the thread was range stepping and stopped outside the stepping range, report the stop to GDB. Otherwise, continue stepping. Add range stepping debug output. (linux_set_resume_request): Copy the step range from the resume request to the lwp. (linux_supports_range_stepping): New. (linux_target_ops) : Set to linux_supports_range_stepping. * linux-low.h (struct linux_target_ops) : New field. (struct lwp_info) : New fields. * linux-x86-low.c (x86_supports_range_stepping): New. (the_low_target) : Set to x86_supports_range_stepping. * server.c (handle_v_cont): Handle 'r' action. (handle_v_requests): Append ";r" if the target supports range stepping. * target.h (struct thread_resume) : New fields. (struct target_ops) : New field. (target_supports_range_stepping): New macro. --- gdb/NEWS | 5 +++ gdb/gdbserver/linux-low.c | 63 ++++++++++++++++++++++++++++++++++------- gdb/gdbserver/linux-low.h | 8 +++++ gdb/gdbserver/linux-x86-low.c | 7 +++++ gdb/gdbserver/server.c | 24 +++++++++++++++- gdb/gdbserver/target.h | 18 ++++++++++++ 6 files changed, 113 insertions(+), 12 deletions(-) diff --git a/gdb/NEWS b/gdb/NEWS index 3f2d757..a4a3c4a 100644 --- a/gdb/NEWS +++ b/gdb/NEWS @@ -81,6 +81,11 @@ vCont;r stub to step through an address range itself, without GDB involvemement at each single-step. +* New features in the GDB remote stub, GDBserver + + ** GDBserver now supports target-assisted range stepping. Currently + enabled on x86/x86_64 GNU/Linux targets. + *** Changes in GDB 7.6 * Target record has been renamed to record-full. diff --git a/gdb/gdbserver/linux-low.c b/gdb/gdbserver/linux-low.c index 72c51e0..5a9aad7 100644 --- a/gdb/gdbserver/linux-low.c +++ b/gdb/gdbserver/linux-low.c @@ -252,6 +252,16 @@ supports_fast_tracepoints (void) return the_low_target.install_fast_tracepoint_jump_pad != NULL; } +/* True if LWP is stopped in its stepping range. */ + +static int +lwp_in_step_range (struct lwp_info *lwp) +{ + CORE_ADDR pc = lwp->stop_pc; + + return (pc >= lwp->step_range_start && pc < lwp->step_range_end); +} + struct pending_signals { int signal; @@ -2313,6 +2323,7 @@ linux_wait_1 (ptid_t ptid, int maybe_internal_trap; int report_to_gdb; int trace_event; + int in_step_range; /* Translate generic target options into linux options. */ options = __WALL; @@ -2322,6 +2333,7 @@ linux_wait_1 (ptid_t ptid, retry: bp_explains_trap = 0; trace_event = 0; + in_step_range = 0; ourstatus->kind = TARGET_WAITKIND_IGNORE; /* If we were only supposed to resume one thread, only wait for @@ -2615,18 +2627,24 @@ Check if we're already there.\n", goto retry; } - /* If GDB wanted this thread to single step, we always want to - report the SIGTRAP, and let GDB handle it. Watchpoints should - always be reported. So should signals we can't explain. A - SIGTRAP we can't explain could be a GDB breakpoint --- we may or - not support Z0 breakpoints. If we do, we're be able to handle - GDB breakpoints on top of internal breakpoints, by handling the - internal breakpoint and still reporting the event to GDB. If we - don't, we're out of luck, GDB won't see the breakpoint hit. */ + /* Note that all addresses are always "out the step range" when + there's no range to begin with. */ + in_step_range = lwp_in_step_range (event_child); + + /* If GDB wanted this thread to single step, and the thread is out + of the step range, we always want to report the SIGTRAP, and let + GDB handle it. Watchpoints should always be reported. So should + signals we can't explain. A SIGTRAP we can't explain could be a + GDB breakpoint --- we may or not support Z0 breakpoints. If we + do, we're be able to handle GDB breakpoints on top of internal + breakpoints, by handling the internal breakpoint and still + reporting the event to GDB. If we don't, we're out of luck, GDB + won't see the breakpoint hit. */ report_to_gdb = (!maybe_internal_trap - || current_inferior->last_resume_kind == resume_step + || (current_inferior->last_resume_kind == resume_step + && !in_step_range) || event_child->stopped_by_watchpoint - || (!step_over_finished + || (!step_over_finished && !in_step_range && !bp_explains_trap && !trace_event) || (gdb_breakpoint_here (event_child->stop_pc) && gdb_condition_true_at_breakpoint (event_child->stop_pc) @@ -2647,6 +2665,11 @@ Check if we're already there.\n", fprintf (stderr, "Step-over finished.\n"); if (trace_event) fprintf (stderr, "Tracepoint event.\n"); + if (lwp_in_step_range (event_child)) + fprintf (stderr, "Range stepping pc 0x%s [0x%s, 0x%s).\n", + paddress (event_child->stop_pc), + paddress (event_child->step_range_start), + paddress (event_child->step_range_end)); } /* We're not reporting this breakpoint to GDB, so apply the @@ -2678,7 +2701,12 @@ Check if we're already there.\n", if (debug_threads) { if (current_inferior->last_resume_kind == resume_step) - fprintf (stderr, "GDB wanted to single-step, reporting event.\n"); + { + if (event_child->step_range_start == event_child->step_range_end) + fprintf (stderr, "GDB wanted to single-step, reporting event.\n"); + else if (!lwp_in_step_range (event_child)) + fprintf (stderr, "Out of step range, reporting event.\n"); + } if (event_child->stopped_by_watchpoint) fprintf (stderr, "Stopped by watchpoint.\n"); if (gdb_breakpoint_here (event_child->stop_pc)) @@ -3377,6 +3405,9 @@ linux_set_resume_request (struct inferior_list_entry *entry, void *arg) lwp->resume = &r->resume[ndx]; thread->last_resume_kind = lwp->resume->kind; + lwp->step_range_start = lwp->resume->step_range_start; + lwp->step_range_end = lwp->resume->step_range_end; + /* If we had a deferred signal to report, dequeue one now. This can happen if LWP gets more than one signal while trying to get out of a jump pad. */ @@ -5083,6 +5114,15 @@ linux_supports_agent (void) return 1; } +static int +linux_supports_range_stepping (void) +{ + if (*the_low_target.supports_range_stepping == NULL) + return 0; + + return (*the_low_target.supports_range_stepping) (); +} + /* Enumerate spufs IDs for process PID. */ static int spu_enumerate_spu_ids (long pid, unsigned char *buf, CORE_ADDR offset, int len) @@ -5939,6 +5979,7 @@ static struct target_ops linux_target_ops = { NULL, NULL, #endif + linux_supports_range_stepping, }; static void diff --git a/gdb/gdbserver/linux-low.h b/gdb/gdbserver/linux-low.h index 205d803..4dd3c9c 100644 --- a/gdb/gdbserver/linux-low.h +++ b/gdb/gdbserver/linux-low.h @@ -166,6 +166,8 @@ struct linux_target_ops for use as a fast tracepoint. */ int (*get_min_fast_tracepoint_insn_len) (void); + /* Returns true if the low target supports range stepping. */ + int (*supports_range_stepping) (void); }; extern struct linux_target_ops the_low_target; @@ -235,6 +237,12 @@ struct lwp_info level on this process was a single-step. */ int stepping; + /* Range to single step within. This is a copy of the step range + passed along the last resume request. See 'struct + thread_resume'. */ + CORE_ADDR step_range_start; /* Inclusive */ + CORE_ADDR step_range_end; /* Exclusive */ + /* If this flag is set, we need to set the event request flags the next time we see this LWP stop. */ int must_set_ptrace_flags; diff --git a/gdb/gdbserver/linux-x86-low.c b/gdb/gdbserver/linux-x86-low.c index 31657d3..1d1df95 100644 --- a/gdb/gdbserver/linux-x86-low.c +++ b/gdb/gdbserver/linux-x86-low.c @@ -3175,6 +3175,12 @@ x86_emit_ops (void) return &i386_emit_ops; } +static int +x86_supports_range_stepping (void) +{ + return 1; +} + /* This is initialized assuming an amd64 target. x86_arch_setup will correct it for i386 or amd64 targets. */ @@ -3214,4 +3220,5 @@ struct linux_target_ops the_low_target = x86_install_fast_tracepoint_jump_pad, x86_emit_ops, x86_get_min_fast_tracepoint_insn_len, + x86_supports_range_stepping, }; diff --git a/gdb/gdbserver/server.c b/gdb/gdbserver/server.c index 6bb36d8..1083aa9 100644 --- a/gdb/gdbserver/server.c +++ b/gdb/gdbserver/server.c @@ -2042,8 +2042,12 @@ handle_v_cont (char *own_buf) { p++; + memset (&resume_info[i], 0, sizeof resume_info[i]); + if (p[0] == 's' || p[0] == 'S') resume_info[i].kind = resume_step; + else if (p[0] == 'r') + resume_info[i].kind = resume_step; else if (p[0] == 'c' || p[0] == 'C') resume_info[i].kind = resume_continue; else if (p[0] == 't') @@ -2063,9 +2067,22 @@ handle_v_cont (char *own_buf) goto err; resume_info[i].sig = gdb_signal_to_host (sig); } + else if (p[0] == 'r') + { + char *p1; + + p = p + 1; + p1 = strchr (p, ','); + decode_address (&resume_info[i].step_range_start, p, p1 - p); + + p = p1 + 1; + p1 = strchr (p, ':'); + decode_address (&resume_info[i].step_range_end, p, p1 - p); + + p = p1; + } else { - resume_info[i].sig = 0; p = p + 1; } @@ -2311,6 +2328,11 @@ handle_v_requests (char *own_buf, int packet_len, int *new_packet_len) if (strncmp (own_buf, "vCont?", 6) == 0) { strcpy (own_buf, "vCont;c;C;s;S;t"); + if (target_supports_range_stepping ()) + { + own_buf = own_buf + strlen (own_buf); + strcpy (own_buf, ";r"); + } return; } } diff --git a/gdb/gdbserver/target.h b/gdb/gdbserver/target.h index f257459..3a64975 100644 --- a/gdb/gdbserver/target.h +++ b/gdb/gdbserver/target.h @@ -57,6 +57,18 @@ struct thread_resume linux; SuspendThread on win32). This is a host signal value (not enum gdb_signal). */ int sig; + + /* Range to single step within. Valid only iff KIND is resume_step. + + Continuing stepping while the PC is in this range. + + Note that STEP_RANGE_END is the address of the first instruction + beyond the step range, and NOT the address of the last + instruction within it. This has the property that START == END + means 'step only once', even if the instruction at START jumps to + START. */ + CORE_ADDR step_range_start; /* Inclusive */ + CORE_ADDR step_range_end; /* Exclusive */ }; /* Generally, what has the program done? */ @@ -414,6 +426,8 @@ struct target_ops to break a cyclic dependency. */ void (*read_btrace) (struct btrace_target_info *, struct buffer *, int type); + /* Return true if target supports range stepping. */ + int (*supports_range_stepping) (void); }; extern struct target_ops *the_target; @@ -549,6 +563,10 @@ int kill_inferior (int); #define target_read_btrace(tinfo, buffer, type) \ (*the_target->read_btrace) (tinfo, buffer, type) +#define target_supports_range_stepping() \ + (the_target->supports_range_stepping ? \ + (*the_target->supports_range_stepping) () : 0) + /* Start non-stop mode, returns 0 on success, -1 on failure. */ int start_non_stop (int nonstop);