[binutils-gdb] Windows gdb: Introduce windows_continue_flags

https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=e6d0aabfd3b3b61d721fadc18042826e42fa3486

commit e6d0aabfd3b3b61d721fadc18042826e42fa3486
Author: Pedro Alves <[email protected]>
Date:   Thu Oct 21 18:16:58 2021 +0100

    Windows gdb: Introduce windows_continue_flags
    
    windows_continue already has two boolean parameters:
    
      (..., int killed, bool last_call = false)
    
    A patch later in the series would need a third.  Instead, convert
    windows_continue to use an optional enum-flags parameter instead of
    multiple booleans.
    
    Approved-By: Tom Tromey <[email protected]>
    Change-Id: I17c4d8a12b662190f972c380f838cb3317bd2e1e
    commit-id:e669e7de

Diff:
---
 gdb/windows-nat.c | 25 ++++++++++++-------------
 gdb/windows-nat.h | 20 ++++++++++++++++++--
 2 files changed, 30 insertions(+), 15 deletions(-)

diff --git a/gdb/windows-nat.c b/gdb/windows-nat.c
index 174b54eda78..170b837e930 100644
--- a/gdb/windows-nat.c
+++ b/gdb/windows-nat.c
@@ -705,14 +705,12 @@ windows_per_inferior::handle_access_violation
 }
 
 /* Resume thread specified by ID, or all artificially suspended
-   threads, if we are continuing execution.  KILLED non-zero means we
-   have killed the inferior, so we should ignore weird errors due to
-   threads shutting down.  LAST_CALL is true if we expect this to be
-   the last call to continue the inferior -- we are either mourning it
-   or detaching.  */
+   threads, if we are continuing execution.  See description of
+   windows_continue_flags for CONT_FLAGS.  */
+
 BOOL
 windows_nat_target::windows_continue (DWORD continue_status, int id,
-				      int killed, bool last_call)
+				      windows_continue_flags cont_flags)
 {
   windows_process->desired_stop_thread_id = id;
 
@@ -728,6 +726,7 @@ windows_nat_target::windows_continue (DWORD continue_status, int id,
   for (auto &th : windows_process->thread_list)
     if (id == -1 || id == (int) th->tid)
       {
+	bool killed = (cont_flags & WCONT_KILLED) != 0;
 	thread_context_continue (th.get (), killed);
 
 	th->resume ();
@@ -735,7 +734,7 @@ windows_nat_target::windows_continue (DWORD continue_status, int id,
 
   continue_last_debug_event_main_thread
     (_("Failed to resume program execution"), continue_status,
-     last_call);
+     cont_flags & WCONT_LAST_CALL);
 
   return TRUE;
 }
@@ -832,9 +831,9 @@ windows_nat_target::resume (ptid_t ptid, int step, enum gdb_signal sig)
      Otherwise complain.  */
 
   if (resume_all)
-    windows_continue (continue_status, -1, 0);
+    windows_continue (continue_status, -1);
   else
-    windows_continue (continue_status, ptid.lwp (), 0);
+    windows_continue (continue_status, ptid.lwp ());
 }
 
 /* Interrupt the inferior.  */
@@ -1538,7 +1537,7 @@ windows_nat_target::detach (inferior *inf, int from_tty)
   if (m_continued)
     break_out_process_thread (process_alive);
 
-  windows_continue (DBG_CONTINUE, -1, 0, true);
+  windows_continue (DBG_CONTINUE, -1, WCONT_LAST_CALL);
 
   std::optional<unsigned> err;
   if (process_alive)
@@ -2286,13 +2285,13 @@ windows_nat_target::create_inferior (const char *exec_file,
 
   do_initial_windows_stuff (pi.dwProcessId, 0);
 
-  /* windows_continue (DBG_CONTINUE, -1, 0); */
+  /* windows_continue (DBG_CONTINUE, -1); */
 }
 
 void
 windows_nat_target::mourn_inferior ()
 {
-  (void) windows_continue (DBG_CONTINUE, -1, 0, true);
+  windows_continue (DBG_CONTINUE, -1, WCONT_LAST_CALL);
   cleanup_windows_arch ();
   if (windows_process->open_process_used)
     {
@@ -2350,7 +2349,7 @@ windows_nat_target::kill ()
 
   for (;;)
     {
-      if (!windows_continue (DBG_CONTINUE, -1, 1))
+      if (!windows_continue (DBG_CONTINUE, -1, WCONT_KILLED))
 	break;
       wait_for_debug_event_main_thread (&windows_process->current_event);
       if (windows_process->current_event.dwDebugEventCode
diff --git a/gdb/windows-nat.h b/gdb/windows-nat.h
index 8866408567c..c4f3b2423b6 100644
--- a/gdb/windows-nat.h
+++ b/gdb/windows-nat.h
@@ -44,6 +44,22 @@ struct windows_solib
   std::string name;
 };
 
+/* Flags that can be passed to windows_continue.  */
+
+enum windows_continue_flag
+  {
+    /* This means we have killed the inferior, so windows_continue
+       should ignore weird errors due to threads shutting down.  */
+    WCONT_KILLED = 1,
+
+    /* This means we expect this windows_continue call to be the last
+       call to continue the inferior -- we are either mourning it or
+       detaching.  */
+    WCONT_LAST_CALL = 2,
+  };
+
+DEF_ENUM_FLAGS_TYPE (windows_continue_flag, windows_continue_flags);
+
 struct windows_per_inferior : public windows_nat::windows_process_info
 {
   windows_thread_info *find_thread (ptid_t ptid) override;
@@ -227,8 +243,8 @@ private:
   void delete_thread (ptid_t ptid, DWORD exit_code, bool main_thread_p);
   DWORD fake_create_process ();
 
-  BOOL windows_continue (DWORD continue_status, int id, int killed,
-			 bool last_call = false);
+  BOOL windows_continue (DWORD continue_status, int id,
+			 windows_continue_flags cont_flags = 0);
 
   /* Helper function to start process_thread.  */
   static DWORD WINAPI process_thread_starter (LPVOID self);