espressif/binutils-gdb
1
0
Fork 0
mirror of https://github.com/espressif/binutils-gdb.git synced 2025-08-06 06:45:56 +08:00
Code Issues Packages Projects Releases Wiki Activity

Async mode fixes.

Browse Source 
* Makefile.in (infcmd.o, inf-loop.o): Update dependencies.
        * breakpoint.c (bpstat_do_actions): In async mode,
        don't jump to top expecting stop_bpstat to be already
        updated.
        * event-loop.c (start_event_loop): Call async_enable_stdin
        on exception.
        * event-top.c (async_enable_stdin): Do nothing if sync_execution
        is not set.
        (command_handler): Do not setup continuation here.
        (command_line_handler_continuation): Move to...
        * top.c (command_line_handler_continuation): ... here.
        (execute_command): In async mode, register continuation.
        Don't check frame's language in running in async mode.
        * exceptions.c (throw_exception): Don't do exec_error_cleanups.
        * inf-loop.c (complete_execution): Inline into...
        (inferior_event_handler): ... here.  Clear target_executing before
        doing any cleanups.  Don't try to show prompt if the target was
        resumed.
        * infcmd.c (signal_command): Add support for async mode.
        (finish_command): Only add continuation if the target was
        successfully resumed.
        * remote.c (init_async_opts): Register to_get_thread_local_address
        handler.
        * mi/mi-interp.c (mi_cmd_interpreter_exec): Don't mess
        with sync_execution.
        * tui/tui-interp.c (tui_command_loop): Call async_enable_stdin
        on exception.
This commit is contained in:
Vladimir Prus
2008-03-14 18:57:44 +00:00
parent c04ea773f9
commit 32c1e744c1
12 changed files with 237 additions and 127 deletions
Download Patch File Download Diff File Expand all files Collapse all files

78
gdb/inf-loop.c
View File

@ -25,9 +25,9 @@
#include "inf-loop.h"
#include "remote.h"
#include "exceptions.h"
#include "language.h"
static int fetch_inferior_event_wrapper (gdb_client_data client_data);
static void complete_execution (void);
void
inferior_event_handler_wrapper (gdb_client_data client_data)
@ -43,6 +43,7 @@ void
inferior_event_handler (enum inferior_event_type event_type,
gdb_client_data client_data)
{
int was_sync = 0;
switch (event_type)
{
case INF_ERROR:
@ -70,11 +71,52 @@ inferior_event_handler (enum inferior_event_type event_type,
break;
case INF_EXEC_COMPLETE:
/* Is there anything left to do for the command issued to
complete? */
/* This is the first thing to do -- so that continuations know that
the target is stopped. For example, command_line_handler_continuation
will run breakpoint commands, and if we think that the target is
running, we'll refuse to execute most commands. MI continuation
presently uses target_executing to either print or not print *stopped. */
target_executing = 0;
/* Unregister the inferior from the event loop. This is done so that
when the inferior is not running we don't get distracted by
spurious inferior output. */
if (target_has_execution)
target_async (NULL, 0);
/* Calls to do_exec_error_cleanup below will call async_enable_stdin,
and that resets 'sync_execution'. However, if we were running
in sync execution mode, we also need to display the prompt. */
was_sync = sync_execution;
if (was_sync)
do_exec_error_cleanups (ALL_CLEANUPS);
do_all_continuations ();
/* Reset things after target has stopped for the async commands. */
complete_execution ();
if (current_language != expected_language)
{
if (language_mode == language_mode_auto)
{
language_info (1); /* Print what changed. */
}
}
/* If the continuation did not start the target again,
prepare for interation with the user. */
if (!target_executing)
{
if (was_sync)
{
display_gdb_prompt (0);
}
else
{
if (exec_done_display_p)
printf_unfiltered (_("completed.\n"));
}
}
break;
case INF_EXEC_CONTINUE:
@ -103,29 +145,3 @@ fetch_inferior_event_wrapper (gdb_client_data client_data)
fetch_inferior_event (client_data);
return 1;
}
/* Reset proper settings after an asynchronous command has finished.
If the execution command was in synchronous mode, register stdin
with the event loop, and reset the prompt. */
static void
complete_execution (void)
{
target_executing = 0;
/* Unregister the inferior from the event loop. This is done so that
when the inferior is not running we don't get distracted by
spurious inferior output. */
target_async (NULL, 0);
if (sync_execution)
{
do_exec_error_cleanups (ALL_CLEANUPS);
display_gdb_prompt (0);
}
else
{
if (exec_done_display_p)
printf_unfiltered (_("completed.\n"));
}
}