From d238133d0292926b937aaa6f83bf921dd0bbb01c Mon Sep 17 00:00:00 2001 From: Tom Tromey Date: Wed, 23 Jan 2019 18:58:35 +0000 Subject: [PATCH] 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 Pedro Alves * infrun.c (reinstall_readline_callback_handler_cleanup): Remove parameter. (fetch_inferior_event): Use SCOPE_EXIT. --- gdb/ChangeLog | 8 ++ gdb/infrun.c | 202 +++++++++++++++++++++++++------------------------- 2 files changed, 110 insertions(+), 100 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 1df10d41a98..33261fed14e 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,11 @@ +2019-01-23 Tom Tromey + Pedro Alves + + * infrun.c (reinstall_readline_callback_handler_cleanup): Remove + parameter. + (fetch_inferior_event): Use SCOPE_EXIT. + + 2019-01-23 Tom Tromey Pedro Alves diff --git a/gdb/infrun.c b/gdb/infrun.c index d954eae6ed2..68574679830 100644 --- 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 (¤t_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 maybe_restore_traceframe; - if (non_stop) - { - maybe_restore_traceframe.emplace (); - set_current_traceframe (-1); - } - - gdb::optional 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 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 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 -- 2.30.2