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"
37 #include <sys/cygwin.h>
40 #define OUTMSG(X) do { printf X; fflush (stderr); } while (0)
53 #define _T(x) TEXT (x)
57 #define COUNTOF(STR) (sizeof (STR) / sizeof ((STR)[0]))
61 # define GETPROCADDRESS(DLL, PROC) \
62 ((winapi_ ## PROC) GetProcAddress (DLL, TEXT (#PROC)))
64 # define GETPROCADDRESS(DLL, PROC) \
65 ((winapi_ ## PROC) GetProcAddress (DLL, #PROC))
68 int using_threads
= 1;
71 static int attaching
= 0;
72 static HANDLE current_process_handle
= NULL
;
73 static DWORD current_process_id
= 0;
74 static DWORD main_thread_id
= 0;
75 static enum gdb_signal last_sig
= GDB_SIGNAL_0
;
77 /* The current debug event from WaitForDebugEvent. */
78 static DEBUG_EVENT current_event
;
80 /* A status that hasn't been reported to the core yet, and so
81 win32_wait should return it next, instead of fetching the next
82 debug event off the win32 API. */
83 static struct target_waitstatus cached_status
;
85 /* Non zero if an interrupt request is to be satisfied by suspending
87 static int soft_interrupt_requested
= 0;
89 /* Non zero if the inferior is stopped in a simulated breakpoint done
90 by suspending all the threads. */
91 static int faked_breakpoint
= 0;
93 const struct target_desc
*win32_tdesc
;
95 #define NUM_REGS (the_low_target.num_regs)
97 typedef BOOL (WINAPI
*winapi_DebugActiveProcessStop
) (DWORD dwProcessId
);
98 typedef BOOL (WINAPI
*winapi_DebugSetProcessKillOnExit
) (BOOL KillOnExit
);
99 typedef BOOL (WINAPI
*winapi_DebugBreakProcess
) (HANDLE
);
100 typedef BOOL (WINAPI
*winapi_GenerateConsoleCtrlEvent
) (DWORD
, DWORD
);
102 static ptid_t
win32_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
104 static void win32_resume (struct thread_resume
*resume_info
, size_t n
);
106 static void win32_add_all_dlls (void);
109 /* Get the thread ID from the current selected inferior (the current
112 current_thread_ptid (void)
117 /* The current debug event from WaitForDebugEvent. */
119 debug_event_ptid (DEBUG_EVENT
*event
)
121 return ptid_build (event
->dwProcessId
, event
->dwThreadId
, 0);
124 /* Get the thread context of the thread associated with TH. */
127 win32_get_thread_context (win32_thread_info
*th
)
129 memset (&th
->context
, 0, sizeof (CONTEXT
));
130 (*the_low_target
.get_thread_context
) (th
);
132 memcpy (&th
->base_context
, &th
->context
, sizeof (CONTEXT
));
136 /* Set the thread context of the thread associated with TH. */
139 win32_set_thread_context (win32_thread_info
*th
)
142 /* Calling SuspendThread on a thread that is running kernel code
143 will report that the suspending was successful, but in fact, that
144 will often not be true. In those cases, the context returned by
145 GetThreadContext will not be correct by the time the thread
146 stops, hence we can't set that context back into the thread when
147 resuming - it will most likelly crash the inferior.
148 Unfortunately, there is no way to know when the thread will
149 really stop. To work around it, we'll only write the context
150 back to the thread when either the user or GDB explicitly change
151 it between stopping and resuming. */
152 if (memcmp (&th
->context
, &th
->base_context
, sizeof (CONTEXT
)) != 0)
154 SetThreadContext (th
->h
, &th
->context
);
157 /* Set the thread context of the thread associated with TH. */
160 win32_prepare_to_resume (win32_thread_info
*th
)
162 if (the_low_target
.prepare_to_resume
!= NULL
)
163 (*the_low_target
.prepare_to_resume
) (th
);
166 /* See win32-low.h. */
169 win32_require_context (win32_thread_info
*th
)
171 if (th
->context
.ContextFlags
== 0)
175 if (SuspendThread (th
->h
) == (DWORD
) -1)
177 DWORD err
= GetLastError ();
178 OUTMSG (("warning: SuspendThread failed in thread_rec, "
179 "(error %d): %s\n", (int) err
, strwinerror (err
)));
185 win32_get_thread_context (th
);
189 /* Find a thread record given a thread id. If GET_CONTEXT is set then
190 also retrieve the context for this thread. */
191 static win32_thread_info
*
192 thread_rec (ptid_t ptid
, int get_context
)
194 struct thread_info
*thread
;
195 win32_thread_info
*th
;
197 thread
= (struct thread_info
*) find_inferior_id (&all_threads
, ptid
);
201 th
= (win32_thread_info
*) thread_target_data (thread
);
203 win32_require_context (th
);
207 /* Add a thread to the thread list. */
208 static win32_thread_info
*
209 child_add_thread (DWORD pid
, DWORD tid
, HANDLE h
, void *tlb
)
211 win32_thread_info
*th
;
212 ptid_t ptid
= ptid_build (pid
, tid
, 0);
214 if ((th
= thread_rec (ptid
, FALSE
)))
217 th
= XCNEW (win32_thread_info
);
220 th
->thread_local_base
= (CORE_ADDR
) (uintptr_t) tlb
;
222 add_thread (ptid
, th
);
224 if (the_low_target
.thread_added
!= NULL
)
225 (*the_low_target
.thread_added
) (th
);
230 /* Delete a thread from the list of threads. */
232 delete_thread_info (struct inferior_list_entry
*entry
)
234 struct thread_info
*thread
= (struct thread_info
*) entry
;
235 win32_thread_info
*th
= (win32_thread_info
*) thread_target_data (thread
);
237 remove_thread (thread
);
242 /* Delete a thread from the list of threads. */
244 child_delete_thread (DWORD pid
, DWORD tid
)
246 struct inferior_list_entry
*thread
;
249 /* If the last thread is exiting, just return. */
250 if (one_inferior_p (&all_threads
))
253 ptid
= ptid_build (pid
, tid
, 0);
254 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 (struct inferior_list_entry
*this_thread
, void *id_ptr
)
434 struct thread_info
*thread
= (struct thread_info
*) this_thread
;
435 int thread_id
= * (int *) id_ptr
;
436 win32_thread_info
*th
= (win32_thread_info
*) thread_target_data (thread
);
438 if (thread_id
== -1 || thread_id
== th
->tid
)
440 win32_prepare_to_resume (th
);
444 if (th
->context
.ContextFlags
)
446 win32_set_thread_context (th
);
447 th
->context
.ContextFlags
= 0;
450 if (ResumeThread (th
->h
) == (DWORD
) -1)
452 DWORD err
= GetLastError ();
453 OUTMSG (("warning: ResumeThread failed in continue_one_thread, "
454 "(error %d): %s\n", (int) err
, strwinerror (err
)));
464 child_continue (DWORD continue_status
, int thread_id
)
466 /* The inferior will only continue after the ContinueDebugEvent
468 find_inferior (&all_threads
, continue_one_thread
, &thread_id
);
469 faked_breakpoint
= 0;
471 if (!ContinueDebugEvent (current_event
.dwProcessId
,
472 current_event
.dwThreadId
,
479 /* Fetch register(s) from the current thread context. */
481 child_fetch_inferior_registers (struct regcache
*regcache
, int r
)
484 win32_thread_info
*th
= thread_rec (current_thread_ptid (), TRUE
);
485 if (r
== -1 || r
> NUM_REGS
)
486 child_fetch_inferior_registers (regcache
, NUM_REGS
);
488 for (regno
= 0; regno
< r
; regno
++)
489 (*the_low_target
.fetch_inferior_register
) (regcache
, th
, regno
);
492 /* Store a new register value into the current thread context. We don't
493 change the program's context until later, when we resume it. */
495 child_store_inferior_registers (struct regcache
*regcache
, int r
)
498 win32_thread_info
*th
= thread_rec (current_thread_ptid (), TRUE
);
499 if (r
== -1 || r
== 0 || r
> NUM_REGS
)
500 child_store_inferior_registers (regcache
, NUM_REGS
);
502 for (regno
= 0; regno
< r
; regno
++)
503 (*the_low_target
.store_inferior_register
) (regcache
, th
, regno
);
506 /* Map the Windows error number in ERROR to a locale-dependent error
507 message string and return a pointer to it. Typically, the values
508 for ERROR come from GetLastError.
510 The string pointed to shall not be modified by the application,
511 but may be overwritten by a subsequent call to strwinerror
513 The strwinerror function does not change the current setting
517 strwinerror (DWORD error
)
519 static char buf
[1024];
521 DWORD lasterr
= GetLastError ();
522 DWORD chars
= FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
523 | FORMAT_MESSAGE_ALLOCATE_BUFFER
,
526 0, /* Default language */
532 /* If there is an \r\n appended, zap it. */
534 && msgbuf
[chars
- 2] == '\r'
535 && msgbuf
[chars
- 1] == '\n')
541 if (chars
> ((COUNTOF (buf
)) - 1))
543 chars
= COUNTOF (buf
) - 1;
548 wcstombs (buf
, msgbuf
, chars
+ 1);
550 strncpy (buf
, msgbuf
, chars
+ 1);
555 sprintf (buf
, "unknown win32 error (%u)", (unsigned) error
);
557 SetLastError (lasterr
);
562 create_process (const char *program
, char *args
,
563 DWORD flags
, PROCESS_INFORMATION
*pi
)
568 wchar_t *p
, *wprogram
, *wargs
;
571 wprogram
= alloca ((strlen (program
) + 1) * sizeof (wchar_t));
572 mbstowcs (wprogram
, program
, strlen (program
) + 1);
574 for (p
= wprogram
; *p
; ++p
)
578 argslen
= strlen (args
);
579 wargs
= alloca ((argslen
+ 1) * sizeof (wchar_t));
580 mbstowcs (wargs
, args
, argslen
+ 1);
582 ret
= CreateProcessW (wprogram
, /* image name */
583 wargs
, /* command line */
584 NULL
, /* security, not supported */
585 NULL
, /* thread, not supported */
586 FALSE
, /* inherit handles, not supported */
587 flags
, /* start flags */
588 NULL
, /* environment, not supported */
589 NULL
, /* current directory, not supported */
590 NULL
, /* start info, not supported */
593 STARTUPINFOA si
= { sizeof (STARTUPINFOA
) };
595 ret
= CreateProcessA (program
, /* image name */
596 args
, /* command line */
599 TRUE
, /* inherit handles */
600 flags
, /* start flags */
601 NULL
, /* environment */
602 NULL
, /* current directory */
603 &si
, /* start info */
610 /* Start a new process.
611 PROGRAM is the program name.
612 PROGRAM_ARGS is the vector containing the inferior's args.
613 Returns the new PID on success, -1 on failure. Registers the new
614 process with the process list. */
616 win32_create_inferior (const char *program
,
617 const std::vector
<char *> &program_args
)
620 char real_path
[PATH_MAX
];
621 char *orig_path
, *new_path
, *path_ptr
;
627 PROCESS_INFORMATION pi
;
629 std::string str_program_args
= stringify_argv (program_args
);
630 char *args
= (char *) str_program_args
.c_str ();
632 /* win32_wait needs to know we're not attaching. */
636 error ("No executable specified, specify executable to debug.\n");
638 flags
= DEBUG_PROCESS
| DEBUG_ONLY_THIS_PROCESS
;
642 path_ptr
= getenv ("PATH");
645 int size
= cygwin_conv_path_list (CCP_POSIX_TO_WIN_A
, path_ptr
, NULL
, 0);
646 orig_path
= (char *) alloca (strlen (path_ptr
) + 1);
647 new_path
= (char *) alloca (size
);
648 strcpy (orig_path
, path_ptr
);
649 cygwin_conv_path_list (CCP_POSIX_TO_WIN_A
, path_ptr
, new_path
, size
);
650 setenv ("PATH", new_path
, 1);
652 cygwin_conv_path (CCP_POSIX_TO_WIN_A
, program
, real_path
, PATH_MAX
);
656 OUTMSG2 (("Command line is \"%s\"\n", args
));
658 #ifdef CREATE_NEW_PROCESS_GROUP
659 flags
|= CREATE_NEW_PROCESS_GROUP
;
662 ret
= create_process (program
, args
, flags
, &pi
);
663 err
= GetLastError ();
664 if (!ret
&& err
== ERROR_FILE_NOT_FOUND
)
666 char *exename
= (char *) alloca (strlen (program
) + 5);
667 strcat (strcpy (exename
, program
), ".exe");
668 ret
= create_process (exename
, args
, flags
, &pi
);
669 err
= GetLastError ();
674 setenv ("PATH", orig_path
, 1);
679 error ("Error creating process \"%s%s\", (error %d): %s\n",
680 program
, args
, (int) err
, strwinerror (err
));
684 OUTMSG2 (("Process created: %s\n", (char *) args
));
688 /* On Windows CE this handle can't be closed. The OS reuses
689 it in the debug events, while the 9x/NT versions of Windows
690 probably use a DuplicateHandle'd one. */
691 CloseHandle (pi
.hThread
);
694 do_initial_child_stuff (pi
.hProcess
, pi
.dwProcessId
, 0);
696 return current_process_id
;
699 /* Attach to a running process.
700 PID is the process ID to attach to, specified by the user
701 or a higher layer. */
703 win32_attach (unsigned long pid
)
706 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
709 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
711 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
713 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
715 h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
718 if (DebugActiveProcess (pid
))
720 if (DebugSetProcessKillOnExit
!= NULL
)
721 DebugSetProcessKillOnExit (FALSE
);
723 /* win32_wait needs to know we're attaching. */
725 do_initial_child_stuff (h
, pid
, 1);
732 err
= GetLastError ();
733 error ("Attach to process failed (error %d): %s\n",
734 (int) err
, strwinerror (err
));
737 /* Handle OUTPUT_DEBUG_STRING_EVENT from child process. */
739 handle_output_debug_string (void)
741 #define READ_BUFFER_LEN 1024
743 char s
[READ_BUFFER_LEN
+ 1] = { 0 };
744 DWORD nbytes
= current_event
.u
.DebugString
.nDebugStringLength
;
749 if (nbytes
> READ_BUFFER_LEN
)
750 nbytes
= READ_BUFFER_LEN
;
752 addr
= (CORE_ADDR
) (size_t) current_event
.u
.DebugString
.lpDebugStringData
;
754 if (current_event
.u
.DebugString
.fUnicode
)
756 /* The event tells us how many bytes, not chars, even
758 WCHAR buffer
[(READ_BUFFER_LEN
+ 1) / sizeof (WCHAR
)] = { 0 };
759 if (read_inferior_memory (addr
, (unsigned char *) buffer
, nbytes
) != 0)
761 wcstombs (s
, buffer
, (nbytes
+ 1) / sizeof (WCHAR
));
765 if (read_inferior_memory (addr
, (unsigned char *) s
, nbytes
) != 0)
769 if (!startswith (s
, "cYg"))
779 #undef READ_BUFFER_LEN
783 win32_clear_inferiors (void)
785 if (current_process_handle
!= NULL
)
786 CloseHandle (current_process_handle
);
788 for_each_inferior (&all_threads
, delete_thread_info
);
792 /* Kill all inferiors. */
796 struct process_info
*process
;
798 if (current_process_handle
== NULL
)
801 TerminateProcess (current_process_handle
, 0);
804 if (!child_continue (DBG_CONTINUE
, -1))
806 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
808 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
810 else if (current_event
.dwDebugEventCode
== OUTPUT_DEBUG_STRING_EVENT
)
811 handle_output_debug_string ();
814 win32_clear_inferiors ();
816 process
= find_process_pid (pid
);
817 remove_process (process
);
821 /* Detach from inferior PID. */
823 win32_detach (int pid
)
825 struct process_info
*process
;
826 winapi_DebugActiveProcessStop DebugActiveProcessStop
= NULL
;
827 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
829 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
831 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
833 DebugActiveProcessStop
= GETPROCADDRESS (dll
, DebugActiveProcessStop
);
834 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
836 if (DebugSetProcessKillOnExit
== NULL
837 || DebugActiveProcessStop
== NULL
)
841 struct thread_resume resume
;
842 resume
.thread
= minus_one_ptid
;
843 resume
.kind
= resume_continue
;
845 win32_resume (&resume
, 1);
848 if (!DebugActiveProcessStop (current_process_id
))
851 DebugSetProcessKillOnExit (FALSE
);
852 process
= find_process_pid (pid
);
853 remove_process (process
);
855 win32_clear_inferiors ();
860 win32_mourn (struct process_info
*process
)
862 remove_process (process
);
865 /* Wait for inferiors to end. */
869 HANDLE h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
872 WaitForSingleObject (h
, INFINITE
);
877 /* Return 1 iff the thread with thread ID TID is alive. */
879 win32_thread_alive (ptid_t ptid
)
883 /* Our thread list is reliable; don't bother to poll target
885 if (find_inferior_id (&all_threads
, ptid
) != NULL
)
892 /* Resume the inferior process. RESUME_INFO describes how we want
895 win32_resume (struct thread_resume
*resume_info
, size_t n
)
900 win32_thread_info
*th
;
901 DWORD continue_status
= DBG_CONTINUE
;
904 /* This handles the very limited set of resume packets that GDB can
905 currently produce. */
907 if (n
== 1 && ptid_equal (resume_info
[0].thread
, minus_one_ptid
))
912 /* Yes, we're ignoring resume_info[0].thread. It'd be tricky to make
913 the Windows resume code do the right thing for thread switching. */
914 tid
= current_event
.dwThreadId
;
916 if (!ptid_equal (resume_info
[0].thread
, minus_one_ptid
))
918 sig
= gdb_signal_from_host (resume_info
[0].sig
);
919 step
= resume_info
[0].kind
== resume_step
;
927 if (sig
!= GDB_SIGNAL_0
)
929 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
931 OUTMSG (("Cannot continue with signal %s here.\n",
932 gdb_signal_to_string (sig
)));
934 else if (sig
== last_sig
)
935 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
937 OUTMSG (("Can only continue with received signal %s.\n",
938 gdb_signal_to_string (last_sig
)));
941 last_sig
= GDB_SIGNAL_0
;
943 /* Get context for the currently selected thread. */
944 ptid
= debug_event_ptid (¤t_event
);
945 th
= thread_rec (ptid
, FALSE
);
948 win32_prepare_to_resume (th
);
950 if (th
->context
.ContextFlags
)
952 /* Move register values from the inferior into the thread
953 context structure. */
954 regcache_invalidate ();
958 if (the_low_target
.single_step
!= NULL
)
959 (*the_low_target
.single_step
) (th
);
961 error ("Single stepping is not supported "
962 "in this configuration.\n");
965 win32_set_thread_context (th
);
966 th
->context
.ContextFlags
= 0;
970 /* Allow continuing with the same signal that interrupted us.
971 Otherwise complain. */
973 child_continue (continue_status
, tid
);
977 win32_add_one_solib (const char *name
, CORE_ADDR load_addr
)
979 char buf
[MAX_PATH
+ 1];
980 char buf2
[MAX_PATH
+ 1];
983 WIN32_FIND_DATA w32_fd
;
984 WCHAR wname
[MAX_PATH
+ 1];
985 mbstowcs (wname
, name
, MAX_PATH
);
986 HANDLE h
= FindFirstFile (wname
, &w32_fd
);
988 WIN32_FIND_DATAA w32_fd
;
989 HANDLE h
= FindFirstFileA (name
, &w32_fd
);
992 /* The symbols in a dll are offset by 0x1000, which is the
993 offset from 0 of the first byte in an image - because
994 of the file header and the section alignment. */
997 if (h
== INVALID_HANDLE_VALUE
)
1005 char cwd
[MAX_PATH
+ 1];
1007 if (GetCurrentDirectoryA (MAX_PATH
+ 1, cwd
))
1009 p
= strrchr (buf
, '\\');
1012 SetCurrentDirectoryA (buf
);
1013 GetFullPathNameA (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
1014 SetCurrentDirectoryA (cwd
);
1021 if (strcasecmp (buf
, "ntdll.dll") == 0)
1023 GetSystemDirectoryA (buf
, sizeof (buf
));
1024 strcat (buf
, "\\ntdll.dll");
1029 cygwin_conv_path (CCP_WIN_A_TO_POSIX
, buf
, buf2
, sizeof (buf2
));
1034 loaded_dll (buf2
, load_addr
);
1038 get_image_name (HANDLE h
, void *address
, int unicode
)
1040 static char buf
[(2 * MAX_PATH
) + 1];
1041 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
1047 /* Attempt to read the name of the dll that was detected.
1048 This is documented to work only when actively debugging
1049 a program. It will not work for attached processes. */
1050 if (address
== NULL
)
1054 /* Windows CE reports the address of the image name,
1055 instead of an address of a pointer into the image name. */
1056 address_ptr
= address
;
1058 /* See if we could read the address of a string, and that the
1059 address isn't null. */
1060 if (!ReadProcessMemory (h
, address
, &address_ptr
,
1061 sizeof (address_ptr
), &done
)
1062 || done
!= sizeof (address_ptr
)
1067 /* Find the length of the string */
1068 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
1069 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
1073 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
1076 WCHAR
*unicode_address
= XALLOCAVEC (WCHAR
, len
);
1077 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
1080 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
1086 typedef BOOL (WINAPI
*winapi_EnumProcessModules
) (HANDLE
, HMODULE
*,
1088 typedef BOOL (WINAPI
*winapi_GetModuleInformation
) (HANDLE
, HMODULE
,
1089 LPMODULEINFO
, DWORD
);
1090 typedef DWORD (WINAPI
*winapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
,
1093 static winapi_EnumProcessModules win32_EnumProcessModules
;
1094 static winapi_GetModuleInformation win32_GetModuleInformation
;
1095 static winapi_GetModuleFileNameExA win32_GetModuleFileNameExA
;
1100 static int psapi_loaded
= 0;
1101 static HMODULE dll
= NULL
;
1106 dll
= LoadLibrary (TEXT("psapi.dll"));
1109 win32_EnumProcessModules
=
1110 GETPROCADDRESS (dll
, EnumProcessModules
);
1111 win32_GetModuleInformation
=
1112 GETPROCADDRESS (dll
, GetModuleInformation
);
1113 win32_GetModuleFileNameExA
=
1114 GETPROCADDRESS (dll
, GetModuleFileNameExA
);
1117 return (win32_EnumProcessModules
!= NULL
1118 && win32_GetModuleInformation
!= NULL
1119 && win32_GetModuleFileNameExA
!= NULL
);
1124 /* Iterate over all DLLs currently mapped by our inferior, and
1125 add them to our list of solibs. */
1128 win32_add_all_dlls (void)
1132 HMODULE
*DllHandle
= dh_buf
;
1140 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
1145 if (!ok
|| !cbNeeded
)
1148 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
1152 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
1159 for (i
= 1; i
< ((size_t) cbNeeded
/ sizeof (HMODULE
)); i
++)
1162 char dll_name
[MAX_PATH
];
1164 if (!(*win32_GetModuleInformation
) (current_process_handle
,
1169 if ((*win32_GetModuleFileNameExA
) (current_process_handle
,
1174 win32_add_one_solib (dll_name
, (CORE_ADDR
) (uintptr_t) mi
.lpBaseOfDll
);
1179 typedef HANDLE (WINAPI
*winapi_CreateToolhelp32Snapshot
) (DWORD
, DWORD
);
1180 typedef BOOL (WINAPI
*winapi_Module32First
) (HANDLE
, LPMODULEENTRY32
);
1181 typedef BOOL (WINAPI
*winapi_Module32Next
) (HANDLE
, LPMODULEENTRY32
);
1183 /* Handle a DLL load event.
1185 This function assumes that this event did not occur during inferior
1186 initialization, where their event info may be incomplete (see
1187 do_initial_child_stuff and win32_add_all_dlls for more info on
1188 how we handle DLL loading during that phase). */
1191 handle_load_dll (void)
1193 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
1196 dll_name
= get_image_name (current_process_handle
,
1197 event
->lpImageName
, event
->fUnicode
);
1201 win32_add_one_solib (dll_name
, (CORE_ADDR
) (uintptr_t) event
->lpBaseOfDll
);
1204 /* Handle a DLL unload event.
1206 This function assumes that this event did not occur during inferior
1207 initialization, where their event info may be incomplete (see
1208 do_initial_child_stuff and win32_add_one_solib for more info
1209 on how we handle DLL loading during that phase). */
1212 handle_unload_dll (void)
1214 CORE_ADDR load_addr
=
1215 (CORE_ADDR
) (uintptr_t) current_event
.u
.UnloadDll
.lpBaseOfDll
;
1217 /* The symbols in a dll are offset by 0x1000, which is the
1218 offset from 0 of the first byte in an image - because
1219 of the file header and the section alignment. */
1220 load_addr
+= 0x1000;
1221 unloaded_dll (NULL
, load_addr
);
1225 handle_exception (struct target_waitstatus
*ourstatus
)
1227 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1229 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1233 case EXCEPTION_ACCESS_VIOLATION
:
1234 OUTMSG2 (("EXCEPTION_ACCESS_VIOLATION"));
1235 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1237 case STATUS_STACK_OVERFLOW
:
1238 OUTMSG2 (("STATUS_STACK_OVERFLOW"));
1239 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1241 case STATUS_FLOAT_DENORMAL_OPERAND
:
1242 OUTMSG2 (("STATUS_FLOAT_DENORMAL_OPERAND"));
1243 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1245 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1246 OUTMSG2 (("EXCEPTION_ARRAY_BOUNDS_EXCEEDED"));
1247 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1249 case STATUS_FLOAT_INEXACT_RESULT
:
1250 OUTMSG2 (("STATUS_FLOAT_INEXACT_RESULT"));
1251 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1253 case STATUS_FLOAT_INVALID_OPERATION
:
1254 OUTMSG2 (("STATUS_FLOAT_INVALID_OPERATION"));
1255 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1257 case STATUS_FLOAT_OVERFLOW
:
1258 OUTMSG2 (("STATUS_FLOAT_OVERFLOW"));
1259 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1261 case STATUS_FLOAT_STACK_CHECK
:
1262 OUTMSG2 (("STATUS_FLOAT_STACK_CHECK"));
1263 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1265 case STATUS_FLOAT_UNDERFLOW
:
1266 OUTMSG2 (("STATUS_FLOAT_UNDERFLOW"));
1267 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1269 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1270 OUTMSG2 (("STATUS_FLOAT_DIVIDE_BY_ZERO"));
1271 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1273 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1274 OUTMSG2 (("STATUS_INTEGER_DIVIDE_BY_ZERO"));
1275 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1277 case STATUS_INTEGER_OVERFLOW
:
1278 OUTMSG2 (("STATUS_INTEGER_OVERFLOW"));
1279 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1281 case EXCEPTION_BREAKPOINT
:
1282 OUTMSG2 (("EXCEPTION_BREAKPOINT"));
1283 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1285 /* Remove the initial breakpoint. */
1286 check_breakpoints ((CORE_ADDR
) (long) current_event
1287 .u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1291 OUTMSG2 (("DBG_CONTROL_C"));
1292 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1294 case DBG_CONTROL_BREAK
:
1295 OUTMSG2 (("DBG_CONTROL_BREAK"));
1296 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1298 case EXCEPTION_SINGLE_STEP
:
1299 OUTMSG2 (("EXCEPTION_SINGLE_STEP"));
1300 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1302 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1303 OUTMSG2 (("EXCEPTION_ILLEGAL_INSTRUCTION"));
1304 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1306 case EXCEPTION_PRIV_INSTRUCTION
:
1307 OUTMSG2 (("EXCEPTION_PRIV_INSTRUCTION"));
1308 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1310 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1311 OUTMSG2 (("EXCEPTION_NONCONTINUABLE_EXCEPTION"));
1312 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1315 if (current_event
.u
.Exception
.dwFirstChance
)
1317 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1320 OUTMSG2 (("gdbserver: unknown target exception 0x%08x at 0x%s",
1321 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1322 phex_nz ((uintptr_t) current_event
.u
.Exception
.ExceptionRecord
.
1323 ExceptionAddress
, sizeof (uintptr_t))));
1324 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1328 last_sig
= ourstatus
->value
.sig
;
1333 suspend_one_thread (struct inferior_list_entry
*entry
)
1335 struct thread_info
*thread
= (struct thread_info
*) entry
;
1336 win32_thread_info
*th
= (win32_thread_info
*) thread_target_data (thread
);
1340 if (SuspendThread (th
->h
) == (DWORD
) -1)
1342 DWORD err
= GetLastError ();
1343 OUTMSG (("warning: SuspendThread failed in suspend_one_thread, "
1344 "(error %d): %s\n", (int) err
, strwinerror (err
)));
1352 fake_breakpoint_event (void)
1354 OUTMSG2(("fake_breakpoint_event\n"));
1356 faked_breakpoint
= 1;
1358 memset (¤t_event
, 0, sizeof (current_event
));
1359 current_event
.dwThreadId
= main_thread_id
;
1360 current_event
.dwDebugEventCode
= EXCEPTION_DEBUG_EVENT
;
1361 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1362 = EXCEPTION_BREAKPOINT
;
1364 for_each_inferior (&all_threads
, suspend_one_thread
);
1369 auto_delete_breakpoint (CORE_ADDR stop_pc
)
1375 /* Get the next event from the child. */
1378 get_child_debug_event (struct target_waitstatus
*ourstatus
)
1382 last_sig
= GDB_SIGNAL_0
;
1383 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1385 /* Check if GDB sent us an interrupt request. */
1386 check_remote_input_interrupt_request ();
1388 if (soft_interrupt_requested
)
1390 soft_interrupt_requested
= 0;
1391 fake_breakpoint_event ();
1400 /* WinCE doesn't set an initial breakpoint automatically. To
1401 stop the inferior, we flush all currently pending debug
1402 events -- the thread list and the dll list are always
1403 reported immediatelly without delay, then, we suspend all
1404 threads and pretend we saw a trap at the current PC of the
1407 Contrary to desktop Windows, Windows CE *does* report the dll
1408 names on LOAD_DLL_DEBUG_EVENTs resulting from a
1409 DebugActiveProcess call. This limits the way we can detect
1410 if all the dlls have already been reported. If we get a real
1411 debug event before leaving attaching, the worst that will
1412 happen is the user will see a spurious breakpoint. */
1414 current_event
.dwDebugEventCode
= 0;
1415 if (!WaitForDebugEvent (¤t_event
, 0))
1417 OUTMSG2(("no attach events left\n"));
1418 fake_breakpoint_event ();
1422 OUTMSG2(("got attach event\n"));
1427 /* Keep the wait time low enough for confortable remote
1428 interruption, but high enough so gdbserver doesn't become a
1430 if (!WaitForDebugEvent (¤t_event
, 250))
1432 DWORD e
= GetLastError();
1434 if (e
== ERROR_PIPE_NOT_CONNECTED
)
1436 /* This will happen if the loader fails to succesfully
1437 load the application, e.g., if the main executable
1438 tries to pull in a non-existing export from a
1440 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1441 ourstatus
->value
.integer
= 1;
1451 switch (current_event
.dwDebugEventCode
)
1453 case CREATE_THREAD_DEBUG_EVENT
:
1454 OUTMSG2 (("gdbserver: kernel event CREATE_THREAD_DEBUG_EVENT "
1455 "for pid=%u tid=%x)\n",
1456 (unsigned) current_event
.dwProcessId
,
1457 (unsigned) current_event
.dwThreadId
));
1459 /* Record the existence of this thread. */
1460 child_add_thread (current_event
.dwProcessId
,
1461 current_event
.dwThreadId
,
1462 current_event
.u
.CreateThread
.hThread
,
1463 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1466 case EXIT_THREAD_DEBUG_EVENT
:
1467 OUTMSG2 (("gdbserver: kernel event EXIT_THREAD_DEBUG_EVENT "
1468 "for pid=%u tid=%x\n",
1469 (unsigned) current_event
.dwProcessId
,
1470 (unsigned) current_event
.dwThreadId
));
1471 child_delete_thread (current_event
.dwProcessId
,
1472 current_event
.dwThreadId
);
1474 current_thread
= (struct thread_info
*) all_threads
.head
;
1477 case CREATE_PROCESS_DEBUG_EVENT
:
1478 OUTMSG2 (("gdbserver: kernel event CREATE_PROCESS_DEBUG_EVENT "
1479 "for pid=%u tid=%x\n",
1480 (unsigned) current_event
.dwProcessId
,
1481 (unsigned) current_event
.dwThreadId
));
1482 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1484 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1485 main_thread_id
= current_event
.dwThreadId
;
1487 /* Add the main thread. */
1488 child_add_thread (current_event
.dwProcessId
,
1490 current_event
.u
.CreateProcessInfo
.hThread
,
1491 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
);
1496 /* Windows CE doesn't set the initial breakpoint
1497 automatically like the desktop versions of Windows do.
1498 We add it explicitly here. It will be removed as soon as
1500 set_breakpoint_at ((CORE_ADDR
) (long) current_event
.u
1501 .CreateProcessInfo
.lpStartAddress
,
1502 auto_delete_breakpoint
);
1507 case EXIT_PROCESS_DEBUG_EVENT
:
1508 OUTMSG2 (("gdbserver: kernel event EXIT_PROCESS_DEBUG_EVENT "
1509 "for pid=%u tid=%x\n",
1510 (unsigned) current_event
.dwProcessId
,
1511 (unsigned) current_event
.dwThreadId
));
1512 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1513 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1514 child_continue (DBG_CONTINUE
, -1);
1515 CloseHandle (current_process_handle
);
1516 current_process_handle
= NULL
;
1519 case LOAD_DLL_DEBUG_EVENT
:
1520 OUTMSG2 (("gdbserver: kernel event LOAD_DLL_DEBUG_EVENT "
1521 "for pid=%u tid=%x\n",
1522 (unsigned) current_event
.dwProcessId
,
1523 (unsigned) current_event
.dwThreadId
));
1524 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1525 if (! child_initialization_done
)
1529 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1530 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1533 case UNLOAD_DLL_DEBUG_EVENT
:
1534 OUTMSG2 (("gdbserver: kernel event UNLOAD_DLL_DEBUG_EVENT "
1535 "for pid=%u tid=%x\n",
1536 (unsigned) current_event
.dwProcessId
,
1537 (unsigned) current_event
.dwThreadId
));
1538 if (! child_initialization_done
)
1540 handle_unload_dll ();
1541 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1542 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1545 case EXCEPTION_DEBUG_EVENT
:
1546 OUTMSG2 (("gdbserver: kernel event EXCEPTION_DEBUG_EVENT "
1547 "for pid=%u tid=%x\n",
1548 (unsigned) current_event
.dwProcessId
,
1549 (unsigned) current_event
.dwThreadId
));
1550 handle_exception (ourstatus
);
1553 case OUTPUT_DEBUG_STRING_EVENT
:
1554 /* A message from the kernel (or Cygwin). */
1555 OUTMSG2 (("gdbserver: kernel event OUTPUT_DEBUG_STRING_EVENT "
1556 "for pid=%u tid=%x\n",
1557 (unsigned) current_event
.dwProcessId
,
1558 (unsigned) current_event
.dwThreadId
));
1559 handle_output_debug_string ();
1563 OUTMSG2 (("gdbserver: kernel event unknown "
1564 "for pid=%u tid=%x code=%x\n",
1565 (unsigned) current_event
.dwProcessId
,
1566 (unsigned) current_event
.dwThreadId
,
1567 (unsigned) current_event
.dwDebugEventCode
));
1571 ptid
= debug_event_ptid (¤t_event
);
1573 (struct thread_info
*) find_inferior_id (&all_threads
, ptid
);
1577 /* Wait for the inferior process to change state.
1578 STATUS will be filled in with a response code to send to GDB.
1579 Returns the signal which caused the process to stop. */
1581 win32_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
1583 struct regcache
*regcache
;
1585 if (cached_status
.kind
!= TARGET_WAITKIND_IGNORE
)
1587 /* The core always does a wait after creating the inferior, and
1588 do_initial_child_stuff already ran the inferior to the
1589 initial breakpoint (or an exit, if creating the process
1590 fails). Report it now. */
1591 *ourstatus
= cached_status
;
1592 cached_status
.kind
= TARGET_WAITKIND_IGNORE
;
1593 return debug_event_ptid (¤t_event
);
1598 if (!get_child_debug_event (ourstatus
))
1601 switch (ourstatus
->kind
)
1603 case TARGET_WAITKIND_EXITED
:
1604 OUTMSG2 (("Child exited with retcode = %x\n",
1605 ourstatus
->value
.integer
));
1606 win32_clear_inferiors ();
1607 return pid_to_ptid (current_event
.dwProcessId
);
1608 case TARGET_WAITKIND_STOPPED
:
1609 case TARGET_WAITKIND_LOADED
:
1610 OUTMSG2 (("Child Stopped with signal = %d \n",
1611 ourstatus
->value
.sig
));
1613 regcache
= get_thread_regcache (current_thread
, 1);
1614 child_fetch_inferior_registers (regcache
, -1);
1615 return debug_event_ptid (¤t_event
);
1617 OUTMSG (("Ignoring unknown internal event, %d\n", ourstatus
->kind
));
1619 case TARGET_WAITKIND_SPURIOUS
:
1620 /* do nothing, just continue */
1621 child_continue (DBG_CONTINUE
, -1);
1627 /* Fetch registers from the inferior process.
1628 If REGNO is -1, fetch all registers; otherwise, fetch at least REGNO. */
1630 win32_fetch_inferior_registers (struct regcache
*regcache
, int regno
)
1632 child_fetch_inferior_registers (regcache
, regno
);
1635 /* Store registers to the inferior process.
1636 If REGNO is -1, store all registers; otherwise, store at least REGNO. */
1638 win32_store_inferior_registers (struct regcache
*regcache
, int regno
)
1640 child_store_inferior_registers (regcache
, regno
);
1643 /* Read memory from the inferior process. This should generally be
1644 called through read_inferior_memory, which handles breakpoint shadowing.
1645 Read LEN bytes at MEMADDR into a buffer at MYADDR. */
1647 win32_read_inferior_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
1649 return child_xfer_memory (memaddr
, (char *) myaddr
, len
, 0, 0) != len
;
1652 /* Write memory to the inferior process. This should generally be
1653 called through write_inferior_memory, which handles breakpoint shadowing.
1654 Write LEN bytes from the buffer at MYADDR to MEMADDR.
1655 Returns 0 on success and errno on failure. */
1657 win32_write_inferior_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
,
1660 return child_xfer_memory (memaddr
, (char *) myaddr
, len
, 1, 0) != len
;
1663 /* Send an interrupt request to the inferior process. */
1665 win32_request_interrupt (void)
1667 winapi_DebugBreakProcess DebugBreakProcess
;
1668 winapi_GenerateConsoleCtrlEvent GenerateConsoleCtrlEvent
;
1671 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
1673 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
1676 GenerateConsoleCtrlEvent
= GETPROCADDRESS (dll
, GenerateConsoleCtrlEvent
);
1678 if (GenerateConsoleCtrlEvent
!= NULL
1679 && GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, current_process_id
))
1682 /* GenerateConsoleCtrlEvent can fail if process id being debugged is
1683 not a process group id.
1684 Fallback to XP/Vista 'DebugBreakProcess', which generates a
1685 breakpoint exception in the interior process. */
1687 DebugBreakProcess
= GETPROCADDRESS (dll
, DebugBreakProcess
);
1689 if (DebugBreakProcess
!= NULL
1690 && DebugBreakProcess (current_process_handle
))
1693 /* Last resort, suspend all threads manually. */
1694 soft_interrupt_requested
= 1;
1699 win32_error_to_fileio_error (DWORD err
)
1703 case ERROR_BAD_PATHNAME
:
1704 case ERROR_FILE_NOT_FOUND
:
1705 case ERROR_INVALID_NAME
:
1706 case ERROR_PATH_NOT_FOUND
:
1707 return FILEIO_ENOENT
;
1709 case ERROR_IO_DEVICE
:
1710 case ERROR_OPEN_FAILED
:
1712 case ERROR_INVALID_HANDLE
:
1713 return FILEIO_EBADF
;
1714 case ERROR_ACCESS_DENIED
:
1715 case ERROR_SHARING_VIOLATION
:
1716 return FILEIO_EACCES
;
1717 case ERROR_NOACCESS
:
1718 return FILEIO_EFAULT
;
1720 return FILEIO_EBUSY
;
1721 case ERROR_ALREADY_EXISTS
:
1722 case ERROR_FILE_EXISTS
:
1723 return FILEIO_EEXIST
;
1724 case ERROR_BAD_DEVICE
:
1725 return FILEIO_ENODEV
;
1726 case ERROR_DIRECTORY
:
1727 return FILEIO_ENOTDIR
;
1728 case ERROR_FILENAME_EXCED_RANGE
:
1729 case ERROR_INVALID_DATA
:
1730 case ERROR_INVALID_PARAMETER
:
1731 case ERROR_NEGATIVE_SEEK
:
1732 return FILEIO_EINVAL
;
1733 case ERROR_TOO_MANY_OPEN_FILES
:
1734 return FILEIO_EMFILE
;
1735 case ERROR_HANDLE_DISK_FULL
:
1736 case ERROR_DISK_FULL
:
1737 return FILEIO_ENOSPC
;
1738 case ERROR_WRITE_PROTECT
:
1739 return FILEIO_EROFS
;
1740 case ERROR_NOT_SUPPORTED
:
1741 return FILEIO_ENOSYS
;
1744 return FILEIO_EUNKNOWN
;
1748 wince_hostio_last_error (char *buf
)
1750 DWORD winerr
= GetLastError ();
1751 int fileio_err
= win32_error_to_fileio_error (winerr
);
1752 sprintf (buf
, "F-1,%x", fileio_err
);
1756 /* Write Windows OS Thread Information Block address. */
1759 win32_get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
1761 win32_thread_info
*th
;
1762 th
= thread_rec (ptid
, 0);
1766 *addr
= th
->thread_local_base
;
1770 /* Implementation of the target_ops method "sw_breakpoint_from_kind". */
1772 static const gdb_byte
*
1773 win32_sw_breakpoint_from_kind (int kind
, int *size
)
1775 *size
= the_low_target
.breakpoint_len
;
1776 return the_low_target
.breakpoint
;
1779 static struct target_ops win32_target_ops
= {
1780 win32_create_inferior
,
1781 NULL
, /* post_create_inferior */
1790 win32_fetch_inferior_registers
,
1791 win32_store_inferior_registers
,
1792 NULL
, /* prepare_to_access_memory */
1793 NULL
, /* done_accessing_memory */
1794 win32_read_inferior_memory
,
1795 win32_write_inferior_memory
,
1796 NULL
, /* lookup_symbols */
1797 win32_request_interrupt
,
1798 NULL
, /* read_auxv */
1799 win32_supports_z_point_type
,
1802 NULL
, /* stopped_by_sw_breakpoint */
1803 NULL
, /* supports_stopped_by_sw_breakpoint */
1804 NULL
, /* stopped_by_hw_breakpoint */
1805 NULL
, /* supports_stopped_by_hw_breakpoint */
1806 target_can_do_hardware_single_step
,
1807 win32_stopped_by_watchpoint
,
1808 win32_stopped_data_address
,
1809 NULL
, /* read_offsets */
1810 NULL
, /* get_tls_address */
1811 NULL
, /* qxfer_spu */
1813 wince_hostio_last_error
,
1815 hostio_last_error_from_errno
,
1817 NULL
, /* qxfer_osdata */
1818 NULL
, /* qxfer_siginfo */
1819 NULL
, /* supports_non_stop */
1821 NULL
, /* start_non_stop */
1822 NULL
, /* supports_multi_process */
1823 NULL
, /* supports_fork_events */
1824 NULL
, /* supports_vfork_events */
1825 NULL
, /* supports_exec_events */
1826 NULL
, /* handle_new_gdb_connection */
1827 NULL
, /* handle_monitor_command */
1828 NULL
, /* core_of_thread */
1829 NULL
, /* read_loadmap */
1830 NULL
, /* process_qsupported */
1831 NULL
, /* supports_tracepoints */
1833 NULL
, /* write_pc */
1834 NULL
, /* thread_stopped */
1835 win32_get_tib_address
,
1836 NULL
, /* pause_all */
1837 NULL
, /* unpause_all */
1838 NULL
, /* stabilize_threads */
1839 NULL
, /* install_fast_tracepoint_jump_pad */
1840 NULL
, /* emit_ops */
1841 NULL
, /* supports_disable_randomization */
1842 NULL
, /* get_min_fast_tracepoint_insn_len */
1843 NULL
, /* qxfer_libraries_svr4 */
1844 NULL
, /* support_agent */
1845 NULL
, /* support_btrace */
1846 NULL
, /* enable_btrace */
1847 NULL
, /* disable_btrace */
1848 NULL
, /* read_btrace */
1849 NULL
, /* read_btrace_conf */
1850 NULL
, /* supports_range_stepping */
1851 NULL
, /* pid_to_exec_file */
1852 NULL
, /* multifs_open */
1853 NULL
, /* multifs_unlink */
1854 NULL
, /* multifs_readlink */
1855 NULL
, /* breakpoint_kind_from_pc */
1856 win32_sw_breakpoint_from_kind
,
1859 /* Initialize the Win32 backend. */
1861 initialize_low (void)
1863 set_target_ops (&win32_target_ops
);
1864 the_low_target
.arch_setup ();