mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-15 04:31:49 +08:00
5b6d1e4fa4
This commit adds multi-target support to GDB. What this means is that
with this commit, GDB can now be connected to different targets at the
same time. E.g., you can debug a live native process and a core dump
at the same time, connect to multiple gdbservers, etc.
Actually, the word "target" is overloaded in gdb. We already have a
target stack, with pushes several target_ops instances on top of one
another. We also have "info target" already, which means something
completely different to what this patch does.
So from here on, I'll be using the "target connections" term, to mean
an open process_stratum target, pushed on a target stack. This patch
makes gdb have multiple target stacks, and multiple process_stratum
targets open simultaneously. The user-visible changes / commands will
also use this terminology, but of course it's all open to debate.
User-interface-wise, not that much changes. The main difference is
that each inferior may have its own target connection.
A target connection (e.g., a target extended-remote connection) may
support debugging multiple processes, just as before.
Say you're debugging against gdbserver in extended-remote mode, and
you do "add-inferior" to prepare to spawn a new process, like:
(gdb) target extended-remote :9999
...
(gdb) start
...
(gdb) add-inferior
Added inferior 2
(gdb) inferior 2
[Switching to inferior 2 [<null>] (<noexec>)]
(gdb) file a.out
...
(gdb) start
...
At this point, you have two inferiors connected to the same gdbserver.
With this commit, GDB will maintain a target stack per inferior,
instead of a global target stack.
To preserve the behavior above, by default, "add-inferior" makes the
new inferior inherit a copy of the target stack of the current
inferior. Same across a fork - the child inherits a copy of the
target stack of the parent. While the target stacks are copied, the
targets themselves are not. Instead, target_ops is made a
refcounted_object, which means that target_ops instances are
refcounted, which each inferior counting for a reference.
What if you want to create an inferior and connect it to some _other_
target? For that, this commit introduces a new "add-inferior
-no-connection" option that makes the new inferior not share the
current inferior's target. So you could do:
(gdb) target extended-remote :9999
Remote debugging using :9999
...
(gdb) add-inferior -no-connection
[New inferior 2]
Added inferior 2
(gdb) inferior 2
[Switching to inferior 2 [<null>] (<noexec>)]
(gdb) info inferiors
Num Description Executable
1 process 18401 target:/home/pedro/tmp/main
* 2 <null>
(gdb) tar extended-remote :10000
Remote debugging using :10000
...
(gdb) info inferiors
Num Description Executable
1 process 18401 target:/home/pedro/tmp/main
* 2 process 18450 target:/home/pedro/tmp/main
(gdb)
A following patch will extended "info inferiors" to include a column
indicating which connection an inferior is bound to, along with a
couple other UI tweaks.
Other than that, debugging is the same as before. Users interact with
inferiors and threads as before. The only difference is that
inferiors may be bound to processes running in different machines.
That's pretty much all there is to it in terms of noticeable UI
changes.
On to implementation.
Since we can be connected to different systems at the same time, a
ptid_t is no longer a unique identifier. Instead a thread can be
identified by a pair of ptid_t and 'process_stratum_target *', the
later being the instance of the process_stratum target that owns the
process/thread. Note that process_stratum_target inherits from
target_ops, and all process_stratum targets inherit from
process_stratum_target. In earlier patches, many places in gdb were
converted to refer to threads by thread_info pointer instead of
ptid_t, but there are still places in gdb where we start with a
pid/tid and need to find the corresponding inferior or thread_info
objects. So you'll see in the patch many places adding a
process_stratum_target parameter to functions that used to take only a
ptid_t.
Since each inferior has its own target stack now, we can always find
the process_stratum target for an inferior. That is done via a
inf->process_target() convenience method.
Since each inferior has its own target stack, we need to handle the
"beneath" calls when servicing target calls. The solution I settled
with is just to make sure to switch the current inferior to the
inferior you want before making a target call. Not relying on global
context is just not feasible in current GDB. Fortunately, there
aren't that many places that need to do that, because generally most
code that calls target methods already has the current context
pointing to the right inferior/thread. Note, to emphasize -- there's
no method to "switch to this target stack". Instead, you switch the
current inferior, and that implicitly switches the target stack.
In some spots, we need to iterate over all inferiors so that we reach
all target stacks.
Native targets are still singletons. There's always only a single
instance of such targets.
Remote targets however, we'll have one instance per remote connection.
The exec target is still a singleton. There's only one instance. I
did not see the point of instanciating more than one exec_target
object.
After vfork, we need to make sure to push the exec target on the new
inferior. See exec_on_vfork.
For type safety, functions that need a {target, ptid} pair to identify
a thread, take a process_stratum_target pointer for target parameter
instead of target_ops *. Some shared code in gdb/nat/ also need to
gain a target pointer parameter. This poses an issue, since gdbserver
doesn't have process_stratum_target, only target_ops. To fix this,
this commit renames gdbserver's target_ops to process_stratum_target.
I think this makes sense. There's no concept of target stack in
gdbserver, and gdbserver's target_ops really implements a
process_stratum-like target.
The thread and inferior iterator functions also gain
process_stratum_target parameters. These are used to be able to
iterate over threads and inferiors of a given target. Following usual
conventions, if the target pointer is null, then we iterate over
threads and inferiors of all targets.
I tried converting "add-inferior" to the gdb::option framework, as a
preparatory patch, but that stumbled on the fact that gdb::option does
not support file options yet, for "add-inferior -exec". I have a WIP
patchset that adds that, but it's not a trivial patch, mainly due to
need to integrate readline's filename completion, so I deferred that
to some other time.
In infrun.c/infcmd.c, the main change is that we need to poll events
out of all targets. See do_target_wait. Right after collecting an
event, we switch the current inferior to an inferior bound to the
target that reported the event, so that target methods can be used
while handling the event. This makes most of the code transparent to
multi-targets. See fetch_inferior_event.
infrun.c:stop_all_threads is interesting -- in this function we need
to stop all threads of all targets. What the function does is send an
asynchronous stop request to all threads, and then synchronously waits
for events, with target_wait, rinse repeat, until all it finds are
stopped threads. Now that we have multiple targets, it's not
efficient to synchronously block in target_wait waiting for events out
of one target. Instead, we implement a mini event loop, with
interruptible_select, select'ing on one file descriptor per target.
For this to work, we need to be able to ask the target for a waitable
file descriptor. Such file descriptors already exist, they are the
descriptors registered in the main event loop with add_file_handler,
inside the target_async implementations. This commit adds a new
target_async_wait_fd target method that just returns the file
descriptor in question. See wait_one / stop_all_threads in infrun.c.
The 'threads_executing' global is made a per-target variable. Since
it is only relevant to process_stratum_target targets, this is where
it is put, instead of in target_ops.
You'll notice that remote.c includes some FIXME notes. These refer to
the fact that the global arrays that hold data for the remote packets
supported are still globals. For example, if we connect to two
different servers/stubs, then each might support different remote
protocol features. They might even be different architectures, like
e.g., one ARM baremetal stub, and a x86 gdbserver, to debug a
host/controller scenario as a single program. That isn't going to
work correctly today, because of said globals. I'm leaving fixing
that for another pass, since it does not appear to be trivial, and I'd
rather land the base work first. It's already useful to be able to
debug multiple instances of the same server (e.g., a distributed
cluster, where you have full control over the servers installed), so I
think as is it's already reasonable incremental progress.
Current limitations:
- You can only resume more that one target at the same time if all
targets support asynchronous debugging, and support non-stop mode.
It should be possible to support mixed all-stop + non-stop
backends, but that is left for another time. This means that
currently in order to do multi-target with gdbserver you need to
issue "maint set target-non-stop on". I would like to make that
mode be the default, but we're not there yet. Note that I'm
talking about how the target backend works, only. User-visible
all-stop mode works just fine.
- As explained above, connecting to different remote servers at the
same time is likely to produce bad results if they don't support the
exact set of RSP features.
FreeBSD updates courtesy of John Baldwin.
gdb/ChangeLog:
2020-01-10 Pedro Alves <palves@redhat.com>
John Baldwin <jhb@FreeBSD.org>
* aarch64-linux-nat.c
(aarch64_linux_nat_target::thread_architecture): Adjust.
* ada-tasks.c (print_ada_task_info): Adjust find_thread_ptid call.
(task_command_1): Likewise.
* aix-thread.c (sync_threadlists, aix_thread_target::resume)
(aix_thread_target::wait, aix_thread_target::fetch_registers)
(aix_thread_target::store_registers)
(aix_thread_target::thread_alive): Adjust.
* amd64-fbsd-tdep.c: Include "inferior.h".
(amd64fbsd_get_thread_local_address): Pass down target.
* amd64-linux-nat.c (ps_get_thread_area): Use ps_prochandle
thread's gdbarch instead of target_gdbarch.
* break-catch-sig.c (signal_catchpoint_print_it): Adjust call to
get_last_target_status.
* break-catch-syscall.c (print_it_catch_syscall): Likewise.
* breakpoint.c (breakpoints_should_be_inserted_now): Consider all
inferiors.
(update_inserted_breakpoint_locations): Skip if inferiors with no
execution.
(update_global_location_list): When handling moribund locations,
find representative inferior for location's pspace, and use thread
count of its process_stratum target.
* bsd-kvm.c (bsd_kvm_target_open): Pass target down.
* bsd-uthread.c (bsd_uthread_target::wait): Use
as_process_stratum_target and adjust thread_change_ptid and
add_thread calls.
(bsd_uthread_target::update_thread_list): Use
as_process_stratum_target and adjust find_thread_ptid,
thread_change_ptid and add_thread calls.
* btrace.c (maint_btrace_packet_history_cmd): Adjust
find_thread_ptid call.
* corelow.c (add_to_thread_list): Adjust add_thread call.
(core_target_open): Adjust add_thread_silent and thread_count
calls.
(core_target::pid_to_str): Adjust find_inferior_ptid call.
* ctf.c (ctf_target_open): Adjust add_thread_silent call.
* event-top.c (async_disconnect): Pop targets from all inferiors.
* exec.c (add_target_sections): Push exec target on all inferiors
sharing the program space.
(remove_target_sections): Remove the exec target from all
inferiors sharing the program space.
(exec_on_vfork): New.
* exec.h (exec_on_vfork): Declare.
* fbsd-nat.c (fbsd_add_threads): Add fbsd_nat_target parameter.
Pass it down.
(fbsd_nat_target::update_thread_list): Adjust.
(fbsd_nat_target::resume): Adjust.
(fbsd_handle_debug_trap): Add fbsd_nat_target parameter. Pass it
down.
(fbsd_nat_target::wait, fbsd_nat_target::post_attach): Adjust.
* fbsd-tdep.c (fbsd_corefile_thread): Adjust
get_thread_arch_regcache call.
* fork-child.c (gdb_startup_inferior): Pass target down to
startup_inferior and set_executing.
* gdbthread.h (struct process_stratum_target): Forward declare.
(add_thread, add_thread_silent, add_thread_with_info)
(in_thread_list): Add process_stratum_target parameter.
(find_thread_ptid(inferior*, ptid_t)): New overload.
(find_thread_ptid, thread_change_ptid): Add process_stratum_target
parameter.
(all_threads()): Delete overload.
(all_threads, all_non_exited_threads): Add process_stratum_target
parameter.
(all_threads_safe): Use brace initialization.
(thread_count): Add process_stratum_target parameter.
(set_resumed, set_running, set_stop_requested, set_executing)
(threads_are_executing, finish_thread_state): Add
process_stratum_target parameter.
(switch_to_thread): Use is_current_thread.
* i386-fbsd-tdep.c: Include "inferior.h".
(i386fbsd_get_thread_local_address): Pass down target.
* i386-linux-nat.c (i386_linux_nat_target::low_resume): Adjust.
* inf-child.c (inf_child_target::maybe_unpush_target): Remove
have_inferiors check.
* inf-ptrace.c (inf_ptrace_target::create_inferior)
(inf_ptrace_target::attach): Adjust.
* infcall.c (run_inferior_call): Adjust.
* infcmd.c (run_command_1): Pass target to
scoped_finish_thread_state.
(proceed_thread_callback): Skip inferiors with no execution.
(continue_command): Rename 'all_threads' local to avoid hiding
'all_threads' function. Adjust get_last_target_status call.
(prepare_one_step): Adjust set_running call.
(signal_command): Use user_visible_resume_target. Compare thread
pointers instead of inferior_ptid.
(info_program_command): Adjust to pass down target.
(attach_command): Mark target's 'thread_executing' flag.
(stop_current_target_threads_ns): New, factored out from ...
(interrupt_target_1): ... this. Switch inferior before making
target calls.
* inferior-iter.h
(struct all_inferiors_iterator, struct all_inferiors_range)
(struct all_inferiors_safe_range)
(struct all_non_exited_inferiors_range): Filter on
process_stratum_target too. Remove explicit.
* inferior.c (inferior::inferior): Push dummy target on target
stack.
(find_inferior_pid, find_inferior_ptid, number_of_live_inferiors):
Add process_stratum_target parameter, and pass it down.
(have_live_inferiors): Adjust.
(switch_to_inferior_and_push_target): New.
(add_inferior_command, clone_inferior_command): Handle
"-no-connection" parameter. Use
switch_to_inferior_and_push_target.
(_initialize_inferior): Mention "-no-connection" option in
the help of "add-inferior" and "clone-inferior" commands.
* inferior.h: Include "process-stratum-target.h".
(interrupt_target_1): Use bool.
(struct inferior) <push_target, unpush_target, target_is_pushed,
find_target_beneath, top_target, process_target, target_at,
m_stack>: New.
(discard_all_inferiors): Delete.
(find_inferior_pid, find_inferior_ptid, number_of_live_inferiors)
(all_inferiors, all_non_exited_inferiors): Add
process_stratum_target parameter.
* infrun.c: Include "gdb_select.h" and <unordered_map>.
(target_last_proc_target): New global.
(follow_fork_inferior): Push target on new inferior. Pass target
to add_thread_silent. Call exec_on_vfork. Handle target's
reference count.
(follow_fork): Adjust get_last_target_status call. Also consider
target.
(follow_exec): Push target on new inferior.
(struct execution_control_state) <target>: New field.
(user_visible_resume_target): New.
(do_target_resume): Call target_async.
(resume_1): Set target's threads_executing flag. Consider resume
target.
(commit_resume_all_targets): New.
(proceed): Also consider resume target. Skip threads of inferiors
with no execution. Commit resumtion in all targets.
(start_remote): Pass current inferior to wait_for_inferior.
(infrun_thread_stop_requested): Consider target as well. Pass
thread_info pointer to clear_inline_frame_state instead of ptid.
(infrun_thread_thread_exit): Consider target as well.
(random_pending_event_thread): New inferior parameter. Use it.
(do_target_wait): Rename to ...
(do_target_wait_1): ... this. Add inferior parameter, and pass it
down.
(threads_are_resumed_pending_p, do_target_wait): New.
(prepare_for_detach): Adjust calls.
(wait_for_inferior): New inferior parameter. Handle it. Use
do_target_wait_1 instead of do_target_wait.
(fetch_inferior_event): Adjust. Switch to representative
inferior. Pass target down.
(set_last_target_status): Add process_stratum_target parameter.
Save target in global.
(get_last_target_status): Add process_stratum_target parameter and
handle it.
(nullify_last_target_wait_ptid): Clear 'target_last_proc_target'.
(context_switch): Check inferior_ptid == null_ptid before calling
inferior_thread().
(get_inferior_stop_soon): Pass down target.
(wait_one): Rename to ...
(poll_one_curr_target): ... this.
(struct wait_one_event): New.
(wait_one): New.
(stop_all_threads): Adjust.
(handle_no_resumed, handle_inferior_event): Adjust to consider the
event's target.
(switch_back_to_stepped_thread): Also consider target.
(print_stop_event): Update.
(normal_stop): Update. Also consider the resume target.
* infrun.h (wait_for_inferior): Remove declaration.
(user_visible_resume_target): New declaration.
(get_last_target_status, set_last_target_status): New
process_stratum_target parameter.
* inline-frame.c (clear_inline_frame_state(ptid_t)): Add
process_stratum_target parameter, and use it.
(clear_inline_frame_state (thread_info*)): New.
* inline-frame.c (clear_inline_frame_state(ptid_t)): Add
process_stratum_target parameter.
(clear_inline_frame_state (thread_info*)): Declare.
* linux-fork.c (delete_checkpoint_command): Pass target down to
find_thread_ptid.
(checkpoint_command): Adjust.
* linux-nat.c (linux_nat_target::follow_fork): Switch to thread
instead of just tweaking inferior_ptid.
(linux_nat_switch_fork): Pass target down to thread_change_ptid.
(exit_lwp): Pass target down to find_thread_ptid.
(attach_proc_task_lwp_callback): Pass target down to
add_thread/set_running/set_executing.
(linux_nat_target::attach): Pass target down to
thread_change_ptid.
(get_detach_signal): Pass target down to find_thread_ptid.
Consider last target status's target.
(linux_resume_one_lwp_throw, resume_lwp)
(linux_handle_syscall_trap, linux_handle_extended_wait, wait_lwp)
(stop_wait_callback, save_stop_reason, linux_nat_filter_event)
(linux_nat_wait_1, resume_stopped_resumed_lwps): Pass target down.
(linux_nat_target::async_wait_fd): New.
(linux_nat_stop_lwp, linux_nat_target::thread_address_space): Pass
target down.
* linux-nat.h (linux_nat_target::async_wait_fd): Declare.
* linux-tdep.c (get_thread_arch_regcache): Pass target down.
* linux-thread-db.c (struct thread_db_info::process_target): New
field.
(add_thread_db_info): Save target.
(get_thread_db_info): New process_stratum_target parameter. Also
match target.
(delete_thread_db_info): New process_stratum_target parameter.
Also match target.
(thread_from_lwp): Adjust to pass down target.
(thread_db_notice_clone): Pass down target.
(check_thread_db_callback): Pass down target.
(try_thread_db_load_1): Always push the thread_db target.
(try_thread_db_load, record_thread): Pass target down.
(thread_db_target::detach): Pass target down. Always unpush the
thread_db target.
(thread_db_target::wait, thread_db_target::mourn_inferior): Pass
target down. Always unpush the thread_db target.
(find_new_threads_callback, thread_db_find_new_threads_2)
(thread_db_target::update_thread_list): Pass target down.
(thread_db_target::pid_to_str): Pass current inferior down.
(thread_db_target::get_thread_local_address): Pass target down.
(thread_db_target::resume, maintenance_check_libthread_db): Pass
target down.
* nto-procfs.c (nto_procfs_target::update_thread_list): Adjust.
* procfs.c (procfs_target::procfs_init_inferior): Declare.
(proc_set_current_signal, do_attach, procfs_target::wait): Adjust.
(procfs_init_inferior): Rename to ...
(procfs_target::procfs_init_inferior): ... this and adjust.
(procfs_target::create_inferior, procfs_notice_thread)
(procfs_do_thread_registers): Adjust.
* ppc-fbsd-tdep.c: Include "inferior.h".
(ppcfbsd_get_thread_local_address): Pass down target.
* proc-service.c (ps_xfer_memory): Switch current inferior and
program space as well.
(get_ps_regcache): Pass target down.
* process-stratum-target.c
(process_stratum_target::thread_address_space)
(process_stratum_target::thread_architecture): Pass target down.
* process-stratum-target.h
(process_stratum_target::threads_executing): New field.
(as_process_stratum_target): New.
* ravenscar-thread.c
(ravenscar_thread_target::update_inferior_ptid): Pass target down.
(ravenscar_thread_target::wait, ravenscar_add_thread): Pass target
down.
* record-btrace.c (record_btrace_target::info_record): Adjust.
(record_btrace_target::record_method)
(record_btrace_target::record_is_replaying)
(record_btrace_target::fetch_registers)
(get_thread_current_frame_id, record_btrace_target::resume)
(record_btrace_target::wait, record_btrace_target::stop): Pass
target down.
* record-full.c (record_full_wait_1): Switch to event thread.
Pass target down.
* regcache.c (regcache::regcache)
(get_thread_arch_aspace_regcache, get_thread_arch_regcache): Add
process_stratum_target parameter and handle it.
(current_thread_target): New global.
(get_thread_regcache): Add process_stratum_target parameter and
handle it. Switch inferior before calling target method.
(get_thread_regcache): Pass target down.
(get_thread_regcache_for_ptid): Pass target down.
(registers_changed_ptid): Add process_stratum_target parameter and
handle it.
(registers_changed_thread, registers_changed): Pass target down.
(test_get_thread_arch_aspace_regcache): New.
(current_regcache_test): Define a couple local test_target_ops
instances and use them for testing.
(readwrite_regcache): Pass process_stratum_target parameter.
(cooked_read_test, cooked_write_test): Pass mock_target down.
* regcache.h (get_thread_regcache, get_thread_arch_regcache)
(get_thread_arch_aspace_regcache): Add process_stratum_target
parameter.
(regcache::target): New method.
(regcache::regcache, regcache::get_thread_arch_aspace_regcache)
(regcache::registers_changed_ptid): Add process_stratum_target
parameter.
(regcache::m_target): New field.
(registers_changed_ptid): Add process_stratum_target parameter.
* remote.c (remote_state::supports_vCont_probed): New field.
(remote_target::async_wait_fd): New method.
(remote_unpush_and_throw): Add remote_target parameter.
(get_current_remote_target): Adjust.
(remote_target::remote_add_inferior): Push target.
(remote_target::remote_add_thread)
(remote_target::remote_notice_new_inferior)
(get_remote_thread_info): Pass target down.
(remote_target::update_thread_list): Skip threads of inferiors
bound to other targets. (remote_target::close): Don't discard
inferiors. (remote_target::add_current_inferior_and_thread)
(remote_target::process_initial_stop_replies)
(remote_target::start_remote)
(remote_target::remote_serial_quit_handler): Pass down target.
(remote_target::remote_unpush_target): New remote_target
parameter. Unpush the target from all inferiors.
(remote_target::remote_unpush_and_throw): New remote_target
parameter. Pass it down.
(remote_target::open_1): Check whether the current inferior has
execution instead of checking whether any inferior is live. Pass
target down.
(remote_target::remote_detach_1): Pass down target. Use
remote_unpush_target.
(extended_remote_target::attach): Pass down target.
(remote_target::remote_vcont_probe): Set supports_vCont_probed.
(remote_target::append_resumption): Pass down target.
(remote_target::append_pending_thread_resumptions)
(remote_target::remote_resume_with_hc, remote_target::resume)
(remote_target::commit_resume): Pass down target.
(remote_target::remote_stop_ns): Check supports_vCont_probed.
(remote_target::interrupt_query)
(remote_target::remove_new_fork_children)
(remote_target::check_pending_events_prevent_wildcard_vcont)
(remote_target::remote_parse_stop_reply)
(remote_target::process_stop_reply): Pass down target.
(first_remote_resumed_thread): New remote_target parameter. Pass
it down.
(remote_target::wait_as): Pass down target.
(unpush_and_perror): New remote_target parameter. Pass it down.
(remote_target::readchar, remote_target::remote_serial_write)
(remote_target::getpkt_or_notif_sane_1)
(remote_target::kill_new_fork_children, remote_target::kill): Pass
down target.
(remote_target::mourn_inferior): Pass down target. Use
remote_unpush_target.
(remote_target::core_of_thread)
(remote_target::remote_btrace_maybe_reopen): Pass down target.
(remote_target::pid_to_exec_file)
(remote_target::thread_handle_to_thread_info): Pass down target.
(remote_target::async_wait_fd): New.
* riscv-fbsd-tdep.c: Include "inferior.h".
(riscv_fbsd_get_thread_local_address): Pass down target.
* sol2-tdep.c (sol2_core_pid_to_str): Pass down target.
* sol-thread.c (sol_thread_target::wait, ps_lgetregs, ps_lsetregs)
(ps_lgetfpregs, ps_lsetfpregs, sol_update_thread_list_callback):
Adjust.
* solib-spu.c (spu_skip_standalone_loader): Pass down target.
* solib-svr4.c (enable_break): Pass down target.
* spu-multiarch.c (parse_spufs_run): Pass down target.
* spu-tdep.c (spu2ppu_sniffer): Pass down target.
* target-delegates.c: Regenerate.
* target.c (g_target_stack): Delete.
(current_top_target): Return the current inferior's top target.
(target_has_execution_1): Refer to the passed-in inferior's top
target.
(target_supports_terminal_ours): Check whether the initial
inferior was already created.
(decref_target): New.
(target_stack::push): Incref/decref the target.
(push_target, push_target, unpush_target): Adjust.
(target_stack::unpush): Defref target.
(target_is_pushed): Return bool. Adjust to refer to the current
inferior's target stack.
(dispose_inferior): Delete, and inline parts ...
(target_preopen): ... here. Only dispose of the current inferior.
(target_detach): Hold strong target reference while detaching.
Pass target down.
(target_thread_name): Add assertion.
(target_resume): Pass down target.
(target_ops::beneath, find_target_at): Adjust to refer to the
current inferior's target stack.
(get_dummy_target): New.
(target_pass_ctrlc): Pass the Ctrl-C to the first inferior that
has a thread running.
(initialize_targets): Rename to ...
(_initialize_target): ... this.
* target.h: Include "gdbsupport/refcounted-object.h".
(struct target_ops): Inherit refcounted_object.
(target_ops::shortname, target_ops::longname): Make const.
(target_ops::async_wait_fd): New method.
(decref_target): Declare.
(struct target_ops_ref_policy): New.
(target_ops_ref): New typedef.
(get_dummy_target): Declare function.
(target_is_pushed): Return bool.
* thread-iter.c (all_matching_threads_iterator::m_inf_matches)
(all_matching_threads_iterator::all_matching_threads_iterator):
Handle filter target.
* thread-iter.h (struct all_matching_threads_iterator, struct
all_matching_threads_range, class all_non_exited_threads_range):
Filter by target too. Remove explicit.
* thread.c (threads_executing): Delete.
(inferior_thread): Pass down current inferior.
(clear_thread_inferior_resources): Pass down thread pointer
instead of ptid_t.
(add_thread_silent, add_thread_with_info, add_thread): Add
process_stratum_target parameter. Use it for thread and inferior
searches.
(is_current_thread): New.
(thread_info::deletable): Use it.
(find_thread_ptid, thread_count, in_thread_list)
(thread_change_ptid, set_resumed, set_running): New
process_stratum_target parameter. Pass it down.
(set_executing): New process_stratum_target parameter. Pass it
down. Adjust reference to 'threads_executing'.
(threads_are_executing): New process_stratum_target parameter.
Adjust reference to 'threads_executing'.
(set_stop_requested, finish_thread_state): New
process_stratum_target parameter. Pass it down.
(switch_to_thread): Also match inferior.
(switch_to_thread): New process_stratum_target parameter. Pass it
down.
(update_threads_executing): Reimplement.
* top.c (quit_force): Pop targets from all inferior.
(gdb_init): Don't call initialize_targets.
* windows-nat.c (windows_nat_target) <get_windows_debug_event>:
Declare.
(windows_add_thread, windows_delete_thread): Adjust.
(get_windows_debug_event): Rename to ...
(windows_nat_target::get_windows_debug_event): ... this. Adjust.
* tracefile-tfile.c (tfile_target_open): Pass down target.
* gdbsupport/common-gdbthread.h (struct process_stratum_target):
Forward declare.
(switch_to_thread): Add process_stratum_target parameter.
* mi/mi-interp.c (mi_on_resume_1): Add process_stratum_target
parameter. Use it.
(mi_on_resume): Pass target down.
* nat/fork-inferior.c (startup_inferior): Add
process_stratum_target parameter. Pass it down.
* nat/fork-inferior.h (startup_inferior): Add
process_stratum_target parameter.
* python/py-threadevent.c (py_get_event_thread): Pass target down.
gdb/gdbserver/ChangeLog:
2020-01-10 Pedro Alves <palves@redhat.com>
* fork-child.c (post_fork_inferior): Pass target down to
startup_inferior.
* inferiors.c (switch_to_thread): Add process_stratum_target
parameter.
* lynx-low.c (lynx_target_ops): Now a process_stratum_target.
* nto-low.c (nto_target_ops): Now a process_stratum_target.
* linux-low.c (linux_target_ops): Now a process_stratum_target.
* remote-utils.c (prepare_resume_reply): Pass the target to
switch_to_thread.
* target.c (the_target): Now a process_stratum_target.
(done_accessing_memory): Pass the target to switch_to_thread.
(set_target_ops): Ajust to use process_stratum_target.
* target.h (struct target_ops): Rename to ...
(struct process_stratum_target): ... this.
(the_target, set_target_ops): Adjust.
(prepare_to_access_memory): Adjust comment.
* win32-low.c (child_xfer_memory): Adjust to use
process_stratum_target.
(win32_target_ops): Now a process_stratum_target.
694 lines
22 KiB
C++
694 lines
22 KiB
C++
/* Variables that describe the inferior process running under GDB:
|
||
Where it is, why it stopped, and how to step it.
|
||
|
||
Copyright (C) 1986-2020 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/>. */
|
||
|
||
#if !defined (INFERIOR_H)
|
||
#define INFERIOR_H 1
|
||
|
||
struct target_waitstatus;
|
||
struct frame_info;
|
||
struct ui_file;
|
||
struct type;
|
||
struct gdbarch;
|
||
struct regcache;
|
||
struct ui_out;
|
||
struct terminal_info;
|
||
struct target_desc_info;
|
||
struct continuation;
|
||
struct inferior;
|
||
struct thread_info;
|
||
|
||
/* For bpstat. */
|
||
#include "breakpoint.h"
|
||
|
||
/* For enum gdb_signal. */
|
||
#include "target.h"
|
||
|
||
/* For struct frame_id. */
|
||
#include "frame.h"
|
||
|
||
/* For gdb_environ. */
|
||
#include "gdbsupport/environ.h"
|
||
|
||
#include "progspace.h"
|
||
#include "registry.h"
|
||
|
||
#include "symfile-add-flags.h"
|
||
#include "gdbsupport/refcounted-object.h"
|
||
#include "gdbsupport/forward-scope-exit.h"
|
||
|
||
#include "gdbsupport/common-inferior.h"
|
||
#include "gdbthread.h"
|
||
|
||
#include "process-stratum-target.h"
|
||
|
||
struct infcall_suspend_state;
|
||
struct infcall_control_state;
|
||
|
||
extern void restore_infcall_suspend_state (struct infcall_suspend_state *);
|
||
extern void restore_infcall_control_state (struct infcall_control_state *);
|
||
|
||
/* A deleter for infcall_suspend_state that calls
|
||
restore_infcall_suspend_state. */
|
||
struct infcall_suspend_state_deleter
|
||
{
|
||
void operator() (struct infcall_suspend_state *state) const
|
||
{
|
||
try
|
||
{
|
||
restore_infcall_suspend_state (state);
|
||
}
|
||
catch (const gdb_exception_error &e)
|
||
{
|
||
/* If we are restoring the inferior state due to an exception,
|
||
some error message will be printed. So, only warn the user
|
||
when we cannot restore during normal execution. */
|
||
if (!std::uncaught_exception ())
|
||
warning (_("Failed to restore inferior state: %s"), e.what ());
|
||
}
|
||
}
|
||
};
|
||
|
||
/* A unique_ptr specialization for infcall_suspend_state. */
|
||
typedef std::unique_ptr<infcall_suspend_state, infcall_suspend_state_deleter>
|
||
infcall_suspend_state_up;
|
||
|
||
extern infcall_suspend_state_up save_infcall_suspend_state ();
|
||
|
||
/* A deleter for infcall_control_state that calls
|
||
restore_infcall_control_state. */
|
||
struct infcall_control_state_deleter
|
||
{
|
||
void operator() (struct infcall_control_state *state) const
|
||
{
|
||
restore_infcall_control_state (state);
|
||
}
|
||
};
|
||
|
||
/* A unique_ptr specialization for infcall_control_state. */
|
||
typedef std::unique_ptr<infcall_control_state, infcall_control_state_deleter>
|
||
infcall_control_state_up;
|
||
|
||
extern infcall_control_state_up save_infcall_control_state ();
|
||
|
||
extern void discard_infcall_suspend_state (struct infcall_suspend_state *);
|
||
extern void discard_infcall_control_state (struct infcall_control_state *);
|
||
|
||
extern readonly_detached_regcache *
|
||
get_infcall_suspend_state_regcache (struct infcall_suspend_state *);
|
||
|
||
extern void set_sigint_trap (void);
|
||
|
||
extern void clear_sigint_trap (void);
|
||
|
||
/* Set/get file name for default use for standard in/out in the inferior. */
|
||
|
||
extern void set_inferior_io_terminal (const char *terminal_name);
|
||
extern const char *get_inferior_io_terminal (void);
|
||
|
||
/* Collected pid, tid, etc. of the debugged inferior. When there's
|
||
no inferior, inferior_ptid.pid () will be 0. */
|
||
|
||
extern ptid_t inferior_ptid;
|
||
|
||
extern void generic_mourn_inferior (void);
|
||
|
||
extern CORE_ADDR unsigned_pointer_to_address (struct gdbarch *gdbarch,
|
||
struct type *type,
|
||
const gdb_byte *buf);
|
||
extern void unsigned_address_to_pointer (struct gdbarch *gdbarch,
|
||
struct type *type, gdb_byte *buf,
|
||
CORE_ADDR addr);
|
||
extern CORE_ADDR signed_pointer_to_address (struct gdbarch *gdbarch,
|
||
struct type *type,
|
||
const gdb_byte *buf);
|
||
extern void address_to_signed_pointer (struct gdbarch *gdbarch,
|
||
struct type *type, gdb_byte *buf,
|
||
CORE_ADDR addr);
|
||
|
||
extern void reopen_exec_file (void);
|
||
|
||
/* From misc files */
|
||
|
||
extern void default_print_registers_info (struct gdbarch *gdbarch,
|
||
struct ui_file *file,
|
||
struct frame_info *frame,
|
||
int regnum, int all);
|
||
|
||
/* Default implementation of gdbarch_print_float_info. Print
|
||
the values of all floating point registers. */
|
||
|
||
extern void default_print_float_info (struct gdbarch *gdbarch,
|
||
struct ui_file *file,
|
||
struct frame_info *frame,
|
||
const char *args);
|
||
|
||
extern void child_terminal_info (struct target_ops *self, const char *, int);
|
||
|
||
extern void child_terminal_ours (struct target_ops *self);
|
||
|
||
extern void child_terminal_ours_for_output (struct target_ops *self);
|
||
|
||
extern void child_terminal_inferior (struct target_ops *self);
|
||
|
||
extern void child_terminal_save_inferior (struct target_ops *self);
|
||
|
||
extern void child_terminal_init (struct target_ops *self);
|
||
|
||
extern void child_terminal_init_with_pgrp (int pgrp);
|
||
|
||
extern void child_pass_ctrlc (struct target_ops *self);
|
||
|
||
extern void child_interrupt (struct target_ops *self);
|
||
|
||
/* From fork-child.c */
|
||
|
||
/* Helper function to call STARTUP_INFERIOR with PID and NUM_TRAPS.
|
||
This function already calls set_executing. Return the ptid_t from
|
||
STARTUP_INFERIOR. */
|
||
extern ptid_t gdb_startup_inferior (pid_t pid, int num_traps);
|
||
|
||
extern char *construct_inferior_arguments (int, char **);
|
||
|
||
/* From infcmd.c */
|
||
|
||
/* Initial inferior setup. Determines the exec file is not yet known,
|
||
takes any necessary post-attaching actions, fetches the target
|
||
description and syncs the shared library list. */
|
||
|
||
extern void setup_inferior (int from_tty);
|
||
|
||
extern void post_create_inferior (struct target_ops *, int);
|
||
|
||
extern void attach_command (const char *, int);
|
||
|
||
extern const char *get_inferior_args (void);
|
||
|
||
extern void set_inferior_args (const char *);
|
||
|
||
extern void set_inferior_args_vector (int, char **);
|
||
|
||
extern void registers_info (const char *, int);
|
||
|
||
extern void continue_1 (int all_threads);
|
||
|
||
extern void interrupt_target_1 (bool all_threads);
|
||
|
||
using delete_longjmp_breakpoint_cleanup
|
||
= FORWARD_SCOPE_EXIT (delete_longjmp_breakpoint);
|
||
|
||
extern void detach_command (const char *, int);
|
||
|
||
extern void notice_new_inferior (struct thread_info *, int, int);
|
||
|
||
extern struct value *get_return_value (struct value *function,
|
||
struct type *value_type);
|
||
|
||
/* Prepare for execution command. TARGET is the target that will run
|
||
the command. BACKGROUND determines whether this is a foreground
|
||
(synchronous) or background (asynchronous) command. */
|
||
|
||
extern void prepare_execution_command (struct target_ops *target,
|
||
int background);
|
||
|
||
/* Nonzero if stopped due to completion of a stack dummy routine. */
|
||
|
||
extern enum stop_stack_kind stop_stack_dummy;
|
||
|
||
/* Nonzero if program stopped due to a random (unexpected) signal in
|
||
inferior process. */
|
||
|
||
extern int stopped_by_random_signal;
|
||
|
||
/* Print notices on inferior events (attach, detach, etc.), set with
|
||
`set print inferior-events'. */
|
||
extern bool print_inferior_events;
|
||
|
||
/* Anything but NO_STOP_QUIETLY means we expect a trap and the caller
|
||
will handle it themselves. STOP_QUIETLY is used when running in
|
||
the shell before the child program has been exec'd and when running
|
||
through shared library loading. STOP_QUIETLY_REMOTE is used when
|
||
setting up a remote connection; it is like STOP_QUIETLY_NO_SIGSTOP
|
||
except that there is no need to hide a signal. */
|
||
|
||
/* STOP_QUIETLY_NO_SIGSTOP is used to handle a tricky situation with attach.
|
||
When doing an attach, the kernel stops the debuggee with a SIGSTOP.
|
||
On newer GNU/Linux kernels (>= 2.5.61) the handling of SIGSTOP for
|
||
a ptraced process has changed. Earlier versions of the kernel
|
||
would ignore these SIGSTOPs, while now SIGSTOP is treated like any
|
||
other signal, i.e. it is not muffled.
|
||
|
||
If the gdb user does a 'continue' after the 'attach', gdb passes
|
||
the global variable stop_signal (which stores the signal from the
|
||
attach, SIGSTOP) to the ptrace(PTRACE_CONT,...) call. This is
|
||
problematic, because the kernel doesn't ignore such SIGSTOP
|
||
now. I.e. it is reported back to gdb, which in turn presents it
|
||
back to the user.
|
||
|
||
To avoid the problem, we use STOP_QUIETLY_NO_SIGSTOP, which allows
|
||
gdb to clear the value of stop_signal after the attach, so that it
|
||
is not passed back down to the kernel. */
|
||
|
||
enum stop_kind
|
||
{
|
||
NO_STOP_QUIETLY = 0,
|
||
STOP_QUIETLY,
|
||
STOP_QUIETLY_REMOTE,
|
||
STOP_QUIETLY_NO_SIGSTOP
|
||
};
|
||
|
||
|
||
/* Possible values for gdbarch_call_dummy_location. */
|
||
#define ON_STACK 1
|
||
#define AT_ENTRY_POINT 4
|
||
|
||
/* Base class for target-specific inferior data. */
|
||
|
||
struct private_inferior
|
||
{
|
||
virtual ~private_inferior () = 0;
|
||
};
|
||
|
||
/* Inferior process specific part of `struct infcall_control_state'.
|
||
|
||
Inferior thread counterpart is `struct thread_control_state'. */
|
||
|
||
struct inferior_control_state
|
||
{
|
||
inferior_control_state ()
|
||
: stop_soon (NO_STOP_QUIETLY)
|
||
{
|
||
}
|
||
|
||
explicit inferior_control_state (enum stop_kind when)
|
||
: stop_soon (when)
|
||
{
|
||
}
|
||
|
||
/* See the definition of stop_kind above. */
|
||
enum stop_kind stop_soon;
|
||
};
|
||
|
||
/* Return a pointer to the current inferior. */
|
||
extern inferior *current_inferior ();
|
||
|
||
extern void set_current_inferior (inferior *);
|
||
|
||
/* Switch inferior (and program space) to INF, and switch to no thread
|
||
selected. */
|
||
extern void switch_to_inferior_no_thread (inferior *inf);
|
||
|
||
/* GDB represents the state of each program execution with an object
|
||
called an inferior. An inferior typically corresponds to a process
|
||
but is more general and applies also to targets that do not have a
|
||
notion of processes. Each run of an executable creates a new
|
||
inferior, as does each attachment to an existing process.
|
||
Inferiors have unique internal identifiers that are different from
|
||
target process ids. Each inferior may in turn have multiple
|
||
threads running in it.
|
||
|
||
Inferiors are intrusively refcounted objects. Unlike thread
|
||
objects, being the user-selected inferior is considered a strong
|
||
reference and is thus accounted for in the inferior object's
|
||
refcount (see set_current_inferior). When GDB needs to remember
|
||
the selected inferior to later restore it, GDB temporarily bumps
|
||
the inferior object's refcount, to prevent something deleting the
|
||
inferior object before reverting back (e.g., due to a
|
||
"remove-inferiors" command (see
|
||
scoped_restore_current_inferior). All other inferior
|
||
references are considered weak references. Inferiors are always
|
||
listed exactly once in the inferior list, so placing an inferior in
|
||
the inferior list is an implicit, not counted strong reference. */
|
||
|
||
class inferior : public refcounted_object
|
||
{
|
||
public:
|
||
explicit inferior (int pid);
|
||
~inferior ();
|
||
|
||
/* Returns true if we can delete this inferior. */
|
||
bool deletable () const { return refcount () == 0; }
|
||
|
||
/* Push T in this inferior's target stack. */
|
||
void push_target (struct target_ops *t)
|
||
{ m_target_stack.push (t); }
|
||
|
||
/* Unpush T from this inferior's target stack. */
|
||
int unpush_target (struct target_ops *t)
|
||
{ return m_target_stack.unpush (t); }
|
||
|
||
/* Returns true if T is pushed in this inferior's target stack. */
|
||
bool target_is_pushed (target_ops *t)
|
||
{ return m_target_stack.is_pushed (t); }
|
||
|
||
/* Find the target beneath T in this inferior's target stack. */
|
||
target_ops *find_target_beneath (const target_ops *t)
|
||
{ return m_target_stack.find_beneath (t); }
|
||
|
||
/* Return the target at the top of this inferior's target stack. */
|
||
target_ops *top_target ()
|
||
{ return m_target_stack.top (); }
|
||
|
||
/* Return the target at process_stratum level in this inferior's
|
||
target stack. */
|
||
struct process_stratum_target *process_target ()
|
||
{ return (process_stratum_target *) m_target_stack.at (process_stratum); }
|
||
|
||
/* Return the target at STRATUM in this inferior's target stack. */
|
||
target_ops *target_at (enum strata stratum)
|
||
{ return m_target_stack.at (stratum); }
|
||
|
||
bool has_execution ()
|
||
{ return target_has_execution_1 (this); }
|
||
|
||
/* Pointer to next inferior in singly-linked list of inferiors. */
|
||
struct inferior *next = NULL;
|
||
|
||
/* This inferior's thread list. */
|
||
thread_info *thread_list = nullptr;
|
||
|
||
/* Returns a range adapter covering the inferior's threads,
|
||
including exited threads. Used like this:
|
||
|
||
for (thread_info *thr : inf->threads ())
|
||
{ .... }
|
||
*/
|
||
inf_threads_range threads ()
|
||
{ return inf_threads_range (this->thread_list); }
|
||
|
||
/* Returns a range adapter covering the inferior's non-exited
|
||
threads. Used like this:
|
||
|
||
for (thread_info *thr : inf->non_exited_threads ())
|
||
{ .... }
|
||
*/
|
||
inf_non_exited_threads_range non_exited_threads ()
|
||
{ return inf_non_exited_threads_range (this->thread_list); }
|
||
|
||
/* Like inferior::threads(), but returns a range adapter that can be
|
||
used with range-for, safely. I.e., it is safe to delete the
|
||
currently-iterated thread, like this:
|
||
|
||
for (thread_info *t : inf->threads_safe ())
|
||
if (some_condition ())
|
||
delete f;
|
||
*/
|
||
inline safe_inf_threads_range threads_safe ()
|
||
{ return safe_inf_threads_range (this->thread_list); }
|
||
|
||
/* Convenient handle (GDB inferior id). Unique across all
|
||
inferiors. */
|
||
int num = 0;
|
||
|
||
/* Actual target inferior id, usually, a process id. This matches
|
||
the ptid_t.pid member of threads of this inferior. */
|
||
int pid = 0;
|
||
/* True if the PID was actually faked by GDB. */
|
||
bool fake_pid_p = false;
|
||
|
||
/* The highest thread number this inferior ever had. */
|
||
int highest_thread_num = 0;
|
||
|
||
/* State of GDB control of inferior process execution.
|
||
See `struct inferior_control_state'. */
|
||
inferior_control_state control;
|
||
|
||
/* True if this was an auto-created inferior, e.g. created from
|
||
following a fork; false, if this inferior was manually added by
|
||
the user, and we should not attempt to prune it
|
||
automatically. */
|
||
bool removable = false;
|
||
|
||
/* The address space bound to this inferior. */
|
||
struct address_space *aspace = NULL;
|
||
|
||
/* The program space bound to this inferior. */
|
||
struct program_space *pspace = NULL;
|
||
|
||
/* The arguments string to use when running. */
|
||
char *args = NULL;
|
||
|
||
/* The size of elements in argv. */
|
||
int argc = 0;
|
||
|
||
/* The vector version of arguments. If ARGC is nonzero,
|
||
then we must compute ARGS from this (via the target).
|
||
This is always coming from main's argv and therefore
|
||
should never be freed. */
|
||
char **argv = NULL;
|
||
|
||
/* The current working directory that will be used when starting
|
||
this inferior. */
|
||
gdb::unique_xmalloc_ptr<char> cwd;
|
||
|
||
/* The name of terminal device to use for I/O. */
|
||
char *terminal = NULL;
|
||
|
||
/* The terminal state as set by the last target_terminal::terminal_*
|
||
call. */
|
||
target_terminal_state terminal_state = target_terminal_state::is_ours;
|
||
|
||
/* Environment to use for running inferior,
|
||
in format described in environ.h. */
|
||
gdb_environ environment;
|
||
|
||
/* True if this child process was attached rather than forked. */
|
||
bool attach_flag = false;
|
||
|
||
/* If this inferior is a vfork child, then this is the pointer to
|
||
its vfork parent, if GDB is still attached to it. */
|
||
inferior *vfork_parent = NULL;
|
||
|
||
/* If this process is a vfork parent, this is the pointer to the
|
||
child. Since a vfork parent is left frozen by the kernel until
|
||
the child execs or exits, a process can only have one vfork child
|
||
at a given time. */
|
||
inferior *vfork_child = NULL;
|
||
|
||
/* True if this inferior should be detached when it's vfork sibling
|
||
exits or execs. */
|
||
bool pending_detach = false;
|
||
|
||
/* True if this inferior is a vfork parent waiting for a vfork child
|
||
not under our control to be done with the shared memory region,
|
||
either by exiting or execing. */
|
||
bool waiting_for_vfork_done = false;
|
||
|
||
/* True if we're in the process of detaching from this inferior. */
|
||
bool detaching = false;
|
||
|
||
/* What is left to do for an execution command after any thread of
|
||
this inferior stops. For continuations associated with a
|
||
specific thread, see `struct thread_info'. */
|
||
continuation *continuations = NULL;
|
||
|
||
/* True if setup_inferior wasn't called for this inferior yet.
|
||
Until that is done, we must not access inferior memory or
|
||
registers, as we haven't determined the target
|
||
architecture/description. */
|
||
bool needs_setup = false;
|
||
|
||
/* Private data used by the target vector implementation. */
|
||
std::unique_ptr<private_inferior> priv;
|
||
|
||
/* HAS_EXIT_CODE is true if the inferior exited with an exit code.
|
||
In this case, the EXIT_CODE field is also valid. */
|
||
bool has_exit_code = false;
|
||
LONGEST exit_code = 0;
|
||
|
||
/* Default flags to pass to the symbol reading functions. These are
|
||
used whenever a new objfile is created. */
|
||
symfile_add_flags symfile_flags = 0;
|
||
|
||
/* Info about an inferior's target description (if it's fetched; the
|
||
user supplied description's filename, if any; etc.). */
|
||
target_desc_info *tdesc_info = NULL;
|
||
|
||
/* The architecture associated with the inferior through the
|
||
connection to the target.
|
||
|
||
The architecture vector provides some information that is really
|
||
a property of the inferior, accessed through a particular target:
|
||
ptrace operations; the layout of certain RSP packets; the
|
||
solib_ops vector; etc. To differentiate architecture accesses to
|
||
per-inferior/target properties from
|
||
per-thread/per-frame/per-objfile properties, accesses to
|
||
per-inferior/target properties should be made through
|
||
this gdbarch. */
|
||
struct gdbarch *gdbarch = NULL;
|
||
|
||
/* Data related to displaced stepping. */
|
||
displaced_step_inferior_state displaced_step_state;
|
||
|
||
/* Per inferior data-pointers required by other GDB modules. */
|
||
REGISTRY_FIELDS;
|
||
|
||
private:
|
||
/* The inferior's target stack. */
|
||
target_stack m_target_stack;
|
||
};
|
||
|
||
/* Keep a registry of per-inferior data-pointers required by other GDB
|
||
modules. */
|
||
|
||
DECLARE_REGISTRY (inferior);
|
||
|
||
/* Add an inferior to the inferior list, print a message that a new
|
||
inferior is found, and return the pointer to the new inferior.
|
||
Caller may use this pointer to initialize the private inferior
|
||
data. */
|
||
extern struct inferior *add_inferior (int pid);
|
||
|
||
/* Same as add_inferior, but don't print new inferior notifications to
|
||
the CLI. */
|
||
extern struct inferior *add_inferior_silent (int pid);
|
||
|
||
extern void delete_inferior (struct inferior *todel);
|
||
|
||
/* Delete an existing inferior list entry, due to inferior detaching. */
|
||
extern void detach_inferior (inferior *inf);
|
||
|
||
extern void exit_inferior (inferior *inf);
|
||
|
||
extern void exit_inferior_silent (inferior *inf);
|
||
|
||
extern void exit_inferior_num_silent (int num);
|
||
|
||
extern void inferior_appeared (struct inferior *inf, int pid);
|
||
|
||
/* Search function to lookup an inferior of TARG by target 'pid'. */
|
||
extern struct inferior *find_inferior_pid (process_stratum_target *targ,
|
||
int pid);
|
||
|
||
/* Search function to lookup an inferior of TARG whose pid is equal to
|
||
'ptid.pid'. */
|
||
extern struct inferior *find_inferior_ptid (process_stratum_target *targ,
|
||
ptid_t ptid);
|
||
|
||
/* Search function to lookup an inferior by GDB 'num'. */
|
||
extern struct inferior *find_inferior_id (int num);
|
||
|
||
/* Find an inferior bound to PSPACE, giving preference to the current
|
||
inferior. */
|
||
extern struct inferior *
|
||
find_inferior_for_program_space (struct program_space *pspace);
|
||
|
||
/* Inferior iterator function.
|
||
|
||
Calls a callback function once for each inferior, so long as the
|
||
callback function returns false. If the callback function returns
|
||
true, the iteration will end and the current inferior will be
|
||
returned. This can be useful for implementing a search for a
|
||
inferior with arbitrary attributes, or for applying some operation
|
||
to every inferior.
|
||
|
||
It is safe to delete the iterated inferior from the callback. */
|
||
extern struct inferior *iterate_over_inferiors (int (*) (struct inferior *,
|
||
void *),
|
||
void *);
|
||
|
||
/* Returns true if the inferior list is not empty. */
|
||
extern int have_inferiors (void);
|
||
|
||
/* Returns the number of live inferiors running on PROC_TARGET (real
|
||
live processes with execution). */
|
||
extern int number_of_live_inferiors (process_stratum_target *proc_target);
|
||
|
||
/* Returns true if there are any live inferiors in the inferior list
|
||
(not cores, not executables, real live processes). */
|
||
extern int have_live_inferiors (void);
|
||
|
||
/* Save/restore the current inferior. */
|
||
|
||
class scoped_restore_current_inferior
|
||
{
|
||
public:
|
||
scoped_restore_current_inferior ()
|
||
: m_saved_inf (current_inferior ())
|
||
{}
|
||
|
||
~scoped_restore_current_inferior ()
|
||
{ set_current_inferior (m_saved_inf); }
|
||
|
||
DISABLE_COPY_AND_ASSIGN (scoped_restore_current_inferior);
|
||
|
||
private:
|
||
inferior *m_saved_inf;
|
||
};
|
||
|
||
|
||
/* Traverse all inferiors. */
|
||
|
||
extern struct inferior *inferior_list;
|
||
|
||
/* Pull in the internals of the inferiors ranges and iterators. Must
|
||
be done after struct inferior is defined. */
|
||
#include "inferior-iter.h"
|
||
|
||
/* Return a range that can be used to walk over all inferiors
|
||
inferiors, with range-for, safely. I.e., it is safe to delete the
|
||
currently-iterated inferior. When combined with range-for, this
|
||
allow convenient patterns like this:
|
||
|
||
for (inferior *inf : all_inferiors_safe ())
|
||
if (some_condition ())
|
||
delete inf;
|
||
*/
|
||
|
||
inline all_inferiors_safe_range
|
||
all_inferiors_safe ()
|
||
{
|
||
return {};
|
||
}
|
||
|
||
/* Returns a range representing all inferiors, suitable to use with
|
||
range-for, like this:
|
||
|
||
for (inferior *inf : all_inferiors ())
|
||
[...]
|
||
*/
|
||
|
||
inline all_inferiors_range
|
||
all_inferiors (process_stratum_target *proc_target = nullptr)
|
||
{
|
||
return all_inferiors_range (proc_target);
|
||
}
|
||
|
||
/* Return a range that can be used to walk over all inferiors with PID
|
||
not zero, with range-for. */
|
||
|
||
inline all_non_exited_inferiors_range
|
||
all_non_exited_inferiors (process_stratum_target *proc_target = nullptr)
|
||
{
|
||
return all_non_exited_inferiors_range (proc_target);
|
||
}
|
||
|
||
/* Prune away automatically added inferiors that aren't required
|
||
anymore. */
|
||
extern void prune_inferiors (void);
|
||
|
||
extern int number_of_inferiors (void);
|
||
|
||
extern struct inferior *add_inferior_with_spaces (void);
|
||
|
||
/* Print the current selected inferior. */
|
||
extern void print_selected_inferior (struct ui_out *uiout);
|
||
|
||
#endif /* !defined (INFERIOR_H) */
|