Remove remaining cleanup from fetch_inferior_event

This removes the remaining cleanup from fetch_inferior_event,
replacing it with a SCOPE_EXIT.  This required introducing a new scope
and reindenting.

gdb/ChangeLog:
2019-01-23  Tom Tromey  <tom@tromey.com>
	    Pedro Alves  <palves@redhat.com>

	* infrun.c (reinstall_readline_callback_handler_cleanup): Remove
	parameter.
	(fetch_inferior_event): Use SCOPE_EXIT.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 1df10d4..33261fe 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,6 +1,14 @@
 2019-01-23  Tom Tromey  <tom@tromey.com>
            Pedro Alves  <palves@redhat.com>
 
+       * infrun.c (reinstall_readline_callback_handler_cleanup): Remove
+       parameter.
+       (fetch_inferior_event): Use SCOPE_EXIT.
+
+
+2019-01-23  Tom Tromey  <tom@tromey.com>
+           Pedro Alves  <palves@redhat.com>
+
        * infrun.c (disable_thread_events): Delete.
        (stop_all_threads): Use SCOPE_EXIT.
 

diff --git a/gdb/infrun.c b/gdb/infrun.c
index d954eae..6857467 100644 (file)
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -3585,7 +3585,7 @@ wait_for_inferior (void)
    input.  */
 
 static void
-reinstall_readline_callback_handler_cleanup (void *arg)
+reinstall_readline_callback_handler_cleanup ()
 {
   struct ui *ui = current_ui;
 
@@ -3687,7 +3687,6 @@ fetch_inferior_event (void *client_data)
 {
   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;
 
@@ -3699,116 +3698,119 @@ 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.  */
-  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.  */
-  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);
+  {
+    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);
+      }
 
-  if (!ecs->wait_some_more)
-    {
-      struct inferior *inf = find_inferior_ptid (ecs->ptid);
-      int should_stop = 1;
-      struct thread_info *thr = ecs->event_thread;
+    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.  */
+    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;
 
-      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 (thread_fsm, thr);
-       }
+           if (thread_fsm != NULL)
+             should_stop = thread_fsm_should_stop (thread_fsm, thr);
+         }
 
-      if (!should_stop)
-       {
-         keep_going (ecs);
-       }
-      else
-       {
-         int should_notify_stop = 1;
-         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
-               = thread_fsm_should_notify_stop (thr->thread_fsm);
-           }
+           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;
+             }
+         }
+      }
 
-  defer_delete_threads.release ();
-  defer_bpstat_clear.release ();
+    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