Rename and move inferior_thread_state and inferior_status.
	* gdbthread.h (struct thread_control_state): New struct, move fields
	step_range_start, step_range_end, step_frame_id, step_stack_frame_id,
	trap_expected, proceed_to_finish, in_infcall, step_over_calls,
	stop_step and stop_bpstat here from struct thread_info.
	(struct thread_suspend_state): New struct, move field stop_signal here
	from struct thread_info.
	(struct thread_info): Move the fields above from this struct.
	* inferior.h: Move the inferior_thread_state and inferior_status
	declarations comment to their definitions at infrun.c.
	(struct inferior_control_state): New struct, move field stop_soon from
	struct inferior here.
	(struct inferior_suspend_state): New empty struct.
	(struct inferior): New fields control and suspend.  Move out field
	stop_soon.
	* infrun.c (struct inferior_thread_state): Rename to ...
	(infcall_suspend_state): ... here.  Replace field stop_signal by
	fields thread_suspend and inferior_suspend.
	(save_inferior_thread_state): Rename to ...
	(save_infcall_suspend_state): ... here.  New variable inf.  Update the
	code for new fields.
	(restore_inferior_thread_state): Rename to ...
	(restore_infcall_suspend_state): ... here.  New variable inf.  Update
	the code for new fields.
	(do_restore_inferior_thread_state_cleanup): Rename to ...
	(do_restore_infcall_suspend_state_cleanup): ... here.
	(make_cleanup_restore_inferior_thread_state): Rename to ...
	(make_cleanup_restore_infcall_suspend_state): ... here.
	(discard_inferior_thread_state): Rename to ...
	(discard_infcall_suspend_state): ... here.
	(get_inferior_thread_state_regcache): Rename to ...
	(get_infcall_suspend_state_regcache): ... here.
	(struct inferior_status): Rename to ...
	(struct infcall_control_state): ... here.  Replace fields
	step_range_start, step_range_end, step_frame_id, step_stack_frame_id,
	trap_expected, proceed_to_finish, in_infcall, step_over_calls,
	stop_step, stop_bpstat and stop_soon by fields thread_control and
	inferior_control.
	(save_inferior_status): Rename to ...
	(save_infcall_control_state): ... here.  Update the code for new
	fields.
	(restore_inferior_status): Rename to ...
	(restore_infcall_control_state): ... here.  Update the code for new
	fields.
	(do_restore_inferior_status_cleanup): Rename to ...
	(do_restore_infcall_control_state_cleanup): ... here.
	(make_cleanup_restore_inferior_status): Rename to ...
	(make_cleanup_restore_infcall_control_state): ... here.
	(discard_inferior_status): Rename to ...
	(discard_infcall_control_state): ... here.
	* alpha-tdep.c, breakpoint.c, dummy-frame.c, dummy-frame.h,
	exceptions.c, fbsd-nat.c, gdbthread.h, infcall.c, infcmd.c,
	inferior.c, inferior.h, infrun.c, linux-nat.c, mi/mi-interp.c,
	mips-tdep.c, procfs.c, solib-irix.c, solib-osf.c, solib-spu.c,
	solib-sunos.c, solib-svr4.c, thread.c, windows-nat.c: Update all the
	references to the moved fields and renamed functions.
This commit is contained in:
Jan Kratochvil 2010-11-28 04:31:25 +00:00
parent f0df11bdc9
commit 16c381f058
24 changed files with 553 additions and 467 deletions

View file

@ -29,6 +29,88 @@ struct symtab;
#include "ui-out.h"
#include "inferior.h"
/* Inferior thread specific part of `struct infcall_control_state'.
Inferior process counterpart is `struct inferior_control_state'. */
struct thread_control_state
{
/* User/external stepping state. */
/* Range to single step within.
If this is nonzero, respond to a single-step signal by continuing
to step if the pc is in this range.
If step_range_start and step_range_end are both 1, it means to
step for a single instruction (FIXME: it might clean up
wait_for_inferior in a minor way if this were changed to the
address of the instruction and that address plus one. But maybe
not.). */
CORE_ADDR step_range_start; /* Inclusive */
CORE_ADDR step_range_end; /* Exclusive */
/* Stack frame address as of when stepping command was issued.
This is how we know when we step into a subroutine call, and how
to set the frame for the breakpoint used to step out. */
struct frame_id step_frame_id;
/* Similarly, the frame ID of the underlying stack frame (skipping
any inlined frames). */
struct frame_id step_stack_frame_id;
/* Nonzero if we are presently stepping over a breakpoint.
If we hit a breakpoint or watchpoint, and then continue, we need
to single step the current thread with breakpoints disabled, to
avoid hitting the same breakpoint or watchpoint again. And we
should step just a single thread and keep other threads stopped,
so that other threads don't miss breakpoints while they are
removed.
So, this variable simultaneously means that we need to single
step the current thread, keep other threads stopped, and that
breakpoints should be removed while we step.
This variable is set either:
- in proceed, when we resume inferior on user's explicit request
- in keep_going, if handle_inferior_event decides we need to
step over breakpoint.
The variable is cleared in normal_stop. The proceed calls
wait_for_inferior, which calls handle_inferior_event in a loop,
and until wait_for_inferior exits, this variable is changed only
by keep_going. */
int trap_expected;
/* Nonzero if the thread is being proceeded for a "finish" command
or a similar situation when stop_registers should be saved. */
int proceed_to_finish;
/* Nonzero if the thread is being proceeded for an inferior function
call. */
int in_infcall;
enum step_over_calls_kind step_over_calls;
/* Nonzero if stopped due to a step command. */
int stop_step;
/* Chain containing status of breakpoint(s) the thread stopped
at. */
bpstat stop_bpstat;
};
/* Inferior thread specific part of `struct infcall_suspend_state'.
Inferior process counterpart is `struct inferior_suspend_state'. */
struct thread_suspend_state
{
/* Last signal that the inferior received (why it stopped). */
enum target_signal stop_signal;
};
struct thread_info
{
struct thread_info *next;
@ -61,33 +143,19 @@ struct thread_info
if we detect it exiting. */
int refcount;
/* State of GDB control of inferior thread execution.
See `struct thread_control_state'. */
struct thread_control_state control;
/* State of inferior thread to restore after GDB is done with an inferior
call. See `struct thread_suspend_state'. */
struct thread_suspend_state suspend;
/* User/external stepping state. */
/* Step-resume or longjmp-resume breakpoint. */
struct breakpoint *step_resume_breakpoint;
/* Range to single step within.
If this is nonzero, respond to a single-step signal by continuing
to step if the pc is in this range.
If step_range_start and step_range_end are both 1, it means to
step for a single instruction (FIXME: it might clean up
wait_for_inferior in a minor way if this were changed to the
address of the instruction and that address plus one. But maybe
not.). */
CORE_ADDR step_range_start; /* Inclusive */
CORE_ADDR step_range_end; /* Exclusive */
/* Stack frame address as of when stepping command was issued.
This is how we know when we step into a subroutine call, and how
to set the frame for the breakpoint used to step out. */
struct frame_id step_frame_id;
/* Similarly, the frame ID of the underlying stack frame (skipping
any inlined frames). */
struct frame_id step_stack_frame_id;
int current_line;
struct symtab *current_symtab;
@ -99,30 +167,6 @@ struct thread_info
SIGTRAP from a breakpoint SIGTRAP. */
CORE_ADDR prev_pc;
/* Nonzero if we are presently stepping over a breakpoint.
If we hit a breakpoint or watchpoint, and then continue, we need
to single step the current thread with breakpoints disabled, to
avoid hitting the same breakpoint or watchpoint again. And we
should step just a single thread and keep other threads stopped,
so that other threads don't miss breakpoints while they are
removed.
So, this variable simultaneously means that we need to single
step the current thread, keep other threads stopped, and that
breakpoints should be removed while we step.
This variable is set either:
- in proceed, when we resume inferior on user's explicit request
- in keep_going, if handle_inferior_event decides we need to
step over breakpoint.
The variable is cleared in normal_stop. The proceed calls
wait_for_inferior, which calls handle_inferior_event in a loop,
and until wait_for_inferior exits, this variable is changed only
by keep_going. */
int trap_expected;
/* Should we step over breakpoint next time keep_going is called? */
int stepping_over_breakpoint;
@ -153,19 +197,6 @@ struct thread_info
command. */
struct continuation *intermediate_continuations;
/* Nonzero if the thread is being proceeded for a "finish" command
or a similar situation when stop_registers should be saved. */
int proceed_to_finish;
/* Nonzero if the thread is being proceeded for an inferior function
call. */
int in_infcall;
enum step_over_calls_kind step_over_calls;
/* Nonzero if stopped due to a step command. */
int stop_step;
/* If stepping, nonzero means step count is > 1 so don't print frame
next time inferior stops if it stops due to stepping. */
int step_multi;
@ -175,13 +206,6 @@ struct thread_info
resume of the thread, and not immediately. */
struct target_waitstatus pending_follow;
/* Last signal that the inferior received (why it stopped). */
enum target_signal stop_signal;
/* Chain containing status of breakpoint(s) the thread stopped
at. */
bpstat stop_bpstat;
/* True if this thread has been explicitly requested to stop. */
int stop_requested;