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 (struct inferior_list_entry
*entry
)
236 struct thread_info
*thread
= (struct thread_info
*) entry
;
237 win32_thread_info
*th
= (win32_thread_info
*) thread_target_data (thread
);
239 remove_thread (thread
);
244 /* Delete a thread from the list of threads. */
246 child_delete_thread (DWORD pid
, DWORD tid
)
248 struct inferior_list_entry
*thread
;
251 /* If the last thread is exiting, just return. */
252 if (one_inferior_p (&all_threads
))
255 ptid
= ptid_build (pid
, tid
, 0);
256 thread
= find_inferior_id (&all_threads
, ptid
);
260 delete_thread_info (thread
);
263 /* These watchpoint related wrapper functions simply pass on the function call
264 if the low target has registered a corresponding function. */
267 win32_supports_z_point_type (char z_type
)
269 return (the_low_target
.supports_z_point_type
!= NULL
270 && the_low_target
.supports_z_point_type (z_type
));
274 win32_insert_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
275 int size
, struct raw_breakpoint
*bp
)
277 if (the_low_target
.insert_point
!= NULL
)
278 return the_low_target
.insert_point (type
, addr
, size
, bp
);
280 /* Unsupported (see target.h). */
285 win32_remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
286 int size
, struct raw_breakpoint
*bp
)
288 if (the_low_target
.remove_point
!= NULL
)
289 return the_low_target
.remove_point (type
, addr
, size
, bp
);
291 /* Unsupported (see target.h). */
296 win32_stopped_by_watchpoint (void)
298 if (the_low_target
.stopped_by_watchpoint
!= NULL
)
299 return the_low_target
.stopped_by_watchpoint ();
305 win32_stopped_data_address (void)
307 if (the_low_target
.stopped_data_address
!= NULL
)
308 return the_low_target
.stopped_data_address ();
314 /* Transfer memory from/to the debugged process. */
316 child_xfer_memory (CORE_ADDR memaddr
, char *our
, int len
,
317 int write
, struct target_ops
*target
)
322 uintptr_t addr
= (uintptr_t) memaddr
;
326 success
= WriteProcessMemory (current_process_handle
, (LPVOID
) addr
,
327 (LPCVOID
) our
, len
, &done
);
329 lasterror
= GetLastError ();
330 FlushInstructionCache (current_process_handle
, (LPCVOID
) addr
, len
);
334 success
= ReadProcessMemory (current_process_handle
, (LPCVOID
) addr
,
335 (LPVOID
) our
, len
, &done
);
337 lasterror
= GetLastError ();
339 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
342 return success
? done
: -1;
345 /* Clear out any old thread list and reinitialize it to a pristine
348 child_init_thread_list (void)
350 for_each_inferior (&all_threads
, delete_thread_info
);
353 /* Zero during the child initialization phase, and nonzero otherwise. */
355 static int child_initialization_done
= 0;
358 do_initial_child_stuff (HANDLE proch
, DWORD pid
, int attached
)
360 struct process_info
*proc
;
362 last_sig
= GDB_SIGNAL_0
;
364 current_process_handle
= proch
;
365 current_process_id
= pid
;
368 soft_interrupt_requested
= 0;
369 faked_breakpoint
= 0;
371 memset (¤t_event
, 0, sizeof (current_event
));
373 proc
= add_process (pid
, attached
);
374 proc
->tdesc
= win32_tdesc
;
375 child_init_thread_list ();
376 child_initialization_done
= 0;
378 if (the_low_target
.initial_stuff
!= NULL
)
379 (*the_low_target
.initial_stuff
) ();
381 cached_status
.kind
= TARGET_WAITKIND_IGNORE
;
383 /* Flush all currently pending debug events (thread and dll list) up
384 to the initial breakpoint. */
387 struct target_waitstatus status
;
389 win32_wait (minus_one_ptid
, &status
, 0);
391 /* Note win32_wait doesn't return thread events. */
392 if (status
.kind
!= TARGET_WAITKIND_LOADED
)
394 cached_status
= status
;
399 struct thread_resume resume
;
401 resume
.thread
= minus_one_ptid
;
402 resume
.kind
= resume_continue
;
405 win32_resume (&resume
, 1);
410 /* Now that the inferior has been started and all DLLs have been mapped,
411 we can iterate over all DLLs and load them in.
413 We avoid doing it any earlier because, on certain versions of Windows,
414 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
415 we have seen on Windows 8.1 that the ntdll.dll load event does not
416 include the DLL name, preventing us from creating an associated SO.
417 A possible explanation is that ntdll.dll might be mapped before
418 the SO info gets created by the Windows system -- ntdll.dll is
419 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
420 do not seem to suffer from that problem.
422 Rather than try to work around this sort of issue, it is much
423 simpler to just ignore DLL load/unload events during the startup
424 phase, and then process them all in one batch now. */
425 win32_add_all_dlls ();
428 child_initialization_done
= 1;
431 /* Resume all artificially suspended threads if we are continuing
434 continue_one_thread (struct inferior_list_entry
*this_thread
, void *id_ptr
)
436 struct thread_info
*thread
= (struct thread_info
*) this_thread
;
437 int thread_id
= * (int *) id_ptr
;
438 win32_thread_info
*th
= (win32_thread_info
*) thread_target_data (thread
);
440 if (thread_id
== -1 || thread_id
== th
->tid
)
442 win32_prepare_to_resume (th
);
446 if (th
->context
.ContextFlags
)
448 win32_set_thread_context (th
);
449 th
->context
.ContextFlags
= 0;
452 if (ResumeThread (th
->h
) == (DWORD
) -1)
454 DWORD err
= GetLastError ();
455 OUTMSG (("warning: ResumeThread failed in continue_one_thread, "
456 "(error %d): %s\n", (int) err
, strwinerror (err
)));
466 child_continue (DWORD continue_status
, int thread_id
)
468 /* The inferior will only continue after the ContinueDebugEvent
470 find_inferior (&all_threads
, continue_one_thread
, &thread_id
);
471 faked_breakpoint
= 0;
473 if (!ContinueDebugEvent (current_event
.dwProcessId
,
474 current_event
.dwThreadId
,
481 /* Fetch register(s) from the current thread context. */
483 child_fetch_inferior_registers (struct regcache
*regcache
, int r
)
486 win32_thread_info
*th
= thread_rec (current_thread_ptid (), TRUE
);
487 if (r
== -1 || r
> NUM_REGS
)
488 child_fetch_inferior_registers (regcache
, NUM_REGS
);
490 for (regno
= 0; regno
< r
; regno
++)
491 (*the_low_target
.fetch_inferior_register
) (regcache
, th
, regno
);
494 /* Store a new register value into the current thread context. We don't
495 change the program's context until later, when we resume it. */
497 child_store_inferior_registers (struct regcache
*regcache
, int r
)
500 win32_thread_info
*th
= thread_rec (current_thread_ptid (), TRUE
);
501 if (r
== -1 || r
== 0 || r
> NUM_REGS
)
502 child_store_inferior_registers (regcache
, NUM_REGS
);
504 for (regno
= 0; regno
< r
; regno
++)
505 (*the_low_target
.store_inferior_register
) (regcache
, th
, regno
);
508 /* Map the Windows error number in ERROR to a locale-dependent error
509 message string and return a pointer to it. Typically, the values
510 for ERROR come from GetLastError.
512 The string pointed to shall not be modified by the application,
513 but may be overwritten by a subsequent call to strwinerror
515 The strwinerror function does not change the current setting
519 strwinerror (DWORD error
)
521 static char buf
[1024];
523 DWORD lasterr
= GetLastError ();
524 DWORD chars
= FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
525 | FORMAT_MESSAGE_ALLOCATE_BUFFER
,
528 0, /* Default language */
534 /* If there is an \r\n appended, zap it. */
536 && msgbuf
[chars
- 2] == '\r'
537 && msgbuf
[chars
- 1] == '\n')
543 if (chars
> ((COUNTOF (buf
)) - 1))
545 chars
= COUNTOF (buf
) - 1;
550 wcstombs (buf
, msgbuf
, chars
+ 1);
552 strncpy (buf
, msgbuf
, chars
+ 1);
557 sprintf (buf
, "unknown win32 error (%u)", (unsigned) error
);
559 SetLastError (lasterr
);
564 create_process (const char *program
, char *args
,
565 DWORD flags
, PROCESS_INFORMATION
*pi
)
567 const char *inferior_cwd
= get_inferior_cwd ();
568 std::string expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
572 wchar_t *p
, *wprogram
, *wargs
, *wcwd
= NULL
;
575 wprogram
= alloca ((strlen (program
) + 1) * sizeof (wchar_t));
576 mbstowcs (wprogram
, program
, strlen (program
) + 1);
578 for (p
= wprogram
; *p
; ++p
)
582 argslen
= strlen (args
);
583 wargs
= alloca ((argslen
+ 1) * sizeof (wchar_t));
584 mbstowcs (wargs
, args
, argslen
+ 1);
586 if (inferior_cwd
!= NULL
)
588 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
590 wcwd
= alloca ((expanded_infcwd
.size () + 1) * sizeof (wchar_t));
591 if (mbstowcs (wcwd
, expanded_infcwd
.c_str (),
592 expanded_infcwd
.size () + 1) == NULL
)
595 Could not convert the expanded inferior cwd to wide-char."));
599 ret
= CreateProcessW (wprogram
, /* image name */
600 wargs
, /* command line */
601 NULL
, /* security, not supported */
602 NULL
, /* thread, not supported */
603 FALSE
, /* inherit handles, not supported */
604 flags
, /* start flags */
605 NULL
, /* environment, not supported */
606 wcwd
, /* current directory */
607 NULL
, /* start info, not supported */
610 STARTUPINFOA si
= { sizeof (STARTUPINFOA
) };
612 ret
= CreateProcessA (program
, /* image name */
613 args
, /* command line */
616 TRUE
, /* inherit handles */
617 flags
, /* start flags */
618 NULL
, /* environment */
619 expanded_infcwd
.c_str (), /* current directory */
620 &si
, /* start info */
627 /* Start a new process.
628 PROGRAM is the program name.
629 PROGRAM_ARGS is the vector containing the inferior's args.
630 Returns the new PID on success, -1 on failure. Registers the new
631 process with the process list. */
633 win32_create_inferior (const char *program
,
634 const std::vector
<char *> &program_args
)
637 char real_path
[PATH_MAX
];
638 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\"\n", 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\n", (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 return current_process_id
;
716 /* Attach to a running process.
717 PID is the process ID to attach to, specified by the user
718 or a higher layer. */
720 win32_attach (unsigned long pid
)
723 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
726 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
728 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
730 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
732 h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
735 if (DebugActiveProcess (pid
))
737 if (DebugSetProcessKillOnExit
!= NULL
)
738 DebugSetProcessKillOnExit (FALSE
);
740 /* win32_wait needs to know we're attaching. */
742 do_initial_child_stuff (h
, pid
, 1);
749 err
= GetLastError ();
750 error ("Attach to process failed (error %d): %s\n",
751 (int) err
, strwinerror (err
));
754 /* Handle OUTPUT_DEBUG_STRING_EVENT from child process. */
756 handle_output_debug_string (void)
758 #define READ_BUFFER_LEN 1024
760 char s
[READ_BUFFER_LEN
+ 1] = { 0 };
761 DWORD nbytes
= current_event
.u
.DebugString
.nDebugStringLength
;
766 if (nbytes
> READ_BUFFER_LEN
)
767 nbytes
= READ_BUFFER_LEN
;
769 addr
= (CORE_ADDR
) (size_t) current_event
.u
.DebugString
.lpDebugStringData
;
771 if (current_event
.u
.DebugString
.fUnicode
)
773 /* The event tells us how many bytes, not chars, even
775 WCHAR buffer
[(READ_BUFFER_LEN
+ 1) / sizeof (WCHAR
)] = { 0 };
776 if (read_inferior_memory (addr
, (unsigned char *) buffer
, nbytes
) != 0)
778 wcstombs (s
, buffer
, (nbytes
+ 1) / sizeof (WCHAR
));
782 if (read_inferior_memory (addr
, (unsigned char *) s
, nbytes
) != 0)
786 if (!startswith (s
, "cYg"))
796 #undef READ_BUFFER_LEN
800 win32_clear_inferiors (void)
802 if (current_process_handle
!= NULL
)
803 CloseHandle (current_process_handle
);
805 for_each_inferior (&all_threads
, delete_thread_info
);
809 /* Kill all inferiors. */
813 struct process_info
*process
;
815 if (current_process_handle
== NULL
)
818 TerminateProcess (current_process_handle
, 0);
821 if (!child_continue (DBG_CONTINUE
, -1))
823 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
825 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
827 else if (current_event
.dwDebugEventCode
== OUTPUT_DEBUG_STRING_EVENT
)
828 handle_output_debug_string ();
831 win32_clear_inferiors ();
833 process
= find_process_pid (pid
);
834 remove_process (process
);
838 /* Detach from inferior PID. */
840 win32_detach (int pid
)
842 struct process_info
*process
;
843 winapi_DebugActiveProcessStop DebugActiveProcessStop
= NULL
;
844 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
846 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
848 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
850 DebugActiveProcessStop
= GETPROCADDRESS (dll
, DebugActiveProcessStop
);
851 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
853 if (DebugSetProcessKillOnExit
== NULL
854 || DebugActiveProcessStop
== NULL
)
858 struct thread_resume resume
;
859 resume
.thread
= minus_one_ptid
;
860 resume
.kind
= resume_continue
;
862 win32_resume (&resume
, 1);
865 if (!DebugActiveProcessStop (current_process_id
))
868 DebugSetProcessKillOnExit (FALSE
);
869 process
= find_process_pid (pid
);
870 remove_process (process
);
872 win32_clear_inferiors ();
877 win32_mourn (struct process_info
*process
)
879 remove_process (process
);
882 /* Wait for inferiors to end. */
886 HANDLE h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
889 WaitForSingleObject (h
, INFINITE
);
894 /* Return 1 iff the thread with thread ID TID is alive. */
896 win32_thread_alive (ptid_t ptid
)
900 /* Our thread list is reliable; don't bother to poll target
902 if (find_inferior_id (&all_threads
, ptid
) != NULL
)
909 /* Resume the inferior process. RESUME_INFO describes how we want
912 win32_resume (struct thread_resume
*resume_info
, size_t n
)
917 win32_thread_info
*th
;
918 DWORD continue_status
= DBG_CONTINUE
;
921 /* This handles the very limited set of resume packets that GDB can
922 currently produce. */
924 if (n
== 1 && ptid_equal (resume_info
[0].thread
, minus_one_ptid
))
929 /* Yes, we're ignoring resume_info[0].thread. It'd be tricky to make
930 the Windows resume code do the right thing for thread switching. */
931 tid
= current_event
.dwThreadId
;
933 if (!ptid_equal (resume_info
[0].thread
, minus_one_ptid
))
935 sig
= gdb_signal_from_host (resume_info
[0].sig
);
936 step
= resume_info
[0].kind
== resume_step
;
944 if (sig
!= GDB_SIGNAL_0
)
946 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
948 OUTMSG (("Cannot continue with signal %s here.\n",
949 gdb_signal_to_string (sig
)));
951 else if (sig
== last_sig
)
952 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
954 OUTMSG (("Can only continue with received signal %s.\n",
955 gdb_signal_to_string (last_sig
)));
958 last_sig
= GDB_SIGNAL_0
;
960 /* Get context for the currently selected thread. */
961 ptid
= debug_event_ptid (¤t_event
);
962 th
= thread_rec (ptid
, FALSE
);
965 win32_prepare_to_resume (th
);
967 if (th
->context
.ContextFlags
)
969 /* Move register values from the inferior into the thread
970 context structure. */
971 regcache_invalidate ();
975 if (the_low_target
.single_step
!= NULL
)
976 (*the_low_target
.single_step
) (th
);
978 error ("Single stepping is not supported "
979 "in this configuration.\n");
982 win32_set_thread_context (th
);
983 th
->context
.ContextFlags
= 0;
987 /* Allow continuing with the same signal that interrupted us.
988 Otherwise complain. */
990 child_continue (continue_status
, tid
);
994 win32_add_one_solib (const char *name
, CORE_ADDR load_addr
)
996 char buf
[MAX_PATH
+ 1];
997 char buf2
[MAX_PATH
+ 1];
1000 WIN32_FIND_DATA w32_fd
;
1001 WCHAR wname
[MAX_PATH
+ 1];
1002 mbstowcs (wname
, name
, MAX_PATH
);
1003 HANDLE h
= FindFirstFile (wname
, &w32_fd
);
1005 WIN32_FIND_DATAA w32_fd
;
1006 HANDLE h
= FindFirstFileA (name
, &w32_fd
);
1009 /* The symbols in a dll are offset by 0x1000, which is the
1010 offset from 0 of the first byte in an image - because
1011 of the file header and the section alignment. */
1012 load_addr
+= 0x1000;
1014 if (h
== INVALID_HANDLE_VALUE
)
1022 char cwd
[MAX_PATH
+ 1];
1024 if (GetCurrentDirectoryA (MAX_PATH
+ 1, cwd
))
1026 p
= strrchr (buf
, '\\');
1029 SetCurrentDirectoryA (buf
);
1030 GetFullPathNameA (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
1031 SetCurrentDirectoryA (cwd
);
1038 if (strcasecmp (buf
, "ntdll.dll") == 0)
1040 GetSystemDirectoryA (buf
, sizeof (buf
));
1041 strcat (buf
, "\\ntdll.dll");
1046 cygwin_conv_path (CCP_WIN_A_TO_POSIX
, buf
, buf2
, sizeof (buf2
));
1051 loaded_dll (buf2
, load_addr
);
1055 get_image_name (HANDLE h
, void *address
, int unicode
)
1057 static char buf
[(2 * MAX_PATH
) + 1];
1058 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
1064 /* Attempt to read the name of the dll that was detected.
1065 This is documented to work only when actively debugging
1066 a program. It will not work for attached processes. */
1067 if (address
== NULL
)
1071 /* Windows CE reports the address of the image name,
1072 instead of an address of a pointer into the image name. */
1073 address_ptr
= address
;
1075 /* See if we could read the address of a string, and that the
1076 address isn't null. */
1077 if (!ReadProcessMemory (h
, address
, &address_ptr
,
1078 sizeof (address_ptr
), &done
)
1079 || done
!= sizeof (address_ptr
)
1084 /* Find the length of the string */
1085 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
1086 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
1090 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
1093 WCHAR
*unicode_address
= XALLOCAVEC (WCHAR
, len
);
1094 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
1097 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
1103 typedef BOOL (WINAPI
*winapi_EnumProcessModules
) (HANDLE
, HMODULE
*,
1105 typedef BOOL (WINAPI
*winapi_GetModuleInformation
) (HANDLE
, HMODULE
,
1106 LPMODULEINFO
, DWORD
);
1107 typedef DWORD (WINAPI
*winapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
,
1110 static winapi_EnumProcessModules win32_EnumProcessModules
;
1111 static winapi_GetModuleInformation win32_GetModuleInformation
;
1112 static winapi_GetModuleFileNameExA win32_GetModuleFileNameExA
;
1117 static int psapi_loaded
= 0;
1118 static HMODULE dll
= NULL
;
1123 dll
= LoadLibrary (TEXT("psapi.dll"));
1126 win32_EnumProcessModules
=
1127 GETPROCADDRESS (dll
, EnumProcessModules
);
1128 win32_GetModuleInformation
=
1129 GETPROCADDRESS (dll
, GetModuleInformation
);
1130 win32_GetModuleFileNameExA
=
1131 GETPROCADDRESS (dll
, GetModuleFileNameExA
);
1134 return (win32_EnumProcessModules
!= NULL
1135 && win32_GetModuleInformation
!= NULL
1136 && win32_GetModuleFileNameExA
!= NULL
);
1141 /* Iterate over all DLLs currently mapped by our inferior, and
1142 add them to our list of solibs. */
1145 win32_add_all_dlls (void)
1149 HMODULE
*DllHandle
= dh_buf
;
1157 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
1162 if (!ok
|| !cbNeeded
)
1165 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
1169 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
1176 for (i
= 1; i
< ((size_t) cbNeeded
/ sizeof (HMODULE
)); i
++)
1179 char dll_name
[MAX_PATH
];
1181 if (!(*win32_GetModuleInformation
) (current_process_handle
,
1186 if ((*win32_GetModuleFileNameExA
) (current_process_handle
,
1191 win32_add_one_solib (dll_name
, (CORE_ADDR
) (uintptr_t) mi
.lpBaseOfDll
);
1196 typedef HANDLE (WINAPI
*winapi_CreateToolhelp32Snapshot
) (DWORD
, DWORD
);
1197 typedef BOOL (WINAPI
*winapi_Module32First
) (HANDLE
, LPMODULEENTRY32
);
1198 typedef BOOL (WINAPI
*winapi_Module32Next
) (HANDLE
, LPMODULEENTRY32
);
1200 /* Handle a DLL load event.
1202 This function assumes that this event did not occur during inferior
1203 initialization, where their event info may be incomplete (see
1204 do_initial_child_stuff and win32_add_all_dlls for more info on
1205 how we handle DLL loading during that phase). */
1208 handle_load_dll (void)
1210 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
1213 dll_name
= get_image_name (current_process_handle
,
1214 event
->lpImageName
, event
->fUnicode
);
1218 win32_add_one_solib (dll_name
, (CORE_ADDR
) (uintptr_t) event
->lpBaseOfDll
);
1221 /* Handle a DLL unload event.
1223 This function assumes that this event did not occur during inferior
1224 initialization, where their event info may be incomplete (see
1225 do_initial_child_stuff and win32_add_one_solib for more info
1226 on how we handle DLL loading during that phase). */
1229 handle_unload_dll (void)
1231 CORE_ADDR load_addr
=
1232 (CORE_ADDR
) (uintptr_t) current_event
.u
.UnloadDll
.lpBaseOfDll
;
1234 /* The symbols in a dll are offset by 0x1000, which is the
1235 offset from 0 of the first byte in an image - because
1236 of the file header and the section alignment. */
1237 load_addr
+= 0x1000;
1238 unloaded_dll (NULL
, load_addr
);
1242 handle_exception (struct target_waitstatus
*ourstatus
)
1244 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
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 (struct inferior_list_entry
*entry
)
1352 struct thread_info
*thread
= (struct thread_info
*) entry
;
1353 win32_thread_info
*th
= (win32_thread_info
*) thread_target_data (thread
);
1357 if (SuspendThread (th
->h
) == (DWORD
) -1)
1359 DWORD err
= GetLastError ();
1360 OUTMSG (("warning: SuspendThread failed in suspend_one_thread, "
1361 "(error %d): %s\n", (int) err
, strwinerror (err
)));
1369 fake_breakpoint_event (void)
1371 OUTMSG2(("fake_breakpoint_event\n"));
1373 faked_breakpoint
= 1;
1375 memset (¤t_event
, 0, sizeof (current_event
));
1376 current_event
.dwThreadId
= main_thread_id
;
1377 current_event
.dwDebugEventCode
= EXCEPTION_DEBUG_EVENT
;
1378 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1379 = EXCEPTION_BREAKPOINT
;
1381 for_each_inferior (&all_threads
, suspend_one_thread
);
1386 auto_delete_breakpoint (CORE_ADDR stop_pc
)
1392 /* Get the next event from the child. */
1395 get_child_debug_event (struct target_waitstatus
*ourstatus
)
1399 last_sig
= GDB_SIGNAL_0
;
1400 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1402 /* Check if GDB sent us an interrupt request. */
1403 check_remote_input_interrupt_request ();
1405 if (soft_interrupt_requested
)
1407 soft_interrupt_requested
= 0;
1408 fake_breakpoint_event ();
1417 /* WinCE doesn't set an initial breakpoint automatically. To
1418 stop the inferior, we flush all currently pending debug
1419 events -- the thread list and the dll list are always
1420 reported immediatelly without delay, then, we suspend all
1421 threads and pretend we saw a trap at the current PC of the
1424 Contrary to desktop Windows, Windows CE *does* report the dll
1425 names on LOAD_DLL_DEBUG_EVENTs resulting from a
1426 DebugActiveProcess call. This limits the way we can detect
1427 if all the dlls have already been reported. If we get a real
1428 debug event before leaving attaching, the worst that will
1429 happen is the user will see a spurious breakpoint. */
1431 current_event
.dwDebugEventCode
= 0;
1432 if (!WaitForDebugEvent (¤t_event
, 0))
1434 OUTMSG2(("no attach events left\n"));
1435 fake_breakpoint_event ();
1439 OUTMSG2(("got attach event\n"));
1444 /* Keep the wait time low enough for confortable remote
1445 interruption, but high enough so gdbserver doesn't become a
1447 if (!WaitForDebugEvent (¤t_event
, 250))
1449 DWORD e
= GetLastError();
1451 if (e
== ERROR_PIPE_NOT_CONNECTED
)
1453 /* This will happen if the loader fails to succesfully
1454 load the application, e.g., if the main executable
1455 tries to pull in a non-existing export from a
1457 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1458 ourstatus
->value
.integer
= 1;
1468 switch (current_event
.dwDebugEventCode
)
1470 case CREATE_THREAD_DEBUG_EVENT
:
1471 OUTMSG2 (("gdbserver: kernel event CREATE_THREAD_DEBUG_EVENT "
1472 "for pid=%u tid=%x)\n",
1473 (unsigned) current_event
.dwProcessId
,
1474 (unsigned) current_event
.dwThreadId
));
1476 /* Record the existence of this thread. */
1477 child_add_thread (current_event
.dwProcessId
,
1478 current_event
.dwThreadId
,
1479 current_event
.u
.CreateThread
.hThread
,
1480 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1483 case EXIT_THREAD_DEBUG_EVENT
:
1484 OUTMSG2 (("gdbserver: kernel event EXIT_THREAD_DEBUG_EVENT "
1485 "for pid=%u tid=%x\n",
1486 (unsigned) current_event
.dwProcessId
,
1487 (unsigned) current_event
.dwThreadId
));
1488 child_delete_thread (current_event
.dwProcessId
,
1489 current_event
.dwThreadId
);
1491 current_thread
= (struct thread_info
*) all_threads
.head
;
1494 case CREATE_PROCESS_DEBUG_EVENT
:
1495 OUTMSG2 (("gdbserver: kernel event CREATE_PROCESS_DEBUG_EVENT "
1496 "for pid=%u tid=%x\n",
1497 (unsigned) current_event
.dwProcessId
,
1498 (unsigned) current_event
.dwThreadId
));
1499 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1501 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1502 main_thread_id
= current_event
.dwThreadId
;
1504 /* Add the main thread. */
1505 child_add_thread (current_event
.dwProcessId
,
1507 current_event
.u
.CreateProcessInfo
.hThread
,
1508 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
);
1513 /* Windows CE doesn't set the initial breakpoint
1514 automatically like the desktop versions of Windows do.
1515 We add it explicitly here. It will be removed as soon as
1517 set_breakpoint_at ((CORE_ADDR
) (long) current_event
.u
1518 .CreateProcessInfo
.lpStartAddress
,
1519 auto_delete_breakpoint
);
1524 case EXIT_PROCESS_DEBUG_EVENT
:
1525 OUTMSG2 (("gdbserver: kernel event EXIT_PROCESS_DEBUG_EVENT "
1526 "for pid=%u tid=%x\n",
1527 (unsigned) current_event
.dwProcessId
,
1528 (unsigned) current_event
.dwThreadId
));
1529 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1530 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1531 child_continue (DBG_CONTINUE
, -1);
1532 CloseHandle (current_process_handle
);
1533 current_process_handle
= NULL
;
1536 case LOAD_DLL_DEBUG_EVENT
:
1537 OUTMSG2 (("gdbserver: kernel event LOAD_DLL_DEBUG_EVENT "
1538 "for pid=%u tid=%x\n",
1539 (unsigned) current_event
.dwProcessId
,
1540 (unsigned) current_event
.dwThreadId
));
1541 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1542 if (! child_initialization_done
)
1546 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1547 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1550 case UNLOAD_DLL_DEBUG_EVENT
:
1551 OUTMSG2 (("gdbserver: kernel event UNLOAD_DLL_DEBUG_EVENT "
1552 "for pid=%u tid=%x\n",
1553 (unsigned) current_event
.dwProcessId
,
1554 (unsigned) current_event
.dwThreadId
));
1555 if (! child_initialization_done
)
1557 handle_unload_dll ();
1558 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1559 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1562 case EXCEPTION_DEBUG_EVENT
:
1563 OUTMSG2 (("gdbserver: kernel event EXCEPTION_DEBUG_EVENT "
1564 "for pid=%u tid=%x\n",
1565 (unsigned) current_event
.dwProcessId
,
1566 (unsigned) current_event
.dwThreadId
));
1567 handle_exception (ourstatus
);
1570 case OUTPUT_DEBUG_STRING_EVENT
:
1571 /* A message from the kernel (or Cygwin). */
1572 OUTMSG2 (("gdbserver: kernel event OUTPUT_DEBUG_STRING_EVENT "
1573 "for pid=%u tid=%x\n",
1574 (unsigned) current_event
.dwProcessId
,
1575 (unsigned) current_event
.dwThreadId
));
1576 handle_output_debug_string ();
1580 OUTMSG2 (("gdbserver: kernel event unknown "
1581 "for pid=%u tid=%x code=%x\n",
1582 (unsigned) current_event
.dwProcessId
,
1583 (unsigned) current_event
.dwThreadId
,
1584 (unsigned) current_event
.dwDebugEventCode
));
1588 ptid
= debug_event_ptid (¤t_event
);
1590 (struct thread_info
*) find_inferior_id (&all_threads
, ptid
);
1594 /* Wait for the inferior process to change state.
1595 STATUS will be filled in with a response code to send to GDB.
1596 Returns the signal which caused the process to stop. */
1598 win32_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
1600 struct regcache
*regcache
;
1602 if (cached_status
.kind
!= TARGET_WAITKIND_IGNORE
)
1604 /* The core always does a wait after creating the inferior, and
1605 do_initial_child_stuff already ran the inferior to the
1606 initial breakpoint (or an exit, if creating the process
1607 fails). Report it now. */
1608 *ourstatus
= cached_status
;
1609 cached_status
.kind
= TARGET_WAITKIND_IGNORE
;
1610 return debug_event_ptid (¤t_event
);
1615 if (!get_child_debug_event (ourstatus
))
1618 switch (ourstatus
->kind
)
1620 case TARGET_WAITKIND_EXITED
:
1621 OUTMSG2 (("Child exited with retcode = %x\n",
1622 ourstatus
->value
.integer
));
1623 win32_clear_inferiors ();
1624 return pid_to_ptid (current_event
.dwProcessId
);
1625 case TARGET_WAITKIND_STOPPED
:
1626 case TARGET_WAITKIND_LOADED
:
1627 OUTMSG2 (("Child Stopped with signal = %d \n",
1628 ourstatus
->value
.sig
));
1630 regcache
= get_thread_regcache (current_thread
, 1);
1631 child_fetch_inferior_registers (regcache
, -1);
1632 return debug_event_ptid (¤t_event
);
1634 OUTMSG (("Ignoring unknown internal event, %d\n", ourstatus
->kind
));
1636 case TARGET_WAITKIND_SPURIOUS
:
1637 /* do nothing, just continue */
1638 child_continue (DBG_CONTINUE
, -1);
1644 /* Fetch registers from the inferior process.
1645 If REGNO is -1, fetch all registers; otherwise, fetch at least REGNO. */
1647 win32_fetch_inferior_registers (struct regcache
*regcache
, int regno
)
1649 child_fetch_inferior_registers (regcache
, regno
);
1652 /* Store registers to the inferior process.
1653 If REGNO is -1, store all registers; otherwise, store at least REGNO. */
1655 win32_store_inferior_registers (struct regcache
*regcache
, int regno
)
1657 child_store_inferior_registers (regcache
, regno
);
1660 /* Read memory from the inferior process. This should generally be
1661 called through read_inferior_memory, which handles breakpoint shadowing.
1662 Read LEN bytes at MEMADDR into a buffer at MYADDR. */
1664 win32_read_inferior_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
1666 return child_xfer_memory (memaddr
, (char *) myaddr
, len
, 0, 0) != len
;
1669 /* Write memory to the inferior process. This should generally be
1670 called through write_inferior_memory, which handles breakpoint shadowing.
1671 Write LEN bytes from the buffer at MYADDR to MEMADDR.
1672 Returns 0 on success and errno on failure. */
1674 win32_write_inferior_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
,
1677 return child_xfer_memory (memaddr
, (char *) myaddr
, len
, 1, 0) != len
;
1680 /* Send an interrupt request to the inferior process. */
1682 win32_request_interrupt (void)
1684 winapi_DebugBreakProcess DebugBreakProcess
;
1685 winapi_GenerateConsoleCtrlEvent GenerateConsoleCtrlEvent
;
1688 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
1690 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
1693 GenerateConsoleCtrlEvent
= GETPROCADDRESS (dll
, GenerateConsoleCtrlEvent
);
1695 if (GenerateConsoleCtrlEvent
!= NULL
1696 && GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, current_process_id
))
1699 /* GenerateConsoleCtrlEvent can fail if process id being debugged is
1700 not a process group id.
1701 Fallback to XP/Vista 'DebugBreakProcess', which generates a
1702 breakpoint exception in the interior process. */
1704 DebugBreakProcess
= GETPROCADDRESS (dll
, DebugBreakProcess
);
1706 if (DebugBreakProcess
!= NULL
1707 && DebugBreakProcess (current_process_handle
))
1710 /* Last resort, suspend all threads manually. */
1711 soft_interrupt_requested
= 1;
1716 win32_error_to_fileio_error (DWORD err
)
1720 case ERROR_BAD_PATHNAME
:
1721 case ERROR_FILE_NOT_FOUND
:
1722 case ERROR_INVALID_NAME
:
1723 case ERROR_PATH_NOT_FOUND
:
1724 return FILEIO_ENOENT
;
1726 case ERROR_IO_DEVICE
:
1727 case ERROR_OPEN_FAILED
:
1729 case ERROR_INVALID_HANDLE
:
1730 return FILEIO_EBADF
;
1731 case ERROR_ACCESS_DENIED
:
1732 case ERROR_SHARING_VIOLATION
:
1733 return FILEIO_EACCES
;
1734 case ERROR_NOACCESS
:
1735 return FILEIO_EFAULT
;
1737 return FILEIO_EBUSY
;
1738 case ERROR_ALREADY_EXISTS
:
1739 case ERROR_FILE_EXISTS
:
1740 return FILEIO_EEXIST
;
1741 case ERROR_BAD_DEVICE
:
1742 return FILEIO_ENODEV
;
1743 case ERROR_DIRECTORY
:
1744 return FILEIO_ENOTDIR
;
1745 case ERROR_FILENAME_EXCED_RANGE
:
1746 case ERROR_INVALID_DATA
:
1747 case ERROR_INVALID_PARAMETER
:
1748 case ERROR_NEGATIVE_SEEK
:
1749 return FILEIO_EINVAL
;
1750 case ERROR_TOO_MANY_OPEN_FILES
:
1751 return FILEIO_EMFILE
;
1752 case ERROR_HANDLE_DISK_FULL
:
1753 case ERROR_DISK_FULL
:
1754 return FILEIO_ENOSPC
;
1755 case ERROR_WRITE_PROTECT
:
1756 return FILEIO_EROFS
;
1757 case ERROR_NOT_SUPPORTED
:
1758 return FILEIO_ENOSYS
;
1761 return FILEIO_EUNKNOWN
;
1765 wince_hostio_last_error (char *buf
)
1767 DWORD winerr
= GetLastError ();
1768 int fileio_err
= win32_error_to_fileio_error (winerr
);
1769 sprintf (buf
, "F-1,%x", fileio_err
);
1773 /* Write Windows OS Thread Information Block address. */
1776 win32_get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
1778 win32_thread_info
*th
;
1779 th
= thread_rec (ptid
, 0);
1783 *addr
= th
->thread_local_base
;
1787 /* Implementation of the target_ops method "sw_breakpoint_from_kind". */
1789 static const gdb_byte
*
1790 win32_sw_breakpoint_from_kind (int kind
, int *size
)
1792 *size
= the_low_target
.breakpoint_len
;
1793 return the_low_target
.breakpoint
;
1796 static struct target_ops win32_target_ops
= {
1797 win32_create_inferior
,
1798 NULL
, /* post_create_inferior */
1807 win32_fetch_inferior_registers
,
1808 win32_store_inferior_registers
,
1809 NULL
, /* prepare_to_access_memory */
1810 NULL
, /* done_accessing_memory */
1811 win32_read_inferior_memory
,
1812 win32_write_inferior_memory
,
1813 NULL
, /* lookup_symbols */
1814 win32_request_interrupt
,
1815 NULL
, /* read_auxv */
1816 win32_supports_z_point_type
,
1819 NULL
, /* stopped_by_sw_breakpoint */
1820 NULL
, /* supports_stopped_by_sw_breakpoint */
1821 NULL
, /* stopped_by_hw_breakpoint */
1822 NULL
, /* supports_stopped_by_hw_breakpoint */
1823 target_can_do_hardware_single_step
,
1824 win32_stopped_by_watchpoint
,
1825 win32_stopped_data_address
,
1826 NULL
, /* read_offsets */
1827 NULL
, /* get_tls_address */
1828 NULL
, /* qxfer_spu */
1830 wince_hostio_last_error
,
1832 hostio_last_error_from_errno
,
1834 NULL
, /* qxfer_osdata */
1835 NULL
, /* qxfer_siginfo */
1836 NULL
, /* supports_non_stop */
1838 NULL
, /* start_non_stop */
1839 NULL
, /* supports_multi_process */
1840 NULL
, /* supports_fork_events */
1841 NULL
, /* supports_vfork_events */
1842 NULL
, /* supports_exec_events */
1843 NULL
, /* handle_new_gdb_connection */
1844 NULL
, /* handle_monitor_command */
1845 NULL
, /* core_of_thread */
1846 NULL
, /* read_loadmap */
1847 NULL
, /* process_qsupported */
1848 NULL
, /* supports_tracepoints */
1850 NULL
, /* write_pc */
1851 NULL
, /* thread_stopped */
1852 win32_get_tib_address
,
1853 NULL
, /* pause_all */
1854 NULL
, /* unpause_all */
1855 NULL
, /* stabilize_threads */
1856 NULL
, /* install_fast_tracepoint_jump_pad */
1857 NULL
, /* emit_ops */
1858 NULL
, /* supports_disable_randomization */
1859 NULL
, /* get_min_fast_tracepoint_insn_len */
1860 NULL
, /* qxfer_libraries_svr4 */
1861 NULL
, /* support_agent */
1862 NULL
, /* support_btrace */
1863 NULL
, /* enable_btrace */
1864 NULL
, /* disable_btrace */
1865 NULL
, /* read_btrace */
1866 NULL
, /* read_btrace_conf */
1867 NULL
, /* supports_range_stepping */
1868 NULL
, /* pid_to_exec_file */
1869 NULL
, /* multifs_open */
1870 NULL
, /* multifs_unlink */
1871 NULL
, /* multifs_readlink */
1872 NULL
, /* breakpoint_kind_from_pc */
1873 win32_sw_breakpoint_from_kind
,
1876 /* Initialize the Win32 backend. */
1878 initialize_low (void)
1880 set_target_ops (&win32_target_ops
);
1881 the_low_target
.arch_setup ();