1 /* Low level interface to Windows debugging, for gdbserver.
2 Copyright (C) 2006-2017 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 "gdb_tilde_expand.h"
36 #include "common-inferior.h"
39 #include <sys/cygwin.h>
42 #define OUTMSG(X) do { printf X; fflush (stderr); } while (0)
55 #define _T(x) TEXT (x)
59 #define COUNTOF(STR) (sizeof (STR) / sizeof ((STR)[0]))
63 # define GETPROCADDRESS(DLL, PROC) \
64 ((winapi_ ## PROC) GetProcAddress (DLL, TEXT (#PROC)))
66 # define GETPROCADDRESS(DLL, PROC) \
67 ((winapi_ ## PROC) GetProcAddress (DLL, #PROC))
70 int using_threads
= 1;
73 static int attaching
= 0;
74 static HANDLE current_process_handle
= NULL
;
75 static DWORD current_process_id
= 0;
76 static DWORD main_thread_id
= 0;
77 static enum gdb_signal last_sig
= GDB_SIGNAL_0
;
79 /* The current debug event from WaitForDebugEvent. */
80 static DEBUG_EVENT current_event
;
82 /* A status that hasn't been reported to the core yet, and so
83 win32_wait should return it next, instead of fetching the next
84 debug event off the win32 API. */
85 static struct target_waitstatus cached_status
;
87 /* Non zero if an interrupt request is to be satisfied by suspending
89 static int soft_interrupt_requested
= 0;
91 /* Non zero if the inferior is stopped in a simulated breakpoint done
92 by suspending all the threads. */
93 static int faked_breakpoint
= 0;
95 const struct target_desc
*win32_tdesc
;
97 #define NUM_REGS (the_low_target.num_regs)
99 typedef BOOL (WINAPI
*winapi_DebugActiveProcessStop
) (DWORD dwProcessId
);
100 typedef BOOL (WINAPI
*winapi_DebugSetProcessKillOnExit
) (BOOL KillOnExit
);
101 typedef BOOL (WINAPI
*winapi_DebugBreakProcess
) (HANDLE
);
102 typedef BOOL (WINAPI
*winapi_GenerateConsoleCtrlEvent
) (DWORD
, DWORD
);
104 static ptid_t
win32_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
106 static void win32_resume (struct thread_resume
*resume_info
, size_t n
);
108 static void win32_add_all_dlls (void);
111 /* Get the thread ID from the current selected inferior (the current
114 current_thread_ptid (void)
119 /* The current debug event from WaitForDebugEvent. */
121 debug_event_ptid (DEBUG_EVENT
*event
)
123 return ptid_build (event
->dwProcessId
, event
->dwThreadId
, 0);
126 /* Get the thread context of the thread associated with TH. */
129 win32_get_thread_context (win32_thread_info
*th
)
131 memset (&th
->context
, 0, sizeof (CONTEXT
));
132 (*the_low_target
.get_thread_context
) (th
);
134 memcpy (&th
->base_context
, &th
->context
, sizeof (CONTEXT
));
138 /* Set the thread context of the thread associated with TH. */
141 win32_set_thread_context (win32_thread_info
*th
)
144 /* Calling SuspendThread on a thread that is running kernel code
145 will report that the suspending was successful, but in fact, that
146 will often not be true. In those cases, the context returned by
147 GetThreadContext will not be correct by the time the thread
148 stops, hence we can't set that context back into the thread when
149 resuming - it will most likelly crash the inferior.
150 Unfortunately, there is no way to know when the thread will
151 really stop. To work around it, we'll only write the context
152 back to the thread when either the user or GDB explicitly change
153 it between stopping and resuming. */
154 if (memcmp (&th
->context
, &th
->base_context
, sizeof (CONTEXT
)) != 0)
156 SetThreadContext (th
->h
, &th
->context
);
159 /* Set the thread context of the thread associated with TH. */
162 win32_prepare_to_resume (win32_thread_info
*th
)
164 if (the_low_target
.prepare_to_resume
!= NULL
)
165 (*the_low_target
.prepare_to_resume
) (th
);
168 /* See win32-low.h. */
171 win32_require_context (win32_thread_info
*th
)
173 if (th
->context
.ContextFlags
== 0)
177 if (SuspendThread (th
->h
) == (DWORD
) -1)
179 DWORD err
= GetLastError ();
180 OUTMSG (("warning: SuspendThread failed in thread_rec, "
181 "(error %d): %s\n", (int) err
, strwinerror (err
)));
187 win32_get_thread_context (th
);
191 /* Find a thread record given a thread id. If GET_CONTEXT is set then
192 also retrieve the context for this thread. */
193 static win32_thread_info
*
194 thread_rec (ptid_t ptid
, int get_context
)
196 struct thread_info
*thread
;
197 win32_thread_info
*th
;
199 thread
= (struct thread_info
*) find_inferior_id (&all_threads
, ptid
);
203 th
= (win32_thread_info
*) thread_target_data (thread
);
205 win32_require_context (th
);
209 /* Add a thread to the thread list. */
210 static win32_thread_info
*
211 child_add_thread (DWORD pid
, DWORD tid
, HANDLE h
, void *tlb
)
213 win32_thread_info
*th
;
214 ptid_t ptid
= ptid_build (pid
, tid
, 0);
216 if ((th
= thread_rec (ptid
, FALSE
)))
219 th
= XCNEW (win32_thread_info
);
222 th
->thread_local_base
= (CORE_ADDR
) (uintptr_t) tlb
;
224 add_thread (ptid
, th
);
226 if (the_low_target
.thread_added
!= NULL
)
227 (*the_low_target
.thread_added
) (th
);
232 /* Delete a thread from the list of threads. */
234 delete_thread_info (thread_info
*thread
)
236 win32_thread_info
*th
= (win32_thread_info
*) thread_target_data (thread
);
238 remove_thread (thread
);
243 /* Delete a thread from the list of threads. */
245 child_delete_thread (DWORD pid
, DWORD tid
)
249 /* If the last thread is exiting, just return. */
250 if (all_threads
.size () == 1)
253 ptid
= ptid_build (pid
, tid
, 0);
254 thread_info
*thread
= find_inferior_id (&all_threads
, ptid
);
258 delete_thread_info (thread
);
261 /* These watchpoint related wrapper functions simply pass on the function call
262 if the low target has registered a corresponding function. */
265 win32_supports_z_point_type (char z_type
)
267 return (the_low_target
.supports_z_point_type
!= NULL
268 && the_low_target
.supports_z_point_type (z_type
));
272 win32_insert_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
273 int size
, struct raw_breakpoint
*bp
)
275 if (the_low_target
.insert_point
!= NULL
)
276 return the_low_target
.insert_point (type
, addr
, size
, bp
);
278 /* Unsupported (see target.h). */
283 win32_remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
284 int size
, struct raw_breakpoint
*bp
)
286 if (the_low_target
.remove_point
!= NULL
)
287 return the_low_target
.remove_point (type
, addr
, size
, bp
);
289 /* Unsupported (see target.h). */
294 win32_stopped_by_watchpoint (void)
296 if (the_low_target
.stopped_by_watchpoint
!= NULL
)
297 return the_low_target
.stopped_by_watchpoint ();
303 win32_stopped_data_address (void)
305 if (the_low_target
.stopped_data_address
!= NULL
)
306 return the_low_target
.stopped_data_address ();
312 /* Transfer memory from/to the debugged process. */
314 child_xfer_memory (CORE_ADDR memaddr
, char *our
, int len
,
315 int write
, struct target_ops
*target
)
320 uintptr_t addr
= (uintptr_t) memaddr
;
324 success
= WriteProcessMemory (current_process_handle
, (LPVOID
) addr
,
325 (LPCVOID
) our
, len
, &done
);
327 lasterror
= GetLastError ();
328 FlushInstructionCache (current_process_handle
, (LPCVOID
) addr
, len
);
332 success
= ReadProcessMemory (current_process_handle
, (LPCVOID
) addr
,
333 (LPVOID
) our
, len
, &done
);
335 lasterror
= GetLastError ();
337 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
340 return success
? done
: -1;
343 /* Clear out any old thread list and reinitialize it to a pristine
346 child_init_thread_list (void)
348 for_each_inferior (&all_threads
, delete_thread_info
);
351 /* Zero during the child initialization phase, and nonzero otherwise. */
353 static int child_initialization_done
= 0;
356 do_initial_child_stuff (HANDLE proch
, DWORD pid
, int attached
)
358 struct process_info
*proc
;
360 last_sig
= GDB_SIGNAL_0
;
362 current_process_handle
= proch
;
363 current_process_id
= pid
;
366 soft_interrupt_requested
= 0;
367 faked_breakpoint
= 0;
369 memset (¤t_event
, 0, sizeof (current_event
));
371 proc
= add_process (pid
, attached
);
372 proc
->tdesc
= win32_tdesc
;
373 child_init_thread_list ();
374 child_initialization_done
= 0;
376 if (the_low_target
.initial_stuff
!= NULL
)
377 (*the_low_target
.initial_stuff
) ();
379 cached_status
.kind
= TARGET_WAITKIND_IGNORE
;
381 /* Flush all currently pending debug events (thread and dll list) up
382 to the initial breakpoint. */
385 struct target_waitstatus status
;
387 win32_wait (minus_one_ptid
, &status
, 0);
389 /* Note win32_wait doesn't return thread events. */
390 if (status
.kind
!= TARGET_WAITKIND_LOADED
)
392 cached_status
= status
;
397 struct thread_resume resume
;
399 resume
.thread
= minus_one_ptid
;
400 resume
.kind
= resume_continue
;
403 win32_resume (&resume
, 1);
408 /* Now that the inferior has been started and all DLLs have been mapped,
409 we can iterate over all DLLs and load them in.
411 We avoid doing it any earlier because, on certain versions of Windows,
412 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
413 we have seen on Windows 8.1 that the ntdll.dll load event does not
414 include the DLL name, preventing us from creating an associated SO.
415 A possible explanation is that ntdll.dll might be mapped before
416 the SO info gets created by the Windows system -- ntdll.dll is
417 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
418 do not seem to suffer from that problem.
420 Rather than try to work around this sort of issue, it is much
421 simpler to just ignore DLL load/unload events during the startup
422 phase, and then process them all in one batch now. */
423 win32_add_all_dlls ();
426 child_initialization_done
= 1;
429 /* Resume all artificially suspended threads if we are continuing
432 continue_one_thread (thread_info
*thread
, void *id_ptr
)
434 int thread_id
= * (int *) id_ptr
;
435 win32_thread_info
*th
= (win32_thread_info
*) thread_target_data (thread
);
437 if (thread_id
== -1 || thread_id
== th
->tid
)
439 win32_prepare_to_resume (th
);
443 if (th
->context
.ContextFlags
)
445 win32_set_thread_context (th
);
446 th
->context
.ContextFlags
= 0;
449 if (ResumeThread (th
->h
) == (DWORD
) -1)
451 DWORD err
= GetLastError ();
452 OUTMSG (("warning: ResumeThread failed in continue_one_thread, "
453 "(error %d): %s\n", (int) err
, strwinerror (err
)));
463 child_continue (DWORD continue_status
, int thread_id
)
465 /* The inferior will only continue after the ContinueDebugEvent
467 find_inferior (&all_threads
, continue_one_thread
, &thread_id
);
468 faked_breakpoint
= 0;
470 if (!ContinueDebugEvent (current_event
.dwProcessId
,
471 current_event
.dwThreadId
,
478 /* Fetch register(s) from the current thread context. */
480 child_fetch_inferior_registers (struct regcache
*regcache
, int r
)
483 win32_thread_info
*th
= thread_rec (current_thread_ptid (), TRUE
);
484 if (r
== -1 || r
> NUM_REGS
)
485 child_fetch_inferior_registers (regcache
, NUM_REGS
);
487 for (regno
= 0; regno
< r
; regno
++)
488 (*the_low_target
.fetch_inferior_register
) (regcache
, th
, regno
);
491 /* Store a new register value into the current thread context. We don't
492 change the program's context until later, when we resume it. */
494 child_store_inferior_registers (struct regcache
*regcache
, int r
)
497 win32_thread_info
*th
= thread_rec (current_thread_ptid (), TRUE
);
498 if (r
== -1 || r
== 0 || r
> NUM_REGS
)
499 child_store_inferior_registers (regcache
, NUM_REGS
);
501 for (regno
= 0; regno
< r
; regno
++)
502 (*the_low_target
.store_inferior_register
) (regcache
, th
, regno
);
505 /* Map the Windows error number in ERROR to a locale-dependent error
506 message string and return a pointer to it. Typically, the values
507 for ERROR come from GetLastError.
509 The string pointed to shall not be modified by the application,
510 but may be overwritten by a subsequent call to strwinerror
512 The strwinerror function does not change the current setting
516 strwinerror (DWORD error
)
518 static char buf
[1024];
520 DWORD lasterr
= GetLastError ();
521 DWORD chars
= FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
522 | FORMAT_MESSAGE_ALLOCATE_BUFFER
,
525 0, /* Default language */
531 /* If there is an \r\n appended, zap it. */
533 && msgbuf
[chars
- 2] == '\r'
534 && msgbuf
[chars
- 1] == '\n')
540 if (chars
> ((COUNTOF (buf
)) - 1))
542 chars
= COUNTOF (buf
) - 1;
547 wcstombs (buf
, msgbuf
, chars
+ 1);
549 strncpy (buf
, msgbuf
, chars
+ 1);
554 sprintf (buf
, "unknown win32 error (%u)", (unsigned) error
);
556 SetLastError (lasterr
);
561 create_process (const char *program
, char *args
,
562 DWORD flags
, PROCESS_INFORMATION
*pi
)
564 const char *inferior_cwd
= get_inferior_cwd ();
565 std::string expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
569 wchar_t *p
, *wprogram
, *wargs
, *wcwd
= NULL
;
572 wprogram
= alloca ((strlen (program
) + 1) * sizeof (wchar_t));
573 mbstowcs (wprogram
, program
, strlen (program
) + 1);
575 for (p
= wprogram
; *p
; ++p
)
579 argslen
= strlen (args
);
580 wargs
= alloca ((argslen
+ 1) * sizeof (wchar_t));
581 mbstowcs (wargs
, args
, argslen
+ 1);
583 if (inferior_cwd
!= NULL
)
585 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
587 wcwd
= alloca ((expanded_infcwd
.size () + 1) * sizeof (wchar_t));
588 if (mbstowcs (wcwd
, expanded_infcwd
.c_str (),
589 expanded_infcwd
.size () + 1) == NULL
)
592 Could not convert the expanded inferior cwd to wide-char."));
596 ret
= CreateProcessW (wprogram
, /* image name */
597 wargs
, /* command line */
598 NULL
, /* security, not supported */
599 NULL
, /* thread, not supported */
600 FALSE
, /* inherit handles, not supported */
601 flags
, /* start flags */
602 NULL
, /* environment, not supported */
603 wcwd
, /* current directory */
604 NULL
, /* start info, not supported */
607 STARTUPINFOA si
= { sizeof (STARTUPINFOA
) };
609 ret
= CreateProcessA (program
, /* image name */
610 args
, /* command line */
613 TRUE
, /* inherit handles */
614 flags
, /* start flags */
615 NULL
, /* environment */
616 expanded_infcwd
.c_str (), /* current directory */
617 &si
, /* start info */
624 /* Start a new process.
625 PROGRAM is the program name.
626 PROGRAM_ARGS is the vector containing the inferior's args.
627 Returns the new PID on success, -1 on failure. Registers the new
628 process with the process list. */
630 win32_create_inferior (const char *program
,
631 const std::vector
<char *> &program_args
)
634 char real_path
[PATH_MAX
];
635 char *orig_path
, *new_path
, *path_ptr
;
641 PROCESS_INFORMATION pi
;
643 std::string str_program_args
= stringify_argv (program_args
);
644 char *args
= (char *) str_program_args
.c_str ();
646 /* win32_wait needs to know we're not attaching. */
650 error ("No executable specified, specify executable to debug.\n");
652 flags
= DEBUG_PROCESS
| DEBUG_ONLY_THIS_PROCESS
;
656 path_ptr
= getenv ("PATH");
659 int size
= cygwin_conv_path_list (CCP_POSIX_TO_WIN_A
, path_ptr
, NULL
, 0);
660 orig_path
= (char *) alloca (strlen (path_ptr
) + 1);
661 new_path
= (char *) alloca (size
);
662 strcpy (orig_path
, path_ptr
);
663 cygwin_conv_path_list (CCP_POSIX_TO_WIN_A
, path_ptr
, new_path
, size
);
664 setenv ("PATH", new_path
, 1);
666 cygwin_conv_path (CCP_POSIX_TO_WIN_A
, program
, real_path
, PATH_MAX
);
670 OUTMSG2 (("Command line is \"%s\"\n", args
));
672 #ifdef CREATE_NEW_PROCESS_GROUP
673 flags
|= CREATE_NEW_PROCESS_GROUP
;
676 ret
= create_process (program
, args
, flags
, &pi
);
677 err
= GetLastError ();
678 if (!ret
&& err
== ERROR_FILE_NOT_FOUND
)
680 char *exename
= (char *) alloca (strlen (program
) + 5);
681 strcat (strcpy (exename
, program
), ".exe");
682 ret
= create_process (exename
, args
, flags
, &pi
);
683 err
= GetLastError ();
688 setenv ("PATH", orig_path
, 1);
693 error ("Error creating process \"%s%s\", (error %d): %s\n",
694 program
, args
, (int) err
, strwinerror (err
));
698 OUTMSG2 (("Process created: %s\n", (char *) args
));
702 /* On Windows CE this handle can't be closed. The OS reuses
703 it in the debug events, while the 9x/NT versions of Windows
704 probably use a DuplicateHandle'd one. */
705 CloseHandle (pi
.hThread
);
708 do_initial_child_stuff (pi
.hProcess
, pi
.dwProcessId
, 0);
710 return current_process_id
;
713 /* Attach to a running process.
714 PID is the process ID to attach to, specified by the user
715 or a higher layer. */
717 win32_attach (unsigned long pid
)
720 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
723 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
725 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
727 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
729 h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
732 if (DebugActiveProcess (pid
))
734 if (DebugSetProcessKillOnExit
!= NULL
)
735 DebugSetProcessKillOnExit (FALSE
);
737 /* win32_wait needs to know we're attaching. */
739 do_initial_child_stuff (h
, pid
, 1);
746 err
= GetLastError ();
747 error ("Attach to process failed (error %d): %s\n",
748 (int) err
, strwinerror (err
));
751 /* Handle OUTPUT_DEBUG_STRING_EVENT from child process. */
753 handle_output_debug_string (void)
755 #define READ_BUFFER_LEN 1024
757 char s
[READ_BUFFER_LEN
+ 1] = { 0 };
758 DWORD nbytes
= current_event
.u
.DebugString
.nDebugStringLength
;
763 if (nbytes
> READ_BUFFER_LEN
)
764 nbytes
= READ_BUFFER_LEN
;
766 addr
= (CORE_ADDR
) (size_t) current_event
.u
.DebugString
.lpDebugStringData
;
768 if (current_event
.u
.DebugString
.fUnicode
)
770 /* The event tells us how many bytes, not chars, even
772 WCHAR buffer
[(READ_BUFFER_LEN
+ 1) / sizeof (WCHAR
)] = { 0 };
773 if (read_inferior_memory (addr
, (unsigned char *) buffer
, nbytes
) != 0)
775 wcstombs (s
, buffer
, (nbytes
+ 1) / sizeof (WCHAR
));
779 if (read_inferior_memory (addr
, (unsigned char *) s
, nbytes
) != 0)
783 if (!startswith (s
, "cYg"))
793 #undef READ_BUFFER_LEN
797 win32_clear_inferiors (void)
799 if (current_process_handle
!= NULL
)
800 CloseHandle (current_process_handle
);
802 for_each_inferior (&all_threads
, delete_thread_info
);
806 /* Kill all inferiors. */
810 struct process_info
*process
;
812 if (current_process_handle
== NULL
)
815 TerminateProcess (current_process_handle
, 0);
818 if (!child_continue (DBG_CONTINUE
, -1))
820 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
822 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
824 else if (current_event
.dwDebugEventCode
== OUTPUT_DEBUG_STRING_EVENT
)
825 handle_output_debug_string ();
828 win32_clear_inferiors ();
830 process
= find_process_pid (pid
);
831 remove_process (process
);
835 /* Detach from inferior PID. */
837 win32_detach (int pid
)
839 struct process_info
*process
;
840 winapi_DebugActiveProcessStop DebugActiveProcessStop
= NULL
;
841 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
843 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
845 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
847 DebugActiveProcessStop
= GETPROCADDRESS (dll
, DebugActiveProcessStop
);
848 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
850 if (DebugSetProcessKillOnExit
== NULL
851 || DebugActiveProcessStop
== NULL
)
855 struct thread_resume resume
;
856 resume
.thread
= minus_one_ptid
;
857 resume
.kind
= resume_continue
;
859 win32_resume (&resume
, 1);
862 if (!DebugActiveProcessStop (current_process_id
))
865 DebugSetProcessKillOnExit (FALSE
);
866 process
= find_process_pid (pid
);
867 remove_process (process
);
869 win32_clear_inferiors ();
874 win32_mourn (struct process_info
*process
)
876 remove_process (process
);
879 /* Wait for inferiors to end. */
883 HANDLE h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
886 WaitForSingleObject (h
, INFINITE
);
891 /* Return 1 iff the thread with thread ID TID is alive. */
893 win32_thread_alive (ptid_t ptid
)
897 /* Our thread list is reliable; don't bother to poll target
899 if (find_inferior_id (&all_threads
, ptid
) != NULL
)
906 /* Resume the inferior process. RESUME_INFO describes how we want
909 win32_resume (struct 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 && ptid_equal (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 (!ptid_equal (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 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1247 case EXCEPTION_ACCESS_VIOLATION
:
1248 OUTMSG2 (("EXCEPTION_ACCESS_VIOLATION"));
1249 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1251 case STATUS_STACK_OVERFLOW
:
1252 OUTMSG2 (("STATUS_STACK_OVERFLOW"));
1253 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1255 case STATUS_FLOAT_DENORMAL_OPERAND
:
1256 OUTMSG2 (("STATUS_FLOAT_DENORMAL_OPERAND"));
1257 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1259 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1260 OUTMSG2 (("EXCEPTION_ARRAY_BOUNDS_EXCEEDED"));
1261 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1263 case STATUS_FLOAT_INEXACT_RESULT
:
1264 OUTMSG2 (("STATUS_FLOAT_INEXACT_RESULT"));
1265 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1267 case STATUS_FLOAT_INVALID_OPERATION
:
1268 OUTMSG2 (("STATUS_FLOAT_INVALID_OPERATION"));
1269 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1271 case STATUS_FLOAT_OVERFLOW
:
1272 OUTMSG2 (("STATUS_FLOAT_OVERFLOW"));
1273 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1275 case STATUS_FLOAT_STACK_CHECK
:
1276 OUTMSG2 (("STATUS_FLOAT_STACK_CHECK"));
1277 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1279 case STATUS_FLOAT_UNDERFLOW
:
1280 OUTMSG2 (("STATUS_FLOAT_UNDERFLOW"));
1281 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1283 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1284 OUTMSG2 (("STATUS_FLOAT_DIVIDE_BY_ZERO"));
1285 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1287 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1288 OUTMSG2 (("STATUS_INTEGER_DIVIDE_BY_ZERO"));
1289 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1291 case STATUS_INTEGER_OVERFLOW
:
1292 OUTMSG2 (("STATUS_INTEGER_OVERFLOW"));
1293 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1295 case EXCEPTION_BREAKPOINT
:
1296 OUTMSG2 (("EXCEPTION_BREAKPOINT"));
1297 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1299 /* Remove the initial breakpoint. */
1300 check_breakpoints ((CORE_ADDR
) (long) current_event
1301 .u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1305 OUTMSG2 (("DBG_CONTROL_C"));
1306 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1308 case DBG_CONTROL_BREAK
:
1309 OUTMSG2 (("DBG_CONTROL_BREAK"));
1310 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1312 case EXCEPTION_SINGLE_STEP
:
1313 OUTMSG2 (("EXCEPTION_SINGLE_STEP"));
1314 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1316 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1317 OUTMSG2 (("EXCEPTION_ILLEGAL_INSTRUCTION"));
1318 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1320 case EXCEPTION_PRIV_INSTRUCTION
:
1321 OUTMSG2 (("EXCEPTION_PRIV_INSTRUCTION"));
1322 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1324 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1325 OUTMSG2 (("EXCEPTION_NONCONTINUABLE_EXCEPTION"));
1326 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1329 if (current_event
.u
.Exception
.dwFirstChance
)
1331 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1334 OUTMSG2 (("gdbserver: unknown target exception 0x%08x at 0x%s",
1335 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1336 phex_nz ((uintptr_t) current_event
.u
.Exception
.ExceptionRecord
.
1337 ExceptionAddress
, sizeof (uintptr_t))));
1338 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1342 last_sig
= ourstatus
->value
.sig
;
1347 suspend_one_thread (thread_info
*thread
)
1349 win32_thread_info
*th
= (win32_thread_info
*) thread_target_data (thread
);
1353 if (SuspendThread (th
->h
) == (DWORD
) -1)
1355 DWORD err
= GetLastError ();
1356 OUTMSG (("warning: SuspendThread failed in suspend_one_thread, "
1357 "(error %d): %s\n", (int) err
, strwinerror (err
)));
1365 fake_breakpoint_event (void)
1367 OUTMSG2(("fake_breakpoint_event\n"));
1369 faked_breakpoint
= 1;
1371 memset (¤t_event
, 0, sizeof (current_event
));
1372 current_event
.dwThreadId
= main_thread_id
;
1373 current_event
.dwDebugEventCode
= EXCEPTION_DEBUG_EVENT
;
1374 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1375 = EXCEPTION_BREAKPOINT
;
1377 for_each_inferior (&all_threads
, suspend_one_thread
);
1382 auto_delete_breakpoint (CORE_ADDR stop_pc
)
1388 /* Get the next event from the child. */
1391 get_child_debug_event (struct target_waitstatus
*ourstatus
)
1395 last_sig
= GDB_SIGNAL_0
;
1396 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1398 /* Check if GDB sent us an interrupt request. */
1399 check_remote_input_interrupt_request ();
1401 if (soft_interrupt_requested
)
1403 soft_interrupt_requested
= 0;
1404 fake_breakpoint_event ();
1413 /* WinCE doesn't set an initial breakpoint automatically. To
1414 stop the inferior, we flush all currently pending debug
1415 events -- the thread list and the dll list are always
1416 reported immediatelly without delay, then, we suspend all
1417 threads and pretend we saw a trap at the current PC of the
1420 Contrary to desktop Windows, Windows CE *does* report the dll
1421 names on LOAD_DLL_DEBUG_EVENTs resulting from a
1422 DebugActiveProcess call. This limits the way we can detect
1423 if all the dlls have already been reported. If we get a real
1424 debug event before leaving attaching, the worst that will
1425 happen is the user will see a spurious breakpoint. */
1427 current_event
.dwDebugEventCode
= 0;
1428 if (!WaitForDebugEvent (¤t_event
, 0))
1430 OUTMSG2(("no attach events left\n"));
1431 fake_breakpoint_event ();
1435 OUTMSG2(("got attach event\n"));
1440 /* Keep the wait time low enough for confortable remote
1441 interruption, but high enough so gdbserver doesn't become a
1443 if (!WaitForDebugEvent (¤t_event
, 250))
1445 DWORD e
= GetLastError();
1447 if (e
== ERROR_PIPE_NOT_CONNECTED
)
1449 /* This will happen if the loader fails to succesfully
1450 load the application, e.g., if the main executable
1451 tries to pull in a non-existing export from a
1453 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1454 ourstatus
->value
.integer
= 1;
1464 switch (current_event
.dwDebugEventCode
)
1466 case CREATE_THREAD_DEBUG_EVENT
:
1467 OUTMSG2 (("gdbserver: kernel event CREATE_THREAD_DEBUG_EVENT "
1468 "for pid=%u tid=%x)\n",
1469 (unsigned) current_event
.dwProcessId
,
1470 (unsigned) current_event
.dwThreadId
));
1472 /* Record the existence of this thread. */
1473 child_add_thread (current_event
.dwProcessId
,
1474 current_event
.dwThreadId
,
1475 current_event
.u
.CreateThread
.hThread
,
1476 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1479 case EXIT_THREAD_DEBUG_EVENT
:
1480 OUTMSG2 (("gdbserver: kernel event EXIT_THREAD_DEBUG_EVENT "
1481 "for pid=%u tid=%x\n",
1482 (unsigned) current_event
.dwProcessId
,
1483 (unsigned) current_event
.dwThreadId
));
1484 child_delete_thread (current_event
.dwProcessId
,
1485 current_event
.dwThreadId
);
1487 current_thread
= get_first_thread ();
1490 case CREATE_PROCESS_DEBUG_EVENT
:
1491 OUTMSG2 (("gdbserver: kernel event CREATE_PROCESS_DEBUG_EVENT "
1492 "for pid=%u tid=%x\n",
1493 (unsigned) current_event
.dwProcessId
,
1494 (unsigned) current_event
.dwThreadId
));
1495 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1497 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1498 main_thread_id
= current_event
.dwThreadId
;
1500 /* Add the main thread. */
1501 child_add_thread (current_event
.dwProcessId
,
1503 current_event
.u
.CreateProcessInfo
.hThread
,
1504 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
);
1509 /* Windows CE doesn't set the initial breakpoint
1510 automatically like the desktop versions of Windows do.
1511 We add it explicitly here. It will be removed as soon as
1513 set_breakpoint_at ((CORE_ADDR
) (long) current_event
.u
1514 .CreateProcessInfo
.lpStartAddress
,
1515 auto_delete_breakpoint
);
1520 case EXIT_PROCESS_DEBUG_EVENT
:
1521 OUTMSG2 (("gdbserver: kernel event EXIT_PROCESS_DEBUG_EVENT "
1522 "for pid=%u tid=%x\n",
1523 (unsigned) current_event
.dwProcessId
,
1524 (unsigned) current_event
.dwThreadId
));
1525 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1526 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1527 child_continue (DBG_CONTINUE
, -1);
1528 CloseHandle (current_process_handle
);
1529 current_process_handle
= NULL
;
1532 case LOAD_DLL_DEBUG_EVENT
:
1533 OUTMSG2 (("gdbserver: kernel event LOAD_DLL_DEBUG_EVENT "
1534 "for pid=%u tid=%x\n",
1535 (unsigned) current_event
.dwProcessId
,
1536 (unsigned) current_event
.dwThreadId
));
1537 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1538 if (! child_initialization_done
)
1542 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1543 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1546 case UNLOAD_DLL_DEBUG_EVENT
:
1547 OUTMSG2 (("gdbserver: kernel event UNLOAD_DLL_DEBUG_EVENT "
1548 "for pid=%u tid=%x\n",
1549 (unsigned) current_event
.dwProcessId
,
1550 (unsigned) current_event
.dwThreadId
));
1551 if (! child_initialization_done
)
1553 handle_unload_dll ();
1554 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1555 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1558 case EXCEPTION_DEBUG_EVENT
:
1559 OUTMSG2 (("gdbserver: kernel event EXCEPTION_DEBUG_EVENT "
1560 "for pid=%u tid=%x\n",
1561 (unsigned) current_event
.dwProcessId
,
1562 (unsigned) current_event
.dwThreadId
));
1563 handle_exception (ourstatus
);
1566 case OUTPUT_DEBUG_STRING_EVENT
:
1567 /* A message from the kernel (or Cygwin). */
1568 OUTMSG2 (("gdbserver: kernel event OUTPUT_DEBUG_STRING_EVENT "
1569 "for pid=%u tid=%x\n",
1570 (unsigned) current_event
.dwProcessId
,
1571 (unsigned) current_event
.dwThreadId
));
1572 handle_output_debug_string ();
1576 OUTMSG2 (("gdbserver: kernel event unknown "
1577 "for pid=%u tid=%x code=%x\n",
1578 (unsigned) current_event
.dwProcessId
,
1579 (unsigned) current_event
.dwThreadId
,
1580 (unsigned) current_event
.dwDebugEventCode
));
1584 ptid
= debug_event_ptid (¤t_event
);
1586 (struct thread_info
*) find_inferior_id (&all_threads
, ptid
);
1590 /* Wait for the inferior process to change state.
1591 STATUS will be filled in with a response code to send to GDB.
1592 Returns the signal which caused the process to stop. */
1594 win32_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
1596 struct regcache
*regcache
;
1598 if (cached_status
.kind
!= TARGET_WAITKIND_IGNORE
)
1600 /* The core always does a wait after creating the inferior, and
1601 do_initial_child_stuff already ran the inferior to the
1602 initial breakpoint (or an exit, if creating the process
1603 fails). Report it now. */
1604 *ourstatus
= cached_status
;
1605 cached_status
.kind
= TARGET_WAITKIND_IGNORE
;
1606 return debug_event_ptid (¤t_event
);
1611 if (!get_child_debug_event (ourstatus
))
1614 switch (ourstatus
->kind
)
1616 case TARGET_WAITKIND_EXITED
:
1617 OUTMSG2 (("Child exited with retcode = %x\n",
1618 ourstatus
->value
.integer
));
1619 win32_clear_inferiors ();
1620 return pid_to_ptid (current_event
.dwProcessId
);
1621 case TARGET_WAITKIND_STOPPED
:
1622 case TARGET_WAITKIND_LOADED
:
1623 OUTMSG2 (("Child Stopped with signal = %d \n",
1624 ourstatus
->value
.sig
));
1626 regcache
= get_thread_regcache (current_thread
, 1);
1627 child_fetch_inferior_registers (regcache
, -1);
1628 return debug_event_ptid (¤t_event
);
1630 OUTMSG (("Ignoring unknown internal event, %d\n", ourstatus
->kind
));
1632 case TARGET_WAITKIND_SPURIOUS
:
1633 /* do nothing, just continue */
1634 child_continue (DBG_CONTINUE
, -1);
1640 /* Fetch registers from the inferior process.
1641 If REGNO is -1, fetch all registers; otherwise, fetch at least REGNO. */
1643 win32_fetch_inferior_registers (struct regcache
*regcache
, int regno
)
1645 child_fetch_inferior_registers (regcache
, regno
);
1648 /* Store registers to the inferior process.
1649 If REGNO is -1, store all registers; otherwise, store at least REGNO. */
1651 win32_store_inferior_registers (struct regcache
*regcache
, int regno
)
1653 child_store_inferior_registers (regcache
, regno
);
1656 /* Read memory from the inferior process. This should generally be
1657 called through read_inferior_memory, which handles breakpoint shadowing.
1658 Read LEN bytes at MEMADDR into a buffer at MYADDR. */
1660 win32_read_inferior_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
1662 return child_xfer_memory (memaddr
, (char *) myaddr
, len
, 0, 0) != len
;
1665 /* Write memory to the inferior process. This should generally be
1666 called through write_inferior_memory, which handles breakpoint shadowing.
1667 Write LEN bytes from the buffer at MYADDR to MEMADDR.
1668 Returns 0 on success and errno on failure. */
1670 win32_write_inferior_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
,
1673 return child_xfer_memory (memaddr
, (char *) myaddr
, len
, 1, 0) != len
;
1676 /* Send an interrupt request to the inferior process. */
1678 win32_request_interrupt (void)
1680 winapi_DebugBreakProcess DebugBreakProcess
;
1681 winapi_GenerateConsoleCtrlEvent GenerateConsoleCtrlEvent
;
1684 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
1686 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
1689 GenerateConsoleCtrlEvent
= GETPROCADDRESS (dll
, GenerateConsoleCtrlEvent
);
1691 if (GenerateConsoleCtrlEvent
!= NULL
1692 && GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, current_process_id
))
1695 /* GenerateConsoleCtrlEvent can fail if process id being debugged is
1696 not a process group id.
1697 Fallback to XP/Vista 'DebugBreakProcess', which generates a
1698 breakpoint exception in the interior process. */
1700 DebugBreakProcess
= GETPROCADDRESS (dll
, DebugBreakProcess
);
1702 if (DebugBreakProcess
!= NULL
1703 && DebugBreakProcess (current_process_handle
))
1706 /* Last resort, suspend all threads manually. */
1707 soft_interrupt_requested
= 1;
1712 win32_error_to_fileio_error (DWORD err
)
1716 case ERROR_BAD_PATHNAME
:
1717 case ERROR_FILE_NOT_FOUND
:
1718 case ERROR_INVALID_NAME
:
1719 case ERROR_PATH_NOT_FOUND
:
1720 return FILEIO_ENOENT
;
1722 case ERROR_IO_DEVICE
:
1723 case ERROR_OPEN_FAILED
:
1725 case ERROR_INVALID_HANDLE
:
1726 return FILEIO_EBADF
;
1727 case ERROR_ACCESS_DENIED
:
1728 case ERROR_SHARING_VIOLATION
:
1729 return FILEIO_EACCES
;
1730 case ERROR_NOACCESS
:
1731 return FILEIO_EFAULT
;
1733 return FILEIO_EBUSY
;
1734 case ERROR_ALREADY_EXISTS
:
1735 case ERROR_FILE_EXISTS
:
1736 return FILEIO_EEXIST
;
1737 case ERROR_BAD_DEVICE
:
1738 return FILEIO_ENODEV
;
1739 case ERROR_DIRECTORY
:
1740 return FILEIO_ENOTDIR
;
1741 case ERROR_FILENAME_EXCED_RANGE
:
1742 case ERROR_INVALID_DATA
:
1743 case ERROR_INVALID_PARAMETER
:
1744 case ERROR_NEGATIVE_SEEK
:
1745 return FILEIO_EINVAL
;
1746 case ERROR_TOO_MANY_OPEN_FILES
:
1747 return FILEIO_EMFILE
;
1748 case ERROR_HANDLE_DISK_FULL
:
1749 case ERROR_DISK_FULL
:
1750 return FILEIO_ENOSPC
;
1751 case ERROR_WRITE_PROTECT
:
1752 return FILEIO_EROFS
;
1753 case ERROR_NOT_SUPPORTED
:
1754 return FILEIO_ENOSYS
;
1757 return FILEIO_EUNKNOWN
;
1761 wince_hostio_last_error (char *buf
)
1763 DWORD winerr
= GetLastError ();
1764 int fileio_err
= win32_error_to_fileio_error (winerr
);
1765 sprintf (buf
, "F-1,%x", fileio_err
);
1769 /* Write Windows OS Thread Information Block address. */
1772 win32_get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
1774 win32_thread_info
*th
;
1775 th
= thread_rec (ptid
, 0);
1779 *addr
= th
->thread_local_base
;
1783 /* Implementation of the target_ops method "sw_breakpoint_from_kind". */
1785 static const gdb_byte
*
1786 win32_sw_breakpoint_from_kind (int kind
, int *size
)
1788 *size
= the_low_target
.breakpoint_len
;
1789 return the_low_target
.breakpoint
;
1792 static struct target_ops win32_target_ops
= {
1793 win32_create_inferior
,
1794 NULL
, /* post_create_inferior */
1803 win32_fetch_inferior_registers
,
1804 win32_store_inferior_registers
,
1805 NULL
, /* prepare_to_access_memory */
1806 NULL
, /* done_accessing_memory */
1807 win32_read_inferior_memory
,
1808 win32_write_inferior_memory
,
1809 NULL
, /* lookup_symbols */
1810 win32_request_interrupt
,
1811 NULL
, /* read_auxv */
1812 win32_supports_z_point_type
,
1815 NULL
, /* stopped_by_sw_breakpoint */
1816 NULL
, /* supports_stopped_by_sw_breakpoint */
1817 NULL
, /* stopped_by_hw_breakpoint */
1818 NULL
, /* supports_stopped_by_hw_breakpoint */
1819 target_can_do_hardware_single_step
,
1820 win32_stopped_by_watchpoint
,
1821 win32_stopped_data_address
,
1822 NULL
, /* read_offsets */
1823 NULL
, /* get_tls_address */
1824 NULL
, /* qxfer_spu */
1826 wince_hostio_last_error
,
1828 hostio_last_error_from_errno
,
1830 NULL
, /* qxfer_osdata */
1831 NULL
, /* qxfer_siginfo */
1832 NULL
, /* supports_non_stop */
1834 NULL
, /* start_non_stop */
1835 NULL
, /* supports_multi_process */
1836 NULL
, /* supports_fork_events */
1837 NULL
, /* supports_vfork_events */
1838 NULL
, /* supports_exec_events */
1839 NULL
, /* handle_new_gdb_connection */
1840 NULL
, /* handle_monitor_command */
1841 NULL
, /* core_of_thread */
1842 NULL
, /* read_loadmap */
1843 NULL
, /* process_qsupported */
1844 NULL
, /* supports_tracepoints */
1846 NULL
, /* write_pc */
1847 NULL
, /* thread_stopped */
1848 win32_get_tib_address
,
1849 NULL
, /* pause_all */
1850 NULL
, /* unpause_all */
1851 NULL
, /* stabilize_threads */
1852 NULL
, /* install_fast_tracepoint_jump_pad */
1853 NULL
, /* emit_ops */
1854 NULL
, /* supports_disable_randomization */
1855 NULL
, /* get_min_fast_tracepoint_insn_len */
1856 NULL
, /* qxfer_libraries_svr4 */
1857 NULL
, /* support_agent */
1858 NULL
, /* support_btrace */
1859 NULL
, /* enable_btrace */
1860 NULL
, /* disable_btrace */
1861 NULL
, /* read_btrace */
1862 NULL
, /* read_btrace_conf */
1863 NULL
, /* supports_range_stepping */
1864 NULL
, /* pid_to_exec_file */
1865 NULL
, /* multifs_open */
1866 NULL
, /* multifs_unlink */
1867 NULL
, /* multifs_readlink */
1868 NULL
, /* breakpoint_kind_from_pc */
1869 win32_sw_breakpoint_from_kind
,
1872 /* Initialize the Win32 backend. */
1874 initialize_low (void)
1876 set_target_ops (&win32_target_ops
);
1877 the_low_target
.arch_setup ();