diff mbox series

[12/34] Windows gdb: Introduce windows_continue_flags

Message ID 20240507234233.371123-13-pedro@palves.net
State New
Headers
Series Windows non-stop mode |

Checks

Context Check Description
linaro-tcwg-bot/tcwg_gdb_build--master-aarch64 success Testing passed
linaro-tcwg-bot/tcwg_gdb_build--master-arm success Testing passed
linaro-tcwg-bot/tcwg_gdb_check--master-arm success Testing passed
linaro-tcwg-bot/tcwg_gdb_check--master-aarch64 success Testing passed

Commit Message

Pedro Alves May 7, 2024, 11:42 p.m. UTC 
  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.

Change-Id: I17c4d8a12b662190f972c380f838cb3317bd2e1e
---
 gdb/windows-nat.c | 48 ++++++++++++++++++++++++++++++-----------------
 1 file changed, 31 insertions(+), 17 deletions(-)

Comments

Tom Tromey May 8, 2024, 3:16 p.m. UTC | #1 
>>>>> "Pedro" == Pedro Alves <pedro@palves.net> writes:

Pedro> windows_continue already has two boolean parameters:
Pedro>   (..., int killed, bool last_call = false)

Pedro> A patch later in the series would need a third.  Instead, convert
Pedro> windows_continue to use an optional enum-flags parameter instead of
Pedro> multiple booleans.

Very nice, thank you.
Approved-By: Tom Tromey <tom@tromey.com>

Tom
diff mbox series

Patch

diff --git a/gdb/windows-nat.c b/gdb/windows-nat.c
index 93ba7850c88..3993820ddab 100644
--- a/gdb/windows-nat.c
+++ b/gdb/windows-nat.c
@@ -88,6 +88,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_process_info
 {
   windows_thread_info *find_thread (ptid_t ptid) override;
@@ -332,8 +348,8 @@  struct windows_nat_target final : public x86_nat_target<inf_child_target>
   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);
@@ -1258,14 +1274,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
+   windows_continue_flags' description 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;
 
@@ -1308,7 +1322,7 @@  windows_nat_target::windows_continue (DWORD continue_status, int id,
 		    BOOL status = Wow64SetThreadContext (th->h,
 							 &th->wow64_context);
 
-		    if (!killed)
+		    if ((cont_flags & WCONT_KILLED) == 0)
 		      CHECK (status);
 		  }
 		th->wow64_context.ContextFlags = 0;
@@ -1337,7 +1351,7 @@  windows_nat_target::windows_continue (DWORD continue_status, int id,
 		  {
 		    BOOL status = SetThreadContext (th->h, &th->context);
 
-		    if (!killed)
+		    if ((cont_flags & WCONT_KILLED) == 0)
 		      CHECK (status);
 		  }
 		th->context.ContextFlags = 0;
@@ -1348,7 +1362,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;
 }
@@ -1464,9 +1478,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.  */
@@ -2174,7 +2188,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)
@@ -2922,13 +2936,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);
   x86_cleanup_dregs();
   if (windows_process.open_process_used)
     {
@@ -2986,7 +3000,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