[PATCH 11/15] More target unification

Gary Benson
2014-07-09T10:39:44Z

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 <tromey@redhat.com>

* 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 <tromey@redhat.com>

* 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 */
--
1.7.1