1 /* Low level interface to Windows debugging, for gdbserver.
2 Copyright (C) 2006-2015 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
= inferior_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
= xcalloc (1, sizeof (*th
));
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
*thread
)
234 win32_thread_info
*th
= inferior_target_data ((struct thread_info
*) thread
);
236 remove_thread ((struct thread_info
*) thread
);
241 /* Delete a thread from the list of threads. */
243 child_delete_thread (DWORD pid
, DWORD tid
)
245 struct inferior_list_entry
*thread
;
248 /* If the last thread is exiting, just return. */
249 if (one_inferior_p (&all_threads
))
252 ptid
= ptid_build (pid
, tid
, 0);
253 thread
= find_inferior_id (&all_threads
, ptid
);
257 delete_thread_info (thread
);
260 /* These watchpoint related wrapper functions simply pass on the function call
261 if the low target has registered a corresponding function. */
264 win32_supports_z_point_type (char z_type
)
266 return (the_low_target
.supports_z_point_type
!= NULL
267 && the_low_target
.supports_z_point_type (z_type
));
271 win32_insert_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
272 int size
, struct raw_breakpoint
*bp
)
274 if (the_low_target
.insert_point
!= NULL
)
275 return the_low_target
.insert_point (type
, addr
, size
, bp
);
277 /* Unsupported (see target.h). */
282 win32_remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
283 int size
, struct raw_breakpoint
*bp
)
285 if (the_low_target
.remove_point
!= NULL
)
286 return the_low_target
.remove_point (type
, addr
, size
, bp
);
288 /* Unsupported (see target.h). */
293 win32_stopped_by_watchpoint (void)
295 if (the_low_target
.stopped_by_watchpoint
!= NULL
)
296 return the_low_target
.stopped_by_watchpoint ();
302 win32_stopped_data_address (void)
304 if (the_low_target
.stopped_data_address
!= NULL
)
305 return the_low_target
.stopped_data_address ();
311 /* Transfer memory from/to the debugged process. */
313 child_xfer_memory (CORE_ADDR memaddr
, char *our
, int len
,
314 int write
, struct target_ops
*target
)
319 uintptr_t addr
= (uintptr_t) memaddr
;
323 success
= WriteProcessMemory (current_process_handle
, (LPVOID
) addr
,
324 (LPCVOID
) our
, len
, &done
);
326 lasterror
= GetLastError ();
327 FlushInstructionCache (current_process_handle
, (LPCVOID
) addr
, len
);
331 success
= ReadProcessMemory (current_process_handle
, (LPCVOID
) addr
,
332 (LPVOID
) our
, len
, &done
);
334 lasterror
= GetLastError ();
336 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
339 return success
? done
: -1;
342 /* Clear out any old thread list and reinitialize it to a pristine
345 child_init_thread_list (void)
347 for_each_inferior (&all_threads
, delete_thread_info
);
350 /* Zero during the child initialization phase, and nonzero otherwise. */
352 static int child_initialization_done
= 0;
355 do_initial_child_stuff (HANDLE proch
, DWORD pid
, int attached
)
357 struct process_info
*proc
;
359 last_sig
= GDB_SIGNAL_0
;
361 current_process_handle
= proch
;
362 current_process_id
= pid
;
365 soft_interrupt_requested
= 0;
366 faked_breakpoint
= 0;
368 memset (¤t_event
, 0, sizeof (current_event
));
370 proc
= add_process (pid
, attached
);
371 proc
->tdesc
= win32_tdesc
;
372 child_init_thread_list ();
373 child_initialization_done
= 0;
375 if (the_low_target
.initial_stuff
!= NULL
)
376 (*the_low_target
.initial_stuff
) ();
378 cached_status
.kind
= TARGET_WAITKIND_IGNORE
;
380 /* Flush all currently pending debug events (thread and dll list) up
381 to the initial breakpoint. */
384 struct target_waitstatus status
;
386 win32_wait (minus_one_ptid
, &status
, 0);
388 /* Note win32_wait doesn't return thread events. */
389 if (status
.kind
!= TARGET_WAITKIND_LOADED
)
391 cached_status
= status
;
396 struct thread_resume resume
;
398 resume
.thread
= minus_one_ptid
;
399 resume
.kind
= resume_continue
;
402 win32_resume (&resume
, 1);
407 /* Now that the inferior has been started and all DLLs have been mapped,
408 we can iterate over all DLLs and load them in.
410 We avoid doing it any earlier because, on certain versions of Windows,
411 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
412 we have seen on Windows 8.1 that the ntdll.dll load event does not
413 include the DLL name, preventing us from creating an associated SO.
414 A possible explanation is that ntdll.dll might be mapped before
415 the SO info gets created by the Windows system -- ntdll.dll is
416 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
417 do not seem to suffer from that problem.
419 Rather than try to work around this sort of issue, it is much
420 simpler to just ignore DLL load/unload events during the startup
421 phase, and then process them all in one batch now. */
422 win32_add_all_dlls ();
425 child_initialization_done
= 1;
428 /* Resume all artificially suspended threads if we are continuing
431 continue_one_thread (struct inferior_list_entry
*this_thread
, void *id_ptr
)
433 struct thread_info
*thread
= (struct thread_info
*) this_thread
;
434 int thread_id
= * (int *) id_ptr
;
435 win32_thread_info
*th
= inferior_target_data (thread
);
437 if (thread_id
== -1 || thread_id
== th
->tid
)
439 win32_prepare_to_resume (th
);
443 if (th
->context
.ContextFlags
)
445 win32_set_thread_context (th
);
446 th
->context
.ContextFlags
= 0;
449 if (ResumeThread (th
->h
) == (DWORD
) -1)
451 DWORD err
= GetLastError ();
452 OUTMSG (("warning: ResumeThread failed in continue_one_thread, "
453 "(error %d): %s\n", (int) err
, strwinerror (err
)));
463 child_continue (DWORD continue_status
, int thread_id
)
465 /* The inferior will only continue after the ContinueDebugEvent
467 find_inferior (&all_threads
, continue_one_thread
, &thread_id
);
468 faked_breakpoint
= 0;
470 if (!ContinueDebugEvent (current_event
.dwProcessId
,
471 current_event
.dwThreadId
,
478 /* Fetch register(s) from the current thread context. */
480 child_fetch_inferior_registers (struct regcache
*regcache
, int r
)
483 win32_thread_info
*th
= thread_rec (current_thread_ptid (), TRUE
);
484 if (r
== -1 || r
> NUM_REGS
)
485 child_fetch_inferior_registers (regcache
, NUM_REGS
);
487 for (regno
= 0; regno
< r
; regno
++)
488 (*the_low_target
.fetch_inferior_register
) (regcache
, th
, regno
);
491 /* Store a new register value into the current thread context. We don't
492 change the program's context until later, when we resume it. */
494 child_store_inferior_registers (struct regcache
*regcache
, int r
)
497 win32_thread_info
*th
= thread_rec (current_thread_ptid (), TRUE
);
498 if (r
== -1 || r
== 0 || r
> NUM_REGS
)
499 child_store_inferior_registers (regcache
, NUM_REGS
);
501 for (regno
= 0; regno
< r
; regno
++)
502 (*the_low_target
.store_inferior_register
) (regcache
, th
, regno
);
505 /* Map the Windows error number in ERROR to a locale-dependent error
506 message string and return a pointer to it. Typically, the values
507 for ERROR come from GetLastError.
509 The string pointed to shall not be modified by the application,
510 but may be overwritten by a subsequent call to strwinerror
512 The strwinerror function does not change the current setting
516 strwinerror (DWORD error
)
518 static char buf
[1024];
520 DWORD lasterr
= GetLastError ();
521 DWORD chars
= FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
522 | FORMAT_MESSAGE_ALLOCATE_BUFFER
,
525 0, /* Default language */
531 /* If there is an \r\n appended, zap it. */
533 && msgbuf
[chars
- 2] == '\r'
534 && msgbuf
[chars
- 1] == '\n')
540 if (chars
> ((COUNTOF (buf
)) - 1))
542 chars
= COUNTOF (buf
) - 1;
547 wcstombs (buf
, msgbuf
, chars
+ 1);
549 strncpy (buf
, msgbuf
, chars
+ 1);
554 sprintf (buf
, "unknown win32 error (%u)", (unsigned) error
);
556 SetLastError (lasterr
);
561 create_process (const char *program
, char *args
,
562 DWORD flags
, PROCESS_INFORMATION
*pi
)
567 wchar_t *p
, *wprogram
, *wargs
;
570 wprogram
= alloca ((strlen (program
) + 1) * sizeof (wchar_t));
571 mbstowcs (wprogram
, program
, strlen (program
) + 1);
573 for (p
= wprogram
; *p
; ++p
)
577 argslen
= strlen (args
);
578 wargs
= alloca ((argslen
+ 1) * sizeof (wchar_t));
579 mbstowcs (wargs
, args
, argslen
+ 1);
581 ret
= CreateProcessW (wprogram
, /* image name */
582 wargs
, /* command line */
583 NULL
, /* security, not supported */
584 NULL
, /* thread, not supported */
585 FALSE
, /* inherit handles, not supported */
586 flags
, /* start flags */
587 NULL
, /* environment, not supported */
588 NULL
, /* current directory, not supported */
589 NULL
, /* start info, not supported */
592 STARTUPINFOA si
= { sizeof (STARTUPINFOA
) };
594 ret
= CreateProcessA (program
, /* image name */
595 args
, /* command line */
598 TRUE
, /* inherit handles */
599 flags
, /* start flags */
600 NULL
, /* environment */
601 NULL
, /* current directory */
602 &si
, /* start info */
609 /* Start a new process.
610 PROGRAM is a path to the program to execute.
611 ARGS is a standard NULL-terminated array of arguments,
612 to be passed to the inferior as ``argv''.
613 Returns the new PID on success, -1 on failure. Registers the new
614 process with the process list. */
616 win32_create_inferior (char *program
, char **program_args
)
619 char real_path
[PATH_MAX
];
620 char *orig_path
, *new_path
, *path_ptr
;
627 PROCESS_INFORMATION pi
;
630 /* win32_wait needs to know we're not attaching. */
634 error ("No executable specified, specify executable to debug.\n");
636 flags
= DEBUG_PROCESS
| DEBUG_ONLY_THIS_PROCESS
;
640 path_ptr
= getenv ("PATH");
643 int size
= cygwin_conv_path_list (CCP_POSIX_TO_WIN_A
, path_ptr
, NULL
, 0);
644 orig_path
= alloca (strlen (path_ptr
) + 1);
645 new_path
= alloca (size
);
646 strcpy (orig_path
, path_ptr
);
647 cygwin_conv_path_list (CCP_POSIX_TO_WIN_A
, path_ptr
, new_path
, size
);
648 setenv ("PATH", new_path
, 1);
650 cygwin_conv_path (CCP_POSIX_TO_WIN_A
, program
, real_path
, PATH_MAX
);
655 for (argc
= 1; program_args
[argc
]; argc
++)
656 argslen
+= strlen (program_args
[argc
]) + 1;
657 args
= alloca (argslen
);
659 for (argc
= 1; program_args
[argc
]; argc
++)
661 /* FIXME: Can we do better about quoting? How does Cygwin
664 strcat (args
, program_args
[argc
]);
666 OUTMSG2 (("Command line is \"%s\"\n", args
));
668 #ifdef CREATE_NEW_PROCESS_GROUP
669 flags
|= CREATE_NEW_PROCESS_GROUP
;
672 ret
= create_process (program
, args
, flags
, &pi
);
673 err
= GetLastError ();
674 if (!ret
&& err
== ERROR_FILE_NOT_FOUND
)
676 char *exename
= alloca (strlen (program
) + 5);
677 strcat (strcpy (exename
, program
), ".exe");
678 ret
= create_process (exename
, args
, flags
, &pi
);
679 err
= GetLastError ();
684 setenv ("PATH", orig_path
, 1);
689 error ("Error creating process \"%s%s\", (error %d): %s\n",
690 program
, args
, (int) err
, strwinerror (err
));
694 OUTMSG2 (("Process created: %s\n", (char *) args
));
698 /* On Windows CE this handle can't be closed. The OS reuses
699 it in the debug events, while the 9x/NT versions of Windows
700 probably use a DuplicateHandle'd one. */
701 CloseHandle (pi
.hThread
);
704 do_initial_child_stuff (pi
.hProcess
, pi
.dwProcessId
, 0);
706 return current_process_id
;
709 /* Attach to a running process.
710 PID is the process ID to attach to, specified by the user
711 or a higher layer. */
713 win32_attach (unsigned long pid
)
716 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
719 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
721 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
723 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
725 h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
728 if (DebugActiveProcess (pid
))
730 if (DebugSetProcessKillOnExit
!= NULL
)
731 DebugSetProcessKillOnExit (FALSE
);
733 /* win32_wait needs to know we're attaching. */
735 do_initial_child_stuff (h
, pid
, 1);
742 err
= GetLastError ();
743 error ("Attach to process failed (error %d): %s\n",
744 (int) err
, strwinerror (err
));
747 /* Handle OUTPUT_DEBUG_STRING_EVENT from child process. */
749 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
751 #define READ_BUFFER_LEN 1024
753 char s
[READ_BUFFER_LEN
+ 1] = { 0 };
754 DWORD nbytes
= current_event
.u
.DebugString
.nDebugStringLength
;
759 if (nbytes
> READ_BUFFER_LEN
)
760 nbytes
= READ_BUFFER_LEN
;
762 addr
= (CORE_ADDR
) (size_t) current_event
.u
.DebugString
.lpDebugStringData
;
764 if (current_event
.u
.DebugString
.fUnicode
)
766 /* The event tells us how many bytes, not chars, even
768 WCHAR buffer
[(READ_BUFFER_LEN
+ 1) / sizeof (WCHAR
)] = { 0 };
769 if (read_inferior_memory (addr
, (unsigned char *) buffer
, nbytes
) != 0)
771 wcstombs (s
, buffer
, (nbytes
+ 1) / sizeof (WCHAR
));
775 if (read_inferior_memory (addr
, (unsigned char *) s
, nbytes
) != 0)
779 if (!startswith (s
, "cYg"))
789 #undef READ_BUFFER_LEN
793 win32_clear_inferiors (void)
795 if (current_process_handle
!= NULL
)
796 CloseHandle (current_process_handle
);
798 for_each_inferior (&all_threads
, delete_thread_info
);
802 /* Kill all inferiors. */
806 struct process_info
*process
;
808 if (current_process_handle
== NULL
)
811 TerminateProcess (current_process_handle
, 0);
814 if (!child_continue (DBG_CONTINUE
, -1))
816 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
818 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
820 else if (current_event
.dwDebugEventCode
== OUTPUT_DEBUG_STRING_EVENT
)
822 struct target_waitstatus our_status
= { 0 };
823 handle_output_debug_string (&our_status
);
827 win32_clear_inferiors ();
829 process
= find_process_pid (pid
);
830 remove_process (process
);
834 /* Detach from inferior PID. */
836 win32_detach (int pid
)
838 struct process_info
*process
;
839 winapi_DebugActiveProcessStop DebugActiveProcessStop
= NULL
;
840 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
842 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
844 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
846 DebugActiveProcessStop
= GETPROCADDRESS (dll
, DebugActiveProcessStop
);
847 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
849 if (DebugSetProcessKillOnExit
== NULL
850 || DebugActiveProcessStop
== NULL
)
854 struct thread_resume resume
;
855 resume
.thread
= minus_one_ptid
;
856 resume
.kind
= resume_continue
;
858 win32_resume (&resume
, 1);
861 if (!DebugActiveProcessStop (current_process_id
))
864 DebugSetProcessKillOnExit (FALSE
);
865 process
= find_process_pid (pid
);
866 remove_process (process
);
868 win32_clear_inferiors ();
873 win32_mourn (struct process_info
*process
)
875 remove_process (process
);
878 /* Wait for inferiors to end. */
882 HANDLE h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
885 WaitForSingleObject (h
, INFINITE
);
890 /* Return 1 iff the thread with thread ID TID is alive. */
892 win32_thread_alive (ptid_t ptid
)
896 /* Our thread list is reliable; don't bother to poll target
898 if (find_inferior_id (&all_threads
, ptid
) != NULL
)
905 /* Resume the inferior process. RESUME_INFO describes how we want
908 win32_resume (struct thread_resume
*resume_info
, size_t n
)
913 win32_thread_info
*th
;
914 DWORD continue_status
= DBG_CONTINUE
;
917 /* This handles the very limited set of resume packets that GDB can
918 currently produce. */
920 if (n
== 1 && ptid_equal (resume_info
[0].thread
, minus_one_ptid
))
925 /* Yes, we're ignoring resume_info[0].thread. It'd be tricky to make
926 the Windows resume code do the right thing for thread switching. */
927 tid
= current_event
.dwThreadId
;
929 if (!ptid_equal (resume_info
[0].thread
, minus_one_ptid
))
931 sig
= resume_info
[0].sig
;
932 step
= resume_info
[0].kind
== resume_step
;
940 if (sig
!= GDB_SIGNAL_0
)
942 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
944 OUTMSG (("Cannot continue with signal %d here.\n", sig
));
946 else if (sig
== last_sig
)
947 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
949 OUTMSG (("Can only continue with recieved signal %d.\n", last_sig
));
952 last_sig
= GDB_SIGNAL_0
;
954 /* Get context for the currently selected thread. */
955 ptid
= debug_event_ptid (¤t_event
);
956 th
= thread_rec (ptid
, FALSE
);
959 win32_prepare_to_resume (th
);
961 if (th
->context
.ContextFlags
)
963 /* Move register values from the inferior into the thread
964 context structure. */
965 regcache_invalidate ();
969 if (the_low_target
.single_step
!= NULL
)
970 (*the_low_target
.single_step
) (th
);
972 error ("Single stepping is not supported "
973 "in this configuration.\n");
976 win32_set_thread_context (th
);
977 th
->context
.ContextFlags
= 0;
981 /* Allow continuing with the same signal that interrupted us.
982 Otherwise complain. */
984 child_continue (continue_status
, tid
);
988 win32_add_one_solib (const char *name
, CORE_ADDR load_addr
)
990 char buf
[MAX_PATH
+ 1];
991 char buf2
[MAX_PATH
+ 1];
994 WIN32_FIND_DATA w32_fd
;
995 WCHAR wname
[MAX_PATH
+ 1];
996 mbstowcs (wname
, name
, MAX_PATH
);
997 HANDLE h
= FindFirstFile (wname
, &w32_fd
);
999 WIN32_FIND_DATAA w32_fd
;
1000 HANDLE h
= FindFirstFileA (name
, &w32_fd
);
1003 /* The symbols in a dll are offset by 0x1000, which is the
1004 offset from 0 of the first byte in an image - because
1005 of the file header and the section alignment. */
1006 load_addr
+= 0x1000;
1008 if (h
== INVALID_HANDLE_VALUE
)
1016 char cwd
[MAX_PATH
+ 1];
1018 if (GetCurrentDirectoryA (MAX_PATH
+ 1, cwd
))
1020 p
= strrchr (buf
, '\\');
1023 SetCurrentDirectoryA (buf
);
1024 GetFullPathNameA (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
1025 SetCurrentDirectoryA (cwd
);
1032 if (strcasecmp (buf
, "ntdll.dll") == 0)
1034 GetSystemDirectoryA (buf
, sizeof (buf
));
1035 strcat (buf
, "\\ntdll.dll");
1040 cygwin_conv_path (CCP_WIN_A_TO_POSIX
, buf
, buf2
, sizeof (buf2
));
1045 loaded_dll (buf2
, load_addr
);
1049 get_image_name (HANDLE h
, void *address
, int unicode
)
1051 static char buf
[(2 * MAX_PATH
) + 1];
1052 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
1058 /* Attempt to read the name of the dll that was detected.
1059 This is documented to work only when actively debugging
1060 a program. It will not work for attached processes. */
1061 if (address
== NULL
)
1065 /* Windows CE reports the address of the image name,
1066 instead of an address of a pointer into the image name. */
1067 address_ptr
= address
;
1069 /* See if we could read the address of a string, and that the
1070 address isn't null. */
1071 if (!ReadProcessMemory (h
, address
, &address_ptr
,
1072 sizeof (address_ptr
), &done
)
1073 || done
!= sizeof (address_ptr
)
1078 /* Find the length of the string */
1079 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
1080 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
1084 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
1087 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
1088 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
1091 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
1097 typedef BOOL (WINAPI
*winapi_EnumProcessModules
) (HANDLE
, HMODULE
*,
1099 typedef BOOL (WINAPI
*winapi_GetModuleInformation
) (HANDLE
, HMODULE
,
1100 LPMODULEINFO
, DWORD
);
1101 typedef DWORD (WINAPI
*winapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
,
1104 static winapi_EnumProcessModules win32_EnumProcessModules
;
1105 static winapi_GetModuleInformation win32_GetModuleInformation
;
1106 static winapi_GetModuleFileNameExA win32_GetModuleFileNameExA
;
1111 static int psapi_loaded
= 0;
1112 static HMODULE dll
= NULL
;
1117 dll
= LoadLibrary (TEXT("psapi.dll"));
1120 win32_EnumProcessModules
=
1121 GETPROCADDRESS (dll
, EnumProcessModules
);
1122 win32_GetModuleInformation
=
1123 GETPROCADDRESS (dll
, GetModuleInformation
);
1124 win32_GetModuleFileNameExA
=
1125 GETPROCADDRESS (dll
, GetModuleFileNameExA
);
1128 return (win32_EnumProcessModules
!= NULL
1129 && win32_GetModuleInformation
!= NULL
1130 && win32_GetModuleFileNameExA
!= NULL
);
1135 /* Iterate over all DLLs currently mapped by our inferior, and
1136 add them to our list of solibs. */
1139 win32_add_all_dlls (void)
1143 HMODULE
*DllHandle
= dh_buf
;
1151 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
1156 if (!ok
|| !cbNeeded
)
1159 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
1163 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
1170 for (i
= 1; i
< ((size_t) cbNeeded
/ sizeof (HMODULE
)); i
++)
1173 char dll_name
[MAX_PATH
];
1175 if (!(*win32_GetModuleInformation
) (current_process_handle
,
1180 if ((*win32_GetModuleFileNameExA
) (current_process_handle
,
1185 win32_add_one_solib (dll_name
, (CORE_ADDR
) (uintptr_t) mi
.lpBaseOfDll
);
1190 typedef HANDLE (WINAPI
*winapi_CreateToolhelp32Snapshot
) (DWORD
, DWORD
);
1191 typedef BOOL (WINAPI
*winapi_Module32First
) (HANDLE
, LPMODULEENTRY32
);
1192 typedef BOOL (WINAPI
*winapi_Module32Next
) (HANDLE
, LPMODULEENTRY32
);
1194 /* Handle a DLL load event.
1196 This function assumes that this event did not occur during inferior
1197 initialization, where their event info may be incomplete (see
1198 do_initial_child_stuff and win32_add_all_dlls for more info on
1199 how we handle DLL loading during that phase). */
1202 handle_load_dll (void)
1204 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
1207 dll_name
= get_image_name (current_process_handle
,
1208 event
->lpImageName
, event
->fUnicode
);
1212 win32_add_one_solib (dll_name
, (CORE_ADDR
) (uintptr_t) event
->lpBaseOfDll
);
1215 /* Handle a DLL unload event.
1217 This function assumes that this event did not occur during inferior
1218 initialization, where their event info may be incomplete (see
1219 do_initial_child_stuff and win32_add_one_solib for more info
1220 on how we handle DLL loading during that phase). */
1223 handle_unload_dll (void)
1225 CORE_ADDR load_addr
=
1226 (CORE_ADDR
) (uintptr_t) current_event
.u
.UnloadDll
.lpBaseOfDll
;
1228 /* The symbols in a dll are offset by 0x1000, which is the
1229 offset from 0 of the first byte in an image - because
1230 of the file header and the section alignment. */
1231 load_addr
+= 0x1000;
1232 unloaded_dll (NULL
, load_addr
);
1236 handle_exception (struct target_waitstatus
*ourstatus
)
1238 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1240 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1244 case EXCEPTION_ACCESS_VIOLATION
:
1245 OUTMSG2 (("EXCEPTION_ACCESS_VIOLATION"));
1246 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1248 case STATUS_STACK_OVERFLOW
:
1249 OUTMSG2 (("STATUS_STACK_OVERFLOW"));
1250 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1252 case STATUS_FLOAT_DENORMAL_OPERAND
:
1253 OUTMSG2 (("STATUS_FLOAT_DENORMAL_OPERAND"));
1254 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1256 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1257 OUTMSG2 (("EXCEPTION_ARRAY_BOUNDS_EXCEEDED"));
1258 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1260 case STATUS_FLOAT_INEXACT_RESULT
:
1261 OUTMSG2 (("STATUS_FLOAT_INEXACT_RESULT"));
1262 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1264 case STATUS_FLOAT_INVALID_OPERATION
:
1265 OUTMSG2 (("STATUS_FLOAT_INVALID_OPERATION"));
1266 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1268 case STATUS_FLOAT_OVERFLOW
:
1269 OUTMSG2 (("STATUS_FLOAT_OVERFLOW"));
1270 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1272 case STATUS_FLOAT_STACK_CHECK
:
1273 OUTMSG2 (("STATUS_FLOAT_STACK_CHECK"));
1274 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1276 case STATUS_FLOAT_UNDERFLOW
:
1277 OUTMSG2 (("STATUS_FLOAT_UNDERFLOW"));
1278 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1280 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1281 OUTMSG2 (("STATUS_FLOAT_DIVIDE_BY_ZERO"));
1282 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1284 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1285 OUTMSG2 (("STATUS_INTEGER_DIVIDE_BY_ZERO"));
1286 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1288 case STATUS_INTEGER_OVERFLOW
:
1289 OUTMSG2 (("STATUS_INTEGER_OVERFLOW"));
1290 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1292 case EXCEPTION_BREAKPOINT
:
1293 OUTMSG2 (("EXCEPTION_BREAKPOINT"));
1294 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1296 /* Remove the initial breakpoint. */
1297 check_breakpoints ((CORE_ADDR
) (long) current_event
1298 .u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1302 OUTMSG2 (("DBG_CONTROL_C"));
1303 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1305 case DBG_CONTROL_BREAK
:
1306 OUTMSG2 (("DBG_CONTROL_BREAK"));
1307 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1309 case EXCEPTION_SINGLE_STEP
:
1310 OUTMSG2 (("EXCEPTION_SINGLE_STEP"));
1311 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1313 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1314 OUTMSG2 (("EXCEPTION_ILLEGAL_INSTRUCTION"));
1315 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1317 case EXCEPTION_PRIV_INSTRUCTION
:
1318 OUTMSG2 (("EXCEPTION_PRIV_INSTRUCTION"));
1319 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1321 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1322 OUTMSG2 (("EXCEPTION_NONCONTINUABLE_EXCEPTION"));
1323 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1326 if (current_event
.u
.Exception
.dwFirstChance
)
1328 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1331 OUTMSG2 (("gdbserver: unknown target exception 0x%08x at 0x%s",
1332 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1333 phex_nz ((uintptr_t) current_event
.u
.Exception
.ExceptionRecord
.
1334 ExceptionAddress
, sizeof (uintptr_t))));
1335 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1339 last_sig
= ourstatus
->value
.sig
;
1344 suspend_one_thread (struct inferior_list_entry
*entry
)
1346 struct thread_info
*thread
= (struct thread_info
*) entry
;
1347 win32_thread_info
*th
= inferior_target_data (thread
);
1351 if (SuspendThread (th
->h
) == (DWORD
) -1)
1353 DWORD err
= GetLastError ();
1354 OUTMSG (("warning: SuspendThread failed in suspend_one_thread, "
1355 "(error %d): %s\n", (int) err
, strwinerror (err
)));
1363 fake_breakpoint_event (void)
1365 OUTMSG2(("fake_breakpoint_event\n"));
1367 faked_breakpoint
= 1;
1369 memset (¤t_event
, 0, sizeof (current_event
));
1370 current_event
.dwThreadId
= main_thread_id
;
1371 current_event
.dwDebugEventCode
= EXCEPTION_DEBUG_EVENT
;
1372 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1373 = EXCEPTION_BREAKPOINT
;
1375 for_each_inferior (&all_threads
, suspend_one_thread
);
1380 auto_delete_breakpoint (CORE_ADDR stop_pc
)
1386 /* Get the next event from the child. */
1389 get_child_debug_event (struct target_waitstatus
*ourstatus
)
1393 last_sig
= GDB_SIGNAL_0
;
1394 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1396 /* Check if GDB sent us an interrupt request. */
1397 check_remote_input_interrupt_request ();
1399 if (soft_interrupt_requested
)
1401 soft_interrupt_requested
= 0;
1402 fake_breakpoint_event ();
1411 /* WinCE doesn't set an initial breakpoint automatically. To
1412 stop the inferior, we flush all currently pending debug
1413 events -- the thread list and the dll list are always
1414 reported immediatelly without delay, then, we suspend all
1415 threads and pretend we saw a trap at the current PC of the
1418 Contrary to desktop Windows, Windows CE *does* report the dll
1419 names on LOAD_DLL_DEBUG_EVENTs resulting from a
1420 DebugActiveProcess call. This limits the way we can detect
1421 if all the dlls have already been reported. If we get a real
1422 debug event before leaving attaching, the worst that will
1423 happen is the user will see a spurious breakpoint. */
1425 current_event
.dwDebugEventCode
= 0;
1426 if (!WaitForDebugEvent (¤t_event
, 0))
1428 OUTMSG2(("no attach events left\n"));
1429 fake_breakpoint_event ();
1433 OUTMSG2(("got attach event\n"));
1438 /* Keep the wait time low enough for confortable remote
1439 interruption, but high enough so gdbserver doesn't become a
1441 if (!WaitForDebugEvent (¤t_event
, 250))
1443 DWORD e
= GetLastError();
1445 if (e
== ERROR_PIPE_NOT_CONNECTED
)
1447 /* This will happen if the loader fails to succesfully
1448 load the application, e.g., if the main executable
1449 tries to pull in a non-existing export from a
1451 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1452 ourstatus
->value
.integer
= 1;
1462 switch (current_event
.dwDebugEventCode
)
1464 case CREATE_THREAD_DEBUG_EVENT
:
1465 OUTMSG2 (("gdbserver: kernel event CREATE_THREAD_DEBUG_EVENT "
1466 "for pid=%u tid=%x)\n",
1467 (unsigned) current_event
.dwProcessId
,
1468 (unsigned) current_event
.dwThreadId
));
1470 /* Record the existence of this thread. */
1471 child_add_thread (current_event
.dwProcessId
,
1472 current_event
.dwThreadId
,
1473 current_event
.u
.CreateThread
.hThread
,
1474 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1477 case EXIT_THREAD_DEBUG_EVENT
:
1478 OUTMSG2 (("gdbserver: kernel event EXIT_THREAD_DEBUG_EVENT "
1479 "for pid=%u tid=%x\n",
1480 (unsigned) current_event
.dwProcessId
,
1481 (unsigned) current_event
.dwThreadId
));
1482 child_delete_thread (current_event
.dwProcessId
,
1483 current_event
.dwThreadId
);
1485 current_thread
= (struct thread_info
*) all_threads
.head
;
1488 case CREATE_PROCESS_DEBUG_EVENT
:
1489 OUTMSG2 (("gdbserver: kernel event CREATE_PROCESS_DEBUG_EVENT "
1490 "for pid=%u tid=%x\n",
1491 (unsigned) current_event
.dwProcessId
,
1492 (unsigned) current_event
.dwThreadId
));
1493 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1495 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1496 main_thread_id
= current_event
.dwThreadId
;
1498 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
1499 ourstatus
->value
.execd_pathname
= "Main executable";
1501 /* Add the main thread. */
1502 child_add_thread (current_event
.dwProcessId
,
1504 current_event
.u
.CreateProcessInfo
.hThread
,
1505 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
);
1507 ourstatus
->value
.related_pid
= debug_event_ptid (¤t_event
);
1511 /* Windows CE doesn't set the initial breakpoint
1512 automatically like the desktop versions of Windows do.
1513 We add it explicitly here. It will be removed as soon as
1515 set_breakpoint_at ((CORE_ADDR
) (long) current_event
.u
1516 .CreateProcessInfo
.lpStartAddress
,
1517 auto_delete_breakpoint
);
1522 case EXIT_PROCESS_DEBUG_EVENT
:
1523 OUTMSG2 (("gdbserver: kernel event EXIT_PROCESS_DEBUG_EVENT "
1524 "for pid=%u tid=%x\n",
1525 (unsigned) current_event
.dwProcessId
,
1526 (unsigned) current_event
.dwThreadId
));
1527 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1528 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1529 child_continue (DBG_CONTINUE
, -1);
1530 CloseHandle (current_process_handle
);
1531 current_process_handle
= NULL
;
1534 case LOAD_DLL_DEBUG_EVENT
:
1535 OUTMSG2 (("gdbserver: kernel event LOAD_DLL_DEBUG_EVENT "
1536 "for pid=%u tid=%x\n",
1537 (unsigned) current_event
.dwProcessId
,
1538 (unsigned) current_event
.dwThreadId
));
1539 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1540 if (! child_initialization_done
)
1544 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1545 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1548 case UNLOAD_DLL_DEBUG_EVENT
:
1549 OUTMSG2 (("gdbserver: kernel event UNLOAD_DLL_DEBUG_EVENT "
1550 "for pid=%u tid=%x\n",
1551 (unsigned) current_event
.dwProcessId
,
1552 (unsigned) current_event
.dwThreadId
));
1553 if (! child_initialization_done
)
1555 handle_unload_dll ();
1556 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1557 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1560 case EXCEPTION_DEBUG_EVENT
:
1561 OUTMSG2 (("gdbserver: kernel event EXCEPTION_DEBUG_EVENT "
1562 "for pid=%u tid=%x\n",
1563 (unsigned) current_event
.dwProcessId
,
1564 (unsigned) current_event
.dwThreadId
));
1565 handle_exception (ourstatus
);
1568 case OUTPUT_DEBUG_STRING_EVENT
:
1569 /* A message from the kernel (or Cygwin). */
1570 OUTMSG2 (("gdbserver: kernel event OUTPUT_DEBUG_STRING_EVENT "
1571 "for pid=%u tid=%x\n",
1572 (unsigned) current_event
.dwProcessId
,
1573 (unsigned) current_event
.dwThreadId
));
1574 handle_output_debug_string (ourstatus
);
1578 OUTMSG2 (("gdbserver: kernel event unknown "
1579 "for pid=%u tid=%x code=%x\n",
1580 (unsigned) current_event
.dwProcessId
,
1581 (unsigned) current_event
.dwThreadId
,
1582 (unsigned) current_event
.dwDebugEventCode
));
1586 ptid
= debug_event_ptid (¤t_event
);
1588 (struct thread_info
*) find_inferior_id (&all_threads
, ptid
);
1592 /* Wait for the inferior process to change state.
1593 STATUS will be filled in with a response code to send to GDB.
1594 Returns the signal which caused the process to stop. */
1596 win32_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
1598 struct regcache
*regcache
;
1600 if (cached_status
.kind
!= TARGET_WAITKIND_IGNORE
)
1602 /* The core always does a wait after creating the inferior, and
1603 do_initial_child_stuff already ran the inferior to the
1604 initial breakpoint (or an exit, if creating the process
1605 fails). Report it now. */
1606 *ourstatus
= cached_status
;
1607 cached_status
.kind
= TARGET_WAITKIND_IGNORE
;
1608 return debug_event_ptid (¤t_event
);
1613 if (!get_child_debug_event (ourstatus
))
1616 switch (ourstatus
->kind
)
1618 case TARGET_WAITKIND_EXITED
:
1619 OUTMSG2 (("Child exited with retcode = %x\n",
1620 ourstatus
->value
.integer
));
1621 win32_clear_inferiors ();
1622 return pid_to_ptid (current_event
.dwProcessId
);
1623 case TARGET_WAITKIND_STOPPED
:
1624 case TARGET_WAITKIND_LOADED
:
1625 OUTMSG2 (("Child Stopped with signal = %d \n",
1626 ourstatus
->value
.sig
));
1628 regcache
= get_thread_regcache (current_thread
, 1);
1629 child_fetch_inferior_registers (regcache
, -1);
1630 return debug_event_ptid (¤t_event
);
1632 OUTMSG (("Ignoring unknown internal event, %d\n", ourstatus
->kind
));
1634 case TARGET_WAITKIND_SPURIOUS
:
1635 case TARGET_WAITKIND_EXECD
:
1636 /* do nothing, just continue */
1637 child_continue (DBG_CONTINUE
, -1);
1643 /* Fetch registers from the inferior process.
1644 If REGNO is -1, fetch all registers; otherwise, fetch at least REGNO. */
1646 win32_fetch_inferior_registers (struct regcache
*regcache
, int regno
)
1648 child_fetch_inferior_registers (regcache
, regno
);
1651 /* Store registers to the inferior process.
1652 If REGNO is -1, store all registers; otherwise, store at least REGNO. */
1654 win32_store_inferior_registers (struct regcache
*regcache
, int regno
)
1656 child_store_inferior_registers (regcache
, regno
);
1659 /* Read memory from the inferior process. This should generally be
1660 called through read_inferior_memory, which handles breakpoint shadowing.
1661 Read LEN bytes at MEMADDR into a buffer at MYADDR. */
1663 win32_read_inferior_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
1665 return child_xfer_memory (memaddr
, (char *) myaddr
, len
, 0, 0) != len
;
1668 /* Write memory to the inferior process. This should generally be
1669 called through write_inferior_memory, which handles breakpoint shadowing.
1670 Write LEN bytes from the buffer at MYADDR to MEMADDR.
1671 Returns 0 on success and errno on failure. */
1673 win32_write_inferior_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
,
1676 return child_xfer_memory (memaddr
, (char *) myaddr
, len
, 1, 0) != len
;
1679 /* Send an interrupt request to the inferior process. */
1681 win32_request_interrupt (void)
1683 winapi_DebugBreakProcess DebugBreakProcess
;
1684 winapi_GenerateConsoleCtrlEvent GenerateConsoleCtrlEvent
;
1687 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
1689 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
1692 GenerateConsoleCtrlEvent
= GETPROCADDRESS (dll
, GenerateConsoleCtrlEvent
);
1694 if (GenerateConsoleCtrlEvent
!= NULL
1695 && GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, current_process_id
))
1698 /* GenerateConsoleCtrlEvent can fail if process id being debugged is
1699 not a process group id.
1700 Fallback to XP/Vista 'DebugBreakProcess', which generates a
1701 breakpoint exception in the interior process. */
1703 DebugBreakProcess
= GETPROCADDRESS (dll
, DebugBreakProcess
);
1705 if (DebugBreakProcess
!= NULL
1706 && DebugBreakProcess (current_process_handle
))
1709 /* Last resort, suspend all threads manually. */
1710 soft_interrupt_requested
= 1;
1715 win32_error_to_fileio_error (DWORD err
)
1719 case ERROR_BAD_PATHNAME
:
1720 case ERROR_FILE_NOT_FOUND
:
1721 case ERROR_INVALID_NAME
:
1722 case ERROR_PATH_NOT_FOUND
:
1723 return FILEIO_ENOENT
;
1725 case ERROR_IO_DEVICE
:
1726 case ERROR_OPEN_FAILED
:
1728 case ERROR_INVALID_HANDLE
:
1729 return FILEIO_EBADF
;
1730 case ERROR_ACCESS_DENIED
:
1731 case ERROR_SHARING_VIOLATION
:
1732 return FILEIO_EACCES
;
1733 case ERROR_NOACCESS
:
1734 return FILEIO_EFAULT
;
1736 return FILEIO_EBUSY
;
1737 case ERROR_ALREADY_EXISTS
:
1738 case ERROR_FILE_EXISTS
:
1739 return FILEIO_EEXIST
;
1740 case ERROR_BAD_DEVICE
:
1741 return FILEIO_ENODEV
;
1742 case ERROR_DIRECTORY
:
1743 return FILEIO_ENOTDIR
;
1744 case ERROR_FILENAME_EXCED_RANGE
:
1745 case ERROR_INVALID_DATA
:
1746 case ERROR_INVALID_PARAMETER
:
1747 case ERROR_NEGATIVE_SEEK
:
1748 return FILEIO_EINVAL
;
1749 case ERROR_TOO_MANY_OPEN_FILES
:
1750 return FILEIO_EMFILE
;
1751 case ERROR_HANDLE_DISK_FULL
:
1752 case ERROR_DISK_FULL
:
1753 return FILEIO_ENOSPC
;
1754 case ERROR_WRITE_PROTECT
:
1755 return FILEIO_EROFS
;
1756 case ERROR_NOT_SUPPORTED
:
1757 return FILEIO_ENOSYS
;
1760 return FILEIO_EUNKNOWN
;
1764 wince_hostio_last_error (char *buf
)
1766 DWORD winerr
= GetLastError ();
1767 int fileio_err
= win32_error_to_fileio_error (winerr
);
1768 sprintf (buf
, "F-1,%x", fileio_err
);
1772 /* Write Windows OS Thread Information Block address. */
1775 win32_get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
1777 win32_thread_info
*th
;
1778 th
= thread_rec (ptid
, 0);
1782 *addr
= th
->thread_local_base
;
1786 static struct target_ops win32_target_ops
= {
1787 win32_create_inferior
,
1788 NULL
, /* arch_setup */
1797 win32_fetch_inferior_registers
,
1798 win32_store_inferior_registers
,
1799 NULL
, /* prepare_to_access_memory */
1800 NULL
, /* done_accessing_memory */
1801 win32_read_inferior_memory
,
1802 win32_write_inferior_memory
,
1803 NULL
, /* lookup_symbols */
1804 win32_request_interrupt
,
1805 NULL
, /* read_auxv */
1806 win32_supports_z_point_type
,
1809 NULL
, /* stopped_by_sw_breakpoint */
1810 NULL
, /* supports_stopped_by_sw_breakpoint */
1811 NULL
, /* stopped_by_hw_breakpoint */
1812 NULL
, /* supports_stopped_by_hw_breakpoint */
1813 /* Although win32-i386 has hardware single step, still disable this
1814 feature for win32, because it is implemented in linux-low.c instead
1815 of in generic code. */
1816 NULL
, /* supports_conditional_breakpoints */
1817 win32_stopped_by_watchpoint
,
1818 win32_stopped_data_address
,
1819 NULL
, /* read_offsets */
1820 NULL
, /* get_tls_address */
1821 NULL
, /* qxfer_spu */
1823 wince_hostio_last_error
,
1825 hostio_last_error_from_errno
,
1827 NULL
, /* qxfer_osdata */
1828 NULL
, /* qxfer_siginfo */
1829 NULL
, /* supports_non_stop */
1831 NULL
, /* start_non_stop */
1832 NULL
, /* supports_multi_process */
1833 NULL
, /* supports_fork_events */
1834 NULL
, /* supports_vfork_events */
1835 NULL
, /* handle_new_gdb_connection */
1836 NULL
, /* handle_monitor_command */
1837 NULL
, /* core_of_thread */
1838 NULL
, /* read_loadmap */
1839 NULL
, /* process_qsupported */
1840 NULL
, /* supports_tracepoints */
1842 NULL
, /* write_pc */
1843 NULL
, /* thread_stopped */
1844 win32_get_tib_address
1847 /* Initialize the Win32 backend. */
1849 initialize_low (void)
1851 set_target_ops (&win32_target_ops
);
1852 if (the_low_target
.breakpoint
!= NULL
)
1853 set_breakpoint_data (the_low_target
.breakpoint
,
1854 the_low_target
.breakpoint_len
);
1855 the_low_target
.arch_setup ();