FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

* inferior.h (context_switch_to): Delete.

Browse source 
* infrun.c (context_switch): Don't save and load infrun state.
	(context_switch_to): Delete.

	* infcmd.c (proceed_thread_callback): Replace context_switch_to
	calls by switch_to_thread calls.

	* gdbthread.h (save_infrun_state, load_infrun_state): Delete.
	* thread.c (main_thread_state, main_thread_executing): Delete.
	(inferior_thread): Delete references to them.
	(add_thread_silent): Fix case where we're adding a thread with the
	same ptid as an exited thread.  Remove references to
	context-switching.
	(load_infrun_state, save_infrun_state): Delete.
	(thread_alive, is_thread_state, any_running, is_executing)
	(set_executing): Remove the special handling for targets that
	don't register any thread.
	(restore_current_thread, thread_apply_all_command)
	(do_captured_thread_select): Unconditionally call
	switch_to_thread.

	* mi/mi-main.c (mi_cmd_execute): Check for exited threads.
	Call switch_to_thread instead of context_switch_to.
This commit is contained in:
Pedro Alves 2008-09-08 22:10:20 +00:00
parent fedae5ffbc
commit dcf4fbde10
7 changed files with 51 additions and 145 deletions
Download patch file Download diff file Expand all files Collapse all files

26
gdb/ChangeLog
View file

@ -1,3 +1,29 @@
2008-09-08 Pedro Alves <pedro@codesourcery.com>
* inferior.h (context_switch_to): Delete.
* infrun.c (context_switch): Don't save and load infrun state.
(context_switch_to): Delete.
* infcmd.c (proceed_thread_callback): Replace context_switch_to
calls by switch_to_thread calls.
* gdbthread.h (save_infrun_state, load_infrun_state): Delete.
* thread.c (main_thread_state, main_thread_executing): Delete.
(inferior_thread): Delete references to them.
(add_thread_silent): Fix case where we're adding a thread with the
same ptid as an exited thread. Remove references to
context-switching.
(load_infrun_state, save_infrun_state): Delete.
(thread_alive, is_thread_state, any_running, is_executing)
(set_executing): Remove the special handling for targets that
don't register any thread.
(restore_current_thread, thread_apply_all_command)
(do_captured_thread_select): Unconditionally call
switch_to_thread.
* mi/mi-main.c (mi_cmd_execute): Check for exited threads.
Call switch_to_thread instead of context_switch_to.
2008-09-08 Pedro Alves <pedro@codesourcery.com>
Remove global continuations in favour of a per-thread

7
gdb/gdbthread.h
View file

@ -232,13 +232,6 @@ extern struct thread_info *iterate_over_threads (thread_callback_func, void *);
extern int thread_count (void);
/* infrun context switch: save the debugger state for the given thread. */
extern void save_infrun_state (ptid_t ptid);
/* infrun context switch: load the debugger state previously saved
for the given thread. */
extern void load_infrun_state (ptid_t ptid);
/* Switch from one thread to another. */
extern void switch_to_thread (ptid_t ptid);

2
gdb/infcmd.c
View file

@ -575,7 +575,7 @@ proceed_thread_callback (struct thread_info *thread, void *arg)
if (!is_stopped (thread->ptid))
return 0;
context_switch_to (thread->ptid);
switch_to_thread (thread->ptid);
clear_proceed_status ();
proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
return 0;

2
gdb/inferior.h
View file

@ -132,8 +132,6 @@ extern void clear_proceed_status (void);
extern void proceed (CORE_ADDR, enum target_signal, int);
extern ptid_t context_switch_to (ptid_t ptid);
/* When set, stop the 'step' command if we enter a function which has
no line number information. The normal behavior is that we step
over such function. */

31
gdb/infrun.c
View file

@ -1720,17 +1720,11 @@ nullify_last_target_wait_ptid (void)
target_last_wait_ptid = minus_one_ptid;
}
/* Switch thread contexts, maintaining "infrun state". */
/* Switch thread contexts. */
static void
context_switch (ptid_t ptid)
{
/* Caution: it may happen that the new thread (or the old one!)
is not in the thread list. In this case we must not attempt
to "switch context", or we run the risk that our context may
be lost. This may happen as a result of the target module
mishandling thread creation. */
if (debug_infrun)
{
fprintf_unfiltered (gdb_stdlog, "infrun: Switching context from %s ",
@ -1739,32 +1733,9 @@ context_switch (ptid_t ptid)
target_pid_to_str (ptid));
}
if (in_thread_list (inferior_ptid) && in_thread_list (ptid))
{ /* Perform infrun state context switch: */
/* Save infrun state for the old thread. */
save_infrun_state (inferior_ptid);
/* Load infrun state for the new thread. */
load_infrun_state (ptid);
}
switch_to_thread (ptid);
}
/* Context switch to thread PTID. */
ptid_t
context_switch_to (ptid_t ptid)
{
ptid_t current_ptid = inferior_ptid;
/* Context switch to the new thread. */
if (!ptid_equal (ptid, inferior_ptid))
{
context_switch (ptid);
}
return current_ptid;
}
static void
adjust_pc_after_break (struct execution_control_state *ecs)
{

8
gdb/mi/mi-main.c
View file

@ -1101,10 +1101,10 @@ mi_cmd_execute (struct mi_parse *parse)
if (!tp)
error (_("Invalid thread id: %d"), parse->thread);
if (non_stop)
context_switch_to (tp->ptid);
else
switch_to_thread (tp->ptid);
if (is_exited (tp->ptid))
error (_("Thread id: %d has terminated"), parse->thread);
switch_to_thread (tp->ptid);
}
if (parse->frame != -1)

112
gdb/thread.c
View file

@ -71,9 +71,6 @@ enum thread_state
THREAD_EXITED,
};
static enum thread_state main_thread_state = THREAD_STOPPED;
static int main_thread_executing = 0;
extern struct thread_info*
inferior_thread (void)
{
@ -130,8 +127,6 @@ init_thread_list (void)
struct thread_info *tp, *tpnext;
highest_thread_num = 0;
main_thread_state = THREAD_STOPPED;
main_thread_executing = 0;
if (!thread_list)
return;
@ -158,12 +153,11 @@ add_thread_silent (ptid_t ptid)
one. */
{
/* In addition to deleting the thread, if this is the current
thread, then we need to also get rid of the current infrun
context, and take care that delete_thread doesn't really
delete the thread if it is inferior_ptid. Create a new
template thread in the list with an invalid ptid, context
switch to it, delete the original thread, reset the new
thread's ptid, and switch to it. */
thread, then we need to take care that delete_thread doesn't
really delete the thread if it is inferior_ptid. Create a
new template thread in the list with an invalid ptid, switch
to it, delete the original thread, reset the new thread's
ptid, and switch to it. */
if (ptid_equal (inferior_ptid, ptid))
{
@ -173,14 +167,17 @@ add_thread_silent (ptid_t ptid)
tp->num = ++highest_thread_num;
tp->next = thread_list;
thread_list = tp;
context_switch_to (minus_one_ptid);
/* Make switch_to_thread not read from the thread. */
tp->state_ = THREAD_EXITED;
switch_to_thread (minus_one_ptid);
/* Now we can delete it. */
delete_thread (ptid);
/* Since the context is already set to this new thread,
reset its ptid, and reswitch inferior_ptid to it. */
/* Now reset its ptid, and reswitch inferior_ptid to it. */
tp->ptid = ptid;
tp->state_ = THREAD_STOPPED;
switch_to_thread (ptid);
observer_notify_new_thread (tp);
@ -442,34 +439,6 @@ gdb_list_thread_ids (struct ui_out *uiout, char **error_message)
return GDB_RC_OK;
}
/* Load infrun state for the thread PID. */
void
load_infrun_state (ptid_t ptid)
{
struct thread_info *tp;
/* If we can't find the thread, then we're debugging a single threaded
process. No need to do anything in that case. */
tp = find_thread_id (pid_to_thread_id (ptid));
if (tp == NULL)
return;
}
/* Save infrun state for the thread PID. */
void
save_infrun_state (ptid_t ptid)
{
struct thread_info *tp;
/* If we can't find the thread, then we're debugging a single-threaded
process. Nothing to do in that case. */
tp = find_thread_id (pid_to_thread_id (ptid));
if (tp == NULL)
return;
}
/* Return true if TP is an active thread. */
static int
thread_alive (struct thread_info *tp)
@ -508,24 +477,6 @@ set_running (ptid_t ptid, int running)
{
struct thread_info *tp;
if (!thread_list)
{
/* This is one of the targets that does not add main
thread to the thread list. Just use a single
global flag to indicate that a thread is running.
This problem is unique to ST programs. For MT programs,
the main thread is always present in the thread list. If it's
not, the first call to context_switch will mess up GDB internal
state. */
if (running
&& main_thread_state != THREAD_RUNNING
&& !suppress_resume_observer)
observer_notify_target_resumed (ptid);
main_thread_state = running ? THREAD_RUNNING : THREAD_STOPPED;
return;
}
/* We try not to notify the observer if no thread has actually changed
the running state -- merely to reduce the number of messages to
frontend. Frontend is supposed to handle multiple *running just fine. */
@ -565,9 +516,6 @@ is_thread_state (ptid_t ptid, enum thread_state state)
if (!target_has_execution)
return 0;
if (!thread_list)
return main_thread_state == state;
tp = find_thread_pid (ptid);
gdb_assert (tp);
return tp->state_ == state;
@ -611,9 +559,6 @@ any_running (void)
if (!target_has_execution)
return 0;
if (!thread_list)
return main_thread_state == THREAD_RUNNING;
for (tp = thread_list; tp; tp = tp->next)
if (tp->state_ == THREAD_RUNNING)
return 1;
@ -629,9 +574,6 @@ is_executing (ptid_t ptid)
if (!target_has_execution)
return 0;
if (!thread_list)
return main_thread_executing;
tp = find_thread_pid (ptid);
gdb_assert (tp);
return tp->executing_;
@ -642,15 +584,6 @@ set_executing (ptid_t ptid, int executing)
{
struct thread_info *tp;
if (!thread_list)
{
/* This target does not add the main thread to the thread list.
Use a global flag to indicate that the thread is
executing. */
main_thread_executing = executing;
return;
}
if (PIDGET (ptid) == -1)
{
for (tp = thread_list; tp; tp = tp->next)
@ -805,13 +738,7 @@ switch_to_thread (ptid_t ptid)
static void
restore_current_thread (ptid_t ptid)
{
if (!ptid_equal (ptid, inferior_ptid))
{
if (non_stop)
context_switch_to (ptid);
else
switch_to_thread (ptid);
}
switch_to_thread (ptid);
}
static void
@ -967,10 +894,7 @@ thread_apply_all_command (char *cmd, int from_tty)
for (tp = thread_list; tp; tp = tp->next)
if (thread_alive (tp))
{
if (non_stop)
context_switch_to (tp->ptid);
else
switch_to_thread (tp->ptid);
switch_to_thread (tp->ptid);
printf_filtered (_("\nThread %d (%s):\n"),
tp->num, target_tid_to_str (inferior_ptid));
@ -1040,10 +964,7 @@ thread_apply_command (char *tidlist, int from_tty)
warning (_("Thread %d has terminated."), start);
else
{
if (non_stop)
context_switch_to (tp->ptid);
else
switch_to_thread (tp->ptid);
switch_to_thread (tp->ptid);
printf_filtered (_("\nThread %d (%s):\n"), tp->num,
target_tid_to_str (inferior_ptid));
@ -1113,10 +1034,7 @@ do_captured_thread_select (struct ui_out *uiout, void *tidstr)
if (!thread_alive (tp))
error (_("Thread ID %d has terminated."), num);
if (non_stop)
context_switch_to (tp->ptid);
else
switch_to_thread (tp->ptid);
switch_to_thread (tp->ptid);
ui_out_text (uiout, "[Switching to thread ");
ui_out_field_int (uiout, "new-thread-id", pid_to_thread_id (inferior_ptid));