Use all_non_exited_inferiors in infrun.c

[deliverable/binutils-gdb.git] / gdb / infrun.c

diff --git a/gdb/infrun.c b/gdb/infrun.c
index 1c48740404e09ed40a017e05a3f5c2d4746b32b6..bc8a3dafcbaec610063d2f3c050e1267989ded95 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-2018 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 "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,10 +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 "gdbsupport/scope-exit.h"
+#include "gdbsupport/forward-scope-exit.h"

 
 /* Prototypes for local functions */
 
 
 /* Prototypes for local functions */
 


@@ -82,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 *);


@@ -134,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)


@@ -153,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)


@@ -174,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,


@@ -203,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,


@@ -232,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,


@@ -254,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 ();
 


@@ -263,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)


@@ -287,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)


@@ -305,20 +297,19 @@ update_observer_mode (void)
 
 /* Tables of how to react to signals; the user sets them.  */
 
 
 /* Tables of how to react to signals; the user sets them.  */
 

-static unsigned char *signal_stop;
-static unsigned char *signal_print;
-static unsigned char *signal_program;
+static unsigned char signal_stop[GDB_SIGNAL_LAST];
+static unsigned char signal_print[GDB_SIGNAL_LAST];
+static unsigned char signal_program[GDB_SIGNAL_LAST];

 
 /* Table of signals that are registered with "catch signal".  A
    non-zero entry indicates that the signal is caught by some "catch
 
 /* Table of signals that are registered with "catch signal".  A
    non-zero entry indicates that the signal is caught by some "catch

-   signal" command.  This has size GDB_SIGNAL_LAST, to accommodate all
-   signals.  */
-static unsigned char *signal_catch;
+   signal" command.  */
+static unsigned char signal_catch[GDB_SIGNAL_LAST];

 
 /* Table of signals that the target may silently handle.
    This is automatically determined from the flags above,
    and simply cached here.  */
 
 /* Table of signals that the target may silently handle.
    This is automatically determined from the flags above,
    and simply cached here.  */

-static unsigned char *signal_pass;
+static unsigned char signal_pass[GDB_SIGNAL_LAST];

 
 #define SET_SIGS(nsigs,sigs,flags) \
   do { \
 
 #define SET_SIGS(nsigs,sigs,flags) \
   do { \


@@ -342,7 +333,7 @@ static unsigned char *signal_pass;
 void
 update_signals_program_target (void)
 {
 void
 update_signals_program_target (void)
 {

-  target_program_signals ((int) GDB_SIGNAL_LAST, signal_program);
+  target_program_signals (signal_program);

 }
 
 /* Value to pass to target_resume() to cause all threads to resume.  */
 }
 
 /* Value to pass to target_resume() to cause all threads to resume.  */


@@ -439,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;
     }
 


@@ -470,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


@@ -606,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);


@@ -875,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);


@@ -914,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;


@@ -925,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;


@@ -940,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


@@ -962,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 ();
 


@@ -971,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;


@@ -996,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
        {


@@ -1029,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)


@@ -1080,13 +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 thread_info *th, *tmp;

   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 ();


@@ -1129,7 +1119,7 @@ follow_exec (ptid_t ptid, char *exec_file_target)
      them.  Deleting them now rather than at the next user-visible
      stop provides a nicer sequence of events for user and MI
      notifications.  */
      them.  Deleting them now rather than at the next user-visible
      stop provides a nicer sequence of events for user and MI
      notifications.  */

-  ALL_THREADS_SAFE (th, tmp)
+  for (thread_info *th : all_threads_safe ())

     if (th->ptid.pid () == pid && th->ptid != ptid)
       delete_thread (th);
 
     if (th->ptid.pid () == pid && th->ptid != ptid)
       delete_thread (th);
 


@@ -1137,7 +1127,7 @@ follow_exec (ptid_t ptid, char *exec_file_target)
      leader/event thread.  E.g., if there was any step-resume
      breakpoint or similar, it's gone now.  We cannot truly
      step-to-next statement through an exec().  */
      leader/event thread.  E.g., if there was any step-resume
      breakpoint or similar, it's gone now.  We cannot truly
      step-to-next statement through an exec().  */

-  th = inferior_thread ();
+  thread_info *th = inferior_thread ();

   th->control.step_resume_breakpoint = NULL;
   th->control.exception_resume_breakpoint = NULL;
   th->control.single_step_breakpoints = NULL;
   th->control.step_resume_breakpoint = NULL;
   th->control.exception_resume_breakpoint = NULL;
   th->control.single_step_breakpoints = NULL;


@@ -1154,14 +1144,12 @@ follow_exec (ptid_t ptid, char *exec_file_target)
   /* What is this a.out's name?  */
   process_ptid = ptid_t (pid);
   printf_unfiltered (_("%s is executing new program: %s\n"),
   /* What is this a.out's name?  */
   process_ptid = ptid_t (pid);
   printf_unfiltered (_("%s is executing new program: %s\n"),

-                    target_pid_to_str (process_ptid),
+                    target_pid_to_str (process_ptid).c_str (),

                     exec_file_target);
 
   /* We've followed the inferior through an exec.  Therefore, the
      inferior has essentially been killed & reborn.  */
 
                     exec_file_target);
 
   /* We've followed the inferior through an exec.  Therefore, the
      inferior has essentially been killed & reborn.  */
 

-  gdb_flush (gdb_stdout);
-

   breakpoint_init_inferior (inf_execd);
 
   gdb::unique_xmalloc_ptr<char> exec_file_host
   breakpoint_init_inferior (inf_execd);
 
   gdb::unique_xmalloc_ptr<char> exec_file_host


@@ -1202,6 +1190,7 @@ follow_exec (ptid_t ptid, char *exec_file_target)
 
       set_current_inferior (inf);
       set_current_program_space (inf->pspace);
 
       set_current_inferior (inf);
       set_current_program_space (inf->pspace);

+      add_thread (ptid);

     }
   else
     {
     }
   else
     {


@@ -1231,11 +1220,6 @@ follow_exec (ptid_t ptid, char *exec_file_target)
      registers.  */
   target_find_description ();
 
      registers.  */
   target_find_description ();
 

-  /* The add_thread call ends up reading registers, so do it after updating the
-     target description.  */
-  if (follow_exec_mode_string == follow_exec_mode_new)
-    add_thread (ptid);
-

   solib_create_inferior_hook (0);
 
   jit_inferior_created_hook ();
   solib_create_inferior_hook (0);
 
   jit_inferior_created_hook ();


@@ -1436,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.
 


@@ -1481,56 +1465,12 @@ step_over_info_valid_p (void)
 
 displaced_step_closure::~displaced_step_closure () = default;
 
 
 displaced_step_closure::~displaced_step_closure () = default;
 

-/* Per-inferior displaced stepping state.  */
-struct displaced_step_inferior_state
-{
-  /* Pointer to next in linked list.  */
-  struct displaced_step_inferior_state *next;
-
-  /* The process this displaced step state refers to.  */
-  inferior *inf;
-
-  /* True if preparing a displaced step ever failed.  If so, we won't
-     try displaced stepping for this inferior again.  */
-  int failed_before;
-
-  /* If this is not nullptr, this is the thread carrying out a
-     displaced single-step in process PID.  This thread's state will
-     require fixing up once it has completed its step.  */
-  thread_info *step_thread;
-
-  /* The architecture the thread had when we stepped it.  */
-  struct gdbarch *step_gdbarch;
-
-  /* The closure provided gdbarch_displaced_step_copy_insn, to be used
-     for post-step cleanup.  */
-  struct displaced_step_closure *step_closure;
-
-  /* The address of the original instruction, and the copy we
-     made.  */
-  CORE_ADDR step_original, step_copy;
-
-  /* Saved contents of copy area.  */
-  gdb_byte *step_saved_copy;
-};
-
-/* The list of states of processes involved in displaced stepping
-   presently.  */
-static std::forward_list<displaced_step_inferior_state *>
-  displaced_step_inferior_states;
-

 /* Get the displaced stepping state of process PID.  */
 
 static displaced_step_inferior_state *
 get_displaced_stepping_state (inferior *inf)
 {
 /* Get the displaced stepping state of process PID.  */
 
 static displaced_step_inferior_state *
 get_displaced_stepping_state (inferior *inf)
 {

-  for (auto *state : displaced_step_inferior_states)
-    {
-      if (state->inf == inf)
-       return state;
-    }
-
-  return nullptr;
+  return &inf->displaced_step_state;

 }
 
 /* Returns true if any inferior has a thread doing a displaced
 }
 
 /* Returns true if any inferior has a thread doing a displaced


@@ -1539,9 +1479,9 @@ get_displaced_stepping_state (inferior *inf)
 static bool
 displaced_step_in_progress_any_inferior ()
 {
 static bool
 displaced_step_in_progress_any_inferior ()
 {

-  for (auto *state : displaced_step_inferior_states)
+  for (inferior *i : all_inferiors ())

     {
     {

-      if (state->step_thread != nullptr)
+      if (i->displaced_step_state.step_thread != nullptr)

        return true;
     }
 
        return true;
     }
 


@@ -1554,13 +1494,9 @@ displaced_step_in_progress_any_inferior ()
 static int
 displaced_step_in_progress_thread (thread_info *thread)
 {
 static int
 displaced_step_in_progress_thread (thread_info *thread)
 {

-  struct displaced_step_inferior_state *displaced;
-

   gdb_assert (thread != NULL);
 
   gdb_assert (thread != NULL);
 

-  displaced = get_displaced_stepping_state (thread->inf);
-
-  return (displaced != NULL && displaced->step_thread == thread);
+  return get_displaced_stepping_state (thread->inf)->step_thread == thread;

 }
 
 /* Return true if process PID has a thread doing a displaced step.  */
 }
 
 /* Return true if process PID has a thread doing a displaced step.  */


@@ -1568,34 +1504,7 @@ displaced_step_in_progress_thread (thread_info *thread)
 static int
 displaced_step_in_progress (inferior *inf)
 {
 static int
 displaced_step_in_progress (inferior *inf)
 {

-  struct displaced_step_inferior_state *displaced;
-
-  displaced = get_displaced_stepping_state (inf);
-  if (displaced != NULL && displaced->step_thread != nullptr)
-    return 1;
-
-  return 0;
-}
-
-/* Add a new displaced stepping state for process PID to the displaced
-   stepping state list, or return a pointer to an already existing
-   entry, if it already exists.  Never returns NULL.  */
-
-static displaced_step_inferior_state *
-add_displaced_stepping_state (inferior *inf)
-{
-  displaced_step_inferior_state *state
-    = get_displaced_stepping_state (inf);
-
-  if (state != nullptr)
-    return state;
-
-  state = XCNEW (struct displaced_step_inferior_state);
-  state->inf = inf;
-
-  displaced_step_inferior_states.push_front (state);
-
-  return state;
+  return get_displaced_stepping_state (inf)->step_thread != nullptr;

 }
 
 /* If inferior is in displaced stepping, and ADDR equals to starting address
 }
 
 /* If inferior is in displaced stepping, and ADDR equals to starting address


@@ -1605,42 +1514,21 @@ add_displaced_stepping_state (inferior *inf)
 struct displaced_step_closure*
 get_displaced_step_closure_by_addr (CORE_ADDR addr)
 {
 struct displaced_step_closure*
 get_displaced_step_closure_by_addr (CORE_ADDR addr)
 {

-  struct displaced_step_inferior_state *displaced
+  displaced_step_inferior_state *displaced

     = get_displaced_stepping_state (current_inferior ());
 
   /* If checking the mode of displaced instruction in copy area.  */
     = get_displaced_stepping_state (current_inferior ());
 
   /* If checking the mode of displaced instruction in copy area.  */

-  if (displaced != NULL
-      && displaced->step_thread != nullptr
+  if (displaced->step_thread != nullptr

       && displaced->step_copy == addr)
     return displaced->step_closure;
 
   return NULL;
 }
 
       && displaced->step_copy == addr)
     return displaced->step_closure;
 
   return NULL;
 }
 

-/* Remove the displaced stepping state of process PID.  */
-
-static void
-remove_displaced_stepping_state (inferior *inf)
-{
-  gdb_assert (inf != nullptr);
-
-  displaced_step_inferior_states.remove_if
-    ([inf] (displaced_step_inferior_state *state)
-      {
-       if (state->inf == inf)
-         {
-           xfree (state);
-           return true;
-         }
-       else
-         return false;
-      });
-}
-

 static void
 infrun_inferior_exit (struct inferior *inf)
 {
 static void
 infrun_inferior_exit (struct inferior *inf)
 {

-  remove_displaced_stepping_state (inf);
+  inf->displaced_step_state.reset ();

 }
 
 /* If ON, and the architecture supports it, GDB will use displaced
 }
 
 /* If ON, and the architecture supports it, GDB will use displaced


@@ -1677,17 +1565,15 @@ use_displaced_stepping (struct thread_info *tp)
 {
   struct regcache *regcache = get_thread_regcache (tp);
   struct gdbarch *gdbarch = regcache->arch ();
 {
   struct regcache *regcache = get_thread_regcache (tp);
   struct gdbarch *gdbarch = regcache->arch ();

-  struct displaced_step_inferior_state *displaced_state;
-
-  displaced_state = get_displaced_stepping_state (tp->inf);
+  displaced_step_inferior_state *displaced_state
+    = get_displaced_stepping_state (tp->inf);

 
   return (((can_use_displaced_stepping == AUTO_BOOLEAN_AUTO
            && target_is_non_stop_p ())
           || can_use_displaced_stepping == AUTO_BOOLEAN_TRUE)
          && gdbarch_displaced_step_copy_insn_p (gdbarch)
          && find_record_target () == NULL
 
   return (((can_use_displaced_stepping == AUTO_BOOLEAN_AUTO
            && target_is_non_stop_p ())
           || can_use_displaced_stepping == AUTO_BOOLEAN_TRUE)
          && gdbarch_displaced_step_copy_insn_p (gdbarch)
          && find_record_target () == NULL

-         && (displaced_state == NULL
-             || !displaced_state->failed_before));
+         && !displaced_state->failed_before);

 }
 
 /* Clean out any stray displaced stepping state.  */
 }
 
 /* Clean out any stray displaced stepping state.  */


@@ -1701,14 +1587,9 @@ displaced_step_clear (struct displaced_step_inferior_state *displaced)
   displaced->step_closure = NULL;
 }
 
   displaced->step_closure = NULL;
 }
 

-static void
-displaced_step_clear_cleanup (void *arg)
-{
-  struct displaced_step_inferior_state *state
-    = (struct displaced_step_inferior_state *) arg;
-
-  displaced_step_clear (state);
-}
+/* A cleanup that wraps displaced_step_clear.  */
+using displaced_step_clear_cleanup
+  = FORWARD_SCOPE_EXIT (displaced_step_clear);

 
 /* Dump LEN bytes at BUF in hex to FILE, followed by a newline.  */
 void
 
 /* Dump LEN bytes at BUF in hex to FILE, followed by a newline.  */
 void


@@ -1742,14 +1623,12 @@ displaced_step_dump_bytes (struct ui_file *file,
 static int
 displaced_step_prepare_throw (thread_info *tp)
 {
 static int
 displaced_step_prepare_throw (thread_info *tp)
 {

-  struct cleanup *ignore_cleanups;

   regcache *regcache = get_thread_regcache (tp);
   struct gdbarch *gdbarch = regcache->arch ();
   const address_space *aspace = regcache->aspace ();
   CORE_ADDR original, copy;
   ULONGEST len;
   struct displaced_step_closure *closure;
   regcache *regcache = get_thread_regcache (tp);
   struct gdbarch *gdbarch = regcache->arch ();
   const address_space *aspace = regcache->aspace ();
   CORE_ADDR original, copy;
   ULONGEST len;
   struct displaced_step_closure *closure;

-  struct displaced_step_inferior_state *displaced;

   int status;
 
   /* We should never reach this function if the architecture does not
   int status;
 
   /* We should never reach this function if the architecture does not


@@ -1768,7 +1647,8 @@ displaced_step_prepare_throw (thread_info *tp)
   /* We have to displaced step one thread at a time, as we only have
      access to a single scratch space per inferior.  */
 
   /* We have to displaced step one thread at a time, as we only have
      access to a single scratch space per inferior.  */
 

-  displaced = add_displaced_stepping_state (tp->inf);
+  displaced_step_inferior_state *displaced
+    = get_displaced_stepping_state (tp->inf);

 
   if (displaced->step_thread != nullptr)
     {
 
   if (displaced->step_thread != nullptr)
     {


@@ -1778,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;


@@ -1788,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);


@@ -1824,10 +1704,8 @@ displaced_step_prepare_throw (thread_info *tp)
     }
 
   /* Save the original contents of the copy area.  */
     }
 
   /* Save the original contents of the copy area.  */

-  displaced->step_saved_copy = (gdb_byte *) xmalloc (len);
-  ignore_cleanups = make_cleanup (free_current_contents,
-                                 &displaced->step_saved_copy);
-  status = target_read_memory (copy, displaced->step_saved_copy, len);
+  displaced->step_saved_copy.resize (len);
+  status = target_read_memory (copy, displaced->step_saved_copy.data (), len);

   if (status != 0)
     throw_error (MEMORY_ERROR,
                 _("Error accessing memory address %s (%s) for "
   if (status != 0)
     throw_error (MEMORY_ERROR,
                 _("Error accessing memory address %s (%s) for "


@@ -1838,7 +1716,7 @@ displaced_step_prepare_throw (thread_info *tp)
       fprintf_unfiltered (gdb_stdlog, "displaced: saved %s: ",
                          paddress (gdbarch, copy));
       displaced_step_dump_bytes (gdb_stdlog,
       fprintf_unfiltered (gdb_stdlog, "displaced: saved %s: ",
                          paddress (gdbarch, copy));
       displaced_step_dump_bytes (gdb_stdlog,

-                                displaced->step_saved_copy,
+                                displaced->step_saved_copy.data (),

                                 len);
     };
 
                                 len);
     };
 


@@ -1849,7 +1727,6 @@ displaced_step_prepare_throw (thread_info *tp)
       /* The architecture doesn't know how or want to displaced step
         this instruction or instruction sequence.  Fallback to
         stepping over the breakpoint in-line.  */
       /* The architecture doesn't know how or want to displaced step
         this instruction or instruction sequence.  Fallback to
         stepping over the breakpoint in-line.  */

-      do_cleanups (ignore_cleanups);

       return -1;
     }
 
       return -1;
     }
 


@@ -1861,12 +1738,14 @@ displaced_step_prepare_throw (thread_info *tp)
   displaced->step_original = original;
   displaced->step_copy = copy;
 
   displaced->step_original = original;
   displaced->step_copy = copy;
 

-  make_cleanup (displaced_step_clear_cleanup, displaced);
+  {
+    displaced_step_clear_cleanup cleanup (displaced);

 
 

-  /* Resume execution at the copy.  */
-  regcache_write_pc (regcache, copy);
+    /* Resume execution at the copy.  */
+    regcache_write_pc (regcache, copy);

 
 

-  discard_cleanups (ignore_cleanups);
+    cleanup.release ();
+  }

 
   if (debug_displaced)
     fprintf_unfiltered (gdb_stdlog, "displaced: displaced pc to %s\n",
 
   if (debug_displaced)
     fprintf_unfiltered (gdb_stdlog, "displaced: displaced pc to %s\n",


@@ -1883,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


@@ -1907,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.  */


@@ -1915,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;
 }


@@ -1939,10 +1817,10 @@ displaced_step_restore (struct displaced_step_inferior_state *displaced,
   ULONGEST len = gdbarch_max_insn_length (displaced->step_gdbarch);
 
   write_memory_ptid (ptid, displaced->step_copy,
   ULONGEST len = gdbarch_max_insn_length (displaced->step_gdbarch);
 
   write_memory_ptid (ptid, displaced->step_copy,

-                    displaced->step_saved_copy, len);
+                    displaced->step_saved_copy.data (), len);

   if (debug_displaced)
     fprintf_unfiltered (gdb_stdlog, "displaced: restored %s %s\n",
   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));
 }


@@ -1956,20 +1834,15 @@ displaced_step_restore (struct displaced_step_inferior_state *displaced,
 static int
 displaced_step_fixup (thread_info *event_thread, enum gdb_signal signal)
 {
 static int
 displaced_step_fixup (thread_info *event_thread, enum gdb_signal signal)
 {

-  struct cleanup *old_cleanups;

   struct displaced_step_inferior_state *displaced
     = get_displaced_stepping_state (event_thread->inf);
   int ret;
 
   struct displaced_step_inferior_state *displaced
     = get_displaced_stepping_state (event_thread->inf);
   int ret;
 

-  /* Was any thread of this process doing a displaced step?  */
-  if (displaced == NULL)
-    return 0;
-

   /* Was this event for the thread we displaced?  */
   if (displaced->step_thread != event_thread)
     return 0;
 
   /* Was this event for the thread we displaced?  */
   if (displaced->step_thread != event_thread)
     return 0;
 

-  old_cleanups = make_cleanup (displaced_step_clear_cleanup, displaced);
+  displaced_step_clear_cleanup cleanup (displaced);

 
   displaced_step_restore (displaced, displaced->step_thread->ptid);
 
 
   displaced_step_restore (displaced, displaced->step_thread->ptid);
 


@@ -2004,10 +1877,6 @@ displaced_step_fixup (thread_info *event_thread, enum gdb_signal signal)
       ret = -1;
     }
 
       ret = -1;
     }
 

-  do_cleanups (old_cleanups);
-
-  displaced->step_thread = nullptr;
-

   return ret;
 }
 
   return ret;
 }
 


@@ -2105,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);


@@ -2114,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


@@ -2209,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.


@@ -2328,9 +2197,9 @@ do_target_resume (ptid_t resume_ptid, int step, enum gdb_signal sig)
        valid.  */
   if (step_over_info_valid_p ()
       || displaced_step_in_progress (tp->inf))
        valid.  */
   if (step_over_info_valid_p ()
       || displaced_step_in_progress (tp->inf))

-    target_pass_signals (0, NULL);
+    target_pass_signals ({});

   else
   else

-    target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
+    target_pass_signals (signal_pass);

 
   target_resume (resume_ptid, step, sig);
 
 
   target_resume (resume_ptid, step, sig);
 


@@ -2373,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));
        }
 


@@ -2385,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;


@@ -2429,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


@@ -2678,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;
 


@@ -2726,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


@@ -2739,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


@@ -2783,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.  */


@@ -2796,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;


@@ -2810,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));
        }
     }


@@ -2820,7 +2691,7 @@ clear_proceed_status_thread (struct thread_info *tp)
   if (!signal_pass_state (tp->suspend.stop_signal))
     tp->suspend.stop_signal = GDB_SIGNAL_0;
 
   if (!signal_pass_state (tp->suspend.stop_signal))
     tp->suspend.stop_signal = GDB_SIGNAL_0;
 

-  thread_fsm_delete (tp->thread_fsm);
+  delete tp->thread_fsm;

   tp->thread_fsm = NULL;
 
   tp->control.trap_expected = 0;
   tp->thread_fsm = NULL;
 
   tp->control.trap_expected = 0;


@@ -2858,21 +2729,14 @@ clear_proceed_status (int step)
                                     execution_direction))
     target_record_stop_replaying ();
 
                                     execution_direction))
     target_record_stop_replaying ();
 

-  if (!non_stop)
+  if (!non_stop && inferior_ptid != null_ptid)

     {
     {

-      struct thread_info *tp;
-      ptid_t resume_ptid;
-
-      resume_ptid = user_visible_resume_ptid (step);
+      ptid_t resume_ptid = user_visible_resume_ptid (step);

 
       /* In all-stop mode, delete the per-thread status of all threads
         we're about to resume, implicitly and explicitly.  */
 
       /* In all-stop mode, delete the per-thread status of all threads
         we're about to resume, implicitly and explicitly.  */

-      ALL_NON_EXITED_THREADS (tp)
-        {
-         if (!tp->ptid.matches (resume_ptid))
-           continue;
-         clear_proceed_status_thread (tp);
-       }
+      for (thread_info *tp : all_non_exited_threads (resume_ptid))
+       clear_proceed_status_thread (tp);

     }
 
   if (inferior_ptid != null_ptid)
     }
 
   if (inferior_ptid != null_ptid)


@@ -2961,7 +2825,6 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal)
 {
   struct regcache *regcache;
   struct gdbarch *gdbarch;
 {
   struct regcache *regcache;
   struct gdbarch *gdbarch;

-  struct thread_info *tp;

   CORE_ADDR pc;
   ptid_t resume_ptid;
   struct execution_control_state ecss;
   CORE_ADDR pc;
   ptid_t resume_ptid;
   struct execution_control_state ecss;


@@ -2988,16 +2851,16 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal)
   const address_space *aspace = regcache->aspace ();
 
   pc = regcache_read_pc (regcache);
   const address_space *aspace = regcache->aspace ();
 
   pc = regcache_read_pc (regcache);

-  tp = inferior_thread ();
+  thread_info *cur_thr = inferior_thread ();

 
   /* Fill in with reasonable starting values.  */
 
   /* Fill in with reasonable starting values.  */

-  init_thread_stepping_state (tp);
+  init_thread_stepping_state (cur_thr);

 
 

-  gdb_assert (!thread_is_in_step_over_chain (tp));
+  gdb_assert (!thread_is_in_step_over_chain (cur_thr));

 
   if (addr == (CORE_ADDR) -1)
     {
 
   if (addr == (CORE_ADDR) -1)
     {

-      if (pc == tp->suspend.stop_pc
+      if (pc == cur_thr->suspend.stop_pc

          && breakpoint_here_p (aspace, pc) == ordinary_breakpoint_here
          && execution_direction != EXEC_REVERSE)
        /* There is a breakpoint at the address we will resume at,
          && breakpoint_here_p (aspace, pc) == ordinary_breakpoint_here
          && execution_direction != EXEC_REVERSE)
        /* There is a breakpoint at the address we will resume at,


@@ -3008,13 +2871,13 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal)
           Note, we don't do this in reverse, because we won't
           actually be executing the breakpoint insn anyway.
           We'll be (un-)executing the previous instruction.  */
           Note, we don't do this in reverse, because we won't
           actually be executing the breakpoint insn anyway.
           We'll be (un-)executing the previous instruction.  */

-       tp->stepping_over_breakpoint = 1;
+       cur_thr->stepping_over_breakpoint = 1;

       else if (gdbarch_single_step_through_delay_p (gdbarch)
               && gdbarch_single_step_through_delay (gdbarch,
                                                     get_current_frame ()))
        /* We stepped onto an instruction that needs to be stepped
           again before re-inserting the breakpoint, do so.  */
       else if (gdbarch_single_step_through_delay_p (gdbarch)
               && gdbarch_single_step_through_delay (gdbarch,
                                                     get_current_frame ()))
        /* We stepped onto an instruction that needs to be stepped
           again before re-inserting the breakpoint, do so.  */

-       tp->stepping_over_breakpoint = 1;
+       cur_thr->stepping_over_breakpoint = 1;

     }
   else
     {
     }
   else
     {


@@ -3022,9 +2885,9 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal)
     }
 
   if (siggnal != GDB_SIGNAL_DEFAULT)
     }
 
   if (siggnal != GDB_SIGNAL_DEFAULT)

-    tp->suspend.stop_signal = siggnal;
+    cur_thr->suspend.stop_signal = siggnal;

 
 

-  resume_ptid = user_visible_resume_ptid (tp->control.stepping_command);
+  resume_ptid = user_visible_resume_ptid (cur_thr->control.stepping_command);

 
   /* If an exception is thrown from this point on, make sure to
      propagate GDB's knowledge of the executing state to the
 
   /* If an exception is thrown from this point on, make sure to
      propagate GDB's knowledge of the executing state to the


@@ -3037,7 +2900,7 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal)
      threads in RESUME_PTID are now running.  Unless we're calling an
      inferior function, as in that case we pretend the inferior
      doesn't run at all.  */
      threads in RESUME_PTID are now running.  Unless we're calling an
      inferior function, as in that case we pretend the inferior
      doesn't run at all.  */

-  if (!tp->control.in_infcall)
+  if (!cur_thr->control.in_infcall)

    set_running (resume_ptid, 1);
 
   if (debug_infrun)
    set_running (resume_ptid, 1);
 
   if (debug_infrun)


@@ -3071,19 +2934,15 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal)
 
   /* If scheduler locking applies, we can avoid iterating over all
      threads.  */
 
   /* If scheduler locking applies, we can avoid iterating over all
      threads.  */

-  if (!non_stop && !schedlock_applies (tp))
+  if (!non_stop && !schedlock_applies (cur_thr))

     {
     {

-      struct thread_info *current = tp;
+      for (thread_info *tp : all_non_exited_threads (resume_ptid))
+       {
+         switch_to_thread_no_regs (tp);

 
 

-      ALL_NON_EXITED_THREADS (tp)
-        {

          /* Ignore the current thread here.  It's handled
             afterwards.  */
          /* Ignore the current thread here.  It's handled
             afterwards.  */

-         if (tp == current)
-           continue;
-
-         /* Ignore threads of processes we're not resuming.  */
-         if (!tp->ptid.matches (resume_ptid))
+         if (tp == cur_thr)

            continue;
 
          if (!thread_still_needs_step_over (tp))
            continue;
 
          if (!thread_still_needs_step_over (tp))


@@ -3094,25 +2953,25 @@ 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);
        }
 

-      tp = current;
+      switch_to_thread (cur_thr);

     }
 
   /* Enqueue the current thread last, so that we move all other
      threads over their breakpoints first.  */
     }
 
   /* Enqueue the current thread last, so that we move all other
      threads over their breakpoints first.  */

-  if (tp->stepping_over_breakpoint)
-    thread_step_over_chain_enqueue (tp);
+  if (cur_thr->stepping_over_breakpoint)
+    thread_step_over_chain_enqueue (cur_thr);

 
   /* If the thread isn't started, we'll still need to set its prev_pc,
      so that switch_back_to_stepped_thread knows the thread hasn't
      advanced.  Must do this before resuming any thread, as in
      all-stop/remote, once we resume we can't send any other packet
      until the target stops again.  */
 
   /* If the thread isn't started, we'll still need to set its prev_pc,
      so that switch_back_to_stepped_thread knows the thread hasn't
      advanced.  Must do this before resuming any thread, as in
      all-stop/remote, once we resume we can't send any other packet
      until the target stops again.  */

-  tp->prev_pc = regcache_read_pc (regcache);
+  cur_thr->prev_pc = regcache_read_pc (regcache);

 
   {
     scoped_restore save_defer_tc = make_scoped_defer_target_commit_resume ();
 
   {
     scoped_restore save_defer_tc = make_scoped_defer_target_commit_resume ();


@@ -3134,18 +2993,16 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal)
       {
        /* In all-stop, but the target is always in non-stop mode.
           Start all other threads that are implicitly resumed too.  */
       {
        /* In all-stop, but the target is always in non-stop mode.
           Start all other threads that are implicitly resumed too.  */

-       ALL_NON_EXITED_THREADS (tp)
+      for (thread_info *tp : all_non_exited_threads (resume_ptid))

         {
         {

-         /* Ignore threads of processes we're not resuming.  */
-         if (!tp->ptid.matches (resume_ptid))
-           continue;
+         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;
            }


@@ -3155,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);


@@ -3171,11 +3028,11 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal)
            error (_("Command aborted."));
        }
       }
            error (_("Command aborted."));
        }
       }

-    else if (!tp->resumed && !thread_is_in_step_over_chain (tp))
+    else if (!cur_thr->resumed && !thread_is_in_step_over_chain (cur_thr))

       {
        /* The thread wasn't started, and isn't queued, run it now.  */
       {
        /* The thread wasn't started, and isn't queued, run it now.  */

-       reset_ecs (ecs, tp);
-       switch_to_thread (tp);
+       reset_ecs (ecs, cur_thr);
+       switch_to_thread (cur_thr);

        keep_going_pass_signal (ecs);
        if (!ecs->wait_some_more)
          error (_("Command aborted."));
        keep_going_pass_signal (ecs);
        if (!ecs->wait_some_more)
          error (_("Command aborted."));


@@ -3186,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.  */


@@ -3239,12 +3101,9 @@ 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;

-
-  /* Discard any skipped inlined frames.  */
-  clear_inline_frame_state (minus_one_ptid);

 }
 
 \f
 }
 
 \f


@@ -3272,53 +3131,50 @@ static int switch_back_to_stepped_thread (struct execution_control_state *ecs);
 static void
 infrun_thread_stop_requested (ptid_t ptid)
 {
 static void
 infrun_thread_stop_requested (ptid_t ptid)
 {

-  struct thread_info *tp;
-

   /* PTID was requested to stop.  If the thread was already stopped,
      but the user/frontend doesn't know about that yet (e.g., the
      thread had been temporarily paused for some step-over), set up
      for reporting the stop now.  */
   /* PTID was requested to stop.  If the thread was already stopped,
      but the user/frontend doesn't know about that yet (e.g., the
      thread had been temporarily paused for some step-over), set up
      for reporting the stop now.  */

-  ALL_NON_EXITED_THREADS (tp)
-    if (tp->ptid.matches (ptid))
-      {
-       if (tp->state != THREAD_RUNNING)
-         continue;
-       if (tp->executing)
-         continue;
+  for (thread_info *tp : all_threads (ptid))
+    {
+      if (tp->state != THREAD_RUNNING)
+       continue;
+      if (tp->executing)
+       continue;

 
 

-       /* Remove matching threads from the step-over queue, so
-          start_step_over doesn't try to resume them
-          automatically.  */
-       if (thread_is_in_step_over_chain (tp))
-         thread_step_over_chain_remove (tp);
-
-       /* If the thread is stopped, but the user/frontend doesn't
-          know about that yet, queue a pending event, as if the
-          thread had just stopped now.  Unless the thread already had
-          a pending event.  */
-       if (!tp->suspend.waitstatus_pending_p)
-         {
-           tp->suspend.waitstatus_pending_p = 1;
-           tp->suspend.waitstatus.kind = TARGET_WAITKIND_STOPPED;
-           tp->suspend.waitstatus.value.sig = GDB_SIGNAL_0;
-         }
+      /* Remove matching threads from the step-over queue, so
+        start_step_over doesn't try to resume them
+        automatically.  */
+      if (thread_is_in_step_over_chain (tp))
+       thread_step_over_chain_remove (tp);
+
+      /* If the thread is stopped, but the user/frontend doesn't
+        know about that yet, queue a pending event, as if the
+        thread had just stopped now.  Unless the thread already had
+        a pending event.  */
+      if (!tp->suspend.waitstatus_pending_p)
+       {
+         tp->suspend.waitstatus_pending_p = 1;
+         tp->suspend.waitstatus.kind = TARGET_WAITKIND_STOPPED;
+         tp->suspend.waitstatus.value.sig = GDB_SIGNAL_0;
+       }

 
 

-       /* Clear the inline-frame state, since we're re-processing the
-          stop.  */
-       clear_inline_frame_state (tp->ptid);
+      /* Clear the inline-frame state, since we're re-processing the
+        stop.  */
+      clear_inline_frame_state (tp->ptid);

 
 

-       /* If this thread was paused because some other thread was
-          doing an inline-step over, let that finish first.  Once
-          that happens, we'll restart all threads and consume pending
-          stop events then.  */
-       if (step_over_info_valid_p ())
-         continue;
+      /* If this thread was paused because some other thread was
+        doing an inline-step over, let that finish first.  Once
+        that happens, we'll restart all threads and consume pending
+        stop events then.  */
+      if (step_over_info_valid_p ())
+       continue;

 
 

-       /* Otherwise we can process the (new) pending event now.  Set
-          it so this pending event is considered by
-          do_target_wait.  */
-       tp->resumed = 1;
-      }
+      /* Otherwise we can process the (new) pending event now.  Set
+        it so this pending event is considered by
+        do_target_wait.  */
+      tp->resumed = 1;
+    }

 }
 
 static void
 }
 
 static void


@@ -3359,13 +3215,9 @@ for_each_just_stopped_thread (for_each_just_stopped_thread_callback_func func)
     }
   else
     {
     }
   else
     {

-      struct thread_info *tp;
-

       /* In all-stop mode, all threads have stopped.  */
       /* In all-stop mode, all threads have stopped.  */

-      ALL_NON_EXITED_THREADS (tp)
-        {
-         func (tp);
-       }
+      for (thread_info *tp : all_non_exited_threads ())
+       func (tp);

     }
 }
 
     }
 }
 


@@ -3387,14 +3239,6 @@ delete_just_stopped_threads_single_step_breakpoints (void)
   for_each_just_stopped_thread (delete_single_step_breakpoints);
 }
 
   for_each_just_stopped_thread (delete_single_step_breakpoints);
 }
 

-/* A cleanup wrapper.  */
-
-static void
-delete_just_stopped_threads_infrun_breakpoints_cleanup (void *arg)
-{
-  delete_just_stopped_threads_infrun_breakpoints ();
-}
-

 /* See infrun.h.  */
 
 void
 /* See infrun.h.  */
 
 void


@@ -3414,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


@@ -3434,24 +3278,26 @@ print_target_wait_results (ptid_t waiton_ptid, ptid_t result_ptid,
 static struct thread_info *
 random_pending_event_thread (ptid_t waiton_ptid)
 {
 static struct thread_info *
 random_pending_event_thread (ptid_t waiton_ptid)
 {

-  struct thread_info *event_tp;

   int num_events = 0;
   int num_events = 0;

-  int random_selector;
+
+  auto has_event = [] (thread_info *tp)
+    {
+      return (tp->resumed
+             && tp->suspend.waitstatus_pending_p);
+    };

 
   /* First see how many events we have.  Count only resumed threads
      that have an event pending.  */
 
   /* First see how many events we have.  Count only resumed threads
      that have an event pending.  */

-  ALL_NON_EXITED_THREADS (event_tp)
-    if (event_tp->ptid.matches (waiton_ptid)
-       && event_tp->resumed
-       && event_tp->suspend.waitstatus_pending_p)
+  for (thread_info *tp : all_non_exited_threads (waiton_ptid))
+    if (has_event (tp))

       num_events++;
 
   if (num_events == 0)
     return NULL;
 
   /* Now randomly pick a thread out of those that have had events.  */
       num_events++;
 
   if (num_events == 0)
     return NULL;
 
   /* Now randomly pick a thread out of those that have had events.  */

-  random_selector = (int)
-    ((num_events * (double) rand ()) / (RAND_MAX + 1.0));
+  int random_selector = (int) ((num_events * (double) rand ())
+                              / (RAND_MAX + 1.0));

 
   if (debug_infrun && num_events > 1)
     fprintf_unfiltered (gdb_stdlog,
 
   if (debug_infrun && num_events > 1)
     fprintf_unfiltered (gdb_stdlog,


@@ -3459,14 +3305,12 @@ random_pending_event_thread (ptid_t waiton_ptid)
                        num_events, random_selector);
 
   /* Select the Nth thread that has had an event.  */
                        num_events, random_selector);
 
   /* Select the Nth thread that has had an event.  */

-  ALL_NON_EXITED_THREADS (event_tp)
-    if (event_tp->ptid.matches (waiton_ptid)
-       && event_tp->resumed
-       && event_tp->suspend.waitstatus_pending_p)
+  for (thread_info *tp : all_non_exited_threads (waiton_ptid))
+    if (has_event (tp))

       if (random_selector-- == 0)
       if (random_selector-- == 0)

-       break;
+       return tp;

 
 

-  return event_tp;
+  gdb_assert_not_reached ("event thread not found");

 }
 
 /* Wrapper for target_wait that first checks whether threads have
 }
 
 /* Wrapper for target_wait that first checks whether threads have


@@ -3490,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);


@@ -3515,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;


@@ -3525,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;


@@ -3536,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;


@@ -3553,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


@@ -3615,7 +3459,7 @@ prepare_for_detach (void)
 
   /* Is any thread of this process displaced stepping?  If not,
      there's nothing else to do.  */
 
   /* Is any thread of this process displaced stepping?  If not,
      there's nothing else to do.  */

-  if (displaced == NULL || displaced->step_thread == nullptr)
+  if (displaced->step_thread == nullptr)

     return;
 
   if (debug_infrun)
     return;
 
   if (debug_infrun)


@@ -3678,15 +3522,11 @@ prepare_for_detach (void)
 void
 wait_for_inferior (void)
 {
 void
 wait_for_inferior (void)
 {

-  struct cleanup *old_cleanups;
-

   if (debug_infrun)
     fprintf_unfiltered
       (gdb_stdlog, "infrun: wait_for_inferior ()\n");
 
   if (debug_infrun)
     fprintf_unfiltered
       (gdb_stdlog, "infrun: wait_for_inferior ()\n");
 

-  old_cleanups
-    = make_cleanup (delete_just_stopped_threads_infrun_breakpoints_cleanup,
-                   NULL);
+  SCOPE_EXIT { delete_just_stopped_threads_infrun_breakpoints (); };

 
   /* If an error happens while handling the event, propagate GDB's
      knowledge of the executing state to the frontend/user running
 
   /* If an error happens while handling the event, propagate GDB's
      knowledge of the executing state to the frontend/user running


@@ -3723,8 +3563,6 @@ wait_for_inferior (void)
 
   /* No error, don't finish the state yet.  */
   finish_state.release ();
 
   /* No error, don't finish the state yet.  */
   finish_state.release ();

-
-  do_cleanups (old_cleanups);

 }
 
 /* Cleanup that reinstalls the readline callback handler, if the
 }
 
 /* Cleanup that reinstalls the readline callback handler, if the


@@ -3738,7 +3576,7 @@ wait_for_inferior (void)
    input.  */
 
 static void
    input.  */
 
 static void

-reinstall_readline_callback_handler_cleanup (void *arg)
+reinstall_readline_callback_handler_cleanup ()

 {
   struct ui *ui = current_ui;
 
 {
   struct ui *ui = current_ui;
 


@@ -3762,14 +3600,13 @@ reinstall_readline_callback_handler_cleanup (void *arg)
 static void
 clean_up_just_stopped_threads_fsms (struct execution_control_state *ecs)
 {
 static void
 clean_up_just_stopped_threads_fsms (struct execution_control_state *ecs)
 {

-  struct thread_info *thr = ecs->event_thread;
-
-  if (thr != NULL && thr->thread_fsm != NULL)
-    thread_fsm_clean_up (thr->thread_fsm, thr);
+  if (ecs->event_thread != NULL
+      && ecs->event_thread->thread_fsm != NULL)
+    ecs->event_thread->thread_fsm->clean_up (ecs->event_thread);

 
   if (!non_stop)
     {
 
   if (!non_stop)
     {

-      ALL_NON_EXITED_THREADS (thr)
+      for (thread_info *thr : all_non_exited_threads ())

         {
          if (thr->thread_fsm == NULL)
            continue;
         {
          if (thr->thread_fsm == NULL)
            continue;


@@ -3777,7 +3614,7 @@ clean_up_just_stopped_threads_fsms (struct execution_control_state *ecs)
            continue;
 
          switch_to_thread (thr);
            continue;
 
          switch_to_thread (thr);

-         thread_fsm_clean_up (thr->thread_fsm, thr);
+         thr->thread_fsm->clean_up (thr);

        }
 
       if (ecs->event_thread != NULL)
        }
 
       if (ecs->event_thread != NULL)


@@ -3840,7 +3677,6 @@ fetch_inferior_event (void *client_data)
 {
   struct execution_control_state ecss;
   struct execution_control_state *ecs = &ecss;
 {
   struct execution_control_state ecss;
   struct execution_control_state *ecs = &ecss;

-  struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);

   int cmd_done = 0;
   ptid_t waiton_ptid = minus_one_ptid;
 
   int cmd_done = 0;
   ptid_t waiton_ptid = minus_one_ptid;
 


@@ -3852,114 +3688,126 @@ fetch_inferior_event (void *client_data)
   scoped_restore save_ui = make_scoped_restore (&current_ui, main_ui);
 
   /* End up with readline processing input, if necessary.  */
   scoped_restore save_ui = make_scoped_restore (&current_ui, main_ui);
 
   /* End up with readline processing input, if necessary.  */

-  make_cleanup (reinstall_readline_callback_handler_cleanup, NULL);
-
-  /* We're handling a live event, so make sure we're doing live
-     debugging.  If we're looking at traceframes while the target is
-     running, we're going to need to get back to that mode after
-     handling the event.  */
-  gdb::optional<scoped_restore_current_traceframe> maybe_restore_traceframe;
-  if (non_stop)
-    {
-      maybe_restore_traceframe.emplace ();
-      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 ();
-
-  overlay_cache_invalid = 1;
-  /* Flush target cache before starting to handle each event.  Target
-     was running and cache could be stale.  This is just a heuristic.
-     Running threads may modify target memory, but we don't get any
-     event.  */
-  target_dcache_invalidate ();
-
-  scoped_restore save_exec_dir
-    = make_scoped_restore (&execution_direction, target_execution_direction ());
-
-  ecs->ptid = do_target_wait (waiton_ptid, &ecs->ws,
-                             target_can_async_p () ? TARGET_WNOHANG : 0);
-
-  if (debug_infrun)
-    print_target_wait_results (waiton_ptid, ecs->ptid, &ecs->ws);
-
-  /* If an error happens while handling the event, propagate GDB's
-     knowledge of the executing state to the frontend/user running
-     state.  */
-  ptid_t finish_ptid = !target_is_non_stop_p () ? minus_one_ptid : ecs->ptid;
-  scoped_finish_thread_state finish_state (finish_ptid);
-
-  /* Get executed before make_cleanup_restore_current_thread above to apply
-     still for the thread which has thrown the exception.  */
-  struct cleanup *ts_old_chain = make_bpstat_clear_actions_cleanup ();
-
-  make_cleanup (delete_just_stopped_threads_infrun_breakpoints_cleanup, NULL);
+  {
+    SCOPE_EXIT { reinstall_readline_callback_handler_cleanup (); };
+
+    /* We're handling a live event, so make sure we're doing live
+       debugging.  If we're looking at traceframes while the target is
+       running, we're going to need to get back to that mode after
+       handling the event.  */
+    gdb::optional<scoped_restore_current_traceframe> maybe_restore_traceframe;
+    if (non_stop)
+      {
+       maybe_restore_traceframe.emplace ();
+       set_current_traceframe (-1);
+      }

 
 

-  /* Now figure out what to do with the result of the result.  */
-  handle_inferior_event (ecs);
+    /* 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
+       was running and cache could be stale.  This is just a heuristic.
+       Running threads may modify target memory, but we don't get any
+       event.  */
+    target_dcache_invalidate ();
+
+    scoped_restore save_exec_dir
+      = make_scoped_restore (&execution_direction,
+                            target_execution_direction ());
+
+    ecs->ptid = do_target_wait (waiton_ptid, &ecs->ws,
+                               target_can_async_p () ? TARGET_WNOHANG : 0);
+
+    if (debug_infrun)
+      print_target_wait_results (waiton_ptid, ecs->ptid, &ecs->ws);
+
+    /* If an error happens while handling the event, propagate GDB's
+       knowledge of the executing state to the frontend/user running
+       state.  */
+    ptid_t finish_ptid = !target_is_non_stop_p () ? minus_one_ptid : ecs->ptid;
+    scoped_finish_thread_state finish_state (finish_ptid);
+
+    /* Get executed before scoped_restore_current_thread above to apply
+       still for the thread which has thrown the exception.  */
+    auto defer_bpstat_clear
+      = make_scope_exit (bpstat_clear_actions);
+    auto defer_delete_threads
+      = make_scope_exit (delete_just_stopped_threads_infrun_breakpoints);
+
+    /* Now figure out what to do with the result of the result.  */
+    handle_inferior_event (ecs);
+
+    if (!ecs->wait_some_more)
+      {
+       struct inferior *inf = find_inferior_ptid (ecs->ptid);
+       int should_stop = 1;
+       struct thread_info *thr = ecs->event_thread;

 
 

-  if (!ecs->wait_some_more)
-    {
-      struct inferior *inf = find_inferior_ptid (ecs->ptid);
-      int should_stop = 1;
-      struct thread_info *thr = ecs->event_thread;
+       delete_just_stopped_threads_infrun_breakpoints ();

 
 

-      delete_just_stopped_threads_infrun_breakpoints ();
+       if (thr != NULL)
+         {
+           struct thread_fsm *thread_fsm = thr->thread_fsm;

 
 

-      if (thr != NULL)
-       {
-         struct thread_fsm *thread_fsm = thr->thread_fsm;
+           if (thread_fsm != NULL)
+             should_stop = thread_fsm->should_stop (thr);
+         }

 
 

-         if (thread_fsm != NULL)
-           should_stop = thread_fsm_should_stop (thread_fsm, thr);
-       }
+       if (!should_stop)
+         {
+           keep_going (ecs);
+         }
+       else
+         {
+           bool should_notify_stop = true;
+           int proceeded = 0;

 
 

-      if (!should_stop)
-       {
-         keep_going (ecs);
-       }
-      else
-       {
-         int should_notify_stop = 1;
-         int proceeded = 0;
+           clean_up_just_stopped_threads_fsms (ecs);

 
 

-         clean_up_just_stopped_threads_fsms (ecs);
+           if (thr != NULL && thr->thread_fsm != NULL)
+             should_notify_stop = thr->thread_fsm->should_notify_stop ();

 
 

-         if (thr != NULL && thr->thread_fsm != NULL)
-           {
-             should_notify_stop
-               = thread_fsm_should_notify_stop (thr->thread_fsm);
-           }
+           if (should_notify_stop)
+             {
+               /* We may not find an inferior if this was a process exit.  */
+               if (inf == NULL || inf->control.stop_soon == NO_STOP_QUIETLY)
+                 proceeded = normal_stop ();
+             }

 
 

-         if (should_notify_stop)
-           {
-             /* We may not find an inferior if this was a process exit.  */
-             if (inf == NULL || inf->control.stop_soon == NO_STOP_QUIETLY)
-               proceeded = normal_stop ();
-           }
+           if (!proceeded)
+             {
+               inferior_event_handler (INF_EXEC_COMPLETE, NULL);
+               cmd_done = 1;
+             }

 
 

-         if (!proceeded)
-           {
-             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 ();
+         }
+      }

 
 

-  discard_cleanups (ts_old_chain);
+    defer_delete_threads.release ();
+    defer_bpstat_clear.release ();

 
 

-  /* No error, don't finish the thread states yet.  */
-  finish_state.release ();
+    /* No error, don't finish the thread states yet.  */
+    finish_state.release ();

 
 

-  /* Revert thread and frame.  */
-  do_cleanups (old_chain);
+    /* This scope is used to ensure that readline callbacks are
+       reinstalled here.  */
+  }

 
   /* If a UI was in sync execution mode, and now isn't, restore its
      prompt (a synchronous execution command has finished, and we're
 
   /* If a UI was in sync execution mode, and now isn't, restore its
      prompt (a synchronous execution command has finished, and we're


@@ -3997,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)


@@ -4006,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.  */


@@ -4034,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);


@@ -4205,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).  */


@@ -4277,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;
     }


@@ -4424,14 +4330,6 @@ save_waitstatus (struct thread_info *tp, struct target_waitstatus *ws)
     }
 }
 
     }
 }
 

-/* A cleanup that disables thread create/exit events.  */
-
-static void
-disable_thread_events (void *arg)
-{
-  target_thread_events (0);
-}
-

 /* See infrun.h.  */
 
 void
 /* See infrun.h.  */
 
 void


@@ -4440,7 +4338,6 @@ stop_all_threads (void)
   /* We may need multiple passes to discover all threads.  */
   int pass;
   int iterations = 0;
   /* We may need multiple passes to discover all threads.  */
   int pass;
   int iterations = 0;

-  struct cleanup *old_chain;

 
   gdb_assert (target_is_non_stop_p ());
 
 
   gdb_assert (target_is_non_stop_p ());
 


@@ -4450,7 +4347,7 @@ stop_all_threads (void)
   scoped_restore_current_thread restore_thread;
 
   target_thread_events (1);
   scoped_restore_current_thread restore_thread;
 
   target_thread_events (1);

-  old_chain = make_cleanup (disable_thread_events, NULL);
+  SCOPE_EXIT { target_thread_events (0); };

 
   /* Request threads to stop, and then wait for the stops.  Because
      threads we already know about can spawn more threads while we're
 
   /* Request threads to stop, and then wait for the stops.  Because
      threads we already know about can spawn more threads while we're


@@ -4468,13 +4365,12 @@ stop_all_threads (void)
          ptid_t event_ptid;
          struct target_waitstatus ws;
          int need_wait = 0;
          ptid_t event_ptid;
          struct target_waitstatus ws;
          int need_wait = 0;

-         struct thread_info *t;

 
          update_thread_list ();
 
          /* Go through all threads looking for threads that we need
             to tell the target to stop.  */
 
          update_thread_list ();
 
          /* Go through all threads looking for threads that we need
             to tell the target to stop.  */

-         ALL_NON_EXITED_THREADS (t)
+         for (thread_info *t : all_non_exited_threads ())

            {
              if (t->executing)
                {
            {
              if (t->executing)
                {


@@ -4486,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;
                    }


@@ -4496,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)


@@ -4507,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.  */


@@ -4525,30 +4422,25 @@ 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
            {

-             inferior *inf;
-
-             t = find_thread_ptid (event_ptid);
+             thread_info *t = find_thread_ptid (event_ptid);

              if (t == NULL)
                t = add_thread (event_ptid);
 
              if (t == NULL)
                t = add_thread (event_ptid);
 


@@ -4559,7 +4451,7 @@ stop_all_threads (void)
 
              /* This may be the first time we see the inferior report
                 a stop.  */
 
              /* This may be the first time we see the inferior report
                 a stop.  */

-             inf = find_inferior_ptid (event_ptid);
+             inferior *inf = find_inferior_ptid (event_ptid);

              if (inf->needs_setup)
                {
                  switch_to_thread_no_regs (t);
              if (inf->needs_setup)
                {
                  switch_to_thread_no_regs (t);


@@ -4583,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);


@@ -4630,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));
                    }
                }


@@ -4638,8 +4530,6 @@ stop_all_threads (void)
        }
     }
 
        }
     }
 

-  do_cleanups (old_chain);
-

   if (debug_infrun)
     fprintf_unfiltered (gdb_stdlog, "infrun: stop_all_threads done\n");
 }
   if (debug_infrun)
     fprintf_unfiltered (gdb_stdlog, "infrun: stop_all_threads done\n");
 }


@@ -4649,9 +4539,6 @@ stop_all_threads (void)
 static int
 handle_no_resumed (struct execution_control_state *ecs)
 {
 static int
 handle_no_resumed (struct execution_control_state *ecs)
 {

-  struct inferior *inf;
-  struct thread_info *thread;
-

   if (target_can_async_p ())
     {
       struct ui *ui;
   if (target_can_async_p ())
     {
       struct ui *ui;


@@ -4714,7 +4601,7 @@ handle_no_resumed (struct execution_control_state *ecs)
      the synchronous command show "no unwaited-for " to the user.  */
   update_thread_list ();
 
      the synchronous command show "no unwaited-for " to the user.  */
   update_thread_list ();
 

-  ALL_NON_EXITED_THREADS (thread)
+  for (thread_info *thread : all_non_exited_threads ())

     {
       if (thread->executing
          || thread->suspend.waitstatus_pending_p)
     {
       if (thread->executing
          || thread->suspend.waitstatus_pending_p)


@@ -4734,12 +4621,9 @@ handle_no_resumed (struct execution_control_state *ecs)
      process exited meanwhile (thus updating the thread list results
      in an empty thread list).  In this case we know we'll be getting
      a process exit event shortly.  */
      process exited meanwhile (thus updating the thread list results
      in an empty thread list).  In this case we know we'll be getting
      a process exit event shortly.  */

-  ALL_INFERIORS (inf)
+  for (inferior *inf : all_non_exited_inferiors ())

     {
     {

-      if (inf->pid == 0)
-       continue;
-
-      thread = any_live_thread_of_inferior (inf);
+      thread_info *thread = any_live_thread_of_inferior (inf);

       if (thread == NULL)
        {
          if (debug_infrun)
       if (thread == NULL)
        {
          if (debug_infrun)


@@ -4769,10 +4653,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


@@ -4784,16 +4677,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;
     }


@@ -4812,9 +4701,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;


@@ -4907,8 +4793,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


@@ -4986,8 +4870,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);


@@ -4996,8 +4878,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);


@@ -5007,16 +4887,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);


@@ -5081,14 +4951,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);


@@ -5249,10 +5111,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;


@@ -5267,8 +5125,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.


@@ -5317,9 +5173,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);


@@ -5331,22 +5184,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.  */


@@ -5367,22 +5213,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.  */


@@ -5390,20 +5220,20 @@ handle_inferior_event (struct execution_control_state *ecs)
 static void
 restart_threads (struct thread_info *event_thread)
 {
 static void
 restart_threads (struct thread_info *event_thread)
 {

-  struct thread_info *tp;
-

   /* In case the instruction just stepped spawned a new thread.  */
   update_thread_list ();
 
   /* In case the instruction just stepped spawned a new thread.  */
   update_thread_list ();
 

-  ALL_NON_EXITED_THREADS (tp)
+  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;
        }
 


@@ -5413,7 +5243,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;
        }
 


@@ -5422,7 +5252,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;
        }


@@ -5433,7 +5263,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;
        }


@@ -5445,7 +5275,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;
        }


@@ -5460,7 +5290,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))


@@ -5468,7 +5298,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


@@ -5479,7 +5309,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);


@@ -5600,7 +5430,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));
            }
 


@@ -5655,9 +5485,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,


@@ -5763,7 +5592,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;
            }


@@ -5775,7 +5604,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 ());

            }
        }
     }
            }
        }
     }


@@ -6145,7 +5974,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


@@ -6754,7 +6583,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);


@@ -6920,7 +6750,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;


@@ -6954,7 +6791,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);


@@ -7003,7 +6841,6 @@ switch_back_to_stepped_thread (struct execution_control_state *ecs)
 {
   if (!target_is_non_stop_p ())
     {
 {
   if (!target_is_non_stop_p ())
     {

-      struct thread_info *tp;

       struct thread_info *stepping_thread;
 
       /* If any thread is blocked on some internal breakpoint, and we
       struct thread_info *stepping_thread;
 
       /* If any thread is blocked on some internal breakpoint, and we


@@ -7026,7 +6863,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;


@@ -7041,7 +6878,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;


@@ -7056,7 +6893,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;


@@ -7090,8 +6927,10 @@ switch_back_to_stepped_thread (struct execution_control_state *ecs)
       /* Look for the stepping/nexting thread.  */
       stepping_thread = NULL;
 
       /* Look for the stepping/nexting thread.  */
       stepping_thread = NULL;
 

-      ALL_NON_EXITED_THREADS (tp)
+      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


@@ -7107,7 +6946,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);
            }
 


@@ -7143,6 +6982,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;


@@ -7504,14 +7345,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.  */


@@ -7535,11 +7376,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


@@ -7598,7 +7438,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;


@@ -7635,10 +7475,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


@@ -7677,7 +7516,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


@@ -7699,7 +7538,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


@@ -7708,7 +7547,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


@@ -7765,18 +7604,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);
 


@@ -7876,31 +7714,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 ());

     }
 }
 
     }
 }
 


@@ -7932,13 +7765,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 ("\"");
        }
     }


@@ -8037,13 +7870,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);


@@ -8051,16 +7883,17 @@ 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 ();
   if (tp->thread_fsm != NULL
   }
 
   tp = inferior_thread ();
   if (tp->thread_fsm != NULL

-      && thread_fsm_finished_p (tp->thread_fsm))
+      && tp->thread_fsm->finished_p ())

     {
       struct return_value_info *rv;
 
     {
       struct return_value_info *rv;
 

-      rv = thread_fsm_return_value (tp->thread_fsm);
+      rv = tp->thread_fsm->return_value ();

       if (rv != NULL)
        print_return_value (uiout, rv);
     }
       if (rv != NULL)
        print_return_value (uiout, rv);
     }


@@ -8161,9 +7994,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 ();
 


@@ -8230,7 +8062,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;


@@ -8297,16 +8129,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


@@ -8330,7 +8161,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);


@@ -8420,7 +8252,7 @@ signal_catch_update (const unsigned int *info)
   for (i = 0; i < GDB_SIGNAL_LAST; ++i)
     signal_catch[i] = info[i] > 0;
   signal_cache_update (-1);
   for (i = 0; i < GDB_SIGNAL_LAST; ++i)
     signal_catch[i] = info[i] > 0;
   signal_cache_update (-1);

-  target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
+  target_pass_signals (signal_pass);

 }
 
 static void
 }
 
 static void


@@ -8456,8 +8288,6 @@ handle_command (const char *args, int from_tty)
   int sigfirst, siglast;
   enum gdb_signal oursig;
   int allsigs;
   int sigfirst, siglast;
   enum gdb_signal oursig;
   int allsigs;

-  int nsigs;
-  unsigned char *sigs;

 
   if (args == NULL)
     {
 
   if (args == NULL)
     {


@@ -8466,9 +8296,8 @@ handle_command (const char *args, int from_tty)
 
   /* Allocate and zero an array of flags for which signals to handle.  */
 
 
   /* Allocate and zero an array of flags for which signals to handle.  */
 

-  nsigs = (int) GDB_SIGNAL_LAST;
-  sigs = (unsigned char *) alloca (nsigs);
-  memset (sigs, 0, nsigs);
+  const size_t nsigs = GDB_SIGNAL_LAST;
+  unsigned char sigs[nsigs] {};

 
   /* Break the command line up into args.  */
 
 
   /* Break the command line up into args.  */
 


@@ -8583,10 +8412,7 @@ Are you sure you want to change it? "),
                      sigs[signum] = 1;
                    }
                  else
                      sigs[signum] = 1;
                    }
                  else

-                   {
-                     printf_unfiltered (_("Not confirmed, unchanged.\n"));
-                     gdb_flush (gdb_stdout);
-                   }
+                   printf_unfiltered (_("Not confirmed, unchanged.\n"));

                }
              break;
            case GDB_SIGNAL_0:
                }
              break;
            case GDB_SIGNAL_0:


@@ -8605,8 +8431,8 @@ Are you sure you want to change it? "),
     if (sigs[signum])
       {
        signal_cache_update (-1);
     if (sigs[signum])
       {
        signal_cache_update (-1);

-       target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
-       target_program_signals ((int) GDB_SIGNAL_LAST, signal_program);
+       target_pass_signals (signal_pass);
+       target_program_signals (signal_program);

 
        if (from_tty)
          {
 
        if (from_tty)
          {


@@ -8787,20 +8613,87 @@ siginfo_make_value (struct gdbarch *gdbarch, struct internalvar *var,
    ends (either successfully, or after it hits a breakpoint or signal)
    if the program is to properly continue where it left off.  */
 
    ends (either successfully, or after it hits a breakpoint or signal)
    if the program is to properly continue where it left off.  */
 

-struct infcall_suspend_state
+class infcall_suspend_state

 {
 {

-  struct thread_suspend_state thread_suspend;
+public:
+  /* Capture state from GDBARCH, TP, and REGCACHE that must be restored
+     once the inferior function call has finished.  */
+  infcall_suspend_state (struct gdbarch *gdbarch,
+                         const struct thread_info *tp,
+                         struct regcache *regcache)
+    : m_thread_suspend (tp->suspend),
+      m_registers (new readonly_detached_regcache (*regcache))
+  {
+    gdb::unique_xmalloc_ptr<gdb_byte> siginfo_data;

 
 

-  /* Other fields:  */
-  std::unique_ptr<readonly_detached_regcache> registers;
+    if (gdbarch_get_siginfo_type_p (gdbarch))
+      {
+        struct type *type = gdbarch_get_siginfo_type (gdbarch);
+        size_t len = TYPE_LENGTH (type);
+
+        siginfo_data.reset ((gdb_byte *) xmalloc (len));
+
+        if (target_read (current_top_target (), TARGET_OBJECT_SIGNAL_INFO, NULL,
+                         siginfo_data.get (), 0, len) != len)
+          {
+            /* Errors ignored.  */
+            siginfo_data.reset (nullptr);
+          }
+      }
+
+    if (siginfo_data)
+      {
+        m_siginfo_gdbarch = gdbarch;
+        m_siginfo_data = std::move (siginfo_data);
+      }
+  }
+
+  /* Return a pointer to the stored register state.  */
+
+  readonly_detached_regcache *registers () const
+  {
+    return m_registers.get ();
+  }
+
+  /* Restores the stored state into GDBARCH, TP, and REGCACHE.  */
+
+  void restore (struct gdbarch *gdbarch,
+                struct thread_info *tp,
+                struct regcache *regcache) const
+  {
+    tp->suspend = m_thread_suspend;
+
+    if (m_siginfo_gdbarch == gdbarch)
+      {
+        struct type *type = gdbarch_get_siginfo_type (gdbarch);
+
+        /* Errors ignored.  */
+        target_write (current_top_target (), TARGET_OBJECT_SIGNAL_INFO, NULL,
+                      m_siginfo_data.get (), 0, TYPE_LENGTH (type));
+      }
+
+    /* The inferior can be gone if the user types "print exit(0)"
+       (and perhaps other times).  */
+    if (target_has_execution)
+      /* NB: The register write goes through to the target.  */
+      regcache->restore (registers ());
+  }
+
+private:
+  /* How the current thread stopped before the inferior function call was
+     executed.  */
+  struct thread_suspend_state m_thread_suspend;
+
+  /* The registers before the inferior function call was executed.  */
+  std::unique_ptr<readonly_detached_regcache> m_registers;

 
   /* Format of SIGINFO_DATA or NULL if it is not present.  */
 
   /* Format of SIGINFO_DATA or NULL if it is not present.  */

-  struct gdbarch *siginfo_gdbarch = nullptr;
+  struct gdbarch *m_siginfo_gdbarch = nullptr;

 
   /* The inferior format depends on SIGINFO_GDBARCH and it has a length of
      TYPE_LENGTH (gdbarch_get_siginfo_type ()).  For different gdbarch the
      content would be invalid.  */
 
   /* The inferior format depends on SIGINFO_GDBARCH and it has a length of
      TYPE_LENGTH (gdbarch_get_siginfo_type ()).  For different gdbarch the
      content would be invalid.  */

-  gdb::unique_xmalloc_ptr<gdb_byte> siginfo_data;
+  gdb::unique_xmalloc_ptr<gdb_byte> m_siginfo_data;

 };
 
 infcall_suspend_state_up
 };
 
 infcall_suspend_state_up


@@ -8809,39 +8702,16 @@ save_infcall_suspend_state ()
   struct thread_info *tp = inferior_thread ();
   struct regcache *regcache = get_current_regcache ();
   struct gdbarch *gdbarch = regcache->arch ();
   struct thread_info *tp = inferior_thread ();
   struct regcache *regcache = get_current_regcache ();
   struct gdbarch *gdbarch = regcache->arch ();

-  gdb::unique_xmalloc_ptr<gdb_byte> siginfo_data;
-
-  if (gdbarch_get_siginfo_type_p (gdbarch))
-    {
-      struct type *type = gdbarch_get_siginfo_type (gdbarch);
-      size_t len = TYPE_LENGTH (type);
-
-      siginfo_data.reset ((gdb_byte *) xmalloc (len));
-
-      if (target_read (current_top_target (), TARGET_OBJECT_SIGNAL_INFO, NULL,
-                      siginfo_data.get (), 0, len) != len)
-       {
-         /* Errors ignored.  */
-         siginfo_data.reset (nullptr);
-       }
-    }
-
-  infcall_suspend_state_up inf_state (new struct infcall_suspend_state);
-
-  if (siginfo_data)
-    {
-      inf_state->siginfo_gdbarch = gdbarch;
-      inf_state->siginfo_data = std::move (siginfo_data);
-    }

 
 

-  inf_state->thread_suspend = tp->suspend;
+  infcall_suspend_state_up inf_state
+    (new struct infcall_suspend_state (gdbarch, tp, regcache));

 
 

-  /* run_inferior_call will not use the signal due to its `proceed' call with
-     GDB_SIGNAL_0 anyway.  */
+  /* Having saved the current state, adjust the thread state, discarding
+     any stop signal information.  The stop signal is not useful when
+     starting an inferior function call, and run_inferior_call will not use
+     the signal due to its `proceed' call with GDB_SIGNAL_0.  */

   tp->suspend.stop_signal = GDB_SIGNAL_0;
 
   tp->suspend.stop_signal = GDB_SIGNAL_0;
 

-  inf_state->registers.reset (new readonly_detached_regcache (*regcache));
-

   return inf_state;
 }
 
   return inf_state;
 }
 


@@ -8854,23 +8724,7 @@ restore_infcall_suspend_state (struct infcall_suspend_state *inf_state)
   struct regcache *regcache = get_current_regcache ();
   struct gdbarch *gdbarch = regcache->arch ();
 
   struct regcache *regcache = get_current_regcache ();
   struct gdbarch *gdbarch = regcache->arch ();
 

-  tp->suspend = inf_state->thread_suspend;
-
-  if (inf_state->siginfo_gdbarch == gdbarch)
-    {
-      struct type *type = gdbarch_get_siginfo_type (gdbarch);
-
-      /* Errors ignored.  */
-      target_write (current_top_target (), TARGET_OBJECT_SIGNAL_INFO, NULL,
-                   inf_state->siginfo_data.get (), 0, TYPE_LENGTH (type));
-    }
-
-  /* The inferior can be gone if the user types "print exit(0)"
-     (and perhaps other times).  */
-  if (target_has_execution)
-    /* NB: The register write goes through to the target.  */
-    regcache->restore (inf_state->registers.get ());
-
+  inf_state->restore (gdbarch, tp, regcache);

   discard_infcall_suspend_state (inf_state);
 }
 
   discard_infcall_suspend_state (inf_state);
 }
 


@@ -8883,7 +8737,7 @@ discard_infcall_suspend_state (struct infcall_suspend_state *inf_state)
 readonly_detached_regcache *
 get_infcall_suspend_state_regcache (struct infcall_suspend_state *inf_state)
 {
 readonly_detached_regcache *
 get_infcall_suspend_state_regcache (struct infcall_suspend_state *inf_state)
 {

-  return inf_state->registers.get ();
+  return inf_state->registers ();

 }
 
 /* infcall_control_state contains state regarding gdb's control of the
 }
 
 /* infcall_control_state contains state regarding gdb's control of the


@@ -8980,11 +8834,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");


@@ -8992,7 +8846,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;


@@ -9104,8 +8957,6 @@ infrun_async_inferior_event_handler (gdb_client_data data)
 void
 _initialize_infrun (void)
 {
 void
 _initialize_infrun (void)
 {

-  int i;
-  int numsigs;

   struct cmd_list_element *c;
 
   /* Register extra event sources in the event loop.  */
   struct cmd_list_element *c;
 
   /* Register extra event sources in the event loop.  */


@@ -9187,13 +9038,7 @@ leave it stopped or free to run as needed."),
                           &setlist,
                           &showlist);
 
                           &setlist,
                           &showlist);
 

-  numsigs = (int) GDB_SIGNAL_LAST;
-  signal_stop = XNEWVEC (unsigned char, numsigs);
-  signal_print = XNEWVEC (unsigned char, numsigs);
-  signal_program = XNEWVEC (unsigned char, numsigs);
-  signal_catch = XNEWVEC (unsigned char, numsigs);
-  signal_pass = XNEWVEC (unsigned char, numsigs);
-  for (i = 0; i < numsigs; i++)
+  for (size_t i = 0; i < GDB_SIGNAL_LAST; i++)

     {
       signal_stop[i] = 1;
       signal_print[i] = 1;
     {
       signal_stop[i] = 1;
       signal_print[i] = 1;