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)
175 win32_get_thread_context (th
);
179 /* Find a thread record given a thread id. If GET_CONTEXT is set then
180 also retrieve the context for this thread. */
181 static windows_thread_info
*
182 thread_rec (ptid_t ptid
, int get_context
)
184 thread_info
*thread
= find_thread_ptid (ptid
);
188 windows_thread_info
*th
= (windows_thread_info
*) thread_target_data (thread
);
190 win32_require_context (th
);
194 /* Add a thread to the thread list. */
195 static windows_thread_info
*
196 child_add_thread (DWORD pid
, DWORD tid
, HANDLE h
, void *tlb
)
198 windows_thread_info
*th
;
199 ptid_t ptid
= ptid_t (pid
, tid
, 0);
201 if ((th
= thread_rec (ptid
, FALSE
)))
204 th
= new windows_thread_info (tid
, h
, (CORE_ADDR
) (uintptr_t) tlb
);
206 add_thread (ptid
, th
);
208 if (the_low_target
.thread_added
!= NULL
)
209 (*the_low_target
.thread_added
) (th
);
214 /* Delete a thread from the list of threads. */
216 delete_thread_info (thread_info
*thread
)
218 windows_thread_info
*th
= (windows_thread_info
*) thread_target_data (thread
);
220 remove_thread (thread
);
225 /* Delete a thread from the list of threads. */
227 child_delete_thread (DWORD pid
, DWORD tid
)
229 /* If the last thread is exiting, just return. */
230 if (all_threads
.size () == 1)
233 thread_info
*thread
= find_thread_ptid (ptid_t (pid
, tid
));
237 delete_thread_info (thread
);
240 /* These watchpoint related wrapper functions simply pass on the function call
241 if the low target has registered a corresponding function. */
244 win32_process_target::supports_z_point_type (char z_type
)
246 return (the_low_target
.supports_z_point_type
!= NULL
247 && the_low_target
.supports_z_point_type (z_type
));
251 win32_process_target::insert_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
252 int size
, raw_breakpoint
*bp
)
254 if (the_low_target
.insert_point
!= NULL
)
255 return the_low_target
.insert_point (type
, addr
, size
, bp
);
257 /* Unsupported (see target.h). */
262 win32_process_target::remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
263 int size
, raw_breakpoint
*bp
)
265 if (the_low_target
.remove_point
!= NULL
)
266 return the_low_target
.remove_point (type
, addr
, size
, bp
);
268 /* Unsupported (see target.h). */
273 win32_process_target::stopped_by_watchpoint ()
275 if (the_low_target
.stopped_by_watchpoint
!= NULL
)
276 return the_low_target
.stopped_by_watchpoint ();
282 win32_process_target::stopped_data_address ()
284 if (the_low_target
.stopped_data_address
!= NULL
)
285 return the_low_target
.stopped_data_address ();
291 /* Transfer memory from/to the debugged process. */
293 child_xfer_memory (CORE_ADDR memaddr
, char *our
, int len
,
294 int write
, process_stratum_target
*target
)
299 uintptr_t addr
= (uintptr_t) memaddr
;
303 success
= WriteProcessMemory (current_process_handle
, (LPVOID
) addr
,
304 (LPCVOID
) our
, len
, &done
);
306 lasterror
= GetLastError ();
307 FlushInstructionCache (current_process_handle
, (LPCVOID
) addr
, len
);
311 success
= ReadProcessMemory (current_process_handle
, (LPCVOID
) addr
,
312 (LPVOID
) our
, len
, &done
);
314 lasterror
= GetLastError ();
316 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
319 return success
? done
: -1;
322 /* Clear out any old thread list and reinitialize it to a pristine
325 child_init_thread_list (void)
327 for_each_thread (delete_thread_info
);
330 /* Zero during the child initialization phase, and nonzero otherwise. */
332 static int child_initialization_done
= 0;
335 do_initial_child_stuff (HANDLE proch
, DWORD pid
, int attached
)
337 struct process_info
*proc
;
339 last_sig
= GDB_SIGNAL_0
;
341 current_process_handle
= proch
;
342 current_process_id
= pid
;
345 soft_interrupt_requested
= 0;
346 faked_breakpoint
= 0;
348 memset (¤t_event
, 0, sizeof (current_event
));
350 proc
= add_process (pid
, attached
);
351 proc
->tdesc
= win32_tdesc
;
352 child_init_thread_list ();
353 child_initialization_done
= 0;
355 if (the_low_target
.initial_stuff
!= NULL
)
356 (*the_low_target
.initial_stuff
) ();
358 cached_status
.kind
= TARGET_WAITKIND_IGNORE
;
360 /* Flush all currently pending debug events (thread and dll list) up
361 to the initial breakpoint. */
364 struct target_waitstatus status
;
366 the_target
->wait (minus_one_ptid
, &status
, 0);
368 /* Note win32_wait doesn't return thread events. */
369 if (status
.kind
!= TARGET_WAITKIND_LOADED
)
371 cached_status
= status
;
376 struct thread_resume resume
;
378 resume
.thread
= minus_one_ptid
;
379 resume
.kind
= resume_continue
;
382 the_target
->resume (&resume
, 1);
387 /* Now that the inferior has been started and all DLLs have been mapped,
388 we can iterate over all DLLs and load them in.
390 We avoid doing it any earlier because, on certain versions of Windows,
391 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
392 we have seen on Windows 8.1 that the ntdll.dll load event does not
393 include the DLL name, preventing us from creating an associated SO.
394 A possible explanation is that ntdll.dll might be mapped before
395 the SO info gets created by the Windows system -- ntdll.dll is
396 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
397 do not seem to suffer from that problem.
399 Rather than try to work around this sort of issue, it is much
400 simpler to just ignore DLL load/unload events during the startup
401 phase, and then process them all in one batch now. */
402 win32_add_all_dlls ();
405 child_initialization_done
= 1;
408 /* Resume all artificially suspended threads if we are continuing
411 continue_one_thread (thread_info
*thread
, int thread_id
)
413 windows_thread_info
*th
= (windows_thread_info
*) thread_target_data (thread
);
415 if (thread_id
== -1 || thread_id
== th
->tid
)
417 win32_prepare_to_resume (th
);
421 if (th
->context
.ContextFlags
)
423 win32_set_thread_context (th
);
424 th
->context
.ContextFlags
= 0;
433 child_continue (DWORD continue_status
, int thread_id
)
435 /* The inferior will only continue after the ContinueDebugEvent
437 for_each_thread ([&] (thread_info
*thread
)
439 continue_one_thread (thread
, thread_id
);
441 faked_breakpoint
= 0;
443 if (!ContinueDebugEvent (current_event
.dwProcessId
,
444 current_event
.dwThreadId
,
451 /* Fetch register(s) from the current thread context. */
453 child_fetch_inferior_registers (struct regcache
*regcache
, int r
)
456 windows_thread_info
*th
= thread_rec (current_thread_ptid (), TRUE
);
457 if (r
== -1 || r
> NUM_REGS
)
458 child_fetch_inferior_registers (regcache
, NUM_REGS
);
460 for (regno
= 0; regno
< r
; regno
++)
461 (*the_low_target
.fetch_inferior_register
) (regcache
, th
, regno
);
464 /* Store a new register value into the current thread context. We don't
465 change the program's context until later, when we resume it. */
467 child_store_inferior_registers (struct regcache
*regcache
, int r
)
470 windows_thread_info
*th
= thread_rec (current_thread_ptid (), TRUE
);
471 if (r
== -1 || r
== 0 || r
> NUM_REGS
)
472 child_store_inferior_registers (regcache
, NUM_REGS
);
474 for (regno
= 0; regno
< r
; regno
++)
475 (*the_low_target
.store_inferior_register
) (regcache
, th
, regno
);
478 /* Map the Windows error number in ERROR to a locale-dependent error
479 message string and return a pointer to it. Typically, the values
480 for ERROR come from GetLastError.
482 The string pointed to shall not be modified by the application,
483 but may be overwritten by a subsequent call to strwinerror
485 The strwinerror function does not change the current setting
489 strwinerror (DWORD error
)
491 static char buf
[1024];
493 DWORD lasterr
= GetLastError ();
494 DWORD chars
= FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
495 | FORMAT_MESSAGE_ALLOCATE_BUFFER
,
498 0, /* Default language */
504 /* If there is an \r\n appended, zap it. */
506 && msgbuf
[chars
- 2] == '\r'
507 && msgbuf
[chars
- 1] == '\n')
513 if (chars
> ((COUNTOF (buf
)) - 1))
515 chars
= COUNTOF (buf
) - 1;
520 wcstombs (buf
, msgbuf
, chars
+ 1);
522 strncpy (buf
, msgbuf
, chars
+ 1);
527 sprintf (buf
, "unknown win32 error (%u)", (unsigned) error
);
529 SetLastError (lasterr
);
534 create_process (const char *program
, char *args
,
535 DWORD flags
, PROCESS_INFORMATION
*pi
)
537 const char *inferior_cwd
= get_inferior_cwd ();
539 size_t argslen
, proglen
;
541 proglen
= strlen (program
) + 1;
542 argslen
= strlen (args
) + proglen
;
545 wchar_t *p
, *wprogram
, *wargs
, *wcwd
= NULL
;
547 wprogram
= (wchar_t *) alloca (proglen
* sizeof (wchar_t));
548 mbstowcs (wprogram
, program
, proglen
);
550 for (p
= wprogram
; *p
; ++p
)
554 wargs
= alloca ((argslen
+ 1) * sizeof (wchar_t));
555 wcscpy (wargs
, wprogram
);
556 wcscat (wargs
, L
" ");
557 mbstowcs (wargs
+ proglen
, args
, argslen
+ 1 - proglen
);
559 if (inferior_cwd
!= NULL
)
561 std::string expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
562 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
564 wcwd
= alloca ((expanded_infcwd
.size () + 1) * sizeof (wchar_t));
565 if (mbstowcs (wcwd
, expanded_infcwd
.c_str (),
566 expanded_infcwd
.size () + 1) == NULL
)
569 Could not convert the expanded inferior cwd to wide-char."));
573 ret
= CreateProcessW (wprogram
, /* image name */
574 wargs
, /* command line */
575 NULL
, /* security, not supported */
576 NULL
, /* thread, not supported */
577 FALSE
, /* inherit handles, not supported */
578 flags
, /* start flags */
579 NULL
, /* environment, not supported */
580 wcwd
, /* current directory */
581 NULL
, /* start info, not supported */
584 STARTUPINFOA si
= { sizeof (STARTUPINFOA
) };
585 char *program_and_args
= (char *) alloca (argslen
+ 1);
587 strcpy (program_and_args
, program
);
588 strcat (program_and_args
, " ");
589 strcat (program_and_args
, args
);
590 ret
= CreateProcessA (program
, /* image name */
591 program_and_args
, /* command line */
594 TRUE
, /* inherit handles */
595 flags
, /* start flags */
596 NULL
, /* environment */
597 /* current directory */
598 (inferior_cwd
== NULL
600 : gdb_tilde_expand (inferior_cwd
).c_str()),
601 &si
, /* start info */
608 /* Start a new process.
609 PROGRAM is the program name.
610 PROGRAM_ARGS is the vector containing the inferior's args.
611 Returns the new PID on success, -1 on failure. Registers the new
612 process with the process list. */
614 win32_process_target::create_inferior (const char *program
,
615 const std::vector
<char *> &program_args
)
617 client_state
&cs
= get_client_state ();
619 char real_path
[PATH_MAX
];
620 char *orig_path
, *new_path
, *path_ptr
;
624 PROCESS_INFORMATION pi
;
626 std::string str_program_args
= stringify_argv (program_args
);
627 char *args
= (char *) str_program_args
.c_str ();
629 /* win32_wait needs to know we're not attaching. */
633 error ("No executable specified, specify executable to debug.\n");
635 flags
= DEBUG_PROCESS
| DEBUG_ONLY_THIS_PROCESS
;
639 path_ptr
= getenv ("PATH");
642 int size
= cygwin_conv_path_list (CCP_POSIX_TO_WIN_A
, path_ptr
, NULL
, 0);
643 orig_path
= (char *) alloca (strlen (path_ptr
) + 1);
644 new_path
= (char *) alloca (size
);
645 strcpy (orig_path
, path_ptr
);
646 cygwin_conv_path_list (CCP_POSIX_TO_WIN_A
, path_ptr
, new_path
, size
);
647 setenv ("PATH", new_path
, 1);
649 cygwin_conv_path (CCP_POSIX_TO_WIN_A
, program
, real_path
, PATH_MAX
);
653 OUTMSG2 (("Command line is \"%s %s\"\n", program
, args
));
655 #ifdef CREATE_NEW_PROCESS_GROUP
656 flags
|= CREATE_NEW_PROCESS_GROUP
;
659 ret
= create_process (program
, args
, flags
, &pi
);
660 err
= GetLastError ();
661 if (!ret
&& err
== ERROR_FILE_NOT_FOUND
)
663 char *exename
= (char *) alloca (strlen (program
) + 5);
664 strcat (strcpy (exename
, program
), ".exe");
665 ret
= create_process (exename
, args
, flags
, &pi
);
666 err
= GetLastError ();
671 setenv ("PATH", orig_path
, 1);
676 error ("Error creating process \"%s %s\", (error %d): %s\n",
677 program
, args
, (int) err
, strwinerror (err
));
681 OUTMSG2 (("Process created: %s %s\n", program
, (char *) args
));
685 /* On Windows CE this handle can't be closed. The OS reuses
686 it in the debug events, while the 9x/NT versions of Windows
687 probably use a DuplicateHandle'd one. */
688 CloseHandle (pi
.hThread
);
691 do_initial_child_stuff (pi
.hProcess
, pi
.dwProcessId
, 0);
693 /* Wait till we are at 1st instruction in program, return new pid
694 (assuming success). */
695 cs
.last_ptid
= wait (ptid_t (current_process_id
), &cs
.last_status
, 0);
697 /* Necessary for handle_v_kill. */
698 signal_pid
= current_process_id
;
700 return current_process_id
;
703 /* Attach to a running process.
704 PID is the process ID to attach to, specified by the user
705 or a higher layer. */
707 win32_process_target::attach (unsigned long pid
)
710 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
713 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
715 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
717 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
719 h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
722 if (DebugActiveProcess (pid
))
724 if (DebugSetProcessKillOnExit
!= NULL
)
725 DebugSetProcessKillOnExit (FALSE
);
727 /* win32_wait needs to know we're attaching. */
729 do_initial_child_stuff (h
, pid
, 1);
736 err
= GetLastError ();
737 error ("Attach to process failed (error %d): %s\n",
738 (int) err
, strwinerror (err
));
741 /* Handle OUTPUT_DEBUG_STRING_EVENT from child process. */
743 handle_output_debug_string (void)
745 #define READ_BUFFER_LEN 1024
747 char s
[READ_BUFFER_LEN
+ 1] = { 0 };
748 DWORD nbytes
= current_event
.u
.DebugString
.nDebugStringLength
;
753 if (nbytes
> READ_BUFFER_LEN
)
754 nbytes
= READ_BUFFER_LEN
;
756 addr
= (CORE_ADDR
) (size_t) current_event
.u
.DebugString
.lpDebugStringData
;
758 if (current_event
.u
.DebugString
.fUnicode
)
760 /* The event tells us how many bytes, not chars, even
762 WCHAR buffer
[(READ_BUFFER_LEN
+ 1) / sizeof (WCHAR
)] = { 0 };
763 if (read_inferior_memory (addr
, (unsigned char *) buffer
, nbytes
) != 0)
765 wcstombs (s
, buffer
, (nbytes
+ 1) / sizeof (WCHAR
));
769 if (read_inferior_memory (addr
, (unsigned char *) s
, nbytes
) != 0)
773 if (!startswith (s
, "cYg"))
783 #undef READ_BUFFER_LEN
787 win32_clear_inferiors (void)
789 if (current_process_handle
!= NULL
)
790 CloseHandle (current_process_handle
);
792 for_each_thread (delete_thread_info
);
793 siginfo_er
.ExceptionCode
= 0;
797 /* Implementation of target_ops::kill. */
800 win32_process_target::kill (process_info
*process
)
802 TerminateProcess (current_process_handle
, 0);
805 if (!child_continue (DBG_CONTINUE
, -1))
807 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
809 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
811 else if (current_event
.dwDebugEventCode
== OUTPUT_DEBUG_STRING_EVENT
)
812 handle_output_debug_string ();
815 win32_clear_inferiors ();
817 remove_process (process
);
821 /* Implementation of target_ops::detach. */
824 win32_process_target::detach (process_info
*process
)
826 winapi_DebugActiveProcessStop DebugActiveProcessStop
= NULL
;
827 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
829 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
831 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
833 DebugActiveProcessStop
= GETPROCADDRESS (dll
, DebugActiveProcessStop
);
834 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
836 if (DebugSetProcessKillOnExit
== NULL
837 || DebugActiveProcessStop
== NULL
)
841 struct thread_resume resume
;
842 resume
.thread
= minus_one_ptid
;
843 resume
.kind
= resume_continue
;
845 this->resume (&resume
, 1);
848 if (!DebugActiveProcessStop (current_process_id
))
851 DebugSetProcessKillOnExit (FALSE
);
852 remove_process (process
);
854 win32_clear_inferiors ();
859 win32_process_target::mourn (struct process_info
*process
)
861 remove_process (process
);
864 /* Implementation of target_ops::join. */
867 win32_process_target::join (int pid
)
869 HANDLE h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
872 WaitForSingleObject (h
, INFINITE
);
877 /* Return true iff the thread with thread ID TID is alive. */
879 win32_process_target::thread_alive (ptid_t ptid
)
881 /* Our thread list is reliable; don't bother to poll target
883 return find_thread_ptid (ptid
) != NULL
;
886 /* Resume the inferior process. RESUME_INFO describes how we want
889 win32_process_target::resume (thread_resume
*resume_info
, size_t n
)
894 windows_thread_info
*th
;
895 DWORD continue_status
= DBG_CONTINUE
;
898 /* This handles the very limited set of resume packets that GDB can
899 currently produce. */
901 if (n
== 1 && resume_info
[0].thread
== minus_one_ptid
)
906 /* Yes, we're ignoring resume_info[0].thread. It'd be tricky to make
907 the Windows resume code do the right thing for thread switching. */
908 tid
= current_event
.dwThreadId
;
910 if (resume_info
[0].thread
!= minus_one_ptid
)
912 sig
= gdb_signal_from_host (resume_info
[0].sig
);
913 step
= resume_info
[0].kind
== resume_step
;
921 if (sig
!= GDB_SIGNAL_0
)
923 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
925 OUTMSG (("Cannot continue with signal %s here.\n",
926 gdb_signal_to_string (sig
)));
928 else if (sig
== last_sig
)
929 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
931 OUTMSG (("Can only continue with received signal %s.\n",
932 gdb_signal_to_string (last_sig
)));
935 last_sig
= GDB_SIGNAL_0
;
937 /* Get context for the currently selected thread. */
938 ptid
= debug_event_ptid (¤t_event
);
939 th
= thread_rec (ptid
, FALSE
);
942 win32_prepare_to_resume (th
);
944 if (th
->context
.ContextFlags
)
946 /* Move register values from the inferior into the thread
947 context structure. */
948 regcache_invalidate ();
952 if (the_low_target
.single_step
!= NULL
)
953 (*the_low_target
.single_step
) (th
);
955 error ("Single stepping is not supported "
956 "in this configuration.\n");
959 win32_set_thread_context (th
);
960 th
->context
.ContextFlags
= 0;
964 /* Allow continuing with the same signal that interrupted us.
965 Otherwise complain. */
967 child_continue (continue_status
, tid
);
971 win32_add_one_solib (const char *name
, CORE_ADDR load_addr
)
973 char buf
[MAX_PATH
+ 1];
974 char buf2
[MAX_PATH
+ 1];
977 WIN32_FIND_DATA w32_fd
;
978 WCHAR wname
[MAX_PATH
+ 1];
979 mbstowcs (wname
, name
, MAX_PATH
);
980 HANDLE h
= FindFirstFile (wname
, &w32_fd
);
982 WIN32_FIND_DATAA w32_fd
;
983 HANDLE h
= FindFirstFileA (name
, &w32_fd
);
986 /* The symbols in a dll are offset by 0x1000, which is the
987 offset from 0 of the first byte in an image - because
988 of the file header and the section alignment. */
991 if (h
== INVALID_HANDLE_VALUE
)
999 char cwd
[MAX_PATH
+ 1];
1001 if (GetCurrentDirectoryA (MAX_PATH
+ 1, cwd
))
1003 p
= strrchr (buf
, '\\');
1006 SetCurrentDirectoryA (buf
);
1007 GetFullPathNameA (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
1008 SetCurrentDirectoryA (cwd
);
1015 if (strcasecmp (buf
, "ntdll.dll") == 0)
1017 GetSystemDirectoryA (buf
, sizeof (buf
));
1018 strcat (buf
, "\\ntdll.dll");
1023 cygwin_conv_path (CCP_WIN_A_TO_POSIX
, buf
, buf2
, sizeof (buf2
));
1028 loaded_dll (buf2
, load_addr
);
1032 get_image_name (HANDLE h
, void *address
, int unicode
)
1034 static char buf
[(2 * MAX_PATH
) + 1];
1035 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
1041 /* Attempt to read the name of the dll that was detected.
1042 This is documented to work only when actively debugging
1043 a program. It will not work for attached processes. */
1044 if (address
== NULL
)
1048 /* Windows CE reports the address of the image name,
1049 instead of an address of a pointer into the image name. */
1050 address_ptr
= address
;
1052 /* See if we could read the address of a string, and that the
1053 address isn't null. */
1054 if (!ReadProcessMemory (h
, address
, &address_ptr
,
1055 sizeof (address_ptr
), &done
)
1056 || done
!= sizeof (address_ptr
)
1061 /* Find the length of the string */
1062 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
1063 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
1067 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
1070 WCHAR
*unicode_address
= XALLOCAVEC (WCHAR
, len
);
1071 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
1074 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
1080 typedef BOOL (WINAPI
*winapi_EnumProcessModules
) (HANDLE
, HMODULE
*,
1082 typedef BOOL (WINAPI
*winapi_GetModuleInformation
) (HANDLE
, HMODULE
,
1083 LPMODULEINFO
, DWORD
);
1084 typedef DWORD (WINAPI
*winapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
,
1087 static winapi_EnumProcessModules win32_EnumProcessModules
;
1088 static winapi_GetModuleInformation win32_GetModuleInformation
;
1089 static winapi_GetModuleFileNameExA win32_GetModuleFileNameExA
;
1094 static int psapi_loaded
= 0;
1095 static HMODULE dll
= NULL
;
1100 dll
= LoadLibrary (TEXT("psapi.dll"));
1103 win32_EnumProcessModules
=
1104 GETPROCADDRESS (dll
, EnumProcessModules
);
1105 win32_GetModuleInformation
=
1106 GETPROCADDRESS (dll
, GetModuleInformation
);
1107 win32_GetModuleFileNameExA
=
1108 GETPROCADDRESS (dll
, GetModuleFileNameExA
);
1111 return (win32_EnumProcessModules
!= NULL
1112 && win32_GetModuleInformation
!= NULL
1113 && win32_GetModuleFileNameExA
!= NULL
);
1118 /* Iterate over all DLLs currently mapped by our inferior, and
1119 add them to our list of solibs. */
1122 win32_add_all_dlls (void)
1126 HMODULE
*DllHandle
= dh_buf
;
1134 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
1139 if (!ok
|| !cbNeeded
)
1142 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
1146 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
1153 for (i
= 1; i
< ((size_t) cbNeeded
/ sizeof (HMODULE
)); i
++)
1156 char dll_name
[MAX_PATH
];
1158 if (!(*win32_GetModuleInformation
) (current_process_handle
,
1163 if ((*win32_GetModuleFileNameExA
) (current_process_handle
,
1168 win32_add_one_solib (dll_name
, (CORE_ADDR
) (uintptr_t) mi
.lpBaseOfDll
);
1173 typedef HANDLE (WINAPI
*winapi_CreateToolhelp32Snapshot
) (DWORD
, DWORD
);
1174 typedef BOOL (WINAPI
*winapi_Module32First
) (HANDLE
, LPMODULEENTRY32
);
1175 typedef BOOL (WINAPI
*winapi_Module32Next
) (HANDLE
, LPMODULEENTRY32
);
1177 /* Handle a DLL load event.
1179 This function assumes that this event did not occur during inferior
1180 initialization, where their event info may be incomplete (see
1181 do_initial_child_stuff and win32_add_all_dlls for more info on
1182 how we handle DLL loading during that phase). */
1185 handle_load_dll (void)
1187 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
1190 dll_name
= get_image_name (current_process_handle
,
1191 event
->lpImageName
, event
->fUnicode
);
1195 win32_add_one_solib (dll_name
, (CORE_ADDR
) (uintptr_t) event
->lpBaseOfDll
);
1198 /* Handle a DLL unload event.
1200 This function assumes that this event did not occur during inferior
1201 initialization, where their event info may be incomplete (see
1202 do_initial_child_stuff and win32_add_one_solib for more info
1203 on how we handle DLL loading during that phase). */
1206 handle_unload_dll (void)
1208 CORE_ADDR load_addr
=
1209 (CORE_ADDR
) (uintptr_t) current_event
.u
.UnloadDll
.lpBaseOfDll
;
1211 /* The symbols in a dll are offset by 0x1000, which is the
1212 offset from 0 of the first byte in an image - because
1213 of the file header and the section alignment. */
1214 load_addr
+= 0x1000;
1215 unloaded_dll (NULL
, load_addr
);
1219 handle_exception (struct target_waitstatus
*ourstatus
)
1221 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1223 memcpy (&siginfo_er
, ¤t_event
.u
.Exception
.ExceptionRecord
,
1226 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1230 case EXCEPTION_ACCESS_VIOLATION
:
1231 OUTMSG2 (("EXCEPTION_ACCESS_VIOLATION"));
1232 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1234 case STATUS_STACK_OVERFLOW
:
1235 OUTMSG2 (("STATUS_STACK_OVERFLOW"));
1236 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1238 case STATUS_FLOAT_DENORMAL_OPERAND
:
1239 OUTMSG2 (("STATUS_FLOAT_DENORMAL_OPERAND"));
1240 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1242 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1243 OUTMSG2 (("EXCEPTION_ARRAY_BOUNDS_EXCEEDED"));
1244 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1246 case STATUS_FLOAT_INEXACT_RESULT
:
1247 OUTMSG2 (("STATUS_FLOAT_INEXACT_RESULT"));
1248 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1250 case STATUS_FLOAT_INVALID_OPERATION
:
1251 OUTMSG2 (("STATUS_FLOAT_INVALID_OPERATION"));
1252 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1254 case STATUS_FLOAT_OVERFLOW
:
1255 OUTMSG2 (("STATUS_FLOAT_OVERFLOW"));
1256 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1258 case STATUS_FLOAT_STACK_CHECK
:
1259 OUTMSG2 (("STATUS_FLOAT_STACK_CHECK"));
1260 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1262 case STATUS_FLOAT_UNDERFLOW
:
1263 OUTMSG2 (("STATUS_FLOAT_UNDERFLOW"));
1264 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1266 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1267 OUTMSG2 (("STATUS_FLOAT_DIVIDE_BY_ZERO"));
1268 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1270 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1271 OUTMSG2 (("STATUS_INTEGER_DIVIDE_BY_ZERO"));
1272 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1274 case STATUS_INTEGER_OVERFLOW
:
1275 OUTMSG2 (("STATUS_INTEGER_OVERFLOW"));
1276 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1278 case EXCEPTION_BREAKPOINT
:
1279 OUTMSG2 (("EXCEPTION_BREAKPOINT"));
1280 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1282 /* Remove the initial breakpoint. */
1283 check_breakpoints ((CORE_ADDR
) (long) current_event
1284 .u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1288 OUTMSG2 (("DBG_CONTROL_C"));
1289 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1291 case DBG_CONTROL_BREAK
:
1292 OUTMSG2 (("DBG_CONTROL_BREAK"));
1293 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1295 case EXCEPTION_SINGLE_STEP
:
1296 OUTMSG2 (("EXCEPTION_SINGLE_STEP"));
1297 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1299 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1300 OUTMSG2 (("EXCEPTION_ILLEGAL_INSTRUCTION"));
1301 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1303 case EXCEPTION_PRIV_INSTRUCTION
:
1304 OUTMSG2 (("EXCEPTION_PRIV_INSTRUCTION"));
1305 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1307 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1308 OUTMSG2 (("EXCEPTION_NONCONTINUABLE_EXCEPTION"));
1309 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1312 if (current_event
.u
.Exception
.dwFirstChance
)
1314 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1317 OUTMSG2 (("gdbserver: unknown target exception 0x%08x at 0x%s",
1318 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1319 phex_nz ((uintptr_t) current_event
.u
.Exception
.ExceptionRecord
.
1320 ExceptionAddress
, sizeof (uintptr_t))));
1321 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1325 last_sig
= ourstatus
->value
.sig
;
1330 suspend_one_thread (thread_info
*thread
)
1332 windows_thread_info
*th
= (windows_thread_info
*) thread_target_data (thread
);
1338 fake_breakpoint_event (void)
1340 OUTMSG2(("fake_breakpoint_event\n"));
1342 faked_breakpoint
= 1;
1344 memset (¤t_event
, 0, sizeof (current_event
));
1345 current_event
.dwThreadId
= main_thread_id
;
1346 current_event
.dwDebugEventCode
= EXCEPTION_DEBUG_EVENT
;
1347 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1348 = EXCEPTION_BREAKPOINT
;
1350 for_each_thread (suspend_one_thread
);
1355 auto_delete_breakpoint (CORE_ADDR stop_pc
)
1361 /* Get the next event from the child. */
1364 get_child_debug_event (struct target_waitstatus
*ourstatus
)
1368 last_sig
= GDB_SIGNAL_0
;
1369 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1371 /* Check if GDB sent us an interrupt request. */
1372 check_remote_input_interrupt_request ();
1374 if (soft_interrupt_requested
)
1376 soft_interrupt_requested
= 0;
1377 fake_breakpoint_event ();
1386 /* WinCE doesn't set an initial breakpoint automatically. To
1387 stop the inferior, we flush all currently pending debug
1388 events -- the thread list and the dll list are always
1389 reported immediatelly without delay, then, we suspend all
1390 threads and pretend we saw a trap at the current PC of the
1393 Contrary to desktop Windows, Windows CE *does* report the dll
1394 names on LOAD_DLL_DEBUG_EVENTs resulting from a
1395 DebugActiveProcess call. This limits the way we can detect
1396 if all the dlls have already been reported. If we get a real
1397 debug event before leaving attaching, the worst that will
1398 happen is the user will see a spurious breakpoint. */
1400 current_event
.dwDebugEventCode
= 0;
1401 if (!WaitForDebugEvent (¤t_event
, 0))
1403 OUTMSG2(("no attach events left\n"));
1404 fake_breakpoint_event ();
1408 OUTMSG2(("got attach event\n"));
1413 /* Keep the wait time low enough for comfortable remote
1414 interruption, but high enough so gdbserver doesn't become a
1416 if (!WaitForDebugEvent (¤t_event
, 250))
1418 DWORD e
= GetLastError();
1420 if (e
== ERROR_PIPE_NOT_CONNECTED
)
1422 /* This will happen if the loader fails to succesfully
1423 load the application, e.g., if the main executable
1424 tries to pull in a non-existing export from a
1426 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1427 ourstatus
->value
.integer
= 1;
1437 switch (current_event
.dwDebugEventCode
)
1439 case CREATE_THREAD_DEBUG_EVENT
:
1440 OUTMSG2 (("gdbserver: kernel event CREATE_THREAD_DEBUG_EVENT "
1441 "for pid=%u tid=%x)\n",
1442 (unsigned) current_event
.dwProcessId
,
1443 (unsigned) current_event
.dwThreadId
));
1445 /* Record the existence of this thread. */
1446 child_add_thread (current_event
.dwProcessId
,
1447 current_event
.dwThreadId
,
1448 current_event
.u
.CreateThread
.hThread
,
1449 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1452 case EXIT_THREAD_DEBUG_EVENT
:
1453 OUTMSG2 (("gdbserver: kernel event EXIT_THREAD_DEBUG_EVENT "
1454 "for pid=%u tid=%x\n",
1455 (unsigned) current_event
.dwProcessId
,
1456 (unsigned) current_event
.dwThreadId
));
1457 child_delete_thread (current_event
.dwProcessId
,
1458 current_event
.dwThreadId
);
1460 current_thread
= get_first_thread ();
1463 case CREATE_PROCESS_DEBUG_EVENT
:
1464 OUTMSG2 (("gdbserver: kernel event CREATE_PROCESS_DEBUG_EVENT "
1465 "for pid=%u tid=%x\n",
1466 (unsigned) current_event
.dwProcessId
,
1467 (unsigned) current_event
.dwThreadId
));
1468 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1470 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1471 main_thread_id
= current_event
.dwThreadId
;
1473 /* Add the main thread. */
1474 child_add_thread (current_event
.dwProcessId
,
1476 current_event
.u
.CreateProcessInfo
.hThread
,
1477 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
);
1482 /* Windows CE doesn't set the initial breakpoint
1483 automatically like the desktop versions of Windows do.
1484 We add it explicitly here. It will be removed as soon as
1486 set_breakpoint_at ((CORE_ADDR
) (long) current_event
.u
1487 .CreateProcessInfo
.lpStartAddress
,
1488 auto_delete_breakpoint
);
1493 case EXIT_PROCESS_DEBUG_EVENT
:
1494 OUTMSG2 (("gdbserver: kernel event EXIT_PROCESS_DEBUG_EVENT "
1495 "for pid=%u tid=%x\n",
1496 (unsigned) current_event
.dwProcessId
,
1497 (unsigned) current_event
.dwThreadId
));
1499 DWORD exit_status
= current_event
.u
.ExitProcess
.dwExitCode
;
1500 /* If the exit status looks like a fatal exception, but we
1501 don't recognize the exception's code, make the original
1502 exit status value available, to avoid losing information. */
1504 = WIFSIGNALED (exit_status
) ? WTERMSIG (exit_status
) : -1;
1505 if (exit_signal
== -1)
1507 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1508 ourstatus
->value
.integer
= exit_status
;
1512 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1513 ourstatus
->value
.sig
= gdb_signal_from_host (exit_signal
);
1516 child_continue (DBG_CONTINUE
, -1);
1517 CloseHandle (current_process_handle
);
1518 current_process_handle
= NULL
;
1521 case LOAD_DLL_DEBUG_EVENT
:
1522 OUTMSG2 (("gdbserver: kernel event LOAD_DLL_DEBUG_EVENT "
1523 "for pid=%u tid=%x\n",
1524 (unsigned) current_event
.dwProcessId
,
1525 (unsigned) current_event
.dwThreadId
));
1526 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1527 if (! child_initialization_done
)
1531 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1532 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1535 case UNLOAD_DLL_DEBUG_EVENT
:
1536 OUTMSG2 (("gdbserver: kernel event UNLOAD_DLL_DEBUG_EVENT "
1537 "for pid=%u tid=%x\n",
1538 (unsigned) current_event
.dwProcessId
,
1539 (unsigned) current_event
.dwThreadId
));
1540 if (! child_initialization_done
)
1542 handle_unload_dll ();
1543 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1544 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1547 case EXCEPTION_DEBUG_EVENT
:
1548 OUTMSG2 (("gdbserver: kernel event EXCEPTION_DEBUG_EVENT "
1549 "for pid=%u tid=%x\n",
1550 (unsigned) current_event
.dwProcessId
,
1551 (unsigned) current_event
.dwThreadId
));
1552 handle_exception (ourstatus
);
1555 case OUTPUT_DEBUG_STRING_EVENT
:
1556 /* A message from the kernel (or Cygwin). */
1557 OUTMSG2 (("gdbserver: kernel event OUTPUT_DEBUG_STRING_EVENT "
1558 "for pid=%u tid=%x\n",
1559 (unsigned) current_event
.dwProcessId
,
1560 (unsigned) current_event
.dwThreadId
));
1561 handle_output_debug_string ();
1565 OUTMSG2 (("gdbserver: kernel event unknown "
1566 "for pid=%u tid=%x code=%x\n",
1567 (unsigned) current_event
.dwProcessId
,
1568 (unsigned) current_event
.dwThreadId
,
1569 (unsigned) current_event
.dwDebugEventCode
));
1573 ptid
= debug_event_ptid (¤t_event
);
1574 current_thread
= find_thread_ptid (ptid
);
1578 /* Wait for the inferior process to change state.
1579 STATUS will be filled in with a response code to send to GDB.
1580 Returns the signal which caused the process to stop. */
1582 win32_process_target::wait (ptid_t ptid
, target_waitstatus
*ourstatus
,
1585 struct regcache
*regcache
;
1587 if (cached_status
.kind
!= TARGET_WAITKIND_IGNORE
)
1589 /* The core always does a wait after creating the inferior, and
1590 do_initial_child_stuff already ran the inferior to the
1591 initial breakpoint (or an exit, if creating the process
1592 fails). Report it now. */
1593 *ourstatus
= cached_status
;
1594 cached_status
.kind
= TARGET_WAITKIND_IGNORE
;
1595 return debug_event_ptid (¤t_event
);
1600 if (!get_child_debug_event (ourstatus
))
1603 switch (ourstatus
->kind
)
1605 case TARGET_WAITKIND_EXITED
:
1606 OUTMSG2 (("Child exited with retcode = %x\n",
1607 ourstatus
->value
.integer
));
1608 win32_clear_inferiors ();
1609 return ptid_t (current_event
.dwProcessId
);
1610 case TARGET_WAITKIND_STOPPED
:
1611 case TARGET_WAITKIND_SIGNALLED
:
1612 case TARGET_WAITKIND_LOADED
:
1613 OUTMSG2 (("Child Stopped with signal = %d \n",
1614 ourstatus
->value
.sig
));
1616 regcache
= get_thread_regcache (current_thread
, 1);
1617 child_fetch_inferior_registers (regcache
, -1);
1618 return debug_event_ptid (¤t_event
);
1620 OUTMSG (("Ignoring unknown internal event, %d\n", ourstatus
->kind
));
1622 case TARGET_WAITKIND_SPURIOUS
:
1623 /* do nothing, just continue */
1624 child_continue (DBG_CONTINUE
, -1);
1630 /* Fetch registers from the inferior process.
1631 If REGNO is -1, fetch all registers; otherwise, fetch at least REGNO. */
1633 win32_process_target::fetch_registers (regcache
*regcache
, int regno
)
1635 child_fetch_inferior_registers (regcache
, regno
);
1638 /* Store registers to the inferior process.
1639 If REGNO is -1, store all registers; otherwise, store at least REGNO. */
1641 win32_process_target::store_registers (regcache
*regcache
, int regno
)
1643 child_store_inferior_registers (regcache
, regno
);
1646 /* Read memory from the inferior process. This should generally be
1647 called through read_inferior_memory, which handles breakpoint shadowing.
1648 Read LEN bytes at MEMADDR into a buffer at MYADDR. */
1650 win32_process_target::read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
,
1653 return child_xfer_memory (memaddr
, (char *) myaddr
, len
, 0, 0) != len
;
1656 /* Write memory to the inferior process. This should generally be
1657 called through write_inferior_memory, which handles breakpoint shadowing.
1658 Write LEN bytes from the buffer at MYADDR to MEMADDR.
1659 Returns 0 on success and errno on failure. */
1661 win32_process_target::write_memory (CORE_ADDR memaddr
,
1662 const unsigned char *myaddr
, int len
)
1664 return child_xfer_memory (memaddr
, (char *) myaddr
, len
, 1, 0) != len
;
1667 /* Send an interrupt request to the inferior process. */
1669 win32_process_target::request_interrupt ()
1671 winapi_DebugBreakProcess DebugBreakProcess
;
1672 winapi_GenerateConsoleCtrlEvent GenerateConsoleCtrlEvent
;
1675 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
1677 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
1680 GenerateConsoleCtrlEvent
= GETPROCADDRESS (dll
, GenerateConsoleCtrlEvent
);
1682 if (GenerateConsoleCtrlEvent
!= NULL
1683 && GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, current_process_id
))
1686 /* GenerateConsoleCtrlEvent can fail if process id being debugged is
1687 not a process group id.
1688 Fallback to XP/Vista 'DebugBreakProcess', which generates a
1689 breakpoint exception in the interior process. */
1691 DebugBreakProcess
= GETPROCADDRESS (dll
, DebugBreakProcess
);
1693 if (DebugBreakProcess
!= NULL
1694 && DebugBreakProcess (current_process_handle
))
1697 /* Last resort, suspend all threads manually. */
1698 soft_interrupt_requested
= 1;
1702 win32_process_target::supports_hardware_single_step ()
1709 win32_error_to_fileio_error (DWORD err
)
1713 case ERROR_BAD_PATHNAME
:
1714 case ERROR_FILE_NOT_FOUND
:
1715 case ERROR_INVALID_NAME
:
1716 case ERROR_PATH_NOT_FOUND
:
1717 return FILEIO_ENOENT
;
1719 case ERROR_IO_DEVICE
:
1720 case ERROR_OPEN_FAILED
:
1722 case ERROR_INVALID_HANDLE
:
1723 return FILEIO_EBADF
;
1724 case ERROR_ACCESS_DENIED
:
1725 case ERROR_SHARING_VIOLATION
:
1726 return FILEIO_EACCES
;
1727 case ERROR_NOACCESS
:
1728 return FILEIO_EFAULT
;
1730 return FILEIO_EBUSY
;
1731 case ERROR_ALREADY_EXISTS
:
1732 case ERROR_FILE_EXISTS
:
1733 return FILEIO_EEXIST
;
1734 case ERROR_BAD_DEVICE
:
1735 return FILEIO_ENODEV
;
1736 case ERROR_DIRECTORY
:
1737 return FILEIO_ENOTDIR
;
1738 case ERROR_FILENAME_EXCED_RANGE
:
1739 case ERROR_INVALID_DATA
:
1740 case ERROR_INVALID_PARAMETER
:
1741 case ERROR_NEGATIVE_SEEK
:
1742 return FILEIO_EINVAL
;
1743 case ERROR_TOO_MANY_OPEN_FILES
:
1744 return FILEIO_EMFILE
;
1745 case ERROR_HANDLE_DISK_FULL
:
1746 case ERROR_DISK_FULL
:
1747 return FILEIO_ENOSPC
;
1748 case ERROR_WRITE_PROTECT
:
1749 return FILEIO_EROFS
;
1750 case ERROR_NOT_SUPPORTED
:
1751 return FILEIO_ENOSYS
;
1754 return FILEIO_EUNKNOWN
;
1758 win32_process_target::hostio_last_error (char *buf
)
1760 DWORD winerr
= GetLastError ();
1761 int fileio_err
= win32_error_to_fileio_error (winerr
);
1762 sprintf (buf
, "F-1,%x", fileio_err
);
1767 win32_process_target::supports_qxfer_siginfo ()
1772 /* Write Windows signal info. */
1775 win32_process_target::qxfer_siginfo (const char *annex
,
1776 unsigned char *readbuf
,
1777 unsigned const char *writebuf
,
1778 CORE_ADDR offset
, int len
)
1780 if (siginfo_er
.ExceptionCode
== 0)
1783 if (readbuf
== nullptr)
1786 if (offset
> sizeof (siginfo_er
))
1789 if (offset
+ len
> sizeof (siginfo_er
))
1790 len
= sizeof (siginfo_er
) - offset
;
1792 memcpy (readbuf
, (char *) &siginfo_er
+ offset
, len
);
1798 win32_process_target::supports_get_tib_address ()
1803 /* Write Windows OS Thread Information Block address. */
1806 win32_process_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
1808 windows_thread_info
*th
;
1809 th
= thread_rec (ptid
, 0);
1813 *addr
= th
->thread_local_base
;
1817 /* Implementation of the target_ops method "sw_breakpoint_from_kind". */
1820 win32_process_target::sw_breakpoint_from_kind (int kind
, int *size
)
1822 *size
= the_low_target
.breakpoint_len
;
1823 return the_low_target
.breakpoint
;
1826 /* The win32 target ops object. */
1828 static win32_process_target the_win32_target
;
1830 /* Initialize the Win32 backend. */
1832 initialize_low (void)
1834 set_target_ops (&the_win32_target
);
1835 the_low_target
.arch_setup ();