projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Some get_last_target_status tweaks
[deliverable/binutils-gdb.git] / gdb / infrun.c
diff --git a/gdb/infrun.c b/gdb/infrun.c
index 61467be029bee86fde523c57287177b4490a00b2..bcfb178ef9c52108c0bdfdb6d31145ea42dca49d 100644 (file)
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -1,7 +1,7 @@
 /* Target-struct-independent code to start (run) and stop an inferior
    process.
 
 /* 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.
 
 
    This file is part of GDB.
 
@@ -25,16 +25,13 @@
 #include "frame.h"
 #include "inferior.h"
 #include "breakpoint.h"
 #include "frame.h"
 #include "inferior.h"
 #include "breakpoint.h"
-#include "common/gdb_wait.h"
 #include "gdbcore.h"
 #include "gdbcmd.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 "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 "inf-loop.h"
 #include "regcache.h"
 #include "value.h"
@@ -42,7 +39,6 @@
 #include "language.h"
 #include "solib.h"
 #include "main.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 "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 "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 "skip.h"
 #include "probe.h"
 #include "objfiles.h"
@@ -63,12 +57,12 @@
 #include "solist.h"
 #include "event-loop.h"
 #include "thread-fsm.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 "progspace-and-thread.h"
-#include "common/gdb_optional.h"
+#include "gdbsupport/gdb_optional.h"
 #include "arch-utils.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 */
 
 
 /* Prototypes for local functions */
 
@@ -84,8 +78,6 @@ static void follow_inferior_reset_breakpoints (void);
 
 static int currently_stepping (struct thread_info *tp);
 
 
 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 *);
 static void insert_hp_step_resume_breakpoint_at_frame (struct frame_info *);
 
 static void insert_step_resume_breakpoint_at_caller (struct frame_info *);
@@ -136,7 +128,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.  */
 /* 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)
 static void
 show_step_stop_if_no_debug (struct ui_file *file, int from_tty,
                            struct cmd_list_element *c, const char *value)
@@ -155,9 +147,9 @@ static ptid_t previous_inferior_ptid;
    Exactly which branch is detached depends on 'set follow-fork-mode'
    setting.  */
 
    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)
 static void
 show_debug_displaced (struct ui_file *file, int from_tty,
                      struct cmd_list_element *c, const char *value)
@@ -176,7 +168,7 @@ show_debug_infrun (struct ui_file *file, int from_tty,
 
 /* Support for disabling address space randomization.  */
 
 
 /* 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,
 
 static void
 show_disable_randomization (struct ui_file *file, int from_tty,
@@ -205,8 +197,8 @@ set_disable_randomization (const char *args, int from_tty,
 
 /* User interface for non-stop mode.  */
 
 
 /* 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,
 
 static void
 set_non_stop (const char *args, int from_tty,
@@ -234,8 +226,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.  */
 
    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,
 
 static void
 set_observer_mode (const char *args, int from_tty,
@@ -256,7 +248,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)
   /* 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 ();
 
   may_stop = !observer_mode;
   update_target_permissions ();
 
@@ -265,7 +257,7 @@ set_observer_mode (const char *args, int from_tty,
   if (observer_mode)
     {
       pagination_enabled = 0;
   if (observer_mode)
     {
       pagination_enabled = 0;
-      non_stop = non_stop_1 = 1;
+      non_stop = non_stop_1 = true;
     }
 
   if (from_tty)
     }
 
   if (from_tty)
@@ -289,13 +281,11 @@ show_observer_mode (struct ui_file *file, int from_tty,
 void
 update_observer_mode (void)
 {
 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)
 
   /* Let the user know if things change.  */
   if (newval != observer_mode)
@@ -440,7 +430,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"));
 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;
     }
 
       return 1;
     }
 
@@ -471,7 +460,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",
              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
            }
        }
       else
@@ -607,7 +596,7 @@ holding the child stopped.  Try \"set detach-on-fork\" or \
              fprintf_filtered (gdb_stdlog,
                                _("[Detaching after fork from "
                                  "parent %s]\n"),
              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);
            }
 
          target_detach (parent_inf, 0);
@@ -876,7 +865,7 @@ proceed_after_vfork_done (struct thread_info *thread,
       if (debug_infrun)
        fprintf_unfiltered (gdb_stdlog,
                            "infrun: resuming vfork parent thread %s\n",
       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);
 
       switch_to_thread (thread);
       clear_proceed_status (0);
@@ -915,10 +904,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
       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;
        {
          struct thread_info *tp;
          struct program_space *pspace;
@@ -926,7 +919,7 @@ handle_vfork_child_exec_or_exit (int exec)
 
          /* follow-fork child, detach-on-fork on.  */
 
 
          /* 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;
 
          gdb::optional<scoped_restore_exited_inferior>
            maybe_restore_inferior;
@@ -941,7 +934,7 @@ handle_vfork_child_exec_or_exit (int exec)
            maybe_restore_thread.emplace ();
 
          /* We're letting loose of the parent.  */
            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
          switch_to_thread (tp);
 
          /* We're about to detach from the parent, which implicitly
@@ -963,8 +956,8 @@ handle_vfork_child_exec_or_exit (int exec)
 
          if (print_inferior_events)
            {
 
          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 ();
 
 
              target_terminal::ours_for_output ();
 
@@ -972,17 +965,17 @@ handle_vfork_child_exec_or_exit (int exec)
                {
                  fprintf_filtered (gdb_stdlog,
                                    _("[Detaching vfork parent %s "
                {
                  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 "
                }
              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;
 
          /* Put it back.  */
          inf->pspace = pspace;
@@ -997,10 +990,7 @@ handle_vfork_child_exec_or_exit (int exec)
          inf->removable = 1;
          set_current_program_space (inf->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
        {
        }
       else
        {
@@ -1030,17 +1020,13 @@ handle_vfork_child_exec_or_exit (int exec)
          set_current_program_space (pspace);
          inf->removable = 1;
          inf->symfile_flags = SYMFILE_NO_READ;
          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;
 
          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)
       gdb_assert (current_program_space == inf->pspace);
 
       if (non_stop && resume_parent != -1)
@@ -1081,12 +1067,16 @@ show_follow_exec_mode_string (struct ui_file *file, int from_tty,
 /* EXEC_FILE_TARGET is assumed to be non-NULL.  */
 
 static void
 /* 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;
 
 {
   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.
   /* 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 +1095,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
 
      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 ();
      we now have a new a.out, those shadow contents aren't valid.  */
 
   mark_breakpoints_out ();
@@ -1154,7 +1144,7 @@ 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"),
   /* 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
                     exec_file_target);
 
   /* We've followed the inferior through an exec.  Therefore, the
@@ -1430,7 +1420,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
      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.
 
      same effect the instruction would have had if we had executed it
      at its original address.  We use this in step n3.
 
@@ -1668,7 +1658,7 @@ displaced_step_prepare_throw (thread_info *tp)
       if (debug_displaced)
        fprintf_unfiltered (gdb_stdlog,
                            "displaced: deferring step of %s\n",
       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;
 
       thread_step_over_chain_enqueue (tp);
       return 0;
@@ -1678,7 +1668,7 @@ displaced_step_prepare_throw (thread_info *tp)
       if (debug_displaced)
        fprintf_unfiltered (gdb_stdlog,
                            "displaced: stepping %s now\n",
       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);
     }
 
   displaced_step_clear (displaced);
@@ -1772,23 +1762,23 @@ displaced_step_prepare (thread_info *thread)
 {
   int prepared = -1;
 
 {
   int prepared = -1;
 
-  TRY
+  try
     {
       prepared = displaced_step_prepare_throw (thread);
     }
     {
       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)
     {
       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",
 
       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
        }
 
       /* Be verbose if "set displaced-stepping" is "on", silent if
@@ -1796,7 +1786,7 @@ displaced_step_prepare (thread_info *thread)
       if (can_use_displaced_stepping == AUTO_BOOLEAN_TRUE)
        {
          warning (_("disabling displaced stepping: %s"),
       if (can_use_displaced_stepping == AUTO_BOOLEAN_TRUE)
        {
          warning (_("disabling displaced stepping: %s"),
-                  ex.message);
+                  ex.what ());
        }
 
       /* Disable further displaced stepping attempts.  */
        }
 
       /* Disable further displaced stepping attempts.  */
@@ -1804,7 +1794,6 @@ displaced_step_prepare (thread_info *thread)
        = get_displaced_stepping_state (thread->inf);
       displaced_state->failed_before = 1;
     }
        = get_displaced_stepping_state (thread->inf);
       displaced_state->failed_before = 1;
     }
-  END_CATCH
 
   return prepared;
 }
 
   return prepared;
 }
@@ -1831,7 +1820,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",
                     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));
 }
                        paddress (displaced->step_gdbarch,
                                  displaced->step_copy));
 }
@@ -1985,7 +1974,7 @@ start_step_over (void)
          internal_error (__FILE__, __LINE__,
                          "[%s] has inconsistent state: "
                          "trap_expected=%d, resumed=%d, executing=%d\n",
          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);
                          tp->control.trap_expected,
                          tp->resumed,
                          tp->executing);
@@ -1994,7 +1983,7 @@ start_step_over (void)
       if (debug_infrun)
        fprintf_unfiltered (gdb_stdlog,
                            "infrun: resuming [%s] for step-over\n",
       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
 
       /* keep_going_pass_signal skips the step-over if the breakpoint
         is no longer inserted.  In all-stop, we want to keep looking
@@ -2089,7 +2078,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.  */
 /* 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.
 
 /* Try to setup for software single stepping over the specified location.
    Return 1 if target_resume() should use hardware single step.
@@ -2253,7 +2242,8 @@ resume_1 (enum gdb_signal sig)
          fprintf_unfiltered (gdb_stdlog,
                              "infrun: resume: thread %s has pending wait "
                              "status %s (currently_stepping=%d).\n",
          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));
        }
 
                              currently_stepping (tp));
        }
 
@@ -2265,7 +2255,8 @@ resume_1 (enum gdb_signal sig)
       if (sig != GDB_SIGNAL_0)
        {
          warning (_("Couldn't deliver signal %s to %s."),
       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;
        }
 
       tp->suspend.stop_signal = GDB_SIGNAL_0;
@@ -2309,7 +2300,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,
                        "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
                        paddress (gdbarch, pc));
 
   /* Normally, by the time we reach `resume', the breakpoints are either
@@ -2558,7 +2549,7 @@ resume_1 (enum gdb_signal sig)
       if (debug_infrun)
        fprintf_unfiltered (gdb_stdlog,
                            "infrun: resume: [%s] stepped breakpoint\n",
       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;
 
 
       tp->stepped_breakpoint = 1;
 
@@ -2606,11 +2597,11 @@ resume_1 (enum gdb_signal sig)
 static void
 resume (gdb_signal sig)
 {
 static void
 resume (gdb_signal sig)
 {
-  TRY
+  try
     {
       resume_1 (sig);
     }
     {
       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
     {
       /* If resuming is being aborted for any reason, delete any
         single-step breakpoint resume_1 may have created, to avoid
@@ -2619,9 +2610,8 @@ resume (gdb_signal sig)
         we're running in non-stop mode.  */
       if (inferior_ptid != null_ptid)
        delete_single_step_breakpoints (inferior_thread ());
         we're running in non-stop mode.  */
       if (inferior_ptid != null_ptid)
        delete_single_step_breakpoints (inferior_thread ());
-      throw_exception (ex);
+      throw;
     }
     }
-  END_CATCH
 }
 
 \f
 }
 
 \f
@@ -2663,7 +2653,7 @@ clear_proceed_status_thread (struct thread_info *tp)
   if (debug_infrun)
     fprintf_unfiltered (gdb_stdlog,
                        "infrun: clear_proceed_status_thread (%s)\n",
   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.  */
 
   /* If we're starting a new sequence, then the previous finished
      single-step is no longer relevant.  */
@@ -2676,7 +2666,7 @@ clear_proceed_status_thread (struct thread_info *tp)
                                "infrun: clear_proceed_status: pending "
                                "event of %s was a finished step. "
                                "Discarding.\n",
                                "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;
 
          tp->suspend.waitstatus_pending_p = 0;
          tp->suspend.stop_reason = TARGET_STOPPED_BY_NO_REASON;
@@ -2690,7 +2680,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",
                              "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));
        }
     }
                              currently_stepping (tp));
        }
     }
@@ -2947,6 +2938,8 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal)
     {
       for (thread_info *tp : all_non_exited_threads (resume_ptid))
        {
     {
       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)
          /* Ignore the current thread here.  It's handled
             afterwards.  */
          if (tp == cur_thr)
@@ -2960,10 +2953,12 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal)
          if (debug_infrun)
            fprintf_unfiltered (gdb_stdlog,
                                "infrun: need to step-over [%s] first\n",
          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);
        }
 
          thread_step_over_chain_enqueue (tp);
        }
+
+      switch_to_thread (cur_thr);
     }
 
   /* Enqueue the current thread last, so that we move all other
     }
 
   /* Enqueue the current thread last, so that we move all other
@@ -3000,12 +2995,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))
         {
           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",
          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;
            }
              gdb_assert (tp->executing || tp->suspend.waitstatus_pending_p);
              continue;
            }
@@ -3015,14 +3012,14 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal)
              if (debug_infrun)
                fprintf_unfiltered (gdb_stdlog,
                                    "infrun: proceed: [%s] needs step-over\n",
              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",
              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);
 
          reset_ecs (ecs, tp);
          switch_to_thread (tp);
@@ -3046,6 +3043,11 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal)
 
   finish_state.release ();
 
 
   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.  */
   /* Tell the event loop to wait for it to stop.  If the target
      supports asynchronous execution, it'll do this from within
      target_resume.  */
@@ -3099,7 +3101,7 @@ init_wait_for_inferior (void)
 
   clear_proceed_status (0);
 
 
   clear_proceed_status (0);
 
-  target_last_wait_ptid = minus_one_ptid;
+  nullify_last_target_wait_ptid ();
 
   previous_inferior_ptid = inferior_ptid;
 }
 
   previous_inferior_ptid = inferior_ptid;
 }
@@ -3256,13 +3258,13 @@ print_target_wait_results (ptid_t waiton_ptid, ptid_t result_ptid,
              waiton_ptid.lwp (),
              waiton_ptid.tid ());
   if (waiton_ptid.pid () != -1)
              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 (),
   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
   stb.printf ("infrun:   %s\n", status_string.c_str ());
 
   /* This uses %s in part to handle %'s in the text, but also to avoid
@@ -3332,7 +3334,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",
       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);
 
       /* We have a specific thread to check.  */
       tp = find_thread_ptid (ptid);
@@ -3357,7 +3359,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",
          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;
                                paddress (gdbarch, tp->suspend.stop_pc),
                                paddress (gdbarch, pc));
          discard = 1;
@@ -3367,7 +3369,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",
          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;
                                paddress (gdbarch, pc));
 
          discard = 1;
@@ -3378,7 +3380,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",
          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;
 
          tp->suspend.waitstatus.kind = TARGET_WAITKIND_SPURIOUS;
          tp->suspend.stop_reason = TARGET_STOPPED_BY_NO_REASON;
@@ -3395,7 +3397,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 (),
          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
        }
 
       /* Now that we've selected our final event LWP, un-adjust its PC
@@ -3700,14 +3702,11 @@ fetch_inferior_event (void *client_data)
        set_current_traceframe (-1);
       }
 
        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
 
     overlay_cache_invalid = 1;
     /* Flush target cache before starting to handle each event.  Target
@@ -3784,6 +3783,19 @@ fetch_inferior_event (void *client_data)
                inferior_event_handler (INF_EXEC_COMPLETE, NULL);
                cmd_done = 1;
              }
                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 ();
          }
       }
 
          }
       }
 
@@ -3833,7 +3845,7 @@ init_thread_stepping_state (struct thread_info *tss)
   tss->step_after_step_resume_breakpoint = 0;
 }
 
   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)
 
 void
 set_last_target_status (ptid_t ptid, struct target_waitstatus status)
@@ -3842,22 +3854,24 @@ set_last_target_status (ptid_t ptid, struct target_waitstatus status)
   target_last_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
 
 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;
 void
 nullify_last_target_wait_ptid (void)
 {
   target_last_wait_ptid = minus_one_ptid;
+  target_last_waitstatus = {};
 }
 
 /* Switch thread contexts.  */
 }
 
 /* Switch thread contexts.  */
@@ -3870,9 +3884,9 @@ context_switch (execution_control_state *ecs)
       && ecs->event_thread != inferior_thread ())
     {
       fprintf_unfiltered (gdb_stdlog, "infrun: Switching context from %s ",
       && 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",
       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);
     }
 
   switch_to_thread (ecs->event_thread);
@@ -4041,6 +4055,45 @@ stepped_in_from (struct frame_info *frame, struct frame_id step_frame_id)
   return 0;
 }
 
   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 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).  */
@@ -4113,18 +4166,35 @@ fill_in_stop_func (struct gdbarch *gdbarch,
 {
   if (!ecs->stop_func_filled_in)
     {
 {
   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.  */
       /* 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;
     }
 
       ecs->stop_func_filled_in = 1;
     }
@@ -4312,7 +4382,8 @@ stop_all_threads (void)
                        fprintf_unfiltered (gdb_stdlog,
                                            "infrun:   %s executing, "
                                            "need stop\n",
                        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;
                    }
                      target_stop (t->ptid);
                      t->stop_requested = 1;
                    }
@@ -4322,7 +4393,7 @@ stop_all_threads (void)
                        fprintf_unfiltered (gdb_stdlog,
                                            "infrun:   %s executing, "
                                            "already stopping\n",
                        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)
                    }
 
                  if (t->stop_requested)
@@ -4333,7 +4404,7 @@ stop_all_threads (void)
                  if (debug_infrun)
                    fprintf_unfiltered (gdb_stdlog,
                                        "infrun:   %s not executing\n",
                  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.  */
 
                  /* The thread may be not executing, but still be
                     resumed with a pending status to process.  */
@@ -4351,24 +4422,21 @@ stop_all_threads (void)
            pass = -1;
 
          event_ptid = wait_one (&ws);
            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
            {
            }
          else
            {
@@ -4407,7 +4475,7 @@ stop_all_threads (void)
                                              "infrun: displaced-step of %s "
                                              "canceled: adding back to the "
                                              "step-over queue\n",
                                              "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);
                        }
                      t->control.trap_expected = 0;
                      thread_step_over_chain_enqueue (t);
@@ -4454,7 +4522,7 @@ stop_all_threads (void)
                                          "(currently_stepping=%d)\n",
                                          paddress (target_gdbarch (),
                                                    t->suspend.stop_pc),
                                          "(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));
                    }
                }
                                          currently_stepping (t));
                    }
                }
@@ -4588,10 +4656,19 @@ handle_no_resumed (struct execution_control_state *ecs)
    once).  */
 
 static void
    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;
 
   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
   if (ecs->ws.kind == TARGET_WAITKIND_IGNORE)
     {
       /* We had an event in the inferior, but we are not interested in
@@ -4603,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.  */
         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)
     {
       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;
     }
       prepare_to_wait (ecs);
       return;
     }
@@ -4631,9 +4704,6 @@ handle_inferior_event_1 (struct execution_control_state *ecs)
     {
       /* No unwaited-for children left.  IOW, all resumed children
         have exited.  */
     {
       /* 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;
       stop_print_frame = 0;
       stop_waiting (ecs);
       return;
@@ -4726,8 +4796,6 @@ handle_inferior_event_1 (struct execution_control_state *ecs)
   switch (ecs->ws.kind)
     {
     case TARGET_WAITKIND_LOADED:
   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
       context_switch (ecs);
       /* Ignore gracefully during startup of the inferior, as it might
          be the shell which has just loaded some objects, otherwise
@@ -4805,8 +4873,6 @@ handle_inferior_event_1 (struct execution_control_state *ecs)
                      _("unhandled stop_soon: %d"), (int) stop_soon);
 
     case TARGET_WAITKIND_SPURIOUS:
                      _("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);
       if (handle_stop_requested (ecs))
        return;
       context_switch (ecs);
@@ -4815,8 +4881,6 @@ handle_inferior_event_1 (struct execution_control_state *ecs)
       return;
 
     case TARGET_WAITKIND_THREAD_CREATED:
       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);
       if (handle_stop_requested (ecs))
        return;
       context_switch (ecs);
@@ -4826,16 +4890,6 @@ handle_inferior_event_1 (struct execution_control_state *ecs)
 
     case TARGET_WAITKIND_EXITED:
     case TARGET_WAITKIND_SIGNALLED:
 
     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);
       inferior_ptid = ecs->ptid;
       set_current_inferior (find_inferior_ptid (ecs->ptid));
       set_current_program_space (current_inferior ()->pspace);
@@ -4900,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:
          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);
       /* Check whether the inferior is displaced stepping.  */
       {
        struct regcache *regcache = get_thread_regcache (ecs->event_thread);
@@ -5068,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.  */
 
       /* 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;
       context_switch (ecs);
 
       current_inferior ()->waiting_for_vfork_done = 0;
@@ -5086,8 +5128,6 @@ Cannot fill $_exitsignal with the correct signal number.\n"));
       return;
 
     case TARGET_WAITKIND_EXECD:
       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.
 
       /* Note we can't read registers yet (the stop_pc), because we
         don't yet know the inferior's post-exec architecture.
@@ -5136,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:
       /* 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);
       /* Getting the current syscall number.  */
       if (handle_syscall_event (ecs) == 0)
        process_event_stop_test (ecs);
@@ -5150,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:
          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 (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:
       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.  */
       /* Reverse execution: target ran out of history info.  */
 
       /* Switch to the stopped thread.  */
@@ -5186,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.  */
 /* 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.  */
@@ -5214,13 +5228,15 @@ restart_threads (struct thread_info *event_thread)
 
   for (thread_info *tp : all_non_exited_threads ())
     {
 
   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",
       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;
        }
 
          continue;
        }
 
@@ -5230,7 +5246,7 @@ restart_threads (struct thread_info *event_thread)
            fprintf_unfiltered (gdb_stdlog,
                                "infrun: restart threads: "
                                "[%s] not meant to be running\n",
            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;
        }
 
          continue;
        }
 
@@ -5239,7 +5255,7 @@ restart_threads (struct thread_info *event_thread)
          if (debug_infrun)
            fprintf_unfiltered (gdb_stdlog,
                                "infrun: restart threads: [%s] resumed\n",
          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;
        }
          gdb_assert (tp->executing || tp->suspend.waitstatus_pending_p);
          continue;
        }
@@ -5250,7 +5266,7 @@ restart_threads (struct thread_info *event_thread)
            fprintf_unfiltered (gdb_stdlog,
                                "infrun: restart threads: "
                                "[%s] needs step-over\n",
            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;
        }
          gdb_assert (!tp->resumed);
          continue;
        }
@@ -5262,7 +5278,7 @@ restart_threads (struct thread_info *event_thread)
            fprintf_unfiltered (gdb_stdlog,
                                "infrun: restart threads: "
                                "[%s] has pending status\n",
            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;
        }
          tp->resumed = 1;
          continue;
        }
@@ -5277,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",
          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))
        }
 
       if (currently_stepping (tp))
@@ -5285,7 +5301,7 @@ restart_threads (struct thread_info *event_thread)
          if (debug_infrun)
            fprintf_unfiltered (gdb_stdlog,
                                "infrun: restart threads: [%s] was stepping\n",
          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
          keep_going_stepped_thread (tp);
        }
       else
@@ -5296,7 +5312,7 @@ restart_threads (struct thread_info *event_thread)
          if (debug_infrun)
            fprintf_unfiltered (gdb_stdlog,
                                "infrun: restart threads: [%s] continuing\n",
          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);
          reset_ecs (ecs, tp);
          switch_to_thread (tp);
          keep_going_pass_signal (ecs);
@@ -5417,7 +5433,7 @@ finish_step_over (struct execution_control_state *ecs)
                                  "(currently_stepping=%d)\n",
                                  paddress (target_gdbarch (),
                                            tp->suspend.stop_pc),
                                  "(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));
            }
 
                                  currently_stepping (tp));
            }
 
@@ -5472,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 ();
     {
       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,
 
       fprintf_unfiltered (gdb_stdlog, "infrun: stop_pc = %s\n",
                          paddress (reg_gdbarch,
@@ -5580,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",
                  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;
            }
                }
              ecs->hit_singlestep_breakpoint = 1;
            }
@@ -5592,7 +5607,7 @@ handle_signal_stop (struct execution_control_state *ecs)
              fprintf_unfiltered (gdb_stdlog,
                                  "infrun: [%s] hit its "
                                  "single-step breakpoint\n",
              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 ());
            }
        }
     }
            }
        }
     }
@@ -5962,7 +5977,7 @@ handle_signal_stop (struct execution_control_state *ecs)
          return;
        }
 
          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
         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
@@ -6571,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 = 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 (execution_direction == EXEC_REVERSE)
              handle_step_into_function_backward (gdbarch, ecs);
@@ -6737,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)
 
          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;
 
          end_stepping_range (ecs);
          return;
@@ -6771,7 +6794,8 @@ process_event_stop_test (struct execution_control_state *ecs)
        fprintf_unfiltered (gdb_stdlog,
                            "infrun: stepping through inlined function\n");
 
        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);
        keep_going (ecs);
       else
        end_stepping_range (ecs);
@@ -6842,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",
            {
              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;
            }
          keep_going (ecs);
          return 1;
@@ -6857,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",
             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;
           }
         keep_going (ecs);
         return 1;
@@ -6872,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",
            {
              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;
            }
          keep_going (ecs);
          return 1;
@@ -6908,6 +6932,8 @@ switch_back_to_stepped_thread (struct execution_control_state *ecs)
 
       for (thread_info *tp : all_non_exited_threads ())
         {
 
       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
          /* Ignore threads of processes the caller is not
             resuming.  */
          if (!sched_multi
@@ -6923,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",
              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);
            }
 
                              tp->control.trap_expected);
            }
 
@@ -6959,6 +6985,8 @@ switch_back_to_stepped_thread (struct execution_control_state *ecs)
              return 1;
            }
        }
              return 1;
            }
        }
+
+      switch_to_thread (ecs->event_thread);
     }
 
   return 0;
     }
 
   return 0;
@@ -7320,14 +7348,14 @@ insert_exception_resume_breakpoint (struct thread_info *tp,
                                    struct frame_info *frame,
                                    struct symbol *sym)
 {
                                    struct frame_info *frame,
                                    struct symbol *sym)
 {
-  TRY
+  try
     {
       struct block_symbol vsym;
       struct value *value;
       CORE_ADDR handler;
       struct breakpoint *bp;
 
     {
       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.  */
                                        b, VAR_DOMAIN);
       value = read_var_value (vsym.symbol, vsym.block, frame);
       /* If the value was optimized out, revert to the old behavior.  */
@@ -7351,11 +7379,10 @@ insert_exception_resume_breakpoint (struct thread_info *tp,
          inferior_thread ()->control.exception_resume_breakpoint = bp;
        }
     }
          inferior_thread ()->control.exception_resume_breakpoint = bp;
        }
     }
-  CATCH (e, RETURN_MASK_ERROR)
+  catch (const gdb_exception_error &e)
     {
       /* We want to ignore errors here.  */
     }
     {
       /* We want to ignore errors here.  */
     }
-  END_CATCH
 }
 
 /* A helper for check_exception_resume that sets an
 }
 
 /* A helper for check_exception_resume that sets an
@@ -7414,7 +7441,7 @@ check_exception_resume (struct execution_control_state *ecs,
   if (!func)
     return;
 
   if (!func)
     return;
 
-  TRY
+  try
     {
       const struct block *b;
       struct block_iterator iter;
     {
       const struct block *b;
       struct block_iterator iter;
@@ -7451,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
 }
 
 static void
@@ -7493,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",
        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
 
       /* We haven't yet gotten our trap, and either: intercepted a
         non-signal event (e.g., a fork); or took a signal which we
@@ -7515,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",
            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
          thread_step_over_chain_enqueue (tp);
        }
       else
@@ -7524,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",
            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
        }
     }
   else
@@ -7581,18 +7607,17 @@ keep_going_pass_signal (struct execution_control_state *ecs)
        stop_all_threads ();
 
       /* Stop stepping if inserting breakpoints fails.  */
        stop_all_threads ();
 
       /* Stop stepping if inserting breakpoints fails.  */
-      TRY
+      try
        {
          insert_breakpoints ();
        }
        {
          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;
        }
        {
          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);
 
 
       ecs->event_thread->control.trap_expected = (remove_bp || remove_wps);
 
@@ -7692,31 +7717,26 @@ void
 print_exited_reason (struct ui_out *uiout, int exitstatus)
 {
   struct inferior *inf = current_inferior ();
 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));
 
   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));
     }
   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 ());
     }
 }
 
     }
 }
 
@@ -7748,13 +7768,13 @@ print_signal_received_reason (struct ui_out *uiout, enum gdb_signal siggnal)
       const char *name;
 
       uiout->text ("\nThread ");
       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 (" \"");
 
       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 ("\"");
        }
     }
          uiout->text ("\"");
        }
     }
@@ -7853,13 +7873,12 @@ print_stop_location (struct target_waitstatus *ws)
 /* See infrun.h.  */
 
 void
 /* See infrun.h.  */
 
 void
-print_stop_event (struct ui_out *uiout)
+print_stop_event (struct ui_out *uiout, bool displays)
 {
   struct target_waitstatus last;
 {
   struct target_waitstatus last;
-  ptid_t last_ptid;
   struct thread_info *tp;
 
   struct thread_info *tp;
 
-  get_last_target_status (&last_ptid, &last);
+  get_last_target_status (nullptr, &last);
 
   {
     scoped_restore save_uiout = make_scoped_restore (&current_uiout, uiout);
 
   {
     scoped_restore save_uiout = make_scoped_restore (&current_uiout, uiout);
@@ -7867,7 +7886,8 @@ print_stop_event (struct ui_out *uiout)
     print_stop_location (&last);
 
     /* Display the auto-display expressions.  */
     print_stop_location (&last);
 
     /* Display the auto-display expressions.  */
-    do_displays ();
+    if (displays)
+      do_displays ();
   }
 
   tp = inferior_thread ();
   }
 
   tp = inferior_thread ();
@@ -7977,9 +7997,8 @@ int
 normal_stop (void)
 {
   struct target_waitstatus last;
 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 ();
 
 
   new_stop_id ();
 
@@ -8046,7 +8065,7 @@ normal_stop (void)
        {
          target_terminal::ours_for_output ();
          printf_filtered (_("[Switching to %s]\n"),
        {
          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;
          annotate_thread_changed ();
        }
       previous_inferior_ptid = inferior_ptid;
@@ -8113,16 +8132,15 @@ normal_stop (void)
     {
       stop_context saved_context;
 
     {
       stop_context saved_context;
 
-      TRY
+      try
        {
          execute_cmd_pre_hook (stop_command);
        }
        {
          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");
        }
        {
          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
 
       /* If the stop hook resumes the target, then there's no point in
         trying to notify about the previous stop; its context is
@@ -8146,7 +8164,8 @@ normal_stop (void)
   if (target_has_execution)
     {
       if (last.kind != TARGET_WAITKIND_SIGNALLED
   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);
        /* 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);
@@ -8818,11 +8837,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.  */
       /* 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);
        }
        {
          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");
        {
          exception_fprintf (gdb_stderr, ex,
                             "Unable to restore previously selected frame:\n");
@@ -8830,7 +8849,6 @@ restore_infcall_control_state (struct infcall_control_state *inf_status)
             innermost frame.  */
          select_frame (get_current_frame ());
        }
             innermost frame.  */
          select_frame (get_current_frame ());
        }
-      END_CATCH
     }
 
   delete inf_status;
     }
 
   delete inf_status;
GDB Binutils - Deliverables
This page took 0.059105 seconds and 4 git commands to generate.