ptid_t inferior_ptid;
-/* Address at which inferior stopped. */
-
-CORE_ADDR stop_pc;
-
/* Nonzero if stopped due to completion of a stack dummy routine. */
enum stop_stack_kind stop_stack_dummy;
/* Now that we know the register layout, retrieve current PC. But
if the PC is unavailable (e.g., we're opening a core file with
missing registers info), ignore it. */
- stop_pc = 0;
+ thread_info *thr = inferior_thread ();
+
+ thr->suspend.stop_pc = 0;
TRY
{
- stop_pc = regcache_read_pc (get_current_regcache ());
+ thr->suspend.stop_pc = regcache_read_pc (get_current_regcache ());
}
CATCH (ex, RETURN_MASK_ERROR)
{
/* Pass zero for FROM_TTY, because at this point the "run" command
has done its thing; now we are setting up the running program. */
- post_create_inferior (target_stack, 0);
+ post_create_inferior (current_top_target (), 0);
/* Queue a pending event so that the program stops immediately. */
if (run_how == RUN_STOP_AT_FIRST_INSN)
much. If/when GDB gains a way to tell the target `hold this
thread stopped until I say otherwise', then we can optimize
this. */
- if (!is_stopped (thread->ptid))
+ if (thread->state != THREAD_STOPPED)
return 0;
- switch_to_thread (thread->ptid);
+ switch_to_thread (thread);
clear_proceed_status (0);
proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
return 0;
static void
ensure_valid_thread (void)
{
- if (ptid_equal (inferior_ptid, null_ptid)
- || is_exited (inferior_ptid))
+ if (inferior_ptid == null_ptid
+ || inferior_thread ()->state == THREAD_EXITED)
error (_("Cannot execute this command without a live selected thread."));
}
static void
ensure_not_running (void)
{
- if (is_running (inferior_ptid))
+ if (inferior_thread ()->state == THREAD_RUNNING)
error_is_running ();
}
struct thread_info *tp;
if (non_stop)
- tp = find_thread_ptid (inferior_ptid);
+ tp = inferior_thread ();
else
{
ptid_t last_ptid;
ensure_not_running ();
}
- prepare_execution_command (target_stack, async_exec);
+ prepare_execution_command (current_top_target (), async_exec);
if (from_tty)
printf_filtered (_("Continuing.\n"));
= strip_bg_char (count_string, &async_exec);
count_string = stripped.get ();
- prepare_execution_command (target_stack, async_exec);
+ prepare_execution_command (current_top_target (), async_exec);
count = count_string ? parse_and_eval_long (count_string) : 1;
/* Step at an inlined function behaves like "down". */
if (!sm->skip_subroutines
- && inline_skipped_frames (inferior_ptid))
+ && inline_skipped_frames (tp))
{
ptid_t resume_ptid;
resume_ptid = user_visible_resume_ptid (1);
set_running (resume_ptid, 1);
- step_into_inline_frame (inferior_ptid);
+ step_into_inline_frame (tp);
sm->count--;
return prepare_one_step (sm);
}
gdb::unique_xmalloc_ptr<char> stripped = strip_bg_char (arg, &async_exec);
arg = stripped.get ();
- prepare_execution_command (target_stack, async_exec);
+ prepare_execution_command (current_top_target (), async_exec);
if (!arg)
error_no_arg (_("starting address"));
= strip_bg_char (signum_exp, &async_exec);
signum_exp = stripped.get ();
- prepare_execution_command (target_stack, async_exec);
+ prepare_execution_command (current_top_target (), async_exec);
if (!signum_exp)
error_no_arg (_("signal number"));
gdb::unique_xmalloc_ptr<char> stripped = strip_bg_char (arg, &async_exec);
arg = stripped.get ();
- prepare_execution_command (target_stack, async_exec);
+ prepare_execution_command (current_top_target (), async_exec);
if (arg)
until_break_command (arg, from_tty, 0);
gdb::unique_xmalloc_ptr<char> stripped = strip_bg_char (arg, &async_exec);
arg = stripped.get ();
- prepare_execution_command (target_stack, async_exec);
+ prepare_execution_command (current_top_target (), async_exec);
until_break_command (arg, from_tty, 1);
}
uiout->field_fmt ("gdb-result-var", "$%d",
rv->value_history_index);
uiout->text (" = ");
- get_no_prettyformat_print_options (&opts);
+ get_user_print_options (&opts);
string_file stb;
gdb::unique_xmalloc_ptr<char> stripped = strip_bg_char (arg, &async_exec);
arg = stripped.get ();
- prepare_execution_command (target_stack, async_exec);
+ prepare_execution_command (current_top_target (), async_exec);
if (arg)
error (_("The \"finish\" command does not take any arguments."));
{
bpstat bs;
int num, stat;
- struct thread_info *tp;
ptid_t ptid;
if (!target_has_execution)
get_last_target_status (&ptid, &ws);
}
- if (ptid_equal (ptid, null_ptid) || is_exited (ptid))
+ if (ptid == null_ptid)
+ error (_("No selected thread."));
+
+ thread_info *tp = find_thread_ptid (ptid);
+
+ if (tp->state == THREAD_EXITED)
error (_("Invalid selected thread."));
- else if (is_running (ptid))
+ else if (tp->state == THREAD_RUNNING)
error (_("Selected thread is running."));
- tp = find_thread_ptid (ptid);
bs = tp->control.stop_bpstat;
stat = bpstat_num (&bs, &num);
target_files_info ();
printf_filtered (_("Program stopped at %s.\n"),
- paddress (target_gdbarch (), stop_pc));
+ paddress (target_gdbarch (), tp->suspend.stop_pc));
if (tp->control.stop_step)
printf_filtered (_("It stopped after being stepped.\n"));
else if (stat != 0)
int pid = current_inferior ()->pid;
/* Save the pid as a string before killing the inferior, since that
may unpush the current target, and we need the string after. */
- std::string pid_str = target_pid_to_str (pid_to_ptid (pid));
+ std::string pid_str = target_pid_to_str (ptid_t (pid));
int infnum = current_inferior ()->num;
target_kill ();
{
int pid = * (int *) arg;
- if (ptid_get_pid (thread->ptid) == pid
- && !is_exited (thread->ptid)
- && !is_executing (thread->ptid)
+ if (thread->ptid.pid () == pid
+ && thread->state != THREAD_EXITED
+ && !thread->executing
&& !thread->stop_requested
&& thread->suspend.stop_signal == GDB_SIGNAL_0)
{
- switch_to_thread (thread->ptid);
+ switch_to_thread (thread);
clear_proceed_status (0);
proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
}
/* If no exec file is yet known, try to determine it from the
process itself. */
if (get_exec_file (0) == NULL)
- exec_file_locate_attach (ptid_get_pid (inferior_ptid), 1, from_tty);
+ exec_file_locate_attach (inferior_ptid.pid (), 1, from_tty);
else
{
reopen_exec_file ();
}
/* Take any necessary post-attaching actions for this platform. */
- target_post_attach (ptid_get_pid (inferior_ptid));
+ target_post_attach (inferior_ptid.pid ());
- post_create_inferior (target_stack, from_tty);
+ post_create_inferior (current_top_target (), from_tty);
}
/* What to do after the first program stops after attaching. */
Be sure to explicitly stop all threads of the process. This
should have no effect on already stopped threads. */
if (non_stop)
- target_stop (pid_to_ptid (inferior->pid));
+ target_stop (ptid_t (inferior->pid));
else if (target_is_non_stop_p ())
{
struct thread_info *thread;
still exists. */
ALL_NON_EXITED_THREADS (thread)
{
- if (ptid_get_pid (thread->ptid) == pid)
+ if (thread->ptid.pid () == pid)
{
if (thread->inf->num < lowest->inf->num
|| thread->per_inf_num < lowest->per_inf_num)
}
}
- switch_to_thread (lowest->ptid);
+ switch_to_thread (lowest);
}
/* Tell the user/frontend where we're stopped. */
else
/* The user requested an `attach', so stop all threads of this
inferior. */
- target_stop (pid_to_ptid (ptid_get_pid (inferior_ptid)));
+ target_stop (ptid_t (inferior_ptid.pid ()));
}
mode = async_exec ? ATTACH_POST_WAIT_RESUME : ATTACH_POST_WAIT_STOP;
as stopped. */
void
-notice_new_inferior (ptid_t ptid, int leave_running, int from_tty)
+notice_new_inferior (thread_info *thr, int leave_running, int from_tty)
{
enum attach_post_wait_mode mode
= leave_running ? ATTACH_POST_WAIT_RESUME : ATTACH_POST_WAIT_NOTHING;
/* Avoid reading registers -- we haven't fetched the target
description yet. */
- switch_to_thread_no_regs (find_thread_ptid (ptid));
+ switch_to_thread_no_regs (thr);
/* When we "notice" a new inferior we need to do all the things we
would normally do if we had just attached to it. */
- if (is_executing (inferior_ptid))
+ if (thr->executing)
{
struct attach_command_continuation_args *a;
struct inferior *inferior = current_inferior ();
c = add_com ("jump", class_run, jump_command, _("\
Continue program being debugged at specified line or address.\n\
-Usage: jump <location>\n\
+Usage: jump LOCATION\n\
Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
for an address to start at."));
set_cmd_completer (c, location_completer);