From patchwork Wed Jan 23 15:21:28 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Pedro Alves X-Patchwork-Id: 31192 Received: (qmail 66919 invoked by alias); 23 Jan 2019 15:21:56 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 66413 invoked by uid 89); 23 Jan 2019 15:21:53 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-25.9 required=5.0 tests=BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_LAZY_DOMAIN_SECURITY, SPF_HELO_PASS autolearn=ham version=3.3.2 spammy=proceeded, sk:!target X-HELO: mx1.redhat.com Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Wed, 23 Jan 2019 15:21:50 +0000 Received: from smtp.corp.redhat.com (int-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.12]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 82371C02938F; Wed, 23 Jan 2019 15:21:49 +0000 (UTC) Received: from localhost.localdomain (ovpn04.gateway.prod.ext.ams2.redhat.com [10.39.146.4]) by smtp.corp.redhat.com (Postfix) with ESMTP id 82CA067143; Wed, 23 Jan 2019 15:21:48 +0000 (UTC) From: Pedro Alves To: gdb-patches@sourceware.org Cc: Tom Tromey , Andrew Burgess Subject: [PATCH v3 14/17] Remove remaining cleanup from fetch_inferior_event Date: Wed, 23 Jan 2019 15:21:28 +0000 Message-Id: <20190123152131.29893-15-palves@redhat.com> In-Reply-To: <20190123152131.29893-1-palves@redhat.com> References: <20190123152131.29893-1-palves@redhat.com> From: Tom Tromey 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: yyyy-mm-dd Tom Tromey Pedro Alves * infrun.c (reinstall_readline_callback_handler_cleanup): Remove parameter. (fetch_inferior_event): Use SCOPE_EXIT. --- gdb/infrun.c | 202 ++++++++++++++++++++++++++++++----------------------------- 1 file changed, 102 insertions(+), 100 deletions(-) diff --git a/gdb/infrun.c b/gdb/infrun.c index d954eae6ed..6857467983 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