* Makefile.in (mingw-hdep.o, posix-hdep.o, remote-fileio.o): Update.

	* event-loop.c (call_async_signal_handler): New.
	* event-loop.h (call_async_signal_handler)
	(gdb_call_async_signal_handler): Declare.
	(mark_async_signal_handler): Add comments.
	* event-top.c (handle_sigint): Use gdb_call_async_signal_handler.
	* mingw-hdep.c (sigint_event, sigint_handler): New.
	(gdb_select): Use them.  Wait for the readline signal handler
	to finish.
	(gdb_call_async_signal_handler, _initialize_mingw_hdep): New functions.
	* posix-hdep.c (gdb_call_async_signal_handler): New function.
	* remote-fileio.c (sigint_fileio_token, async_remote_fileio_interrupt):
	New.
	(remote_fileio_ctrl_c_signal_handler): Use
	gdb_call_async_signal_handler.
	(initialize_remote_fileio): Initialize sigint_fileio_token.
	* remote.c (initialize_sigint_signal_handler, handle_remote_sigint): Do
	not initialize tokens here.
	(handle_remote_sigint_twice): Likewise.  Reinstall
	handle_remote_sigint.
	(async_remote_interrupt_twice): Just call interrupt_query.
	(cleanup_sigint_signal_handler): Do not delete tokens.
	(remote_interrupt, remote_interrupt_twice): Use
	gdb_call_async_signal_handler.
	(interrupt_query): Reinstall the default signal handler.
	(_initialize_remote): Initialize tokens here.

1 files changed, 58 insertions, 7 deletions

diff --git a/gdb/mingw-hdep.c b/gdb/mingw-hdep.c
index bfa0c510521..3f69f085a3f 100644
--- a/gdb/mingw-hdep.c
+++ b/gdb/mingw-hdep.c
@@ -19,13 +19,23 @@
 
 #include "defs.h"
 #include "serial.h"
+#include "event-loop.h"
 
 #include "gdb_assert.h"
 #include "gdb_select.h"
 #include "gdb_string.h"
+#include "readline/readline.h"
 
 #include <windows.h>
 
+/* This event is signalled whenever an asynchronous SIGINT handler
+   needs to perform an action in the main thread.  */
+static HANDLE sigint_event;
+
+/* When SIGINT_EVENT is signalled, gdb_select will call this
+   function.  */
+struct async_signal_handler *sigint_handler;
+
 /* The strerror() function can return NULL for errno values that are
    out of range.  Provide a "safe" version that always returns a
    printable string.
@@ -141,14 +151,9 @@ gdb_select (int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
 	  handles[num_handles++] = except;
 	}
     }
-  /* If we don't need to wait for any handles, we are done.  */
-  if (!num_handles)
-    {
-      if (timeout)
-	Sleep (timeout->tv_sec * 1000 + timeout->tv_usec / 1000);
 
-      return 0;
-    }
+  gdb_assert (num_handles < MAXIMUM_WAIT_OBJECTS);
+  handles[num_handles++] = sigint_event;
 
   event = WaitForMultipleObjects (num_handles,
 				  handles,
@@ -203,5 +208,51 @@ gdb_select (int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
 	}
     }
 
+  /* With multi-threaded SIGINT handling, there is a race between the
+     readline signal handler and GDB.  It may still be in
+     rl_prep_terminal in another thread.  Do not return until it is
+     done; we can check the state here because we never longjmp from
+     signal handlers on Windows.  */
+  while (RL_ISSTATE (RL_STATE_SIGHANDLER))
+    Sleep (1);
+
+  if (h == sigint_event
+      || WaitForSingleObject (sigint_event, 0) == WAIT_OBJECT_0)
+    {
+      if (sigint_handler != NULL)
+	call_async_signal_handler (sigint_handler);
+
+      if (num_ready == 0)
+	{
+	  errno = EINTR;
+	  return -1;
+	}
+    }
+
   return num_ready;
 }
+
+/* Wrapper for the body of signal handlers.  On Windows systems, a
+   SIGINT handler runs in its own thread.  We can't longjmp from
+   there, and we shouldn't even prompt the user.  Delay HANDLER
+   until the main thread is next in gdb_select.  */
+
+void
+gdb_call_async_signal_handler (struct async_signal_handler *handler,
+			       int immediate_p)
+{
+  if (immediate_p)
+    sigint_handler = handler;
+  else
+    {
+      mark_async_signal_handler (handler);
+      sigint_handler = NULL;
+    }
+  SetEvent (sigint_event);
+}
+
+void
+_initialize_mingw_hdep (void)
+{
+  sigint_event = CreateEvent (0, FALSE, FALSE, 0);
+}