/* Target-struct-independent code to start (run) and stop an inferior
process.
- Copyright (C) 1986-2019 Free Software Foundation, Inc.
+ Copyright (C) 1986-2020 Free Software Foundation, Inc.
This file is part of GDB.
#include "frame.h"
#include "inferior.h"
#include "breakpoint.h"
-#include "common/gdb_wait.h"
#include "gdbcore.h"
#include "gdbcmd.h"
-#include "cli/cli-script.h"
#include "target.h"
#include "gdbthread.h"
#include "annotate.h"
#include "symfile.h"
#include "top.h"
-#include <signal.h>
#include "inf-loop.h"
#include "regcache.h"
#include "value.h"
#include "language.h"
#include "solib.h"
#include "main.h"
-#include "dictionary.h"
#include "block.h"
#include "mi/mi-common.h"
#include "event-top.h"
#include "inline-frame.h"
#include "jit.h"
#include "tracepoint.h"
-#include "continuations.h"
-#include "interps.h"
#include "skip.h"
#include "probe.h"
#include "objfiles.h"
#include "solist.h"
#include "event-loop.h"
#include "thread-fsm.h"
-#include "common/enum-flags.h"
+#include "gdbsupport/enum-flags.h"
#include "progspace-and-thread.h"
-#include "common/gdb_optional.h"
+#include "gdbsupport/gdb_optional.h"
#include "arch-utils.h"
-#include "common/scope-exit.h"
-#include "common/forward-scope-exit.h"
+#include "gdbsupport/scope-exit.h"
+#include "gdbsupport/forward-scope-exit.h"
/* Prototypes for local functions */
static int currently_stepping (struct thread_info *tp);
-void nullify_last_target_wait_ptid (void);
-
static void insert_hp_step_resume_breakpoint_at_frame (struct frame_info *);
static void insert_step_resume_breakpoint_at_caller (struct frame_info *);
/* When set, stop the 'step' command if we enter a function which has
no line number information. The normal behavior is that we step
over such function. */
-int step_stop_if_no_debug = 0;
+bool step_stop_if_no_debug = false;
static void
show_step_stop_if_no_debug (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
Exactly which branch is detached depends on 'set follow-fork-mode'
setting. */
-static int detach_fork = 1;
+static bool detach_fork = true;
-int debug_displaced = 0;
+bool debug_displaced = false;
static void
show_debug_displaced (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
/* Support for disabling address space randomization. */
-int disable_randomization = 1;
+bool disable_randomization = true;
static void
show_disable_randomization (struct ui_file *file, int from_tty,
/* User interface for non-stop mode. */
-int non_stop = 0;
-static int non_stop_1 = 0;
+bool non_stop = false;
+static bool non_stop_1 = false;
static void
set_non_stop (const char *args, int from_tty,
non-stop, in which all GDB operations that might affect the
target's execution have been disabled. */
-int observer_mode = 0;
-static int observer_mode_1 = 0;
+bool observer_mode = false;
+static bool observer_mode_1 = false;
static void
set_observer_mode (const char *args, int from_tty,
/* We can insert fast tracepoints in or out of observer mode,
but enable them if we're going into this mode. */
if (observer_mode)
- may_insert_fast_tracepoints = 1;
+ may_insert_fast_tracepoints = true;
may_stop = !observer_mode;
update_target_permissions ();
if (observer_mode)
{
pagination_enabled = 0;
- non_stop = non_stop_1 = 1;
+ non_stop = non_stop_1 = true;
}
if (from_tty)
void
update_observer_mode (void)
{
- int newval;
-
- newval = (!may_insert_breakpoints
- && !may_insert_tracepoints
- && may_insert_fast_tracepoints
- && !may_stop
- && non_stop);
+ bool newval = (!may_insert_breakpoints
+ && !may_insert_tracepoints
+ && may_insert_fast_tracepoints
+ && !may_stop
+ && non_stop);
/* Let the user know if things change. */
if (newval != observer_mode)
Can not resume the parent process over vfork in the foreground while\n\
holding the child stopped. Try \"set detach-on-fork\" or \
\"set schedule-multiple\".\n"));
- /* FIXME output string > 80 columns. */
return 1;
}
int resume_parent = -1;
/* This exec or exit marks the end of the shared memory region
- between the parent and the child. If the user wanted to
- detach from the parent, now is the time. */
+ between the parent and the child. Break the bonds. */
+ inferior *vfork_parent = inf->vfork_parent;
+ inf->vfork_parent->vfork_child = NULL;
+ inf->vfork_parent = NULL;
- if (inf->vfork_parent->pending_detach)
+ /* If the user wanted to detach from the parent, now is the
+ time. */
+ if (vfork_parent->pending_detach)
{
struct thread_info *tp;
struct program_space *pspace;
/* follow-fork child, detach-on-fork on. */
- inf->vfork_parent->pending_detach = 0;
+ vfork_parent->pending_detach = 0;
gdb::optional<scoped_restore_exited_inferior>
maybe_restore_inferior;
maybe_restore_thread.emplace ();
/* We're letting loose of the parent. */
- tp = any_live_thread_of_inferior (inf->vfork_parent);
+ tp = any_live_thread_of_inferior (vfork_parent);
switch_to_thread (tp);
/* We're about to detach from the parent, which implicitly
if (print_inferior_events)
{
std::string pidstr
- = target_pid_to_str (ptid_t (inf->vfork_parent->pid));
+ = target_pid_to_str (ptid_t (vfork_parent->pid));
target_terminal::ours_for_output ();
}
}
- target_detach (inf->vfork_parent, 0);
+ target_detach (vfork_parent, 0);
/* Put it back. */
inf->pspace = pspace;
inf->removable = 1;
set_current_program_space (inf->pspace);
- resume_parent = inf->vfork_parent->pid;
-
- /* Break the bonds. */
- inf->vfork_parent->vfork_child = NULL;
+ resume_parent = vfork_parent->pid;
}
else
{
set_current_program_space (pspace);
inf->removable = 1;
inf->symfile_flags = SYMFILE_NO_READ;
- clone_program_space (pspace, inf->vfork_parent->pspace);
+ clone_program_space (pspace, vfork_parent->pspace);
inf->pspace = pspace;
inf->aspace = pspace->aspace;
- resume_parent = inf->vfork_parent->pid;
- /* Break the bonds. */
- inf->vfork_parent->vfork_child = NULL;
+ resume_parent = vfork_parent->pid;
}
- inf->vfork_parent = NULL;
-
gdb_assert (current_program_space == inf->pspace);
if (non_stop && resume_parent != -1)
/* EXEC_FILE_TARGET is assumed to be non-NULL. */
static void
-follow_exec (ptid_t ptid, char *exec_file_target)
+follow_exec (ptid_t ptid, const char *exec_file_target)
{
struct inferior *inf = current_inferior ();
int pid = ptid.pid ();
And, we DON'T want to call delete_breakpoints() here, since
that may write the bp's "shadow contents" (the instruction
- value that was overwritten witha TRAP instruction). Since
+ value that was overwritten with a TRAP instruction). Since
we now have a new a.out, those shadow contents aren't valid. */
mark_breakpoints_out ();
register contents, and memory. We use this in step n1.
- gdbarch_displaced_step_fixup adjusts registers and memory after
- we have successfuly single-stepped the instruction, to yield the
+ we have successfully single-stepped the instruction, to yield the
same effect the instruction would have had if we had executed it
at its original address. We use this in step n3.
if (ex.error != MEMORY_ERROR
&& ex.error != NOT_SUPPORTED_ERROR)
- throw_exception (ex);
+ throw;
if (debug_infrun)
{
/* True if execution commands resume all threads of all processes by
default; otherwise, resume only threads of the current inferior
process. */
-int sched_multi = 0;
+bool sched_multi = false;
/* Try to setup for software single stepping over the specified location.
Return 1 if target_resume() should use hardware single step.
we're running in non-stop mode. */
if (inferior_ptid != null_ptid)
delete_single_step_breakpoints (inferior_thread ());
- throw_exception (ex);
+ throw;
}
}
{
for (thread_info *tp : all_non_exited_threads (resume_ptid))
{
+ switch_to_thread_no_regs (tp);
+
/* Ignore the current thread here. It's handled
afterwards. */
if (tp == cur_thr)
thread_step_over_chain_enqueue (tp);
}
+
+ switch_to_thread (cur_thr);
}
/* Enqueue the current thread last, so that we move all other
Start all other threads that are implicitly resumed too. */
for (thread_info *tp : all_non_exited_threads (resume_ptid))
{
+ switch_to_thread_no_regs (tp);
+
if (tp->resumed)
{
if (debug_infrun)
finish_state.release ();
+ /* If we've switched threads above, switch back to the previously
+ current thread. We don't want the user to see a different
+ selected thread. */
+ switch_to_thread (cur_thr);
+
/* Tell the event loop to wait for it to stop. If the target
supports asynchronous execution, it'll do this from within
target_resume. */
clear_proceed_status (0);
- target_last_wait_ptid = minus_one_ptid;
+ nullify_last_target_wait_ptid ();
previous_inferior_ptid = inferior_ptid;
}
set_current_traceframe (-1);
}
- gdb::optional<scoped_restore_current_thread> maybe_restore_thread;
-
- if (non_stop)
- /* In non-stop mode, the user/frontend should not notice a thread
- switch due to internal events. Make sure we reverse to the
- user selected thread and frame after handling the event and
- running any breakpoint commands. */
- maybe_restore_thread.emplace ();
+ /* The user/frontend should not notice a thread switch due to
+ internal events. Make sure we revert to the user selected
+ thread and frame after handling the event and running any
+ breakpoint commands. */
+ scoped_restore_current_thread restore_thread;
overlay_cache_invalid = 1;
/* Flush target cache before starting to handle each event. Target
inferior_event_handler (INF_EXEC_COMPLETE, NULL);
cmd_done = 1;
}
+
+ /* If we got a TARGET_WAITKIND_NO_RESUMED event, then the
+ previously selected thread is gone. We have two
+ choices - switch to no thread selected, or restore the
+ previously selected thread (now exited). We chose the
+ later, just because that's what GDB used to do. After
+ this, "info threads" says "The current thread <Thread
+ ID 2> has terminated." instead of "No thread
+ selected.". */
+ if (!non_stop
+ && cmd_done
+ && ecs->ws.kind != TARGET_WAITKIND_NO_RESUMED)
+ restore_thread.dont_restore ();
}
}
tss->step_after_step_resume_breakpoint = 0;
}
-/* Set the cached copy of the last ptid/waitstatus. */
+/* See infrun.h. */
void
set_last_target_status (ptid_t ptid, struct target_waitstatus status)
target_last_waitstatus = status;
}
-/* Return the cached copy of the last pid/waitstatus returned by
- target_wait()/deprecated_target_wait_hook(). The data is actually
- cached by handle_inferior_event(), which gets called immediately
- after target_wait()/deprecated_target_wait_hook(). */
+/* See infrun.h. */
void
-get_last_target_status (ptid_t *ptidp, struct target_waitstatus *status)
+get_last_target_status (ptid_t *ptid, struct target_waitstatus *status)
{
- *ptidp = target_last_wait_ptid;
- *status = target_last_waitstatus;
+ if (ptid != nullptr)
+ *ptid = target_last_wait_ptid;
+ if (status != nullptr)
+ *status = target_last_waitstatus;
}
+/* See infrun.h. */
+
void
nullify_last_target_wait_ptid (void)
{
target_last_wait_ptid = minus_one_ptid;
+ target_last_waitstatus = {};
}
/* Switch thread contexts. */
return 0;
}
+/* Look for an inline frame that is marked for skip.
+ If PREV_FRAME is TRUE start at the previous frame,
+ otherwise start at the current frame. Stop at the
+ first non-inline frame, or at the frame where the
+ step started. */
+
+static bool
+inline_frame_is_marked_for_skip (bool prev_frame, struct thread_info *tp)
+{
+ struct frame_info *frame = get_current_frame ();
+
+ if (prev_frame)
+ frame = get_prev_frame (frame);
+
+ for (; frame != NULL; frame = get_prev_frame (frame))
+ {
+ const char *fn = NULL;
+ symtab_and_line sal;
+ struct symbol *sym;
+
+ if (frame_id_eq (get_frame_id (frame), tp->control.step_frame_id))
+ break;
+ if (get_frame_type (frame) != INLINE_FRAME)
+ break;
+
+ sal = find_frame_sal (frame);
+ sym = get_frame_function (frame);
+
+ if (sym != NULL)
+ fn = sym->print_name ();
+
+ if (sal.line != 0
+ && function_name_is_marked_for_skip (fn, sal))
+ return true;
+ }
+
+ return false;
+}
+
/* If the event thread has the stop requested flag set, pretend it
stopped for a GDB_SIGNAL_0 (i.e., as if it stopped due to
target_stop). */
{
if (!ecs->stop_func_filled_in)
{
+ const block *block;
+
/* Don't care about return value; stop_func_start and stop_func_name
will both be 0 if it doesn't work. */
- find_function_entry_range_from_pc (ecs->event_thread->suspend.stop_pc,
- &ecs->stop_func_name,
- &ecs->stop_func_start,
- &ecs->stop_func_end);
- ecs->stop_func_start
- += gdbarch_deprecated_function_start_offset (gdbarch);
-
- if (gdbarch_skip_entrypoint_p (gdbarch))
- ecs->stop_func_start = gdbarch_skip_entrypoint (gdbarch,
- ecs->stop_func_start);
+ find_pc_partial_function (ecs->event_thread->suspend.stop_pc,
+ &ecs->stop_func_name,
+ &ecs->stop_func_start,
+ &ecs->stop_func_end,
+ &block);
+
+ /* The call to find_pc_partial_function, above, will set
+ stop_func_start and stop_func_end to the start and end
+ of the range containing the stop pc. If this range
+ contains the entry pc for the block (which is always the
+ case for contiguous blocks), advance stop_func_start past
+ the function's start offset and entrypoint. Note that
+ stop_func_start is NOT advanced when in a range of a
+ non-contiguous block that does not contain the entry pc. */
+ if (block != nullptr
+ && ecs->stop_func_start <= BLOCK_ENTRY_PC (block)
+ && BLOCK_ENTRY_PC (block) < ecs->stop_func_end)
+ {
+ ecs->stop_func_start
+ += gdbarch_deprecated_function_start_offset (gdbarch);
+
+ if (gdbarch_skip_entrypoint_p (gdbarch))
+ ecs->stop_func_start
+ = gdbarch_skip_entrypoint (gdbarch, ecs->stop_func_start);
+ }
ecs->stop_func_filled_in = 1;
}
"infrun: %s executing, "
"need stop\n",
target_pid_to_str (t->ptid).c_str ());
+ switch_to_thread_no_regs (t);
target_stop (t->ptid);
t->stop_requested = 1;
}
for (thread_info *tp : all_non_exited_threads ())
{
+ switch_to_thread_no_regs (tp);
+
if (tp == event_thread)
{
if (debug_infrun)
{
struct regcache *regcache = get_thread_regcache (ecs->event_thread);
struct gdbarch *reg_gdbarch = regcache->arch ();
- scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
- inferior_ptid = ecs->ptid;
+ switch_to_thread (ecs->event_thread);
fprintf_unfiltered (gdb_stdlog, "infrun: stop_pc = %s\n",
paddress (reg_gdbarch,
return;
}
- /* Note: step_resume_breakpoint may be non-NULL. This occures
+ /* Note: step_resume_breakpoint may be non-NULL. This occurs
when either there's a nested signal, or when there's a
pending signal enabled just as the signal handler returns
(leaving the inferior at the step-resume-breakpoint without
tmp_sal = find_pc_line (ecs->stop_func_start, 0);
if (tmp_sal.line != 0
&& !function_name_is_marked_for_skip (ecs->stop_func_name,
- tmp_sal))
+ tmp_sal)
+ && !inline_frame_is_marked_for_skip (true, ecs->event_thread))
{
if (execution_direction == EXEC_REVERSE)
handle_step_into_function_backward (gdbarch, ecs);
if (call_sal.line == ecs->event_thread->current_line
&& call_sal.symtab == ecs->event_thread->current_symtab)
- step_into_inline_frame (ecs->event_thread);
+ {
+ step_into_inline_frame (ecs->event_thread);
+ if (inline_frame_is_marked_for_skip (false, ecs->event_thread))
+ {
+ keep_going (ecs);
+ return;
+ }
+ }
end_stepping_range (ecs);
return;
fprintf_unfiltered (gdb_stdlog,
"infrun: stepping through inlined function\n");
- if (ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
+ if (ecs->event_thread->control.step_over_calls == STEP_OVER_ALL
+ || inline_frame_is_marked_for_skip (false, ecs->event_thread))
keep_going (ecs);
else
end_stepping_range (ecs);
for (thread_info *tp : all_non_exited_threads ())
{
+ switch_to_thread_no_regs (tp);
+
/* Ignore threads of processes the caller is not
resuming. */
if (!sched_multi
return 1;
}
}
+
+ switch_to_thread (ecs->event_thread);
}
return 0;
CORE_ADDR handler;
struct breakpoint *bp;
- vsym = lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym),
+ vsym = lookup_symbol_search_name (sym->search_name (),
b, VAR_DOMAIN);
value = read_var_value (vsym.symbol, vsym.block, frame);
/* If the value was optimized out, revert to the old behavior. */
{
if (uiout->is_mi_like_p ())
uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXITED));
- uiout->text ("[Inferior ");
- uiout->text (plongest (inf->num));
- uiout->text (" (");
- uiout->text (pidstr.c_str ());
- uiout->text (") exited with code ");
- uiout->field_fmt ("exit-code", "0%o", (unsigned int) exitstatus);
- uiout->text ("]\n");
+ std::string exit_code_str
+ = string_printf ("0%o", (unsigned int) exitstatus);
+ uiout->message ("[Inferior %s (%s) exited with code %pF]\n",
+ plongest (inf->num), pidstr.c_str (),
+ string_field ("exit-code", exit_code_str.c_str ()));
}
else
{
if (uiout->is_mi_like_p ())
uiout->field_string
("reason", async_reason_lookup (EXEC_ASYNC_EXITED_NORMALLY));
- uiout->text ("[Inferior ");
- uiout->text (plongest (inf->num));
- uiout->text (" (");
- uiout->text (pidstr.c_str ());
- uiout->text (") exited normally]\n");
+ uiout->message ("[Inferior %s (%s) exited normally]\n",
+ plongest (inf->num), pidstr.c_str ());
}
}
const char *name;
uiout->text ("\nThread ");
- uiout->field_fmt ("thread-id", "%s", print_thread_id (thr));
+ uiout->field_string ("thread-id", print_thread_id (thr));
name = thr->name != NULL ? thr->name : target_thread_name (thr);
if (name != NULL)
{
uiout->text (" \"");
- uiout->field_fmt ("name", "%s", name);
+ uiout->field_string ("name", name);
uiout->text ("\"");
}
}
print_stop_event (struct ui_out *uiout, bool displays)
{
struct target_waitstatus last;
- ptid_t last_ptid;
struct thread_info *tp;
- get_last_target_status (&last_ptid, &last);
+ get_last_target_status (nullptr, &last);
{
scoped_restore save_uiout = make_scoped_restore (¤t_uiout, uiout);
normal_stop (void)
{
struct target_waitstatus last;
- ptid_t last_ptid;
- get_last_target_status (&last_ptid, &last);
+ get_last_target_status (nullptr, &last);
new_stop_id ();
projects / deliverable / binutils-gdb.git / blobdiff