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;
77 static HANDLE current_process_handle
= NULL
;
78 static DWORD current_process_id
= 0;
79 static DWORD main_thread_id
= 0;
80 static EXCEPTION_RECORD siginfo_er
; /* Contents of $_siginfo */
81 static enum gdb_signal last_sig
= GDB_SIGNAL_0
;
83 /* The current debug event from WaitForDebugEvent. */
84 static DEBUG_EVENT current_event
;
86 /* A status that hasn't been reported to the core yet, and so
87 win32_wait should return it next, instead of fetching the next
88 debug event off the win32 API. */
89 static struct target_waitstatus cached_status
;
91 /* Non zero if an interrupt request is to be satisfied by suspending
93 static int soft_interrupt_requested
= 0;
95 /* Non zero if the inferior is stopped in a simulated breakpoint done
96 by suspending all the threads. */
97 static int faked_breakpoint
= 0;
99 const struct target_desc
*win32_tdesc
;
101 #define NUM_REGS (the_low_target.num_regs)
103 typedef BOOL (WINAPI
*winapi_DebugActiveProcessStop
) (DWORD dwProcessId
);
104 typedef BOOL (WINAPI
*winapi_DebugSetProcessKillOnExit
) (BOOL KillOnExit
);
105 typedef BOOL (WINAPI
*winapi_DebugBreakProcess
) (HANDLE
);
106 typedef BOOL (WINAPI
*winapi_GenerateConsoleCtrlEvent
) (DWORD
, DWORD
);
109 static void win32_add_all_dlls (void);
112 /* Get the thread ID from the current selected inferior (the current
115 current_thread_ptid (void)
120 /* The current debug event from WaitForDebugEvent. */
122 debug_event_ptid (DEBUG_EVENT
*event
)
124 return ptid_t (event
->dwProcessId
, event
->dwThreadId
, 0);
127 /* Get the thread context of the thread associated with TH. */
130 win32_get_thread_context (windows_thread_info
*th
)
132 memset (&th
->context
, 0, sizeof (CONTEXT
));
133 (*the_low_target
.get_thread_context
) (th
);
135 memcpy (&th
->base_context
, &th
->context
, sizeof (CONTEXT
));
139 /* Set the thread context of the thread associated with TH. */
142 win32_set_thread_context (windows_thread_info
*th
)
145 /* Calling SuspendThread on a thread that is running kernel code
146 will report that the suspending was successful, but in fact, that
147 will often not be true. In those cases, the context returned by
148 GetThreadContext will not be correct by the time the thread
149 stops, hence we can't set that context back into the thread when
150 resuming - it will most likely crash the inferior.
151 Unfortunately, there is no way to know when the thread will
152 really stop. To work around it, we'll only write the context
153 back to the thread when either the user or GDB explicitly change
154 it between stopping and resuming. */
155 if (memcmp (&th
->context
, &th
->base_context
, sizeof (CONTEXT
)) != 0)
157 SetThreadContext (th
->h
, &th
->context
);
160 /* Set the thread context of the thread associated with TH. */
163 win32_prepare_to_resume (windows_thread_info
*th
)
165 if (the_low_target
.prepare_to_resume
!= NULL
)
166 (*the_low_target
.prepare_to_resume
) (th
);
169 /* See win32-low.h. */
172 win32_require_context (windows_thread_info
*th
)
174 if (th
->context
.ContextFlags
== 0)
177 win32_get_thread_context (th
);
181 /* Find a thread record given a thread id. If GET_CONTEXT is set then
182 also retrieve the context for this thread. */
183 static windows_thread_info
*
184 thread_rec (ptid_t ptid
, int get_context
)
186 thread_info
*thread
= find_thread_ptid (ptid
);
190 windows_thread_info
*th
= (windows_thread_info
*) thread_target_data (thread
);
192 win32_require_context (th
);
196 /* Add a thread to the thread list. */
197 static windows_thread_info
*
198 child_add_thread (DWORD pid
, DWORD tid
, HANDLE h
, void *tlb
)
200 windows_thread_info
*th
;
201 ptid_t ptid
= ptid_t (pid
, tid
, 0);
203 if ((th
= thread_rec (ptid
, FALSE
)))
206 th
= new windows_thread_info (tid
, h
, (CORE_ADDR
) (uintptr_t) tlb
);
208 add_thread (ptid
, th
);
210 if (the_low_target
.thread_added
!= NULL
)
211 (*the_low_target
.thread_added
) (th
);
216 /* Delete a thread from the list of threads. */
218 delete_thread_info (thread_info
*thread
)
220 windows_thread_info
*th
= (windows_thread_info
*) thread_target_data (thread
);
222 remove_thread (thread
);
226 /* Delete a thread from the list of threads. */
228 child_delete_thread (DWORD pid
, DWORD tid
)
230 /* If the last thread is exiting, just return. */
231 if (all_threads
.size () == 1)
234 thread_info
*thread
= find_thread_ptid (ptid_t (pid
, tid
));
238 delete_thread_info (thread
);
241 /* These watchpoint related wrapper functions simply pass on the function call
242 if the low target has registered a corresponding function. */
245 win32_process_target::supports_z_point_type (char z_type
)
247 return (the_low_target
.supports_z_point_type
!= NULL
248 && the_low_target
.supports_z_point_type (z_type
));
252 win32_process_target::insert_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
253 int size
, raw_breakpoint
*bp
)
255 if (the_low_target
.insert_point
!= NULL
)
256 return the_low_target
.insert_point (type
, addr
, size
, bp
);
258 /* Unsupported (see target.h). */
263 win32_process_target::remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
264 int size
, raw_breakpoint
*bp
)
266 if (the_low_target
.remove_point
!= NULL
)
267 return the_low_target
.remove_point (type
, addr
, size
, bp
);
269 /* Unsupported (see target.h). */
274 win32_process_target::stopped_by_watchpoint ()
276 if (the_low_target
.stopped_by_watchpoint
!= NULL
)
277 return the_low_target
.stopped_by_watchpoint ();
283 win32_process_target::stopped_data_address ()
285 if (the_low_target
.stopped_data_address
!= NULL
)
286 return the_low_target
.stopped_data_address ();
292 /* Transfer memory from/to the debugged process. */
294 child_xfer_memory (CORE_ADDR memaddr
, char *our
, int len
,
295 int write
, process_stratum_target
*target
)
300 uintptr_t addr
= (uintptr_t) memaddr
;
304 success
= WriteProcessMemory (current_process_handle
, (LPVOID
) addr
,
305 (LPCVOID
) our
, len
, &done
);
307 lasterror
= GetLastError ();
308 FlushInstructionCache (current_process_handle
, (LPCVOID
) addr
, len
);
312 success
= ReadProcessMemory (current_process_handle
, (LPCVOID
) addr
,
313 (LPVOID
) our
, len
, &done
);
315 lasterror
= GetLastError ();
317 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
320 return success
? done
: -1;
323 /* Clear out any old thread list and reinitialize it to a pristine
326 child_init_thread_list (void)
328 for_each_thread (delete_thread_info
);
331 /* Zero during the child initialization phase, and nonzero otherwise. */
333 static int child_initialization_done
= 0;
336 do_initial_child_stuff (HANDLE proch
, DWORD pid
, int attached
)
338 struct process_info
*proc
;
340 last_sig
= GDB_SIGNAL_0
;
342 current_process_handle
= proch
;
343 current_process_id
= pid
;
346 soft_interrupt_requested
= 0;
347 faked_breakpoint
= 0;
349 memset (¤t_event
, 0, sizeof (current_event
));
351 proc
= add_process (pid
, attached
);
352 proc
->tdesc
= win32_tdesc
;
353 child_init_thread_list ();
354 child_initialization_done
= 0;
356 if (the_low_target
.initial_stuff
!= NULL
)
357 (*the_low_target
.initial_stuff
) ();
359 cached_status
.kind
= TARGET_WAITKIND_IGNORE
;
361 /* Flush all currently pending debug events (thread and dll list) up
362 to the initial breakpoint. */
365 struct target_waitstatus status
;
367 the_target
->wait (minus_one_ptid
, &status
, 0);
369 /* Note win32_wait doesn't return thread events. */
370 if (status
.kind
!= TARGET_WAITKIND_LOADED
)
372 cached_status
= status
;
377 struct thread_resume resume
;
379 resume
.thread
= minus_one_ptid
;
380 resume
.kind
= resume_continue
;
383 the_target
->resume (&resume
, 1);
388 /* Now that the inferior has been started and all DLLs have been mapped,
389 we can iterate over all DLLs and load them in.
391 We avoid doing it any earlier because, on certain versions of Windows,
392 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
393 we have seen on Windows 8.1 that the ntdll.dll load event does not
394 include the DLL name, preventing us from creating an associated SO.
395 A possible explanation is that ntdll.dll might be mapped before
396 the SO info gets created by the Windows system -- ntdll.dll is
397 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
398 do not seem to suffer from that problem.
400 Rather than try to work around this sort of issue, it is much
401 simpler to just ignore DLL load/unload events during the startup
402 phase, and then process them all in one batch now. */
403 win32_add_all_dlls ();
406 child_initialization_done
= 1;
409 /* Resume all artificially suspended threads if we are continuing
412 continue_one_thread (thread_info
*thread
, int thread_id
)
414 windows_thread_info
*th
= (windows_thread_info
*) thread_target_data (thread
);
416 if (thread_id
== -1 || thread_id
== th
->tid
)
418 win32_prepare_to_resume (th
);
422 if (th
->context
.ContextFlags
)
424 win32_set_thread_context (th
);
425 th
->context
.ContextFlags
= 0;
434 child_continue (DWORD continue_status
, int thread_id
)
436 /* The inferior will only continue after the ContinueDebugEvent
438 for_each_thread ([&] (thread_info
*thread
)
440 continue_one_thread (thread
, thread_id
);
442 faked_breakpoint
= 0;
444 if (!ContinueDebugEvent (current_event
.dwProcessId
,
445 current_event
.dwThreadId
,
452 /* Fetch register(s) from the current thread context. */
454 child_fetch_inferior_registers (struct regcache
*regcache
, int r
)
457 windows_thread_info
*th
= thread_rec (current_thread_ptid (), TRUE
);
458 if (r
== -1 || r
> NUM_REGS
)
459 child_fetch_inferior_registers (regcache
, NUM_REGS
);
461 for (regno
= 0; regno
< r
; regno
++)
462 (*the_low_target
.fetch_inferior_register
) (regcache
, th
, regno
);
465 /* Store a new register value into the current thread context. We don't
466 change the program's context until later, when we resume it. */
468 child_store_inferior_registers (struct regcache
*regcache
, int r
)
471 windows_thread_info
*th
= thread_rec (current_thread_ptid (), TRUE
);
472 if (r
== -1 || r
== 0 || r
> NUM_REGS
)
473 child_store_inferior_registers (regcache
, NUM_REGS
);
475 for (regno
= 0; regno
< r
; regno
++)
476 (*the_low_target
.store_inferior_register
) (regcache
, th
, regno
);
479 /* Map the Windows error number in ERROR to a locale-dependent error
480 message string and return a pointer to it. Typically, the values
481 for ERROR come from GetLastError.
483 The string pointed to shall not be modified by the application,
484 but may be overwritten by a subsequent call to strwinerror
486 The strwinerror function does not change the current setting
490 strwinerror (DWORD error
)
492 static char buf
[1024];
494 DWORD lasterr
= GetLastError ();
495 DWORD chars
= FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
496 | FORMAT_MESSAGE_ALLOCATE_BUFFER
,
499 0, /* Default language */
505 /* If there is an \r\n appended, zap it. */
507 && msgbuf
[chars
- 2] == '\r'
508 && msgbuf
[chars
- 1] == '\n')
514 if (chars
> ((COUNTOF (buf
)) - 1))
516 chars
= COUNTOF (buf
) - 1;
521 wcstombs (buf
, msgbuf
, chars
+ 1);
523 strncpy (buf
, msgbuf
, chars
+ 1);
528 sprintf (buf
, "unknown win32 error (%u)", (unsigned) error
);
530 SetLastError (lasterr
);
535 create_process (const char *program
, char *args
,
536 DWORD flags
, PROCESS_INFORMATION
*pi
)
538 const char *inferior_cwd
= get_inferior_cwd ();
540 size_t argslen
, proglen
;
542 proglen
= strlen (program
) + 1;
543 argslen
= strlen (args
) + proglen
;
546 wchar_t *p
, *wprogram
, *wargs
, *wcwd
= NULL
;
548 wprogram
= (wchar_t *) alloca (proglen
* sizeof (wchar_t));
549 mbstowcs (wprogram
, program
, proglen
);
551 for (p
= wprogram
; *p
; ++p
)
555 wargs
= alloca ((argslen
+ 1) * sizeof (wchar_t));
556 wcscpy (wargs
, wprogram
);
557 wcscat (wargs
, L
" ");
558 mbstowcs (wargs
+ proglen
, args
, argslen
+ 1 - proglen
);
560 if (inferior_cwd
!= NULL
)
562 std::string expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
563 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
565 wcwd
= alloca ((expanded_infcwd
.size () + 1) * sizeof (wchar_t));
566 if (mbstowcs (wcwd
, expanded_infcwd
.c_str (),
567 expanded_infcwd
.size () + 1) == NULL
)
570 Could not convert the expanded inferior cwd to wide-char."));
574 ret
= CreateProcessW (wprogram
, /* image name */
575 wargs
, /* command line */
576 NULL
, /* security, not supported */
577 NULL
, /* thread, not supported */
578 FALSE
, /* inherit handles, not supported */
579 flags
, /* start flags */
580 NULL
, /* environment, not supported */
581 wcwd
, /* current directory */
582 NULL
, /* start info, not supported */
585 STARTUPINFOA si
= { sizeof (STARTUPINFOA
) };
586 char *program_and_args
= (char *) alloca (argslen
+ 1);
588 strcpy (program_and_args
, program
);
589 strcat (program_and_args
, " ");
590 strcat (program_and_args
, args
);
591 ret
= CreateProcessA (program
, /* image name */
592 program_and_args
, /* command line */
595 TRUE
, /* inherit handles */
596 flags
, /* start flags */
597 NULL
, /* environment */
598 /* current directory */
599 (inferior_cwd
== NULL
601 : gdb_tilde_expand (inferior_cwd
).c_str()),
602 &si
, /* start info */
609 /* Start a new process.
610 PROGRAM is the program name.
611 PROGRAM_ARGS is the vector containing the inferior's args.
612 Returns the new PID on success, -1 on failure. Registers the new
613 process with the process list. */
615 win32_process_target::create_inferior (const char *program
,
616 const std::vector
<char *> &program_args
)
618 client_state
&cs
= get_client_state ();
620 char real_path
[PATH_MAX
];
621 char *orig_path
, *new_path
, *path_ptr
;
625 PROCESS_INFORMATION pi
;
627 std::string str_program_args
= stringify_argv (program_args
);
628 char *args
= (char *) str_program_args
.c_str ();
630 /* win32_wait needs to know we're not attaching. */
634 error ("No executable specified, specify executable to debug.\n");
636 flags
= DEBUG_PROCESS
| DEBUG_ONLY_THIS_PROCESS
;
640 path_ptr
= getenv ("PATH");
643 int size
= cygwin_conv_path_list (CCP_POSIX_TO_WIN_A
, path_ptr
, NULL
, 0);
644 orig_path
= (char *) alloca (strlen (path_ptr
) + 1);
645 new_path
= (char *) alloca (size
);
646 strcpy (orig_path
, path_ptr
);
647 cygwin_conv_path_list (CCP_POSIX_TO_WIN_A
, path_ptr
, new_path
, size
);
648 setenv ("PATH", new_path
, 1);
650 cygwin_conv_path (CCP_POSIX_TO_WIN_A
, program
, real_path
, PATH_MAX
);
654 OUTMSG2 (("Command line is \"%s %s\"\n", program
, args
));
656 #ifdef CREATE_NEW_PROCESS_GROUP
657 flags
|= CREATE_NEW_PROCESS_GROUP
;
660 ret
= create_process (program
, args
, flags
, &pi
);
661 err
= GetLastError ();
662 if (!ret
&& err
== ERROR_FILE_NOT_FOUND
)
664 char *exename
= (char *) alloca (strlen (program
) + 5);
665 strcat (strcpy (exename
, program
), ".exe");
666 ret
= create_process (exename
, args
, flags
, &pi
);
667 err
= GetLastError ();
672 setenv ("PATH", orig_path
, 1);
677 error ("Error creating process \"%s %s\", (error %d): %s\n",
678 program
, args
, (int) err
, strwinerror (err
));
682 OUTMSG2 (("Process created: %s %s\n", program
, (char *) args
));
686 /* On Windows CE this handle can't be closed. The OS reuses
687 it in the debug events, while the 9x/NT versions of Windows
688 probably use a DuplicateHandle'd one. */
689 CloseHandle (pi
.hThread
);
692 do_initial_child_stuff (pi
.hProcess
, pi
.dwProcessId
, 0);
694 /* Wait till we are at 1st instruction in program, return new pid
695 (assuming success). */
696 cs
.last_ptid
= wait (ptid_t (current_process_id
), &cs
.last_status
, 0);
698 /* Necessary for handle_v_kill. */
699 signal_pid
= current_process_id
;
701 return current_process_id
;
704 /* Attach to a running process.
705 PID is the process ID to attach to, specified by the user
706 or a higher layer. */
708 win32_process_target::attach (unsigned long pid
)
711 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
714 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
716 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
718 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
720 h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
723 if (DebugActiveProcess (pid
))
725 if (DebugSetProcessKillOnExit
!= NULL
)
726 DebugSetProcessKillOnExit (FALSE
);
728 /* win32_wait needs to know we're attaching. */
730 do_initial_child_stuff (h
, pid
, 1);
737 err
= GetLastError ();
738 error ("Attach to process failed (error %d): %s\n",
739 (int) err
, strwinerror (err
));
742 /* Handle OUTPUT_DEBUG_STRING_EVENT from child process. */
744 handle_output_debug_string (void)
746 #define READ_BUFFER_LEN 1024
748 char s
[READ_BUFFER_LEN
+ 1] = { 0 };
749 DWORD nbytes
= current_event
.u
.DebugString
.nDebugStringLength
;
754 if (nbytes
> READ_BUFFER_LEN
)
755 nbytes
= READ_BUFFER_LEN
;
757 addr
= (CORE_ADDR
) (size_t) current_event
.u
.DebugString
.lpDebugStringData
;
759 if (current_event
.u
.DebugString
.fUnicode
)
761 /* The event tells us how many bytes, not chars, even
763 WCHAR buffer
[(READ_BUFFER_LEN
+ 1) / sizeof (WCHAR
)] = { 0 };
764 if (read_inferior_memory (addr
, (unsigned char *) buffer
, nbytes
) != 0)
766 wcstombs (s
, buffer
, (nbytes
+ 1) / sizeof (WCHAR
));
770 if (read_inferior_memory (addr
, (unsigned char *) s
, nbytes
) != 0)
774 if (!startswith (s
, "cYg"))
784 #undef READ_BUFFER_LEN
788 win32_clear_inferiors (void)
790 if (current_process_handle
!= NULL
)
791 CloseHandle (current_process_handle
);
793 for_each_thread (delete_thread_info
);
794 siginfo_er
.ExceptionCode
= 0;
798 /* Implementation of target_ops::kill. */
801 win32_process_target::kill (process_info
*process
)
803 TerminateProcess (current_process_handle
, 0);
806 if (!child_continue (DBG_CONTINUE
, -1))
808 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
810 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
812 else if (current_event
.dwDebugEventCode
== OUTPUT_DEBUG_STRING_EVENT
)
813 handle_output_debug_string ();
816 win32_clear_inferiors ();
818 remove_process (process
);
822 /* Implementation of target_ops::detach. */
825 win32_process_target::detach (process_info
*process
)
827 winapi_DebugActiveProcessStop DebugActiveProcessStop
= NULL
;
828 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
830 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
832 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
834 DebugActiveProcessStop
= GETPROCADDRESS (dll
, DebugActiveProcessStop
);
835 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
837 if (DebugSetProcessKillOnExit
== NULL
838 || DebugActiveProcessStop
== NULL
)
842 struct thread_resume resume
;
843 resume
.thread
= minus_one_ptid
;
844 resume
.kind
= resume_continue
;
846 this->resume (&resume
, 1);
849 if (!DebugActiveProcessStop (current_process_id
))
852 DebugSetProcessKillOnExit (FALSE
);
853 remove_process (process
);
855 win32_clear_inferiors ();
860 win32_process_target::mourn (struct process_info
*process
)
862 remove_process (process
);
865 /* Implementation of target_ops::join. */
868 win32_process_target::join (int pid
)
870 HANDLE h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
873 WaitForSingleObject (h
, INFINITE
);
878 /* Return true iff the thread with thread ID TID is alive. */
880 win32_process_target::thread_alive (ptid_t ptid
)
882 /* Our thread list is reliable; don't bother to poll target
884 return find_thread_ptid (ptid
) != NULL
;
887 /* Resume the inferior process. RESUME_INFO describes how we want
890 win32_process_target::resume (thread_resume
*resume_info
, size_t n
)
895 windows_thread_info
*th
;
896 DWORD continue_status
= DBG_CONTINUE
;
899 /* This handles the very limited set of resume packets that GDB can
900 currently produce. */
902 if (n
== 1 && resume_info
[0].thread
== minus_one_ptid
)
907 /* Yes, we're ignoring resume_info[0].thread. It'd be tricky to make
908 the Windows resume code do the right thing for thread switching. */
909 tid
= current_event
.dwThreadId
;
911 if (resume_info
[0].thread
!= minus_one_ptid
)
913 sig
= gdb_signal_from_host (resume_info
[0].sig
);
914 step
= resume_info
[0].kind
== resume_step
;
922 if (sig
!= GDB_SIGNAL_0
)
924 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
926 OUTMSG (("Cannot continue with signal %s here.\n",
927 gdb_signal_to_string (sig
)));
929 else if (sig
== last_sig
)
930 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
932 OUTMSG (("Can only continue with received signal %s.\n",
933 gdb_signal_to_string (last_sig
)));
936 last_sig
= GDB_SIGNAL_0
;
938 /* Get context for the currently selected thread. */
939 ptid
= debug_event_ptid (¤t_event
);
940 th
= thread_rec (ptid
, FALSE
);
943 win32_prepare_to_resume (th
);
945 if (th
->context
.ContextFlags
)
947 /* Move register values from the inferior into the thread
948 context structure. */
949 regcache_invalidate ();
953 if (the_low_target
.single_step
!= NULL
)
954 (*the_low_target
.single_step
) (th
);
956 error ("Single stepping is not supported "
957 "in this configuration.\n");
960 win32_set_thread_context (th
);
961 th
->context
.ContextFlags
= 0;
965 /* Allow continuing with the same signal that interrupted us.
966 Otherwise complain. */
968 child_continue (continue_status
, tid
);
972 win32_add_one_solib (const char *name
, CORE_ADDR load_addr
)
974 char buf
[MAX_PATH
+ 1];
975 char buf2
[MAX_PATH
+ 1];
978 WIN32_FIND_DATA w32_fd
;
979 WCHAR wname
[MAX_PATH
+ 1];
980 mbstowcs (wname
, name
, MAX_PATH
);
981 HANDLE h
= FindFirstFile (wname
, &w32_fd
);
983 WIN32_FIND_DATAA w32_fd
;
984 HANDLE h
= FindFirstFileA (name
, &w32_fd
);
987 /* The symbols in a dll are offset by 0x1000, which is the
988 offset from 0 of the first byte in an image - because
989 of the file header and the section alignment. */
992 if (h
== INVALID_HANDLE_VALUE
)
1000 char cwd
[MAX_PATH
+ 1];
1002 if (GetCurrentDirectoryA (MAX_PATH
+ 1, cwd
))
1004 p
= strrchr (buf
, '\\');
1007 SetCurrentDirectoryA (buf
);
1008 GetFullPathNameA (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
1009 SetCurrentDirectoryA (cwd
);
1016 if (strcasecmp (buf
, "ntdll.dll") == 0)
1018 GetSystemDirectoryA (buf
, sizeof (buf
));
1019 strcat (buf
, "\\ntdll.dll");
1024 cygwin_conv_path (CCP_WIN_A_TO_POSIX
, buf
, buf2
, sizeof (buf2
));
1029 loaded_dll (buf2
, load_addr
);
1033 get_image_name (HANDLE h
, void *address
, int unicode
)
1035 static char buf
[(2 * MAX_PATH
) + 1];
1036 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
1042 /* Attempt to read the name of the dll that was detected.
1043 This is documented to work only when actively debugging
1044 a program. It will not work for attached processes. */
1045 if (address
== NULL
)
1049 /* Windows CE reports the address of the image name,
1050 instead of an address of a pointer into the image name. */
1051 address_ptr
= address
;
1053 /* See if we could read the address of a string, and that the
1054 address isn't null. */
1055 if (!ReadProcessMemory (h
, address
, &address_ptr
,
1056 sizeof (address_ptr
), &done
)
1057 || done
!= sizeof (address_ptr
)
1062 /* Find the length of the string */
1063 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
1064 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
1068 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
1071 WCHAR
*unicode_address
= XALLOCAVEC (WCHAR
, len
);
1072 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
1075 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
1081 typedef BOOL (WINAPI
*winapi_EnumProcessModules
) (HANDLE
, HMODULE
*,
1083 typedef BOOL (WINAPI
*winapi_GetModuleInformation
) (HANDLE
, HMODULE
,
1084 LPMODULEINFO
, DWORD
);
1085 typedef DWORD (WINAPI
*winapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
,
1088 static winapi_EnumProcessModules win32_EnumProcessModules
;
1089 static winapi_GetModuleInformation win32_GetModuleInformation
;
1090 static winapi_GetModuleFileNameExA win32_GetModuleFileNameExA
;
1095 static int psapi_loaded
= 0;
1096 static HMODULE dll
= NULL
;
1101 dll
= LoadLibrary (TEXT("psapi.dll"));
1104 win32_EnumProcessModules
=
1105 GETPROCADDRESS (dll
, EnumProcessModules
);
1106 win32_GetModuleInformation
=
1107 GETPROCADDRESS (dll
, GetModuleInformation
);
1108 win32_GetModuleFileNameExA
=
1109 GETPROCADDRESS (dll
, GetModuleFileNameExA
);
1112 return (win32_EnumProcessModules
!= NULL
1113 && win32_GetModuleInformation
!= NULL
1114 && win32_GetModuleFileNameExA
!= NULL
);
1119 /* Iterate over all DLLs currently mapped by our inferior, and
1120 add them to our list of solibs. */
1123 win32_add_all_dlls (void)
1127 HMODULE
*DllHandle
= dh_buf
;
1135 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
1140 if (!ok
|| !cbNeeded
)
1143 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
1147 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
1154 for (i
= 1; i
< ((size_t) cbNeeded
/ sizeof (HMODULE
)); i
++)
1157 char dll_name
[MAX_PATH
];
1159 if (!(*win32_GetModuleInformation
) (current_process_handle
,
1164 if ((*win32_GetModuleFileNameExA
) (current_process_handle
,
1169 win32_add_one_solib (dll_name
, (CORE_ADDR
) (uintptr_t) mi
.lpBaseOfDll
);
1174 typedef HANDLE (WINAPI
*winapi_CreateToolhelp32Snapshot
) (DWORD
, DWORD
);
1175 typedef BOOL (WINAPI
*winapi_Module32First
) (HANDLE
, LPMODULEENTRY32
);
1176 typedef BOOL (WINAPI
*winapi_Module32Next
) (HANDLE
, LPMODULEENTRY32
);
1178 /* Handle a DLL load event.
1180 This function assumes that this event did not occur during inferior
1181 initialization, where their event info may be incomplete (see
1182 do_initial_child_stuff and win32_add_all_dlls for more info on
1183 how we handle DLL loading during that phase). */
1186 handle_load_dll (void)
1188 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
1191 dll_name
= get_image_name (current_process_handle
,
1192 event
->lpImageName
, event
->fUnicode
);
1196 win32_add_one_solib (dll_name
, (CORE_ADDR
) (uintptr_t) event
->lpBaseOfDll
);
1199 /* Handle a DLL unload event.
1201 This function assumes that this event did not occur during inferior
1202 initialization, where their event info may be incomplete (see
1203 do_initial_child_stuff and win32_add_one_solib for more info
1204 on how we handle DLL loading during that phase). */
1207 handle_unload_dll (void)
1209 CORE_ADDR load_addr
=
1210 (CORE_ADDR
) (uintptr_t) current_event
.u
.UnloadDll
.lpBaseOfDll
;
1212 /* The symbols in a dll are offset by 0x1000, which is the
1213 offset from 0 of the first byte in an image - because
1214 of the file header and the section alignment. */
1215 load_addr
+= 0x1000;
1216 unloaded_dll (NULL
, load_addr
);
1220 handle_exception (struct target_waitstatus
*ourstatus
)
1222 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1224 memcpy (&siginfo_er
, ¤t_event
.u
.Exception
.ExceptionRecord
,
1227 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1231 case EXCEPTION_ACCESS_VIOLATION
:
1232 OUTMSG2 (("EXCEPTION_ACCESS_VIOLATION"));
1233 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1235 case STATUS_STACK_OVERFLOW
:
1236 OUTMSG2 (("STATUS_STACK_OVERFLOW"));
1237 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1239 case STATUS_FLOAT_DENORMAL_OPERAND
:
1240 OUTMSG2 (("STATUS_FLOAT_DENORMAL_OPERAND"));
1241 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1243 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1244 OUTMSG2 (("EXCEPTION_ARRAY_BOUNDS_EXCEEDED"));
1245 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1247 case STATUS_FLOAT_INEXACT_RESULT
:
1248 OUTMSG2 (("STATUS_FLOAT_INEXACT_RESULT"));
1249 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1251 case STATUS_FLOAT_INVALID_OPERATION
:
1252 OUTMSG2 (("STATUS_FLOAT_INVALID_OPERATION"));
1253 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1255 case STATUS_FLOAT_OVERFLOW
:
1256 OUTMSG2 (("STATUS_FLOAT_OVERFLOW"));
1257 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1259 case STATUS_FLOAT_STACK_CHECK
:
1260 OUTMSG2 (("STATUS_FLOAT_STACK_CHECK"));
1261 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1263 case STATUS_FLOAT_UNDERFLOW
:
1264 OUTMSG2 (("STATUS_FLOAT_UNDERFLOW"));
1265 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1267 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1268 OUTMSG2 (("STATUS_FLOAT_DIVIDE_BY_ZERO"));
1269 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1271 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1272 OUTMSG2 (("STATUS_INTEGER_DIVIDE_BY_ZERO"));
1273 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1275 case STATUS_INTEGER_OVERFLOW
:
1276 OUTMSG2 (("STATUS_INTEGER_OVERFLOW"));
1277 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1279 case EXCEPTION_BREAKPOINT
:
1280 OUTMSG2 (("EXCEPTION_BREAKPOINT"));
1281 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1283 /* Remove the initial breakpoint. */
1284 check_breakpoints ((CORE_ADDR
) (long) current_event
1285 .u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1289 OUTMSG2 (("DBG_CONTROL_C"));
1290 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1292 case DBG_CONTROL_BREAK
:
1293 OUTMSG2 (("DBG_CONTROL_BREAK"));
1294 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1296 case EXCEPTION_SINGLE_STEP
:
1297 OUTMSG2 (("EXCEPTION_SINGLE_STEP"));
1298 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1300 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1301 OUTMSG2 (("EXCEPTION_ILLEGAL_INSTRUCTION"));
1302 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1304 case EXCEPTION_PRIV_INSTRUCTION
:
1305 OUTMSG2 (("EXCEPTION_PRIV_INSTRUCTION"));
1306 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1308 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1309 OUTMSG2 (("EXCEPTION_NONCONTINUABLE_EXCEPTION"));
1310 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1313 if (current_event
.u
.Exception
.dwFirstChance
)
1315 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1318 OUTMSG2 (("gdbserver: unknown target exception 0x%08x at 0x%s",
1319 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1320 phex_nz ((uintptr_t) current_event
.u
.Exception
.ExceptionRecord
.
1321 ExceptionAddress
, sizeof (uintptr_t))));
1322 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1326 last_sig
= ourstatus
->value
.sig
;
1331 suspend_one_thread (thread_info
*thread
)
1333 windows_thread_info
*th
= (windows_thread_info
*) thread_target_data (thread
);
1339 fake_breakpoint_event (void)
1341 OUTMSG2(("fake_breakpoint_event\n"));
1343 faked_breakpoint
= 1;
1345 memset (¤t_event
, 0, sizeof (current_event
));
1346 current_event
.dwThreadId
= main_thread_id
;
1347 current_event
.dwDebugEventCode
= EXCEPTION_DEBUG_EVENT
;
1348 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1349 = EXCEPTION_BREAKPOINT
;
1351 for_each_thread (suspend_one_thread
);
1356 auto_delete_breakpoint (CORE_ADDR stop_pc
)
1362 /* Get the next event from the child. */
1365 get_child_debug_event (struct target_waitstatus
*ourstatus
)
1369 last_sig
= GDB_SIGNAL_0
;
1370 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1372 /* Check if GDB sent us an interrupt request. */
1373 check_remote_input_interrupt_request ();
1375 if (soft_interrupt_requested
)
1377 soft_interrupt_requested
= 0;
1378 fake_breakpoint_event ();
1387 /* WinCE doesn't set an initial breakpoint automatically. To
1388 stop the inferior, we flush all currently pending debug
1389 events -- the thread list and the dll list are always
1390 reported immediatelly without delay, then, we suspend all
1391 threads and pretend we saw a trap at the current PC of the
1394 Contrary to desktop Windows, Windows CE *does* report the dll
1395 names on LOAD_DLL_DEBUG_EVENTs resulting from a
1396 DebugActiveProcess call. This limits the way we can detect
1397 if all the dlls have already been reported. If we get a real
1398 debug event before leaving attaching, the worst that will
1399 happen is the user will see a spurious breakpoint. */
1401 current_event
.dwDebugEventCode
= 0;
1402 if (!WaitForDebugEvent (¤t_event
, 0))
1404 OUTMSG2(("no attach events left\n"));
1405 fake_breakpoint_event ();
1409 OUTMSG2(("got attach event\n"));
1414 /* Keep the wait time low enough for comfortable remote
1415 interruption, but high enough so gdbserver doesn't become a
1417 if (!WaitForDebugEvent (¤t_event
, 250))
1419 DWORD e
= GetLastError();
1421 if (e
== ERROR_PIPE_NOT_CONNECTED
)
1423 /* This will happen if the loader fails to succesfully
1424 load the application, e.g., if the main executable
1425 tries to pull in a non-existing export from a
1427 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1428 ourstatus
->value
.integer
= 1;
1438 switch (current_event
.dwDebugEventCode
)
1440 case CREATE_THREAD_DEBUG_EVENT
:
1441 OUTMSG2 (("gdbserver: kernel event CREATE_THREAD_DEBUG_EVENT "
1442 "for pid=%u tid=%x)\n",
1443 (unsigned) current_event
.dwProcessId
,
1444 (unsigned) current_event
.dwThreadId
));
1446 /* Record the existence of this thread. */
1447 child_add_thread (current_event
.dwProcessId
,
1448 current_event
.dwThreadId
,
1449 current_event
.u
.CreateThread
.hThread
,
1450 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1453 case EXIT_THREAD_DEBUG_EVENT
:
1454 OUTMSG2 (("gdbserver: kernel event EXIT_THREAD_DEBUG_EVENT "
1455 "for pid=%u tid=%x\n",
1456 (unsigned) current_event
.dwProcessId
,
1457 (unsigned) current_event
.dwThreadId
));
1458 child_delete_thread (current_event
.dwProcessId
,
1459 current_event
.dwThreadId
);
1461 current_thread
= get_first_thread ();
1464 case CREATE_PROCESS_DEBUG_EVENT
:
1465 OUTMSG2 (("gdbserver: kernel event CREATE_PROCESS_DEBUG_EVENT "
1466 "for pid=%u tid=%x\n",
1467 (unsigned) current_event
.dwProcessId
,
1468 (unsigned) current_event
.dwThreadId
));
1469 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1471 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1472 main_thread_id
= current_event
.dwThreadId
;
1474 /* Add the main thread. */
1475 child_add_thread (current_event
.dwProcessId
,
1477 current_event
.u
.CreateProcessInfo
.hThread
,
1478 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
);
1483 /* Windows CE doesn't set the initial breakpoint
1484 automatically like the desktop versions of Windows do.
1485 We add it explicitly here. It will be removed as soon as
1487 set_breakpoint_at ((CORE_ADDR
) (long) current_event
.u
1488 .CreateProcessInfo
.lpStartAddress
,
1489 auto_delete_breakpoint
);
1494 case EXIT_PROCESS_DEBUG_EVENT
:
1495 OUTMSG2 (("gdbserver: kernel event EXIT_PROCESS_DEBUG_EVENT "
1496 "for pid=%u tid=%x\n",
1497 (unsigned) current_event
.dwProcessId
,
1498 (unsigned) current_event
.dwThreadId
));
1500 DWORD exit_status
= current_event
.u
.ExitProcess
.dwExitCode
;
1501 /* If the exit status looks like a fatal exception, but we
1502 don't recognize the exception's code, make the original
1503 exit status value available, to avoid losing information. */
1505 = WIFSIGNALED (exit_status
) ? WTERMSIG (exit_status
) : -1;
1506 if (exit_signal
== -1)
1508 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1509 ourstatus
->value
.integer
= exit_status
;
1513 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1514 ourstatus
->value
.sig
= gdb_signal_from_host (exit_signal
);
1517 child_continue (DBG_CONTINUE
, -1);
1518 CloseHandle (current_process_handle
);
1519 current_process_handle
= NULL
;
1522 case LOAD_DLL_DEBUG_EVENT
:
1523 OUTMSG2 (("gdbserver: kernel event LOAD_DLL_DEBUG_EVENT "
1524 "for pid=%u tid=%x\n",
1525 (unsigned) current_event
.dwProcessId
,
1526 (unsigned) current_event
.dwThreadId
));
1527 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1528 if (! child_initialization_done
)
1532 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1533 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1536 case UNLOAD_DLL_DEBUG_EVENT
:
1537 OUTMSG2 (("gdbserver: kernel event UNLOAD_DLL_DEBUG_EVENT "
1538 "for pid=%u tid=%x\n",
1539 (unsigned) current_event
.dwProcessId
,
1540 (unsigned) current_event
.dwThreadId
));
1541 if (! child_initialization_done
)
1543 handle_unload_dll ();
1544 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1545 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1548 case EXCEPTION_DEBUG_EVENT
:
1549 OUTMSG2 (("gdbserver: kernel event EXCEPTION_DEBUG_EVENT "
1550 "for pid=%u tid=%x\n",
1551 (unsigned) current_event
.dwProcessId
,
1552 (unsigned) current_event
.dwThreadId
));
1553 handle_exception (ourstatus
);
1556 case OUTPUT_DEBUG_STRING_EVENT
:
1557 /* A message from the kernel (or Cygwin). */
1558 OUTMSG2 (("gdbserver: kernel event OUTPUT_DEBUG_STRING_EVENT "
1559 "for pid=%u tid=%x\n",
1560 (unsigned) current_event
.dwProcessId
,
1561 (unsigned) current_event
.dwThreadId
));
1562 handle_output_debug_string ();
1566 OUTMSG2 (("gdbserver: kernel event unknown "
1567 "for pid=%u tid=%x code=%x\n",
1568 (unsigned) current_event
.dwProcessId
,
1569 (unsigned) current_event
.dwThreadId
,
1570 (unsigned) current_event
.dwDebugEventCode
));
1574 ptid
= debug_event_ptid (¤t_event
);
1575 current_thread
= find_thread_ptid (ptid
);
1579 /* Wait for the inferior process to change state.
1580 STATUS will be filled in with a response code to send to GDB.
1581 Returns the signal which caused the process to stop. */
1583 win32_process_target::wait (ptid_t ptid
, target_waitstatus
*ourstatus
,
1586 struct regcache
*regcache
;
1588 if (cached_status
.kind
!= TARGET_WAITKIND_IGNORE
)
1590 /* The core always does a wait after creating the inferior, and
1591 do_initial_child_stuff already ran the inferior to the
1592 initial breakpoint (or an exit, if creating the process
1593 fails). Report it now. */
1594 *ourstatus
= cached_status
;
1595 cached_status
.kind
= TARGET_WAITKIND_IGNORE
;
1596 return debug_event_ptid (¤t_event
);
1601 if (!get_child_debug_event (ourstatus
))
1604 switch (ourstatus
->kind
)
1606 case TARGET_WAITKIND_EXITED
:
1607 OUTMSG2 (("Child exited with retcode = %x\n",
1608 ourstatus
->value
.integer
));
1609 win32_clear_inferiors ();
1610 return ptid_t (current_event
.dwProcessId
);
1611 case TARGET_WAITKIND_STOPPED
:
1612 case TARGET_WAITKIND_SIGNALLED
:
1613 case TARGET_WAITKIND_LOADED
:
1614 OUTMSG2 (("Child Stopped with signal = %d \n",
1615 ourstatus
->value
.sig
));
1617 regcache
= get_thread_regcache (current_thread
, 1);
1618 child_fetch_inferior_registers (regcache
, -1);
1619 return debug_event_ptid (¤t_event
);
1621 OUTMSG (("Ignoring unknown internal event, %d\n", ourstatus
->kind
));
1623 case TARGET_WAITKIND_SPURIOUS
:
1624 /* do nothing, just continue */
1625 child_continue (DBG_CONTINUE
, -1);
1631 /* Fetch registers from the inferior process.
1632 If REGNO is -1, fetch all registers; otherwise, fetch at least REGNO. */
1634 win32_process_target::fetch_registers (regcache
*regcache
, int regno
)
1636 child_fetch_inferior_registers (regcache
, regno
);
1639 /* Store registers to the inferior process.
1640 If REGNO is -1, store all registers; otherwise, store at least REGNO. */
1642 win32_process_target::store_registers (regcache
*regcache
, int regno
)
1644 child_store_inferior_registers (regcache
, regno
);
1647 /* Read memory from the inferior process. This should generally be
1648 called through read_inferior_memory, which handles breakpoint shadowing.
1649 Read LEN bytes at MEMADDR into a buffer at MYADDR. */
1651 win32_process_target::read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
,
1654 return child_xfer_memory (memaddr
, (char *) myaddr
, len
, 0, 0) != len
;
1657 /* Write memory to the inferior process. This should generally be
1658 called through write_inferior_memory, which handles breakpoint shadowing.
1659 Write LEN bytes from the buffer at MYADDR to MEMADDR.
1660 Returns 0 on success and errno on failure. */
1662 win32_process_target::write_memory (CORE_ADDR memaddr
,
1663 const unsigned char *myaddr
, int len
)
1665 return child_xfer_memory (memaddr
, (char *) myaddr
, len
, 1, 0) != len
;
1668 /* Send an interrupt request to the inferior process. */
1670 win32_process_target::request_interrupt ()
1672 winapi_DebugBreakProcess DebugBreakProcess
;
1673 winapi_GenerateConsoleCtrlEvent GenerateConsoleCtrlEvent
;
1676 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
1678 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
1681 GenerateConsoleCtrlEvent
= GETPROCADDRESS (dll
, GenerateConsoleCtrlEvent
);
1683 if (GenerateConsoleCtrlEvent
!= NULL
1684 && GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, current_process_id
))
1687 /* GenerateConsoleCtrlEvent can fail if process id being debugged is
1688 not a process group id.
1689 Fallback to XP/Vista 'DebugBreakProcess', which generates a
1690 breakpoint exception in the interior process. */
1692 DebugBreakProcess
= GETPROCADDRESS (dll
, DebugBreakProcess
);
1694 if (DebugBreakProcess
!= NULL
1695 && DebugBreakProcess (current_process_handle
))
1698 /* Last resort, suspend all threads manually. */
1699 soft_interrupt_requested
= 1;
1703 win32_process_target::supports_hardware_single_step ()
1710 win32_error_to_fileio_error (DWORD err
)
1714 case ERROR_BAD_PATHNAME
:
1715 case ERROR_FILE_NOT_FOUND
:
1716 case ERROR_INVALID_NAME
:
1717 case ERROR_PATH_NOT_FOUND
:
1718 return FILEIO_ENOENT
;
1720 case ERROR_IO_DEVICE
:
1721 case ERROR_OPEN_FAILED
:
1723 case ERROR_INVALID_HANDLE
:
1724 return FILEIO_EBADF
;
1725 case ERROR_ACCESS_DENIED
:
1726 case ERROR_SHARING_VIOLATION
:
1727 return FILEIO_EACCES
;
1728 case ERROR_NOACCESS
:
1729 return FILEIO_EFAULT
;
1731 return FILEIO_EBUSY
;
1732 case ERROR_ALREADY_EXISTS
:
1733 case ERROR_FILE_EXISTS
:
1734 return FILEIO_EEXIST
;
1735 case ERROR_BAD_DEVICE
:
1736 return FILEIO_ENODEV
;
1737 case ERROR_DIRECTORY
:
1738 return FILEIO_ENOTDIR
;
1739 case ERROR_FILENAME_EXCED_RANGE
:
1740 case ERROR_INVALID_DATA
:
1741 case ERROR_INVALID_PARAMETER
:
1742 case ERROR_NEGATIVE_SEEK
:
1743 return FILEIO_EINVAL
;
1744 case ERROR_TOO_MANY_OPEN_FILES
:
1745 return FILEIO_EMFILE
;
1746 case ERROR_HANDLE_DISK_FULL
:
1747 case ERROR_DISK_FULL
:
1748 return FILEIO_ENOSPC
;
1749 case ERROR_WRITE_PROTECT
:
1750 return FILEIO_EROFS
;
1751 case ERROR_NOT_SUPPORTED
:
1752 return FILEIO_ENOSYS
;
1755 return FILEIO_EUNKNOWN
;
1759 win32_process_target::hostio_last_error (char *buf
)
1761 DWORD winerr
= GetLastError ();
1762 int fileio_err
= win32_error_to_fileio_error (winerr
);
1763 sprintf (buf
, "F-1,%x", fileio_err
);
1768 win32_process_target::supports_qxfer_siginfo ()
1773 /* Write Windows signal info. */
1776 win32_process_target::qxfer_siginfo (const char *annex
,
1777 unsigned char *readbuf
,
1778 unsigned const char *writebuf
,
1779 CORE_ADDR offset
, int len
)
1781 if (siginfo_er
.ExceptionCode
== 0)
1784 if (readbuf
== nullptr)
1787 if (offset
> sizeof (siginfo_er
))
1790 if (offset
+ len
> sizeof (siginfo_er
))
1791 len
= sizeof (siginfo_er
) - offset
;
1793 memcpy (readbuf
, (char *) &siginfo_er
+ offset
, len
);
1799 win32_process_target::supports_get_tib_address ()
1804 /* Write Windows OS Thread Information Block address. */
1807 win32_process_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
1809 windows_thread_info
*th
;
1810 th
= thread_rec (ptid
, 0);
1814 *addr
= th
->thread_local_base
;
1818 /* Implementation of the target_ops method "sw_breakpoint_from_kind". */
1821 win32_process_target::sw_breakpoint_from_kind (int kind
, int *size
)
1823 *size
= the_low_target
.breakpoint_len
;
1824 return the_low_target
.breakpoint
;
1827 /* The win32 target ops object. */
1829 static win32_process_target the_win32_target
;
1831 /* Initialize the Win32 backend. */
1833 initialize_low (void)
1835 set_target_ops (&the_win32_target
);
1836 the_low_target
.arch_setup ();