Remove some globals from nat/windows-nat.c

nat/windows-nat.c has a number of globals that it uses to communicate
with its clients (gdb and gdbserver).  However, if we ever want the
Windows ports to be multi-inferior, globals won't work.

This patch takes a step toward that by moving most nat/windows-nat.c
globals into a new struct windows_process_info.  Many functions are
converted to be methods on this object.

A couple of globals remain, as they are needed to truly be global due
to the way that the Windows debugging APIs work.

The clients still have a global for the current process.  That is,
this patch is a step toward the end goal, but doesn't implement the
goal itself.

1 files changed, 133 insertions, 112 deletions

diff --git a/gdbserver/win32-low.cc b/gdbserver/win32-low.cc
index e19bc2b..8437c69 100644
--- a/gdbserver/win32-low.cc
+++ b/gdbserver/win32-low.cc
@@ -38,6 +38,8 @@
 
 using namespace windows_nat;
 
+static windows_process_info windows_process;
+
 #ifndef USE_WIN32API
 #include <sys/cygwin.h>
 #endif
@@ -163,7 +165,8 @@ win32_require_context (windows_thread_info *th)
 /* See nat/windows-nat.h.  */
 
 windows_thread_info *
-windows_nat::thread_rec (ptid_t ptid, thread_disposition_type disposition)
+windows_nat::windows_process_info::thread_rec
+     (ptid_t ptid, thread_disposition_type disposition)
 {
   thread_info *thread = find_thread_ptid (ptid);
   if (thread == NULL)
@@ -182,7 +185,7 @@ child_add_thread (DWORD pid, DWORD tid, HANDLE h, void *tlb)
   windows_thread_info *th;
   ptid_t ptid = ptid_t (pid, tid, 0);
 
-  if ((th = thread_rec (ptid, DONT_INVALIDATE_CONTEXT)))
+  if ((th = windows_process.thread_rec (ptid, DONT_INVALIDATE_CONTEXT)))
     return th;
 
   CORE_ADDR base = (CORE_ADDR) (uintptr_t) tlb;
@@ -295,15 +298,15 @@ child_xfer_memory (CORE_ADDR memaddr, char *our, int len,
 
   if (write)
     {
-      success = WriteProcessMemory (current_process_handle, (LPVOID) addr,
+      success = WriteProcessMemory (windows_process.handle, (LPVOID) addr,
 				    (LPCVOID) our, len, &done);
       if (!success)
 	lasterror = GetLastError ();
-      FlushInstructionCache (current_process_handle, (LPCVOID) addr, len);
+      FlushInstructionCache (windows_process.handle, (LPCVOID) addr, len);
     }
   else
     {
-      success = ReadProcessMemory (current_process_handle, (LPCVOID) addr,
+      success = ReadProcessMemory (windows_process.handle, (LPCVOID) addr,
 				   (LPVOID) our, len, &done);
       if (!success)
 	lasterror = GetLastError ();
@@ -331,17 +334,17 @@ do_initial_child_stuff (HANDLE proch, DWORD pid, int attached)
 {
   struct process_info *proc;
 
-  last_sig = GDB_SIGNAL_0;
-
-  current_process_handle = proch;
-  current_process_id = pid;
-  main_thread_id = 0;
+  windows_process.last_sig = GDB_SIGNAL_0;
+  windows_process.handle = proch;
+  windows_process.id = pid;
+  windows_process.main_thread_id = 0;
 
   soft_interrupt_requested = 0;
   faked_breakpoint = 0;
   open_process_used = true;
 
-  memset (&current_event, 0, sizeof (current_event));
+  memset (&windows_process.current_event, 0,
+	  sizeof (windows_process.current_event));
 
 #ifdef __x86_64__
   BOOL wow64;
@@ -417,7 +420,7 @@ do_initial_child_stuff (HANDLE proch, DWORD pid, int attached)
      Rather than try to work around this sort of issue, it is much
      simpler to just ignore DLL load/unload events during the startup
      phase, and then process them all in one batch now.  */
-  windows_add_all_dlls ();
+  windows_process.add_all_dlls ();
 
   child_initialization_done = 1;
 }
@@ -456,8 +459,8 @@ continue_one_thread (thread_info *thread, int thread_id)
 static BOOL
 child_continue (DWORD continue_status, int thread_id)
 {
-  desired_stop_thread_id = thread_id;
-  if (matching_pending_stop (debug_threads))
+  windows_process.desired_stop_thread_id = thread_id;
+  if (windows_process.matching_pending_stop (debug_threads))
     return TRUE;
 
   /* The inferior will only continue after the ContinueDebugEvent
@@ -476,8 +479,9 @@ static void
 child_fetch_inferior_registers (struct regcache *regcache, int r)
 {
   int regno;
-  windows_thread_info *th = thread_rec (current_thread_ptid (),
-					INVALIDATE_CONTEXT);
+  windows_thread_info *th
+    = windows_process.thread_rec (current_thread_ptid (),
+				  INVALIDATE_CONTEXT);
   if (r == -1 || r > NUM_REGS)
     child_fetch_inferior_registers (regcache, NUM_REGS);
   else
@@ -491,8 +495,9 @@ static void
 child_store_inferior_registers (struct regcache *regcache, int r)
 {
   int regno;
-  windows_thread_info *th = thread_rec (current_thread_ptid (),
-					INVALIDATE_CONTEXT);
+  windows_thread_info *th
+    = windows_process.thread_rec (current_thread_ptid (),
+				  INVALIDATE_CONTEXT);
   if (r == -1 || r == 0 || r > NUM_REGS)
     child_store_inferior_registers (regcache, NUM_REGS);
   else
@@ -671,12 +676,12 @@ win32_process_target::create_inferior (const char *program,
 
   /* Wait till we are at 1st instruction in program, return new pid
      (assuming success).  */
-  cs.last_ptid = wait (ptid_t (current_process_id), &cs.last_status, 0);
+  cs.last_ptid = wait (ptid_t (windows_process.id), &cs.last_status, 0);
 
   /* Necessary for handle_v_kill.  */
-  signal_pid = current_process_id;
+  signal_pid = windows_process.id;
 
-  return current_process_id;
+  return windows_process.id;
 }
 
 /* Attach to a running process.
@@ -712,7 +717,8 @@ win32_process_target::attach (unsigned long pid)
 /* See nat/windows-nat.h.  */
 
 int
-windows_nat::handle_output_debug_string (struct target_waitstatus *ourstatus)
+windows_nat::windows_process_info::handle_output_debug_string
+     (struct target_waitstatus *ourstatus)
 {
 #define READ_BUFFER_LEN 1024
   CORE_ADDR addr;
@@ -762,12 +768,12 @@ win32_clear_inferiors (void)
 {
   if (open_process_used)
     {
-      CloseHandle (current_process_handle);
+      CloseHandle (windows_process.handle);
       open_process_used = false;
     }
 
   for_each_thread (delete_thread_info);
-  siginfo_er.ExceptionCode = 0;
+  windows_process.siginfo_er.ExceptionCode = 0;
   clear_inferiors ();
 }
 
@@ -776,17 +782,19 @@ win32_clear_inferiors (void)
 int
 win32_process_target::kill (process_info *process)
 {
-  TerminateProcess (current_process_handle, 0);
+  TerminateProcess (windows_process.handle, 0);
   for (;;)
     {
       if (!child_continue (DBG_CONTINUE, -1))
 	break;
-      if (!wait_for_debug_event (&current_event, INFINITE))
+      if (!wait_for_debug_event (&windows_process.current_event, INFINITE))
 	break;
-      if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
+      if (windows_process.current_event.dwDebugEventCode
+	  == EXIT_PROCESS_DEBUG_EVENT)
 	break;
-      else if (current_event.dwDebugEventCode == OUTPUT_DEBUG_STRING_EVENT)
-	handle_output_debug_string (nullptr);
+      else if (windows_process.current_event.dwDebugEventCode
+	       == OUTPUT_DEBUG_STRING_EVENT)
+	windows_process.handle_output_debug_string (nullptr);
     }
 
   win32_clear_inferiors ();
@@ -806,7 +814,7 @@ win32_process_target::detach (process_info *process)
   resume.sig = 0;
   this->resume (&resume, 1);
 
-  if (!DebugActiveProcessStop (current_process_id))
+  if (!DebugActiveProcessStop (windows_process.id))
     return -1;
 
   DebugSetProcessKillOnExit (FALSE);
@@ -866,7 +874,7 @@ win32_process_target::resume (thread_resume *resume_info, size_t n)
   else
     /* Yes, we're ignoring resume_info[0].thread.  It'd be tricky to make
        the Windows resume code do the right thing for thread switching.  */
-    tid = current_event.dwThreadId;
+    tid = windows_process.current_event.dwThreadId;
 
   if (resume_info[0].thread != minus_one_ptid)
     {
@@ -881,23 +889,24 @@ win32_process_target::resume (thread_resume *resume_info, size_t n)
 
   if (sig != GDB_SIGNAL_0)
     {
-      if (current_event.dwDebugEventCode != EXCEPTION_DEBUG_EVENT)
+      if (windows_process.current_event.dwDebugEventCode
+	  != EXCEPTION_DEBUG_EVENT)
 	{
 	  OUTMSG (("Cannot continue with signal %s here.\n",
 		   gdb_signal_to_string (sig)));
 	}
-      else if (sig == last_sig)
+      else if (sig == windows_process.last_sig)
 	continue_status = DBG_EXCEPTION_NOT_HANDLED;
       else
 	OUTMSG (("Can only continue with received signal %s.\n",
-		 gdb_signal_to_string (last_sig)));
+		 gdb_signal_to_string (windows_process.last_sig)));
     }
 
-  last_sig = GDB_SIGNAL_0;
+  windows_process.last_sig = GDB_SIGNAL_0;
 
   /* Get context for the currently selected thread.  */
-  ptid = debug_event_ptid (&current_event);
-  th = thread_rec (ptid, DONT_INVALIDATE_CONTEXT);
+  ptid = debug_event_ptid (&windows_process.current_event);
+  th = windows_process.thread_rec (ptid, DONT_INVALIDATE_CONTEXT);
   if (th)
     {
       win32_prepare_to_resume (th);
@@ -938,7 +947,8 @@ win32_process_target::resume (thread_resume *resume_info, size_t n)
 /* See nat/windows-nat.h.  */
 
 void
-windows_nat::handle_load_dll (const char *name, LPVOID base)
+windows_nat::windows_process_info::handle_load_dll (const char *name,
+						    LPVOID base)
 {
   CORE_ADDR load_addr = (CORE_ADDR) (uintptr_t) base;
 
@@ -992,7 +1002,7 @@ windows_nat::handle_load_dll (const char *name, LPVOID base)
 /* See nat/windows-nat.h.  */
 
 void
-windows_nat::handle_unload_dll ()
+windows_nat::windows_process_info::handle_unload_dll ()
 {
   CORE_ADDR load_addr =
 	  (CORE_ADDR) (uintptr_t) current_event.u.UnloadDll.lpBaseOfDll;
@@ -1019,10 +1029,11 @@ fake_breakpoint_event (void)
 
   faked_breakpoint = 1;
 
-  memset (&current_event, 0, sizeof (current_event));
-  current_event.dwThreadId = main_thread_id;
-  current_event.dwDebugEventCode = EXCEPTION_DEBUG_EVENT;
-  current_event.u.Exception.ExceptionRecord.ExceptionCode
+  memset (&windows_process.current_event, 0,
+	  sizeof (windows_process.current_event));
+  windows_process.current_event.dwThreadId = windows_process.main_thread_id;
+  windows_process.current_event.dwDebugEventCode = EXCEPTION_DEBUG_EVENT;
+  windows_process.current_event.u.Exception.ExceptionRecord.ExceptionCode
     = EXCEPTION_BREAKPOINT;
 
   for_each_thread (suspend_one_thread);
@@ -1031,7 +1042,8 @@ fake_breakpoint_event (void)
 /* See nat/windows-nat.h.  */
 
 bool
-windows_nat::handle_ms_vc_exception (const EXCEPTION_RECORD *rec)
+windows_nat::windows_process_info::handle_ms_vc_exception
+     (const EXCEPTION_RECORD *rec)
 {
   return false;
 }
@@ -1039,7 +1051,8 @@ windows_nat::handle_ms_vc_exception (const EXCEPTION_RECORD *rec)
 /* See nat/windows-nat.h.  */
 
 bool
-windows_nat::handle_access_violation (const EXCEPTION_RECORD *rec)
+windows_nat::windows_process_info::handle_access_violation
+     (const EXCEPTION_RECORD *rec)
 {
   return false;
 }
@@ -1054,14 +1067,15 @@ maybe_adjust_pc ()
   struct regcache *regcache = get_thread_regcache (current_thread, 1);
   child_fetch_inferior_registers (regcache, -1);
 
-  windows_thread_info *th = thread_rec (current_thread_ptid (),
-					DONT_INVALIDATE_CONTEXT);
+  windows_thread_info *th
+    = windows_process.thread_rec (current_thread_ptid (),
+				  DONT_INVALIDATE_CONTEXT);
   th->stopped_at_software_breakpoint = false;
 
-  if (current_event.dwDebugEventCode == EXCEPTION_DEBUG_EVENT
-      && ((current_event.u.Exception.ExceptionRecord.ExceptionCode
+  if (windows_process.current_event.dwDebugEventCode == EXCEPTION_DEBUG_EVENT
+      && ((windows_process.current_event.u.Exception.ExceptionRecord.ExceptionCode
 	   == EXCEPTION_BREAKPOINT)
-	  || (current_event.u.Exception.ExceptionRecord.ExceptionCode
+	  || (windows_process.current_event.u.Exception.ExceptionRecord.ExceptionCode
 	      == STATUS_WX86_BREAKPOINT))
       && child_initialization_done)
     {
@@ -1080,13 +1094,15 @@ get_child_debug_event (DWORD *continue_status,
 {
   ptid_t ptid;
 
-  last_sig = GDB_SIGNAL_0;
+  windows_process.last_sig = GDB_SIGNAL_0;
   ourstatus->set_spurious ();
   *continue_status = DBG_CONTINUE;
 
   /* Check if GDB sent us an interrupt request.  */
   check_remote_input_interrupt_request ();
 
+  DEBUG_EVENT *current_event = &windows_process.current_event;
+
   if (soft_interrupt_requested)
     {
       soft_interrupt_requested = 0;
@@ -1096,12 +1112,13 @@ get_child_debug_event (DWORD *continue_status,
 
   attaching = 0;
   {
-    gdb::optional<pending_stop> stop = fetch_pending_stop (debug_threads);
+    gdb::optional<pending_stop> stop
+      = windows_process.fetch_pending_stop (debug_threads);
     if (stop.has_value ())
       {
 	*ourstatus = stop->status;
-	current_event = stop->event;
-	ptid = debug_event_ptid (&current_event);
+	windows_process.current_event = stop->event;
+	ptid = debug_event_ptid (&windows_process.current_event);
 	switch_to_thread (find_thread_ptid (ptid));
 	return 1;
       }
@@ -1109,7 +1126,7 @@ get_child_debug_event (DWORD *continue_status,
     /* Keep the wait time low enough for comfortable remote
        interruption, but high enough so gdbserver doesn't become a
        bottleneck.  */
-    if (!wait_for_debug_event (&current_event, 250))
+    if (!wait_for_debug_event (&windows_process.current_event, 250))
       {
 	DWORD e  = GetLastError();
 
@@ -1129,28 +1146,28 @@ get_child_debug_event (DWORD *continue_status,
 
  gotevent:
 
-  switch (current_event.dwDebugEventCode)
+  switch (current_event->dwDebugEventCode)
     {
     case CREATE_THREAD_DEBUG_EVENT:
       OUTMSG2 (("gdbserver: kernel event CREATE_THREAD_DEBUG_EVENT "
 		"for pid=%u tid=%x)\n",
-		(unsigned) current_event.dwProcessId,
-		(unsigned) current_event.dwThreadId));
+		(unsigned) current_event->dwProcessId,
+		(unsigned) current_event->dwThreadId));
 
       /* Record the existence of this thread.  */
-      child_add_thread (current_event.dwProcessId,
-			current_event.dwThreadId,
-			current_event.u.CreateThread.hThread,
-			current_event.u.CreateThread.lpThreadLocalBase);
+      child_add_thread (current_event->dwProcessId,
+			current_event->dwThreadId,
+			current_event->u.CreateThread.hThread,
+			current_event->u.CreateThread.lpThreadLocalBase);
       break;
 
     case EXIT_THREAD_DEBUG_EVENT:
       OUTMSG2 (("gdbserver: kernel event EXIT_THREAD_DEBUG_EVENT "
 		"for pid=%u tid=%x\n",
-		(unsigned) current_event.dwProcessId,
-		(unsigned) current_event.dwThreadId));
-      child_delete_thread (current_event.dwProcessId,
-			   current_event.dwThreadId);
+		(unsigned) current_event->dwProcessId,
+		(unsigned) current_event->dwThreadId));
+      child_delete_thread (current_event->dwProcessId,
+			   current_event->dwThreadId);
 
       switch_to_thread (get_first_thread ());
       return 1;
@@ -1158,33 +1175,33 @@ get_child_debug_event (DWORD *continue_status,
     case CREATE_PROCESS_DEBUG_EVENT:
       OUTMSG2 (("gdbserver: kernel event CREATE_PROCESS_DEBUG_EVENT "
 		"for pid=%u tid=%x\n",
-		(unsigned) current_event.dwProcessId,
-		(unsigned) current_event.dwThreadId));
-      CloseHandle (current_event.u.CreateProcessInfo.hFile);
+		(unsigned) current_event->dwProcessId,
+		(unsigned) current_event->dwThreadId));
+      CloseHandle (current_event->u.CreateProcessInfo.hFile);
 
       if (open_process_used)
 	{
-	  CloseHandle (current_process_handle);
+	  CloseHandle (windows_process.handle);
 	  open_process_used = false;
 	}
 
-      current_process_handle = current_event.u.CreateProcessInfo.hProcess;
-      main_thread_id = current_event.dwThreadId;
+      windows_process.handle = current_event->u.CreateProcessInfo.hProcess;
+      windows_process.main_thread_id = current_event->dwThreadId;
 
       /* Add the main thread.  */
-      child_add_thread (current_event.dwProcessId,
-			main_thread_id,
-			current_event.u.CreateProcessInfo.hThread,
-			current_event.u.CreateProcessInfo.lpThreadLocalBase);
+      child_add_thread (current_event->dwProcessId,
+			windows_process.main_thread_id,
+			current_event->u.CreateProcessInfo.hThread,
+			current_event->u.CreateProcessInfo.lpThreadLocalBase);
       break;
 
     case EXIT_PROCESS_DEBUG_EVENT:
       OUTMSG2 (("gdbserver: kernel event EXIT_PROCESS_DEBUG_EVENT "
 		"for pid=%u tid=%x\n",
-		(unsigned) current_event.dwProcessId,
-		(unsigned) current_event.dwThreadId));
+		(unsigned) current_event->dwProcessId,
+		(unsigned) current_event->dwThreadId));
       {
-	DWORD exit_status = current_event.u.ExitProcess.dwExitCode;
+	DWORD exit_status = current_event->u.ExitProcess.dwExitCode;
 	/* If the exit status looks like a fatal exception, but we
 	   don't recognize the exception's code, make the original
 	   exit status value available, to avoid losing information.  */
@@ -1195,18 +1212,18 @@ get_child_debug_event (DWORD *continue_status,
 	else
 	  ourstatus->set_signalled (gdb_signal_from_host (exit_signal));
       }
-      child_continue (DBG_CONTINUE, desired_stop_thread_id);
+      child_continue (DBG_CONTINUE, windows_process.desired_stop_thread_id);
       break;
 
     case LOAD_DLL_DEBUG_EVENT:
       OUTMSG2 (("gdbserver: kernel event LOAD_DLL_DEBUG_EVENT "
 		"for pid=%u tid=%x\n",
-		(unsigned) current_event.dwProcessId,
-		(unsigned) current_event.dwThreadId));
-      CloseHandle (current_event.u.LoadDll.hFile);
+		(unsigned) current_event->dwProcessId,
+		(unsigned) current_event->dwThreadId));
+      CloseHandle (current_event->u.LoadDll.hFile);
       if (! child_initialization_done)
 	break;
-      dll_loaded_event ();
+      windows_process.dll_loaded_event ();
 
       ourstatus->set_loaded ();
       break;
@@ -1214,20 +1231,20 @@ get_child_debug_event (DWORD *continue_status,
     case UNLOAD_DLL_DEBUG_EVENT:
       OUTMSG2 (("gdbserver: kernel event UNLOAD_DLL_DEBUG_EVENT "
 		"for pid=%u tid=%x\n",
-		(unsigned) current_event.dwProcessId,
-		(unsigned) current_event.dwThreadId));
+		(unsigned) current_event->dwProcessId,
+		(unsigned) current_event->dwThreadId));
       if (! child_initialization_done)
 	break;
-      handle_unload_dll ();
+      windows_process.handle_unload_dll ();
       ourstatus->set_loaded ();
       break;
 
     case EXCEPTION_DEBUG_EVENT:
       OUTMSG2 (("gdbserver: kernel event EXCEPTION_DEBUG_EVENT "
 		"for pid=%u tid=%x\n",
-		(unsigned) current_event.dwProcessId,
-		(unsigned) current_event.dwThreadId));
-      if (handle_exception (ourstatus, debug_threads)
+		(unsigned) current_event->dwProcessId,
+		(unsigned) current_event->dwThreadId));
+      if (windows_process.handle_exception (ourstatus, debug_threads)
 	  == HANDLE_EXCEPTION_UNHANDLED)
 	*continue_status = DBG_EXCEPTION_NOT_HANDLED;
       break;
@@ -1236,31 +1253,33 @@ get_child_debug_event (DWORD *continue_status,
       /* A message from the kernel (or Cygwin).  */
       OUTMSG2 (("gdbserver: kernel event OUTPUT_DEBUG_STRING_EVENT "
 		"for pid=%u tid=%x\n",
-		(unsigned) current_event.dwProcessId,
-		(unsigned) current_event.dwThreadId));
-      handle_output_debug_string (nullptr);
+		(unsigned) current_event->dwProcessId,
+		(unsigned) current_event->dwThreadId));
+      windows_process.handle_output_debug_string (nullptr);
       break;
 
     default:
       OUTMSG2 (("gdbserver: kernel event unknown "
 		"for pid=%u tid=%x code=%x\n",
-		(unsigned) current_event.dwProcessId,
-		(unsigned) current_event.dwThreadId,
-		(unsigned) current_event.dwDebugEventCode));
+		(unsigned) current_event->dwProcessId,
+		(unsigned) current_event->dwThreadId,
+		(unsigned) current_event->dwDebugEventCode));
       break;
     }
 
-  ptid = debug_event_ptid (&current_event);
+  ptid = debug_event_ptid (&windows_process.current_event);
 
-  if (desired_stop_thread_id != -1 && desired_stop_thread_id != ptid.lwp ())
+  if (windows_process.desired_stop_thread_id != -1
+      && windows_process.desired_stop_thread_id != ptid.lwp ())
     {
       /* Pending stop.  See the comment by the definition of
 	 "pending_stops" for details on why this is needed.  */
       OUTMSG2 (("get_windows_debug_event - "
 		"unexpected stop in 0x%lx (expecting 0x%x)\n",
-		ptid.lwp (), desired_stop_thread_id));
+		ptid.lwp (), windows_process.desired_stop_thread_id));
       maybe_adjust_pc ();
-      pending_stops.push_back ({(DWORD) ptid.lwp (), *ourstatus, current_event});
+      windows_process.pending_stops.push_back
+	({(DWORD) ptid.lwp (), *ourstatus, *current_event});
       ourstatus->set_spurious ();
     }
   else
@@ -1284,7 +1303,7 @@ win32_process_target::wait (ptid_t ptid, target_waitstatus *ourstatus,
 	 fails).  Report it now.  */
       *ourstatus = cached_status;
       cached_status.set_ignore ();
-      return debug_event_ptid (&current_event);
+      return debug_event_ptid (&windows_process.current_event);
     }
 
   while (1)
@@ -1299,7 +1318,7 @@ win32_process_target::wait (ptid_t ptid, target_waitstatus *ourstatus,
 	  OUTMSG2 (("Child exited with retcode = %x\n",
 		    ourstatus->exit_status ()));
 	  win32_clear_inferiors ();
-	  return ptid_t (current_event.dwProcessId);
+	  return ptid_t (windows_process.current_event.dwProcessId);
 	case TARGET_WAITKIND_STOPPED:
 	case TARGET_WAITKIND_SIGNALLED:
 	case TARGET_WAITKIND_LOADED:
@@ -1307,7 +1326,7 @@ win32_process_target::wait (ptid_t ptid, target_waitstatus *ourstatus,
 	    OUTMSG2 (("Child Stopped with signal = %d \n",
 		      ourstatus->sig ()));
 	    maybe_adjust_pc ();
-	    return debug_event_ptid (&current_event);
+	    return debug_event_ptid (&windows_process.current_event);
 	  }
 	default:
 	  OUTMSG (("Ignoring unknown internal event, %d\n",
@@ -1315,7 +1334,8 @@ win32_process_target::wait (ptid_t ptid, target_waitstatus *ourstatus,
 	  /* fall-through */
 	case TARGET_WAITKIND_SPURIOUS:
 	  /* do nothing, just continue */
-	  child_continue (continue_status, desired_stop_thread_id);
+	  child_continue (continue_status,
+			  windows_process.desired_stop_thread_id);
 	  break;
 	}
     }
@@ -1362,7 +1382,7 @@ win32_process_target::write_memory (CORE_ADDR memaddr,
 void
 win32_process_target::request_interrupt ()
 {
-  if (GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT, current_process_id))
+  if (GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT, windows_process.id))
     return;
 
   /* GenerateConsoleCtrlEvent can fail if process id being debugged is
@@ -1370,7 +1390,7 @@ win32_process_target::request_interrupt ()
      Fallback to XP/Vista 'DebugBreakProcess', which generates a
      breakpoint exception in the interior process.  */
 
-  if (DebugBreakProcess (current_process_handle))
+  if (DebugBreakProcess (windows_process.handle))
     return;
 
   /* Last resort, suspend all threads manually.  */
@@ -1397,14 +1417,14 @@ win32_process_target::qxfer_siginfo (const char *annex,
 				     unsigned const char *writebuf,
 				     CORE_ADDR offset, int len)
 {
-  if (siginfo_er.ExceptionCode == 0)
+  if (windows_process.siginfo_er.ExceptionCode == 0)
     return -1;
 
   if (readbuf == nullptr)
     return -1;
 
-  char *buf = (char *) &siginfo_er;
-  size_t bufsize = sizeof (siginfo_er);
+  char *buf = (char *) &windows_process.siginfo_er;
+  size_t bufsize = sizeof (windows_process.siginfo_er);
 
 #ifdef __x86_64__
   EXCEPTION_RECORD32 er32;
@@ -1447,7 +1467,7 @@ int
 win32_process_target::get_tib_address (ptid_t ptid, CORE_ADDR *addr)
 {
   windows_thread_info *th;
-  th = thread_rec (ptid, DONT_INVALIDATE_CONTEXT);
+  th = windows_process.thread_rec (ptid, DONT_INVALIDATE_CONTEXT);
   if (th == NULL)
     return 0;
   if (addr != NULL)
@@ -1467,8 +1487,9 @@ win32_process_target::sw_breakpoint_from_kind (int kind, int *size)
 bool
 win32_process_target::stopped_by_sw_breakpoint ()
 {
-  windows_thread_info *th = thread_rec (current_thread_ptid (),
-					DONT_INVALIDATE_CONTEXT);
+  windows_thread_info *th
+    = windows_process.thread_rec (current_thread_ptid (),
+				  DONT_INVALIDATE_CONTEXT);
   return th == nullptr ? false : th->stopped_at_software_breakpoint;
 }