1 /* Low level interface to Windows debugging, for gdbserver.
2 Copyright (C) 2006-2018 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_t (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 thread_info
*thread
= find_thread_ptid (ptid
);
200 win32_thread_info
*th
= (win32_thread_info
*) thread_target_data (thread
);
202 win32_require_context (th
);
206 /* Add a thread to the thread list. */
207 static win32_thread_info
*
208 child_add_thread (DWORD pid
, DWORD tid
, HANDLE h
, void *tlb
)
210 win32_thread_info
*th
;
211 ptid_t ptid
= ptid_t (pid
, tid
, 0);
213 if ((th
= thread_rec (ptid
, FALSE
)))
216 th
= XCNEW (win32_thread_info
);
219 th
->thread_local_base
= (CORE_ADDR
) (uintptr_t) tlb
;
221 add_thread (ptid
, th
);
223 if (the_low_target
.thread_added
!= NULL
)
224 (*the_low_target
.thread_added
) (th
);
229 /* Delete a thread from the list of threads. */
231 delete_thread_info (thread_info
*thread
)
233 win32_thread_info
*th
= (win32_thread_info
*) thread_target_data (thread
);
235 remove_thread (thread
);
240 /* Delete a thread from the list of threads. */
242 child_delete_thread (DWORD pid
, DWORD tid
)
244 /* If the last thread is exiting, just return. */
245 if (all_threads
.size () == 1)
248 thread_info
*thread
= find_thread_ptid (ptid_t (pid
, tid
));
252 delete_thread_info (thread
);
255 /* These watchpoint related wrapper functions simply pass on the function call
256 if the low target has registered a corresponding function. */
259 win32_supports_z_point_type (char z_type
)
261 return (the_low_target
.supports_z_point_type
!= NULL
262 && the_low_target
.supports_z_point_type (z_type
));
266 win32_insert_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
267 int size
, struct raw_breakpoint
*bp
)
269 if (the_low_target
.insert_point
!= NULL
)
270 return the_low_target
.insert_point (type
, addr
, size
, bp
);
272 /* Unsupported (see target.h). */
277 win32_remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
278 int size
, struct raw_breakpoint
*bp
)
280 if (the_low_target
.remove_point
!= NULL
)
281 return the_low_target
.remove_point (type
, addr
, size
, bp
);
283 /* Unsupported (see target.h). */
288 win32_stopped_by_watchpoint (void)
290 if (the_low_target
.stopped_by_watchpoint
!= NULL
)
291 return the_low_target
.stopped_by_watchpoint ();
297 win32_stopped_data_address (void)
299 if (the_low_target
.stopped_data_address
!= NULL
)
300 return the_low_target
.stopped_data_address ();
306 /* Transfer memory from/to the debugged process. */
308 child_xfer_memory (CORE_ADDR memaddr
, char *our
, int len
,
309 int write
, struct target_ops
*target
)
314 uintptr_t addr
= (uintptr_t) memaddr
;
318 success
= WriteProcessMemory (current_process_handle
, (LPVOID
) addr
,
319 (LPCVOID
) our
, len
, &done
);
321 lasterror
= GetLastError ();
322 FlushInstructionCache (current_process_handle
, (LPCVOID
) addr
, len
);
326 success
= ReadProcessMemory (current_process_handle
, (LPCVOID
) addr
,
327 (LPVOID
) our
, len
, &done
);
329 lasterror
= GetLastError ();
331 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
334 return success
? done
: -1;
337 /* Clear out any old thread list and reinitialize it to a pristine
340 child_init_thread_list (void)
342 for_each_thread (delete_thread_info
);
345 /* Zero during the child initialization phase, and nonzero otherwise. */
347 static int child_initialization_done
= 0;
350 do_initial_child_stuff (HANDLE proch
, DWORD pid
, int attached
)
352 struct process_info
*proc
;
354 last_sig
= GDB_SIGNAL_0
;
356 current_process_handle
= proch
;
357 current_process_id
= pid
;
360 soft_interrupt_requested
= 0;
361 faked_breakpoint
= 0;
363 memset (¤t_event
, 0, sizeof (current_event
));
365 proc
= add_process (pid
, attached
);
366 proc
->tdesc
= win32_tdesc
;
367 child_init_thread_list ();
368 child_initialization_done
= 0;
370 if (the_low_target
.initial_stuff
!= NULL
)
371 (*the_low_target
.initial_stuff
) ();
373 cached_status
.kind
= TARGET_WAITKIND_IGNORE
;
375 /* Flush all currently pending debug events (thread and dll list) up
376 to the initial breakpoint. */
379 struct target_waitstatus status
;
381 win32_wait (minus_one_ptid
, &status
, 0);
383 /* Note win32_wait doesn't return thread events. */
384 if (status
.kind
!= TARGET_WAITKIND_LOADED
)
386 cached_status
= status
;
391 struct thread_resume resume
;
393 resume
.thread
= minus_one_ptid
;
394 resume
.kind
= resume_continue
;
397 win32_resume (&resume
, 1);
402 /* Now that the inferior has been started and all DLLs have been mapped,
403 we can iterate over all DLLs and load them in.
405 We avoid doing it any earlier because, on certain versions of Windows,
406 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
407 we have seen on Windows 8.1 that the ntdll.dll load event does not
408 include the DLL name, preventing us from creating an associated SO.
409 A possible explanation is that ntdll.dll might be mapped before
410 the SO info gets created by the Windows system -- ntdll.dll is
411 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
412 do not seem to suffer from that problem.
414 Rather than try to work around this sort of issue, it is much
415 simpler to just ignore DLL load/unload events during the startup
416 phase, and then process them all in one batch now. */
417 win32_add_all_dlls ();
420 child_initialization_done
= 1;
423 /* Resume all artificially suspended threads if we are continuing
426 continue_one_thread (thread_info
*thread
, int thread_id
)
428 win32_thread_info
*th
= (win32_thread_info
*) thread_target_data (thread
);
430 if (thread_id
== -1 || thread_id
== th
->tid
)
432 win32_prepare_to_resume (th
);
436 if (th
->context
.ContextFlags
)
438 win32_set_thread_context (th
);
439 th
->context
.ContextFlags
= 0;
442 if (ResumeThread (th
->h
) == (DWORD
) -1)
444 DWORD err
= GetLastError ();
445 OUTMSG (("warning: ResumeThread failed in continue_one_thread, "
446 "(error %d): %s\n", (int) err
, strwinerror (err
)));
454 child_continue (DWORD continue_status
, int thread_id
)
456 /* The inferior will only continue after the ContinueDebugEvent
458 for_each_thread ([&] (thread_info
*thread
)
460 continue_one_thread (thread
, thread_id
);
462 faked_breakpoint
= 0;
464 if (!ContinueDebugEvent (current_event
.dwProcessId
,
465 current_event
.dwThreadId
,
472 /* Fetch register(s) from the current thread context. */
474 child_fetch_inferior_registers (struct regcache
*regcache
, int r
)
477 win32_thread_info
*th
= thread_rec (current_thread_ptid (), TRUE
);
478 if (r
== -1 || r
> NUM_REGS
)
479 child_fetch_inferior_registers (regcache
, NUM_REGS
);
481 for (regno
= 0; regno
< r
; regno
++)
482 (*the_low_target
.fetch_inferior_register
) (regcache
, th
, regno
);
485 /* Store a new register value into the current thread context. We don't
486 change the program's context until later, when we resume it. */
488 child_store_inferior_registers (struct regcache
*regcache
, int r
)
491 win32_thread_info
*th
= thread_rec (current_thread_ptid (), TRUE
);
492 if (r
== -1 || r
== 0 || r
> NUM_REGS
)
493 child_store_inferior_registers (regcache
, NUM_REGS
);
495 for (regno
= 0; regno
< r
; regno
++)
496 (*the_low_target
.store_inferior_register
) (regcache
, th
, regno
);
499 /* Map the Windows error number in ERROR to a locale-dependent error
500 message string and return a pointer to it. Typically, the values
501 for ERROR come from GetLastError.
503 The string pointed to shall not be modified by the application,
504 but may be overwritten by a subsequent call to strwinerror
506 The strwinerror function does not change the current setting
510 strwinerror (DWORD error
)
512 static char buf
[1024];
514 DWORD lasterr
= GetLastError ();
515 DWORD chars
= FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
516 | FORMAT_MESSAGE_ALLOCATE_BUFFER
,
519 0, /* Default language */
525 /* If there is an \r\n appended, zap it. */
527 && msgbuf
[chars
- 2] == '\r'
528 && msgbuf
[chars
- 1] == '\n')
534 if (chars
> ((COUNTOF (buf
)) - 1))
536 chars
= COUNTOF (buf
) - 1;
541 wcstombs (buf
, msgbuf
, chars
+ 1);
543 strncpy (buf
, msgbuf
, chars
+ 1);
548 sprintf (buf
, "unknown win32 error (%u)", (unsigned) error
);
550 SetLastError (lasterr
);
555 create_process (const char *program
, char *args
,
556 DWORD flags
, PROCESS_INFORMATION
*pi
)
558 const char *inferior_cwd
= get_inferior_cwd ();
562 wchar_t *p
, *wprogram
, *wargs
, *wcwd
= NULL
;
565 wprogram
= alloca ((strlen (program
) + 1) * sizeof (wchar_t));
566 mbstowcs (wprogram
, program
, strlen (program
) + 1);
568 for (p
= wprogram
; *p
; ++p
)
572 argslen
= strlen (args
);
573 wargs
= alloca ((argslen
+ 1) * sizeof (wchar_t));
574 mbstowcs (wargs
, args
, argslen
+ 1);
576 if (inferior_cwd
!= NULL
)
578 std::string expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
579 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
581 wcwd
= alloca ((expanded_infcwd
.size () + 1) * sizeof (wchar_t));
582 if (mbstowcs (wcwd
, expanded_infcwd
.c_str (),
583 expanded_infcwd
.size () + 1) == NULL
)
586 Could not convert the expanded inferior cwd to wide-char."));
590 ret
= CreateProcessW (wprogram
, /* image name */
591 wargs
, /* command line */
592 NULL
, /* security, not supported */
593 NULL
, /* thread, not supported */
594 FALSE
, /* inherit handles, not supported */
595 flags
, /* start flags */
596 NULL
, /* environment, not supported */
597 wcwd
, /* current directory */
598 NULL
, /* start info, not supported */
601 STARTUPINFOA si
= { sizeof (STARTUPINFOA
) };
603 ret
= CreateProcessA (program
, /* image name */
604 args
, /* command line */
607 TRUE
, /* inherit handles */
608 flags
, /* start flags */
609 NULL
, /* environment */
610 /* current directory */
611 (inferior_cwd
== NULL
613 : gdb_tilde_expand (inferior_cwd
).c_str()),
614 &si
, /* start info */
621 /* Start a new process.
622 PROGRAM is the program name.
623 PROGRAM_ARGS is the vector containing the inferior's args.
624 Returns the new PID on success, -1 on failure. Registers the new
625 process with the process list. */
627 win32_create_inferior (const char *program
,
628 const std::vector
<char *> &program_args
)
630 client_state
&cs
= get_client_state ();
632 char real_path
[PATH_MAX
];
633 char *orig_path
, *new_path
, *path_ptr
;
639 PROCESS_INFORMATION pi
;
641 std::string str_program_args
= stringify_argv (program_args
);
642 char *args
= (char *) str_program_args
.c_str ();
644 /* win32_wait needs to know we're not attaching. */
648 error ("No executable specified, specify executable to debug.\n");
650 flags
= DEBUG_PROCESS
| DEBUG_ONLY_THIS_PROCESS
;
654 path_ptr
= getenv ("PATH");
657 int size
= cygwin_conv_path_list (CCP_POSIX_TO_WIN_A
, path_ptr
, NULL
, 0);
658 orig_path
= (char *) alloca (strlen (path_ptr
) + 1);
659 new_path
= (char *) alloca (size
);
660 strcpy (orig_path
, path_ptr
);
661 cygwin_conv_path_list (CCP_POSIX_TO_WIN_A
, path_ptr
, new_path
, size
);
662 setenv ("PATH", new_path
, 1);
664 cygwin_conv_path (CCP_POSIX_TO_WIN_A
, program
, real_path
, PATH_MAX
);
668 OUTMSG2 (("Command line is \"%s\"\n", args
));
670 #ifdef CREATE_NEW_PROCESS_GROUP
671 flags
|= CREATE_NEW_PROCESS_GROUP
;
674 ret
= create_process (program
, args
, flags
, &pi
);
675 err
= GetLastError ();
676 if (!ret
&& err
== ERROR_FILE_NOT_FOUND
)
678 char *exename
= (char *) alloca (strlen (program
) + 5);
679 strcat (strcpy (exename
, program
), ".exe");
680 ret
= create_process (exename
, args
, flags
, &pi
);
681 err
= GetLastError ();
686 setenv ("PATH", orig_path
, 1);
691 error ("Error creating process \"%s%s\", (error %d): %s\n",
692 program
, args
, (int) err
, strwinerror (err
));
696 OUTMSG2 (("Process created: %s\n", (char *) args
));
700 /* On Windows CE this handle can't be closed. The OS reuses
701 it in the debug events, while the 9x/NT versions of Windows
702 probably use a DuplicateHandle'd one. */
703 CloseHandle (pi
.hThread
);
706 do_initial_child_stuff (pi
.hProcess
, pi
.dwProcessId
, 0);
708 /* Wait till we are at 1st instruction in program, return new pid
709 (assuming success). */
710 cs
.last_ptid
= win32_wait (ptid_t (current_process_id
), &cs
.last_status
, 0);
712 return current_process_id
;
715 /* Attach to a running process.
716 PID is the process ID to attach to, specified by the user
717 or a higher layer. */
719 win32_attach (unsigned long pid
)
722 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
725 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
727 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
729 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
731 h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
734 if (DebugActiveProcess (pid
))
736 if (DebugSetProcessKillOnExit
!= NULL
)
737 DebugSetProcessKillOnExit (FALSE
);
739 /* win32_wait needs to know we're attaching. */
741 do_initial_child_stuff (h
, pid
, 1);
748 err
= GetLastError ();
749 error ("Attach to process failed (error %d): %s\n",
750 (int) err
, strwinerror (err
));
753 /* Handle OUTPUT_DEBUG_STRING_EVENT from child process. */
755 handle_output_debug_string (void)
757 #define READ_BUFFER_LEN 1024
759 char s
[READ_BUFFER_LEN
+ 1] = { 0 };
760 DWORD nbytes
= current_event
.u
.DebugString
.nDebugStringLength
;
765 if (nbytes
> READ_BUFFER_LEN
)
766 nbytes
= READ_BUFFER_LEN
;
768 addr
= (CORE_ADDR
) (size_t) current_event
.u
.DebugString
.lpDebugStringData
;
770 if (current_event
.u
.DebugString
.fUnicode
)
772 /* The event tells us how many bytes, not chars, even
774 WCHAR buffer
[(READ_BUFFER_LEN
+ 1) / sizeof (WCHAR
)] = { 0 };
775 if (read_inferior_memory (addr
, (unsigned char *) buffer
, nbytes
) != 0)
777 wcstombs (s
, buffer
, (nbytes
+ 1) / sizeof (WCHAR
));
781 if (read_inferior_memory (addr
, (unsigned char *) s
, nbytes
) != 0)
785 if (!startswith (s
, "cYg"))
795 #undef READ_BUFFER_LEN
799 win32_clear_inferiors (void)
801 if (current_process_handle
!= NULL
)
802 CloseHandle (current_process_handle
);
804 for_each_thread (delete_thread_info
);
808 /* Kill all inferiors. */
812 struct process_info
*process
;
814 if (current_process_handle
== NULL
)
817 TerminateProcess (current_process_handle
, 0);
820 if (!child_continue (DBG_CONTINUE
, -1))
822 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
824 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
826 else if (current_event
.dwDebugEventCode
== OUTPUT_DEBUG_STRING_EVENT
)
827 handle_output_debug_string ();
830 win32_clear_inferiors ();
832 process
= find_process_pid (pid
);
833 remove_process (process
);
837 /* Detach from inferior PID. */
839 win32_detach (int pid
)
841 struct process_info
*process
;
842 winapi_DebugActiveProcessStop DebugActiveProcessStop
= NULL
;
843 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
845 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
847 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
849 DebugActiveProcessStop
= GETPROCADDRESS (dll
, DebugActiveProcessStop
);
850 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
852 if (DebugSetProcessKillOnExit
== NULL
853 || DebugActiveProcessStop
== NULL
)
857 struct thread_resume resume
;
858 resume
.thread
= minus_one_ptid
;
859 resume
.kind
= resume_continue
;
861 win32_resume (&resume
, 1);
864 if (!DebugActiveProcessStop (current_process_id
))
867 DebugSetProcessKillOnExit (FALSE
);
868 process
= find_process_pid (pid
);
869 remove_process (process
);
871 win32_clear_inferiors ();
876 win32_mourn (struct process_info
*process
)
878 remove_process (process
);
881 /* Wait for inferiors to end. */
885 HANDLE h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
888 WaitForSingleObject (h
, INFINITE
);
893 /* Return 1 iff the thread with thread ID TID is alive. */
895 win32_thread_alive (ptid_t ptid
)
897 /* Our thread list is reliable; don't bother to poll target
899 return find_thread_ptid (ptid
) != NULL
;
902 /* Resume the inferior process. RESUME_INFO describes how we want
905 win32_resume (struct thread_resume
*resume_info
, size_t n
)
910 win32_thread_info
*th
;
911 DWORD continue_status
= DBG_CONTINUE
;
914 /* This handles the very limited set of resume packets that GDB can
915 currently produce. */
917 if (n
== 1 && resume_info
[0].thread
== minus_one_ptid
)
922 /* Yes, we're ignoring resume_info[0].thread. It'd be tricky to make
923 the Windows resume code do the right thing for thread switching. */
924 tid
= current_event
.dwThreadId
;
926 if (resume_info
[0].thread
!= minus_one_ptid
)
928 sig
= gdb_signal_from_host (resume_info
[0].sig
);
929 step
= resume_info
[0].kind
== resume_step
;
937 if (sig
!= GDB_SIGNAL_0
)
939 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
941 OUTMSG (("Cannot continue with signal %s here.\n",
942 gdb_signal_to_string (sig
)));
944 else if (sig
== last_sig
)
945 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
947 OUTMSG (("Can only continue with received signal %s.\n",
948 gdb_signal_to_string (last_sig
)));
951 last_sig
= GDB_SIGNAL_0
;
953 /* Get context for the currently selected thread. */
954 ptid
= debug_event_ptid (¤t_event
);
955 th
= thread_rec (ptid
, FALSE
);
958 win32_prepare_to_resume (th
);
960 if (th
->context
.ContextFlags
)
962 /* Move register values from the inferior into the thread
963 context structure. */
964 regcache_invalidate ();
968 if (the_low_target
.single_step
!= NULL
)
969 (*the_low_target
.single_step
) (th
);
971 error ("Single stepping is not supported "
972 "in this configuration.\n");
975 win32_set_thread_context (th
);
976 th
->context
.ContextFlags
= 0;
980 /* Allow continuing with the same signal that interrupted us.
981 Otherwise complain. */
983 child_continue (continue_status
, tid
);
987 win32_add_one_solib (const char *name
, CORE_ADDR load_addr
)
989 char buf
[MAX_PATH
+ 1];
990 char buf2
[MAX_PATH
+ 1];
993 WIN32_FIND_DATA w32_fd
;
994 WCHAR wname
[MAX_PATH
+ 1];
995 mbstowcs (wname
, name
, MAX_PATH
);
996 HANDLE h
= FindFirstFile (wname
, &w32_fd
);
998 WIN32_FIND_DATAA w32_fd
;
999 HANDLE h
= FindFirstFileA (name
, &w32_fd
);
1002 /* The symbols in a dll are offset by 0x1000, which is the
1003 offset from 0 of the first byte in an image - because
1004 of the file header and the section alignment. */
1005 load_addr
+= 0x1000;
1007 if (h
== INVALID_HANDLE_VALUE
)
1015 char cwd
[MAX_PATH
+ 1];
1017 if (GetCurrentDirectoryA (MAX_PATH
+ 1, cwd
))
1019 p
= strrchr (buf
, '\\');
1022 SetCurrentDirectoryA (buf
);
1023 GetFullPathNameA (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
1024 SetCurrentDirectoryA (cwd
);
1031 if (strcasecmp (buf
, "ntdll.dll") == 0)
1033 GetSystemDirectoryA (buf
, sizeof (buf
));
1034 strcat (buf
, "\\ntdll.dll");
1039 cygwin_conv_path (CCP_WIN_A_TO_POSIX
, buf
, buf2
, sizeof (buf2
));
1044 loaded_dll (buf2
, load_addr
);
1048 get_image_name (HANDLE h
, void *address
, int unicode
)
1050 static char buf
[(2 * MAX_PATH
) + 1];
1051 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
1057 /* Attempt to read the name of the dll that was detected.
1058 This is documented to work only when actively debugging
1059 a program. It will not work for attached processes. */
1060 if (address
== NULL
)
1064 /* Windows CE reports the address of the image name,
1065 instead of an address of a pointer into the image name. */
1066 address_ptr
= address
;
1068 /* See if we could read the address of a string, and that the
1069 address isn't null. */
1070 if (!ReadProcessMemory (h
, address
, &address_ptr
,
1071 sizeof (address_ptr
), &done
)
1072 || done
!= sizeof (address_ptr
)
1077 /* Find the length of the string */
1078 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
1079 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
1083 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
1086 WCHAR
*unicode_address
= XALLOCAVEC (WCHAR
, len
);
1087 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
1090 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
1096 typedef BOOL (WINAPI
*winapi_EnumProcessModules
) (HANDLE
, HMODULE
*,
1098 typedef BOOL (WINAPI
*winapi_GetModuleInformation
) (HANDLE
, HMODULE
,
1099 LPMODULEINFO
, DWORD
);
1100 typedef DWORD (WINAPI
*winapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
,
1103 static winapi_EnumProcessModules win32_EnumProcessModules
;
1104 static winapi_GetModuleInformation win32_GetModuleInformation
;
1105 static winapi_GetModuleFileNameExA win32_GetModuleFileNameExA
;
1110 static int psapi_loaded
= 0;
1111 static HMODULE dll
= NULL
;
1116 dll
= LoadLibrary (TEXT("psapi.dll"));
1119 win32_EnumProcessModules
=
1120 GETPROCADDRESS (dll
, EnumProcessModules
);
1121 win32_GetModuleInformation
=
1122 GETPROCADDRESS (dll
, GetModuleInformation
);
1123 win32_GetModuleFileNameExA
=
1124 GETPROCADDRESS (dll
, GetModuleFileNameExA
);
1127 return (win32_EnumProcessModules
!= NULL
1128 && win32_GetModuleInformation
!= NULL
1129 && win32_GetModuleFileNameExA
!= NULL
);
1134 /* Iterate over all DLLs currently mapped by our inferior, and
1135 add them to our list of solibs. */
1138 win32_add_all_dlls (void)
1142 HMODULE
*DllHandle
= dh_buf
;
1150 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
1155 if (!ok
|| !cbNeeded
)
1158 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
1162 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
1169 for (i
= 1; i
< ((size_t) cbNeeded
/ sizeof (HMODULE
)); i
++)
1172 char dll_name
[MAX_PATH
];
1174 if (!(*win32_GetModuleInformation
) (current_process_handle
,
1179 if ((*win32_GetModuleFileNameExA
) (current_process_handle
,
1184 win32_add_one_solib (dll_name
, (CORE_ADDR
) (uintptr_t) mi
.lpBaseOfDll
);
1189 typedef HANDLE (WINAPI
*winapi_CreateToolhelp32Snapshot
) (DWORD
, DWORD
);
1190 typedef BOOL (WINAPI
*winapi_Module32First
) (HANDLE
, LPMODULEENTRY32
);
1191 typedef BOOL (WINAPI
*winapi_Module32Next
) (HANDLE
, LPMODULEENTRY32
);
1193 /* Handle a DLL load event.
1195 This function assumes that this event did not occur during inferior
1196 initialization, where their event info may be incomplete (see
1197 do_initial_child_stuff and win32_add_all_dlls for more info on
1198 how we handle DLL loading during that phase). */
1201 handle_load_dll (void)
1203 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
1206 dll_name
= get_image_name (current_process_handle
,
1207 event
->lpImageName
, event
->fUnicode
);
1211 win32_add_one_solib (dll_name
, (CORE_ADDR
) (uintptr_t) event
->lpBaseOfDll
);
1214 /* Handle a DLL unload event.
1216 This function assumes that this event did not occur during inferior
1217 initialization, where their event info may be incomplete (see
1218 do_initial_child_stuff and win32_add_one_solib for more info
1219 on how we handle DLL loading during that phase). */
1222 handle_unload_dll (void)
1224 CORE_ADDR load_addr
=
1225 (CORE_ADDR
) (uintptr_t) current_event
.u
.UnloadDll
.lpBaseOfDll
;
1227 /* The symbols in a dll are offset by 0x1000, which is the
1228 offset from 0 of the first byte in an image - because
1229 of the file header and the section alignment. */
1230 load_addr
+= 0x1000;
1231 unloaded_dll (NULL
, load_addr
);
1235 handle_exception (struct target_waitstatus
*ourstatus
)
1237 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1239 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1243 case EXCEPTION_ACCESS_VIOLATION
:
1244 OUTMSG2 (("EXCEPTION_ACCESS_VIOLATION"));
1245 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1247 case STATUS_STACK_OVERFLOW
:
1248 OUTMSG2 (("STATUS_STACK_OVERFLOW"));
1249 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1251 case STATUS_FLOAT_DENORMAL_OPERAND
:
1252 OUTMSG2 (("STATUS_FLOAT_DENORMAL_OPERAND"));
1253 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1255 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1256 OUTMSG2 (("EXCEPTION_ARRAY_BOUNDS_EXCEEDED"));
1257 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1259 case STATUS_FLOAT_INEXACT_RESULT
:
1260 OUTMSG2 (("STATUS_FLOAT_INEXACT_RESULT"));
1261 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1263 case STATUS_FLOAT_INVALID_OPERATION
:
1264 OUTMSG2 (("STATUS_FLOAT_INVALID_OPERATION"));
1265 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1267 case STATUS_FLOAT_OVERFLOW
:
1268 OUTMSG2 (("STATUS_FLOAT_OVERFLOW"));
1269 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1271 case STATUS_FLOAT_STACK_CHECK
:
1272 OUTMSG2 (("STATUS_FLOAT_STACK_CHECK"));
1273 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1275 case STATUS_FLOAT_UNDERFLOW
:
1276 OUTMSG2 (("STATUS_FLOAT_UNDERFLOW"));
1277 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1279 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1280 OUTMSG2 (("STATUS_FLOAT_DIVIDE_BY_ZERO"));
1281 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1283 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1284 OUTMSG2 (("STATUS_INTEGER_DIVIDE_BY_ZERO"));
1285 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1287 case STATUS_INTEGER_OVERFLOW
:
1288 OUTMSG2 (("STATUS_INTEGER_OVERFLOW"));
1289 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1291 case EXCEPTION_BREAKPOINT
:
1292 OUTMSG2 (("EXCEPTION_BREAKPOINT"));
1293 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1295 /* Remove the initial breakpoint. */
1296 check_breakpoints ((CORE_ADDR
) (long) current_event
1297 .u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1301 OUTMSG2 (("DBG_CONTROL_C"));
1302 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1304 case DBG_CONTROL_BREAK
:
1305 OUTMSG2 (("DBG_CONTROL_BREAK"));
1306 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1308 case EXCEPTION_SINGLE_STEP
:
1309 OUTMSG2 (("EXCEPTION_SINGLE_STEP"));
1310 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1312 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1313 OUTMSG2 (("EXCEPTION_ILLEGAL_INSTRUCTION"));
1314 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1316 case EXCEPTION_PRIV_INSTRUCTION
:
1317 OUTMSG2 (("EXCEPTION_PRIV_INSTRUCTION"));
1318 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1320 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1321 OUTMSG2 (("EXCEPTION_NONCONTINUABLE_EXCEPTION"));
1322 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1325 if (current_event
.u
.Exception
.dwFirstChance
)
1327 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1330 OUTMSG2 (("gdbserver: unknown target exception 0x%08x at 0x%s",
1331 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1332 phex_nz ((uintptr_t) current_event
.u
.Exception
.ExceptionRecord
.
1333 ExceptionAddress
, sizeof (uintptr_t))));
1334 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1338 last_sig
= ourstatus
->value
.sig
;
1343 suspend_one_thread (thread_info
*thread
)
1345 win32_thread_info
*th
= (win32_thread_info
*) thread_target_data (thread
);
1349 if (SuspendThread (th
->h
) == (DWORD
) -1)
1351 DWORD err
= GetLastError ();
1352 OUTMSG (("warning: SuspendThread failed in suspend_one_thread, "
1353 "(error %d): %s\n", (int) err
, strwinerror (err
)));
1361 fake_breakpoint_event (void)
1363 OUTMSG2(("fake_breakpoint_event\n"));
1365 faked_breakpoint
= 1;
1367 memset (¤t_event
, 0, sizeof (current_event
));
1368 current_event
.dwThreadId
= main_thread_id
;
1369 current_event
.dwDebugEventCode
= EXCEPTION_DEBUG_EVENT
;
1370 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1371 = EXCEPTION_BREAKPOINT
;
1373 for_each_thread (suspend_one_thread
);
1378 auto_delete_breakpoint (CORE_ADDR stop_pc
)
1384 /* Get the next event from the child. */
1387 get_child_debug_event (struct target_waitstatus
*ourstatus
)
1391 last_sig
= GDB_SIGNAL_0
;
1392 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1394 /* Check if GDB sent us an interrupt request. */
1395 check_remote_input_interrupt_request ();
1397 if (soft_interrupt_requested
)
1399 soft_interrupt_requested
= 0;
1400 fake_breakpoint_event ();
1409 /* WinCE doesn't set an initial breakpoint automatically. To
1410 stop the inferior, we flush all currently pending debug
1411 events -- the thread list and the dll list are always
1412 reported immediatelly without delay, then, we suspend all
1413 threads and pretend we saw a trap at the current PC of the
1416 Contrary to desktop Windows, Windows CE *does* report the dll
1417 names on LOAD_DLL_DEBUG_EVENTs resulting from a
1418 DebugActiveProcess call. This limits the way we can detect
1419 if all the dlls have already been reported. If we get a real
1420 debug event before leaving attaching, the worst that will
1421 happen is the user will see a spurious breakpoint. */
1423 current_event
.dwDebugEventCode
= 0;
1424 if (!WaitForDebugEvent (¤t_event
, 0))
1426 OUTMSG2(("no attach events left\n"));
1427 fake_breakpoint_event ();
1431 OUTMSG2(("got attach event\n"));
1436 /* Keep the wait time low enough for confortable remote
1437 interruption, but high enough so gdbserver doesn't become a
1439 if (!WaitForDebugEvent (¤t_event
, 250))
1441 DWORD e
= GetLastError();
1443 if (e
== ERROR_PIPE_NOT_CONNECTED
)
1445 /* This will happen if the loader fails to succesfully
1446 load the application, e.g., if the main executable
1447 tries to pull in a non-existing export from a
1449 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1450 ourstatus
->value
.integer
= 1;
1460 switch (current_event
.dwDebugEventCode
)
1462 case CREATE_THREAD_DEBUG_EVENT
:
1463 OUTMSG2 (("gdbserver: kernel event CREATE_THREAD_DEBUG_EVENT "
1464 "for pid=%u tid=%x)\n",
1465 (unsigned) current_event
.dwProcessId
,
1466 (unsigned) current_event
.dwThreadId
));
1468 /* Record the existence of this thread. */
1469 child_add_thread (current_event
.dwProcessId
,
1470 current_event
.dwThreadId
,
1471 current_event
.u
.CreateThread
.hThread
,
1472 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1475 case EXIT_THREAD_DEBUG_EVENT
:
1476 OUTMSG2 (("gdbserver: kernel event EXIT_THREAD_DEBUG_EVENT "
1477 "for pid=%u tid=%x\n",
1478 (unsigned) current_event
.dwProcessId
,
1479 (unsigned) current_event
.dwThreadId
));
1480 child_delete_thread (current_event
.dwProcessId
,
1481 current_event
.dwThreadId
);
1483 current_thread
= get_first_thread ();
1486 case CREATE_PROCESS_DEBUG_EVENT
:
1487 OUTMSG2 (("gdbserver: kernel event CREATE_PROCESS_DEBUG_EVENT "
1488 "for pid=%u tid=%x\n",
1489 (unsigned) current_event
.dwProcessId
,
1490 (unsigned) current_event
.dwThreadId
));
1491 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1493 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1494 main_thread_id
= current_event
.dwThreadId
;
1496 /* Add the main thread. */
1497 child_add_thread (current_event
.dwProcessId
,
1499 current_event
.u
.CreateProcessInfo
.hThread
,
1500 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
);
1505 /* Windows CE doesn't set the initial breakpoint
1506 automatically like the desktop versions of Windows do.
1507 We add it explicitly here. It will be removed as soon as
1509 set_breakpoint_at ((CORE_ADDR
) (long) current_event
.u
1510 .CreateProcessInfo
.lpStartAddress
,
1511 auto_delete_breakpoint
);
1516 case EXIT_PROCESS_DEBUG_EVENT
:
1517 OUTMSG2 (("gdbserver: kernel event EXIT_PROCESS_DEBUG_EVENT "
1518 "for pid=%u tid=%x\n",
1519 (unsigned) current_event
.dwProcessId
,
1520 (unsigned) current_event
.dwThreadId
));
1521 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1522 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1523 child_continue (DBG_CONTINUE
, -1);
1524 CloseHandle (current_process_handle
);
1525 current_process_handle
= NULL
;
1528 case LOAD_DLL_DEBUG_EVENT
:
1529 OUTMSG2 (("gdbserver: kernel event LOAD_DLL_DEBUG_EVENT "
1530 "for pid=%u tid=%x\n",
1531 (unsigned) current_event
.dwProcessId
,
1532 (unsigned) current_event
.dwThreadId
));
1533 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1534 if (! child_initialization_done
)
1538 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1539 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1542 case UNLOAD_DLL_DEBUG_EVENT
:
1543 OUTMSG2 (("gdbserver: kernel event UNLOAD_DLL_DEBUG_EVENT "
1544 "for pid=%u tid=%x\n",
1545 (unsigned) current_event
.dwProcessId
,
1546 (unsigned) current_event
.dwThreadId
));
1547 if (! child_initialization_done
)
1549 handle_unload_dll ();
1550 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1551 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1554 case EXCEPTION_DEBUG_EVENT
:
1555 OUTMSG2 (("gdbserver: kernel event EXCEPTION_DEBUG_EVENT "
1556 "for pid=%u tid=%x\n",
1557 (unsigned) current_event
.dwProcessId
,
1558 (unsigned) current_event
.dwThreadId
));
1559 handle_exception (ourstatus
);
1562 case OUTPUT_DEBUG_STRING_EVENT
:
1563 /* A message from the kernel (or Cygwin). */
1564 OUTMSG2 (("gdbserver: kernel event OUTPUT_DEBUG_STRING_EVENT "
1565 "for pid=%u tid=%x\n",
1566 (unsigned) current_event
.dwProcessId
,
1567 (unsigned) current_event
.dwThreadId
));
1568 handle_output_debug_string ();
1572 OUTMSG2 (("gdbserver: kernel event unknown "
1573 "for pid=%u tid=%x code=%x\n",
1574 (unsigned) current_event
.dwProcessId
,
1575 (unsigned) current_event
.dwThreadId
,
1576 (unsigned) current_event
.dwDebugEventCode
));
1580 ptid
= debug_event_ptid (¤t_event
);
1581 current_thread
= find_thread_ptid (ptid
);
1585 /* Wait for the inferior process to change state.
1586 STATUS will be filled in with a response code to send to GDB.
1587 Returns the signal which caused the process to stop. */
1589 win32_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
1591 struct regcache
*regcache
;
1593 if (cached_status
.kind
!= TARGET_WAITKIND_IGNORE
)
1595 /* The core always does a wait after creating the inferior, and
1596 do_initial_child_stuff already ran the inferior to the
1597 initial breakpoint (or an exit, if creating the process
1598 fails). Report it now. */
1599 *ourstatus
= cached_status
;
1600 cached_status
.kind
= TARGET_WAITKIND_IGNORE
;
1601 return debug_event_ptid (¤t_event
);
1606 if (!get_child_debug_event (ourstatus
))
1609 switch (ourstatus
->kind
)
1611 case TARGET_WAITKIND_EXITED
:
1612 OUTMSG2 (("Child exited with retcode = %x\n",
1613 ourstatus
->value
.integer
));
1614 win32_clear_inferiors ();
1615 return ptid_t (current_event
.dwProcessId
);
1616 case TARGET_WAITKIND_STOPPED
:
1617 case TARGET_WAITKIND_LOADED
:
1618 OUTMSG2 (("Child Stopped with signal = %d \n",
1619 ourstatus
->value
.sig
));
1621 regcache
= get_thread_regcache (current_thread
, 1);
1622 child_fetch_inferior_registers (regcache
, -1);
1623 return debug_event_ptid (¤t_event
);
1625 OUTMSG (("Ignoring unknown internal event, %d\n", ourstatus
->kind
));
1627 case TARGET_WAITKIND_SPURIOUS
:
1628 /* do nothing, just continue */
1629 child_continue (DBG_CONTINUE
, -1);
1635 /* Fetch registers from the inferior process.
1636 If REGNO is -1, fetch all registers; otherwise, fetch at least REGNO. */
1638 win32_fetch_inferior_registers (struct regcache
*regcache
, int regno
)
1640 child_fetch_inferior_registers (regcache
, regno
);
1643 /* Store registers to the inferior process.
1644 If REGNO is -1, store all registers; otherwise, store at least REGNO. */
1646 win32_store_inferior_registers (struct regcache
*regcache
, int regno
)
1648 child_store_inferior_registers (regcache
, regno
);
1651 /* Read memory from the inferior process. This should generally be
1652 called through read_inferior_memory, which handles breakpoint shadowing.
1653 Read LEN bytes at MEMADDR into a buffer at MYADDR. */
1655 win32_read_inferior_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
1657 return child_xfer_memory (memaddr
, (char *) myaddr
, len
, 0, 0) != len
;
1660 /* Write memory to the inferior process. This should generally be
1661 called through write_inferior_memory, which handles breakpoint shadowing.
1662 Write LEN bytes from the buffer at MYADDR to MEMADDR.
1663 Returns 0 on success and errno on failure. */
1665 win32_write_inferior_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
,
1668 return child_xfer_memory (memaddr
, (char *) myaddr
, len
, 1, 0) != len
;
1671 /* Send an interrupt request to the inferior process. */
1673 win32_request_interrupt (void)
1675 winapi_DebugBreakProcess DebugBreakProcess
;
1676 winapi_GenerateConsoleCtrlEvent GenerateConsoleCtrlEvent
;
1679 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
1681 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
1684 GenerateConsoleCtrlEvent
= GETPROCADDRESS (dll
, GenerateConsoleCtrlEvent
);
1686 if (GenerateConsoleCtrlEvent
!= NULL
1687 && GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, current_process_id
))
1690 /* GenerateConsoleCtrlEvent can fail if process id being debugged is
1691 not a process group id.
1692 Fallback to XP/Vista 'DebugBreakProcess', which generates a
1693 breakpoint exception in the interior process. */
1695 DebugBreakProcess
= GETPROCADDRESS (dll
, DebugBreakProcess
);
1697 if (DebugBreakProcess
!= NULL
1698 && DebugBreakProcess (current_process_handle
))
1701 /* Last resort, suspend all threads manually. */
1702 soft_interrupt_requested
= 1;
1707 win32_error_to_fileio_error (DWORD err
)
1711 case ERROR_BAD_PATHNAME
:
1712 case ERROR_FILE_NOT_FOUND
:
1713 case ERROR_INVALID_NAME
:
1714 case ERROR_PATH_NOT_FOUND
:
1715 return FILEIO_ENOENT
;
1717 case ERROR_IO_DEVICE
:
1718 case ERROR_OPEN_FAILED
:
1720 case ERROR_INVALID_HANDLE
:
1721 return FILEIO_EBADF
;
1722 case ERROR_ACCESS_DENIED
:
1723 case ERROR_SHARING_VIOLATION
:
1724 return FILEIO_EACCES
;
1725 case ERROR_NOACCESS
:
1726 return FILEIO_EFAULT
;
1728 return FILEIO_EBUSY
;
1729 case ERROR_ALREADY_EXISTS
:
1730 case ERROR_FILE_EXISTS
:
1731 return FILEIO_EEXIST
;
1732 case ERROR_BAD_DEVICE
:
1733 return FILEIO_ENODEV
;
1734 case ERROR_DIRECTORY
:
1735 return FILEIO_ENOTDIR
;
1736 case ERROR_FILENAME_EXCED_RANGE
:
1737 case ERROR_INVALID_DATA
:
1738 case ERROR_INVALID_PARAMETER
:
1739 case ERROR_NEGATIVE_SEEK
:
1740 return FILEIO_EINVAL
;
1741 case ERROR_TOO_MANY_OPEN_FILES
:
1742 return FILEIO_EMFILE
;
1743 case ERROR_HANDLE_DISK_FULL
:
1744 case ERROR_DISK_FULL
:
1745 return FILEIO_ENOSPC
;
1746 case ERROR_WRITE_PROTECT
:
1747 return FILEIO_EROFS
;
1748 case ERROR_NOT_SUPPORTED
:
1749 return FILEIO_ENOSYS
;
1752 return FILEIO_EUNKNOWN
;
1756 wince_hostio_last_error (char *buf
)
1758 DWORD winerr
= GetLastError ();
1759 int fileio_err
= win32_error_to_fileio_error (winerr
);
1760 sprintf (buf
, "F-1,%x", fileio_err
);
1764 /* Write Windows OS Thread Information Block address. */
1767 win32_get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
1769 win32_thread_info
*th
;
1770 th
= thread_rec (ptid
, 0);
1774 *addr
= th
->thread_local_base
;
1778 /* Implementation of the target_ops method "sw_breakpoint_from_kind". */
1780 static const gdb_byte
*
1781 win32_sw_breakpoint_from_kind (int kind
, int *size
)
1783 *size
= the_low_target
.breakpoint_len
;
1784 return the_low_target
.breakpoint
;
1787 static struct target_ops win32_target_ops
= {
1788 win32_create_inferior
,
1789 NULL
, /* post_create_inferior */
1798 win32_fetch_inferior_registers
,
1799 win32_store_inferior_registers
,
1800 NULL
, /* prepare_to_access_memory */
1801 NULL
, /* done_accessing_memory */
1802 win32_read_inferior_memory
,
1803 win32_write_inferior_memory
,
1804 NULL
, /* lookup_symbols */
1805 win32_request_interrupt
,
1806 NULL
, /* read_auxv */
1807 win32_supports_z_point_type
,
1810 NULL
, /* stopped_by_sw_breakpoint */
1811 NULL
, /* supports_stopped_by_sw_breakpoint */
1812 NULL
, /* stopped_by_hw_breakpoint */
1813 NULL
, /* supports_stopped_by_hw_breakpoint */
1814 target_can_do_hardware_single_step
,
1815 win32_stopped_by_watchpoint
,
1816 win32_stopped_data_address
,
1817 NULL
, /* read_offsets */
1818 NULL
, /* get_tls_address */
1819 NULL
, /* qxfer_spu */
1821 wince_hostio_last_error
,
1823 hostio_last_error_from_errno
,
1825 NULL
, /* qxfer_osdata */
1826 NULL
, /* qxfer_siginfo */
1827 NULL
, /* supports_non_stop */
1829 NULL
, /* start_non_stop */
1830 NULL
, /* supports_multi_process */
1831 NULL
, /* supports_fork_events */
1832 NULL
, /* supports_vfork_events */
1833 NULL
, /* supports_exec_events */
1834 NULL
, /* handle_new_gdb_connection */
1835 NULL
, /* handle_monitor_command */
1836 NULL
, /* core_of_thread */
1837 NULL
, /* read_loadmap */
1838 NULL
, /* process_qsupported */
1839 NULL
, /* supports_tracepoints */
1841 NULL
, /* write_pc */
1842 NULL
, /* thread_stopped */
1843 win32_get_tib_address
,
1844 NULL
, /* pause_all */
1845 NULL
, /* unpause_all */
1846 NULL
, /* stabilize_threads */
1847 NULL
, /* install_fast_tracepoint_jump_pad */
1848 NULL
, /* emit_ops */
1849 NULL
, /* supports_disable_randomization */
1850 NULL
, /* get_min_fast_tracepoint_insn_len */
1851 NULL
, /* qxfer_libraries_svr4 */
1852 NULL
, /* support_agent */
1853 NULL
, /* enable_btrace */
1854 NULL
, /* disable_btrace */
1855 NULL
, /* read_btrace */
1856 NULL
, /* read_btrace_conf */
1857 NULL
, /* supports_range_stepping */
1858 NULL
, /* pid_to_exec_file */
1859 NULL
, /* multifs_open */
1860 NULL
, /* multifs_unlink */
1861 NULL
, /* multifs_readlink */
1862 NULL
, /* breakpoint_kind_from_pc */
1863 win32_sw_breakpoint_from_kind
,
1866 /* Initialize the Win32 backend. */
1868 initialize_low (void)
1870 set_target_ops (&win32_target_ops
);
1871 the_low_target
.arch_setup ();