espressif/binutils-gdb
1
0
Fork 0
mirror of https://github.com/espressif/binutils-gdb.git synced 2025-06-23 03:29:47 +08:00
Code Issues Packages Projects Releases Wiki Activity

Remove find_inferior usage for thread_search

Browse Source 
Replace it with for_each_thread.  While at it, we can inline the
callback code.  One little change is that I am using the
prev_general_thread variable instead of current_gen_ptid, since they
should have the same value.

gdb/gdbserver/ChangeLog:

	* target.c (struct thread_search): Remove.
	(thread_search_callback): Remove.
	(prepare_to_access_memory): Use for_each_thread instead of
	find_inferior.  Inline code from thread_search_callback.
This commit is contained in:
Simon Marchi
2017-10-27 23:44:12 -04:00
parent eaddb42592
commit bac608e7e1
2 changed files with 39 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
gdb/gdbserver/ChangeLog
View File

@ -1,3 +1,10 @@
2017-10-27 Simon Marchi <simon.marchi@ericsson.com>
* target.c (struct thread_search): Remove.
(thread_search_callback): Remove.
(prepare_to_access_memory): Use for_each_thread instead of
find_inferior. Inline code from thread_search_callback.
2017-10-27 Simon Marchi <simon.marchi@ericsson.com>
* server.c (struct visit_actioned_threads_data): Remove.

88
gdb/gdbserver/target.c
View File

@ -32,51 +32,6 @@ set_desired_thread ()
return (current_thread != NULL);
}
/* Structure used to look up a thread to use as current when accessing
memory. */
struct thread_search
{
/* The PTID of the current general thread. This is an input
parameter. */
ptid_t current_gen_ptid;
/* The first thread found. */
struct thread_info *first;
/* The first stopped thread found. */
struct thread_info *stopped;
/* The current general thread, if found. */
struct thread_info *current;
};
/* Callback for find_inferior. Search for a thread to use as current
when accessing memory. */
static int
thread_search_callback (thread_info *thread, void *args)
{
struct thread_search *s = (struct thread_search *) args;
if (thread->id.pid () == ptid_get_pid (s->current_gen_ptid)
&& mythread_alive (ptid_of (thread)))
{
if (s->stopped == NULL
&& the_target->thread_stopped != NULL
&& thread_stopped (thread))
s->stopped = thread;
if (s->first == NULL)
s->first = thread;
if (s->current == NULL && s->current_gen_ptid == thread->id)
s->current = thread;
}
return 0;
}
/* The thread that was current before prepare_to_access_memory was
called. done_accessing_memory uses this to restore the previous
selected thread. */
@ -87,11 +42,15 @@ static ptid_t prev_general_thread;
int
prepare_to_access_memory (void)
{
struct thread_search search;
struct thread_info *thread;
/* The first thread found. */
struct thread_info *first = NULL;
/* The first stopped thread found. */
struct thread_info *stopped = NULL;
/* The current general thread, if found. */
struct thread_info *current = NULL;
memset (&search, 0, sizeof (search));
search.current_gen_ptid = general_thread;
/* Save the general thread value, since prepare_to_access_memory could change
it. */
prev_general_thread = general_thread;
if (the_target->prepare_to_access_memory != NULL)
@ -103,18 +62,35 @@ prepare_to_access_memory (void)
return res;
}
find_inferior (&all_threads, thread_search_callback, &search);
for_each_thread (prev_general_thread.pid (), [&] (thread_info *thread)
{
if (mythread_alive (thread->id))
{
if (stopped == NULL && the_target->thread_stopped != NULL
&& thread_stopped (thread))
stopped = thread;
if (first == NULL)
first = thread;
if (current == NULL && prev_general_thread == thread->id)
current = thread;
}
});
/* The thread we end up choosing. */
struct thread_info *thread;
/* Prefer a stopped thread. If none is found, try the current
thread. Otherwise, take the first thread in the process. If
none is found, undo the effects of
target->prepare_to_access_memory() and return error. */
if (search.stopped != NULL)
thread = search.stopped;
else if (search.current != NULL)
thread = search.current;
else if (search.first != NULL)
thread = search.first;
if (stopped != NULL)
thread = stopped;
else if (current != NULL)
thread = current;
else if (first != NULL)
thread = first;
else
{
done_accessing_memory ();