00431a78b2
This is more preparation bits for multi-target support. In a multi-target scenario, we need to address the case of different processes/threads running on different targets that happen to have the same PID/PTID. E.g., we can have both process 123 in target 1, and process 123 in target 2, while they're in reality different processes running on different machines. Or maybe we've loaded multiple instances of the same core file. Etc. To address this, in my WIP multi-target branch, threads and processes are uniquely identified by the (process_stratum target_ops *, ptid_t) and (process_stratum target_ops *, pid) tuples respectively. I.e., each process_stratum instance has its own thread/process number space. As you can imagine, that requires passing around target_ops * pointers in a number of functions where we're currently passing only a ptid_t or an int. E.g., when we look up a thread_info object by ptid_t in find_thread_ptid, the ptid_t alone isn't sufficient. In many cases though, we already have the thread_info or inferior pointer handy, but we "lose" it somewhere along the call stack, only to look it up again by ptid_t/pid. Since thread_info or inferior objects know their parent target, if we pass around thread_info or inferior pointers when possible, we avoid having to add extra target_ops parameters to many functions, and also, we eliminate a number of by ptid_t/int lookups. So that's what this patch does. In a bit more detail: - Changes a number of functions and methods to take a thread_info or inferior pointer instead of a ptid_t or int parameter. - Changes a number of structure fields from ptid_t/int to inferior or thread_info pointers. - Uses the inferior_thread() function whenever possible instead of inferior_ptid. - Uses thread_info pointers directly when possible instead of the is_running/is_stopped etc. routines that require a lookup. - A number of functions are eliminated along the way, such as: int valid_gdb_inferior_id (int num); int pid_to_gdb_inferior_id (int pid); int gdb_inferior_id_to_pid (int num); int in_inferior_list (int pid); - A few structures and places hold a thread_info pointer across inferior execution, so now they take a strong reference to the (refcounted) thread_info object to avoid the thread_info pointer getting stale. This is done in enable_thread_stack_temporaries and in the infcall.c code. - Related, there's a spot in infcall.c where using a RAII object to handle the refcount would be handy, so a gdb::ref_ptr specialization for thread_info is added (thread_info_ref, in gdbthread.h), along with a gdb_ref_ptr policy that works for all refcounted_object types (in common/refcounted-object.h). gdb/ChangeLog: 2018-06-21 Pedro Alves <palves@redhat.com> * ada-lang.h (ada_get_task_number): Take a thread_info pointer instead of a ptid_t. All callers adjusted. * ada-tasks.c (ada_get_task_number): Likewise. All callers adjusted. (print_ada_task_info, display_current_task_id, task_command_1): Adjust. * breakpoint.c (watchpoint_in_thread_scope): Adjust to use inferior_thread. (breakpoint_kind): Adjust. (remove_breakpoints_pid): Rename to ... (remove_breakpoints_inf): ... this. Adjust to take an inferior pointer. All callers adjusted. (bpstat_clear_actions): Use inferior_thread. (get_bpstat_thread): New. (bpstat_do_actions): Use it. (bpstat_check_breakpoint_conditions, bpstat_stop_status): Adjust to take a thread_info pointer. All callers adjusted. (set_longjmp_breakpoint_for_call_dummy, set_momentary_breakpoint) (breakpoint_re_set_thread): Use inferior_thread. * breakpoint.h (struct inferior): Forward declare. (bpstat_stop_status): Update. (remove_breakpoints_pid): Delete. (remove_breakpoints_inf): New. * bsd-uthread.c (bsd_uthread_target::wait) (bsd_uthread_target::update_thread_list): Use find_thread_ptid. * btrace.c (btrace_add_pc, btrace_enable, btrace_fetch) (maint_btrace_packet_history_cmd) (maint_btrace_clear_packet_history_cmd): Adjust. (maint_btrace_clear_cmd, maint_info_btrace_cmd): Adjust to use inferior_thread. * cli/cli-interp.c: Include "inferior.h". * common/refcounted-object.h (struct refcounted_object_ref_policy): New. * compile/compile-object-load.c: Include gdbthread.h. (store_regs): Use inferior_thread. * corelow.c (core_target::close): Use current_inferior. (core_target_open): Adjust to use first_thread_of_inferior and use the current inferior. * ctf.c (ctf_target::close): Adjust to use current_inferior. * dummy-frame.c (dummy_frame_id) <ptid>: Delete, replaced by ... <thread>: ... this new field. All references adjusted. (dummy_frame_pop, dummy_frame_discard, register_dummy_frame_dtor): Take a thread_info pointer instead of a ptid_t. * dummy-frame.h (dummy_frame_push, dummy_frame_pop) (dummy_frame_discard, register_dummy_frame_dtor): Take a thread_info pointer instead of a ptid_t. * elfread.c: Include "inferior.h". (elf_gnu_ifunc_resolver_stop, elf_gnu_ifunc_resolver_return_stop): Use inferior_thread. * eval.c (evaluate_subexp): Likewise. * frame.c (frame_pop, has_stack_frames, find_frame_sal): Use inferior_thread. * gdb_proc_service.h (struct thread_info): Forward declare. (struct ps_prochandle) <ptid>: Delete, replaced by ... <thread>: ... this new field. All references adjusted. * gdbarch.h, gdbarch.c: Regenerate. * gdbarch.sh (get_syscall_number): Replace 'ptid' parameter with a 'thread' parameter. All implementations and callers adjusted. * gdbthread.h (thread_info) <set_running>: New method. (delete_thread, delete_thread_silent): Take a thread_info pointer instead of a ptid. (global_thread_id_to_ptid, ptid_to_global_thread_id): Delete. (first_thread_of_process): Delete, replaced by ... (first_thread_of_inferior): ... this new function. All callers adjusted. (any_live_thread_of_process): Delete, replaced by ... (any_live_thread_of_inferior): ... this new function. All callers adjusted. (switch_to_thread, switch_to_no_thread): Declare. (is_executing): Delete. (enable_thread_stack_temporaries): Update comment. <enable_thread_stack_temporaries>: Take a thread_info pointer instead of a ptid_t. Incref the thread. <~enable_thread_stack_temporaries>: Decref the thread. <m_ptid>: Delete <m_thr>: New. (thread_stack_temporaries_enabled_p, push_thread_stack_temporary) (get_last_thread_stack_temporary) (value_in_thread_stack_temporaries, can_access_registers_thread): Take a thread_info pointer instead of a ptid_t. All callers adjusted. * infcall.c (get_call_return_value): Use inferior_thread. (run_inferior_call): Work with thread pointers instead of ptid_t. (call_function_by_hand_dummy): Work with thread pointers instead of ptid_t. Use thread_info_ref. * infcmd.c (proceed_thread_callback): Access thread's state directly. (ensure_valid_thread, ensure_not_running): Use inferior_thread, access thread's state directly. (continue_command): Use inferior_thread. (info_program_command): Use find_thread_ptid and access thread state directly. (proceed_after_attach_callback): Use thread state directly. (notice_new_inferior): Take a thread_info pointer instead of a ptid_t. All callers adjusted. (exit_inferior): Take an inferior pointer instead of a pid. All callers adjusted. (exit_inferior_silent): New. (detach_inferior): Delete. (valid_gdb_inferior_id, pid_to_gdb_inferior_id) (gdb_inferior_id_to_pid, in_inferior_list): Delete. (detach_inferior_command, kill_inferior_command): Use find_inferior_id instead of valid_gdb_inferior_id and gdb_inferior_id_to_pid. (inferior_command): Use inferior and thread pointers. * inferior.h (struct thread_info): Forward declare. (notice_new_inferior): Take a thread_info pointer instead of a ptid_t. All callers adjusted. (detach_inferior): Delete declaration. (exit_inferior, exit_inferior_silent): Take an inferior pointer instead of a pid. All callers adjusted. (gdb_inferior_id_to_pid, pid_to_gdb_inferior_id, in_inferior_list) (valid_gdb_inferior_id): Delete. * infrun.c (follow_fork_inferior, proceed_after_vfork_done) (handle_vfork_child_exec_or_exit, follow_exec): Adjust. (struct displaced_step_inferior_state) <pid>: Delete, replaced by ... <inf>: ... this new field. <step_ptid>: Delete, replaced by ... <step_thread>: ... this new field. (get_displaced_stepping_state): Take an inferior pointer instead of a pid. All callers adjusted. (displaced_step_in_progress_any_inferior): Adjust. (displaced_step_in_progress_thread): Take a thread pointer instead of a ptid_t. All callers adjusted. (displaced_step_in_progress, add_displaced_stepping_state): Take an inferior pointer instead of a pid. All callers adjusted. (get_displaced_step_closure_by_addr): Adjust. (remove_displaced_stepping_state): Take an inferior pointer instead of a pid. All callers adjusted. (displaced_step_prepare_throw, displaced_step_prepare) (displaced_step_fixup): Take a thread pointer instead of a ptid_t. All callers adjusted. (start_step_over): Adjust. (infrun_thread_ptid_changed): Remove bit updating ptids in the displaced step queue. (do_target_resume): Adjust. (fetch_inferior_event): Use inferior_thread. (context_switch, get_inferior_stop_soon): Take an execution_control_state pointer instead of a ptid_t. All callers adjusted. (switch_to_thread_cleanup): Delete. (stop_all_threads): Use scoped_restore_current_thread. * inline-frame.c: Include "gdbthread.h". (inline_state) <inline_state>: Take a thread pointer instead of a ptid_t. All callers adjusted. <ptid>: Delete, replaced by ... <thread>: ... this new field. (find_inline_frame_state): Take a thread pointer instead of a ptid_t. All callers adjusted. (skip_inline_frames, step_into_inline_frame) (inline_skipped_frames, inline_skipped_symbol): Take a thread pointer instead of a ptid_t. All callers adjusted. * inline-frame.h (skip_inline_frames, step_into_inline_frame) (inline_skipped_frames, inline_skipped_symbol): Likewise. * linux-fork.c (delete_checkpoint_command): Adjust to use thread pointers directly. * linux-nat.c (get_detach_signal): Likewise. * linux-thread-db.c (thread_from_lwp): New 'stopped' parameter. (thread_db_notice_clone): Adjust. (thread_db_find_new_threads_silently) (thread_db_find_new_threads_2, thread_db_find_new_threads_1): Take a thread pointer instead of a ptid_t. All callers adjusted. * mi/mi-cmd-var.c: Include "inferior.h". (mi_cmd_var_update_iter): Update to use thread pointers. * mi/mi-interp.c (mi_new_thread): Update to use the thread's inferior directly. (mi_output_running_pid, mi_inferior_count): Delete, bits factored out to ... (mi_output_running): ... this new function. (mi_on_resume_1): Adjust to use it. (mi_user_selected_context_changed): Adjust to use inferior_thread. * mi/mi-main.c (proceed_thread): Adjust to use thread pointers directly. (interrupt_thread_callback): : Adjust to use thread and inferior pointers. * proc-service.c: Include "gdbthread.h". (ps_pglobal_lookup): Adjust to use the thread's inferior directly. * progspace-and-thread.c: Include "inferior.h". * progspace.c: Include "inferior.h". * python/py-exitedevent.c (create_exited_event_object): Adjust to hold a reference to an inferior_object. * python/py-finishbreakpoint.c (bpfinishpy_init): Adjust to use inferior_thread. * python/py-inferior.c (struct inferior_object): Give the type a tag name instead of a typedef. (python_on_normal_stop): No need to check if the current thread is listed. (inferior_to_inferior_object): Change return type to inferior_object. All callers adjusted. (find_thread_object): Delete, bits factored out to ... (thread_to_thread_object): ... this new function. * python/py-infthread.c (create_thread_object): Use inferior_to_inferior_object. (thpy_is_stopped): Use thread pointer directly. (gdbpy_selected_thread): Use inferior_thread. * python/py-record-btrace.c (btpy_list_object) <ptid>: Delete field, replaced with ... <thread>: ... this new field. All users adjusted. (btpy_insn_or_gap_new): Drop const. (btpy_list_new): Take a thread pointer instead of a ptid_t. All callers adjusted. * python/py-record.c: Include "gdbthread.h". (recpy_insn_new, recpy_func_new): Take a thread pointer instead of a ptid_t. All callers adjusted. (gdbpy_current_recording): Use inferior_thread. * python/py-record.h (recpy_record_object) <ptid>: Delete field, replaced with ... <thread>: ... this new field. All users adjusted. (recpy_element_object) <ptid>: Delete field, replaced with ... <thread>: ... this new field. All users adjusted. (recpy_insn_new, recpy_func_new): Take a thread pointer instead of a ptid_t. All callers adjusted. * python/py-threadevent.c: Include "gdbthread.h". (get_event_thread): Use thread_to_thread_object. * python/python-internal.h (struct inferior_object): Forward declare. (find_thread_object, find_inferior_object): Delete declarations. (thread_to_thread_object, inferior_to_inferior_object): New declarations. * record-btrace.c: Include "inferior.h". (require_btrace_thread): Use inferior_thread. (record_btrace_frame_sniffer) (record_btrace_tailcall_frame_sniffer): Use inferior_thread. (get_thread_current_frame): Use scoped_restore_current_thread and switch_to_thread. (get_thread_current_frame): Use thread pointer directly. (record_btrace_replay_at_breakpoint): Use thread's inferior pointer directly. * record-full.c: Include "inferior.h". * regcache.c: Include "gdbthread.h". (get_thread_arch_regcache): Use the inferior's address space directly. (get_thread_regcache, registers_changed_thread): New. * regcache.h (get_thread_regcache(thread_info *thread)): New overload. (registers_changed_thread): New. (remote_target) <remote_detach_1>: Swap order of parameters. (remote_add_thread): <remote_add_thread>: Return the new thread. (get_remote_thread_info(ptid_t)): New overload. (remote_target::remote_notice_new_inferior): Use thread pointers directly. (remote_target::process_initial_stop_replies): Use thread_info::set_running. (remote_target::remote_detach_1, remote_target::detach) (extended_remote_target::detach): Adjust. * stack.c (frame_show_address): Use inferior_thread. * target-debug.h (target_debug_print_thread_info_pp): New. * target-delegates.c: Regenerate. * target.c (default_thread_address_space): Delete. (memory_xfer_partial_1): Use current_inferior. (target_detach): Use current_inferior. (target_thread_address_space): Delete. (generic_mourn_inferior): Use current_inferior. * target.h (struct target_ops) <thread_address_space>: Delete. (target_thread_address_space): Delete. * thread.c (init_thread_list): Use ALL_THREADS_SAFE. Use thread pointers directly. (delete_thread_1, delete_thread, delete_thread_silent): Take a thread pointer instead of a ptid_t. Adjust all callers. (ptid_to_global_thread_id, global_thread_id_to_ptid): Delete. (first_thread_of_process): Delete, replaced by ... (first_thread_of_inferior): ... this new function. All callers adjusted. (any_thread_of_process): Rename to ... (any_thread_of_inferior): ... this, and take an inferior pointer. (any_live_thread_of_process): Rename to ... (any_live_thread_of_inferior): ... this, and take an inferior pointer. (thread_stack_temporaries_enabled_p, push_thread_stack_temporary) (value_in_thread_stack_temporaries) (get_last_thread_stack_temporary): Take a thread pointer instead of a ptid_t. Adjust all callers. (thread_info::set_running): New. (validate_registers_access): Use inferior_thread. (can_access_registers_ptid): Rename to ... (can_access_registers_thread): ... this, and take a thread pointer. (print_thread_info_1): Adjust to compare thread pointers instead of ptids. (switch_to_no_thread, switch_to_thread): Make extern. (scoped_restore_current_thread::~scoped_restore_current_thread): Use m_thread pointer directly. (scoped_restore_current_thread::scoped_restore_current_thread): Use inferior_thread. (thread_command): Use thread pointer directly. (thread_num_make_value_helper): Use inferior_thread. * top.c (execute_command): Use inferior_thread. * tui/tui-interp.c: Include "inferior.h". * varobj.c (varobj_create): Use inferior_thread. (value_of_root_1): Use find_thread_global_id instead of global_thread_id_to_ptid.
996 lines
22 KiB
C
996 lines
22 KiB
C
/* Multi-process control for GDB, the GNU debugger.
|
||
|
||
Copyright (C) 2008-2018 Free Software Foundation, Inc.
|
||
|
||
This file is part of GDB.
|
||
|
||
This program is free software; you can redistribute it and/or modify
|
||
it under the terms of the GNU General Public License as published by
|
||
the Free Software Foundation; either version 3 of the License, or
|
||
(at your option) any later version.
|
||
|
||
This program is distributed in the hope that it will be useful,
|
||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
GNU General Public License for more details.
|
||
|
||
You should have received a copy of the GNU General Public License
|
||
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
||
|
||
#include "defs.h"
|
||
#include "exec.h"
|
||
#include "inferior.h"
|
||
#include "target.h"
|
||
#include "command.h"
|
||
#include "completer.h"
|
||
#include "gdbcmd.h"
|
||
#include "gdbthread.h"
|
||
#include "ui-out.h"
|
||
#include "observable.h"
|
||
#include "gdbcore.h"
|
||
#include "symfile.h"
|
||
#include "environ.h"
|
||
#include "cli/cli-utils.h"
|
||
#include "continuations.h"
|
||
#include "arch-utils.h"
|
||
#include "target-descriptions.h"
|
||
#include "readline/tilde.h"
|
||
#include "progspace-and-thread.h"
|
||
|
||
/* Keep a registry of per-inferior data-pointers required by other GDB
|
||
modules. */
|
||
|
||
DEFINE_REGISTRY (inferior, REGISTRY_ACCESS_FIELD)
|
||
|
||
struct inferior *inferior_list = NULL;
|
||
static int highest_inferior_num;
|
||
|
||
/* See inferior.h. */
|
||
int print_inferior_events = 1;
|
||
|
||
/* The Current Inferior. This is a strong reference. I.e., whenever
|
||
an inferior is the current inferior, its refcount is
|
||
incremented. */
|
||
static struct inferior *current_inferior_ = NULL;
|
||
|
||
struct inferior*
|
||
current_inferior (void)
|
||
{
|
||
return current_inferior_;
|
||
}
|
||
|
||
void
|
||
set_current_inferior (struct inferior *inf)
|
||
{
|
||
/* There's always an inferior. */
|
||
gdb_assert (inf != NULL);
|
||
|
||
inf->incref ();
|
||
current_inferior_->decref ();
|
||
current_inferior_ = inf;
|
||
}
|
||
|
||
private_inferior::~private_inferior () = default;
|
||
|
||
inferior::~inferior ()
|
||
{
|
||
inferior *inf = this;
|
||
|
||
discard_all_inferior_continuations (inf);
|
||
inferior_free_data (inf);
|
||
xfree (inf->args);
|
||
xfree (inf->terminal);
|
||
target_desc_info_free (inf->tdesc_info);
|
||
}
|
||
|
||
inferior::inferior (int pid_)
|
||
: num (++highest_inferior_num),
|
||
pid (pid_),
|
||
environment (gdb_environ::from_host_environ ()),
|
||
registry_data ()
|
||
{
|
||
inferior_alloc_data (this);
|
||
}
|
||
|
||
struct inferior *
|
||
add_inferior_silent (int pid)
|
||
{
|
||
inferior *inf = new inferior (pid);
|
||
|
||
if (inferior_list == NULL)
|
||
inferior_list = inf;
|
||
else
|
||
{
|
||
inferior *last;
|
||
|
||
for (last = inferior_list; last->next != NULL; last = last->next)
|
||
;
|
||
last->next = inf;
|
||
}
|
||
|
||
gdb::observers::inferior_added.notify (inf);
|
||
|
||
if (pid != 0)
|
||
inferior_appeared (inf, pid);
|
||
|
||
return inf;
|
||
}
|
||
|
||
struct inferior *
|
||
add_inferior (int pid)
|
||
{
|
||
struct inferior *inf = add_inferior_silent (pid);
|
||
|
||
if (print_inferior_events)
|
||
printf_unfiltered (_("[New inferior %d (%s)]\n"),
|
||
inf->num,
|
||
target_pid_to_str (pid_to_ptid (pid)));
|
||
|
||
return inf;
|
||
}
|
||
|
||
struct delete_thread_of_inferior_arg
|
||
{
|
||
int pid;
|
||
int silent;
|
||
};
|
||
|
||
static int
|
||
delete_thread_of_inferior (struct thread_info *tp, void *data)
|
||
{
|
||
struct delete_thread_of_inferior_arg *arg
|
||
= (struct delete_thread_of_inferior_arg *) data;
|
||
|
||
if (ptid_get_pid (tp->ptid) == arg->pid)
|
||
{
|
||
if (arg->silent)
|
||
delete_thread_silent (tp);
|
||
else
|
||
delete_thread (tp);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
void
|
||
delete_inferior (struct inferior *todel)
|
||
{
|
||
struct inferior *inf, *infprev;
|
||
struct delete_thread_of_inferior_arg arg;
|
||
|
||
infprev = NULL;
|
||
|
||
for (inf = inferior_list; inf; infprev = inf, inf = inf->next)
|
||
if (inf == todel)
|
||
break;
|
||
|
||
if (!inf)
|
||
return;
|
||
|
||
arg.pid = inf->pid;
|
||
arg.silent = 1;
|
||
|
||
iterate_over_threads (delete_thread_of_inferior, &arg);
|
||
|
||
if (infprev)
|
||
infprev->next = inf->next;
|
||
else
|
||
inferior_list = inf->next;
|
||
|
||
gdb::observers::inferior_removed.notify (inf);
|
||
|
||
/* If this program space is rendered useless, remove it. */
|
||
if (program_space_empty_p (inf->pspace))
|
||
delete_program_space (inf->pspace);
|
||
|
||
delete inf;
|
||
}
|
||
|
||
/* If SILENT then be quiet -- don't announce a inferior exit, or the
|
||
exit of its threads. */
|
||
|
||
static void
|
||
exit_inferior_1 (struct inferior *inftoex, int silent)
|
||
{
|
||
struct inferior *inf;
|
||
struct delete_thread_of_inferior_arg arg;
|
||
|
||
for (inf = inferior_list; inf; inf = inf->next)
|
||
if (inf == inftoex)
|
||
break;
|
||
|
||
if (!inf)
|
||
return;
|
||
|
||
arg.pid = inf->pid;
|
||
arg.silent = silent;
|
||
|
||
iterate_over_threads (delete_thread_of_inferior, &arg);
|
||
|
||
gdb::observers::inferior_exit.notify (inf);
|
||
|
||
inf->pid = 0;
|
||
inf->fake_pid_p = 0;
|
||
inf->priv = NULL;
|
||
|
||
if (inf->vfork_parent != NULL)
|
||
{
|
||
inf->vfork_parent->vfork_child = NULL;
|
||
inf->vfork_parent = NULL;
|
||
}
|
||
if (inf->vfork_child != NULL)
|
||
{
|
||
inf->vfork_child->vfork_parent = NULL;
|
||
inf->vfork_child = NULL;
|
||
}
|
||
|
||
inf->pending_detach = 0;
|
||
/* Reset it. */
|
||
inf->control = {NO_STOP_QUIETLY};
|
||
}
|
||
|
||
void
|
||
exit_inferior (inferior *inf)
|
||
{
|
||
int pid = inf->pid;
|
||
exit_inferior_1 (inf, 0);
|
||
}
|
||
|
||
void
|
||
exit_inferior_silent (int pid)
|
||
{
|
||
struct inferior *inf = find_inferior_pid (pid);
|
||
|
||
exit_inferior_1 (inf, 1);
|
||
}
|
||
|
||
void
|
||
exit_inferior_silent (inferior *inf)
|
||
{
|
||
exit_inferior_1 (inf, 1);
|
||
}
|
||
|
||
void
|
||
exit_inferior_num_silent (int num)
|
||
{
|
||
struct inferior *inf = find_inferior_id (num);
|
||
|
||
exit_inferior_1 (inf, 1);
|
||
}
|
||
|
||
/* See inferior.h. */
|
||
|
||
void
|
||
detach_inferior (inferior *inf)
|
||
{
|
||
/* Save the pid, since exit_inferior_1 will reset it. */
|
||
int pid = inf->pid;
|
||
|
||
exit_inferior_1 (inf, 0);
|
||
|
||
if (print_inferior_events)
|
||
printf_unfiltered (_("[Inferior %d (%s) detached]\n"),
|
||
inf->num,
|
||
target_pid_to_str (pid_to_ptid (pid)));
|
||
}
|
||
|
||
void
|
||
inferior_appeared (struct inferior *inf, int pid)
|
||
{
|
||
inf->pid = pid;
|
||
inf->has_exit_code = 0;
|
||
inf->exit_code = 0;
|
||
|
||
gdb::observers::inferior_appeared.notify (inf);
|
||
}
|
||
|
||
void
|
||
discard_all_inferiors (void)
|
||
{
|
||
struct inferior *inf;
|
||
|
||
for (inf = inferior_list; inf; inf = inf->next)
|
||
{
|
||
if (inf->pid != 0)
|
||
exit_inferior_silent (inf);
|
||
}
|
||
}
|
||
|
||
struct inferior *
|
||
find_inferior_id (int num)
|
||
{
|
||
struct inferior *inf;
|
||
|
||
for (inf = inferior_list; inf; inf = inf->next)
|
||
if (inf->num == num)
|
||
return inf;
|
||
|
||
return NULL;
|
||
}
|
||
|
||
struct inferior *
|
||
find_inferior_pid (int pid)
|
||
{
|
||
struct inferior *inf;
|
||
|
||
/* Looking for inferior pid == 0 is always wrong, and indicative of
|
||
a bug somewhere else. There may be more than one with pid == 0,
|
||
for instance. */
|
||
gdb_assert (pid != 0);
|
||
|
||
for (inf = inferior_list; inf; inf = inf->next)
|
||
if (inf->pid == pid)
|
||
return inf;
|
||
|
||
return NULL;
|
||
}
|
||
|
||
/* See inferior.h */
|
||
|
||
struct inferior *
|
||
find_inferior_ptid (ptid_t ptid)
|
||
{
|
||
return find_inferior_pid (ptid_get_pid (ptid));
|
||
}
|
||
|
||
/* See inferior.h. */
|
||
|
||
struct inferior *
|
||
find_inferior_for_program_space (struct program_space *pspace)
|
||
{
|
||
struct inferior *inf = current_inferior ();
|
||
|
||
if (inf->pspace == pspace)
|
||
return inf;
|
||
|
||
for (inf = inferior_list; inf != NULL; inf = inf->next)
|
||
{
|
||
if (inf->pspace == pspace)
|
||
return inf;
|
||
}
|
||
|
||
return NULL;
|
||
}
|
||
|
||
struct inferior *
|
||
iterate_over_inferiors (int (*callback) (struct inferior *, void *),
|
||
void *data)
|
||
{
|
||
struct inferior *inf, *infnext;
|
||
|
||
for (inf = inferior_list; inf; inf = infnext)
|
||
{
|
||
infnext = inf->next;
|
||
if ((*callback) (inf, data))
|
||
return inf;
|
||
}
|
||
|
||
return NULL;
|
||
}
|
||
|
||
int
|
||
have_inferiors (void)
|
||
{
|
||
struct inferior *inf;
|
||
|
||
for (inf = inferior_list; inf; inf = inf->next)
|
||
if (inf->pid != 0)
|
||
return 1;
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Return the number of live inferiors. We account for the case
|
||
where an inferior might have a non-zero pid but no threads, as
|
||
in the middle of a 'mourn' operation. */
|
||
|
||
int
|
||
number_of_live_inferiors (void)
|
||
{
|
||
struct inferior *inf;
|
||
int num_inf = 0;
|
||
|
||
for (inf = inferior_list; inf; inf = inf->next)
|
||
if (inf->pid != 0)
|
||
{
|
||
struct thread_info *tp;
|
||
|
||
ALL_NON_EXITED_THREADS (tp)
|
||
if (tp && ptid_get_pid (tp->ptid) == inf->pid)
|
||
if (target_has_execution_1 (tp->ptid))
|
||
{
|
||
/* Found a live thread in this inferior, go to the next
|
||
inferior. */
|
||
++num_inf;
|
||
break;
|
||
}
|
||
}
|
||
|
||
return num_inf;
|
||
}
|
||
|
||
/* Return true if there is at least one live inferior. */
|
||
|
||
int
|
||
have_live_inferiors (void)
|
||
{
|
||
return number_of_live_inferiors () > 0;
|
||
}
|
||
|
||
/* Prune away any unused inferiors, and then prune away no longer used
|
||
program spaces. */
|
||
|
||
void
|
||
prune_inferiors (void)
|
||
{
|
||
struct inferior *ss, **ss_link;
|
||
|
||
ss = inferior_list;
|
||
ss_link = &inferior_list;
|
||
while (ss)
|
||
{
|
||
if (!ss->deletable ()
|
||
|| !ss->removable
|
||
|| ss->pid != 0)
|
||
{
|
||
ss_link = &ss->next;
|
||
ss = *ss_link;
|
||
continue;
|
||
}
|
||
|
||
*ss_link = ss->next;
|
||
delete_inferior (ss);
|
||
ss = *ss_link;
|
||
}
|
||
}
|
||
|
||
/* Simply returns the count of inferiors. */
|
||
|
||
int
|
||
number_of_inferiors (void)
|
||
{
|
||
struct inferior *inf;
|
||
int count = 0;
|
||
|
||
for (inf = inferior_list; inf != NULL; inf = inf->next)
|
||
count++;
|
||
|
||
return count;
|
||
}
|
||
|
||
/* Converts an inferior process id to a string. Like
|
||
target_pid_to_str, but special cases the null process. */
|
||
|
||
static const char *
|
||
inferior_pid_to_str (int pid)
|
||
{
|
||
if (pid != 0)
|
||
return target_pid_to_str (pid_to_ptid (pid));
|
||
else
|
||
return _("<null>");
|
||
}
|
||
|
||
/* See inferior.h. */
|
||
|
||
void
|
||
print_selected_inferior (struct ui_out *uiout)
|
||
{
|
||
struct inferior *inf = current_inferior ();
|
||
const char *filename = inf->pspace->pspace_exec_filename;
|
||
|
||
if (filename == NULL)
|
||
filename = _("<noexec>");
|
||
|
||
uiout->message (_("[Switching to inferior %d [%s] (%s)]\n"),
|
||
inf->num, inferior_pid_to_str (inf->pid), filename);
|
||
}
|
||
|
||
/* Prints the list of inferiors and their details on UIOUT. This is a
|
||
version of 'info_inferior_command' suitable for use from MI.
|
||
|
||
If REQUESTED_INFERIORS is not NULL, it's a list of GDB ids of the
|
||
inferiors that should be printed. Otherwise, all inferiors are
|
||
printed. */
|
||
|
||
static void
|
||
print_inferior (struct ui_out *uiout, const char *requested_inferiors)
|
||
{
|
||
struct inferior *inf;
|
||
int inf_count = 0;
|
||
|
||
/* Compute number of inferiors we will print. */
|
||
for (inf = inferior_list; inf; inf = inf->next)
|
||
{
|
||
if (!number_is_in_list (requested_inferiors, inf->num))
|
||
continue;
|
||
|
||
++inf_count;
|
||
}
|
||
|
||
if (inf_count == 0)
|
||
{
|
||
uiout->message ("No inferiors.\n");
|
||
return;
|
||
}
|
||
|
||
ui_out_emit_table table_emitter (uiout, 4, inf_count, "inferiors");
|
||
uiout->table_header (1, ui_left, "current", "");
|
||
uiout->table_header (4, ui_left, "number", "Num");
|
||
uiout->table_header (17, ui_left, "target-id", "Description");
|
||
uiout->table_header (17, ui_left, "exec", "Executable");
|
||
|
||
uiout->table_body ();
|
||
for (inf = inferior_list; inf; inf = inf->next)
|
||
{
|
||
if (!number_is_in_list (requested_inferiors, inf->num))
|
||
continue;
|
||
|
||
ui_out_emit_tuple tuple_emitter (uiout, NULL);
|
||
|
||
if (inf == current_inferior ())
|
||
uiout->field_string ("current", "*");
|
||
else
|
||
uiout->field_skip ("current");
|
||
|
||
uiout->field_int ("number", inf->num);
|
||
|
||
uiout->field_string ("target-id", inferior_pid_to_str (inf->pid));
|
||
|
||
if (inf->pspace->pspace_exec_filename != NULL)
|
||
uiout->field_string ("exec", inf->pspace->pspace_exec_filename);
|
||
else
|
||
uiout->field_skip ("exec");
|
||
|
||
/* Print extra info that isn't really fit to always present in
|
||
tabular form. Currently we print the vfork parent/child
|
||
relationships, if any. */
|
||
if (inf->vfork_parent)
|
||
{
|
||
uiout->text (_("\n\tis vfork child of inferior "));
|
||
uiout->field_int ("vfork-parent", inf->vfork_parent->num);
|
||
}
|
||
if (inf->vfork_child)
|
||
{
|
||
uiout->text (_("\n\tis vfork parent of inferior "));
|
||
uiout->field_int ("vfork-child", inf->vfork_child->num);
|
||
}
|
||
|
||
uiout->text ("\n");
|
||
}
|
||
}
|
||
|
||
static void
|
||
detach_inferior_command (const char *args, int from_tty)
|
||
{
|
||
if (!args || !*args)
|
||
error (_("Requires argument (inferior id(s) to detach)"));
|
||
|
||
number_or_range_parser parser (args);
|
||
while (!parser.finished ())
|
||
{
|
||
int num = parser.get_number ();
|
||
|
||
inferior *inf = find_inferior_id (num);
|
||
if (inf == NULL)
|
||
{
|
||
warning (_("Inferior ID %d not known."), num);
|
||
continue;
|
||
}
|
||
|
||
if (inf->pid == 0)
|
||
{
|
||
warning (_("Inferior ID %d is not running."), num);
|
||
continue;
|
||
}
|
||
|
||
thread_info *tp = any_thread_of_inferior (inf);
|
||
if (tp == NULL)
|
||
{
|
||
warning (_("Inferior ID %d has no threads."), num);
|
||
continue;
|
||
}
|
||
|
||
switch_to_thread (tp);
|
||
|
||
detach_command (NULL, from_tty);
|
||
}
|
||
}
|
||
|
||
static void
|
||
kill_inferior_command (const char *args, int from_tty)
|
||
{
|
||
if (!args || !*args)
|
||
error (_("Requires argument (inferior id(s) to kill)"));
|
||
|
||
number_or_range_parser parser (args);
|
||
while (!parser.finished ())
|
||
{
|
||
int num = parser.get_number ();
|
||
|
||
inferior *inf = find_inferior_id (num);
|
||
if (inf == NULL)
|
||
{
|
||
warning (_("Inferior ID %d not known."), num);
|
||
continue;
|
||
}
|
||
|
||
if (inf->pid == 0)
|
||
{
|
||
warning (_("Inferior ID %d is not running."), num);
|
||
continue;
|
||
}
|
||
|
||
thread_info *tp = any_thread_of_inferior (inf);
|
||
if (tp == NULL)
|
||
{
|
||
warning (_("Inferior ID %d has no threads."), num);
|
||
continue;
|
||
}
|
||
|
||
switch_to_thread (tp);
|
||
|
||
target_kill ();
|
||
}
|
||
|
||
bfd_cache_close_all ();
|
||
}
|
||
|
||
static void
|
||
inferior_command (const char *args, int from_tty)
|
||
{
|
||
struct inferior *inf;
|
||
int num;
|
||
|
||
num = parse_and_eval_long (args);
|
||
|
||
inf = find_inferior_id (num);
|
||
if (inf == NULL)
|
||
error (_("Inferior ID %d not known."), num);
|
||
|
||
if (inf->pid != 0)
|
||
{
|
||
if (inf != current_inferior ())
|
||
{
|
||
thread_info *tp = any_thread_of_inferior (inf);
|
||
if (tp == NULL)
|
||
error (_("Inferior has no threads."));
|
||
|
||
switch_to_thread (tp);
|
||
}
|
||
|
||
gdb::observers::user_selected_context_changed.notify
|
||
(USER_SELECTED_INFERIOR
|
||
| USER_SELECTED_THREAD
|
||
| USER_SELECTED_FRAME);
|
||
}
|
||
else
|
||
{
|
||
set_current_inferior (inf);
|
||
switch_to_no_thread ();
|
||
set_current_program_space (inf->pspace);
|
||
|
||
gdb::observers::user_selected_context_changed.notify
|
||
(USER_SELECTED_INFERIOR);
|
||
}
|
||
}
|
||
|
||
/* Print information about currently known inferiors. */
|
||
|
||
static void
|
||
info_inferiors_command (const char *args, int from_tty)
|
||
{
|
||
print_inferior (current_uiout, args);
|
||
}
|
||
|
||
/* remove-inferior ID */
|
||
|
||
static void
|
||
remove_inferior_command (const char *args, int from_tty)
|
||
{
|
||
if (args == NULL || *args == '\0')
|
||
error (_("Requires an argument (inferior id(s) to remove)"));
|
||
|
||
number_or_range_parser parser (args);
|
||
while (!parser.finished ())
|
||
{
|
||
int num = parser.get_number ();
|
||
struct inferior *inf = find_inferior_id (num);
|
||
|
||
if (inf == NULL)
|
||
{
|
||
warning (_("Inferior ID %d not known."), num);
|
||
continue;
|
||
}
|
||
|
||
if (!inf->deletable ())
|
||
{
|
||
warning (_("Can not remove current inferior %d."), num);
|
||
continue;
|
||
}
|
||
|
||
if (inf->pid != 0)
|
||
{
|
||
warning (_("Can not remove active inferior %d."), num);
|
||
continue;
|
||
}
|
||
|
||
delete_inferior (inf);
|
||
}
|
||
}
|
||
|
||
struct inferior *
|
||
add_inferior_with_spaces (void)
|
||
{
|
||
struct address_space *aspace;
|
||
struct program_space *pspace;
|
||
struct inferior *inf;
|
||
struct gdbarch_info info;
|
||
|
||
/* If all inferiors share an address space on this system, this
|
||
doesn't really return a new address space; otherwise, it
|
||
really does. */
|
||
aspace = maybe_new_address_space ();
|
||
pspace = new program_space (aspace);
|
||
inf = add_inferior (0);
|
||
inf->pspace = pspace;
|
||
inf->aspace = pspace->aspace;
|
||
|
||
/* Setup the inferior's initial arch, based on information obtained
|
||
from the global "set ..." options. */
|
||
gdbarch_info_init (&info);
|
||
inf->gdbarch = gdbarch_find_by_info (info);
|
||
/* The "set ..." options reject invalid settings, so we should
|
||
always have a valid arch by now. */
|
||
gdb_assert (inf->gdbarch != NULL);
|
||
|
||
return inf;
|
||
}
|
||
|
||
/* add-inferior [-copies N] [-exec FILENAME] */
|
||
|
||
static void
|
||
add_inferior_command (const char *args, int from_tty)
|
||
{
|
||
int i, copies = 1;
|
||
gdb::unique_xmalloc_ptr<char> exec;
|
||
symfile_add_flags add_flags = 0;
|
||
|
||
if (from_tty)
|
||
add_flags |= SYMFILE_VERBOSE;
|
||
|
||
if (args)
|
||
{
|
||
gdb_argv built_argv (args);
|
||
|
||
for (char **argv = built_argv.get (); *argv != NULL; argv++)
|
||
{
|
||
if (**argv == '-')
|
||
{
|
||
if (strcmp (*argv, "-copies") == 0)
|
||
{
|
||
++argv;
|
||
if (!*argv)
|
||
error (_("No argument to -copies"));
|
||
copies = parse_and_eval_long (*argv);
|
||
}
|
||
else if (strcmp (*argv, "-exec") == 0)
|
||
{
|
||
++argv;
|
||
if (!*argv)
|
||
error (_("No argument to -exec"));
|
||
exec.reset (tilde_expand (*argv));
|
||
}
|
||
}
|
||
else
|
||
error (_("Invalid argument"));
|
||
}
|
||
}
|
||
|
||
scoped_restore_current_pspace_and_thread restore_pspace_thread;
|
||
|
||
for (i = 0; i < copies; ++i)
|
||
{
|
||
struct inferior *inf = add_inferior_with_spaces ();
|
||
|
||
printf_filtered (_("Added inferior %d\n"), inf->num);
|
||
|
||
if (exec != NULL)
|
||
{
|
||
/* Switch over temporarily, while reading executable and
|
||
symbols.q. */
|
||
set_current_program_space (inf->pspace);
|
||
set_current_inferior (inf);
|
||
switch_to_no_thread ();
|
||
|
||
exec_file_attach (exec.get (), from_tty);
|
||
symbol_file_add_main (exec.get (), add_flags);
|
||
}
|
||
}
|
||
}
|
||
|
||
/* clone-inferior [-copies N] [ID] */
|
||
|
||
static void
|
||
clone_inferior_command (const char *args, int from_tty)
|
||
{
|
||
int i, copies = 1;
|
||
struct inferior *orginf = NULL;
|
||
|
||
if (args)
|
||
{
|
||
gdb_argv built_argv (args);
|
||
|
||
char **argv = built_argv.get ();
|
||
for (; *argv != NULL; argv++)
|
||
{
|
||
if (**argv == '-')
|
||
{
|
||
if (strcmp (*argv, "-copies") == 0)
|
||
{
|
||
++argv;
|
||
if (!*argv)
|
||
error (_("No argument to -copies"));
|
||
copies = parse_and_eval_long (*argv);
|
||
|
||
if (copies < 0)
|
||
error (_("Invalid copies number"));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (orginf == NULL)
|
||
{
|
||
int num;
|
||
|
||
/* The first non-option (-) argument specified the
|
||
program space ID. */
|
||
num = parse_and_eval_long (*argv);
|
||
orginf = find_inferior_id (num);
|
||
|
||
if (orginf == NULL)
|
||
error (_("Inferior ID %d not known."), num);
|
||
continue;
|
||
}
|
||
else
|
||
error (_("Invalid argument"));
|
||
}
|
||
}
|
||
}
|
||
|
||
/* If no inferior id was specified, then the user wants to clone the
|
||
current inferior. */
|
||
if (orginf == NULL)
|
||
orginf = current_inferior ();
|
||
|
||
scoped_restore_current_pspace_and_thread restore_pspace_thread;
|
||
|
||
for (i = 0; i < copies; ++i)
|
||
{
|
||
struct address_space *aspace;
|
||
struct program_space *pspace;
|
||
struct inferior *inf;
|
||
|
||
/* If all inferiors share an address space on this system, this
|
||
doesn't really return a new address space; otherwise, it
|
||
really does. */
|
||
aspace = maybe_new_address_space ();
|
||
pspace = new program_space (aspace);
|
||
inf = add_inferior (0);
|
||
inf->pspace = pspace;
|
||
inf->aspace = pspace->aspace;
|
||
inf->gdbarch = orginf->gdbarch;
|
||
|
||
/* If the original inferior had a user specified target
|
||
description, make the clone use it too. */
|
||
if (target_desc_info_from_user_p (inf->tdesc_info))
|
||
copy_inferior_target_desc_info (inf, orginf);
|
||
|
||
printf_filtered (_("Added inferior %d.\n"), inf->num);
|
||
|
||
set_current_inferior (inf);
|
||
switch_to_no_thread ();
|
||
clone_program_space (pspace, orginf->pspace);
|
||
}
|
||
}
|
||
|
||
/* Print notices when new inferiors are created and die. */
|
||
static void
|
||
show_print_inferior_events (struct ui_file *file, int from_tty,
|
||
struct cmd_list_element *c, const char *value)
|
||
{
|
||
fprintf_filtered (file, _("Printing of inferior events is %s.\n"), value);
|
||
}
|
||
|
||
/* Return a new value for the selected inferior's id. */
|
||
|
||
static struct value *
|
||
inferior_id_make_value (struct gdbarch *gdbarch, struct internalvar *var,
|
||
void *ignore)
|
||
{
|
||
struct inferior *inf = current_inferior ();
|
||
|
||
return value_from_longest (builtin_type (gdbarch)->builtin_int, inf->num);
|
||
}
|
||
|
||
/* Implementation of `$_inferior' variable. */
|
||
|
||
static const struct internalvar_funcs inferior_funcs =
|
||
{
|
||
inferior_id_make_value,
|
||
NULL,
|
||
NULL
|
||
};
|
||
|
||
|
||
|
||
void
|
||
initialize_inferiors (void)
|
||
{
|
||
struct cmd_list_element *c = NULL;
|
||
|
||
/* There's always one inferior. Note that this function isn't an
|
||
automatic _initialize_foo function, since other _initialize_foo
|
||
routines may need to install their per-inferior data keys. We
|
||
can only allocate an inferior when all those modules have done
|
||
that. Do this after initialize_progspace, due to the
|
||
current_program_space reference. */
|
||
current_inferior_ = add_inferior_silent (0);
|
||
current_inferior_->incref ();
|
||
current_inferior_->pspace = current_program_space;
|
||
current_inferior_->aspace = current_program_space->aspace;
|
||
/* The architecture will be initialized shortly, by
|
||
initialize_current_architecture. */
|
||
|
||
add_info ("inferiors", info_inferiors_command,
|
||
_("Print a list of inferiors being managed.\n\
|
||
Usage: info inferiors [ID]...\n\
|
||
If IDs are specified, the list is limited to just those inferiors.\n\
|
||
By default all inferiors are displayed."));
|
||
|
||
c = add_com ("add-inferior", no_class, add_inferior_command, _("\
|
||
Add a new inferior.\n\
|
||
Usage: add-inferior [-copies N] [-exec FILENAME]\n\
|
||
N is the optional number of inferiors to add, default is 1.\n\
|
||
FILENAME is the file name of the executable to use\n\
|
||
as main program."));
|
||
set_cmd_completer (c, filename_completer);
|
||
|
||
add_com ("remove-inferiors", no_class, remove_inferior_command, _("\
|
||
Remove inferior ID (or list of IDs).\n\
|
||
Usage: remove-inferiors ID..."));
|
||
|
||
add_com ("clone-inferior", no_class, clone_inferior_command, _("\
|
||
Clone inferior ID.\n\
|
||
Usage: clone-inferior [-copies N] [ID]\n\
|
||
Add N copies of inferior ID. The new inferior has the same\n\
|
||
executable loaded as the copied inferior. If -copies is not specified,\n\
|
||
adds 1 copy. If ID is not specified, it is the current inferior\n\
|
||
that is cloned."));
|
||
|
||
add_cmd ("inferiors", class_run, detach_inferior_command, _("\
|
||
Detach from inferior ID (or list of IDS).\n\
|
||
Usage; detach inferiors ID..."),
|
||
&detachlist);
|
||
|
||
add_cmd ("inferiors", class_run, kill_inferior_command, _("\
|
||
Kill inferior ID (or list of IDs).\n\
|
||
Usage: kill inferiors ID..."),
|
||
&killlist);
|
||
|
||
add_cmd ("inferior", class_run, inferior_command, _("\
|
||
Use this command to switch between inferiors.\n\
|
||
Usage: inferior ID\n\
|
||
The new inferior ID must be currently known."),
|
||
&cmdlist);
|
||
|
||
add_setshow_boolean_cmd ("inferior-events", no_class,
|
||
&print_inferior_events, _("\
|
||
Set printing of inferior events (e.g., inferior start and exit)."), _("\
|
||
Show printing of inferior events (e.g., inferior start and exit)."), NULL,
|
||
NULL,
|
||
show_print_inferior_events,
|
||
&setprintlist, &showprintlist);
|
||
|
||
create_internalvar_type_lazy ("_inferior", &inferior_funcs, NULL);
|
||
}
|