* infcall.c (run_inferior_call): Remove references to

	suppress_stop_observer.
	* infcmd.c (suppress_stop_observer): Delete.
	(finish_command_continuation): Remove NOTE.  Don't clear
	suppress_stop_observer anymore.
	(finish_command_continuation_free_arg): Likewise.
	(finish_forward): Remove references to suppress_stop_observer.
	Call normal_stop observer if we haven't already.
	* inferior.h (suppress_stop_observer): Delete.
	* infrun.c (normal_stop): When deciding to suppress the
	normal_stop observer, check for proceed_to_finish instead of
	suppress_stop_observer.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 5f77b43..504ed02 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,20 @@
 2009-03-22  Pedro Alves  <pedro@codesourcery.com>
 
+       * infcall.c (run_inferior_call): Remove references to
+       suppress_stop_observer.
+       * infcmd.c (suppress_stop_observer): Delete.
+       (finish_command_continuation): Remove NOTE.  Don't clear
+       suppress_stop_observer anymore.
+       (finish_command_continuation_free_arg): Likewise.
+       (finish_forward): Remove references to suppress_stop_observer.
+       Call normal_stop observer if we haven't already.
+       * inferior.h (suppress_stop_observer): Delete.
+       * infrun.c (normal_stop): When deciding to suppress the
+       normal_stop observer, check for proceed_to_finish instead of
+       suppress_stop_observer.
+
+2009-03-22  Pedro Alves  <pedro@codesourcery.com>
+
        * symfile.c (symfile_relocate_debug_section): Remove check for
        SEC_DEBUGGING.
 

diff --git a/gdb/infcall.c b/gdb/infcall.c
index d6da8b2..3a11149 100644 (file)
--- a/gdb/infcall.c
+++ b/gdb/infcall.c
@@ -331,7 +331,6 @@ run_inferior_call (struct thread_info *call_thread, CORE_ADDR real_pc)
   volatile struct gdb_exception e;
   int saved_async = 0;
   int saved_suppress_resume_observer = suppress_resume_observer;
-  int saved_suppress_stop_observer = suppress_stop_observer;
   ptid_t call_thread_ptid = call_thread->ptid;
   char *saved_target_shortname = xstrdup (target_shortname);
 
@@ -344,7 +343,6 @@ run_inferior_call (struct thread_info *call_thread, CORE_ADDR real_pc)
     saved_async = target_async_mask (0);
 
   suppress_resume_observer = 1;
-  suppress_stop_observer = 1;
 
   TRY_CATCH (e, RETURN_MASK_ALL)
     proceed (real_pc, TARGET_SIGNAL_0, 0);
@@ -355,7 +353,6 @@ run_inferior_call (struct thread_info *call_thread, CORE_ADDR real_pc)
   call_thread = NULL;
 
   suppress_resume_observer = saved_suppress_resume_observer;
-  suppress_stop_observer = saved_suppress_stop_observer;
 
   /* Don't restore the async mask if the target has changed,
      saved_async is for the original target.  */

diff --git a/gdb/infcmd.c b/gdb/infcmd.c
index 6aed426..0d5dce9 100644 (file)
--- a/gdb/infcmd.c
+++ b/gdb/infcmd.c
@@ -169,8 +169,6 @@ struct gdb_environ *inferior_environ;
 
 /* When set, no calls to target_resumed observer will be made.  */
 int suppress_resume_observer = 0;
-/* When set, normal_stop will not call the normal_stop observer.  */
-int suppress_stop_observer = 0;
 \f
 /* Accessor routines. */
 
@@ -1346,13 +1344,16 @@ static void
 finish_command_continuation (void *arg)
 {
   struct finish_command_continuation_args *a = arg;
-
+  struct thread_info *tp = NULL;
   bpstat bs = NULL;
 
   if (!ptid_equal (inferior_ptid, null_ptid)
       && target_has_execution
       && is_stopped (inferior_ptid))
-    bs = inferior_thread ()->stop_bpstat;
+    {
+      tp = inferior_thread ();
+      bs = tp->stop_bpstat;
+    }
 
   if (bpstat_find_breakpoint (bs, a->breakpoint) != NULL
       && a->function != NULL)
@@ -1369,22 +1370,15 @@ finish_command_continuation (void *arg)
     }
 
   /* We suppress normal call of normal_stop observer and do it here so
-     that that *stopped notification includes the return value.  */
-  /* NOTE: This is broken in non-stop mode.  There is no guarantee the
-     next stop will be in the same thread that we started doing a
-     finish on.  This suppressing (or some other replacement means)
-     should be a thread property.  */
-  observer_notify_normal_stop (bs, 1 /* print frame */);
-  suppress_stop_observer = 0;
+     that the *stopped notification includes the return value.  */
+  if (bs != NULL && tp->proceed_to_finish)
+    observer_notify_normal_stop (bs, 1 /* print frame */);
   delete_breakpoint (a->breakpoint);
 }
 
 static void
 finish_command_continuation_free_arg (void *arg)
 {
-  /* NOTE: See finish_command_continuation.  This would go away, if
-     this suppressing is made a thread property.  */
-  suppress_stop_observer = 0;
   xfree (arg);
 }
 
@@ -1469,8 +1463,6 @@ finish_forward (struct symbol *function, struct frame_info *frame)
   old_chain = make_cleanup_delete_breakpoint (breakpoint);
 
   tp->proceed_to_finish = 1;    /* We want stop_registers, please...  */
-  make_cleanup_restore_integer (&suppress_stop_observer);
-  suppress_stop_observer = 1;
   proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
 
   cargs = xmalloc (sizeof (*cargs));

diff --git a/gdb/inferior.h b/gdb/inferior.h
index 6a1c01a..4d41402 100644 (file)
--- a/gdb/inferior.h
+++ b/gdb/inferior.h
@@ -368,10 +368,6 @@ extern int debug_displaced;
 void displaced_step_dump_bytes (struct ui_file *file,
                                 const gdb_byte *buf, size_t len);
 
-
-/* When set, normal_stop will not call the normal_stop observer.  */
-extern int suppress_stop_observer;
-
 /* When set, no calls to target_resumed observer will be made.  */
 extern int suppress_resume_observer;
 

diff --git a/gdb/infrun.c b/gdb/infrun.c
index d774e32..8466ed6 100644 (file)
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -4433,11 +4433,25 @@ Further execution is probably impossible.\n"));
 
 done:
   annotate_stopped ();
-  if (!suppress_stop_observer
-      && !(target_has_execution
-          && last.kind != TARGET_WAITKIND_SIGNALLED
-          && last.kind != TARGET_WAITKIND_EXITED
-          && inferior_thread ()->step_multi))
+
+  /* Suppress the stop observer if we're in the middle of:
+
+     - a step n (n > 1), as there still more steps to be done.
+
+     - a "finish" command, as the observer will be called in
+       finish_command_continuation, so it can include the inferior
+       function's return value.
+
+     - calling an inferior function, as we pretend we inferior didn't
+       run at all.  The return value of the call is handled by the
+       expression evaluator, through call_function_by_hand.  */
+
+  if (!target_has_execution
+      || last.kind == TARGET_WAITKIND_SIGNALLED
+      || last.kind == TARGET_WAITKIND_EXITED
+      || (!inferior_thread ()->step_multi
+         && !(inferior_thread ()->stop_bpstat
+              && inferior_thread ()->proceed_to_finish)))
     {
       if (!ptid_equal (inferior_ptid, null_ptid))
        observer_notify_normal_stop (inferior_thread ()->stop_bpstat,