Some get_last_target_status tweaks

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

diff --git a/gdb/infrun.c b/gdb/infrun.c
index deb7bd6abd61aa14a1c4570fd065b1e768973a7c..bcfb178ef9c52108c0bdfdb6d31145ea42dca49d 100644 (file)
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -1,7 +1,7 @@
 /* Target-struct-independent code to start (run) and stop an inferior
    process.
 
 /* Target-struct-independent code to start (run) and stop an inferior
    process.
 

-   Copyright (C) 1986-2019 Free Software Foundation, Inc.
+   Copyright (C) 1986-2020 Free Software Foundation, Inc.

 
    This file is part of GDB.
 
 
    This file is part of GDB.
 


@@ -25,16 +25,13 @@
 #include "frame.h"
 #include "inferior.h"
 #include "breakpoint.h"
 #include "frame.h"
 #include "inferior.h"
 #include "breakpoint.h"

-#include "common/gdb_wait.h"

 #include "gdbcore.h"
 #include "gdbcmd.h"
 #include "gdbcore.h"
 #include "gdbcmd.h"

-#include "cli/cli-script.h"

 #include "target.h"
 #include "gdbthread.h"
 #include "annotate.h"
 #include "symfile.h"
 #include "top.h"
 #include "target.h"
 #include "gdbthread.h"
 #include "annotate.h"
 #include "symfile.h"
 #include "top.h"

-#include <signal.h>

 #include "inf-loop.h"
 #include "regcache.h"
 #include "value.h"
 #include "inf-loop.h"
 #include "regcache.h"
 #include "value.h"


@@ -42,7 +39,6 @@
 #include "language.h"
 #include "solib.h"
 #include "main.h"
 #include "language.h"
 #include "solib.h"
 #include "main.h"

-#include "dictionary.h"

 #include "block.h"
 #include "mi/mi-common.h"
 #include "event-top.h"
 #include "block.h"
 #include "mi/mi-common.h"
 #include "event-top.h"


@@ -51,8 +47,6 @@
 #include "inline-frame.h"
 #include "jit.h"
 #include "tracepoint.h"
 #include "inline-frame.h"
 #include "jit.h"
 #include "tracepoint.h"

-#include "continuations.h"
-#include "interps.h"

 #include "skip.h"
 #include "probe.h"
 #include "objfiles.h"
 #include "skip.h"
 #include "probe.h"
 #include "objfiles.h"


@@ -63,12 +57,12 @@
 #include "solist.h"
 #include "event-loop.h"
 #include "thread-fsm.h"
 #include "solist.h"
 #include "event-loop.h"
 #include "thread-fsm.h"

-#include "common/enum-flags.h"
+#include "gdbsupport/enum-flags.h"

 #include "progspace-and-thread.h"
 #include "progspace-and-thread.h"

-#include "common/gdb_optional.h"
+#include "gdbsupport/gdb_optional.h"

 #include "arch-utils.h"
 #include "arch-utils.h"

-#include "common/scope-exit.h"
-#include "common/forward-scope-exit.h"
+#include "gdbsupport/scope-exit.h"
+#include "gdbsupport/forward-scope-exit.h"

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


@@ -84,8 +78,6 @@ static void follow_inferior_reset_breakpoints (void);
 
 static int currently_stepping (struct thread_info *tp);
 
 
 static int currently_stepping (struct thread_info *tp);
 

-void nullify_last_target_wait_ptid (void);
-

 static void insert_hp_step_resume_breakpoint_at_frame (struct frame_info *);
 
 static void insert_step_resume_breakpoint_at_caller (struct frame_info *);
 static void insert_hp_step_resume_breakpoint_at_frame (struct frame_info *);
 
 static void insert_step_resume_breakpoint_at_caller (struct frame_info *);


@@ -136,7 +128,7 @@ mark_infrun_async_event_handler (void)
 /* When set, stop the 'step' command if we enter a function which has
    no line number information.  The normal behavior is that we step
    over such function.  */
 /* When set, stop the 'step' command if we enter a function which has
    no line number information.  The normal behavior is that we step
    over such function.  */

-int step_stop_if_no_debug = 0;
+bool step_stop_if_no_debug = false;

 static void
 show_step_stop_if_no_debug (struct ui_file *file, int from_tty,
                            struct cmd_list_element *c, const char *value)
 static void
 show_step_stop_if_no_debug (struct ui_file *file, int from_tty,
                            struct cmd_list_element *c, const char *value)


@@ -155,9 +147,9 @@ static ptid_t previous_inferior_ptid;
    Exactly which branch is detached depends on 'set follow-fork-mode'
    setting.  */
 
    Exactly which branch is detached depends on 'set follow-fork-mode'
    setting.  */
 

-static int detach_fork = 1;
+static bool detach_fork = true;

 
 

-int debug_displaced = 0;
+bool debug_displaced = false;

 static void
 show_debug_displaced (struct ui_file *file, int from_tty,
                      struct cmd_list_element *c, const char *value)
 static void
 show_debug_displaced (struct ui_file *file, int from_tty,
                      struct cmd_list_element *c, const char *value)


@@ -176,7 +168,7 @@ show_debug_infrun (struct ui_file *file, int from_tty,
 
 /* Support for disabling address space randomization.  */
 
 
 /* Support for disabling address space randomization.  */
 

-int disable_randomization = 1;
+bool disable_randomization = true;

 
 static void
 show_disable_randomization (struct ui_file *file, int from_tty,
 
 static void
 show_disable_randomization (struct ui_file *file, int from_tty,


@@ -205,8 +197,8 @@ set_disable_randomization (const char *args, int from_tty,
 
 /* User interface for non-stop mode.  */
 
 
 /* User interface for non-stop mode.  */
 

-int non_stop = 0;
-static int non_stop_1 = 0;
+bool non_stop = false;
+static bool non_stop_1 = false;

 
 static void
 set_non_stop (const char *args, int from_tty,
 
 static void
 set_non_stop (const char *args, int from_tty,


@@ -234,8 +226,8 @@ show_non_stop (struct ui_file *file, int from_tty,
    non-stop, in which all GDB operations that might affect the
    target's execution have been disabled.  */
 
    non-stop, in which all GDB operations that might affect the
    target's execution have been disabled.  */
 

-int observer_mode = 0;
-static int observer_mode_1 = 0;
+bool observer_mode = false;
+static bool observer_mode_1 = false;

 
 static void
 set_observer_mode (const char *args, int from_tty,
 
 static void
 set_observer_mode (const char *args, int from_tty,


@@ -256,7 +248,7 @@ set_observer_mode (const char *args, int from_tty,
   /* We can insert fast tracepoints in or out of observer mode,
      but enable them if we're going into this mode.  */
   if (observer_mode)
   /* We can insert fast tracepoints in or out of observer mode,
      but enable them if we're going into this mode.  */
   if (observer_mode)

-    may_insert_fast_tracepoints = 1;
+    may_insert_fast_tracepoints = true;

   may_stop = !observer_mode;
   update_target_permissions ();
 
   may_stop = !observer_mode;
   update_target_permissions ();
 


@@ -265,7 +257,7 @@ set_observer_mode (const char *args, int from_tty,
   if (observer_mode)
     {
       pagination_enabled = 0;
   if (observer_mode)
     {
       pagination_enabled = 0;

-      non_stop = non_stop_1 = 1;
+      non_stop = non_stop_1 = true;

     }
 
   if (from_tty)
     }
 
   if (from_tty)


@@ -289,13 +281,11 @@ show_observer_mode (struct ui_file *file, int from_tty,
 void
 update_observer_mode (void)
 {
 void
 update_observer_mode (void)
 {

-  int newval;
-
-  newval = (!may_insert_breakpoints
-           && !may_insert_tracepoints
-           && may_insert_fast_tracepoints
-           && !may_stop
-           && non_stop);
+  bool newval = (!may_insert_breakpoints
+                && !may_insert_tracepoints
+                && may_insert_fast_tracepoints
+                && !may_stop
+                && non_stop);

 
   /* Let the user know if things change.  */
   if (newval != observer_mode)
 
   /* Let the user know if things change.  */
   if (newval != observer_mode)


@@ -440,7 +430,6 @@ follow_fork_inferior (int follow_child, int detach_fork)
 Can not resume the parent process over vfork in the foreground while\n\
 holding the child stopped.  Try \"set detach-on-fork\" or \
 \"set schedule-multiple\".\n"));
 Can not resume the parent process over vfork in the foreground while\n\
 holding the child stopped.  Try \"set detach-on-fork\" or \
 \"set schedule-multiple\".\n"));

-      /* FIXME output string > 80 columns.  */

       return 1;
     }
 
       return 1;
     }
 


@@ -915,10 +904,14 @@ handle_vfork_child_exec_or_exit (int exec)
       int resume_parent = -1;
 
       /* This exec or exit marks the end of the shared memory region
       int resume_parent = -1;
 
       /* This exec or exit marks the end of the shared memory region

-        between the parent and the child.  If the user wanted to
-        detach from the parent, now is the time.  */
+        between the parent and the child.  Break the bonds.  */
+      inferior *vfork_parent = inf->vfork_parent;
+      inf->vfork_parent->vfork_child = NULL;
+      inf->vfork_parent = NULL;

 
 

-      if (inf->vfork_parent->pending_detach)
+      /* If the user wanted to detach from the parent, now is the
+        time.  */
+      if (vfork_parent->pending_detach)

        {
          struct thread_info *tp;
          struct program_space *pspace;
        {
          struct thread_info *tp;
          struct program_space *pspace;


@@ -926,7 +919,7 @@ handle_vfork_child_exec_or_exit (int exec)
 
          /* follow-fork child, detach-on-fork on.  */
 
 
          /* follow-fork child, detach-on-fork on.  */
 

-         inf->vfork_parent->pending_detach = 0;
+         vfork_parent->pending_detach = 0;

 
          gdb::optional<scoped_restore_exited_inferior>
            maybe_restore_inferior;
 
          gdb::optional<scoped_restore_exited_inferior>
            maybe_restore_inferior;


@@ -941,7 +934,7 @@ handle_vfork_child_exec_or_exit (int exec)
            maybe_restore_thread.emplace ();
 
          /* We're letting loose of the parent.  */
            maybe_restore_thread.emplace ();
 
          /* We're letting loose of the parent.  */

-         tp = any_live_thread_of_inferior (inf->vfork_parent);
+         tp = any_live_thread_of_inferior (vfork_parent);

          switch_to_thread (tp);
 
          /* We're about to detach from the parent, which implicitly
          switch_to_thread (tp);
 
          /* We're about to detach from the parent, which implicitly


@@ -964,7 +957,7 @@ handle_vfork_child_exec_or_exit (int exec)
          if (print_inferior_events)
            {
              std::string pidstr
          if (print_inferior_events)
            {
              std::string pidstr

-               = target_pid_to_str (ptid_t (inf->vfork_parent->pid));
+               = target_pid_to_str (ptid_t (vfork_parent->pid));

 
              target_terminal::ours_for_output ();
 
 
              target_terminal::ours_for_output ();
 


@@ -982,7 +975,7 @@ handle_vfork_child_exec_or_exit (int exec)
                }
            }
 
                }
            }
 

-         target_detach (inf->vfork_parent, 0);
+         target_detach (vfork_parent, 0);

 
          /* Put it back.  */
          inf->pspace = pspace;
 
          /* Put it back.  */
          inf->pspace = pspace;


@@ -997,10 +990,7 @@ handle_vfork_child_exec_or_exit (int exec)
          inf->removable = 1;
          set_current_program_space (inf->pspace);
 
          inf->removable = 1;
          set_current_program_space (inf->pspace);
 

-         resume_parent = inf->vfork_parent->pid;
-
-         /* Break the bonds.  */
-         inf->vfork_parent->vfork_child = NULL;
+         resume_parent = vfork_parent->pid;

        }
       else
        {
        }
       else
        {


@@ -1030,17 +1020,13 @@ handle_vfork_child_exec_or_exit (int exec)
          set_current_program_space (pspace);
          inf->removable = 1;
          inf->symfile_flags = SYMFILE_NO_READ;
          set_current_program_space (pspace);
          inf->removable = 1;
          inf->symfile_flags = SYMFILE_NO_READ;

-         clone_program_space (pspace, inf->vfork_parent->pspace);
+         clone_program_space (pspace, vfork_parent->pspace);

          inf->pspace = pspace;
          inf->aspace = pspace->aspace;
 
          inf->pspace = pspace;
          inf->aspace = pspace->aspace;
 

-         resume_parent = inf->vfork_parent->pid;
-         /* Break the bonds.  */
-         inf->vfork_parent->vfork_child = NULL;
+         resume_parent = vfork_parent->pid;

        }
 
        }
 

-      inf->vfork_parent = NULL;
-

       gdb_assert (current_program_space == inf->pspace);
 
       if (non_stop && resume_parent != -1)
       gdb_assert (current_program_space == inf->pspace);
 
       if (non_stop && resume_parent != -1)


@@ -1081,7 +1067,7 @@ show_follow_exec_mode_string (struct ui_file *file, int from_tty,
 /* EXEC_FILE_TARGET is assumed to be non-NULL.  */
 
 static void
 /* EXEC_FILE_TARGET is assumed to be non-NULL.  */
 
 static void

-follow_exec (ptid_t ptid, char *exec_file_target)
+follow_exec (ptid_t ptid, const char *exec_file_target)

 {
   struct inferior *inf = current_inferior ();
   int pid = ptid.pid ();
 {
   struct inferior *inf = current_inferior ();
   int pid = ptid.pid ();


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


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


@@ -1786,7 +1772,7 @@ displaced_step_prepare (thread_info *thread)
 
       if (ex.error != MEMORY_ERROR
          && ex.error != NOT_SUPPORTED_ERROR)
 
       if (ex.error != MEMORY_ERROR
          && ex.error != NOT_SUPPORTED_ERROR)

-       throw_exception (ex);
+       throw;

 
       if (debug_infrun)
        {
 
       if (debug_infrun)
        {


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


@@ -2624,7 +2610,7 @@ 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;

     }
 }
 
     }
 }
 


@@ -2952,6 +2938,8 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal)
     {
       for (thread_info *tp : all_non_exited_threads (resume_ptid))
        {
     {
       for (thread_info *tp : all_non_exited_threads (resume_ptid))
        {

+         switch_to_thread_no_regs (tp);
+

          /* Ignore the current thread here.  It's handled
             afterwards.  */
          if (tp == cur_thr)
          /* Ignore the current thread here.  It's handled
             afterwards.  */
          if (tp == cur_thr)


@@ -2969,6 +2957,8 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal)
 
          thread_step_over_chain_enqueue (tp);
        }
 
          thread_step_over_chain_enqueue (tp);
        }

+
+      switch_to_thread (cur_thr);

     }
 
   /* Enqueue the current thread last, so that we move all other
     }
 
   /* Enqueue the current thread last, so that we move all other


@@ -3005,6 +2995,8 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal)
           Start all other threads that are implicitly resumed too.  */
       for (thread_info *tp : all_non_exited_threads (resume_ptid))
         {
           Start all other threads that are implicitly resumed too.  */
       for (thread_info *tp : all_non_exited_threads (resume_ptid))
         {

+         switch_to_thread_no_regs (tp);
+

          if (tp->resumed)
            {
              if (debug_infrun)
          if (tp->resumed)
            {
              if (debug_infrun)


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


@@ -3104,7 +3101,7 @@ init_wait_for_inferior (void)
 
   clear_proceed_status (0);
 
 
   clear_proceed_status (0);
 

-  target_last_wait_ptid = minus_one_ptid;
+  nullify_last_target_wait_ptid ();

 
   previous_inferior_ptid = inferior_ptid;
 }
 
   previous_inferior_ptid = inferior_ptid;
 }


@@ -3705,14 +3702,11 @@ fetch_inferior_event (void *client_data)
        set_current_traceframe (-1);
       }
 
        set_current_traceframe (-1);
       }
 

-    gdb::optional<scoped_restore_current_thread> maybe_restore_thread;
-
-    if (non_stop)
-      /* In non-stop mode, the user/frontend should not notice a thread
-        switch due to internal events.  Make sure we reverse to the
-        user selected thread and frame after handling the event and
-        running any breakpoint commands.  */
-      maybe_restore_thread.emplace ();
+    /* The user/frontend should not notice a thread switch due to
+       internal events.  Make sure we revert to the user selected
+       thread and frame after handling the event and running any
+       breakpoint commands.  */
+    scoped_restore_current_thread restore_thread;

 
     overlay_cache_invalid = 1;
     /* Flush target cache before starting to handle each event.  Target
 
     overlay_cache_invalid = 1;
     /* Flush target cache before starting to handle each event.  Target


@@ -3789,6 +3783,19 @@ fetch_inferior_event (void *client_data)
                inferior_event_handler (INF_EXEC_COMPLETE, NULL);
                cmd_done = 1;
              }
                inferior_event_handler (INF_EXEC_COMPLETE, NULL);
                cmd_done = 1;
              }

+
+           /* If we got a TARGET_WAITKIND_NO_RESUMED event, then the
+              previously selected thread is gone.  We have two
+              choices - switch to no thread selected, or restore the
+              previously selected thread (now exited).  We chose the
+              later, just because that's what GDB used to do.  After
+              this, "info threads" says "The current thread <Thread
+              ID 2> has terminated." instead of "No thread
+              selected.".  */
+           if (!non_stop
+               && cmd_done
+               && ecs->ws.kind != TARGET_WAITKIND_NO_RESUMED)
+             restore_thread.dont_restore ();

          }
       }
 
          }
       }
 


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


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


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


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


@@ -4318,6 +4383,7 @@ stop_all_threads (void)
                                            "infrun:   %s executing, "
                                            "need stop\n",
                                            target_pid_to_str (t->ptid).c_str ());
                                            "infrun:   %s executing, "
                                            "need stop\n",
                                            target_pid_to_str (t->ptid).c_str ());

+                     switch_to_thread_no_regs (t);

                      target_stop (t->ptid);
                      t->stop_requested = 1;
                    }
                      target_stop (t->ptid);
                      t->stop_requested = 1;
                    }


@@ -5162,6 +5228,8 @@ restart_threads (struct thread_info *event_thread)
 
   for (thread_info *tp : all_non_exited_threads ())
     {
 
   for (thread_info *tp : all_non_exited_threads ())
     {

+      switch_to_thread_no_regs (tp);
+

       if (tp == event_thread)
        {
          if (debug_infrun)
       if (tp == event_thread)
        {
          if (debug_infrun)


@@ -5420,9 +5488,8 @@ handle_signal_stop (struct execution_control_state *ecs)
     {
       struct regcache *regcache = get_thread_regcache (ecs->event_thread);
       struct gdbarch *reg_gdbarch = regcache->arch ();
     {
       struct regcache *regcache = get_thread_regcache (ecs->event_thread);
       struct gdbarch *reg_gdbarch = regcache->arch ();

-      scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);

 
 

-      inferior_ptid = ecs->ptid;
+      switch_to_thread (ecs->event_thread);

 
       fprintf_unfiltered (gdb_stdlog, "infrun: stop_pc = %s\n",
                          paddress (reg_gdbarch,
 
       fprintf_unfiltered (gdb_stdlog, "infrun: stop_pc = %s\n",
                          paddress (reg_gdbarch,


@@ -5910,7 +5977,7 @@ handle_signal_stop (struct execution_control_state *ecs)
          return;
        }
 
          return;
        }
 

-      /* Note: step_resume_breakpoint may be non-NULL.  This occures
+      /* Note: step_resume_breakpoint may be non-NULL.  This occurs

         when either there's a nested signal, or when there's a
         pending signal enabled just as the signal handler returns
         (leaving the inferior at the step-resume-breakpoint without
         when either there's a nested signal, or when there's a
         pending signal enabled just as the signal handler returns
         (leaving the inferior at the step-resume-breakpoint without


@@ -6519,7 +6586,8 @@ process_event_stop_test (struct execution_control_state *ecs)
        tmp_sal = find_pc_line (ecs->stop_func_start, 0);
        if (tmp_sal.line != 0
            && !function_name_is_marked_for_skip (ecs->stop_func_name,
        tmp_sal = find_pc_line (ecs->stop_func_start, 0);
        if (tmp_sal.line != 0
            && !function_name_is_marked_for_skip (ecs->stop_func_name,

-                                                 tmp_sal))
+                                                 tmp_sal)
+           && !inline_frame_is_marked_for_skip (true, ecs->event_thread))

          {
            if (execution_direction == EXEC_REVERSE)
              handle_step_into_function_backward (gdbarch, ecs);
          {
            if (execution_direction == EXEC_REVERSE)
              handle_step_into_function_backward (gdbarch, ecs);


@@ -6685,7 +6753,14 @@ process_event_stop_test (struct execution_control_state *ecs)
 
          if (call_sal.line == ecs->event_thread->current_line
              && call_sal.symtab == ecs->event_thread->current_symtab)
 
          if (call_sal.line == ecs->event_thread->current_line
              && call_sal.symtab == ecs->event_thread->current_symtab)

-           step_into_inline_frame (ecs->event_thread);
+           {
+             step_into_inline_frame (ecs->event_thread);
+             if (inline_frame_is_marked_for_skip (false, ecs->event_thread))
+               {
+                 keep_going (ecs);
+                 return;
+               }
+           }

 
          end_stepping_range (ecs);
          return;
 
          end_stepping_range (ecs);
          return;


@@ -6719,7 +6794,8 @@ process_event_stop_test (struct execution_control_state *ecs)
        fprintf_unfiltered (gdb_stdlog,
                            "infrun: stepping through inlined function\n");
 
        fprintf_unfiltered (gdb_stdlog,
                            "infrun: stepping through inlined function\n");
 

-      if (ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
+      if (ecs->event_thread->control.step_over_calls == STEP_OVER_ALL
+         || inline_frame_is_marked_for_skip (false, ecs->event_thread))

        keep_going (ecs);
       else
        end_stepping_range (ecs);
        keep_going (ecs);
       else
        end_stepping_range (ecs);


@@ -6856,6 +6932,8 @@ switch_back_to_stepped_thread (struct execution_control_state *ecs)
 
       for (thread_info *tp : all_non_exited_threads ())
         {
 
       for (thread_info *tp : all_non_exited_threads ())
         {

+         switch_to_thread_no_regs (tp);
+

          /* Ignore threads of processes the caller is not
             resuming.  */
          if (!sched_multi
          /* Ignore threads of processes the caller is not
             resuming.  */
          if (!sched_multi


@@ -6907,6 +6985,8 @@ switch_back_to_stepped_thread (struct execution_control_state *ecs)
              return 1;
            }
        }
              return 1;
            }
        }

+
+      switch_to_thread (ecs->event_thread);

     }
 
   return 0;
     }
 
   return 0;


@@ -7275,7 +7355,7 @@ insert_exception_resume_breakpoint (struct thread_info *tp,
       CORE_ADDR handler;
       struct breakpoint *bp;
 
       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.  */


@@ -7644,24 +7724,19 @@ print_exited_reason (struct ui_out *uiout, int exitstatus)
     {
       if (uiout->is_mi_like_p ())
        uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXITED));
     {
       if (uiout->is_mi_like_p ())
        uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXITED));

-      uiout->text ("[Inferior ");
-      uiout->text (plongest (inf->num));
-      uiout->text (" (");
-      uiout->text (pidstr.c_str ());
-      uiout->text (") exited with code ");
-      uiout->field_fmt ("exit-code", "0%o", (unsigned int) exitstatus);
-      uiout->text ("]\n");
+      std::string exit_code_str
+       = string_printf ("0%o", (unsigned int) exitstatus);
+      uiout->message ("[Inferior %s (%s) exited with code %pF]\n",
+                     plongest (inf->num), pidstr.c_str (),
+                     string_field ("exit-code", exit_code_str.c_str ()));

     }
   else
     {
       if (uiout->is_mi_like_p ())
        uiout->field_string
          ("reason", async_reason_lookup (EXEC_ASYNC_EXITED_NORMALLY));
     }
   else
     {
       if (uiout->is_mi_like_p ())
        uiout->field_string
          ("reason", async_reason_lookup (EXEC_ASYNC_EXITED_NORMALLY));

-      uiout->text ("[Inferior ");
-      uiout->text (plongest (inf->num));
-      uiout->text (" (");
-      uiout->text (pidstr.c_str ());
-      uiout->text (") exited normally]\n");
+      uiout->message ("[Inferior %s (%s) exited normally]\n",
+                     plongest (inf->num), pidstr.c_str ());

     }
 }
 
     }
 }
 


@@ -7693,13 +7768,13 @@ print_signal_received_reason (struct ui_out *uiout, enum gdb_signal siggnal)
       const char *name;
 
       uiout->text ("\nThread ");
       const char *name;
 
       uiout->text ("\nThread ");

-      uiout->field_fmt ("thread-id", "%s", print_thread_id (thr));
+      uiout->field_string ("thread-id", print_thread_id (thr));

 
       name = thr->name != NULL ? thr->name : target_thread_name (thr);
       if (name != NULL)
        {
          uiout->text (" \"");
 
       name = thr->name != NULL ? thr->name : target_thread_name (thr);
       if (name != NULL)
        {
          uiout->text (" \"");

-         uiout->field_fmt ("name", "%s", name);
+         uiout->field_string ("name", name);

          uiout->text ("\"");
        }
     }
          uiout->text ("\"");
        }
     }


@@ -7801,10 +7876,9 @@ void
 print_stop_event (struct ui_out *uiout, bool displays)
 {
   struct target_waitstatus last;
 print_stop_event (struct ui_out *uiout, bool displays)
 {
   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);


@@ -7923,9 +7997,8 @@ int
 normal_stop (void)
 {
   struct target_waitstatus last;
 normal_stop (void)
 {
   struct target_waitstatus last;

-  ptid_t last_ptid;

 
 

-  get_last_target_status (&last_ptid, &last);
+  get_last_target_status (nullptr, &last);

 
   new_stop_id ();
 
 
   new_stop_id ();