1 /* Low level interface to Windows debugging, for gdbserver.
2 Copyright (C) 2006-2020 Free Software Foundation, Inc.
4 Contributed by Leo Zayas. Based on "win32-nat.c" from GDB.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "gdb/fileio.h"
24 #include "mem-break.h"
25 #include "win32-low.h"
26 #include "gdbthread.h"
35 #include "gdbsupport/gdb_tilde_expand.h"
36 #include "gdbsupport/common-inferior.h"
37 #include "gdbsupport/gdb_wait.h"
39 using namespace windows_nat
;
42 #include <sys/cygwin.h>
45 #define OUTMSG(X) do { printf X; fflush (stderr); } while (0)
58 #define _T(x) TEXT (x)
62 #define COUNTOF(STR) (sizeof (STR) / sizeof ((STR)[0]))
66 # define GETPROCADDRESS(DLL, PROC) \
67 ((winapi_ ## PROC) GetProcAddress (DLL, TEXT (#PROC)))
69 # define GETPROCADDRESS(DLL, PROC) \
70 ((winapi_ ## PROC) GetProcAddress (DLL, #PROC))
73 int using_threads
= 1;
76 static int attaching
= 0;
78 /* A status that hasn't been reported to the core yet, and so
79 win32_wait should return it next, instead of fetching the next
80 debug event off the win32 API. */
81 static struct target_waitstatus cached_status
;
83 /* Non zero if an interrupt request is to be satisfied by suspending
85 static int soft_interrupt_requested
= 0;
87 /* Non zero if the inferior is stopped in a simulated breakpoint done
88 by suspending all the threads. */
89 static int faked_breakpoint
= 0;
91 const struct target_desc
*win32_tdesc
;
93 #define NUM_REGS (the_low_target.num_regs)
95 typedef BOOL (WINAPI
*winapi_DebugActiveProcessStop
) (DWORD dwProcessId
);
96 typedef BOOL (WINAPI
*winapi_DebugSetProcessKillOnExit
) (BOOL KillOnExit
);
97 typedef BOOL (WINAPI
*winapi_DebugBreakProcess
) (HANDLE
);
98 typedef BOOL (WINAPI
*winapi_GenerateConsoleCtrlEvent
) (DWORD
, DWORD
);
101 static void win32_add_all_dlls (void);
104 /* Get the thread ID from the current selected inferior (the current
107 current_thread_ptid (void)
112 /* The current debug event from WaitForDebugEvent. */
114 debug_event_ptid (DEBUG_EVENT
*event
)
116 return ptid_t (event
->dwProcessId
, event
->dwThreadId
, 0);
119 /* Get the thread context of the thread associated with TH. */
122 win32_get_thread_context (windows_thread_info
*th
)
124 memset (&th
->context
, 0, sizeof (CONTEXT
));
125 (*the_low_target
.get_thread_context
) (th
);
127 memcpy (&th
->base_context
, &th
->context
, sizeof (CONTEXT
));
131 /* Set the thread context of the thread associated with TH. */
134 win32_set_thread_context (windows_thread_info
*th
)
137 /* Calling SuspendThread on a thread that is running kernel code
138 will report that the suspending was successful, but in fact, that
139 will often not be true. In those cases, the context returned by
140 GetThreadContext will not be correct by the time the thread
141 stops, hence we can't set that context back into the thread when
142 resuming - it will most likely crash the inferior.
143 Unfortunately, there is no way to know when the thread will
144 really stop. To work around it, we'll only write the context
145 back to the thread when either the user or GDB explicitly change
146 it between stopping and resuming. */
147 if (memcmp (&th
->context
, &th
->base_context
, sizeof (CONTEXT
)) != 0)
149 SetThreadContext (th
->h
, &th
->context
);
152 /* Set the thread context of the thread associated with TH. */
155 win32_prepare_to_resume (windows_thread_info
*th
)
157 if (the_low_target
.prepare_to_resume
!= NULL
)
158 (*the_low_target
.prepare_to_resume
) (th
);
161 /* See win32-low.h. */
164 win32_require_context (windows_thread_info
*th
)
166 if (th
->context
.ContextFlags
== 0)
169 win32_get_thread_context (th
);
173 /* See nat/windows-nat.h. */
175 windows_thread_info
*
176 windows_nat::thread_rec (ptid_t ptid
, thread_disposition_type disposition
)
178 thread_info
*thread
= find_thread_ptid (ptid
);
182 windows_thread_info
*th
= (windows_thread_info
*) thread_target_data (thread
);
183 if (disposition
!= DONT_INVALIDATE_CONTEXT
)
184 win32_require_context (th
);
188 /* Add a thread to the thread list. */
189 static windows_thread_info
*
190 child_add_thread (DWORD pid
, DWORD tid
, HANDLE h
, void *tlb
)
192 windows_thread_info
*th
;
193 ptid_t ptid
= ptid_t (pid
, tid
, 0);
195 if ((th
= thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
)))
198 th
= new windows_thread_info (tid
, h
, (CORE_ADDR
) (uintptr_t) tlb
);
200 add_thread (ptid
, th
);
202 if (the_low_target
.thread_added
!= NULL
)
203 (*the_low_target
.thread_added
) (th
);
208 /* Delete a thread from the list of threads. */
210 delete_thread_info (thread_info
*thread
)
212 windows_thread_info
*th
= (windows_thread_info
*) thread_target_data (thread
);
214 remove_thread (thread
);
218 /* Delete a thread from the list of threads. */
220 child_delete_thread (DWORD pid
, DWORD tid
)
222 /* If the last thread is exiting, just return. */
223 if (all_threads
.size () == 1)
226 thread_info
*thread
= find_thread_ptid (ptid_t (pid
, tid
));
230 delete_thread_info (thread
);
233 /* These watchpoint related wrapper functions simply pass on the function call
234 if the low target has registered a corresponding function. */
237 win32_process_target::supports_z_point_type (char z_type
)
239 return (the_low_target
.supports_z_point_type
!= NULL
240 && the_low_target
.supports_z_point_type (z_type
));
244 win32_process_target::insert_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
245 int size
, raw_breakpoint
*bp
)
247 if (the_low_target
.insert_point
!= NULL
)
248 return the_low_target
.insert_point (type
, addr
, size
, bp
);
250 /* Unsupported (see target.h). */
255 win32_process_target::remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
256 int size
, raw_breakpoint
*bp
)
258 if (the_low_target
.remove_point
!= NULL
)
259 return the_low_target
.remove_point (type
, addr
, size
, bp
);
261 /* Unsupported (see target.h). */
266 win32_process_target::stopped_by_watchpoint ()
268 if (the_low_target
.stopped_by_watchpoint
!= NULL
)
269 return the_low_target
.stopped_by_watchpoint ();
275 win32_process_target::stopped_data_address ()
277 if (the_low_target
.stopped_data_address
!= NULL
)
278 return the_low_target
.stopped_data_address ();
284 /* Transfer memory from/to the debugged process. */
286 child_xfer_memory (CORE_ADDR memaddr
, char *our
, int len
,
287 int write
, process_stratum_target
*target
)
292 uintptr_t addr
= (uintptr_t) memaddr
;
296 success
= WriteProcessMemory (current_process_handle
, (LPVOID
) addr
,
297 (LPCVOID
) our
, len
, &done
);
299 lasterror
= GetLastError ();
300 FlushInstructionCache (current_process_handle
, (LPCVOID
) addr
, len
);
304 success
= ReadProcessMemory (current_process_handle
, (LPCVOID
) addr
,
305 (LPVOID
) our
, len
, &done
);
307 lasterror
= GetLastError ();
309 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
312 return success
? done
: -1;
315 /* Clear out any old thread list and reinitialize it to a pristine
318 child_init_thread_list (void)
320 for_each_thread (delete_thread_info
);
323 /* Zero during the child initialization phase, and nonzero otherwise. */
325 static int child_initialization_done
= 0;
328 do_initial_child_stuff (HANDLE proch
, DWORD pid
, int attached
)
330 struct process_info
*proc
;
332 last_sig
= GDB_SIGNAL_0
;
334 current_process_handle
= proch
;
335 current_process_id
= pid
;
338 soft_interrupt_requested
= 0;
339 faked_breakpoint
= 0;
341 memset (¤t_event
, 0, sizeof (current_event
));
343 proc
= add_process (pid
, attached
);
344 proc
->tdesc
= win32_tdesc
;
345 child_init_thread_list ();
346 child_initialization_done
= 0;
348 if (the_low_target
.initial_stuff
!= NULL
)
349 (*the_low_target
.initial_stuff
) ();
351 cached_status
.kind
= TARGET_WAITKIND_IGNORE
;
353 /* Flush all currently pending debug events (thread and dll list) up
354 to the initial breakpoint. */
357 struct target_waitstatus status
;
359 the_target
->wait (minus_one_ptid
, &status
, 0);
361 /* Note win32_wait doesn't return thread events. */
362 if (status
.kind
!= TARGET_WAITKIND_LOADED
)
364 cached_status
= status
;
369 struct thread_resume resume
;
371 resume
.thread
= minus_one_ptid
;
372 resume
.kind
= resume_continue
;
375 the_target
->resume (&resume
, 1);
380 /* Now that the inferior has been started and all DLLs have been mapped,
381 we can iterate over all DLLs and load them in.
383 We avoid doing it any earlier because, on certain versions of Windows,
384 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
385 we have seen on Windows 8.1 that the ntdll.dll load event does not
386 include the DLL name, preventing us from creating an associated SO.
387 A possible explanation is that ntdll.dll might be mapped before
388 the SO info gets created by the Windows system -- ntdll.dll is
389 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
390 do not seem to suffer from that problem.
392 Rather than try to work around this sort of issue, it is much
393 simpler to just ignore DLL load/unload events during the startup
394 phase, and then process them all in one batch now. */
395 win32_add_all_dlls ();
398 child_initialization_done
= 1;
401 /* Resume all artificially suspended threads if we are continuing
404 continue_one_thread (thread_info
*thread
, int thread_id
)
406 windows_thread_info
*th
= (windows_thread_info
*) thread_target_data (thread
);
408 if (thread_id
== -1 || thread_id
== th
->tid
)
410 win32_prepare_to_resume (th
);
414 if (th
->context
.ContextFlags
)
416 win32_set_thread_context (th
);
417 th
->context
.ContextFlags
= 0;
426 child_continue (DWORD continue_status
, int thread_id
)
428 /* The inferior will only continue after the ContinueDebugEvent
430 for_each_thread ([&] (thread_info
*thread
)
432 continue_one_thread (thread
, thread_id
);
434 faked_breakpoint
= 0;
436 return continue_last_debug_event (continue_status
, debug_threads
);
439 /* Fetch register(s) from the current thread context. */
441 child_fetch_inferior_registers (struct regcache
*regcache
, int r
)
444 windows_thread_info
*th
= thread_rec (current_thread_ptid (),
446 if (r
== -1 || r
> NUM_REGS
)
447 child_fetch_inferior_registers (regcache
, NUM_REGS
);
449 for (regno
= 0; regno
< r
; regno
++)
450 (*the_low_target
.fetch_inferior_register
) (regcache
, th
, regno
);
453 /* Store a new register value into the current thread context. We don't
454 change the program's context until later, when we resume it. */
456 child_store_inferior_registers (struct regcache
*regcache
, int r
)
459 windows_thread_info
*th
= thread_rec (current_thread_ptid (),
461 if (r
== -1 || r
== 0 || r
> NUM_REGS
)
462 child_store_inferior_registers (regcache
, NUM_REGS
);
464 for (regno
= 0; regno
< r
; regno
++)
465 (*the_low_target
.store_inferior_register
) (regcache
, th
, regno
);
468 /* Map the Windows error number in ERROR to a locale-dependent error
469 message string and return a pointer to it. Typically, the values
470 for ERROR come from GetLastError.
472 The string pointed to shall not be modified by the application,
473 but may be overwritten by a subsequent call to strwinerror
475 The strwinerror function does not change the current setting
479 strwinerror (DWORD error
)
481 static char buf
[1024];
483 DWORD lasterr
= GetLastError ();
484 DWORD chars
= FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
485 | FORMAT_MESSAGE_ALLOCATE_BUFFER
,
488 0, /* Default language */
494 /* If there is an \r\n appended, zap it. */
496 && msgbuf
[chars
- 2] == '\r'
497 && msgbuf
[chars
- 1] == '\n')
503 if (chars
> ((COUNTOF (buf
)) - 1))
505 chars
= COUNTOF (buf
) - 1;
510 wcstombs (buf
, msgbuf
, chars
+ 1);
512 strncpy (buf
, msgbuf
, chars
+ 1);
517 sprintf (buf
, "unknown win32 error (%u)", (unsigned) error
);
519 SetLastError (lasterr
);
524 create_process (const char *program
, char *args
,
525 DWORD flags
, PROCESS_INFORMATION
*pi
)
527 const char *inferior_cwd
= get_inferior_cwd ();
529 size_t argslen
, proglen
;
531 proglen
= strlen (program
) + 1;
532 argslen
= strlen (args
) + proglen
;
535 wchar_t *p
, *wprogram
, *wargs
, *wcwd
= NULL
;
537 wprogram
= (wchar_t *) alloca (proglen
* sizeof (wchar_t));
538 mbstowcs (wprogram
, program
, proglen
);
540 for (p
= wprogram
; *p
; ++p
)
544 wargs
= alloca ((argslen
+ 1) * sizeof (wchar_t));
545 wcscpy (wargs
, wprogram
);
546 wcscat (wargs
, L
" ");
547 mbstowcs (wargs
+ proglen
, args
, argslen
+ 1 - proglen
);
549 if (inferior_cwd
!= NULL
)
551 std::string expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
552 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
554 wcwd
= alloca ((expanded_infcwd
.size () + 1) * sizeof (wchar_t));
555 if (mbstowcs (wcwd
, expanded_infcwd
.c_str (),
556 expanded_infcwd
.size () + 1) == NULL
)
559 Could not convert the expanded inferior cwd to wide-char."));
563 ret
= CreateProcessW (wprogram
, /* image name */
564 wargs
, /* command line */
565 NULL
, /* security, not supported */
566 NULL
, /* thread, not supported */
567 FALSE
, /* inherit handles, not supported */
568 flags
, /* start flags */
569 NULL
, /* environment, not supported */
570 wcwd
, /* current directory */
571 NULL
, /* start info, not supported */
574 STARTUPINFOA si
= { sizeof (STARTUPINFOA
) };
575 char *program_and_args
= (char *) alloca (argslen
+ 1);
577 strcpy (program_and_args
, program
);
578 strcat (program_and_args
, " ");
579 strcat (program_and_args
, args
);
580 ret
= CreateProcessA (program
, /* image name */
581 program_and_args
, /* command line */
584 TRUE
, /* inherit handles */
585 flags
, /* start flags */
586 NULL
, /* environment */
587 /* current directory */
588 (inferior_cwd
== NULL
590 : gdb_tilde_expand (inferior_cwd
).c_str()),
591 &si
, /* start info */
598 /* Start a new process.
599 PROGRAM is the program name.
600 PROGRAM_ARGS is the vector containing the inferior's args.
601 Returns the new PID on success, -1 on failure. Registers the new
602 process with the process list. */
604 win32_process_target::create_inferior (const char *program
,
605 const std::vector
<char *> &program_args
)
607 client_state
&cs
= get_client_state ();
609 char real_path
[PATH_MAX
];
610 char *orig_path
, *new_path
, *path_ptr
;
614 PROCESS_INFORMATION pi
;
616 std::string str_program_args
= stringify_argv (program_args
);
617 char *args
= (char *) str_program_args
.c_str ();
619 /* win32_wait needs to know we're not attaching. */
623 error ("No executable specified, specify executable to debug.\n");
625 flags
= DEBUG_PROCESS
| DEBUG_ONLY_THIS_PROCESS
;
629 path_ptr
= getenv ("PATH");
632 int size
= cygwin_conv_path_list (CCP_POSIX_TO_WIN_A
, path_ptr
, NULL
, 0);
633 orig_path
= (char *) alloca (strlen (path_ptr
) + 1);
634 new_path
= (char *) alloca (size
);
635 strcpy (orig_path
, path_ptr
);
636 cygwin_conv_path_list (CCP_POSIX_TO_WIN_A
, path_ptr
, new_path
, size
);
637 setenv ("PATH", new_path
, 1);
639 cygwin_conv_path (CCP_POSIX_TO_WIN_A
, program
, real_path
, PATH_MAX
);
643 OUTMSG2 (("Command line is \"%s %s\"\n", program
, args
));
645 #ifdef CREATE_NEW_PROCESS_GROUP
646 flags
|= CREATE_NEW_PROCESS_GROUP
;
649 ret
= create_process (program
, args
, flags
, &pi
);
650 err
= GetLastError ();
651 if (!ret
&& err
== ERROR_FILE_NOT_FOUND
)
653 char *exename
= (char *) alloca (strlen (program
) + 5);
654 strcat (strcpy (exename
, program
), ".exe");
655 ret
= create_process (exename
, args
, flags
, &pi
);
656 err
= GetLastError ();
661 setenv ("PATH", orig_path
, 1);
666 error ("Error creating process \"%s %s\", (error %d): %s\n",
667 program
, args
, (int) err
, strwinerror (err
));
671 OUTMSG2 (("Process created: %s %s\n", program
, (char *) args
));
675 /* On Windows CE this handle can't be closed. The OS reuses
676 it in the debug events, while the 9x/NT versions of Windows
677 probably use a DuplicateHandle'd one. */
678 CloseHandle (pi
.hThread
);
681 do_initial_child_stuff (pi
.hProcess
, pi
.dwProcessId
, 0);
683 /* Wait till we are at 1st instruction in program, return new pid
684 (assuming success). */
685 cs
.last_ptid
= wait (ptid_t (current_process_id
), &cs
.last_status
, 0);
687 /* Necessary for handle_v_kill. */
688 signal_pid
= current_process_id
;
690 return current_process_id
;
693 /* Attach to a running process.
694 PID is the process ID to attach to, specified by the user
695 or a higher layer. */
697 win32_process_target::attach (unsigned long pid
)
700 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
703 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
705 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
707 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
709 h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
712 if (DebugActiveProcess (pid
))
714 if (DebugSetProcessKillOnExit
!= NULL
)
715 DebugSetProcessKillOnExit (FALSE
);
717 /* win32_wait needs to know we're attaching. */
719 do_initial_child_stuff (h
, pid
, 1);
726 err
= GetLastError ();
727 error ("Attach to process failed (error %d): %s\n",
728 (int) err
, strwinerror (err
));
731 /* See nat/windows-nat.h. */
734 windows_nat::handle_output_debug_string (struct target_waitstatus
*ourstatus
)
736 #define READ_BUFFER_LEN 1024
738 char s
[READ_BUFFER_LEN
+ 1] = { 0 };
739 DWORD nbytes
= current_event
.u
.DebugString
.nDebugStringLength
;
744 if (nbytes
> READ_BUFFER_LEN
)
745 nbytes
= READ_BUFFER_LEN
;
747 addr
= (CORE_ADDR
) (size_t) current_event
.u
.DebugString
.lpDebugStringData
;
749 if (current_event
.u
.DebugString
.fUnicode
)
751 /* The event tells us how many bytes, not chars, even
753 WCHAR buffer
[(READ_BUFFER_LEN
+ 1) / sizeof (WCHAR
)] = { 0 };
754 if (read_inferior_memory (addr
, (unsigned char *) buffer
, nbytes
) != 0)
756 wcstombs (s
, buffer
, (nbytes
+ 1) / sizeof (WCHAR
));
760 if (read_inferior_memory (addr
, (unsigned char *) s
, nbytes
) != 0)
764 if (!startswith (s
, "cYg"))
774 #undef READ_BUFFER_LEN
780 win32_clear_inferiors (void)
782 if (current_process_handle
!= NULL
)
783 CloseHandle (current_process_handle
);
785 for_each_thread (delete_thread_info
);
786 siginfo_er
.ExceptionCode
= 0;
790 /* Implementation of target_ops::kill. */
793 win32_process_target::kill (process_info
*process
)
795 TerminateProcess (current_process_handle
, 0);
798 if (!child_continue (DBG_CONTINUE
, -1))
800 if (!wait_for_debug_event (¤t_event
, INFINITE
))
802 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
804 else if (current_event
.dwDebugEventCode
== OUTPUT_DEBUG_STRING_EVENT
)
805 handle_output_debug_string (nullptr);
808 win32_clear_inferiors ();
810 remove_process (process
);
814 /* Implementation of target_ops::detach. */
817 win32_process_target::detach (process_info
*process
)
819 winapi_DebugActiveProcessStop DebugActiveProcessStop
= NULL
;
820 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
822 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
824 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
826 DebugActiveProcessStop
= GETPROCADDRESS (dll
, DebugActiveProcessStop
);
827 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
829 if (DebugSetProcessKillOnExit
== NULL
830 || DebugActiveProcessStop
== NULL
)
834 struct thread_resume resume
;
835 resume
.thread
= minus_one_ptid
;
836 resume
.kind
= resume_continue
;
838 this->resume (&resume
, 1);
841 if (!DebugActiveProcessStop (current_process_id
))
844 DebugSetProcessKillOnExit (FALSE
);
845 remove_process (process
);
847 win32_clear_inferiors ();
852 win32_process_target::mourn (struct process_info
*process
)
854 remove_process (process
);
857 /* Implementation of target_ops::join. */
860 win32_process_target::join (int pid
)
862 HANDLE h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
865 WaitForSingleObject (h
, INFINITE
);
870 /* Return true iff the thread with thread ID TID is alive. */
872 win32_process_target::thread_alive (ptid_t ptid
)
874 /* Our thread list is reliable; don't bother to poll target
876 return find_thread_ptid (ptid
) != NULL
;
879 /* Resume the inferior process. RESUME_INFO describes how we want
882 win32_process_target::resume (thread_resume
*resume_info
, size_t n
)
887 windows_thread_info
*th
;
888 DWORD continue_status
= DBG_CONTINUE
;
891 /* This handles the very limited set of resume packets that GDB can
892 currently produce. */
894 if (n
== 1 && resume_info
[0].thread
== minus_one_ptid
)
899 /* Yes, we're ignoring resume_info[0].thread. It'd be tricky to make
900 the Windows resume code do the right thing for thread switching. */
901 tid
= current_event
.dwThreadId
;
903 if (resume_info
[0].thread
!= minus_one_ptid
)
905 sig
= gdb_signal_from_host (resume_info
[0].sig
);
906 step
= resume_info
[0].kind
== resume_step
;
914 if (sig
!= GDB_SIGNAL_0
)
916 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
918 OUTMSG (("Cannot continue with signal %s here.\n",
919 gdb_signal_to_string (sig
)));
921 else if (sig
== last_sig
)
922 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
924 OUTMSG (("Can only continue with received signal %s.\n",
925 gdb_signal_to_string (last_sig
)));
928 last_sig
= GDB_SIGNAL_0
;
930 /* Get context for the currently selected thread. */
931 ptid
= debug_event_ptid (¤t_event
);
932 th
= thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
);
935 win32_prepare_to_resume (th
);
937 if (th
->context
.ContextFlags
)
939 /* Move register values from the inferior into the thread
940 context structure. */
941 regcache_invalidate ();
945 if (the_low_target
.single_step
!= NULL
)
946 (*the_low_target
.single_step
) (th
);
948 error ("Single stepping is not supported "
949 "in this configuration.\n");
952 win32_set_thread_context (th
);
953 th
->context
.ContextFlags
= 0;
957 /* Allow continuing with the same signal that interrupted us.
958 Otherwise complain. */
960 child_continue (continue_status
, tid
);
964 win32_add_one_solib (const char *name
, CORE_ADDR load_addr
)
966 char buf
[MAX_PATH
+ 1];
967 char buf2
[MAX_PATH
+ 1];
970 WIN32_FIND_DATA w32_fd
;
971 WCHAR wname
[MAX_PATH
+ 1];
972 mbstowcs (wname
, name
, MAX_PATH
);
973 HANDLE h
= FindFirstFile (wname
, &w32_fd
);
975 WIN32_FIND_DATAA w32_fd
;
976 HANDLE h
= FindFirstFileA (name
, &w32_fd
);
979 /* The symbols in a dll are offset by 0x1000, which is the
980 offset from 0 of the first byte in an image - because
981 of the file header and the section alignment. */
984 if (h
== INVALID_HANDLE_VALUE
)
992 char cwd
[MAX_PATH
+ 1];
994 if (GetCurrentDirectoryA (MAX_PATH
+ 1, cwd
))
996 p
= strrchr (buf
, '\\');
999 SetCurrentDirectoryA (buf
);
1000 GetFullPathNameA (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
1001 SetCurrentDirectoryA (cwd
);
1008 if (strcasecmp (buf
, "ntdll.dll") == 0)
1010 GetSystemDirectoryA (buf
, sizeof (buf
));
1011 strcat (buf
, "\\ntdll.dll");
1016 cygwin_conv_path (CCP_WIN_A_TO_POSIX
, buf
, buf2
, sizeof (buf2
));
1021 loaded_dll (buf2
, load_addr
);
1024 typedef BOOL (WINAPI
*winapi_EnumProcessModules
) (HANDLE
, HMODULE
*,
1026 typedef BOOL (WINAPI
*winapi_GetModuleInformation
) (HANDLE
, HMODULE
,
1027 LPMODULEINFO
, DWORD
);
1028 typedef DWORD (WINAPI
*winapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
,
1031 static winapi_EnumProcessModules win32_EnumProcessModules
;
1032 static winapi_GetModuleInformation win32_GetModuleInformation
;
1033 static winapi_GetModuleFileNameExA win32_GetModuleFileNameExA
;
1038 static int psapi_loaded
= 0;
1039 static HMODULE dll
= NULL
;
1044 dll
= LoadLibrary (TEXT("psapi.dll"));
1047 win32_EnumProcessModules
=
1048 GETPROCADDRESS (dll
, EnumProcessModules
);
1049 win32_GetModuleInformation
=
1050 GETPROCADDRESS (dll
, GetModuleInformation
);
1051 win32_GetModuleFileNameExA
=
1052 GETPROCADDRESS (dll
, GetModuleFileNameExA
);
1055 return (win32_EnumProcessModules
!= NULL
1056 && win32_GetModuleInformation
!= NULL
1057 && win32_GetModuleFileNameExA
!= NULL
);
1062 /* Iterate over all DLLs currently mapped by our inferior, and
1063 add them to our list of solibs. */
1066 win32_add_all_dlls (void)
1070 HMODULE
*DllHandle
= dh_buf
;
1078 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
1083 if (!ok
|| !cbNeeded
)
1086 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
1090 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
1097 for (i
= 1; i
< ((size_t) cbNeeded
/ sizeof (HMODULE
)); i
++)
1100 char dll_name
[MAX_PATH
];
1102 if (!(*win32_GetModuleInformation
) (current_process_handle
,
1107 if ((*win32_GetModuleFileNameExA
) (current_process_handle
,
1112 win32_add_one_solib (dll_name
, (CORE_ADDR
) (uintptr_t) mi
.lpBaseOfDll
);
1117 typedef HANDLE (WINAPI
*winapi_CreateToolhelp32Snapshot
) (DWORD
, DWORD
);
1118 typedef BOOL (WINAPI
*winapi_Module32First
) (HANDLE
, LPMODULEENTRY32
);
1119 typedef BOOL (WINAPI
*winapi_Module32Next
) (HANDLE
, LPMODULEENTRY32
);
1121 /* See nat/windows-nat.h. */
1124 windows_nat::handle_load_dll ()
1126 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
1127 const char *dll_name
;
1129 dll_name
= get_image_name (current_process_handle
,
1130 event
->lpImageName
, event
->fUnicode
);
1134 win32_add_one_solib (dll_name
, (CORE_ADDR
) (uintptr_t) event
->lpBaseOfDll
);
1137 /* See nat/windows-nat.h. */
1140 windows_nat::handle_unload_dll ()
1142 CORE_ADDR load_addr
=
1143 (CORE_ADDR
) (uintptr_t) current_event
.u
.UnloadDll
.lpBaseOfDll
;
1145 /* The symbols in a dll are offset by 0x1000, which is the
1146 offset from 0 of the first byte in an image - because
1147 of the file header and the section alignment. */
1148 load_addr
+= 0x1000;
1149 unloaded_dll (NULL
, load_addr
);
1153 suspend_one_thread (thread_info
*thread
)
1155 windows_thread_info
*th
= (windows_thread_info
*) thread_target_data (thread
);
1161 fake_breakpoint_event (void)
1163 OUTMSG2(("fake_breakpoint_event\n"));
1165 faked_breakpoint
= 1;
1167 memset (¤t_event
, 0, sizeof (current_event
));
1168 current_event
.dwThreadId
= main_thread_id
;
1169 current_event
.dwDebugEventCode
= EXCEPTION_DEBUG_EVENT
;
1170 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1171 = EXCEPTION_BREAKPOINT
;
1173 for_each_thread (suspend_one_thread
);
1178 auto_delete_breakpoint (CORE_ADDR stop_pc
)
1184 /* See nat/windows-nat.h. */
1187 windows_nat::handle_ms_vc_exception (const EXCEPTION_RECORD
*rec
)
1192 /* Get the next event from the child. */
1195 get_child_debug_event (DWORD
*continue_status
,
1196 struct target_waitstatus
*ourstatus
)
1200 last_sig
= GDB_SIGNAL_0
;
1201 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1202 *continue_status
= DBG_CONTINUE
;
1204 /* Check if GDB sent us an interrupt request. */
1205 check_remote_input_interrupt_request ();
1207 if (soft_interrupt_requested
)
1209 soft_interrupt_requested
= 0;
1210 fake_breakpoint_event ();
1219 /* WinCE doesn't set an initial breakpoint automatically. To
1220 stop the inferior, we flush all currently pending debug
1221 events -- the thread list and the dll list are always
1222 reported immediatelly without delay, then, we suspend all
1223 threads and pretend we saw a trap at the current PC of the
1226 Contrary to desktop Windows, Windows CE *does* report the dll
1227 names on LOAD_DLL_DEBUG_EVENTs resulting from a
1228 DebugActiveProcess call. This limits the way we can detect
1229 if all the dlls have already been reported. If we get a real
1230 debug event before leaving attaching, the worst that will
1231 happen is the user will see a spurious breakpoint. */
1233 current_event
.dwDebugEventCode
= 0;
1234 if (!wait_for_debug_event (¤t_event
, 0))
1236 OUTMSG2(("no attach events left\n"));
1237 fake_breakpoint_event ();
1241 OUTMSG2(("got attach event\n"));
1246 /* Keep the wait time low enough for comfortable remote
1247 interruption, but high enough so gdbserver doesn't become a
1249 if (!wait_for_debug_event (¤t_event
, 250))
1251 DWORD e
= GetLastError();
1253 if (e
== ERROR_PIPE_NOT_CONNECTED
)
1255 /* This will happen if the loader fails to succesfully
1256 load the application, e.g., if the main executable
1257 tries to pull in a non-existing export from a
1259 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1260 ourstatus
->value
.integer
= 1;
1270 switch (current_event
.dwDebugEventCode
)
1272 case CREATE_THREAD_DEBUG_EVENT
:
1273 OUTMSG2 (("gdbserver: kernel event CREATE_THREAD_DEBUG_EVENT "
1274 "for pid=%u tid=%x)\n",
1275 (unsigned) current_event
.dwProcessId
,
1276 (unsigned) current_event
.dwThreadId
));
1278 /* Record the existence of this thread. */
1279 child_add_thread (current_event
.dwProcessId
,
1280 current_event
.dwThreadId
,
1281 current_event
.u
.CreateThread
.hThread
,
1282 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1285 case EXIT_THREAD_DEBUG_EVENT
:
1286 OUTMSG2 (("gdbserver: kernel event EXIT_THREAD_DEBUG_EVENT "
1287 "for pid=%u tid=%x\n",
1288 (unsigned) current_event
.dwProcessId
,
1289 (unsigned) current_event
.dwThreadId
));
1290 child_delete_thread (current_event
.dwProcessId
,
1291 current_event
.dwThreadId
);
1293 current_thread
= get_first_thread ();
1296 case CREATE_PROCESS_DEBUG_EVENT
:
1297 OUTMSG2 (("gdbserver: kernel event CREATE_PROCESS_DEBUG_EVENT "
1298 "for pid=%u tid=%x\n",
1299 (unsigned) current_event
.dwProcessId
,
1300 (unsigned) current_event
.dwThreadId
));
1301 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1303 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1304 main_thread_id
= current_event
.dwThreadId
;
1306 /* Add the main thread. */
1307 child_add_thread (current_event
.dwProcessId
,
1309 current_event
.u
.CreateProcessInfo
.hThread
,
1310 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
);
1315 /* Windows CE doesn't set the initial breakpoint
1316 automatically like the desktop versions of Windows do.
1317 We add it explicitly here. It will be removed as soon as
1319 set_breakpoint_at ((CORE_ADDR
) (long) current_event
.u
1320 .CreateProcessInfo
.lpStartAddress
,
1321 auto_delete_breakpoint
);
1326 case EXIT_PROCESS_DEBUG_EVENT
:
1327 OUTMSG2 (("gdbserver: kernel event EXIT_PROCESS_DEBUG_EVENT "
1328 "for pid=%u tid=%x\n",
1329 (unsigned) current_event
.dwProcessId
,
1330 (unsigned) current_event
.dwThreadId
));
1332 DWORD exit_status
= current_event
.u
.ExitProcess
.dwExitCode
;
1333 /* If the exit status looks like a fatal exception, but we
1334 don't recognize the exception's code, make the original
1335 exit status value available, to avoid losing information. */
1337 = WIFSIGNALED (exit_status
) ? WTERMSIG (exit_status
) : -1;
1338 if (exit_signal
== -1)
1340 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1341 ourstatus
->value
.integer
= exit_status
;
1345 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1346 ourstatus
->value
.sig
= gdb_signal_from_host (exit_signal
);
1349 child_continue (DBG_CONTINUE
, -1);
1350 CloseHandle (current_process_handle
);
1351 current_process_handle
= NULL
;
1354 case LOAD_DLL_DEBUG_EVENT
:
1355 OUTMSG2 (("gdbserver: kernel event LOAD_DLL_DEBUG_EVENT "
1356 "for pid=%u tid=%x\n",
1357 (unsigned) current_event
.dwProcessId
,
1358 (unsigned) current_event
.dwThreadId
));
1359 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1360 if (! child_initialization_done
)
1364 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1365 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1368 case UNLOAD_DLL_DEBUG_EVENT
:
1369 OUTMSG2 (("gdbserver: kernel event UNLOAD_DLL_DEBUG_EVENT "
1370 "for pid=%u tid=%x\n",
1371 (unsigned) current_event
.dwProcessId
,
1372 (unsigned) current_event
.dwThreadId
));
1373 if (! child_initialization_done
)
1375 handle_unload_dll ();
1376 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1377 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1380 case EXCEPTION_DEBUG_EVENT
:
1381 OUTMSG2 (("gdbserver: kernel event EXCEPTION_DEBUG_EVENT "
1382 "for pid=%u tid=%x\n",
1383 (unsigned) current_event
.dwProcessId
,
1384 (unsigned) current_event
.dwThreadId
));
1385 if (handle_exception (ourstatus
, debug_threads
)
1386 == HANDLE_EXCEPTION_UNHANDLED
)
1387 *continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1390 case OUTPUT_DEBUG_STRING_EVENT
:
1391 /* A message from the kernel (or Cygwin). */
1392 OUTMSG2 (("gdbserver: kernel event OUTPUT_DEBUG_STRING_EVENT "
1393 "for pid=%u tid=%x\n",
1394 (unsigned) current_event
.dwProcessId
,
1395 (unsigned) current_event
.dwThreadId
));
1396 handle_output_debug_string (nullptr);
1400 OUTMSG2 (("gdbserver: kernel event unknown "
1401 "for pid=%u tid=%x code=%x\n",
1402 (unsigned) current_event
.dwProcessId
,
1403 (unsigned) current_event
.dwThreadId
,
1404 (unsigned) current_event
.dwDebugEventCode
));
1408 ptid
= debug_event_ptid (¤t_event
);
1409 current_thread
= find_thread_ptid (ptid
);
1413 /* Wait for the inferior process to change state.
1414 STATUS will be filled in with a response code to send to GDB.
1415 Returns the signal which caused the process to stop. */
1417 win32_process_target::wait (ptid_t ptid
, target_waitstatus
*ourstatus
,
1420 struct regcache
*regcache
;
1422 if (cached_status
.kind
!= TARGET_WAITKIND_IGNORE
)
1424 /* The core always does a wait after creating the inferior, and
1425 do_initial_child_stuff already ran the inferior to the
1426 initial breakpoint (or an exit, if creating the process
1427 fails). Report it now. */
1428 *ourstatus
= cached_status
;
1429 cached_status
.kind
= TARGET_WAITKIND_IGNORE
;
1430 return debug_event_ptid (¤t_event
);
1435 DWORD continue_status
;
1436 if (!get_child_debug_event (&continue_status
, ourstatus
))
1439 switch (ourstatus
->kind
)
1441 case TARGET_WAITKIND_EXITED
:
1442 OUTMSG2 (("Child exited with retcode = %x\n",
1443 ourstatus
->value
.integer
));
1444 win32_clear_inferiors ();
1445 return ptid_t (current_event
.dwProcessId
);
1446 case TARGET_WAITKIND_STOPPED
:
1447 case TARGET_WAITKIND_SIGNALLED
:
1448 case TARGET_WAITKIND_LOADED
:
1449 OUTMSG2 (("Child Stopped with signal = %d \n",
1450 ourstatus
->value
.sig
));
1452 regcache
= get_thread_regcache (current_thread
, 1);
1453 child_fetch_inferior_registers (regcache
, -1);
1454 return debug_event_ptid (¤t_event
);
1456 OUTMSG (("Ignoring unknown internal event, %d\n", ourstatus
->kind
));
1458 case TARGET_WAITKIND_SPURIOUS
:
1459 /* do nothing, just continue */
1460 child_continue (continue_status
, -1);
1466 /* Fetch registers from the inferior process.
1467 If REGNO is -1, fetch all registers; otherwise, fetch at least REGNO. */
1469 win32_process_target::fetch_registers (regcache
*regcache
, int regno
)
1471 child_fetch_inferior_registers (regcache
, regno
);
1474 /* Store registers to the inferior process.
1475 If REGNO is -1, store all registers; otherwise, store at least REGNO. */
1477 win32_process_target::store_registers (regcache
*regcache
, int regno
)
1479 child_store_inferior_registers (regcache
, regno
);
1482 /* Read memory from the inferior process. This should generally be
1483 called through read_inferior_memory, which handles breakpoint shadowing.
1484 Read LEN bytes at MEMADDR into a buffer at MYADDR. */
1486 win32_process_target::read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
,
1489 return child_xfer_memory (memaddr
, (char *) myaddr
, len
, 0, 0) != len
;
1492 /* Write memory to the inferior process. This should generally be
1493 called through write_inferior_memory, which handles breakpoint shadowing.
1494 Write LEN bytes from the buffer at MYADDR to MEMADDR.
1495 Returns 0 on success and errno on failure. */
1497 win32_process_target::write_memory (CORE_ADDR memaddr
,
1498 const unsigned char *myaddr
, int len
)
1500 return child_xfer_memory (memaddr
, (char *) myaddr
, len
, 1, 0) != len
;
1503 /* Send an interrupt request to the inferior process. */
1505 win32_process_target::request_interrupt ()
1507 winapi_DebugBreakProcess DebugBreakProcess
;
1508 winapi_GenerateConsoleCtrlEvent GenerateConsoleCtrlEvent
;
1511 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
1513 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
1516 GenerateConsoleCtrlEvent
= GETPROCADDRESS (dll
, GenerateConsoleCtrlEvent
);
1518 if (GenerateConsoleCtrlEvent
!= NULL
1519 && GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, current_process_id
))
1522 /* GenerateConsoleCtrlEvent can fail if process id being debugged is
1523 not a process group id.
1524 Fallback to XP/Vista 'DebugBreakProcess', which generates a
1525 breakpoint exception in the interior process. */
1527 DebugBreakProcess
= GETPROCADDRESS (dll
, DebugBreakProcess
);
1529 if (DebugBreakProcess
!= NULL
1530 && DebugBreakProcess (current_process_handle
))
1533 /* Last resort, suspend all threads manually. */
1534 soft_interrupt_requested
= 1;
1538 win32_process_target::supports_hardware_single_step ()
1545 win32_error_to_fileio_error (DWORD err
)
1549 case ERROR_BAD_PATHNAME
:
1550 case ERROR_FILE_NOT_FOUND
:
1551 case ERROR_INVALID_NAME
:
1552 case ERROR_PATH_NOT_FOUND
:
1553 return FILEIO_ENOENT
;
1555 case ERROR_IO_DEVICE
:
1556 case ERROR_OPEN_FAILED
:
1558 case ERROR_INVALID_HANDLE
:
1559 return FILEIO_EBADF
;
1560 case ERROR_ACCESS_DENIED
:
1561 case ERROR_SHARING_VIOLATION
:
1562 return FILEIO_EACCES
;
1563 case ERROR_NOACCESS
:
1564 return FILEIO_EFAULT
;
1566 return FILEIO_EBUSY
;
1567 case ERROR_ALREADY_EXISTS
:
1568 case ERROR_FILE_EXISTS
:
1569 return FILEIO_EEXIST
;
1570 case ERROR_BAD_DEVICE
:
1571 return FILEIO_ENODEV
;
1572 case ERROR_DIRECTORY
:
1573 return FILEIO_ENOTDIR
;
1574 case ERROR_FILENAME_EXCED_RANGE
:
1575 case ERROR_INVALID_DATA
:
1576 case ERROR_INVALID_PARAMETER
:
1577 case ERROR_NEGATIVE_SEEK
:
1578 return FILEIO_EINVAL
;
1579 case ERROR_TOO_MANY_OPEN_FILES
:
1580 return FILEIO_EMFILE
;
1581 case ERROR_HANDLE_DISK_FULL
:
1582 case ERROR_DISK_FULL
:
1583 return FILEIO_ENOSPC
;
1584 case ERROR_WRITE_PROTECT
:
1585 return FILEIO_EROFS
;
1586 case ERROR_NOT_SUPPORTED
:
1587 return FILEIO_ENOSYS
;
1590 return FILEIO_EUNKNOWN
;
1594 win32_process_target::hostio_last_error (char *buf
)
1596 DWORD winerr
= GetLastError ();
1597 int fileio_err
= win32_error_to_fileio_error (winerr
);
1598 sprintf (buf
, "F-1,%x", fileio_err
);
1603 win32_process_target::supports_qxfer_siginfo ()
1608 /* Write Windows signal info. */
1611 win32_process_target::qxfer_siginfo (const char *annex
,
1612 unsigned char *readbuf
,
1613 unsigned const char *writebuf
,
1614 CORE_ADDR offset
, int len
)
1616 if (siginfo_er
.ExceptionCode
== 0)
1619 if (readbuf
== nullptr)
1622 if (offset
> sizeof (siginfo_er
))
1625 if (offset
+ len
> sizeof (siginfo_er
))
1626 len
= sizeof (siginfo_er
) - offset
;
1628 memcpy (readbuf
, (char *) &siginfo_er
+ offset
, len
);
1634 win32_process_target::supports_get_tib_address ()
1639 /* Write Windows OS Thread Information Block address. */
1642 win32_process_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
1644 windows_thread_info
*th
;
1645 th
= thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
);
1649 *addr
= th
->thread_local_base
;
1653 /* Implementation of the target_ops method "sw_breakpoint_from_kind". */
1656 win32_process_target::sw_breakpoint_from_kind (int kind
, int *size
)
1658 *size
= the_low_target
.breakpoint_len
;
1659 return the_low_target
.breakpoint
;
1663 win32_process_target::read_pc (struct regcache
*regcache
)
1665 return (*the_low_target
.get_pc
) (regcache
);
1669 win32_process_target::write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1671 return (*the_low_target
.set_pc
) (regcache
, pc
);
1674 /* The win32 target ops object. */
1676 static win32_process_target the_win32_target
;
1678 /* Initialize the Win32 backend. */
1680 initialize_low (void)
1682 set_target_ops (&the_win32_target
);
1683 the_low_target
.arch_setup ();