2011-05-20 Pedro Alves <pedro@codesourcery.com>

	gdb/
	* infcmd.c: Include "inf-loop.h".
	(step_once): When stepping into an inline subroutine, pretend the
	target has run.  If the target can async, switch the inferior
	event loop to INF_EXEC_COMPLETE.
	* inferior.h (user_visible_resume_ptid): Declare.
	* infrun.c (user_visible_resume_ptid): New function, factored out
	from `resume'.
	(resume): Use it.
	* mi/mi-main.c (mi_execute_async_cli_command): Remove assertion
	that the current thread is running.  Merge async and sync
	branches.

5 files changed, 73 insertions, 36 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index de59f42725..c8ebd0981b 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,19 @@
 2011-05-20  Pedro Alves  <pedro@codesourcery.com>
 
+	* infcmd.c: Include "inf-loop.h".
+	(step_once): When stepping into an inline subroutine, pretend the
+	target has run.  If the target can async, switch the inferior
+	event loop to INF_EXEC_COMPLETE.
+	* inferior.h (user_visible_resume_ptid): Declare.
+	* infrun.c (user_visible_resume_ptid): New function, factored out
+	from `resume'.
+	(resume): Use it.
+	* mi/mi-main.c (mi_execute_async_cli_command): Remove assertion
+	that the current thread is running.  Merge async and sync
+	branches.
+
+2011-05-20  Pedro Alves  <pedro@codesourcery.com>
+
 	* infcmd.c (step_1): Simplify synchronous case.
 
 2011-05-20  Pedro Alves  <pedro@codesourcery.com>
diff --git a/gdb/infcmd.c b/gdb/infcmd.c
index ab1f2f93cb..f857ba0dab 100644
--- a/gdb/infcmd.c
+++ b/gdb/infcmd.c
@@ -55,6 +55,7 @@
 #include "valprint.h"
 #include "inline-frame.h"
 #include "tracepoint.h"
+#include "inf-loop.h"
 
 /* Functions exported for general use, in inferior.h: */
 
@@ -994,12 +995,23 @@ step_once (int skip_subroutines, int single_inst, int count, int thread)
 	  if (!skip_subroutines && !single_inst
 	      && inline_skipped_frames (inferior_ptid))
 	    {
+	      ptid_t resume_ptid;
+
+	      /* Pretend that we've ran.  */
+	      resume_ptid = user_visible_resume_ptid (1);
+	      set_running (resume_ptid, 1);
+
 	      step_into_inline_frame (inferior_ptid);
 	      if (count > 1)
 		step_once (skip_subroutines, single_inst, count - 1, thread);
 	      else
-		/* Pretend that we've stopped.  */
-		normal_stop ();
+		{
+		  /* Pretend that we've stopped.  */
+		  normal_stop ();
+
+		  if (target_can_async_p ())
+		    inferior_event_handler (INF_EXEC_COMPLETE, NULL);
+		}
 	      return;
 	    }
 
diff --git a/gdb/inferior.h b/gdb/inferior.h
index 15e3ca2264..57a96cf9ea 100644
--- a/gdb/inferior.h
+++ b/gdb/inferior.h
@@ -188,6 +188,8 @@ extern void reopen_exec_file (void);
 
 extern void resume (int, enum target_signal);
 
+extern ptid_t user_visible_resume_ptid (int step);
+
 /* From misc files */
 
 extern void default_print_registers_info (struct gdbarch *gdbarch,
diff --git a/gdb/infrun.c b/gdb/infrun.c
index 8d6910df4a..7b9245c4bf 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -1601,6 +1601,45 @@ maybe_software_singlestep (struct gdbarch *gdbarch, CORE_ADDR pc)
   return hw_step;
 }
 
+/* Return a ptid representing the set of threads that we will proceed,
+   in the perspective of the user/frontend.  We may actually resume
+   fewer threads at first, e.g., if a thread is stopped at a
+   breakpoint that needs stepping-off, but that should be visible to
+   the user/frontend, and neither should the frontend/user be allowed
+   to proceed any of the threads that happen to be stopped at for
+   internal run control handling, if a previous command wanted them
+   resumed.  */
+
+ptid_t
+user_visible_resume_ptid (int step)
+{
+  /* By default, resume all threads of all processes.  */
+  ptid_t resume_ptid = RESUME_ALL;
+
+  /* Maybe resume only all threads of the current process.  */
+  if (!sched_multi && target_supports_multi_process ())
+    {
+      resume_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
+    }
+
+  /* Maybe resume a single thread after all.  */
+  if (non_stop)
+    {
+      /* With non-stop mode on, threads are always handled
+	 individually.  */
+      resume_ptid = inferior_ptid;
+    }
+  else if ((scheduler_mode == schedlock_on)
+	   || (scheduler_mode == schedlock_step
+	       && (step || singlestep_breakpoints_inserted_p)))
+    {
+      /* User-settable 'scheduler' mode requires solo thread resume.  */
+      resume_ptid = inferior_ptid;
+    }
+
+  return resume_ptid;
+}
+
 /* Resume the inferior, but allow a QUIT.  This is useful if the user
    wants to interrupt some lengthy single-stepping operation
    (for child processes, the SIGINT goes to the inferior, and so
@@ -1762,15 +1801,7 @@ a command like `return' or `jump' to continue execution."));
       /* Decide the set of threads to ask the target to resume.  Start
 	 by assuming everything will be resumed, than narrow the set
 	 by applying increasingly restricting conditions.  */
-
-      /* By default, resume all threads of all processes.  */
-      resume_ptid = RESUME_ALL;
-
-      /* Maybe resume only all threads of the current process.  */
-      if (!sched_multi && target_supports_multi_process ())
-	{
-	  resume_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
-	}
+      resume_ptid = user_visible_resume_ptid (step);
 
       /* Maybe resume a single thread after all.  */
       if (singlestep_breakpoints_inserted_p
@@ -1804,19 +1835,6 @@ a command like `return' or `jump' to continue execution."));
 	     breakpoint, not just the one at PC.  */
 	  resume_ptid = inferior_ptid;
 	}
-      else if (non_stop)
-	{
-	  /* With non-stop mode on, threads are always handled
-	     individually.  */
-	  resume_ptid = inferior_ptid;
-	}
-      else if ((scheduler_mode == schedlock_on)
-	       || (scheduler_mode == schedlock_step
-		   && (step || singlestep_breakpoints_inserted_p)))
-	{
-	  /* User-settable 'scheduler' mode requires solo thread resume.  */
-	  resume_ptid = inferior_ptid;
-	}
 
       if (gdbarch_cannot_step_breakpoint (gdbarch))
 	{
diff --git a/gdb/mi/mi-main.c b/gdb/mi/mi-main.c
index 518127323d..4d1e3f9b9d 100644
--- a/gdb/mi/mi-main.c
+++ b/gdb/mi/mi-main.c
@@ -2162,18 +2162,9 @@ mi_execute_async_cli_command (char *cli_command, char **argv, int argc)
 
   execute_command ( /*ui */ run, 0 /*from_tty */ );
 
-  if (target_can_async_p ())
-    {
-      /* If we're not executing, an exception should have been throw.  */
-      gdb_assert (is_running (inferior_ptid));
-      do_cleanups (old_cleanups);
-    }
-  else
-    {
-      /* Do this before doing any printing.  It would appear that some
-         print code leaves garbage around in the buffer.  */
-      do_cleanups (old_cleanups);
-    }
+  /* Do this before doing any printing.  It would appear that some
+     print code leaves garbage around in the buffer.  */
+  do_cleanups (old_cleanups);
 }
 
 void