From patchwork Wed Jul 9 10:37:31 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Gary Benson X-Patchwork-Id: 1971 Received: (qmail 6467 invoked by alias); 9 Jul 2014 10:39:44 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 6370 invoked by uid 89); 9 Jul 2014 10:39:43 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.4 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; Wed, 09 Jul 2014 10:39:38 +0000 Received: from int-mx13.intmail.prod.int.phx2.redhat.com (int-mx13.intmail.prod.int.phx2.redhat.com [10.5.11.26]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id s69AcElx008722 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK) for ; Wed, 9 Jul 2014 06:38:14 -0400 Received: from blade.nx (ovpn-116-101.ams2.redhat.com [10.36.116.101]) by int-mx13.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id s69AcCeg013315 for ; Wed, 9 Jul 2014 06:38:12 -0400 Received: from blade.nx (localhost [127.0.0.1]) by blade.nx (Postfix) with ESMTP id 448C12640D0 for ; Wed, 9 Jul 2014 11:38:11 +0100 (BST) From: Gary Benson To: gdb-patches@sourceware.org Subject: [PATCH 11/15] More target unification Date: Wed, 9 Jul 2014 11:37:31 +0100 Message-Id: <1404902255-11101-12-git-send-email-gbenson@redhat.com> In-Reply-To: <1404902255-11101-1-git-send-email-gbenson@redhat.com> References: <1404902255-11101-1-git-send-email-gbenson@redhat.com> X-IsSubscribed: yes This unifies a few more top-level target functions -- target_resume, target_wait, and target_stop -- and the declaration of the variable "non_stop". This follows the usual pattern, where clients of "common" are expected to define the objects appropriately, thus simplifying common/agent.c a bit more. gdb/ 2014-07-09 Tom Tromey * target/target.h (target_resume, target_wait, target_stop) (non_stop): Moved from target.h. * target.h (target_resume, target_wait, target_stop, non_stop): Move to target/target.h. * common/agent.c (agent_run_command): Always use target_resume, target_stop, and target_wait. gdb/gdbserver/ 2014-07-09 Tom Tromey * target.c (target_wait, target_stop, target_resume): New functions. --- gdb/ChangeLog | 9 +++++++++ gdb/common/agent.c | 27 +-------------------------- gdb/gdbserver/ChangeLog | 5 +++++ gdb/gdbserver/target.c | 34 ++++++++++++++++++++++++++++++++++ gdb/target.h | 31 ------------------------------- gdb/target/target.h | 38 ++++++++++++++++++++++++++++++++++++++ 6 files changed, 87 insertions(+), 57 deletions(-) diff --git a/gdb/common/agent.c b/gdb/common/agent.c index 52de3d4..0fde2fd 100644 --- a/gdb/common/agent.c +++ b/gdb/common/agent.c @@ -230,18 +230,7 @@ agent_run_command (int pid, const char *cmd, int len) DEBUG_AGENT ("agent: resumed helper thread\n"); /* Resume helper thread. */ -#ifdef GDBSERVER -{ - struct thread_resume resume_info; - - resume_info.thread = ptid; - resume_info.kind = resume_continue; - resume_info.sig = GDB_SIGNAL_0; - (*the_target->resume) (&resume_info, 1); -} -#else - target_resume (ptid, 0, GDB_SIGNAL_0); -#endif + target_resume (ptid, 0, GDB_SIGNAL_0); fd = gdb_connect_sync_socket (pid); if (fd >= 0) @@ -277,25 +266,11 @@ agent_run_command (int pid, const char *cmd, int len) int was_non_stop = non_stop; /* Stop thread PTID. */ DEBUG_AGENT ("agent: stop helper thread\n"); -#ifdef GDBSERVER - { - struct thread_resume resume_info; - - resume_info.thread = ptid; - resume_info.kind = resume_stop; - resume_info.sig = GDB_SIGNAL_0; - (*the_target->resume) (&resume_info, 1); - } - - non_stop = 1; - mywait (ptid, &status, 0, 0); -#else non_stop = 1; target_stop (ptid); memset (&status, 0, sizeof (status)); target_wait (ptid, &status, 0); -#endif non_stop = was_non_stop; } diff --git a/gdb/gdbserver/target.c b/gdb/gdbserver/target.c index 44e1e11..f93163e 100644 --- a/gdb/gdbserver/target.c +++ b/gdb/gdbserver/target.c @@ -134,6 +134,40 @@ mywait (ptid_t ptid, struct target_waitstatus *ourstatus, int options, return ret; } +/* See target/target.h. */ + +ptid_t +target_wait (ptid_t ptid, struct target_waitstatus *status, int options) +{ + return mywait (ptid, status, options, 0); +} + +/* See target/target.h. */ + +void +target_stop (ptid_t ptid) +{ + struct thread_resume resume_info; + + resume_info.thread = ptid; + resume_info.kind = resume_stop; + resume_info.sig = GDB_SIGNAL_0; + (*the_target->resume) (&resume_info, 1); +} + +/* See target/target.h. */ + +void +target_resume (ptid_t ptid, int step, enum gdb_signal signal) +{ + struct thread_resume resume_info; + + resume_info.thread = ptid; + resume_info.kind = step ? resume_step : resume_continue; + resume_info.sig = GDB_SIGNAL_0; + (*the_target->resume) (&resume_info, 1); +} + int start_non_stop (int nonstop) { diff --git a/gdb/target.h b/gdb/target.h index 8a2faca..2a4783c 100644 --- a/gdb/target.h +++ b/gdb/target.h @@ -1191,31 +1191,6 @@ extern void target_detach (const char *, int); extern void target_disconnect (const char *, int); -/* Resume execution of the target process PTID (or a group of - threads). STEP says whether to single-step or to run free; SIGGNAL - is the signal to be given to the target, or GDB_SIGNAL_0 for no - signal. The caller may not pass GDB_SIGNAL_DEFAULT. A specific - PTID means `step/resume only this process id'. A wildcard PTID - (all threads, or all threads of process) means `step/resume - INFERIOR_PTID, and let other threads (for which the wildcard PTID - matches) resume with their 'thread->suspend.stop_signal' signal - (usually GDB_SIGNAL_0) if it is in "pass" state, or with no signal - if in "no pass" state. */ - -extern void target_resume (ptid_t ptid, int step, enum gdb_signal signal); - -/* Wait for process pid to do something. PTID = -1 to wait for any - pid to do something. Return pid of child, or -1 in case of error; - store status through argument pointer STATUS. Note that it is - _NOT_ OK to throw_exception() out of target_wait() without popping - the debugging target from the stack; GDB isn't prepared to get back - to the prompt with a debugging target but without the frame cache, - stop_pc, etc., set up. OPTIONS is a bitwise OR of TARGET_W* - options. */ - -extern ptid_t target_wait (ptid_t ptid, struct target_waitstatus *status, - int options); - /* Fetch at least register REGNO, or all regs if regno == -1. No result. */ extern void target_fetch_registers (struct regcache *regcache, int regno); @@ -1557,12 +1532,6 @@ extern int target_thread_alive (ptid_t ptid); extern void target_find_new_threads (void); -/* Make target stop in a continuable fashion. (For instance, under - Unix, this should act like SIGSTOP). This function is normally - used by GUIs to implement a stop button. */ - -extern void target_stop (ptid_t ptid); - /* Send the specified COMMAND to the target's monitor (shell,interpreter) for execution. The result of the query is placed in OUTBUF. */ diff --git a/gdb/target/target.h b/gdb/target/target.h index b3bd719..cb96181 100644 --- a/gdb/target/target.h +++ b/gdb/target/target.h @@ -22,6 +22,37 @@ /* This header is a stopgap until more code is shared. */ +/* Resume execution of the target process PTID (or a group of + threads). STEP says whether to single-step or to run free; SIGGNAL + is the signal to be given to the target, or GDB_SIGNAL_0 for no + signal. The caller may not pass GDB_SIGNAL_DEFAULT. A specific + PTID means `step/resume only this process id'. A wildcard PTID + (all threads, or all threads of process) means `step/resume + INFERIOR_PTID, and let other threads (for which the wildcard PTID + matches) resume with their 'thread->suspend.stop_signal' signal + (usually GDB_SIGNAL_0) if it is in "pass" state, or with no signal + if in "no pass" state. */ + +extern void target_resume (ptid_t ptid, int step, enum gdb_signal signal); + +/* Wait for process pid to do something. PTID = -1 to wait for any + pid to do something. Return pid of child, or -1 in case of error; + store status through argument pointer STATUS. Note that it is + _NOT_ OK to throw_exception() out of target_wait() without popping + the debugging target from the stack; GDB isn't prepared to get back + to the prompt with a debugging target but without the frame cache, + stop_pc, etc., set up. OPTIONS is a bitwise OR of TARGET_W* + options. */ + +extern ptid_t target_wait (ptid_t ptid, struct target_waitstatus *status, + int options); + +/* Make target stop in a continuable fashion. (For instance, under + Unix, this should act like SIGSTOP). This function is normally + used by GUIs to implement a stop button. */ + +extern void target_stop (ptid_t ptid); + extern int target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len); @@ -31,4 +62,11 @@ extern int target_read_uint32 (CORE_ADDR memaddr, unsigned int *result); extern int target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len); +/* If set, the inferior should be controlled in non-stop mode. In + this mode, each thread is controlled independently. Execution + commands apply only to the selected thread by default, and stop + events stop only the thread that had the event -- the other threads + are kept running freely. */ +extern int non_stop; + #endif /* TARGET_COMMON_H */