OpenE2K/binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
6f0ffe50c8
binutils-gdb/gdb/inferior.c
Pedro Alves 0803633106 Per-inferior thread list, thread ranges/iterators, down with ALL_THREADS, etc. 
As preparation for multi-target, this patch makes each inferior have
its own thread list.

This isn't absolutely necessary for multi-target, but simplifies
things.  It originally stemmed from the desire to eliminate the
init_thread_list calls sprinkled around, plus it makes it more
efficient to iterate over threads of a given inferior (no need to
always iterate over threads of all inferiors).

We still need to iterate over threads of all inferiors in a number of
places, which means we'd need adjust the ALL_THREADS /
ALL_NON_EXITED_THREADS macros.  However, naively tweaking those macros
to have an extra for loop, like:

     #define ALL_THREADS (thr, inf) \
       for (inf = inferior_list; inf; inf = inf->next) \
	 for (thr = inf->thread_list; thr; thr = thr->next)

causes problems with code that does "break" or "continue" within the
ALL_THREADS loop body.  Plus, we need to declare the extra "inf" local
variable in order to pass it as temporary variable to ALL_THREADS
(etc.)

It gets even trickier when we consider extending the macros to filter
out threads matching a ptid_t and a target.  The macros become tricker
to read/write.  Been there.

An alternative (which was my next attempt), is to replace the
ALL_THREADS etc. iteration style with for_each_all_threads,
for_each_non_exited_threads, etc. functions which would take a
callback as parameter, which would usually be passed a lambda.
However, I did not find that satisfactory at all, because the
resulting code ends up a little less natural / more noisy to read,
write and debug/step-through (due to use of lambdas), and in many
places where we use "continue;" to skip to the next thread now need to
use "return;".  (I ran into hard to debug bugs caused by a
continue/return confusion.)

I.e., before:

    ALL_NON_EXITED_THREADS (tp)
      {
	if (tp->not_what_I_want)
	  continue;
	// do something
      }

would turn into:

    for_each_non_exited_thread ([&] (thread_info *tp)
      {
	if (tp->not_what_I_want)
	  return;
	// do something
      });

Lastly, the solution I settled with was to replace the ALL_THREADS /
ALL_NON_EXITED_THREADS / ALL_INFERIORS macros with (C++20-like) ranges
and iterators, such that you can instead naturaly iterate over
threads/inferiors using range-for, like e.g,.:

   // all threads, including THREAD_EXITED threads.
   for (thread_info *tp : all_threads ())
     { .... }

   // all non-exited threads.
   for (thread_info *tp : all_non_exited_threads ())
     { .... }

   // all non-exited threads of INF inferior.
   for (thread_info *tp : inf->non_exited_threads ())
     { .... }

The all_non_exited_threads() function takes an optional filter ptid_t as
parameter, which is quite convenient when we need to iterate over
threads matching that filter.  See e.g., how the
set_executing/set_stop_requested/finish_thread_state etc. functions in
thread.c end up being simplified.

Most of the patch thus is about adding the infrustructure for allowing
the above.  Later on when we get to actual multi-target, these
functions/ranges/iterators will gain a "target_ops *" parameter so
that e.g., we can iterate over all threads of a given target that
match a given filter ptid_t.

The only entry points users needs to be aware of are the
all_threads/all_non_exited_threads etc. functions seen above.  Thus,
those functions are declared in gdbthread.h/inferior.h.  The actual
iterators/ranges are mainly "internals" and thus are put out of view
in the new thread-iter.h/thread-iter.c/inferior-iter.h files.  That
keeps the gdbthread.h/inferior.h headers quite a bit more readable.

A common/safe-iterator.h header is added which adds a template that
can be used to build "safe" iterators, which are forward iterators
that can be used to replace the ALL_THREADS_SAFE macro and other
instances of the same idiom in future.

There's a little bit of shuffling of code between
gdbthread.h/thread.c/inferior.h in the patch.  That is necessary in
order to avoid circular dependencies between the
gdbthread.h/inferior.h headers.

As for the init_thread_list calls sprinkled around, they're all
eliminated by this patch, and a new, central call is added to
inferior_appeared.  Note how also related to that, there's a call to
init_wait_for_inferior in remote.c that is eliminated.
init_wait_for_inferior is currently responsible for discarding skipped
inline frames, which had to be moved elsewhere.  Given that nowadays
we always have a thread even for single-threaded processes, the
natural place is to delete a frame's inline frame info when we delete
the thread.  I.e., from clear_thread_inferior_resources.

gdb/ChangeLog:
2018-11-22  Pedro Alves  <palves@redhat.com>

	* Makefile.in (COMMON_SFILES): Add thread-iter.c.
	* breakpoint.c (breakpoints_should_be_inserted_now): Replace
	ALL_NON_EXITED_THREADS with all_non_exited_threads.
	(print_one_breakpoint_location): Replace ALL_INFERIORS with
	all_inferiors.
	* bsd-kvm.c: Include inferior.h.
	* btrace.c (btrace_free_objfile): Replace ALL_NON_EXITED_THREADS
	with all_non_exited_threads.
	* common/filtered-iterator.h: New.
	* common/safe-iterator.h: New.
	* corelow.c (core_target_open): Don't call init_thread_list here.
	* darwin-nat.c (thread_info_from_private_thread_info): Replace
	ALL_THREADS with all_threads.
	* fbsd-nat.c (fbsd_nat_target::resume): Replace
	ALL_NON_EXITED_THREADS with inf->non_exited_threads.
	* fbsd-tdep.c (fbsd_make_corefile_notes): Replace
	ALL_NON_EXITED_THREADS with inf->non_exited_threads.
	* fork-child.c (postfork_hook): Don't call init_thread_list here.
	* gdbarch-selftests.c (register_to_value_test): Adjust.
	* gdbthread.h: Don't include "inferior.h" here.
	(struct inferior): Forward declare.
	(enum step_over_calls_kind): Moved here from inferior.h.
	(thread_info::deletable): Definition moved to thread.c.
	(find_thread_ptid (inferior *, ptid_t)): Declare.
	(ALL_THREADS, ALL_THREADS_BY_INFERIOR, ALL_THREADS_SAFE): Delete.
	Include "thread-iter.h".
	(all_threads, all_non_exited_threads, all_threads_safe): New.
	(any_thread_p): Declare.
	(thread_list): Delete.
	* infcmd.c (signal_command): Replace ALL_NON_EXITED_THREADS with
	all_non_exited_threads.
	(proceed_after_attach_callback): Delete.
	(proceed_after_attach): Take an inferior pointer instead of an
	integer PID.  Adjust to use range-for.
	(attach_post_wait): Pass down inferior pointer instead of pid.
	Use range-for instead of ALL_NON_EXITED_THREADS.
	(detach_command): Remove init_thread_list call.
	* inferior-iter.h: New.
	* inferior.c (struct delete_thread_of_inferior_arg): Delete.
	(delete_thread_of_inferior): Delete.
	(delete_inferior, exit_inferior_1): Use range-for with
	inf->threads_safe() instead of iterate_over_threads.
	(inferior_appeared): Call init_thread_list here.
	(discard_all_inferiors): Use all_non_exited_inferiors.
	(find_inferior_id, find_inferior_pid): Use all_inferiors.
	(iterate_over_inferiors): Use all_inferiors_safe.
	(have_inferiors, number_of_live_inferiors): Use
	all_non_exited_inferiors.
	(number_of_inferiors): Use all_inferiors and std::distance.
	(print_inferior): Use all_inferiors.
	* inferior.h: Include gdbthread.h.
	(enum step_over_calls_kind): Moved to gdbthread.h.
	(struct inferior) <thread_list>: New field.
	<threads, non_exited_threads, threads_safe>: New methods.
	(ALL_INFERIORS): Delete.
	Include "inferior-iter.h".
	(ALL_NON_EXITED_INFERIORS): Delete.
	(all_inferiors_safe, all_inferiors, all_non_exited_inferiors): New
	functions.
	* inflow.c (child_interrupt, child_pass_ctrlc): Replace
	ALL_NON_EXITED_THREADS with all_non_exited_threads.
	* infrun.c (follow_exec): Use all_threads_safe.
	(clear_proceed_status, proceed): Use all_non_exited_threads.
	(init_wait_for_inferior): Don't clear inline frame state here.
	(infrun_thread_stop_requested, for_each_just_stopped_thread): Use
	all_threads instead of ALL_NON_EXITED_THREADS.
	(random_pending_event_thread): Use all_non_exited_threads instead
	of ALL_NON_EXITED_THREADS.  Use a lambda for repeated code.
	(clean_up_just_stopped_threads_fsms): Use all_non_exited_threads
	instead of ALL_NON_EXITED_THREADS.
	(handle_no_resumed): Use all_non_exited_threads instead of
	ALL_NON_EXITED_THREADS.  Use all_inferiors instead of
	ALL_INFERIORS.
	(restart_threads, switch_back_to_stepped_thread): Use
	all_non_exited_threads instead of ALL_NON_EXITED_THREADS.
	* linux-nat.c (check_zombie_leaders): Replace ALL_INFERIORS with
	all_inferiors.
	(kill_unfollowed_fork_children): Use inf->non_exited_threads
	instead of ALL_NON_EXITED_THREADS.
	* linux-tdep.c (linux_make_corefile_notes): Use
	inf->non_exited_threads instead of ALL_NON_EXITED_THREADS.
	* linux-thread-db.c (thread_db_target::update_thread_list):
	Replace ALL_INFERIORS with all_inferiors.
	(thread_db_target::thread_handle_to_thread_info): Use
	inf->non_exited_threads instead of ALL_NON_EXITED_THREADS.
	* mi/mi-interp.c (multiple_inferiors_p): New.
	(mi_on_resume_1): Simplify using all_non_exited_threads and
	multiple_inferiors_p.
	* mi/mi-main.c (mi_cmd_thread_list_ids): Use all_non_exited_threads
	instead of ALL_NON_EXITED_THREADS.
	* nto-procfs.c (nto_procfs_target::open): Don't call
	init_thread_list here.
	* record-btrace.c (record_btrace_target_open)
	(record_btrace_target::stop_recording)
	(record_btrace_target::close)
	(record_btrace_target::record_is_replaying)
	(record_btrace_target::resume, record_btrace_target::wait)
	(record_btrace_target::record_stop_replaying): Use
	all_non_exited_threads instead of ALL_NON_EXITED_THREADS.
	* record-full.c (record_full_wait_1): Use all_non_exited_threads
	instead of ALL_NON_EXITED_THREADS.
	* regcache.c (cooked_read_test): Remove reference to global
	thread_list.
	* remote-sim.c (gdbsim_target::create_inferior): Don't call
	init_thread_list here.
	* remote.c (remote_target::update_thread_list): Use
	all_threads_safe instead of ALL_NON_EXITED_THREADS.
	(remote_target::process_initial_stop_replies): Replace
	ALL_INFERIORS with all_non_exited_inferiors and use
	all_non_exited_threads instead of ALL_NON_EXITED_THREADS.
	(remote_target::open_1): Don't call init_thread_list here.
	(remote_target::append_pending_thread_resumptions)
	(remote_target::remote_resume_with_hc): Use all_non_exited_threads
	instead of ALL_NON_EXITED_THREADS.
	(remote_target::commit_resume)
	(remote_target::remove_new_fork_children): Replace ALL_INFERIORS
	with all_non_exited_inferiors and use all_non_exited_threads
	instead of ALL_NON_EXITED_THREADS.
	(remote_target::kill_new_fork_children): Use
	all_non_exited_threads instead of ALL_NON_EXITED_THREADS.  Remove
	init_thread_list and init_wait_for_inferior calls.
	(remote_target::remote_btrace_maybe_reopen)
	(remote_target::thread_handle_to_thread_info): Use
	all_non_exited_threads instead of ALL_NON_EXITED_THREADS.
	* target.c (target_terminal::restore_inferior)
	(target_terminal_is_ours_kind): Replace ALL_INFERIORS with
	all_non_exited_inferiors.
	* thread-iter.c: New file.
	* thread-iter.h: New file.
	* thread.c: Include "inline-frame.h".
	(thread_list): Delete.
	(clear_thread_inferior_resources): Call clear_inline_frame_state.
	(init_thread_list): Use all_threads_safe instead of
	ALL_THREADS_SAFE.  Adjust to per-inferior thread lists.
	(new_thread): Adjust to per-inferior thread lists.
	(add_thread_silent): Pass inferior to find_thread_ptid.
	(thread_info::deletable): New, moved from the header.
	(delete_thread_1): Adjust to per-inferior thread lists.
	(find_thread_global_id): Use inf->threads().
	(find_thread_ptid): Use find_inferior_ptid and pass inferior to
	find_thread_ptid.
	(find_thread_ptid(inferior*, ptid_t)): New overload.
	(iterate_over_threads): Use all_threads_safe.
	(any_thread_p): New.
	(thread_count): Use all_threads and std::distance.
	(live_threads_count): Use all_non_exited_threads and
	std::distance.
	(valid_global_thread_id): Use all_threads.
	(in_thread_list): Use find_thread_ptid.
	(first_thread_of_inferior): Adjust to per-inferior thread lists.
	(any_thread_of_inferior, any_live_thread_of_inferior): Use
	inf->non_exited_threads().
	(prune_threads, delete_exited_threads): Use all_threads_safe.
	(thread_change_ptid): Pass inferior pointer to find_thread_ptid.
	(set_resumed, set_running): Use all_non_exited_threads.
	(is_thread_state, is_stopped, is_exited, is_running)
	(is_executing): Delete.
	(set_executing, set_stop_requested, finish_thread_state): Use
	all_non_exited_threads.
	(print_thread_info_1): Use all_inferiors and all_threads.
	(thread_apply_all_command): Use all_non_exited_threads.
	(thread_find_command): Use all_threads.
	(update_threads_executing): Use all_non_exited_threads.
	* tid-parse.c (parse_thread_id): Use inf->threads.
	* x86-bsd-nat.c (x86bsd_dr_set): Use inf->non_exited_threads ().
2018-11-22 16:13:23 +00:00

941 lines
21 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* 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)
{
if (pid != 0)
printf_unfiltered (_("[New inferior %d (%s)]\n"),
inf->num,
target_pid_to_str (ptid_t (pid)));
else
printf_unfiltered (_("[New inferior %d]\n"), inf->num);
}
return inf;
}
void
delete_inferior (struct inferior *todel)
{
struct inferior *inf, *infprev;
infprev = NULL;
for (inf = inferior_list; inf; infprev = inf, inf = inf->next)
if (inf == todel)
break;
if (!inf)
return;
for (thread_info *tp : inf->threads_safe ())
delete_thread_silent (tp);
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;
for (inf = inferior_list; inf; inf = inf->next)
if (inf == inftoex)
break;
if (!inf)
return;
for (thread_info *tp : inf->threads_safe ())
{
if (silent)
delete_thread_silent (tp);
else
delete_thread (tp);
}
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 = inferior_control_state (NO_STOP_QUIETLY);
}
void
exit_inferior (inferior *inf)
{
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);
}
/* 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 (ptid_t (pid)));
}
void
inferior_appeared (struct inferior *inf, int pid)
{
/* If this is the first inferior with threads, reset the global
thread id. */
if (!any_thread_p ())
init_thread_list ();
inf->pid = pid;
inf->has_exit_code = 0;
inf->exit_code = 0;
gdb::observers::inferior_appeared.notify (inf);
}
void
discard_all_inferiors (void)
{
for (inferior *inf : all_non_exited_inferiors ())
exit_inferior_silent (inf);
}
struct inferior *
find_inferior_id (int num)
{
for (inferior *inf : all_inferiors ())
if (inf->num == num)
return inf;
return NULL;
}
struct inferior *
find_inferior_pid (int pid)
{
/* 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 (inferior *inf : all_inferiors ())
if (inf->pid == pid)
return inf;
return NULL;
}
/* See inferior.h */
struct inferior *
find_inferior_ptid (ptid_t ptid)
{
return find_inferior_pid (ptid.pid ());
}
/* See inferior.h. */
struct inferior *
find_inferior_for_program_space (struct program_space *pspace)
{
struct inferior *cur_inf = current_inferior ();
if (cur_inf->pspace == pspace)
return cur_inf;
for (inferior *inf : all_inferiors ())
if (inf->pspace == pspace)
return inf;
return NULL;
}
struct inferior *
iterate_over_inferiors (int (*callback) (struct inferior *, void *),
void *data)
{
for (inferior *inf : all_inferiors_safe ())
if ((*callback) (inf, data))
return inf;
return NULL;
}
int
have_inferiors (void)
{
for (inferior *inf ATTRIBUTE_UNUSED : all_non_exited_inferiors ())
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)
{
int num_inf = 0;
for (inferior *inf : all_non_exited_inferiors ())
if (target_has_execution_1 (ptid_t (inf->pid)))
for (thread_info *tp ATTRIBUTE_UNUSED : inf->non_exited_threads ())
{
/* 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)
{
auto rng = all_inferiors ();
return std::distance (rng.begin (), rng.end ());
}
/* 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 (ptid_t (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)
{
int inf_count = 0;
/* Compute number of inferiors we will print. */
for (inferior *inf : all_inferiors ())
{
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 (inferior *inf : all_inferiors ())
{
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);
}
Reference in New Issue View Git Blame Copy Permalink