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"
40 #include <sys/cygwin.h>
43 #define OUTMSG(X) do { printf X; fflush (stderr); } while (0)
56 #define _T(x) TEXT (x)
60 #define COUNTOF(STR) (sizeof (STR) / sizeof ((STR)[0]))
64 # define GETPROCADDRESS(DLL, PROC) \
65 ((winapi_ ## PROC) GetProcAddress (DLL, TEXT (#PROC)))
67 # define GETPROCADDRESS(DLL, PROC) \
68 ((winapi_ ## PROC) GetProcAddress (DLL, #PROC))
71 int using_threads
= 1;
74 static int attaching
= 0;
75 static HANDLE current_process_handle
= NULL
;
76 static DWORD current_process_id
= 0;
77 static DWORD main_thread_id
= 0;
78 static EXCEPTION_RECORD siginfo_er
; /* Contents of $_siginfo */
79 static enum gdb_signal last_sig
= GDB_SIGNAL_0
;
81 /* The current debug event from WaitForDebugEvent. */
82 static DEBUG_EVENT current_event
;
84 /* A status that hasn't been reported to the core yet, and so
85 win32_wait should return it next, instead of fetching the next
86 debug event off the win32 API. */
87 static struct target_waitstatus cached_status
;
89 /* Non zero if an interrupt request is to be satisfied by suspending
91 static int soft_interrupt_requested
= 0;
93 /* Non zero if the inferior is stopped in a simulated breakpoint done
94 by suspending all the threads. */
95 static int faked_breakpoint
= 0;
97 const struct target_desc
*win32_tdesc
;
99 #define NUM_REGS (the_low_target.num_regs)
101 typedef BOOL (WINAPI
*winapi_DebugActiveProcessStop
) (DWORD dwProcessId
);
102 typedef BOOL (WINAPI
*winapi_DebugSetProcessKillOnExit
) (BOOL KillOnExit
);
103 typedef BOOL (WINAPI
*winapi_DebugBreakProcess
) (HANDLE
);
104 typedef BOOL (WINAPI
*winapi_GenerateConsoleCtrlEvent
) (DWORD
, DWORD
);
107 static void win32_add_all_dlls (void);
110 /* Get the thread ID from the current selected inferior (the current
113 current_thread_ptid (void)
118 /* The current debug event from WaitForDebugEvent. */
120 debug_event_ptid (DEBUG_EVENT
*event
)
122 return ptid_t (event
->dwProcessId
, event
->dwThreadId
, 0);
125 /* Get the thread context of the thread associated with TH. */
128 win32_get_thread_context (windows_thread_info
*th
)
130 memset (&th
->context
, 0, sizeof (CONTEXT
));
131 (*the_low_target
.get_thread_context
) (th
);
133 memcpy (&th
->base_context
, &th
->context
, sizeof (CONTEXT
));
137 /* Set the thread context of the thread associated with TH. */
140 win32_set_thread_context (windows_thread_info
*th
)
143 /* Calling SuspendThread on a thread that is running kernel code
144 will report that the suspending was successful, but in fact, that
145 will often not be true. In those cases, the context returned by
146 GetThreadContext will not be correct by the time the thread
147 stops, hence we can't set that context back into the thread when
148 resuming - it will most likely crash the inferior.
149 Unfortunately, there is no way to know when the thread will
150 really stop. To work around it, we'll only write the context
151 back to the thread when either the user or GDB explicitly change
152 it between stopping and resuming. */
153 if (memcmp (&th
->context
, &th
->base_context
, sizeof (CONTEXT
)) != 0)
155 SetThreadContext (th
->h
, &th
->context
);
158 /* Set the thread context of the thread associated with TH. */
161 win32_prepare_to_resume (windows_thread_info
*th
)
163 if (the_low_target
.prepare_to_resume
!= NULL
)
164 (*the_low_target
.prepare_to_resume
) (th
);
167 /* See win32-low.h. */
170 win32_require_context (windows_thread_info
*th
)
172 if (th
->context
.ContextFlags
== 0)
176 if (SuspendThread (th
->h
) == (DWORD
) -1)
178 DWORD err
= GetLastError ();
179 OUTMSG (("warning: SuspendThread failed in thread_rec, "
180 "(error %d): %s\n", (int) err
, strwinerror (err
)));
186 win32_get_thread_context (th
);
190 /* Find a thread record given a thread id. If GET_CONTEXT is set then
191 also retrieve the context for this thread. */
192 static windows_thread_info
*
193 thread_rec (ptid_t ptid
, int get_context
)
195 thread_info
*thread
= find_thread_ptid (ptid
);
199 windows_thread_info
*th
= (windows_thread_info
*) thread_target_data (thread
);
201 win32_require_context (th
);
205 /* Add a thread to the thread list. */
206 static windows_thread_info
*
207 child_add_thread (DWORD pid
, DWORD tid
, HANDLE h
, void *tlb
)
209 windows_thread_info
*th
;
210 ptid_t ptid
= ptid_t (pid
, tid
, 0);
212 if ((th
= thread_rec (ptid
, FALSE
)))
215 th
= new windows_thread_info (tid
, h
, (CORE_ADDR
) (uintptr_t) tlb
);
217 add_thread (ptid
, th
);
219 if (the_low_target
.thread_added
!= NULL
)
220 (*the_low_target
.thread_added
) (th
);
225 /* Delete a thread from the list of threads. */
227 delete_thread_info (thread_info
*thread
)
229 windows_thread_info
*th
= (windows_thread_info
*) thread_target_data (thread
);
231 remove_thread (thread
);
236 /* Delete a thread from the list of threads. */
238 child_delete_thread (DWORD pid
, DWORD tid
)
240 /* If the last thread is exiting, just return. */
241 if (all_threads
.size () == 1)
244 thread_info
*thread
= find_thread_ptid (ptid_t (pid
, tid
));
248 delete_thread_info (thread
);
251 /* These watchpoint related wrapper functions simply pass on the function call
252 if the low target has registered a corresponding function. */
255 win32_process_target::supports_z_point_type (char z_type
)
257 return (the_low_target
.supports_z_point_type
!= NULL
258 && the_low_target
.supports_z_point_type (z_type
));
262 win32_process_target::insert_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
263 int size
, raw_breakpoint
*bp
)
265 if (the_low_target
.insert_point
!= NULL
)
266 return the_low_target
.insert_point (type
, addr
, size
, bp
);
268 /* Unsupported (see target.h). */
273 win32_process_target::remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
274 int size
, raw_breakpoint
*bp
)
276 if (the_low_target
.remove_point
!= NULL
)
277 return the_low_target
.remove_point (type
, addr
, size
, bp
);
279 /* Unsupported (see target.h). */
284 win32_process_target::stopped_by_watchpoint ()
286 if (the_low_target
.stopped_by_watchpoint
!= NULL
)
287 return the_low_target
.stopped_by_watchpoint ();
293 win32_process_target::stopped_data_address ()
295 if (the_low_target
.stopped_data_address
!= NULL
)
296 return the_low_target
.stopped_data_address ();
302 /* Transfer memory from/to the debugged process. */
304 child_xfer_memory (CORE_ADDR memaddr
, char *our
, int len
,
305 int write
, process_stratum_target
*target
)
310 uintptr_t addr
= (uintptr_t) memaddr
;
314 success
= WriteProcessMemory (current_process_handle
, (LPVOID
) addr
,
315 (LPCVOID
) our
, len
, &done
);
317 lasterror
= GetLastError ();
318 FlushInstructionCache (current_process_handle
, (LPCVOID
) addr
, len
);
322 success
= ReadProcessMemory (current_process_handle
, (LPCVOID
) addr
,
323 (LPVOID
) our
, len
, &done
);
325 lasterror
= GetLastError ();
327 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
330 return success
? done
: -1;
333 /* Clear out any old thread list and reinitialize it to a pristine
336 child_init_thread_list (void)
338 for_each_thread (delete_thread_info
);
341 /* Zero during the child initialization phase, and nonzero otherwise. */
343 static int child_initialization_done
= 0;
346 do_initial_child_stuff (HANDLE proch
, DWORD pid
, int attached
)
348 struct process_info
*proc
;
350 last_sig
= GDB_SIGNAL_0
;
352 current_process_handle
= proch
;
353 current_process_id
= pid
;
356 soft_interrupt_requested
= 0;
357 faked_breakpoint
= 0;
359 memset (¤t_event
, 0, sizeof (current_event
));
361 proc
= add_process (pid
, attached
);
362 proc
->tdesc
= win32_tdesc
;
363 child_init_thread_list ();
364 child_initialization_done
= 0;
366 if (the_low_target
.initial_stuff
!= NULL
)
367 (*the_low_target
.initial_stuff
) ();
369 cached_status
.kind
= TARGET_WAITKIND_IGNORE
;
371 /* Flush all currently pending debug events (thread and dll list) up
372 to the initial breakpoint. */
375 struct target_waitstatus status
;
377 the_target
->wait (minus_one_ptid
, &status
, 0);
379 /* Note win32_wait doesn't return thread events. */
380 if (status
.kind
!= TARGET_WAITKIND_LOADED
)
382 cached_status
= status
;
387 struct thread_resume resume
;
389 resume
.thread
= minus_one_ptid
;
390 resume
.kind
= resume_continue
;
393 the_target
->resume (&resume
, 1);
398 /* Now that the inferior has been started and all DLLs have been mapped,
399 we can iterate over all DLLs and load them in.
401 We avoid doing it any earlier because, on certain versions of Windows,
402 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
403 we have seen on Windows 8.1 that the ntdll.dll load event does not
404 include the DLL name, preventing us from creating an associated SO.
405 A possible explanation is that ntdll.dll might be mapped before
406 the SO info gets created by the Windows system -- ntdll.dll is
407 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
408 do not seem to suffer from that problem.
410 Rather than try to work around this sort of issue, it is much
411 simpler to just ignore DLL load/unload events during the startup
412 phase, and then process them all in one batch now. */
413 win32_add_all_dlls ();
416 child_initialization_done
= 1;
419 /* Resume all artificially suspended threads if we are continuing
422 continue_one_thread (thread_info
*thread
, int thread_id
)
424 windows_thread_info
*th
= (windows_thread_info
*) thread_target_data (thread
);
426 if (thread_id
== -1 || thread_id
== th
->tid
)
428 win32_prepare_to_resume (th
);
432 if (th
->context
.ContextFlags
)
434 win32_set_thread_context (th
);
435 th
->context
.ContextFlags
= 0;
438 if (ResumeThread (th
->h
) == (DWORD
) -1)
440 DWORD err
= GetLastError ();
441 OUTMSG (("warning: ResumeThread failed in continue_one_thread, "
442 "(error %d): %s\n", (int) err
, strwinerror (err
)));
450 child_continue (DWORD continue_status
, int thread_id
)
452 /* The inferior will only continue after the ContinueDebugEvent
454 for_each_thread ([&] (thread_info
*thread
)
456 continue_one_thread (thread
, thread_id
);
458 faked_breakpoint
= 0;
460 if (!ContinueDebugEvent (current_event
.dwProcessId
,
461 current_event
.dwThreadId
,
468 /* Fetch register(s) from the current thread context. */
470 child_fetch_inferior_registers (struct regcache
*regcache
, int r
)
473 windows_thread_info
*th
= thread_rec (current_thread_ptid (), TRUE
);
474 if (r
== -1 || r
> NUM_REGS
)
475 child_fetch_inferior_registers (regcache
, NUM_REGS
);
477 for (regno
= 0; regno
< r
; regno
++)
478 (*the_low_target
.fetch_inferior_register
) (regcache
, th
, regno
);
481 /* Store a new register value into the current thread context. We don't
482 change the program's context until later, when we resume it. */
484 child_store_inferior_registers (struct regcache
*regcache
, int r
)
487 windows_thread_info
*th
= thread_rec (current_thread_ptid (), TRUE
);
488 if (r
== -1 || r
== 0 || r
> NUM_REGS
)
489 child_store_inferior_registers (regcache
, NUM_REGS
);
491 for (regno
= 0; regno
< r
; regno
++)
492 (*the_low_target
.store_inferior_register
) (regcache
, th
, regno
);
495 /* Map the Windows error number in ERROR to a locale-dependent error
496 message string and return a pointer to it. Typically, the values
497 for ERROR come from GetLastError.
499 The string pointed to shall not be modified by the application,
500 but may be overwritten by a subsequent call to strwinerror
502 The strwinerror function does not change the current setting
506 strwinerror (DWORD error
)
508 static char buf
[1024];
510 DWORD lasterr
= GetLastError ();
511 DWORD chars
= FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
512 | FORMAT_MESSAGE_ALLOCATE_BUFFER
,
515 0, /* Default language */
521 /* If there is an \r\n appended, zap it. */
523 && msgbuf
[chars
- 2] == '\r'
524 && msgbuf
[chars
- 1] == '\n')
530 if (chars
> ((COUNTOF (buf
)) - 1))
532 chars
= COUNTOF (buf
) - 1;
537 wcstombs (buf
, msgbuf
, chars
+ 1);
539 strncpy (buf
, msgbuf
, chars
+ 1);
544 sprintf (buf
, "unknown win32 error (%u)", (unsigned) error
);
546 SetLastError (lasterr
);
551 create_process (const char *program
, char *args
,
552 DWORD flags
, PROCESS_INFORMATION
*pi
)
554 const char *inferior_cwd
= get_inferior_cwd ();
556 size_t argslen
, proglen
;
558 proglen
= strlen (program
) + 1;
559 argslen
= strlen (args
) + proglen
;
562 wchar_t *p
, *wprogram
, *wargs
, *wcwd
= NULL
;
564 wprogram
= (wchar_t *) alloca (proglen
* sizeof (wchar_t));
565 mbstowcs (wprogram
, program
, proglen
);
567 for (p
= wprogram
; *p
; ++p
)
571 wargs
= alloca ((argslen
+ 1) * sizeof (wchar_t));
572 wcscpy (wargs
, wprogram
);
573 wcscat (wargs
, L
" ");
574 mbstowcs (wargs
+ proglen
, args
, argslen
+ 1 - proglen
);
576 if (inferior_cwd
!= NULL
)
578 std::string expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
579 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
581 wcwd
= alloca ((expanded_infcwd
.size () + 1) * sizeof (wchar_t));
582 if (mbstowcs (wcwd
, expanded_infcwd
.c_str (),
583 expanded_infcwd
.size () + 1) == NULL
)
586 Could not convert the expanded inferior cwd to wide-char."));
590 ret
= CreateProcessW (wprogram
, /* image name */
591 wargs
, /* command line */
592 NULL
, /* security, not supported */
593 NULL
, /* thread, not supported */
594 FALSE
, /* inherit handles, not supported */
595 flags
, /* start flags */
596 NULL
, /* environment, not supported */
597 wcwd
, /* current directory */
598 NULL
, /* start info, not supported */
601 STARTUPINFOA si
= { sizeof (STARTUPINFOA
) };
602 char *program_and_args
= (char *) alloca (argslen
+ 1);
604 strcpy (program_and_args
, program
);
605 strcat (program_and_args
, " ");
606 strcat (program_and_args
, args
);
607 ret
= CreateProcessA (program
, /* image name */
608 program_and_args
, /* command line */
611 TRUE
, /* inherit handles */
612 flags
, /* start flags */
613 NULL
, /* environment */
614 /* current directory */
615 (inferior_cwd
== NULL
617 : gdb_tilde_expand (inferior_cwd
).c_str()),
618 &si
, /* start info */
625 /* Start a new process.
626 PROGRAM is the program name.
627 PROGRAM_ARGS is the vector containing the inferior's args.
628 Returns the new PID on success, -1 on failure. Registers the new
629 process with the process list. */
631 win32_process_target::create_inferior (const char *program
,
632 const std::vector
<char *> &program_args
)
634 client_state
&cs
= get_client_state ();
636 char real_path
[PATH_MAX
];
637 char *orig_path
, *new_path
, *path_ptr
;
641 PROCESS_INFORMATION pi
;
643 std::string str_program_args
= stringify_argv (program_args
);
644 char *args
= (char *) str_program_args
.c_str ();
646 /* win32_wait needs to know we're not attaching. */
650 error ("No executable specified, specify executable to debug.\n");
652 flags
= DEBUG_PROCESS
| DEBUG_ONLY_THIS_PROCESS
;
656 path_ptr
= getenv ("PATH");
659 int size
= cygwin_conv_path_list (CCP_POSIX_TO_WIN_A
, path_ptr
, NULL
, 0);
660 orig_path
= (char *) alloca (strlen (path_ptr
) + 1);
661 new_path
= (char *) alloca (size
);
662 strcpy (orig_path
, path_ptr
);
663 cygwin_conv_path_list (CCP_POSIX_TO_WIN_A
, path_ptr
, new_path
, size
);
664 setenv ("PATH", new_path
, 1);
666 cygwin_conv_path (CCP_POSIX_TO_WIN_A
, program
, real_path
, PATH_MAX
);
670 OUTMSG2 (("Command line is \"%s %s\"\n", program
, args
));
672 #ifdef CREATE_NEW_PROCESS_GROUP
673 flags
|= CREATE_NEW_PROCESS_GROUP
;
676 ret
= create_process (program
, args
, flags
, &pi
);
677 err
= GetLastError ();
678 if (!ret
&& err
== ERROR_FILE_NOT_FOUND
)
680 char *exename
= (char *) alloca (strlen (program
) + 5);
681 strcat (strcpy (exename
, program
), ".exe");
682 ret
= create_process (exename
, args
, flags
, &pi
);
683 err
= GetLastError ();
688 setenv ("PATH", orig_path
, 1);
693 error ("Error creating process \"%s %s\", (error %d): %s\n",
694 program
, args
, (int) err
, strwinerror (err
));
698 OUTMSG2 (("Process created: %s %s\n", program
, (char *) args
));
702 /* On Windows CE this handle can't be closed. The OS reuses
703 it in the debug events, while the 9x/NT versions of Windows
704 probably use a DuplicateHandle'd one. */
705 CloseHandle (pi
.hThread
);
708 do_initial_child_stuff (pi
.hProcess
, pi
.dwProcessId
, 0);
710 /* Wait till we are at 1st instruction in program, return new pid
711 (assuming success). */
712 cs
.last_ptid
= wait (ptid_t (current_process_id
), &cs
.last_status
, 0);
714 /* Necessary for handle_v_kill. */
715 signal_pid
= current_process_id
;
717 return current_process_id
;
720 /* Attach to a running process.
721 PID is the process ID to attach to, specified by the user
722 or a higher layer. */
724 win32_process_target::attach (unsigned long pid
)
727 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
730 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
732 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
734 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
736 h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
739 if (DebugActiveProcess (pid
))
741 if (DebugSetProcessKillOnExit
!= NULL
)
742 DebugSetProcessKillOnExit (FALSE
);
744 /* win32_wait needs to know we're attaching. */
746 do_initial_child_stuff (h
, pid
, 1);
753 err
= GetLastError ();
754 error ("Attach to process failed (error %d): %s\n",
755 (int) err
, strwinerror (err
));
758 /* Handle OUTPUT_DEBUG_STRING_EVENT from child process. */
760 handle_output_debug_string (void)
762 #define READ_BUFFER_LEN 1024
764 char s
[READ_BUFFER_LEN
+ 1] = { 0 };
765 DWORD nbytes
= current_event
.u
.DebugString
.nDebugStringLength
;
770 if (nbytes
> READ_BUFFER_LEN
)
771 nbytes
= READ_BUFFER_LEN
;
773 addr
= (CORE_ADDR
) (size_t) current_event
.u
.DebugString
.lpDebugStringData
;
775 if (current_event
.u
.DebugString
.fUnicode
)
777 /* The event tells us how many bytes, not chars, even
779 WCHAR buffer
[(READ_BUFFER_LEN
+ 1) / sizeof (WCHAR
)] = { 0 };
780 if (read_inferior_memory (addr
, (unsigned char *) buffer
, nbytes
) != 0)
782 wcstombs (s
, buffer
, (nbytes
+ 1) / sizeof (WCHAR
));
786 if (read_inferior_memory (addr
, (unsigned char *) s
, nbytes
) != 0)
790 if (!startswith (s
, "cYg"))
800 #undef READ_BUFFER_LEN
804 win32_clear_inferiors (void)
806 if (current_process_handle
!= NULL
)
807 CloseHandle (current_process_handle
);
809 for_each_thread (delete_thread_info
);
810 siginfo_er
.ExceptionCode
= 0;
814 /* Implementation of target_ops::kill. */
817 win32_process_target::kill (process_info
*process
)
819 TerminateProcess (current_process_handle
, 0);
822 if (!child_continue (DBG_CONTINUE
, -1))
824 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
826 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
828 else if (current_event
.dwDebugEventCode
== OUTPUT_DEBUG_STRING_EVENT
)
829 handle_output_debug_string ();
832 win32_clear_inferiors ();
834 remove_process (process
);
838 /* Implementation of target_ops::detach. */
841 win32_process_target::detach (process_info
*process
)
843 winapi_DebugActiveProcessStop DebugActiveProcessStop
= NULL
;
844 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
846 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
848 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
850 DebugActiveProcessStop
= GETPROCADDRESS (dll
, DebugActiveProcessStop
);
851 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
853 if (DebugSetProcessKillOnExit
== NULL
854 || DebugActiveProcessStop
== NULL
)
858 struct thread_resume resume
;
859 resume
.thread
= minus_one_ptid
;
860 resume
.kind
= resume_continue
;
862 this->resume (&resume
, 1);
865 if (!DebugActiveProcessStop (current_process_id
))
868 DebugSetProcessKillOnExit (FALSE
);
869 remove_process (process
);
871 win32_clear_inferiors ();
876 win32_process_target::mourn (struct process_info
*process
)
878 remove_process (process
);
881 /* Implementation of target_ops::join. */
884 win32_process_target::join (int pid
)
886 HANDLE h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
889 WaitForSingleObject (h
, INFINITE
);
894 /* Return true iff the thread with thread ID TID is alive. */
896 win32_process_target::thread_alive (ptid_t ptid
)
898 /* Our thread list is reliable; don't bother to poll target
900 return find_thread_ptid (ptid
) != NULL
;
903 /* Resume the inferior process. RESUME_INFO describes how we want
906 win32_process_target::resume (thread_resume
*resume_info
, size_t n
)
911 windows_thread_info
*th
;
912 DWORD continue_status
= DBG_CONTINUE
;
915 /* This handles the very limited set of resume packets that GDB can
916 currently produce. */
918 if (n
== 1 && resume_info
[0].thread
== minus_one_ptid
)
923 /* Yes, we're ignoring resume_info[0].thread. It'd be tricky to make
924 the Windows resume code do the right thing for thread switching. */
925 tid
= current_event
.dwThreadId
;
927 if (resume_info
[0].thread
!= minus_one_ptid
)
929 sig
= gdb_signal_from_host (resume_info
[0].sig
);
930 step
= resume_info
[0].kind
== resume_step
;
938 if (sig
!= GDB_SIGNAL_0
)
940 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
942 OUTMSG (("Cannot continue with signal %s here.\n",
943 gdb_signal_to_string (sig
)));
945 else if (sig
== last_sig
)
946 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
948 OUTMSG (("Can only continue with received signal %s.\n",
949 gdb_signal_to_string (last_sig
)));
952 last_sig
= GDB_SIGNAL_0
;
954 /* Get context for the currently selected thread. */
955 ptid
= debug_event_ptid (¤t_event
);
956 th
= thread_rec (ptid
, FALSE
);
959 win32_prepare_to_resume (th
);
961 if (th
->context
.ContextFlags
)
963 /* Move register values from the inferior into the thread
964 context structure. */
965 regcache_invalidate ();
969 if (the_low_target
.single_step
!= NULL
)
970 (*the_low_target
.single_step
) (th
);
972 error ("Single stepping is not supported "
973 "in this configuration.\n");
976 win32_set_thread_context (th
);
977 th
->context
.ContextFlags
= 0;
981 /* Allow continuing with the same signal that interrupted us.
982 Otherwise complain. */
984 child_continue (continue_status
, tid
);
988 win32_add_one_solib (const char *name
, CORE_ADDR load_addr
)
990 char buf
[MAX_PATH
+ 1];
991 char buf2
[MAX_PATH
+ 1];
994 WIN32_FIND_DATA w32_fd
;
995 WCHAR wname
[MAX_PATH
+ 1];
996 mbstowcs (wname
, name
, MAX_PATH
);
997 HANDLE h
= FindFirstFile (wname
, &w32_fd
);
999 WIN32_FIND_DATAA w32_fd
;
1000 HANDLE h
= FindFirstFileA (name
, &w32_fd
);
1003 /* The symbols in a dll are offset by 0x1000, which is the
1004 offset from 0 of the first byte in an image - because
1005 of the file header and the section alignment. */
1006 load_addr
+= 0x1000;
1008 if (h
== INVALID_HANDLE_VALUE
)
1016 char cwd
[MAX_PATH
+ 1];
1018 if (GetCurrentDirectoryA (MAX_PATH
+ 1, cwd
))
1020 p
= strrchr (buf
, '\\');
1023 SetCurrentDirectoryA (buf
);
1024 GetFullPathNameA (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
1025 SetCurrentDirectoryA (cwd
);
1032 if (strcasecmp (buf
, "ntdll.dll") == 0)
1034 GetSystemDirectoryA (buf
, sizeof (buf
));
1035 strcat (buf
, "\\ntdll.dll");
1040 cygwin_conv_path (CCP_WIN_A_TO_POSIX
, buf
, buf2
, sizeof (buf2
));
1045 loaded_dll (buf2
, load_addr
);
1049 get_image_name (HANDLE h
, void *address
, int unicode
)
1051 static char buf
[(2 * MAX_PATH
) + 1];
1052 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
1058 /* Attempt to read the name of the dll that was detected.
1059 This is documented to work only when actively debugging
1060 a program. It will not work for attached processes. */
1061 if (address
== NULL
)
1065 /* Windows CE reports the address of the image name,
1066 instead of an address of a pointer into the image name. */
1067 address_ptr
= address
;
1069 /* See if we could read the address of a string, and that the
1070 address isn't null. */
1071 if (!ReadProcessMemory (h
, address
, &address_ptr
,
1072 sizeof (address_ptr
), &done
)
1073 || done
!= sizeof (address_ptr
)
1078 /* Find the length of the string */
1079 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
1080 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
1084 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
1087 WCHAR
*unicode_address
= XALLOCAVEC (WCHAR
, len
);
1088 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
1091 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
1097 typedef BOOL (WINAPI
*winapi_EnumProcessModules
) (HANDLE
, HMODULE
*,
1099 typedef BOOL (WINAPI
*winapi_GetModuleInformation
) (HANDLE
, HMODULE
,
1100 LPMODULEINFO
, DWORD
);
1101 typedef DWORD (WINAPI
*winapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
,
1104 static winapi_EnumProcessModules win32_EnumProcessModules
;
1105 static winapi_GetModuleInformation win32_GetModuleInformation
;
1106 static winapi_GetModuleFileNameExA win32_GetModuleFileNameExA
;
1111 static int psapi_loaded
= 0;
1112 static HMODULE dll
= NULL
;
1117 dll
= LoadLibrary (TEXT("psapi.dll"));
1120 win32_EnumProcessModules
=
1121 GETPROCADDRESS (dll
, EnumProcessModules
);
1122 win32_GetModuleInformation
=
1123 GETPROCADDRESS (dll
, GetModuleInformation
);
1124 win32_GetModuleFileNameExA
=
1125 GETPROCADDRESS (dll
, GetModuleFileNameExA
);
1128 return (win32_EnumProcessModules
!= NULL
1129 && win32_GetModuleInformation
!= NULL
1130 && win32_GetModuleFileNameExA
!= NULL
);
1135 /* Iterate over all DLLs currently mapped by our inferior, and
1136 add them to our list of solibs. */
1139 win32_add_all_dlls (void)
1143 HMODULE
*DllHandle
= dh_buf
;
1151 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
1156 if (!ok
|| !cbNeeded
)
1159 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
1163 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
1170 for (i
= 1; i
< ((size_t) cbNeeded
/ sizeof (HMODULE
)); i
++)
1173 char dll_name
[MAX_PATH
];
1175 if (!(*win32_GetModuleInformation
) (current_process_handle
,
1180 if ((*win32_GetModuleFileNameExA
) (current_process_handle
,
1185 win32_add_one_solib (dll_name
, (CORE_ADDR
) (uintptr_t) mi
.lpBaseOfDll
);
1190 typedef HANDLE (WINAPI
*winapi_CreateToolhelp32Snapshot
) (DWORD
, DWORD
);
1191 typedef BOOL (WINAPI
*winapi_Module32First
) (HANDLE
, LPMODULEENTRY32
);
1192 typedef BOOL (WINAPI
*winapi_Module32Next
) (HANDLE
, LPMODULEENTRY32
);
1194 /* Handle a DLL load event.
1196 This function assumes that this event did not occur during inferior
1197 initialization, where their event info may be incomplete (see
1198 do_initial_child_stuff and win32_add_all_dlls for more info on
1199 how we handle DLL loading during that phase). */
1202 handle_load_dll (void)
1204 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
1207 dll_name
= get_image_name (current_process_handle
,
1208 event
->lpImageName
, event
->fUnicode
);
1212 win32_add_one_solib (dll_name
, (CORE_ADDR
) (uintptr_t) event
->lpBaseOfDll
);
1215 /* Handle a DLL unload event.
1217 This function assumes that this event did not occur during inferior
1218 initialization, where their event info may be incomplete (see
1219 do_initial_child_stuff and win32_add_one_solib for more info
1220 on how we handle DLL loading during that phase). */
1223 handle_unload_dll (void)
1225 CORE_ADDR load_addr
=
1226 (CORE_ADDR
) (uintptr_t) current_event
.u
.UnloadDll
.lpBaseOfDll
;
1228 /* The symbols in a dll are offset by 0x1000, which is the
1229 offset from 0 of the first byte in an image - because
1230 of the file header and the section alignment. */
1231 load_addr
+= 0x1000;
1232 unloaded_dll (NULL
, load_addr
);
1236 handle_exception (struct target_waitstatus
*ourstatus
)
1238 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1240 memcpy (&siginfo_er
, ¤t_event
.u
.Exception
.ExceptionRecord
,
1243 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1247 case EXCEPTION_ACCESS_VIOLATION
:
1248 OUTMSG2 (("EXCEPTION_ACCESS_VIOLATION"));
1249 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1251 case STATUS_STACK_OVERFLOW
:
1252 OUTMSG2 (("STATUS_STACK_OVERFLOW"));
1253 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1255 case STATUS_FLOAT_DENORMAL_OPERAND
:
1256 OUTMSG2 (("STATUS_FLOAT_DENORMAL_OPERAND"));
1257 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1259 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1260 OUTMSG2 (("EXCEPTION_ARRAY_BOUNDS_EXCEEDED"));
1261 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1263 case STATUS_FLOAT_INEXACT_RESULT
:
1264 OUTMSG2 (("STATUS_FLOAT_INEXACT_RESULT"));
1265 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1267 case STATUS_FLOAT_INVALID_OPERATION
:
1268 OUTMSG2 (("STATUS_FLOAT_INVALID_OPERATION"));
1269 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1271 case STATUS_FLOAT_OVERFLOW
:
1272 OUTMSG2 (("STATUS_FLOAT_OVERFLOW"));
1273 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1275 case STATUS_FLOAT_STACK_CHECK
:
1276 OUTMSG2 (("STATUS_FLOAT_STACK_CHECK"));
1277 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1279 case STATUS_FLOAT_UNDERFLOW
:
1280 OUTMSG2 (("STATUS_FLOAT_UNDERFLOW"));
1281 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1283 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1284 OUTMSG2 (("STATUS_FLOAT_DIVIDE_BY_ZERO"));
1285 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1287 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1288 OUTMSG2 (("STATUS_INTEGER_DIVIDE_BY_ZERO"));
1289 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1291 case STATUS_INTEGER_OVERFLOW
:
1292 OUTMSG2 (("STATUS_INTEGER_OVERFLOW"));
1293 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1295 case EXCEPTION_BREAKPOINT
:
1296 OUTMSG2 (("EXCEPTION_BREAKPOINT"));
1297 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1299 /* Remove the initial breakpoint. */
1300 check_breakpoints ((CORE_ADDR
) (long) current_event
1301 .u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1305 OUTMSG2 (("DBG_CONTROL_C"));
1306 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1308 case DBG_CONTROL_BREAK
:
1309 OUTMSG2 (("DBG_CONTROL_BREAK"));
1310 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1312 case EXCEPTION_SINGLE_STEP
:
1313 OUTMSG2 (("EXCEPTION_SINGLE_STEP"));
1314 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1316 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1317 OUTMSG2 (("EXCEPTION_ILLEGAL_INSTRUCTION"));
1318 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1320 case EXCEPTION_PRIV_INSTRUCTION
:
1321 OUTMSG2 (("EXCEPTION_PRIV_INSTRUCTION"));
1322 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1324 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1325 OUTMSG2 (("EXCEPTION_NONCONTINUABLE_EXCEPTION"));
1326 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1329 if (current_event
.u
.Exception
.dwFirstChance
)
1331 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1334 OUTMSG2 (("gdbserver: unknown target exception 0x%08x at 0x%s",
1335 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1336 phex_nz ((uintptr_t) current_event
.u
.Exception
.ExceptionRecord
.
1337 ExceptionAddress
, sizeof (uintptr_t))));
1338 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1342 last_sig
= ourstatus
->value
.sig
;
1347 suspend_one_thread (thread_info
*thread
)
1349 windows_thread_info
*th
= (windows_thread_info
*) thread_target_data (thread
);
1353 if (SuspendThread (th
->h
) == (DWORD
) -1)
1355 DWORD err
= GetLastError ();
1356 OUTMSG (("warning: SuspendThread failed in suspend_one_thread, "
1357 "(error %d): %s\n", (int) err
, strwinerror (err
)));
1365 fake_breakpoint_event (void)
1367 OUTMSG2(("fake_breakpoint_event\n"));
1369 faked_breakpoint
= 1;
1371 memset (¤t_event
, 0, sizeof (current_event
));
1372 current_event
.dwThreadId
= main_thread_id
;
1373 current_event
.dwDebugEventCode
= EXCEPTION_DEBUG_EVENT
;
1374 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1375 = EXCEPTION_BREAKPOINT
;
1377 for_each_thread (suspend_one_thread
);
1382 auto_delete_breakpoint (CORE_ADDR stop_pc
)
1388 /* Get the next event from the child. */
1391 get_child_debug_event (struct target_waitstatus
*ourstatus
)
1395 last_sig
= GDB_SIGNAL_0
;
1396 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1398 /* Check if GDB sent us an interrupt request. */
1399 check_remote_input_interrupt_request ();
1401 if (soft_interrupt_requested
)
1403 soft_interrupt_requested
= 0;
1404 fake_breakpoint_event ();
1413 /* WinCE doesn't set an initial breakpoint automatically. To
1414 stop the inferior, we flush all currently pending debug
1415 events -- the thread list and the dll list are always
1416 reported immediatelly without delay, then, we suspend all
1417 threads and pretend we saw a trap at the current PC of the
1420 Contrary to desktop Windows, Windows CE *does* report the dll
1421 names on LOAD_DLL_DEBUG_EVENTs resulting from a
1422 DebugActiveProcess call. This limits the way we can detect
1423 if all the dlls have already been reported. If we get a real
1424 debug event before leaving attaching, the worst that will
1425 happen is the user will see a spurious breakpoint. */
1427 current_event
.dwDebugEventCode
= 0;
1428 if (!WaitForDebugEvent (¤t_event
, 0))
1430 OUTMSG2(("no attach events left\n"));
1431 fake_breakpoint_event ();
1435 OUTMSG2(("got attach event\n"));
1440 /* Keep the wait time low enough for comfortable remote
1441 interruption, but high enough so gdbserver doesn't become a
1443 if (!WaitForDebugEvent (¤t_event
, 250))
1445 DWORD e
= GetLastError();
1447 if (e
== ERROR_PIPE_NOT_CONNECTED
)
1449 /* This will happen if the loader fails to succesfully
1450 load the application, e.g., if the main executable
1451 tries to pull in a non-existing export from a
1453 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1454 ourstatus
->value
.integer
= 1;
1464 switch (current_event
.dwDebugEventCode
)
1466 case CREATE_THREAD_DEBUG_EVENT
:
1467 OUTMSG2 (("gdbserver: kernel event CREATE_THREAD_DEBUG_EVENT "
1468 "for pid=%u tid=%x)\n",
1469 (unsigned) current_event
.dwProcessId
,
1470 (unsigned) current_event
.dwThreadId
));
1472 /* Record the existence of this thread. */
1473 child_add_thread (current_event
.dwProcessId
,
1474 current_event
.dwThreadId
,
1475 current_event
.u
.CreateThread
.hThread
,
1476 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1479 case EXIT_THREAD_DEBUG_EVENT
:
1480 OUTMSG2 (("gdbserver: kernel event EXIT_THREAD_DEBUG_EVENT "
1481 "for pid=%u tid=%x\n",
1482 (unsigned) current_event
.dwProcessId
,
1483 (unsigned) current_event
.dwThreadId
));
1484 child_delete_thread (current_event
.dwProcessId
,
1485 current_event
.dwThreadId
);
1487 current_thread
= get_first_thread ();
1490 case CREATE_PROCESS_DEBUG_EVENT
:
1491 OUTMSG2 (("gdbserver: kernel event CREATE_PROCESS_DEBUG_EVENT "
1492 "for pid=%u tid=%x\n",
1493 (unsigned) current_event
.dwProcessId
,
1494 (unsigned) current_event
.dwThreadId
));
1495 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1497 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1498 main_thread_id
= current_event
.dwThreadId
;
1500 /* Add the main thread. */
1501 child_add_thread (current_event
.dwProcessId
,
1503 current_event
.u
.CreateProcessInfo
.hThread
,
1504 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
);
1509 /* Windows CE doesn't set the initial breakpoint
1510 automatically like the desktop versions of Windows do.
1511 We add it explicitly here. It will be removed as soon as
1513 set_breakpoint_at ((CORE_ADDR
) (long) current_event
.u
1514 .CreateProcessInfo
.lpStartAddress
,
1515 auto_delete_breakpoint
);
1520 case EXIT_PROCESS_DEBUG_EVENT
:
1521 OUTMSG2 (("gdbserver: kernel event EXIT_PROCESS_DEBUG_EVENT "
1522 "for pid=%u tid=%x\n",
1523 (unsigned) current_event
.dwProcessId
,
1524 (unsigned) current_event
.dwThreadId
));
1526 DWORD exit_status
= current_event
.u
.ExitProcess
.dwExitCode
;
1527 /* If the exit status looks like a fatal exception, but we
1528 don't recognize the exception's code, make the original
1529 exit status value available, to avoid losing information. */
1531 = WIFSIGNALED (exit_status
) ? WTERMSIG (exit_status
) : -1;
1532 if (exit_signal
== -1)
1534 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1535 ourstatus
->value
.integer
= exit_status
;
1539 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1540 ourstatus
->value
.sig
= gdb_signal_from_host (exit_signal
);
1543 child_continue (DBG_CONTINUE
, -1);
1544 CloseHandle (current_process_handle
);
1545 current_process_handle
= NULL
;
1548 case LOAD_DLL_DEBUG_EVENT
:
1549 OUTMSG2 (("gdbserver: kernel event LOAD_DLL_DEBUG_EVENT "
1550 "for pid=%u tid=%x\n",
1551 (unsigned) current_event
.dwProcessId
,
1552 (unsigned) current_event
.dwThreadId
));
1553 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1554 if (! child_initialization_done
)
1558 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1559 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1562 case UNLOAD_DLL_DEBUG_EVENT
:
1563 OUTMSG2 (("gdbserver: kernel event UNLOAD_DLL_DEBUG_EVENT "
1564 "for pid=%u tid=%x\n",
1565 (unsigned) current_event
.dwProcessId
,
1566 (unsigned) current_event
.dwThreadId
));
1567 if (! child_initialization_done
)
1569 handle_unload_dll ();
1570 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1571 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1574 case EXCEPTION_DEBUG_EVENT
:
1575 OUTMSG2 (("gdbserver: kernel event EXCEPTION_DEBUG_EVENT "
1576 "for pid=%u tid=%x\n",
1577 (unsigned) current_event
.dwProcessId
,
1578 (unsigned) current_event
.dwThreadId
));
1579 handle_exception (ourstatus
);
1582 case OUTPUT_DEBUG_STRING_EVENT
:
1583 /* A message from the kernel (or Cygwin). */
1584 OUTMSG2 (("gdbserver: kernel event OUTPUT_DEBUG_STRING_EVENT "
1585 "for pid=%u tid=%x\n",
1586 (unsigned) current_event
.dwProcessId
,
1587 (unsigned) current_event
.dwThreadId
));
1588 handle_output_debug_string ();
1592 OUTMSG2 (("gdbserver: kernel event unknown "
1593 "for pid=%u tid=%x code=%x\n",
1594 (unsigned) current_event
.dwProcessId
,
1595 (unsigned) current_event
.dwThreadId
,
1596 (unsigned) current_event
.dwDebugEventCode
));
1600 ptid
= debug_event_ptid (¤t_event
);
1601 current_thread
= find_thread_ptid (ptid
);
1605 /* Wait for the inferior process to change state.
1606 STATUS will be filled in with a response code to send to GDB.
1607 Returns the signal which caused the process to stop. */
1609 win32_process_target::wait (ptid_t ptid
, target_waitstatus
*ourstatus
,
1612 struct regcache
*regcache
;
1614 if (cached_status
.kind
!= TARGET_WAITKIND_IGNORE
)
1616 /* The core always does a wait after creating the inferior, and
1617 do_initial_child_stuff already ran the inferior to the
1618 initial breakpoint (or an exit, if creating the process
1619 fails). Report it now. */
1620 *ourstatus
= cached_status
;
1621 cached_status
.kind
= TARGET_WAITKIND_IGNORE
;
1622 return debug_event_ptid (¤t_event
);
1627 if (!get_child_debug_event (ourstatus
))
1630 switch (ourstatus
->kind
)
1632 case TARGET_WAITKIND_EXITED
:
1633 OUTMSG2 (("Child exited with retcode = %x\n",
1634 ourstatus
->value
.integer
));
1635 win32_clear_inferiors ();
1636 return ptid_t (current_event
.dwProcessId
);
1637 case TARGET_WAITKIND_STOPPED
:
1638 case TARGET_WAITKIND_SIGNALLED
:
1639 case TARGET_WAITKIND_LOADED
:
1640 OUTMSG2 (("Child Stopped with signal = %d \n",
1641 ourstatus
->value
.sig
));
1643 regcache
= get_thread_regcache (current_thread
, 1);
1644 child_fetch_inferior_registers (regcache
, -1);
1645 return debug_event_ptid (¤t_event
);
1647 OUTMSG (("Ignoring unknown internal event, %d\n", ourstatus
->kind
));
1649 case TARGET_WAITKIND_SPURIOUS
:
1650 /* do nothing, just continue */
1651 child_continue (DBG_CONTINUE
, -1);
1657 /* Fetch registers from the inferior process.
1658 If REGNO is -1, fetch all registers; otherwise, fetch at least REGNO. */
1660 win32_process_target::fetch_registers (regcache
*regcache
, int regno
)
1662 child_fetch_inferior_registers (regcache
, regno
);
1665 /* Store registers to the inferior process.
1666 If REGNO is -1, store all registers; otherwise, store at least REGNO. */
1668 win32_process_target::store_registers (regcache
*regcache
, int regno
)
1670 child_store_inferior_registers (regcache
, regno
);
1673 /* Read memory from the inferior process. This should generally be
1674 called through read_inferior_memory, which handles breakpoint shadowing.
1675 Read LEN bytes at MEMADDR into a buffer at MYADDR. */
1677 win32_process_target::read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
,
1680 return child_xfer_memory (memaddr
, (char *) myaddr
, len
, 0, 0) != len
;
1683 /* Write memory to the inferior process. This should generally be
1684 called through write_inferior_memory, which handles breakpoint shadowing.
1685 Write LEN bytes from the buffer at MYADDR to MEMADDR.
1686 Returns 0 on success and errno on failure. */
1688 win32_process_target::write_memory (CORE_ADDR memaddr
,
1689 const unsigned char *myaddr
, int len
)
1691 return child_xfer_memory (memaddr
, (char *) myaddr
, len
, 1, 0) != len
;
1694 /* Send an interrupt request to the inferior process. */
1696 win32_process_target::request_interrupt ()
1698 winapi_DebugBreakProcess DebugBreakProcess
;
1699 winapi_GenerateConsoleCtrlEvent GenerateConsoleCtrlEvent
;
1702 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
1704 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
1707 GenerateConsoleCtrlEvent
= GETPROCADDRESS (dll
, GenerateConsoleCtrlEvent
);
1709 if (GenerateConsoleCtrlEvent
!= NULL
1710 && GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, current_process_id
))
1713 /* GenerateConsoleCtrlEvent can fail if process id being debugged is
1714 not a process group id.
1715 Fallback to XP/Vista 'DebugBreakProcess', which generates a
1716 breakpoint exception in the interior process. */
1718 DebugBreakProcess
= GETPROCADDRESS (dll
, DebugBreakProcess
);
1720 if (DebugBreakProcess
!= NULL
1721 && DebugBreakProcess (current_process_handle
))
1724 /* Last resort, suspend all threads manually. */
1725 soft_interrupt_requested
= 1;
1729 win32_process_target::supports_hardware_single_step ()
1736 win32_error_to_fileio_error (DWORD err
)
1740 case ERROR_BAD_PATHNAME
:
1741 case ERROR_FILE_NOT_FOUND
:
1742 case ERROR_INVALID_NAME
:
1743 case ERROR_PATH_NOT_FOUND
:
1744 return FILEIO_ENOENT
;
1746 case ERROR_IO_DEVICE
:
1747 case ERROR_OPEN_FAILED
:
1749 case ERROR_INVALID_HANDLE
:
1750 return FILEIO_EBADF
;
1751 case ERROR_ACCESS_DENIED
:
1752 case ERROR_SHARING_VIOLATION
:
1753 return FILEIO_EACCES
;
1754 case ERROR_NOACCESS
:
1755 return FILEIO_EFAULT
;
1757 return FILEIO_EBUSY
;
1758 case ERROR_ALREADY_EXISTS
:
1759 case ERROR_FILE_EXISTS
:
1760 return FILEIO_EEXIST
;
1761 case ERROR_BAD_DEVICE
:
1762 return FILEIO_ENODEV
;
1763 case ERROR_DIRECTORY
:
1764 return FILEIO_ENOTDIR
;
1765 case ERROR_FILENAME_EXCED_RANGE
:
1766 case ERROR_INVALID_DATA
:
1767 case ERROR_INVALID_PARAMETER
:
1768 case ERROR_NEGATIVE_SEEK
:
1769 return FILEIO_EINVAL
;
1770 case ERROR_TOO_MANY_OPEN_FILES
:
1771 return FILEIO_EMFILE
;
1772 case ERROR_HANDLE_DISK_FULL
:
1773 case ERROR_DISK_FULL
:
1774 return FILEIO_ENOSPC
;
1775 case ERROR_WRITE_PROTECT
:
1776 return FILEIO_EROFS
;
1777 case ERROR_NOT_SUPPORTED
:
1778 return FILEIO_ENOSYS
;
1781 return FILEIO_EUNKNOWN
;
1785 win32_process_target::hostio_last_error (char *buf
)
1787 DWORD winerr
= GetLastError ();
1788 int fileio_err
= win32_error_to_fileio_error (winerr
);
1789 sprintf (buf
, "F-1,%x", fileio_err
);
1794 win32_process_target::supports_qxfer_siginfo ()
1799 /* Write Windows signal info. */
1802 win32_process_target::qxfer_siginfo (const char *annex
,
1803 unsigned char *readbuf
,
1804 unsigned const char *writebuf
,
1805 CORE_ADDR offset
, int len
)
1807 if (siginfo_er
.ExceptionCode
== 0)
1810 if (readbuf
== nullptr)
1813 if (offset
> sizeof (siginfo_er
))
1816 if (offset
+ len
> sizeof (siginfo_er
))
1817 len
= sizeof (siginfo_er
) - offset
;
1819 memcpy (readbuf
, (char *) &siginfo_er
+ offset
, len
);
1825 win32_process_target::supports_get_tib_address ()
1830 /* Write Windows OS Thread Information Block address. */
1833 win32_process_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
1835 windows_thread_info
*th
;
1836 th
= thread_rec (ptid
, 0);
1840 *addr
= th
->thread_local_base
;
1844 /* Implementation of the target_ops method "sw_breakpoint_from_kind". */
1847 win32_process_target::sw_breakpoint_from_kind (int kind
, int *size
)
1849 *size
= the_low_target
.breakpoint_len
;
1850 return the_low_target
.breakpoint
;
1853 /* The win32 target ops object. */
1855 static win32_process_target the_win32_target
;
1857 /* Initialize the Win32 backend. */
1859 initialize_low (void)
1861 set_target_ops (&the_win32_target
);
1862 the_low_target
.arch_setup ();