X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Finfrun.c;h=2fa5cd89b4181363d98c09b944afa8364225bb91;hb=f3f8ece4b1c77c925d1f1566df0bf632790a4d24;hp=68574679830f982665f1a07347dce9f45e076569;hpb=d238133d0292926b937aaa6f83bf921dd0bbb01c;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/infrun.c b/gdb/infrun.c index 6857467983..2fa5cd89b4 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -1,7 +1,7 @@ /* 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. @@ -25,16 +25,13 @@ #include "frame.h" #include "inferior.h" #include "breakpoint.h" -#include "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 #include "inf-loop.h" #include "regcache.h" #include "value.h" @@ -42,7 +39,6 @@ #include "language.h" #include "solib.h" #include "main.h" -#include "dictionary.h" #include "block.h" #include "mi/mi-common.h" #include "event-top.h" @@ -51,8 +47,6 @@ #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" @@ -63,11 +57,12 @@ #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 "gdbsupport/scope-exit.h" +#include "gdbsupport/forward-scope-exit.h" /* Prototypes for local functions */ @@ -135,7 +130,7 @@ mark_infrun_async_event_handler (void) /* 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) @@ -154,9 +149,9 @@ static ptid_t previous_inferior_ptid; 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) @@ -175,7 +170,7 @@ show_debug_infrun (struct ui_file *file, int from_tty, /* 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, @@ -204,8 +199,8 @@ set_disable_randomization (const char *args, 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, @@ -233,8 +228,8 @@ show_non_stop (struct ui_file *file, 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, @@ -255,7 +250,7 @@ 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 (); @@ -264,7 +259,7 @@ set_observer_mode (const char *args, int from_tty, if (observer_mode) { pagination_enabled = 0; - non_stop = non_stop_1 = 1; + non_stop = non_stop_1 = true; } if (from_tty) @@ -288,13 +283,11 @@ show_observer_mode (struct ui_file *file, int 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) @@ -306,20 +299,19 @@ update_observer_mode (void) /* Tables of how to react to signals; the user sets them. */ -static unsigned char *signal_stop; -static unsigned char *signal_print; -static unsigned char *signal_program; +static unsigned char signal_stop[GDB_SIGNAL_LAST]; +static unsigned char signal_print[GDB_SIGNAL_LAST]; +static unsigned char signal_program[GDB_SIGNAL_LAST]; /* Table of signals that are registered with "catch signal". A non-zero entry indicates that the signal is caught by some "catch - signal" command. This has size GDB_SIGNAL_LAST, to accommodate all - signals. */ -static unsigned char *signal_catch; + signal" command. */ +static unsigned char signal_catch[GDB_SIGNAL_LAST]; /* Table of signals that the target may silently handle. This is automatically determined from the flags above, and simply cached here. */ -static unsigned char *signal_pass; +static unsigned char signal_pass[GDB_SIGNAL_LAST]; #define SET_SIGS(nsigs,sigs,flags) \ do { \ @@ -343,7 +335,7 @@ static unsigned char *signal_pass; void update_signals_program_target (void) { - target_program_signals ((int) GDB_SIGNAL_LAST, signal_program); + target_program_signals (signal_program); } /* Value to pass to target_resume() to cause all threads to resume. */ @@ -440,7 +432,6 @@ follow_fork_inferior (int follow_child, int detach_fork) 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; } @@ -471,7 +462,7 @@ holding the child stopped. Try \"set detach-on-fork\" or \ fprintf_filtered (gdb_stdlog, _("[Detaching after %s from child %s]\n"), has_vforked ? "vfork" : "fork", - target_pid_to_str (process_ptid)); + target_pid_to_str (process_ptid).c_str ()); } } else @@ -607,7 +598,7 @@ holding the child stopped. Try \"set detach-on-fork\" or \ fprintf_filtered (gdb_stdlog, _("[Detaching after fork from " "parent %s]\n"), - target_pid_to_str (process_ptid)); + target_pid_to_str (process_ptid).c_str ()); } target_detach (parent_inf, 0); @@ -876,7 +867,7 @@ proceed_after_vfork_done (struct thread_info *thread, if (debug_infrun) fprintf_unfiltered (gdb_stdlog, "infrun: resuming vfork parent thread %s\n", - target_pid_to_str (thread->ptid)); + target_pid_to_str (thread->ptid).c_str ()); switch_to_thread (thread); clear_proceed_status (0); @@ -915,10 +906,14 @@ handle_vfork_child_exec_or_exit (int exec) 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; @@ -926,7 +921,7 @@ handle_vfork_child_exec_or_exit (int exec) /* follow-fork child, detach-on-fork on. */ - inf->vfork_parent->pending_detach = 0; + vfork_parent->pending_detach = 0; gdb::optional maybe_restore_inferior; @@ -941,7 +936,7 @@ handle_vfork_child_exec_or_exit (int exec) 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 @@ -963,8 +958,8 @@ handle_vfork_child_exec_or_exit (int exec) if (print_inferior_events) { - const char *pidstr - = target_pid_to_str (ptid_t (inf->vfork_parent->pid)); + std::string pidstr + = target_pid_to_str (ptid_t (vfork_parent->pid)); target_terminal::ours_for_output (); @@ -972,17 +967,17 @@ handle_vfork_child_exec_or_exit (int exec) { fprintf_filtered (gdb_stdlog, _("[Detaching vfork parent %s " - "after child exec]\n"), pidstr); + "after child exec]\n"), pidstr.c_str ()); } else { fprintf_filtered (gdb_stdlog, _("[Detaching vfork parent %s " - "after child exit]\n"), pidstr); + "after child exit]\n"), pidstr.c_str ()); } } - target_detach (inf->vfork_parent, 0); + target_detach (vfork_parent, 0); /* Put it back. */ inf->pspace = pspace; @@ -997,10 +992,7 @@ handle_vfork_child_exec_or_exit (int exec) 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 { @@ -1030,17 +1022,13 @@ handle_vfork_child_exec_or_exit (int exec) 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) @@ -1081,12 +1069,16 @@ show_follow_exec_mode_string (struct ui_file *file, int from_tty, /* 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 (); ptid_t process_ptid; + /* Switch terminal for any messages produced e.g. by + breakpoint_re_set. */ + target_terminal::ours_for_output (); + /* This is an exec event that we actually wish to pay attention to. Refresh our symbol table to the newly exec'd program, remove any momentary bp's, etc. @@ -1105,7 +1097,7 @@ follow_exec (ptid_t ptid, char *exec_file_target) 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 (); @@ -1154,14 +1146,12 @@ follow_exec (ptid_t ptid, char *exec_file_target) /* What is this a.out's name? */ process_ptid = ptid_t (pid); printf_unfiltered (_("%s is executing new program: %s\n"), - target_pid_to_str (process_ptid), + target_pid_to_str (process_ptid).c_str (), exec_file_target); /* We've followed the inferior through an exec. Therefore, the inferior has essentially been killed & reborn. */ - gdb_flush (gdb_stdout); - breakpoint_init_inferior (inf_execd); gdb::unique_xmalloc_ptr exec_file_host @@ -1432,7 +1422,7 @@ step_over_info_valid_p (void) 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. @@ -1599,14 +1589,9 @@ displaced_step_clear (struct displaced_step_inferior_state *displaced) displaced->step_closure = NULL; } -static void -displaced_step_clear_cleanup (void *arg) -{ - struct displaced_step_inferior_state *state - = (struct displaced_step_inferior_state *) arg; - - displaced_step_clear (state); -} +/* A cleanup that wraps displaced_step_clear. */ +using displaced_step_clear_cleanup + = FORWARD_SCOPE_EXIT (displaced_step_clear); /* Dump LEN bytes at BUF in hex to FILE, followed by a newline. */ void @@ -1675,7 +1660,7 @@ displaced_step_prepare_throw (thread_info *tp) if (debug_displaced) fprintf_unfiltered (gdb_stdlog, "displaced: deferring step of %s\n", - target_pid_to_str (tp->ptid)); + target_pid_to_str (tp->ptid).c_str ()); thread_step_over_chain_enqueue (tp); return 0; @@ -1685,7 +1670,7 @@ displaced_step_prepare_throw (thread_info *tp) if (debug_displaced) fprintf_unfiltered (gdb_stdlog, "displaced: stepping %s now\n", - target_pid_to_str (tp->ptid)); + target_pid_to_str (tp->ptid).c_str ()); } displaced_step_clear (displaced); @@ -1755,13 +1740,14 @@ displaced_step_prepare_throw (thread_info *tp) displaced->step_original = original; displaced->step_copy = copy; - cleanup *ignore_cleanups - = make_cleanup (displaced_step_clear_cleanup, displaced); + { + displaced_step_clear_cleanup cleanup (displaced); - /* Resume execution at the copy. */ - regcache_write_pc (regcache, copy); + /* Resume execution at the copy. */ + regcache_write_pc (regcache, copy); - discard_cleanups (ignore_cleanups); + cleanup.release (); + } if (debug_displaced) fprintf_unfiltered (gdb_stdlog, "displaced: displaced pc to %s\n", @@ -1778,23 +1764,23 @@ displaced_step_prepare (thread_info *thread) { int prepared = -1; - TRY + try { prepared = displaced_step_prepare_throw (thread); } - CATCH (ex, RETURN_MASK_ERROR) + catch (const gdb_exception_error &ex) { struct displaced_step_inferior_state *displaced_state; if (ex.error != MEMORY_ERROR && ex.error != NOT_SUPPORTED_ERROR) - throw_exception (ex); + throw; if (debug_infrun) { fprintf_unfiltered (gdb_stdlog, "infrun: disabling displaced stepping: %s\n", - ex.message); + ex.what ()); } /* Be verbose if "set displaced-stepping" is "on", silent if @@ -1802,7 +1788,7 @@ displaced_step_prepare (thread_info *thread) if (can_use_displaced_stepping == AUTO_BOOLEAN_TRUE) { warning (_("disabling displaced stepping: %s"), - ex.message); + ex.what ()); } /* Disable further displaced stepping attempts. */ @@ -1810,7 +1796,6 @@ displaced_step_prepare (thread_info *thread) = get_displaced_stepping_state (thread->inf); displaced_state->failed_before = 1; } - END_CATCH return prepared; } @@ -1837,7 +1822,7 @@ displaced_step_restore (struct displaced_step_inferior_state *displaced, displaced->step_saved_copy.data (), len); if (debug_displaced) fprintf_unfiltered (gdb_stdlog, "displaced: restored %s %s\n", - target_pid_to_str (ptid), + target_pid_to_str (ptid).c_str (), paddress (displaced->step_gdbarch, displaced->step_copy)); } @@ -1851,7 +1836,6 @@ displaced_step_restore (struct displaced_step_inferior_state *displaced, static int displaced_step_fixup (thread_info *event_thread, enum gdb_signal signal) { - struct cleanup *old_cleanups; struct displaced_step_inferior_state *displaced = get_displaced_stepping_state (event_thread->inf); int ret; @@ -1860,7 +1844,7 @@ displaced_step_fixup (thread_info *event_thread, enum gdb_signal signal) if (displaced->step_thread != event_thread) return 0; - old_cleanups = make_cleanup (displaced_step_clear_cleanup, displaced); + displaced_step_clear_cleanup cleanup (displaced); displaced_step_restore (displaced, displaced->step_thread->ptid); @@ -1895,10 +1879,6 @@ displaced_step_fixup (thread_info *event_thread, enum gdb_signal signal) ret = -1; } - do_cleanups (old_cleanups); - - displaced->step_thread = nullptr; - return ret; } @@ -1996,7 +1976,7 @@ start_step_over (void) internal_error (__FILE__, __LINE__, "[%s] has inconsistent state: " "trap_expected=%d, resumed=%d, executing=%d\n", - target_pid_to_str (tp->ptid), + target_pid_to_str (tp->ptid).c_str (), tp->control.trap_expected, tp->resumed, tp->executing); @@ -2005,7 +1985,7 @@ start_step_over (void) if (debug_infrun) fprintf_unfiltered (gdb_stdlog, "infrun: resuming [%s] for step-over\n", - target_pid_to_str (tp->ptid)); + target_pid_to_str (tp->ptid).c_str ()); /* keep_going_pass_signal skips the step-over if the breakpoint is no longer inserted. In all-stop, we want to keep looking @@ -2100,7 +2080,7 @@ set_schedlock_func (const char *args, int from_tty, struct cmd_list_element *c) /* 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. @@ -2219,9 +2199,9 @@ do_target_resume (ptid_t resume_ptid, int step, enum gdb_signal sig) valid. */ if (step_over_info_valid_p () || displaced_step_in_progress (tp->inf)) - target_pass_signals (0, NULL); + target_pass_signals ({}); else - target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass); + target_pass_signals (signal_pass); target_resume (resume_ptid, step, sig); @@ -2264,7 +2244,8 @@ resume_1 (enum gdb_signal sig) fprintf_unfiltered (gdb_stdlog, "infrun: resume: thread %s has pending wait " "status %s (currently_stepping=%d).\n", - target_pid_to_str (tp->ptid), statstr.c_str (), + target_pid_to_str (tp->ptid).c_str (), + statstr.c_str (), currently_stepping (tp)); } @@ -2276,7 +2257,8 @@ resume_1 (enum gdb_signal sig) if (sig != GDB_SIGNAL_0) { warning (_("Couldn't deliver signal %s to %s."), - gdb_signal_to_name (sig), target_pid_to_str (tp->ptid)); + gdb_signal_to_name (sig), + target_pid_to_str (tp->ptid).c_str ()); } tp->suspend.stop_signal = GDB_SIGNAL_0; @@ -2320,7 +2302,7 @@ resume_1 (enum gdb_signal sig) "trap_expected=%d, current thread [%s] at %s\n", step, gdb_signal_to_symbol_string (sig), tp->control.trap_expected, - target_pid_to_str (inferior_ptid), + target_pid_to_str (inferior_ptid).c_str (), paddress (gdbarch, pc)); /* Normally, by the time we reach `resume', the breakpoints are either @@ -2569,7 +2551,7 @@ resume_1 (enum gdb_signal sig) if (debug_infrun) fprintf_unfiltered (gdb_stdlog, "infrun: resume: [%s] stepped breakpoint\n", - target_pid_to_str (tp->ptid)); + target_pid_to_str (tp->ptid).c_str ()); tp->stepped_breakpoint = 1; @@ -2617,11 +2599,11 @@ resume_1 (enum gdb_signal sig) static void resume (gdb_signal sig) { - TRY + try { resume_1 (sig); } - CATCH (ex, RETURN_MASK_ALL) + catch (const gdb_exception &ex) { /* If resuming is being aborted for any reason, delete any single-step breakpoint resume_1 may have created, to avoid @@ -2630,9 +2612,8 @@ resume (gdb_signal sig) we're running in non-stop mode. */ if (inferior_ptid != null_ptid) delete_single_step_breakpoints (inferior_thread ()); - throw_exception (ex); + throw; } - END_CATCH } @@ -2674,7 +2655,7 @@ clear_proceed_status_thread (struct thread_info *tp) if (debug_infrun) fprintf_unfiltered (gdb_stdlog, "infrun: clear_proceed_status_thread (%s)\n", - target_pid_to_str (tp->ptid)); + target_pid_to_str (tp->ptid).c_str ()); /* If we're starting a new sequence, then the previous finished single-step is no longer relevant. */ @@ -2687,7 +2668,7 @@ clear_proceed_status_thread (struct thread_info *tp) "infrun: clear_proceed_status: pending " "event of %s was a finished step. " "Discarding.\n", - target_pid_to_str (tp->ptid)); + target_pid_to_str (tp->ptid).c_str ()); tp->suspend.waitstatus_pending_p = 0; tp->suspend.stop_reason = TARGET_STOPPED_BY_NO_REASON; @@ -2701,7 +2682,8 @@ clear_proceed_status_thread (struct thread_info *tp) "infrun: clear_proceed_status_thread: thread %s " "has pending wait status %s " "(currently_stepping=%d).\n", - target_pid_to_str (tp->ptid), statstr.c_str (), + target_pid_to_str (tp->ptid).c_str (), + statstr.c_str (), currently_stepping (tp)); } } @@ -2711,7 +2693,7 @@ clear_proceed_status_thread (struct thread_info *tp) if (!signal_pass_state (tp->suspend.stop_signal)) tp->suspend.stop_signal = GDB_SIGNAL_0; - thread_fsm_delete (tp->thread_fsm); + delete tp->thread_fsm; tp->thread_fsm = NULL; tp->control.trap_expected = 0; @@ -2958,6 +2940,8 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal) { 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) @@ -2971,10 +2955,12 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal) if (debug_infrun) fprintf_unfiltered (gdb_stdlog, "infrun: need to step-over [%s] first\n", - target_pid_to_str (tp->ptid)); + target_pid_to_str (tp->ptid).c_str ()); thread_step_over_chain_enqueue (tp); } + + switch_to_thread (cur_thr); } /* Enqueue the current thread last, so that we move all other @@ -3011,12 +2997,14 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal) 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) fprintf_unfiltered (gdb_stdlog, "infrun: proceed: [%s] resumed\n", - target_pid_to_str (tp->ptid)); + target_pid_to_str (tp->ptid).c_str ()); gdb_assert (tp->executing || tp->suspend.waitstatus_pending_p); continue; } @@ -3026,14 +3014,14 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal) if (debug_infrun) fprintf_unfiltered (gdb_stdlog, "infrun: proceed: [%s] needs step-over\n", - target_pid_to_str (tp->ptid)); + target_pid_to_str (tp->ptid).c_str ()); continue; } if (debug_infrun) fprintf_unfiltered (gdb_stdlog, "infrun: proceed: resuming %s\n", - target_pid_to_str (tp->ptid)); + target_pid_to_str (tp->ptid).c_str ()); reset_ecs (ecs, tp); switch_to_thread (tp); @@ -3057,6 +3045,11 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal) 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. */ @@ -3267,13 +3260,13 @@ print_target_wait_results (ptid_t waiton_ptid, ptid_t result_ptid, waiton_ptid.lwp (), waiton_ptid.tid ()); if (waiton_ptid.pid () != -1) - stb.printf (" [%s]", target_pid_to_str (waiton_ptid)); + stb.printf (" [%s]", target_pid_to_str (waiton_ptid).c_str ()); stb.printf (", status) =\n"); stb.printf ("infrun: %d.%ld.%ld [%s],\n", result_ptid.pid (), result_ptid.lwp (), result_ptid.tid (), - target_pid_to_str (result_ptid)); + target_pid_to_str (result_ptid).c_str ()); stb.printf ("infrun: %s\n", status_string.c_str ()); /* This uses %s in part to handle %'s in the text, but also to avoid @@ -3343,7 +3336,7 @@ do_target_wait (ptid_t ptid, struct target_waitstatus *status, int options) if (debug_infrun) fprintf_unfiltered (gdb_stdlog, "infrun: Waiting for specific thread %s.\n", - target_pid_to_str (ptid)); + target_pid_to_str (ptid).c_str ()); /* We have a specific thread to check. */ tp = find_thread_ptid (ptid); @@ -3368,7 +3361,7 @@ do_target_wait (ptid_t ptid, struct target_waitstatus *status, int options) if (debug_infrun) fprintf_unfiltered (gdb_stdlog, "infrun: PC of %s changed. was=%s, now=%s\n", - target_pid_to_str (tp->ptid), + target_pid_to_str (tp->ptid).c_str (), paddress (gdbarch, tp->suspend.stop_pc), paddress (gdbarch, pc)); discard = 1; @@ -3378,7 +3371,7 @@ do_target_wait (ptid_t ptid, struct target_waitstatus *status, int options) if (debug_infrun) fprintf_unfiltered (gdb_stdlog, "infrun: previous breakpoint of %s, at %s gone\n", - target_pid_to_str (tp->ptid), + target_pid_to_str (tp->ptid).c_str (), paddress (gdbarch, pc)); discard = 1; @@ -3389,7 +3382,7 @@ do_target_wait (ptid_t ptid, struct target_waitstatus *status, int options) if (debug_infrun) fprintf_unfiltered (gdb_stdlog, "infrun: pending event of %s cancelled.\n", - target_pid_to_str (tp->ptid)); + target_pid_to_str (tp->ptid).c_str ()); tp->suspend.waitstatus.kind = TARGET_WAITKIND_SPURIOUS; tp->suspend.stop_reason = TARGET_STOPPED_BY_NO_REASON; @@ -3406,7 +3399,7 @@ do_target_wait (ptid_t ptid, struct target_waitstatus *status, int options) fprintf_unfiltered (gdb_stdlog, "infrun: Using pending wait status %s for %s.\n", statstr.c_str (), - target_pid_to_str (tp->ptid)); + target_pid_to_str (tp->ptid).c_str ()); } /* Now that we've selected our final event LWP, un-adjust its PC @@ -3611,8 +3604,7 @@ clean_up_just_stopped_threads_fsms (struct execution_control_state *ecs) { if (ecs->event_thread != NULL && ecs->event_thread->thread_fsm != NULL) - thread_fsm_clean_up (ecs->event_thread->thread_fsm, - ecs->event_thread); + ecs->event_thread->thread_fsm->clean_up (ecs->event_thread); if (!non_stop) { @@ -3624,7 +3616,7 @@ clean_up_just_stopped_threads_fsms (struct execution_control_state *ecs) continue; switch_to_thread (thr); - thread_fsm_clean_up (thr->thread_fsm, thr); + thr->thread_fsm->clean_up (thr); } if (ecs->event_thread != NULL) @@ -3712,14 +3704,11 @@ fetch_inferior_event (void *client_data) set_current_traceframe (-1); } - gdb::optional 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 @@ -3744,7 +3733,7 @@ fetch_inferior_event (void *client_data) ptid_t finish_ptid = !target_is_non_stop_p () ? minus_one_ptid : ecs->ptid; scoped_finish_thread_state finish_state (finish_ptid); - /* Get executed before make_cleanup_restore_current_thread above to apply + /* Get executed before scoped_restore_current_thread above to apply still for the thread which has thrown the exception. */ auto defer_bpstat_clear = make_scope_exit (bpstat_clear_actions); @@ -3767,7 +3756,7 @@ fetch_inferior_event (void *client_data) struct thread_fsm *thread_fsm = thr->thread_fsm; if (thread_fsm != NULL) - should_stop = thread_fsm_should_stop (thread_fsm, thr); + should_stop = thread_fsm->should_stop (thr); } if (!should_stop) @@ -3776,16 +3765,13 @@ fetch_inferior_event (void *client_data) } else { - int should_notify_stop = 1; + bool should_notify_stop = true; int proceeded = 0; clean_up_just_stopped_threads_fsms (ecs); if (thr != NULL && thr->thread_fsm != NULL) - { - should_notify_stop - = thread_fsm_should_notify_stop (thr->thread_fsm); - } + should_notify_stop = thr->thread_fsm->should_notify_stop (); if (should_notify_stop) { @@ -3799,6 +3785,19 @@ fetch_inferior_event (void *client_data) 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 has terminated." instead of "No thread + selected.". */ + if (!non_stop + && cmd_done + && ecs->ws.kind != TARGET_WAITKIND_NO_RESUMED) + restore_thread.dont_restore (); } } @@ -3885,9 +3884,9 @@ context_switch (execution_control_state *ecs) && ecs->event_thread != inferior_thread ()) { fprintf_unfiltered (gdb_stdlog, "infrun: Switching context from %s ", - target_pid_to_str (inferior_ptid)); + target_pid_to_str (inferior_ptid).c_str ()); fprintf_unfiltered (gdb_stdlog, "to %s\n", - target_pid_to_str (ecs->ptid)); + target_pid_to_str (ecs->ptid).c_str ()); } switch_to_thread (ecs->event_thread); @@ -4056,6 +4055,45 @@ stepped_in_from (struct frame_info *frame, struct frame_id step_frame_id) 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). */ @@ -4128,18 +4166,35 @@ fill_in_stop_func (struct gdbarch *gdbarch, { 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; } @@ -4327,7 +4382,8 @@ stop_all_threads (void) fprintf_unfiltered (gdb_stdlog, "infrun: %s executing, " "need stop\n", - target_pid_to_str (t->ptid)); + target_pid_to_str (t->ptid).c_str ()); + switch_to_thread_no_regs (t); target_stop (t->ptid); t->stop_requested = 1; } @@ -4337,7 +4393,7 @@ stop_all_threads (void) fprintf_unfiltered (gdb_stdlog, "infrun: %s executing, " "already stopping\n", - target_pid_to_str (t->ptid)); + target_pid_to_str (t->ptid).c_str ()); } if (t->stop_requested) @@ -4348,7 +4404,7 @@ stop_all_threads (void) if (debug_infrun) fprintf_unfiltered (gdb_stdlog, "infrun: %s not executing\n", - target_pid_to_str (t->ptid)); + target_pid_to_str (t->ptid).c_str ()); /* The thread may be not executing, but still be resumed with a pending status to process. */ @@ -4366,24 +4422,21 @@ stop_all_threads (void) pass = -1; event_ptid = wait_one (&ws); - - if (ws.kind == TARGET_WAITKIND_NO_RESUMED) + if (debug_infrun) { - /* All resumed threads exited. */ + fprintf_unfiltered (gdb_stdlog, + "infrun: stop_all_threads %s %s\n", + target_waitstatus_to_string (&ws).c_str (), + target_pid_to_str (event_ptid).c_str ()); } - else if (ws.kind == TARGET_WAITKIND_THREAD_EXITED - || ws.kind == TARGET_WAITKIND_EXITED - || ws.kind == TARGET_WAITKIND_SIGNALLED) - { - if (debug_infrun) - { - ptid_t ptid = ptid_t (ws.value.integer); - fprintf_unfiltered (gdb_stdlog, - "infrun: %s exited while " - "stopping threads\n", - target_pid_to_str (ptid)); - } + if (ws.kind == TARGET_WAITKIND_NO_RESUMED + || ws.kind == TARGET_WAITKIND_THREAD_EXITED + || ws.kind == TARGET_WAITKIND_EXITED + || ws.kind == TARGET_WAITKIND_SIGNALLED) + { + /* All resumed threads exited + or one thread/process exited/signalled. */ } else { @@ -4422,7 +4475,7 @@ stop_all_threads (void) "infrun: displaced-step of %s " "canceled: adding back to the " "step-over queue\n", - target_pid_to_str (t->ptid)); + target_pid_to_str (t->ptid).c_str ()); } t->control.trap_expected = 0; thread_step_over_chain_enqueue (t); @@ -4469,7 +4522,7 @@ stop_all_threads (void) "(currently_stepping=%d)\n", paddress (target_gdbarch (), t->suspend.stop_pc), - target_pid_to_str (t->ptid), + target_pid_to_str (t->ptid).c_str (), currently_stepping (t)); } } @@ -4603,10 +4656,19 @@ handle_no_resumed (struct execution_control_state *ecs) once). */ static void -handle_inferior_event_1 (struct execution_control_state *ecs) +handle_inferior_event (struct execution_control_state *ecs) { + /* Make sure that all temporary struct value objects that were + created during the handling of the event get deleted at the + end. */ + scoped_value_mark free_values; + enum stop_kind stop_soon; + if (debug_infrun) + fprintf_unfiltered (gdb_stdlog, "infrun: handle_inferior_event %s\n", + target_waitstatus_to_string (&ecs->ws).c_str ()); + if (ecs->ws.kind == TARGET_WAITKIND_IGNORE) { /* We had an event in the inferior, but we are not interested in @@ -4618,16 +4680,12 @@ handle_inferior_event_1 (struct execution_control_state *ecs) not stopped, and we are ignoring the event. Another possible circumstance is any event which the lower level knows will be reported multiple times without an intervening resume. */ - if (debug_infrun) - fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_IGNORE\n"); prepare_to_wait (ecs); return; } if (ecs->ws.kind == TARGET_WAITKIND_THREAD_EXITED) { - if (debug_infrun) - fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_THREAD_EXITED\n"); prepare_to_wait (ecs); return; } @@ -4646,9 +4704,6 @@ handle_inferior_event_1 (struct execution_control_state *ecs) { /* No unwaited-for children left. IOW, all resumed children have exited. */ - if (debug_infrun) - fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_NO_RESUMED\n"); - stop_print_frame = 0; stop_waiting (ecs); return; @@ -4741,8 +4796,6 @@ handle_inferior_event_1 (struct execution_control_state *ecs) switch (ecs->ws.kind) { case TARGET_WAITKIND_LOADED: - if (debug_infrun) - fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_LOADED\n"); context_switch (ecs); /* Ignore gracefully during startup of the inferior, as it might be the shell which has just loaded some objects, otherwise @@ -4820,8 +4873,6 @@ handle_inferior_event_1 (struct execution_control_state *ecs) _("unhandled stop_soon: %d"), (int) stop_soon); case TARGET_WAITKIND_SPURIOUS: - if (debug_infrun) - fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_SPURIOUS\n"); if (handle_stop_requested (ecs)) return; context_switch (ecs); @@ -4830,8 +4881,6 @@ handle_inferior_event_1 (struct execution_control_state *ecs) return; case TARGET_WAITKIND_THREAD_CREATED: - if (debug_infrun) - fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_THREAD_CREATED\n"); if (handle_stop_requested (ecs)) return; context_switch (ecs); @@ -4841,16 +4890,6 @@ handle_inferior_event_1 (struct execution_control_state *ecs) case TARGET_WAITKIND_EXITED: case TARGET_WAITKIND_SIGNALLED: - if (debug_infrun) - { - if (ecs->ws.kind == TARGET_WAITKIND_EXITED) - fprintf_unfiltered (gdb_stdlog, - "infrun: TARGET_WAITKIND_EXITED\n"); - else - fprintf_unfiltered (gdb_stdlog, - "infrun: TARGET_WAITKIND_SIGNALLED\n"); - } - inferior_ptid = ecs->ptid; set_current_inferior (find_inferior_ptid (ecs->ptid)); set_current_program_space (current_inferior ()->pspace); @@ -4915,14 +4954,6 @@ Cannot fill $_exitsignal with the correct signal number.\n")); the above cases end in a continue or goto. */ case TARGET_WAITKIND_FORKED: case TARGET_WAITKIND_VFORKED: - if (debug_infrun) - { - if (ecs->ws.kind == TARGET_WAITKIND_FORKED) - fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_FORKED\n"); - else - fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_VFORKED\n"); - } - /* Check whether the inferior is displaced stepping. */ { struct regcache *regcache = get_thread_regcache (ecs->event_thread); @@ -5083,10 +5114,6 @@ Cannot fill $_exitsignal with the correct signal number.\n")); /* Done with the shared memory region. Re-insert breakpoints in the parent, and keep going. */ - if (debug_infrun) - fprintf_unfiltered (gdb_stdlog, - "infrun: TARGET_WAITKIND_VFORK_DONE\n"); - context_switch (ecs); current_inferior ()->waiting_for_vfork_done = 0; @@ -5101,8 +5128,6 @@ Cannot fill $_exitsignal with the correct signal number.\n")); return; case TARGET_WAITKIND_EXECD: - if (debug_infrun) - fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_EXECD\n"); /* Note we can't read registers yet (the stop_pc), because we don't yet know the inferior's post-exec architecture. @@ -5151,9 +5176,6 @@ Cannot fill $_exitsignal with the correct signal number.\n")); /* Be careful not to try to gather much state about a thread that's in a syscall. It's frequently a losing proposition. */ case TARGET_WAITKIND_SYSCALL_ENTRY: - if (debug_infrun) - fprintf_unfiltered (gdb_stdlog, - "infrun: TARGET_WAITKIND_SYSCALL_ENTRY\n"); /* Getting the current syscall number. */ if (handle_syscall_event (ecs) == 0) process_event_stop_test (ecs); @@ -5165,22 +5187,15 @@ Cannot fill $_exitsignal with the correct signal number.\n")); syscall. Stepping one instruction seems to get it back into user code.) */ case TARGET_WAITKIND_SYSCALL_RETURN: - if (debug_infrun) - fprintf_unfiltered (gdb_stdlog, - "infrun: TARGET_WAITKIND_SYSCALL_RETURN\n"); if (handle_syscall_event (ecs) == 0) process_event_stop_test (ecs); return; case TARGET_WAITKIND_STOPPED: - if (debug_infrun) - fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_STOPPED\n"); handle_signal_stop (ecs); return; case TARGET_WAITKIND_NO_HISTORY: - if (debug_infrun) - fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_NO_HISTORY\n"); /* Reverse execution: target ran out of history info. */ /* Switch to the stopped thread. */ @@ -5201,22 +5216,6 @@ Cannot fill $_exitsignal with the correct signal number.\n")); } } -/* A wrapper around handle_inferior_event_1, which also makes sure - that all temporary struct value objects that were created during - the handling of the event get deleted at the end. */ - -static void -handle_inferior_event (struct execution_control_state *ecs) -{ - struct value *mark = value_mark (); - - handle_inferior_event_1 (ecs); - /* Purge all temporary values created during the event handling, - as it could be a long time before we return to the command level - where such values would otherwise be purged. */ - value_free_to_mark (mark); -} - /* Restart threads back to what they were trying to do back when we paused them for an in-line step-over. The EVENT_THREAD thread is ignored. */ @@ -5229,13 +5228,15 @@ restart_threads (struct thread_info *event_thread) for (thread_info *tp : all_non_exited_threads ()) { + switch_to_thread_no_regs (tp); + if (tp == event_thread) { if (debug_infrun) fprintf_unfiltered (gdb_stdlog, "infrun: restart threads: " "[%s] is event thread\n", - target_pid_to_str (tp->ptid)); + target_pid_to_str (tp->ptid).c_str ()); continue; } @@ -5245,7 +5246,7 @@ restart_threads (struct thread_info *event_thread) fprintf_unfiltered (gdb_stdlog, "infrun: restart threads: " "[%s] not meant to be running\n", - target_pid_to_str (tp->ptid)); + target_pid_to_str (tp->ptid).c_str ()); continue; } @@ -5254,7 +5255,7 @@ restart_threads (struct thread_info *event_thread) if (debug_infrun) fprintf_unfiltered (gdb_stdlog, "infrun: restart threads: [%s] resumed\n", - target_pid_to_str (tp->ptid)); + target_pid_to_str (tp->ptid).c_str ()); gdb_assert (tp->executing || tp->suspend.waitstatus_pending_p); continue; } @@ -5265,7 +5266,7 @@ restart_threads (struct thread_info *event_thread) fprintf_unfiltered (gdb_stdlog, "infrun: restart threads: " "[%s] needs step-over\n", - target_pid_to_str (tp->ptid)); + target_pid_to_str (tp->ptid).c_str ()); gdb_assert (!tp->resumed); continue; } @@ -5277,7 +5278,7 @@ restart_threads (struct thread_info *event_thread) fprintf_unfiltered (gdb_stdlog, "infrun: restart threads: " "[%s] has pending status\n", - target_pid_to_str (tp->ptid)); + target_pid_to_str (tp->ptid).c_str ()); tp->resumed = 1; continue; } @@ -5292,7 +5293,7 @@ restart_threads (struct thread_info *event_thread) internal_error (__FILE__, __LINE__, "thread [%s] needs a step-over, but not in " "step-over queue\n", - target_pid_to_str (tp->ptid)); + target_pid_to_str (tp->ptid).c_str ()); } if (currently_stepping (tp)) @@ -5300,7 +5301,7 @@ restart_threads (struct thread_info *event_thread) if (debug_infrun) fprintf_unfiltered (gdb_stdlog, "infrun: restart threads: [%s] was stepping\n", - target_pid_to_str (tp->ptid)); + target_pid_to_str (tp->ptid).c_str ()); keep_going_stepped_thread (tp); } else @@ -5311,7 +5312,7 @@ restart_threads (struct thread_info *event_thread) if (debug_infrun) fprintf_unfiltered (gdb_stdlog, "infrun: restart threads: [%s] continuing\n", - target_pid_to_str (tp->ptid)); + target_pid_to_str (tp->ptid).c_str ()); reset_ecs (ecs, tp); switch_to_thread (tp); keep_going_pass_signal (ecs); @@ -5432,7 +5433,7 @@ finish_step_over (struct execution_control_state *ecs) "(currently_stepping=%d)\n", paddress (target_gdbarch (), tp->suspend.stop_pc), - target_pid_to_str (tp->ptid), + target_pid_to_str (tp->ptid).c_str (), currently_stepping (tp)); } @@ -5487,9 +5488,8 @@ handle_signal_stop (struct execution_control_state *ecs) { 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, @@ -5595,7 +5595,7 @@ handle_signal_stop (struct execution_control_state *ecs) fprintf_unfiltered (gdb_stdlog, "infrun: [%s] hit another thread's " "single-step breakpoint\n", - target_pid_to_str (ecs->ptid)); + target_pid_to_str (ecs->ptid).c_str ()); } ecs->hit_singlestep_breakpoint = 1; } @@ -5607,7 +5607,7 @@ handle_signal_stop (struct execution_control_state *ecs) fprintf_unfiltered (gdb_stdlog, "infrun: [%s] hit its " "single-step breakpoint\n", - target_pid_to_str (ecs->ptid)); + target_pid_to_str (ecs->ptid).c_str ()); } } } @@ -5977,7 +5977,7 @@ handle_signal_stop (struct execution_control_state *ecs) 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 @@ -6586,7 +6586,8 @@ process_event_stop_test (struct execution_control_state *ecs) 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); @@ -6752,7 +6753,14 @@ process_event_stop_test (struct execution_control_state *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; @@ -6786,7 +6794,8 @@ process_event_stop_test (struct execution_control_state *ecs) 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); @@ -6857,7 +6866,7 @@ switch_back_to_stepped_thread (struct execution_control_state *ecs) { fprintf_unfiltered (gdb_stdlog, "infrun: need to finish step-over of [%s]\n", - target_pid_to_str (ecs->event_thread->ptid)); + target_pid_to_str (ecs->event_thread->ptid).c_str ()); } keep_going (ecs); return 1; @@ -6872,7 +6881,7 @@ switch_back_to_stepped_thread (struct execution_control_state *ecs) fprintf_unfiltered (gdb_stdlog, "infrun: need to step [%s] over single-step " "breakpoint\n", - target_pid_to_str (ecs->ptid)); + target_pid_to_str (ecs->ptid).c_str ()); } keep_going (ecs); return 1; @@ -6887,7 +6896,7 @@ switch_back_to_stepped_thread (struct execution_control_state *ecs) { fprintf_unfiltered (gdb_stdlog, "infrun: thread [%s] still needs step-over\n", - target_pid_to_str (ecs->event_thread->ptid)); + target_pid_to_str (ecs->event_thread->ptid).c_str ()); } keep_going (ecs); return 1; @@ -6923,6 +6932,8 @@ switch_back_to_stepped_thread (struct execution_control_state *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 @@ -6938,7 +6949,7 @@ switch_back_to_stepped_thread (struct execution_control_state *ecs) internal_error (__FILE__, __LINE__, "[%s] has inconsistent state: " "trap_expected=%d\n", - target_pid_to_str (tp->ptid), + target_pid_to_str (tp->ptid).c_str (), tp->control.trap_expected); } @@ -6974,6 +6985,8 @@ switch_back_to_stepped_thread (struct execution_control_state *ecs) return 1; } } + + switch_to_thread (ecs->event_thread); } return 0; @@ -7335,14 +7348,14 @@ insert_exception_resume_breakpoint (struct thread_info *tp, struct frame_info *frame, struct symbol *sym) { - TRY + try { struct block_symbol vsym; struct value *value; 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. */ @@ -7366,11 +7379,10 @@ insert_exception_resume_breakpoint (struct thread_info *tp, inferior_thread ()->control.exception_resume_breakpoint = bp; } } - CATCH (e, RETURN_MASK_ERROR) + catch (const gdb_exception_error &e) { /* We want to ignore errors here. */ } - END_CATCH } /* A helper for check_exception_resume that sets an @@ -7429,7 +7441,7 @@ check_exception_resume (struct execution_control_state *ecs, if (!func) return; - TRY + try { const struct block *b; struct block_iterator iter; @@ -7466,10 +7478,9 @@ check_exception_resume (struct execution_control_state *ecs, } } } - CATCH (e, RETURN_MASK_ERROR) + catch (const gdb_exception_error &e) { } - END_CATCH } static void @@ -7508,7 +7519,7 @@ keep_going_pass_signal (struct execution_control_state *ecs) fprintf_unfiltered (gdb_stdlog, "infrun: %s has trap_expected set, " "resuming to collect trap\n", - target_pid_to_str (tp->ptid)); + target_pid_to_str (tp->ptid).c_str ()); /* We haven't yet gotten our trap, and either: intercepted a non-signal event (e.g., a fork); or took a signal which we @@ -7530,7 +7541,7 @@ keep_going_pass_signal (struct execution_control_state *ecs) fprintf_unfiltered (gdb_stdlog, "infrun: step-over already in progress: " "step-over for %s deferred\n", - target_pid_to_str (tp->ptid)); + target_pid_to_str (tp->ptid).c_str ()); thread_step_over_chain_enqueue (tp); } else @@ -7539,7 +7550,7 @@ keep_going_pass_signal (struct execution_control_state *ecs) fprintf_unfiltered (gdb_stdlog, "infrun: step-over in progress: " "resume of %s deferred\n", - target_pid_to_str (tp->ptid)); + target_pid_to_str (tp->ptid).c_str ()); } } else @@ -7596,18 +7607,17 @@ keep_going_pass_signal (struct execution_control_state *ecs) stop_all_threads (); /* Stop stepping if inserting breakpoints fails. */ - TRY + try { insert_breakpoints (); } - CATCH (e, RETURN_MASK_ERROR) + catch (const gdb_exception_error &e) { exception_print (gdb_stderr, e); stop_waiting (ecs); clear_step_over_info (); return; } - END_CATCH ecs->event_thread->control.trap_expected = (remove_bp || remove_wps); @@ -7707,31 +7717,26 @@ void print_exited_reason (struct ui_out *uiout, int exitstatus) { struct inferior *inf = current_inferior (); - const char *pidstr = target_pid_to_str (ptid_t (inf->pid)); + std::string pidstr = target_pid_to_str (ptid_t (inf->pid)); annotate_exited (exitstatus); if (exitstatus) { 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); - 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); - uiout->text (") exited normally]\n"); + uiout->message ("[Inferior %s (%s) exited normally]\n", + plongest (inf->num), pidstr.c_str ()); } } @@ -7763,13 +7768,13 @@ print_signal_received_reason (struct ui_out *uiout, enum gdb_signal siggnal) 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 ("\""); } } @@ -7868,7 +7873,7 @@ print_stop_location (struct target_waitstatus *ws) /* See infrun.h. */ void -print_stop_event (struct ui_out *uiout) +print_stop_event (struct ui_out *uiout, bool displays) { struct target_waitstatus last; ptid_t last_ptid; @@ -7882,16 +7887,17 @@ print_stop_event (struct ui_out *uiout) print_stop_location (&last); /* Display the auto-display expressions. */ - do_displays (); + if (displays) + do_displays (); } tp = inferior_thread (); if (tp->thread_fsm != NULL - && thread_fsm_finished_p (tp->thread_fsm)) + && tp->thread_fsm->finished_p ()) { struct return_value_info *rv; - rv = thread_fsm_return_value (tp->thread_fsm); + rv = tp->thread_fsm->return_value (); if (rv != NULL) print_return_value (uiout, rv); } @@ -8061,7 +8067,7 @@ normal_stop (void) { target_terminal::ours_for_output (); printf_filtered (_("[Switching to %s]\n"), - target_pid_to_str (inferior_ptid)); + target_pid_to_str (inferior_ptid).c_str ()); annotate_thread_changed (); } previous_inferior_ptid = inferior_ptid; @@ -8128,16 +8134,15 @@ normal_stop (void) { stop_context saved_context; - TRY + try { execute_cmd_pre_hook (stop_command); } - CATCH (ex, RETURN_MASK_ALL) + catch (const gdb_exception &ex) { exception_fprintf (gdb_stderr, ex, "Error while running hook_stop:\n"); } - END_CATCH /* If the stop hook resumes the target, then there's no point in trying to notify about the previous stop; its context is @@ -8161,7 +8166,8 @@ normal_stop (void) if (target_has_execution) { if (last.kind != TARGET_WAITKIND_SIGNALLED - && last.kind != TARGET_WAITKIND_EXITED) + && last.kind != TARGET_WAITKIND_EXITED + && last.kind != TARGET_WAITKIND_NO_RESUMED) /* Delete the breakpoint we stopped at, if it wants to be deleted. Delete any breakpoint that is to be deleted at the next stop. */ breakpoint_auto_delete (inferior_thread ()->control.stop_bpstat); @@ -8251,7 +8257,7 @@ signal_catch_update (const unsigned int *info) for (i = 0; i < GDB_SIGNAL_LAST; ++i) signal_catch[i] = info[i] > 0; signal_cache_update (-1); - target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass); + target_pass_signals (signal_pass); } static void @@ -8287,8 +8293,6 @@ handle_command (const char *args, int from_tty) int sigfirst, siglast; enum gdb_signal oursig; int allsigs; - int nsigs; - unsigned char *sigs; if (args == NULL) { @@ -8297,9 +8301,8 @@ handle_command (const char *args, int from_tty) /* Allocate and zero an array of flags for which signals to handle. */ - nsigs = (int) GDB_SIGNAL_LAST; - sigs = (unsigned char *) alloca (nsigs); - memset (sigs, 0, nsigs); + const size_t nsigs = GDB_SIGNAL_LAST; + unsigned char sigs[nsigs] {}; /* Break the command line up into args. */ @@ -8414,10 +8417,7 @@ Are you sure you want to change it? "), sigs[signum] = 1; } else - { - printf_unfiltered (_("Not confirmed, unchanged.\n")); - gdb_flush (gdb_stdout); - } + printf_unfiltered (_("Not confirmed, unchanged.\n")); } break; case GDB_SIGNAL_0: @@ -8436,8 +8436,8 @@ Are you sure you want to change it? "), if (sigs[signum]) { signal_cache_update (-1); - target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass); - target_program_signals ((int) GDB_SIGNAL_LAST, signal_program); + target_pass_signals (signal_pass); + target_program_signals (signal_program); if (from_tty) { @@ -8839,11 +8839,11 @@ restore_infcall_control_state (struct infcall_control_state *inf_status) /* The point of the try/catch is that if the stack is clobbered, walking the stack might encounter a garbage pointer and error() trying to dereference it. */ - TRY + try { restore_selected_frame (inf_status->selected_frame_id); } - CATCH (ex, RETURN_MASK_ERROR) + catch (const gdb_exception_error &ex) { exception_fprintf (gdb_stderr, ex, "Unable to restore previously selected frame:\n"); @@ -8851,7 +8851,6 @@ restore_infcall_control_state (struct infcall_control_state *inf_status) innermost frame. */ select_frame (get_current_frame ()); } - END_CATCH } delete inf_status; @@ -8963,8 +8962,6 @@ infrun_async_inferior_event_handler (gdb_client_data data) void _initialize_infrun (void) { - int i; - int numsigs; struct cmd_list_element *c; /* Register extra event sources in the event loop. */ @@ -9046,13 +9043,7 @@ leave it stopped or free to run as needed."), &setlist, &showlist); - numsigs = (int) GDB_SIGNAL_LAST; - signal_stop = XNEWVEC (unsigned char, numsigs); - signal_print = XNEWVEC (unsigned char, numsigs); - signal_program = XNEWVEC (unsigned char, numsigs); - signal_catch = XNEWVEC (unsigned char, numsigs); - signal_pass = XNEWVEC (unsigned char, numsigs); - for (i = 0; i < numsigs; i++) + for (size_t i = 0; i < GDB_SIGNAL_LAST; i++) { signal_stop[i] = 1; signal_print[i] = 1;