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 (win32_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 (win32_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 (win32_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 (win32_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 win32_thread_info
*
193 thread_rec (ptid_t ptid
, int get_context
)
195 thread_info
*thread
= find_thread_ptid (ptid
);
199 win32_thread_info
*th
= (win32_thread_info
*) thread_target_data (thread
);
201 win32_require_context (th
);
205 /* Add a thread to the thread list. */
206 static win32_thread_info
*
207 child_add_thread (DWORD pid
, DWORD tid
, HANDLE h
, void *tlb
)
209 win32_thread_info
*th
;
210 ptid_t ptid
= ptid_t (pid
, tid
, 0);
212 if ((th
= thread_rec (ptid
, FALSE
)))
215 th
= XCNEW (win32_thread_info
);
218 th
->thread_local_base
= (CORE_ADDR
) (uintptr_t) tlb
;
220 add_thread (ptid
, th
);
222 if (the_low_target
.thread_added
!= NULL
)
223 (*the_low_target
.thread_added
) (th
);
228 /* Delete a thread from the list of threads. */
230 delete_thread_info (thread_info
*thread
)
232 win32_thread_info
*th
= (win32_thread_info
*) thread_target_data (thread
);
234 remove_thread (thread
);
239 /* Delete a thread from the list of threads. */
241 child_delete_thread (DWORD pid
, DWORD tid
)
243 /* If the last thread is exiting, just return. */
244 if (all_threads
.size () == 1)
247 thread_info
*thread
= find_thread_ptid (ptid_t (pid
, tid
));
251 delete_thread_info (thread
);
254 /* These watchpoint related wrapper functions simply pass on the function call
255 if the low target has registered a corresponding function. */
258 win32_process_target::supports_z_point_type (char z_type
)
260 return (the_low_target
.supports_z_point_type
!= NULL
261 && the_low_target
.supports_z_point_type (z_type
));
265 win32_process_target::insert_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
266 int size
, raw_breakpoint
*bp
)
268 if (the_low_target
.insert_point
!= NULL
)
269 return the_low_target
.insert_point (type
, addr
, size
, bp
);
271 /* Unsupported (see target.h). */
276 win32_process_target::remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
277 int size
, raw_breakpoint
*bp
)
279 if (the_low_target
.remove_point
!= NULL
)
280 return the_low_target
.remove_point (type
, addr
, size
, bp
);
282 /* Unsupported (see target.h). */
287 win32_process_target::stopped_by_watchpoint ()
289 if (the_low_target
.stopped_by_watchpoint
!= NULL
)
290 return the_low_target
.stopped_by_watchpoint ();
296 win32_process_target::stopped_data_address ()
298 if (the_low_target
.stopped_data_address
!= NULL
)
299 return the_low_target
.stopped_data_address ();
305 /* Transfer memory from/to the debugged process. */
307 child_xfer_memory (CORE_ADDR memaddr
, char *our
, int len
,
308 int write
, process_stratum_target
*target
)
313 uintptr_t addr
= (uintptr_t) memaddr
;
317 success
= WriteProcessMemory (current_process_handle
, (LPVOID
) addr
,
318 (LPCVOID
) our
, len
, &done
);
320 lasterror
= GetLastError ();
321 FlushInstructionCache (current_process_handle
, (LPCVOID
) addr
, len
);
325 success
= ReadProcessMemory (current_process_handle
, (LPCVOID
) addr
,
326 (LPVOID
) our
, len
, &done
);
328 lasterror
= GetLastError ();
330 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
333 return success
? done
: -1;
336 /* Clear out any old thread list and reinitialize it to a pristine
339 child_init_thread_list (void)
341 for_each_thread (delete_thread_info
);
344 /* Zero during the child initialization phase, and nonzero otherwise. */
346 static int child_initialization_done
= 0;
349 do_initial_child_stuff (HANDLE proch
, DWORD pid
, int attached
)
351 struct process_info
*proc
;
353 last_sig
= GDB_SIGNAL_0
;
355 current_process_handle
= proch
;
356 current_process_id
= pid
;
359 soft_interrupt_requested
= 0;
360 faked_breakpoint
= 0;
362 memset (¤t_event
, 0, sizeof (current_event
));
364 proc
= add_process (pid
, attached
);
365 proc
->tdesc
= win32_tdesc
;
366 child_init_thread_list ();
367 child_initialization_done
= 0;
369 if (the_low_target
.initial_stuff
!= NULL
)
370 (*the_low_target
.initial_stuff
) ();
372 cached_status
.kind
= TARGET_WAITKIND_IGNORE
;
374 /* Flush all currently pending debug events (thread and dll list) up
375 to the initial breakpoint. */
378 struct target_waitstatus status
;
380 the_target
->pt
->wait (minus_one_ptid
, &status
, 0);
382 /* Note win32_wait doesn't return thread events. */
383 if (status
.kind
!= TARGET_WAITKIND_LOADED
)
385 cached_status
= status
;
390 struct thread_resume resume
;
392 resume
.thread
= minus_one_ptid
;
393 resume
.kind
= resume_continue
;
396 the_target
->pt
->resume (&resume
, 1);
401 /* Now that the inferior has been started and all DLLs have been mapped,
402 we can iterate over all DLLs and load them in.
404 We avoid doing it any earlier because, on certain versions of Windows,
405 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
406 we have seen on Windows 8.1 that the ntdll.dll load event does not
407 include the DLL name, preventing us from creating an associated SO.
408 A possible explanation is that ntdll.dll might be mapped before
409 the SO info gets created by the Windows system -- ntdll.dll is
410 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
411 do not seem to suffer from that problem.
413 Rather than try to work around this sort of issue, it is much
414 simpler to just ignore DLL load/unload events during the startup
415 phase, and then process them all in one batch now. */
416 win32_add_all_dlls ();
419 child_initialization_done
= 1;
422 /* Resume all artificially suspended threads if we are continuing
425 continue_one_thread (thread_info
*thread
, int thread_id
)
427 win32_thread_info
*th
= (win32_thread_info
*) thread_target_data (thread
);
429 if (thread_id
== -1 || thread_id
== th
->tid
)
431 win32_prepare_to_resume (th
);
435 if (th
->context
.ContextFlags
)
437 win32_set_thread_context (th
);
438 th
->context
.ContextFlags
= 0;
441 if (ResumeThread (th
->h
) == (DWORD
) -1)
443 DWORD err
= GetLastError ();
444 OUTMSG (("warning: ResumeThread failed in continue_one_thread, "
445 "(error %d): %s\n", (int) err
, strwinerror (err
)));
453 child_continue (DWORD continue_status
, int thread_id
)
455 /* The inferior will only continue after the ContinueDebugEvent
457 for_each_thread ([&] (thread_info
*thread
)
459 continue_one_thread (thread
, thread_id
);
461 faked_breakpoint
= 0;
463 if (!ContinueDebugEvent (current_event
.dwProcessId
,
464 current_event
.dwThreadId
,
471 /* Fetch register(s) from the current thread context. */
473 child_fetch_inferior_registers (struct regcache
*regcache
, int r
)
476 win32_thread_info
*th
= thread_rec (current_thread_ptid (), TRUE
);
477 if (r
== -1 || r
> NUM_REGS
)
478 child_fetch_inferior_registers (regcache
, NUM_REGS
);
480 for (regno
= 0; regno
< r
; regno
++)
481 (*the_low_target
.fetch_inferior_register
) (regcache
, th
, regno
);
484 /* Store a new register value into the current thread context. We don't
485 change the program's context until later, when we resume it. */
487 child_store_inferior_registers (struct regcache
*regcache
, int r
)
490 win32_thread_info
*th
= thread_rec (current_thread_ptid (), TRUE
);
491 if (r
== -1 || r
== 0 || r
> NUM_REGS
)
492 child_store_inferior_registers (regcache
, NUM_REGS
);
494 for (regno
= 0; regno
< r
; regno
++)
495 (*the_low_target
.store_inferior_register
) (regcache
, th
, regno
);
498 /* Map the Windows error number in ERROR to a locale-dependent error
499 message string and return a pointer to it. Typically, the values
500 for ERROR come from GetLastError.
502 The string pointed to shall not be modified by the application,
503 but may be overwritten by a subsequent call to strwinerror
505 The strwinerror function does not change the current setting
509 strwinerror (DWORD error
)
511 static char buf
[1024];
513 DWORD lasterr
= GetLastError ();
514 DWORD chars
= FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
515 | FORMAT_MESSAGE_ALLOCATE_BUFFER
,
518 0, /* Default language */
524 /* If there is an \r\n appended, zap it. */
526 && msgbuf
[chars
- 2] == '\r'
527 && msgbuf
[chars
- 1] == '\n')
533 if (chars
> ((COUNTOF (buf
)) - 1))
535 chars
= COUNTOF (buf
) - 1;
540 wcstombs (buf
, msgbuf
, chars
+ 1);
542 strncpy (buf
, msgbuf
, chars
+ 1);
547 sprintf (buf
, "unknown win32 error (%u)", (unsigned) error
);
549 SetLastError (lasterr
);
554 create_process (const char *program
, char *args
,
555 DWORD flags
, PROCESS_INFORMATION
*pi
)
557 const char *inferior_cwd
= get_inferior_cwd ();
559 size_t argslen
, proglen
;
561 proglen
= strlen (program
) + 1;
562 argslen
= strlen (args
) + proglen
;
565 wchar_t *p
, *wprogram
, *wargs
, *wcwd
= NULL
;
567 wprogram
= (wchar_t *) alloca (proglen
* sizeof (wchar_t));
568 mbstowcs (wprogram
, program
, proglen
);
570 for (p
= wprogram
; *p
; ++p
)
574 wargs
= alloca ((argslen
+ 1) * sizeof (wchar_t));
575 wcscpy (wargs
, wprogram
);
576 wcscat (wargs
, L
" ");
577 mbstowcs (wargs
+ proglen
, args
, argslen
+ 1 - proglen
);
579 if (inferior_cwd
!= NULL
)
581 std::string expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
582 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
584 wcwd
= alloca ((expanded_infcwd
.size () + 1) * sizeof (wchar_t));
585 if (mbstowcs (wcwd
, expanded_infcwd
.c_str (),
586 expanded_infcwd
.size () + 1) == NULL
)
589 Could not convert the expanded inferior cwd to wide-char."));
593 ret
= CreateProcessW (wprogram
, /* image name */
594 wargs
, /* command line */
595 NULL
, /* security, not supported */
596 NULL
, /* thread, not supported */
597 FALSE
, /* inherit handles, not supported */
598 flags
, /* start flags */
599 NULL
, /* environment, not supported */
600 wcwd
, /* current directory */
601 NULL
, /* start info, not supported */
604 STARTUPINFOA si
= { sizeof (STARTUPINFOA
) };
605 char *program_and_args
= (char *) alloca (argslen
+ 1);
607 strcpy (program_and_args
, program
);
608 strcat (program_and_args
, " ");
609 strcat (program_and_args
, args
);
610 ret
= CreateProcessA (program
, /* image name */
611 program_and_args
, /* command line */
614 TRUE
, /* inherit handles */
615 flags
, /* start flags */
616 NULL
, /* environment */
617 /* current directory */
618 (inferior_cwd
== NULL
620 : gdb_tilde_expand (inferior_cwd
).c_str()),
621 &si
, /* start info */
628 /* Start a new process.
629 PROGRAM is the program name.
630 PROGRAM_ARGS is the vector containing the inferior's args.
631 Returns the new PID on success, -1 on failure. Registers the new
632 process with the process list. */
634 win32_process_target::create_inferior (const char *program
,
635 const std::vector
<char *> &program_args
)
637 client_state
&cs
= get_client_state ();
639 char real_path
[PATH_MAX
];
640 char *orig_path
, *new_path
, *path_ptr
;
644 PROCESS_INFORMATION pi
;
646 std::string str_program_args
= stringify_argv (program_args
);
647 char *args
= (char *) str_program_args
.c_str ();
649 /* win32_wait needs to know we're not attaching. */
653 error ("No executable specified, specify executable to debug.\n");
655 flags
= DEBUG_PROCESS
| DEBUG_ONLY_THIS_PROCESS
;
659 path_ptr
= getenv ("PATH");
662 int size
= cygwin_conv_path_list (CCP_POSIX_TO_WIN_A
, path_ptr
, NULL
, 0);
663 orig_path
= (char *) alloca (strlen (path_ptr
) + 1);
664 new_path
= (char *) alloca (size
);
665 strcpy (orig_path
, path_ptr
);
666 cygwin_conv_path_list (CCP_POSIX_TO_WIN_A
, path_ptr
, new_path
, size
);
667 setenv ("PATH", new_path
, 1);
669 cygwin_conv_path (CCP_POSIX_TO_WIN_A
, program
, real_path
, PATH_MAX
);
673 OUTMSG2 (("Command line is \"%s %s\"\n", program
, args
));
675 #ifdef CREATE_NEW_PROCESS_GROUP
676 flags
|= CREATE_NEW_PROCESS_GROUP
;
679 ret
= create_process (program
, args
, flags
, &pi
);
680 err
= GetLastError ();
681 if (!ret
&& err
== ERROR_FILE_NOT_FOUND
)
683 char *exename
= (char *) alloca (strlen (program
) + 5);
684 strcat (strcpy (exename
, program
), ".exe");
685 ret
= create_process (exename
, args
, flags
, &pi
);
686 err
= GetLastError ();
691 setenv ("PATH", orig_path
, 1);
696 error ("Error creating process \"%s %s\", (error %d): %s\n",
697 program
, args
, (int) err
, strwinerror (err
));
701 OUTMSG2 (("Process created: %s %s\n", program
, (char *) args
));
705 /* On Windows CE this handle can't be closed. The OS reuses
706 it in the debug events, while the 9x/NT versions of Windows
707 probably use a DuplicateHandle'd one. */
708 CloseHandle (pi
.hThread
);
711 do_initial_child_stuff (pi
.hProcess
, pi
.dwProcessId
, 0);
713 /* Wait till we are at 1st instruction in program, return new pid
714 (assuming success). */
715 cs
.last_ptid
= wait (ptid_t (current_process_id
), &cs
.last_status
, 0);
717 /* Necessary for handle_v_kill. */
718 signal_pid
= current_process_id
;
720 return current_process_id
;
723 /* Attach to a running process.
724 PID is the process ID to attach to, specified by the user
725 or a higher layer. */
727 win32_process_target::attach (unsigned long pid
)
730 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
733 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
735 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
737 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
739 h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
742 if (DebugActiveProcess (pid
))
744 if (DebugSetProcessKillOnExit
!= NULL
)
745 DebugSetProcessKillOnExit (FALSE
);
747 /* win32_wait needs to know we're attaching. */
749 do_initial_child_stuff (h
, pid
, 1);
756 err
= GetLastError ();
757 error ("Attach to process failed (error %d): %s\n",
758 (int) err
, strwinerror (err
));
761 /* Handle OUTPUT_DEBUG_STRING_EVENT from child process. */
763 handle_output_debug_string (void)
765 #define READ_BUFFER_LEN 1024
767 char s
[READ_BUFFER_LEN
+ 1] = { 0 };
768 DWORD nbytes
= current_event
.u
.DebugString
.nDebugStringLength
;
773 if (nbytes
> READ_BUFFER_LEN
)
774 nbytes
= READ_BUFFER_LEN
;
776 addr
= (CORE_ADDR
) (size_t) current_event
.u
.DebugString
.lpDebugStringData
;
778 if (current_event
.u
.DebugString
.fUnicode
)
780 /* The event tells us how many bytes, not chars, even
782 WCHAR buffer
[(READ_BUFFER_LEN
+ 1) / sizeof (WCHAR
)] = { 0 };
783 if (read_inferior_memory (addr
, (unsigned char *) buffer
, nbytes
) != 0)
785 wcstombs (s
, buffer
, (nbytes
+ 1) / sizeof (WCHAR
));
789 if (read_inferior_memory (addr
, (unsigned char *) s
, nbytes
) != 0)
793 if (!startswith (s
, "cYg"))
803 #undef READ_BUFFER_LEN
807 win32_clear_inferiors (void)
809 if (current_process_handle
!= NULL
)
810 CloseHandle (current_process_handle
);
812 for_each_thread (delete_thread_info
);
813 siginfo_er
.ExceptionCode
= 0;
817 /* Implementation of target_ops::kill. */
820 win32_process_target::kill (process_info
*process
)
822 TerminateProcess (current_process_handle
, 0);
825 if (!child_continue (DBG_CONTINUE
, -1))
827 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
829 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
831 else if (current_event
.dwDebugEventCode
== OUTPUT_DEBUG_STRING_EVENT
)
832 handle_output_debug_string ();
835 win32_clear_inferiors ();
837 remove_process (process
);
841 /* Implementation of target_ops::detach. */
844 win32_process_target::detach (process_info
*process
)
846 winapi_DebugActiveProcessStop DebugActiveProcessStop
= NULL
;
847 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
849 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
851 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
853 DebugActiveProcessStop
= GETPROCADDRESS (dll
, DebugActiveProcessStop
);
854 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
856 if (DebugSetProcessKillOnExit
== NULL
857 || DebugActiveProcessStop
== NULL
)
861 struct thread_resume resume
;
862 resume
.thread
= minus_one_ptid
;
863 resume
.kind
= resume_continue
;
865 this->resume (&resume
, 1);
868 if (!DebugActiveProcessStop (current_process_id
))
871 DebugSetProcessKillOnExit (FALSE
);
872 remove_process (process
);
874 win32_clear_inferiors ();
879 win32_process_target::mourn (struct process_info
*process
)
881 remove_process (process
);
884 /* Implementation of target_ops::join. */
887 win32_process_target::join (int pid
)
889 HANDLE h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
892 WaitForSingleObject (h
, INFINITE
);
897 /* Return true iff the thread with thread ID TID is alive. */
899 win32_process_target::thread_alive (ptid_t ptid
)
901 /* Our thread list is reliable; don't bother to poll target
903 return find_thread_ptid (ptid
) != NULL
;
906 /* Resume the inferior process. RESUME_INFO describes how we want
909 win32_process_target::resume (thread_resume
*resume_info
, size_t n
)
914 win32_thread_info
*th
;
915 DWORD continue_status
= DBG_CONTINUE
;
918 /* This handles the very limited set of resume packets that GDB can
919 currently produce. */
921 if (n
== 1 && resume_info
[0].thread
== minus_one_ptid
)
926 /* Yes, we're ignoring resume_info[0].thread. It'd be tricky to make
927 the Windows resume code do the right thing for thread switching. */
928 tid
= current_event
.dwThreadId
;
930 if (resume_info
[0].thread
!= minus_one_ptid
)
932 sig
= gdb_signal_from_host (resume_info
[0].sig
);
933 step
= resume_info
[0].kind
== resume_step
;
941 if (sig
!= GDB_SIGNAL_0
)
943 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
945 OUTMSG (("Cannot continue with signal %s here.\n",
946 gdb_signal_to_string (sig
)));
948 else if (sig
== last_sig
)
949 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
951 OUTMSG (("Can only continue with received signal %s.\n",
952 gdb_signal_to_string (last_sig
)));
955 last_sig
= GDB_SIGNAL_0
;
957 /* Get context for the currently selected thread. */
958 ptid
= debug_event_ptid (¤t_event
);
959 th
= thread_rec (ptid
, FALSE
);
962 win32_prepare_to_resume (th
);
964 if (th
->context
.ContextFlags
)
966 /* Move register values from the inferior into the thread
967 context structure. */
968 regcache_invalidate ();
972 if (the_low_target
.single_step
!= NULL
)
973 (*the_low_target
.single_step
) (th
);
975 error ("Single stepping is not supported "
976 "in this configuration.\n");
979 win32_set_thread_context (th
);
980 th
->context
.ContextFlags
= 0;
984 /* Allow continuing with the same signal that interrupted us.
985 Otherwise complain. */
987 child_continue (continue_status
, tid
);
991 win32_add_one_solib (const char *name
, CORE_ADDR load_addr
)
993 char buf
[MAX_PATH
+ 1];
994 char buf2
[MAX_PATH
+ 1];
997 WIN32_FIND_DATA w32_fd
;
998 WCHAR wname
[MAX_PATH
+ 1];
999 mbstowcs (wname
, name
, MAX_PATH
);
1000 HANDLE h
= FindFirstFile (wname
, &w32_fd
);
1002 WIN32_FIND_DATAA w32_fd
;
1003 HANDLE h
= FindFirstFileA (name
, &w32_fd
);
1006 /* The symbols in a dll are offset by 0x1000, which is the
1007 offset from 0 of the first byte in an image - because
1008 of the file header and the section alignment. */
1009 load_addr
+= 0x1000;
1011 if (h
== INVALID_HANDLE_VALUE
)
1019 char cwd
[MAX_PATH
+ 1];
1021 if (GetCurrentDirectoryA (MAX_PATH
+ 1, cwd
))
1023 p
= strrchr (buf
, '\\');
1026 SetCurrentDirectoryA (buf
);
1027 GetFullPathNameA (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
1028 SetCurrentDirectoryA (cwd
);
1035 if (strcasecmp (buf
, "ntdll.dll") == 0)
1037 GetSystemDirectoryA (buf
, sizeof (buf
));
1038 strcat (buf
, "\\ntdll.dll");
1043 cygwin_conv_path (CCP_WIN_A_TO_POSIX
, buf
, buf2
, sizeof (buf2
));
1048 loaded_dll (buf2
, load_addr
);
1052 get_image_name (HANDLE h
, void *address
, int unicode
)
1054 static char buf
[(2 * MAX_PATH
) + 1];
1055 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
1061 /* Attempt to read the name of the dll that was detected.
1062 This is documented to work only when actively debugging
1063 a program. It will not work for attached processes. */
1064 if (address
== NULL
)
1068 /* Windows CE reports the address of the image name,
1069 instead of an address of a pointer into the image name. */
1070 address_ptr
= address
;
1072 /* See if we could read the address of a string, and that the
1073 address isn't null. */
1074 if (!ReadProcessMemory (h
, address
, &address_ptr
,
1075 sizeof (address_ptr
), &done
)
1076 || done
!= sizeof (address_ptr
)
1081 /* Find the length of the string */
1082 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
1083 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
1087 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
1090 WCHAR
*unicode_address
= XALLOCAVEC (WCHAR
, len
);
1091 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
1094 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
1100 typedef BOOL (WINAPI
*winapi_EnumProcessModules
) (HANDLE
, HMODULE
*,
1102 typedef BOOL (WINAPI
*winapi_GetModuleInformation
) (HANDLE
, HMODULE
,
1103 LPMODULEINFO
, DWORD
);
1104 typedef DWORD (WINAPI
*winapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
,
1107 static winapi_EnumProcessModules win32_EnumProcessModules
;
1108 static winapi_GetModuleInformation win32_GetModuleInformation
;
1109 static winapi_GetModuleFileNameExA win32_GetModuleFileNameExA
;
1114 static int psapi_loaded
= 0;
1115 static HMODULE dll
= NULL
;
1120 dll
= LoadLibrary (TEXT("psapi.dll"));
1123 win32_EnumProcessModules
=
1124 GETPROCADDRESS (dll
, EnumProcessModules
);
1125 win32_GetModuleInformation
=
1126 GETPROCADDRESS (dll
, GetModuleInformation
);
1127 win32_GetModuleFileNameExA
=
1128 GETPROCADDRESS (dll
, GetModuleFileNameExA
);
1131 return (win32_EnumProcessModules
!= NULL
1132 && win32_GetModuleInformation
!= NULL
1133 && win32_GetModuleFileNameExA
!= NULL
);
1138 /* Iterate over all DLLs currently mapped by our inferior, and
1139 add them to our list of solibs. */
1142 win32_add_all_dlls (void)
1146 HMODULE
*DllHandle
= dh_buf
;
1154 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
1159 if (!ok
|| !cbNeeded
)
1162 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
1166 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
1173 for (i
= 1; i
< ((size_t) cbNeeded
/ sizeof (HMODULE
)); i
++)
1176 char dll_name
[MAX_PATH
];
1178 if (!(*win32_GetModuleInformation
) (current_process_handle
,
1183 if ((*win32_GetModuleFileNameExA
) (current_process_handle
,
1188 win32_add_one_solib (dll_name
, (CORE_ADDR
) (uintptr_t) mi
.lpBaseOfDll
);
1193 typedef HANDLE (WINAPI
*winapi_CreateToolhelp32Snapshot
) (DWORD
, DWORD
);
1194 typedef BOOL (WINAPI
*winapi_Module32First
) (HANDLE
, LPMODULEENTRY32
);
1195 typedef BOOL (WINAPI
*winapi_Module32Next
) (HANDLE
, LPMODULEENTRY32
);
1197 /* Handle a DLL load event.
1199 This function assumes that this event did not occur during inferior
1200 initialization, where their event info may be incomplete (see
1201 do_initial_child_stuff and win32_add_all_dlls for more info on
1202 how we handle DLL loading during that phase). */
1205 handle_load_dll (void)
1207 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
1210 dll_name
= get_image_name (current_process_handle
,
1211 event
->lpImageName
, event
->fUnicode
);
1215 win32_add_one_solib (dll_name
, (CORE_ADDR
) (uintptr_t) event
->lpBaseOfDll
);
1218 /* Handle a DLL unload event.
1220 This function assumes that this event did not occur during inferior
1221 initialization, where their event info may be incomplete (see
1222 do_initial_child_stuff and win32_add_one_solib for more info
1223 on how we handle DLL loading during that phase). */
1226 handle_unload_dll (void)
1228 CORE_ADDR load_addr
=
1229 (CORE_ADDR
) (uintptr_t) current_event
.u
.UnloadDll
.lpBaseOfDll
;
1231 /* The symbols in a dll are offset by 0x1000, which is the
1232 offset from 0 of the first byte in an image - because
1233 of the file header and the section alignment. */
1234 load_addr
+= 0x1000;
1235 unloaded_dll (NULL
, load_addr
);
1239 handle_exception (struct target_waitstatus
*ourstatus
)
1241 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1243 memcpy (&siginfo_er
, ¤t_event
.u
.Exception
.ExceptionRecord
,
1246 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1250 case EXCEPTION_ACCESS_VIOLATION
:
1251 OUTMSG2 (("EXCEPTION_ACCESS_VIOLATION"));
1252 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1254 case STATUS_STACK_OVERFLOW
:
1255 OUTMSG2 (("STATUS_STACK_OVERFLOW"));
1256 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1258 case STATUS_FLOAT_DENORMAL_OPERAND
:
1259 OUTMSG2 (("STATUS_FLOAT_DENORMAL_OPERAND"));
1260 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1262 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1263 OUTMSG2 (("EXCEPTION_ARRAY_BOUNDS_EXCEEDED"));
1264 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1266 case STATUS_FLOAT_INEXACT_RESULT
:
1267 OUTMSG2 (("STATUS_FLOAT_INEXACT_RESULT"));
1268 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1270 case STATUS_FLOAT_INVALID_OPERATION
:
1271 OUTMSG2 (("STATUS_FLOAT_INVALID_OPERATION"));
1272 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1274 case STATUS_FLOAT_OVERFLOW
:
1275 OUTMSG2 (("STATUS_FLOAT_OVERFLOW"));
1276 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1278 case STATUS_FLOAT_STACK_CHECK
:
1279 OUTMSG2 (("STATUS_FLOAT_STACK_CHECK"));
1280 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1282 case STATUS_FLOAT_UNDERFLOW
:
1283 OUTMSG2 (("STATUS_FLOAT_UNDERFLOW"));
1284 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1286 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1287 OUTMSG2 (("STATUS_FLOAT_DIVIDE_BY_ZERO"));
1288 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1290 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1291 OUTMSG2 (("STATUS_INTEGER_DIVIDE_BY_ZERO"));
1292 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1294 case STATUS_INTEGER_OVERFLOW
:
1295 OUTMSG2 (("STATUS_INTEGER_OVERFLOW"));
1296 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1298 case EXCEPTION_BREAKPOINT
:
1299 OUTMSG2 (("EXCEPTION_BREAKPOINT"));
1300 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1302 /* Remove the initial breakpoint. */
1303 check_breakpoints ((CORE_ADDR
) (long) current_event
1304 .u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1308 OUTMSG2 (("DBG_CONTROL_C"));
1309 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1311 case DBG_CONTROL_BREAK
:
1312 OUTMSG2 (("DBG_CONTROL_BREAK"));
1313 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1315 case EXCEPTION_SINGLE_STEP
:
1316 OUTMSG2 (("EXCEPTION_SINGLE_STEP"));
1317 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1319 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1320 OUTMSG2 (("EXCEPTION_ILLEGAL_INSTRUCTION"));
1321 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1323 case EXCEPTION_PRIV_INSTRUCTION
:
1324 OUTMSG2 (("EXCEPTION_PRIV_INSTRUCTION"));
1325 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1327 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1328 OUTMSG2 (("EXCEPTION_NONCONTINUABLE_EXCEPTION"));
1329 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1332 if (current_event
.u
.Exception
.dwFirstChance
)
1334 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1337 OUTMSG2 (("gdbserver: unknown target exception 0x%08x at 0x%s",
1338 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1339 phex_nz ((uintptr_t) current_event
.u
.Exception
.ExceptionRecord
.
1340 ExceptionAddress
, sizeof (uintptr_t))));
1341 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1345 last_sig
= ourstatus
->value
.sig
;
1350 suspend_one_thread (thread_info
*thread
)
1352 win32_thread_info
*th
= (win32_thread_info
*) thread_target_data (thread
);
1356 if (SuspendThread (th
->h
) == (DWORD
) -1)
1358 DWORD err
= GetLastError ();
1359 OUTMSG (("warning: SuspendThread failed in suspend_one_thread, "
1360 "(error %d): %s\n", (int) err
, strwinerror (err
)));
1368 fake_breakpoint_event (void)
1370 OUTMSG2(("fake_breakpoint_event\n"));
1372 faked_breakpoint
= 1;
1374 memset (¤t_event
, 0, sizeof (current_event
));
1375 current_event
.dwThreadId
= main_thread_id
;
1376 current_event
.dwDebugEventCode
= EXCEPTION_DEBUG_EVENT
;
1377 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1378 = EXCEPTION_BREAKPOINT
;
1380 for_each_thread (suspend_one_thread
);
1385 auto_delete_breakpoint (CORE_ADDR stop_pc
)
1391 /* Get the next event from the child. */
1394 get_child_debug_event (struct target_waitstatus
*ourstatus
)
1398 last_sig
= GDB_SIGNAL_0
;
1399 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1401 /* Check if GDB sent us an interrupt request. */
1402 check_remote_input_interrupt_request ();
1404 if (soft_interrupt_requested
)
1406 soft_interrupt_requested
= 0;
1407 fake_breakpoint_event ();
1416 /* WinCE doesn't set an initial breakpoint automatically. To
1417 stop the inferior, we flush all currently pending debug
1418 events -- the thread list and the dll list are always
1419 reported immediatelly without delay, then, we suspend all
1420 threads and pretend we saw a trap at the current PC of the
1423 Contrary to desktop Windows, Windows CE *does* report the dll
1424 names on LOAD_DLL_DEBUG_EVENTs resulting from a
1425 DebugActiveProcess call. This limits the way we can detect
1426 if all the dlls have already been reported. If we get a real
1427 debug event before leaving attaching, the worst that will
1428 happen is the user will see a spurious breakpoint. */
1430 current_event
.dwDebugEventCode
= 0;
1431 if (!WaitForDebugEvent (¤t_event
, 0))
1433 OUTMSG2(("no attach events left\n"));
1434 fake_breakpoint_event ();
1438 OUTMSG2(("got attach event\n"));
1443 /* Keep the wait time low enough for comfortable remote
1444 interruption, but high enough so gdbserver doesn't become a
1446 if (!WaitForDebugEvent (¤t_event
, 250))
1448 DWORD e
= GetLastError();
1450 if (e
== ERROR_PIPE_NOT_CONNECTED
)
1452 /* This will happen if the loader fails to succesfully
1453 load the application, e.g., if the main executable
1454 tries to pull in a non-existing export from a
1456 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1457 ourstatus
->value
.integer
= 1;
1467 switch (current_event
.dwDebugEventCode
)
1469 case CREATE_THREAD_DEBUG_EVENT
:
1470 OUTMSG2 (("gdbserver: kernel event CREATE_THREAD_DEBUG_EVENT "
1471 "for pid=%u tid=%x)\n",
1472 (unsigned) current_event
.dwProcessId
,
1473 (unsigned) current_event
.dwThreadId
));
1475 /* Record the existence of this thread. */
1476 child_add_thread (current_event
.dwProcessId
,
1477 current_event
.dwThreadId
,
1478 current_event
.u
.CreateThread
.hThread
,
1479 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1482 case EXIT_THREAD_DEBUG_EVENT
:
1483 OUTMSG2 (("gdbserver: kernel event EXIT_THREAD_DEBUG_EVENT "
1484 "for pid=%u tid=%x\n",
1485 (unsigned) current_event
.dwProcessId
,
1486 (unsigned) current_event
.dwThreadId
));
1487 child_delete_thread (current_event
.dwProcessId
,
1488 current_event
.dwThreadId
);
1490 current_thread
= get_first_thread ();
1493 case CREATE_PROCESS_DEBUG_EVENT
:
1494 OUTMSG2 (("gdbserver: kernel event CREATE_PROCESS_DEBUG_EVENT "
1495 "for pid=%u tid=%x\n",
1496 (unsigned) current_event
.dwProcessId
,
1497 (unsigned) current_event
.dwThreadId
));
1498 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1500 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1501 main_thread_id
= current_event
.dwThreadId
;
1503 /* Add the main thread. */
1504 child_add_thread (current_event
.dwProcessId
,
1506 current_event
.u
.CreateProcessInfo
.hThread
,
1507 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
);
1512 /* Windows CE doesn't set the initial breakpoint
1513 automatically like the desktop versions of Windows do.
1514 We add it explicitly here. It will be removed as soon as
1516 set_breakpoint_at ((CORE_ADDR
) (long) current_event
.u
1517 .CreateProcessInfo
.lpStartAddress
,
1518 auto_delete_breakpoint
);
1523 case EXIT_PROCESS_DEBUG_EVENT
:
1524 OUTMSG2 (("gdbserver: kernel event EXIT_PROCESS_DEBUG_EVENT "
1525 "for pid=%u tid=%x\n",
1526 (unsigned) current_event
.dwProcessId
,
1527 (unsigned) current_event
.dwThreadId
));
1529 DWORD exit_status
= current_event
.u
.ExitProcess
.dwExitCode
;
1530 /* If the exit status looks like a fatal exception, but we
1531 don't recognize the exception's code, make the original
1532 exit status value available, to avoid losing information. */
1534 = WIFSIGNALED (exit_status
) ? WTERMSIG (exit_status
) : -1;
1535 if (exit_signal
== -1)
1537 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1538 ourstatus
->value
.integer
= exit_status
;
1542 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1543 ourstatus
->value
.sig
= gdb_signal_from_host (exit_signal
);
1546 child_continue (DBG_CONTINUE
, -1);
1547 CloseHandle (current_process_handle
);
1548 current_process_handle
= NULL
;
1551 case LOAD_DLL_DEBUG_EVENT
:
1552 OUTMSG2 (("gdbserver: kernel event LOAD_DLL_DEBUG_EVENT "
1553 "for pid=%u tid=%x\n",
1554 (unsigned) current_event
.dwProcessId
,
1555 (unsigned) current_event
.dwThreadId
));
1556 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1557 if (! child_initialization_done
)
1561 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1562 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1565 case UNLOAD_DLL_DEBUG_EVENT
:
1566 OUTMSG2 (("gdbserver: kernel event UNLOAD_DLL_DEBUG_EVENT "
1567 "for pid=%u tid=%x\n",
1568 (unsigned) current_event
.dwProcessId
,
1569 (unsigned) current_event
.dwThreadId
));
1570 if (! child_initialization_done
)
1572 handle_unload_dll ();
1573 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1574 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1577 case EXCEPTION_DEBUG_EVENT
:
1578 OUTMSG2 (("gdbserver: kernel event EXCEPTION_DEBUG_EVENT "
1579 "for pid=%u tid=%x\n",
1580 (unsigned) current_event
.dwProcessId
,
1581 (unsigned) current_event
.dwThreadId
));
1582 handle_exception (ourstatus
);
1585 case OUTPUT_DEBUG_STRING_EVENT
:
1586 /* A message from the kernel (or Cygwin). */
1587 OUTMSG2 (("gdbserver: kernel event OUTPUT_DEBUG_STRING_EVENT "
1588 "for pid=%u tid=%x\n",
1589 (unsigned) current_event
.dwProcessId
,
1590 (unsigned) current_event
.dwThreadId
));
1591 handle_output_debug_string ();
1595 OUTMSG2 (("gdbserver: kernel event unknown "
1596 "for pid=%u tid=%x code=%x\n",
1597 (unsigned) current_event
.dwProcessId
,
1598 (unsigned) current_event
.dwThreadId
,
1599 (unsigned) current_event
.dwDebugEventCode
));
1603 ptid
= debug_event_ptid (¤t_event
);
1604 current_thread
= find_thread_ptid (ptid
);
1608 /* Wait for the inferior process to change state.
1609 STATUS will be filled in with a response code to send to GDB.
1610 Returns the signal which caused the process to stop. */
1612 win32_process_target::wait (ptid_t ptid
, target_waitstatus
*ourstatus
,
1615 struct regcache
*regcache
;
1617 if (cached_status
.kind
!= TARGET_WAITKIND_IGNORE
)
1619 /* The core always does a wait after creating the inferior, and
1620 do_initial_child_stuff already ran the inferior to the
1621 initial breakpoint (or an exit, if creating the process
1622 fails). Report it now. */
1623 *ourstatus
= cached_status
;
1624 cached_status
.kind
= TARGET_WAITKIND_IGNORE
;
1625 return debug_event_ptid (¤t_event
);
1630 if (!get_child_debug_event (ourstatus
))
1633 switch (ourstatus
->kind
)
1635 case TARGET_WAITKIND_EXITED
:
1636 OUTMSG2 (("Child exited with retcode = %x\n",
1637 ourstatus
->value
.integer
));
1638 win32_clear_inferiors ();
1639 return ptid_t (current_event
.dwProcessId
);
1640 case TARGET_WAITKIND_STOPPED
:
1641 case TARGET_WAITKIND_SIGNALLED
:
1642 case TARGET_WAITKIND_LOADED
:
1643 OUTMSG2 (("Child Stopped with signal = %d \n",
1644 ourstatus
->value
.sig
));
1646 regcache
= get_thread_regcache (current_thread
, 1);
1647 child_fetch_inferior_registers (regcache
, -1);
1648 return debug_event_ptid (¤t_event
);
1650 OUTMSG (("Ignoring unknown internal event, %d\n", ourstatus
->kind
));
1652 case TARGET_WAITKIND_SPURIOUS
:
1653 /* do nothing, just continue */
1654 child_continue (DBG_CONTINUE
, -1);
1660 /* Fetch registers from the inferior process.
1661 If REGNO is -1, fetch all registers; otherwise, fetch at least REGNO. */
1663 win32_process_target::fetch_registers (regcache
*regcache
, int regno
)
1665 child_fetch_inferior_registers (regcache
, regno
);
1668 /* Store registers to the inferior process.
1669 If REGNO is -1, store all registers; otherwise, store at least REGNO. */
1671 win32_process_target::store_registers (regcache
*regcache
, int regno
)
1673 child_store_inferior_registers (regcache
, regno
);
1676 /* Read memory from the inferior process. This should generally be
1677 called through read_inferior_memory, which handles breakpoint shadowing.
1678 Read LEN bytes at MEMADDR into a buffer at MYADDR. */
1680 win32_process_target::read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
,
1683 return child_xfer_memory (memaddr
, (char *) myaddr
, len
, 0, 0) != len
;
1686 /* Write memory to the inferior process. This should generally be
1687 called through write_inferior_memory, which handles breakpoint shadowing.
1688 Write LEN bytes from the buffer at MYADDR to MEMADDR.
1689 Returns 0 on success and errno on failure. */
1691 win32_process_target::write_memory (CORE_ADDR memaddr
,
1692 const unsigned char *myaddr
, int len
)
1694 return child_xfer_memory (memaddr
, (char *) myaddr
, len
, 1, 0) != len
;
1697 /* Send an interrupt request to the inferior process. */
1699 win32_process_target::request_interrupt ()
1701 winapi_DebugBreakProcess DebugBreakProcess
;
1702 winapi_GenerateConsoleCtrlEvent GenerateConsoleCtrlEvent
;
1705 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
1707 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
1710 GenerateConsoleCtrlEvent
= GETPROCADDRESS (dll
, GenerateConsoleCtrlEvent
);
1712 if (GenerateConsoleCtrlEvent
!= NULL
1713 && GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, current_process_id
))
1716 /* GenerateConsoleCtrlEvent can fail if process id being debugged is
1717 not a process group id.
1718 Fallback to XP/Vista 'DebugBreakProcess', which generates a
1719 breakpoint exception in the interior process. */
1721 DebugBreakProcess
= GETPROCADDRESS (dll
, DebugBreakProcess
);
1723 if (DebugBreakProcess
!= NULL
1724 && DebugBreakProcess (current_process_handle
))
1727 /* Last resort, suspend all threads manually. */
1728 soft_interrupt_requested
= 1;
1732 win32_process_target::supports_hardware_single_step ()
1739 win32_error_to_fileio_error (DWORD err
)
1743 case ERROR_BAD_PATHNAME
:
1744 case ERROR_FILE_NOT_FOUND
:
1745 case ERROR_INVALID_NAME
:
1746 case ERROR_PATH_NOT_FOUND
:
1747 return FILEIO_ENOENT
;
1749 case ERROR_IO_DEVICE
:
1750 case ERROR_OPEN_FAILED
:
1752 case ERROR_INVALID_HANDLE
:
1753 return FILEIO_EBADF
;
1754 case ERROR_ACCESS_DENIED
:
1755 case ERROR_SHARING_VIOLATION
:
1756 return FILEIO_EACCES
;
1757 case ERROR_NOACCESS
:
1758 return FILEIO_EFAULT
;
1760 return FILEIO_EBUSY
;
1761 case ERROR_ALREADY_EXISTS
:
1762 case ERROR_FILE_EXISTS
:
1763 return FILEIO_EEXIST
;
1764 case ERROR_BAD_DEVICE
:
1765 return FILEIO_ENODEV
;
1766 case ERROR_DIRECTORY
:
1767 return FILEIO_ENOTDIR
;
1768 case ERROR_FILENAME_EXCED_RANGE
:
1769 case ERROR_INVALID_DATA
:
1770 case ERROR_INVALID_PARAMETER
:
1771 case ERROR_NEGATIVE_SEEK
:
1772 return FILEIO_EINVAL
;
1773 case ERROR_TOO_MANY_OPEN_FILES
:
1774 return FILEIO_EMFILE
;
1775 case ERROR_HANDLE_DISK_FULL
:
1776 case ERROR_DISK_FULL
:
1777 return FILEIO_ENOSPC
;
1778 case ERROR_WRITE_PROTECT
:
1779 return FILEIO_EROFS
;
1780 case ERROR_NOT_SUPPORTED
:
1781 return FILEIO_ENOSYS
;
1784 return FILEIO_EUNKNOWN
;
1788 win32_process_target::hostio_last_error (char *buf
)
1790 DWORD winerr
= GetLastError ();
1791 int fileio_err
= win32_error_to_fileio_error (winerr
);
1792 sprintf (buf
, "F-1,%x", fileio_err
);
1797 win32_process_target::supports_qxfer_siginfo ()
1802 /* Write Windows signal info. */
1805 win32_process_target::qxfer_siginfo (const char *annex
,
1806 unsigned char *readbuf
,
1807 unsigned const char *writebuf
,
1808 CORE_ADDR offset
, int len
)
1810 if (siginfo_er
.ExceptionCode
== 0)
1813 if (readbuf
== nullptr)
1816 if (offset
> sizeof (siginfo_er
))
1819 if (offset
+ len
> sizeof (siginfo_er
))
1820 len
= sizeof (siginfo_er
) - offset
;
1822 memcpy (readbuf
, (char *) &siginfo_er
+ offset
, len
);
1827 /* Write Windows OS Thread Information Block address. */
1830 win32_get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
1832 win32_thread_info
*th
;
1833 th
= thread_rec (ptid
, 0);
1837 *addr
= th
->thread_local_base
;
1841 /* Implementation of the target_ops method "sw_breakpoint_from_kind". */
1843 static const gdb_byte
*
1844 win32_sw_breakpoint_from_kind (int kind
, int *size
)
1846 *size
= the_low_target
.breakpoint_len
;
1847 return the_low_target
.breakpoint
;
1850 /* The win32 target ops object. */
1852 static win32_process_target the_win32_target
;
1854 static process_stratum_target win32_target_ops
= {
1855 NULL
, /* handle_monitor_command */
1856 NULL
, /* core_of_thread */
1857 NULL
, /* read_loadmap */
1858 NULL
, /* process_qsupported */
1859 NULL
, /* supports_tracepoints */
1861 NULL
, /* write_pc */
1862 NULL
, /* thread_stopped */
1863 win32_get_tib_address
,
1864 NULL
, /* pause_all */
1865 NULL
, /* unpause_all */
1866 NULL
, /* stabilize_threads */
1867 NULL
, /* install_fast_tracepoint_jump_pad */
1868 NULL
, /* emit_ops */
1869 NULL
, /* supports_disable_randomization */
1870 NULL
, /* get_min_fast_tracepoint_insn_len */
1871 NULL
, /* qxfer_libraries_svr4 */
1872 NULL
, /* support_agent */
1873 NULL
, /* enable_btrace */
1874 NULL
, /* disable_btrace */
1875 NULL
, /* read_btrace */
1876 NULL
, /* read_btrace_conf */
1877 NULL
, /* supports_range_stepping */
1878 NULL
, /* pid_to_exec_file */
1879 NULL
, /* multifs_open */
1880 NULL
, /* multifs_unlink */
1881 NULL
, /* multifs_readlink */
1882 NULL
, /* breakpoint_kind_from_pc */
1883 win32_sw_breakpoint_from_kind
,
1884 NULL
, /* thread_name */
1885 NULL
, /* breakpoint_kind_from_current_state */
1886 NULL
, /* supports_software_single_step */
1887 NULL
, /* supports_catch_syscall */
1888 NULL
, /* get_ipa_tdesc_idx */
1889 NULL
, /* thread_handle */
1893 /* Initialize the Win32 backend. */
1895 initialize_low (void)
1897 set_target_ops (&win32_target_ops
);
1898 the_low_target
.arch_setup ();