1 /* Low level interface to Windows debugging, for gdbserver.
2 Copyright (C) 2006, 2007, 2008, 2009, 2010 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/signals.h"
24 #include "gdb/fileio.h"
25 #include "mem-break.h"
26 #include "win32-low.h"
33 #include <sys/param.h>
38 #include <sys/cygwin.h>
41 #define OUTMSG(X) do { printf X; fflush (stderr); } while (0)
54 #define _T(x) TEXT (x)
58 #define COUNTOF(STR) (sizeof (STR) / sizeof ((STR)[0]))
62 # define GETPROCADDRESS(DLL, PROC) \
63 ((winapi_ ## PROC) GetProcAddress (DLL, TEXT (#PROC)))
65 # define GETPROCADDRESS(DLL, PROC) \
66 ((winapi_ ## PROC) GetProcAddress (DLL, #PROC))
69 int using_threads
= 1;
72 static int attaching
= 0;
73 static HANDLE current_process_handle
= NULL
;
74 static DWORD current_process_id
= 0;
75 static DWORD main_thread_id
= 0;
76 static enum target_signal last_sig
= TARGET_SIGNAL_0
;
78 /* The current debug event from WaitForDebugEvent. */
79 static DEBUG_EVENT current_event
;
81 /* Non zero if an interrupt request is to be satisfied by suspending
83 static int soft_interrupt_requested
= 0;
85 /* Non zero if the inferior is stopped in a simulated breakpoint done
86 by suspending all the threads. */
87 static int faked_breakpoint
= 0;
89 #define NUM_REGS (the_low_target.num_regs)
91 typedef BOOL
WINAPI (*winapi_DebugActiveProcessStop
) (DWORD dwProcessId
);
92 typedef BOOL
WINAPI (*winapi_DebugSetProcessKillOnExit
) (BOOL KillOnExit
);
93 typedef BOOL
WINAPI (*winapi_DebugBreakProcess
) (HANDLE
);
94 typedef BOOL
WINAPI (*winapi_GenerateConsoleCtrlEvent
) (DWORD
, DWORD
);
96 static void win32_resume (struct thread_resume
*resume_info
, size_t n
);
98 /* Get the thread ID from the current selected inferior (the current
101 current_inferior_ptid (void)
103 return ((struct inferior_list_entry
*) current_inferior
)->id
;
106 /* The current debug event from WaitForDebugEvent. */
108 debug_event_ptid (DEBUG_EVENT
*event
)
110 return ptid_build (event
->dwProcessId
, event
->dwThreadId
, 0);
113 /* Get the thread context of the thread associated with TH. */
116 win32_get_thread_context (win32_thread_info
*th
)
118 memset (&th
->context
, 0, sizeof (CONTEXT
));
119 (*the_low_target
.get_thread_context
) (th
, ¤t_event
);
121 memcpy (&th
->base_context
, &th
->context
, sizeof (CONTEXT
));
125 /* Set the thread context of the thread associated with TH. */
128 win32_set_thread_context (win32_thread_info
*th
)
131 /* Calling SuspendThread on a thread that is running kernel code
132 will report that the suspending was successful, but in fact, that
133 will often not be true. In those cases, the context returned by
134 GetThreadContext will not be correct by the time the thread
135 stops, hence we can't set that context back into the thread when
136 resuming - it will most likelly crash the inferior.
137 Unfortunately, there is no way to know when the thread will
138 really stop. To work around it, we'll only write the context
139 back to the thread when either the user or GDB explicitly change
140 it between stopping and resuming. */
141 if (memcmp (&th
->context
, &th
->base_context
, sizeof (CONTEXT
)) != 0)
143 (*the_low_target
.set_thread_context
) (th
, ¤t_event
);
146 /* Find a thread record given a thread id. If GET_CONTEXT is set then
147 also retrieve the context for this thread. */
148 static win32_thread_info
*
149 thread_rec (ptid_t ptid
, int get_context
)
151 struct thread_info
*thread
;
152 win32_thread_info
*th
;
154 thread
= (struct thread_info
*) find_inferior_id (&all_threads
, ptid
);
158 th
= inferior_target_data (thread
);
159 if (get_context
&& th
->context
.ContextFlags
== 0)
163 if (SuspendThread (th
->h
) == (DWORD
) -1)
165 DWORD err
= GetLastError ();
166 OUTMSG (("warning: SuspendThread failed in thread_rec, "
167 "(error %d): %s\n", (int) err
, strwinerror (err
)));
173 win32_get_thread_context (th
);
179 /* Add a thread to the thread list. */
180 static win32_thread_info
*
181 child_add_thread (DWORD pid
, DWORD tid
, HANDLE h
)
183 win32_thread_info
*th
;
184 ptid_t ptid
= ptid_build (pid
, tid
, 0);
186 if ((th
= thread_rec (ptid
, FALSE
)))
189 th
= xcalloc (1, sizeof (*th
));
193 add_thread (ptid
, th
);
194 set_inferior_regcache_data ((struct thread_info
*)
195 find_inferior_id (&all_threads
, ptid
),
196 new_register_cache ());
198 if (the_low_target
.thread_added
!= NULL
)
199 (*the_low_target
.thread_added
) (th
);
204 /* Delete a thread from the list of threads. */
206 delete_thread_info (struct inferior_list_entry
*thread
)
208 win32_thread_info
*th
= inferior_target_data ((struct thread_info
*) thread
);
210 remove_thread ((struct thread_info
*) thread
);
215 /* Delete a thread from the list of threads. */
217 child_delete_thread (DWORD pid
, DWORD tid
)
219 struct inferior_list_entry
*thread
;
222 /* If the last thread is exiting, just return. */
223 if (all_threads
.head
== all_threads
.tail
)
226 ptid
= ptid_build (pid
, tid
, 0);
227 thread
= find_inferior_id (&all_threads
, ptid
);
231 delete_thread_info (thread
);
234 /* These watchpoint related wrapper functions simply pass on the function call
235 if the low target has registered a corresponding function. */
238 win32_insert_point (char type
, CORE_ADDR addr
, int len
)
240 if (the_low_target
.insert_point
!= NULL
)
241 return the_low_target
.insert_point (type
, addr
, len
);
243 /* Unsupported (see target.h). */
248 win32_remove_point (char type
, CORE_ADDR addr
, int len
)
250 if (the_low_target
.remove_point
!= NULL
)
251 return the_low_target
.remove_point (type
, addr
, len
);
253 /* Unsupported (see target.h). */
258 win32_stopped_by_watchpoint (void)
260 if (the_low_target
.stopped_by_watchpoint
!= NULL
)
261 return the_low_target
.stopped_by_watchpoint ();
267 win32_stopped_data_address (void)
269 if (the_low_target
.stopped_data_address
!= NULL
)
270 return the_low_target
.stopped_data_address ();
276 /* Transfer memory from/to the debugged process. */
278 child_xfer_memory (CORE_ADDR memaddr
, char *our
, int len
,
279 int write
, struct target_ops
*target
)
282 long addr
= (long) memaddr
;
286 WriteProcessMemory (current_process_handle
, (LPVOID
) addr
,
287 (LPCVOID
) our
, len
, &done
);
288 FlushInstructionCache (current_process_handle
, (LPCVOID
) addr
, len
);
292 ReadProcessMemory (current_process_handle
, (LPCVOID
) addr
, (LPVOID
) our
,
298 /* Clear out any old thread list and reinitialize it to a pristine
301 child_init_thread_list (void)
303 for_each_inferior (&all_threads
, delete_thread_info
);
307 do_initial_child_stuff (HANDLE proch
, DWORD pid
, int attached
)
309 last_sig
= TARGET_SIGNAL_0
;
311 current_process_handle
= proch
;
312 current_process_id
= pid
;
315 soft_interrupt_requested
= 0;
316 faked_breakpoint
= 0;
318 memset (¤t_event
, 0, sizeof (current_event
));
320 add_process (pid
, attached
);
321 child_init_thread_list ();
323 if (the_low_target
.initial_stuff
!= NULL
)
324 (*the_low_target
.initial_stuff
) ();
327 /* Resume all artificially suspended threads if we are continuing
330 continue_one_thread (struct inferior_list_entry
*this_thread
, void *id_ptr
)
332 struct thread_info
*thread
= (struct thread_info
*) this_thread
;
333 int thread_id
= * (int *) id_ptr
;
334 win32_thread_info
*th
= inferior_target_data (thread
);
336 if ((thread_id
== -1 || thread_id
== th
->tid
)
339 if (th
->context
.ContextFlags
)
341 win32_set_thread_context (th
);
342 th
->context
.ContextFlags
= 0;
345 if (ResumeThread (th
->h
) == (DWORD
) -1)
347 DWORD err
= GetLastError ();
348 OUTMSG (("warning: ResumeThread failed in continue_one_thread, "
349 "(error %d): %s\n", (int) err
, strwinerror (err
)));
358 child_continue (DWORD continue_status
, int thread_id
)
360 /* The inferior will only continue after the ContinueDebugEvent
362 find_inferior (&all_threads
, continue_one_thread
, &thread_id
);
363 faked_breakpoint
= 0;
365 if (!ContinueDebugEvent (current_event
.dwProcessId
,
366 current_event
.dwThreadId
,
373 /* Fetch register(s) from the current thread context. */
375 child_fetch_inferior_registers (struct regcache
*regcache
, int r
)
378 win32_thread_info
*th
= thread_rec (current_inferior_ptid (), TRUE
);
379 if (r
== -1 || r
> NUM_REGS
)
380 child_fetch_inferior_registers (regcache
, NUM_REGS
);
382 for (regno
= 0; regno
< r
; regno
++)
383 (*the_low_target
.fetch_inferior_register
) (regcache
, th
, regno
);
386 /* Store a new register value into the current thread context. We don't
387 change the program's context until later, when we resume it. */
389 child_store_inferior_registers (struct regcache
*regcache
, int r
)
392 win32_thread_info
*th
= thread_rec (current_inferior_ptid (), TRUE
);
393 if (r
== -1 || r
== 0 || r
> NUM_REGS
)
394 child_store_inferior_registers (regcache
, NUM_REGS
);
396 for (regno
= 0; regno
< r
; regno
++)
397 (*the_low_target
.store_inferior_register
) (regcache
, th
, regno
);
400 /* Map the Windows error number in ERROR to a locale-dependent error
401 message string and return a pointer to it. Typically, the values
402 for ERROR come from GetLastError.
404 The string pointed to shall not be modified by the application,
405 but may be overwritten by a subsequent call to strwinerror
407 The strwinerror function does not change the current setting
411 strwinerror (DWORD error
)
413 static char buf
[1024];
415 DWORD lasterr
= GetLastError ();
416 DWORD chars
= FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
417 | FORMAT_MESSAGE_ALLOCATE_BUFFER
,
420 0, /* Default language */
426 /* If there is an \r\n appended, zap it. */
428 && msgbuf
[chars
- 2] == '\r'
429 && msgbuf
[chars
- 1] == '\n')
435 if (chars
> ((COUNTOF (buf
)) - 1))
437 chars
= COUNTOF (buf
) - 1;
442 wcstombs (buf
, msgbuf
, chars
+ 1);
444 strncpy (buf
, msgbuf
, chars
+ 1);
449 sprintf (buf
, "unknown win32 error (%ld)", error
);
451 SetLastError (lasterr
);
456 create_process (const char *program
, char *args
,
457 DWORD flags
, PROCESS_INFORMATION
*pi
)
462 wchar_t *p
, *wprogram
, *wargs
;
465 wprogram
= alloca ((strlen (program
) + 1) * sizeof (wchar_t));
466 mbstowcs (wprogram
, program
, strlen (program
) + 1);
468 for (p
= wprogram
; *p
; ++p
)
472 argslen
= strlen (args
);
473 wargs
= alloca ((argslen
+ 1) * sizeof (wchar_t));
474 mbstowcs (wargs
, args
, argslen
+ 1);
476 ret
= CreateProcessW (wprogram
, /* image name */
477 wargs
, /* command line */
478 NULL
, /* security, not supported */
479 NULL
, /* thread, not supported */
480 FALSE
, /* inherit handles, not supported */
481 flags
, /* start flags */
482 NULL
, /* environment, not supported */
483 NULL
, /* current directory, not supported */
484 NULL
, /* start info, not supported */
487 STARTUPINFOA si
= { sizeof (STARTUPINFOA
) };
489 ret
= CreateProcessA (program
, /* image name */
490 args
, /* command line */
493 TRUE
, /* inherit handles */
494 flags
, /* start flags */
495 NULL
, /* environment */
496 NULL
, /* current directory */
497 &si
, /* start info */
504 /* Start a new process.
505 PROGRAM is a path to the program to execute.
506 ARGS is a standard NULL-terminated array of arguments,
507 to be passed to the inferior as ``argv''.
508 Returns the new PID on success, -1 on failure. Registers the new
509 process with the process list. */
511 win32_create_inferior (char *program
, char **program_args
)
514 char real_path
[MAXPATHLEN
];
515 char *orig_path
, *new_path
, *path_ptr
;
522 PROCESS_INFORMATION pi
;
525 /* win32_wait needs to know we're not attaching. */
529 error ("No executable specified, specify executable to debug.\n");
531 flags
= DEBUG_PROCESS
| DEBUG_ONLY_THIS_PROCESS
;
535 path_ptr
= getenv ("PATH");
538 orig_path
= alloca (strlen (path_ptr
) + 1);
539 new_path
= alloca (cygwin_posix_to_win32_path_list_buf_size (path_ptr
));
540 strcpy (orig_path
, path_ptr
);
541 cygwin_posix_to_win32_path_list (path_ptr
, new_path
);
542 setenv ("PATH", new_path
, 1);
544 cygwin_conv_to_win32_path (program
, real_path
);
549 for (argc
= 1; program_args
[argc
]; argc
++)
550 argslen
+= strlen (program_args
[argc
]) + 1;
551 args
= alloca (argslen
);
553 for (argc
= 1; program_args
[argc
]; argc
++)
555 /* FIXME: Can we do better about quoting? How does Cygwin
558 strcat (args
, program_args
[argc
]);
560 OUTMSG2 (("Command line is \"%s\"\n", args
));
562 #ifdef CREATE_NEW_PROCESS_GROUP
563 flags
|= CREATE_NEW_PROCESS_GROUP
;
566 ret
= create_process (program
, args
, flags
, &pi
);
567 err
= GetLastError ();
568 if (!ret
&& err
== ERROR_FILE_NOT_FOUND
)
570 char *exename
= alloca (strlen (program
) + 5);
571 strcat (strcpy (exename
, program
), ".exe");
572 ret
= create_process (exename
, args
, flags
, &pi
);
573 err
= GetLastError ();
578 setenv ("PATH", orig_path
, 1);
583 error ("Error creating process \"%s%s\", (error %d): %s\n",
584 program
, args
, (int) err
, strwinerror (err
));
588 OUTMSG2 (("Process created: %s\n", (char *) args
));
592 /* On Windows CE this handle can't be closed. The OS reuses
593 it in the debug events, while the 9x/NT versions of Windows
594 probably use a DuplicateHandle'd one. */
595 CloseHandle (pi
.hThread
);
598 do_initial_child_stuff (pi
.hProcess
, pi
.dwProcessId
, 0);
600 return current_process_id
;
603 /* Attach to a running process.
604 PID is the process ID to attach to, specified by the user
605 or a higher layer. */
607 win32_attach (unsigned long pid
)
610 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
613 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
615 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
617 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
619 h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
622 if (DebugActiveProcess (pid
))
624 if (DebugSetProcessKillOnExit
!= NULL
)
625 DebugSetProcessKillOnExit (FALSE
);
627 /* win32_wait needs to know we're attaching. */
629 do_initial_child_stuff (h
, pid
, 1);
636 err
= GetLastError ();
637 error ("Attach to process failed (error %d): %s\n",
638 (int) err
, strwinerror (err
));
641 /* Handle OUTPUT_DEBUG_STRING_EVENT from child process. */
643 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
645 #define READ_BUFFER_LEN 1024
647 char s
[READ_BUFFER_LEN
+ 1] = { 0 };
648 DWORD nbytes
= current_event
.u
.DebugString
.nDebugStringLength
;
653 if (nbytes
> READ_BUFFER_LEN
)
654 nbytes
= READ_BUFFER_LEN
;
656 addr
= (CORE_ADDR
) (size_t) current_event
.u
.DebugString
.lpDebugStringData
;
658 if (current_event
.u
.DebugString
.fUnicode
)
660 /* The event tells us how many bytes, not chars, even
662 WCHAR buffer
[(READ_BUFFER_LEN
+ 1) / sizeof (WCHAR
)] = { 0 };
663 if (read_inferior_memory (addr
, (unsigned char *) buffer
, nbytes
) != 0)
665 wcstombs (s
, buffer
, (nbytes
+ 1) / sizeof (WCHAR
));
669 if (read_inferior_memory (addr
, (unsigned char *) s
, nbytes
) != 0)
673 if (strncmp (s
, "cYg", 3) != 0)
683 #undef READ_BUFFER_LEN
687 win32_clear_inferiors (void)
689 if (current_process_handle
!= NULL
)
690 CloseHandle (current_process_handle
);
692 for_each_inferior (&all_threads
, delete_thread_info
);
696 /* Kill all inferiors. */
700 struct process_info
*process
;
702 if (current_process_handle
== NULL
)
705 TerminateProcess (current_process_handle
, 0);
708 if (!child_continue (DBG_CONTINUE
, -1))
710 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
712 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
714 else if (current_event
.dwDebugEventCode
== OUTPUT_DEBUG_STRING_EVENT
)
716 struct target_waitstatus our_status
= { 0 };
717 handle_output_debug_string (&our_status
);
721 win32_clear_inferiors ();
723 process
= find_process_pid (pid
);
724 remove_process (process
);
728 /* Detach from inferior PID. */
730 win32_detach (int pid
)
732 struct process_info
*process
;
733 winapi_DebugActiveProcessStop DebugActiveProcessStop
= NULL
;
734 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
736 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
738 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
740 DebugActiveProcessStop
= GETPROCADDRESS (dll
, DebugActiveProcessStop
);
741 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
743 if (DebugSetProcessKillOnExit
== NULL
744 || DebugActiveProcessStop
== NULL
)
748 struct thread_resume resume
;
749 resume
.thread
= minus_one_ptid
;
750 resume
.kind
= resume_continue
;
752 win32_resume (&resume
, 1);
755 if (!DebugActiveProcessStop (current_process_id
))
758 DebugSetProcessKillOnExit (FALSE
);
759 process
= find_process_pid (pid
);
760 remove_process (process
);
762 win32_clear_inferiors ();
767 win32_mourn (struct process_info
*process
)
769 remove_process (process
);
772 /* Wait for inferiors to end. */
776 HANDLE h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
779 WaitForSingleObject (h
, INFINITE
);
784 /* Return 1 iff the thread with thread ID TID is alive. */
786 win32_thread_alive (ptid_t ptid
)
790 /* Our thread list is reliable; don't bother to poll target
792 if (find_inferior_id (&all_threads
, ptid
) != NULL
)
799 /* Resume the inferior process. RESUME_INFO describes how we want
802 win32_resume (struct thread_resume
*resume_info
, size_t n
)
805 enum target_signal sig
;
807 win32_thread_info
*th
;
808 DWORD continue_status
= DBG_CONTINUE
;
811 /* This handles the very limited set of resume packets that GDB can
812 currently produce. */
814 if (n
== 1 && ptid_equal (resume_info
[0].thread
, minus_one_ptid
))
819 /* Yes, we're ignoring resume_info[0].thread. It'd be tricky to make
820 the Windows resume code do the right thing for thread switching. */
821 tid
= current_event
.dwThreadId
;
823 if (!ptid_equal (resume_info
[0].thread
, minus_one_ptid
))
825 sig
= resume_info
[0].sig
;
826 step
= resume_info
[0].kind
== resume_step
;
834 if (sig
!= TARGET_SIGNAL_0
)
836 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
838 OUTMSG (("Cannot continue with signal %d here.\n", sig
));
840 else if (sig
== last_sig
)
841 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
843 OUTMSG (("Can only continue with recieved signal %d.\n", last_sig
));
846 last_sig
= TARGET_SIGNAL_0
;
848 /* Get context for the currently selected thread. */
849 ptid
= debug_event_ptid (¤t_event
);
850 th
= thread_rec (ptid
, FALSE
);
853 if (th
->context
.ContextFlags
)
855 /* Move register values from the inferior into the thread
856 context structure. */
857 regcache_invalidate ();
861 if (the_low_target
.single_step
!= NULL
)
862 (*the_low_target
.single_step
) (th
);
864 error ("Single stepping is not supported "
865 "in this configuration.\n");
868 win32_set_thread_context (th
);
869 th
->context
.ContextFlags
= 0;
873 /* Allow continuing with the same signal that interrupted us.
874 Otherwise complain. */
876 child_continue (continue_status
, tid
);
880 win32_add_one_solib (const char *name
, CORE_ADDR load_addr
)
882 char buf
[MAX_PATH
+ 1];
883 char buf2
[MAX_PATH
+ 1];
886 WIN32_FIND_DATA w32_fd
;
887 WCHAR wname
[MAX_PATH
+ 1];
888 mbstowcs (wname
, name
, MAX_PATH
);
889 HANDLE h
= FindFirstFile (wname
, &w32_fd
);
891 WIN32_FIND_DATAA w32_fd
;
892 HANDLE h
= FindFirstFileA (name
, &w32_fd
);
895 if (h
== INVALID_HANDLE_VALUE
)
903 char cwd
[MAX_PATH
+ 1];
905 if (GetCurrentDirectoryA (MAX_PATH
+ 1, cwd
))
907 p
= strrchr (buf
, '\\');
910 SetCurrentDirectoryA (buf
);
911 GetFullPathNameA (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
912 SetCurrentDirectoryA (cwd
);
919 if (strcasecmp (buf
, "ntdll.dll") == 0)
921 GetSystemDirectoryA (buf
, sizeof (buf
));
922 strcat (buf
, "\\ntdll.dll");
927 cygwin_conv_to_posix_path (buf
, buf2
);
932 loaded_dll (buf2
, load_addr
);
936 get_image_name (HANDLE h
, void *address
, int unicode
)
938 static char buf
[(2 * MAX_PATH
) + 1];
939 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
945 /* Attempt to read the name of the dll that was detected.
946 This is documented to work only when actively debugging
947 a program. It will not work for attached processes. */
952 /* Windows CE reports the address of the image name,
953 instead of an address of a pointer into the image name. */
954 address_ptr
= address
;
956 /* See if we could read the address of a string, and that the
957 address isn't null. */
958 if (!ReadProcessMemory (h
, address
, &address_ptr
,
959 sizeof (address_ptr
), &done
)
960 || done
!= sizeof (address_ptr
)
965 /* Find the length of the string */
966 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
967 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
971 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
974 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
975 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
978 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
984 typedef BOOL (WINAPI
*winapi_EnumProcessModules
) (HANDLE
, HMODULE
*,
986 typedef BOOL (WINAPI
*winapi_GetModuleInformation
) (HANDLE
, HMODULE
,
987 LPMODULEINFO
, DWORD
);
988 typedef DWORD (WINAPI
*winapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
,
991 static winapi_EnumProcessModules win32_EnumProcessModules
;
992 static winapi_GetModuleInformation win32_GetModuleInformation
;
993 static winapi_GetModuleFileNameExA win32_GetModuleFileNameExA
;
998 static int psapi_loaded
= 0;
999 static HMODULE dll
= NULL
;
1004 dll
= LoadLibrary (TEXT("psapi.dll"));
1007 win32_EnumProcessModules
=
1008 GETPROCADDRESS (dll
, EnumProcessModules
);
1009 win32_GetModuleInformation
=
1010 GETPROCADDRESS (dll
, GetModuleInformation
);
1011 win32_GetModuleFileNameExA
=
1012 GETPROCADDRESS (dll
, GetModuleFileNameExA
);
1015 return (win32_EnumProcessModules
!= NULL
1016 && win32_GetModuleInformation
!= NULL
1017 && win32_GetModuleFileNameExA
!= NULL
);
1021 psapi_get_dll_name (DWORD BaseAddress
, char *dll_name_ret
)
1027 HMODULE
*DllHandle
= dh_buf
;
1035 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
1040 if (!ok
|| !cbNeeded
)
1043 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
1047 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
1054 for (i
= 0; i
< ((size_t) cbNeeded
/ sizeof (HMODULE
)); i
++)
1056 if (!(*win32_GetModuleInformation
) (current_process_handle
,
1061 DWORD err
= GetLastError ();
1062 error ("Can't get module info: (error %d): %s\n",
1063 (int) err
, strwinerror (err
));
1066 if ((DWORD
) (mi
.lpBaseOfDll
) == BaseAddress
)
1068 len
= (*win32_GetModuleFileNameExA
) (current_process_handle
,
1074 DWORD err
= GetLastError ();
1075 error ("Error getting dll name: (error %d): %s\n",
1076 (int) err
, strwinerror (err
));
1083 dll_name_ret
[0] = '\0';
1087 typedef HANDLE (WINAPI
*winapi_CreateToolhelp32Snapshot
) (DWORD
, DWORD
);
1088 typedef BOOL (WINAPI
*winapi_Module32First
) (HANDLE
, LPMODULEENTRY32
);
1089 typedef BOOL (WINAPI
*winapi_Module32Next
) (HANDLE
, LPMODULEENTRY32
);
1091 static winapi_CreateToolhelp32Snapshot win32_CreateToolhelp32Snapshot
;
1092 static winapi_Module32First win32_Module32First
;
1093 static winapi_Module32Next win32_Module32Next
;
1095 typedef BOOL (WINAPI
*winapi_CloseToolhelp32Snapshot
) (HANDLE
);
1096 static winapi_CloseToolhelp32Snapshot win32_CloseToolhelp32Snapshot
;
1100 load_toolhelp (void)
1102 static int toolhelp_loaded
= 0;
1103 static HMODULE dll
= NULL
;
1105 if (!toolhelp_loaded
)
1107 toolhelp_loaded
= 1;
1109 dll
= GetModuleHandle (_T("KERNEL32.DLL"));
1111 dll
= LoadLibrary (L
"TOOLHELP.DLL");
1116 win32_CreateToolhelp32Snapshot
=
1117 GETPROCADDRESS (dll
, CreateToolhelp32Snapshot
);
1118 win32_Module32First
= GETPROCADDRESS (dll
, Module32First
);
1119 win32_Module32Next
= GETPROCADDRESS (dll
, Module32Next
);
1121 win32_CloseToolhelp32Snapshot
=
1122 GETPROCADDRESS (dll
, CloseToolhelp32Snapshot
);
1126 return (win32_CreateToolhelp32Snapshot
!= NULL
1127 && win32_Module32First
!= NULL
1128 && win32_Module32Next
!= NULL
1130 && win32_CloseToolhelp32Snapshot
!= NULL
1136 toolhelp_get_dll_name (DWORD BaseAddress
, char *dll_name_ret
)
1138 HANDLE snapshot_module
;
1139 MODULEENTRY32 modEntry
= { sizeof (MODULEENTRY32
) };
1142 if (!load_toolhelp ())
1145 snapshot_module
= win32_CreateToolhelp32Snapshot (TH32CS_SNAPMODULE
,
1146 current_event
.dwProcessId
);
1147 if (snapshot_module
== INVALID_HANDLE_VALUE
)
1150 /* Ignore the first module, which is the exe. */
1151 if (win32_Module32First (snapshot_module
, &modEntry
))
1152 while (win32_Module32Next (snapshot_module
, &modEntry
))
1153 if ((DWORD
) modEntry
.modBaseAddr
== BaseAddress
)
1156 wcstombs (dll_name_ret
, modEntry
.szExePath
, MAX_PATH
+ 1);
1158 strcpy (dll_name_ret
, modEntry
.szExePath
);
1165 win32_CloseToolhelp32Snapshot (snapshot_module
);
1167 CloseHandle (snapshot_module
);
1173 handle_load_dll (void)
1175 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
1176 char dll_buf
[MAX_PATH
+ 1];
1177 char *dll_name
= NULL
;
1180 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
1182 /* Windows does not report the image name of the dlls in the debug
1183 event on attaches. We resort to iterating over the list of
1184 loaded dlls looking for a match by image base. */
1185 if (!psapi_get_dll_name ((DWORD
) event
->lpBaseOfDll
, dll_buf
))
1187 if (!server_waiting
)
1188 /* On some versions of Windows and Windows CE, we can't create
1189 toolhelp snapshots while the inferior is stopped in a
1190 LOAD_DLL_DEBUG_EVENT due to a dll load, but we can while
1191 Windows is reporting the already loaded dlls. */
1192 toolhelp_get_dll_name ((DWORD
) event
->lpBaseOfDll
, dll_buf
);
1197 if (*dll_name
== '\0')
1198 dll_name
= get_image_name (current_process_handle
,
1199 event
->lpImageName
, event
->fUnicode
);
1203 /* The symbols in a dll are offset by 0x1000, which is the
1204 the offset from 0 of the first byte in an image - because
1205 of the file header and the section alignment. */
1207 load_addr
= (DWORD
) event
->lpBaseOfDll
+ 0x1000;
1208 win32_add_one_solib (dll_name
, load_addr
);
1212 handle_unload_dll (void)
1214 CORE_ADDR load_addr
=
1215 (CORE_ADDR
) (DWORD
) current_event
.u
.UnloadDll
.lpBaseOfDll
;
1216 load_addr
+= 0x1000;
1217 unloaded_dll (NULL
, load_addr
);
1221 handle_exception (struct target_waitstatus
*ourstatus
)
1223 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1225 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1229 case EXCEPTION_ACCESS_VIOLATION
:
1230 OUTMSG2 (("EXCEPTION_ACCESS_VIOLATION"));
1231 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1233 case STATUS_STACK_OVERFLOW
:
1234 OUTMSG2 (("STATUS_STACK_OVERFLOW"));
1235 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1237 case STATUS_FLOAT_DENORMAL_OPERAND
:
1238 OUTMSG2 (("STATUS_FLOAT_DENORMAL_OPERAND"));
1239 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1241 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1242 OUTMSG2 (("EXCEPTION_ARRAY_BOUNDS_EXCEEDED"));
1243 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1245 case STATUS_FLOAT_INEXACT_RESULT
:
1246 OUTMSG2 (("STATUS_FLOAT_INEXACT_RESULT"));
1247 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1249 case STATUS_FLOAT_INVALID_OPERATION
:
1250 OUTMSG2 (("STATUS_FLOAT_INVALID_OPERATION"));
1251 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1253 case STATUS_FLOAT_OVERFLOW
:
1254 OUTMSG2 (("STATUS_FLOAT_OVERFLOW"));
1255 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1257 case STATUS_FLOAT_STACK_CHECK
:
1258 OUTMSG2 (("STATUS_FLOAT_STACK_CHECK"));
1259 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1261 case STATUS_FLOAT_UNDERFLOW
:
1262 OUTMSG2 (("STATUS_FLOAT_UNDERFLOW"));
1263 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1265 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1266 OUTMSG2 (("STATUS_FLOAT_DIVIDE_BY_ZERO"));
1267 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1269 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1270 OUTMSG2 (("STATUS_INTEGER_DIVIDE_BY_ZERO"));
1271 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1273 case STATUS_INTEGER_OVERFLOW
:
1274 OUTMSG2 (("STATUS_INTEGER_OVERFLOW"));
1275 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1277 case EXCEPTION_BREAKPOINT
:
1278 OUTMSG2 (("EXCEPTION_BREAKPOINT"));
1279 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1281 /* Remove the initial breakpoint. */
1282 check_breakpoints ((CORE_ADDR
) (long) current_event
1283 .u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1287 OUTMSG2 (("DBG_CONTROL_C"));
1288 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1290 case DBG_CONTROL_BREAK
:
1291 OUTMSG2 (("DBG_CONTROL_BREAK"));
1292 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1294 case EXCEPTION_SINGLE_STEP
:
1295 OUTMSG2 (("EXCEPTION_SINGLE_STEP"));
1296 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1298 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1299 OUTMSG2 (("EXCEPTION_ILLEGAL_INSTRUCTION"));
1300 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1302 case EXCEPTION_PRIV_INSTRUCTION
:
1303 OUTMSG2 (("EXCEPTION_PRIV_INSTRUCTION"));
1304 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1306 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1307 OUTMSG2 (("EXCEPTION_NONCONTINUABLE_EXCEPTION"));
1308 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1311 if (current_event
.u
.Exception
.dwFirstChance
)
1313 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1316 OUTMSG2 (("gdbserver: unknown target exception 0x%08lx at 0x%08lx",
1317 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1318 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.
1320 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1324 last_sig
= ourstatus
->value
.sig
;
1329 suspend_one_thread (struct inferior_list_entry
*entry
)
1331 struct thread_info
*thread
= (struct thread_info
*) entry
;
1332 win32_thread_info
*th
= inferior_target_data (thread
);
1336 if (SuspendThread (th
->h
) == (DWORD
) -1)
1338 DWORD err
= GetLastError ();
1339 OUTMSG (("warning: SuspendThread failed in suspend_one_thread, "
1340 "(error %d): %s\n", (int) err
, strwinerror (err
)));
1348 fake_breakpoint_event (void)
1350 OUTMSG2(("fake_breakpoint_event\n"));
1352 faked_breakpoint
= 1;
1354 memset (¤t_event
, 0, sizeof (current_event
));
1355 current_event
.dwThreadId
= main_thread_id
;
1356 current_event
.dwDebugEventCode
= EXCEPTION_DEBUG_EVENT
;
1357 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1358 = EXCEPTION_BREAKPOINT
;
1360 for_each_inferior (&all_threads
, suspend_one_thread
);
1365 auto_delete_breakpoint (CORE_ADDR stop_pc
)
1371 /* Get the next event from the child. */
1374 get_child_debug_event (struct target_waitstatus
*ourstatus
)
1378 last_sig
= TARGET_SIGNAL_0
;
1379 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1381 /* Check if GDB sent us an interrupt request. */
1382 check_remote_input_interrupt_request ();
1384 if (soft_interrupt_requested
)
1386 soft_interrupt_requested
= 0;
1387 fake_breakpoint_event ();
1396 /* WinCE doesn't set an initial breakpoint automatically. To
1397 stop the inferior, we flush all currently pending debug
1398 events -- the thread list and the dll list are always
1399 reported immediatelly without delay, then, we suspend all
1400 threads and pretend we saw a trap at the current PC of the
1403 Contrary to desktop Windows, Windows CE *does* report the dll
1404 names on LOAD_DLL_DEBUG_EVENTs resulting from a
1405 DebugActiveProcess call. This limits the way we can detect
1406 if all the dlls have already been reported. If we get a real
1407 debug event before leaving attaching, the worst that will
1408 happen is the user will see a spurious breakpoint. */
1410 current_event
.dwDebugEventCode
= 0;
1411 if (!WaitForDebugEvent (¤t_event
, 0))
1413 OUTMSG2(("no attach events left\n"));
1414 fake_breakpoint_event ();
1418 OUTMSG2(("got attach event\n"));
1423 /* Keep the wait time low enough for confortable remote
1424 interruption, but high enough so gdbserver doesn't become a
1426 if (!WaitForDebugEvent (¤t_event
, 250))
1428 DWORD e
= GetLastError();
1430 if (e
== ERROR_PIPE_NOT_CONNECTED
)
1432 /* This will happen if the loader fails to succesfully
1433 load the application, e.g., if the main executable
1434 tries to pull in a non-existing export from a
1436 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1437 ourstatus
->value
.integer
= 1;
1447 switch (current_event
.dwDebugEventCode
)
1449 case CREATE_THREAD_DEBUG_EVENT
:
1450 OUTMSG2 (("gdbserver: kernel event CREATE_THREAD_DEBUG_EVENT "
1451 "for pid=%d tid=%x)\n",
1452 (unsigned) current_event
.dwProcessId
,
1453 (unsigned) current_event
.dwThreadId
));
1455 /* Record the existence of this thread. */
1456 child_add_thread (current_event
.dwProcessId
,
1457 current_event
.dwThreadId
,
1458 current_event
.u
.CreateThread
.hThread
);
1461 case EXIT_THREAD_DEBUG_EVENT
:
1462 OUTMSG2 (("gdbserver: kernel event EXIT_THREAD_DEBUG_EVENT "
1463 "for pid=%d tid=%x\n",
1464 (unsigned) current_event
.dwProcessId
,
1465 (unsigned) current_event
.dwThreadId
));
1466 child_delete_thread (current_event
.dwProcessId
,
1467 current_event
.dwThreadId
);
1469 current_inferior
= (struct thread_info
*) all_threads
.head
;
1472 case CREATE_PROCESS_DEBUG_EVENT
:
1473 OUTMSG2 (("gdbserver: kernel event CREATE_PROCESS_DEBUG_EVENT "
1474 "for pid=%d tid=%x\n",
1475 (unsigned) current_event
.dwProcessId
,
1476 (unsigned) current_event
.dwThreadId
));
1477 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1479 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1480 main_thread_id
= current_event
.dwThreadId
;
1482 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
1483 ourstatus
->value
.execd_pathname
= "Main executable";
1485 /* Add the main thread. */
1486 child_add_thread (current_event
.dwProcessId
,
1488 current_event
.u
.CreateProcessInfo
.hThread
);
1490 ourstatus
->value
.related_pid
= debug_event_ptid (¤t_event
);
1494 /* Windows CE doesn't set the initial breakpoint
1495 automatically like the desktop versions of Windows do.
1496 We add it explicitly here. It will be removed as soon as
1498 set_breakpoint_at ((CORE_ADDR
) (long) current_event
.u
1499 .CreateProcessInfo
.lpStartAddress
,
1500 auto_delete_breakpoint
);
1505 case EXIT_PROCESS_DEBUG_EVENT
:
1506 OUTMSG2 (("gdbserver: kernel event EXIT_PROCESS_DEBUG_EVENT "
1507 "for pid=%d tid=%x\n",
1508 (unsigned) current_event
.dwProcessId
,
1509 (unsigned) current_event
.dwThreadId
));
1510 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1511 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1512 child_continue (DBG_CONTINUE
, -1);
1513 CloseHandle (current_process_handle
);
1514 current_process_handle
= NULL
;
1517 case LOAD_DLL_DEBUG_EVENT
:
1518 OUTMSG2 (("gdbserver: kernel event LOAD_DLL_DEBUG_EVENT "
1519 "for pid=%d tid=%x\n",
1520 (unsigned) current_event
.dwProcessId
,
1521 (unsigned) current_event
.dwThreadId
));
1522 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1525 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1526 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1529 case UNLOAD_DLL_DEBUG_EVENT
:
1530 OUTMSG2 (("gdbserver: kernel event UNLOAD_DLL_DEBUG_EVENT "
1531 "for pid=%d tid=%x\n",
1532 (unsigned) current_event
.dwProcessId
,
1533 (unsigned) current_event
.dwThreadId
));
1534 handle_unload_dll ();
1535 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1536 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1539 case EXCEPTION_DEBUG_EVENT
:
1540 OUTMSG2 (("gdbserver: kernel event EXCEPTION_DEBUG_EVENT "
1541 "for pid=%d tid=%x\n",
1542 (unsigned) current_event
.dwProcessId
,
1543 (unsigned) current_event
.dwThreadId
));
1544 handle_exception (ourstatus
);
1547 case OUTPUT_DEBUG_STRING_EVENT
:
1548 /* A message from the kernel (or Cygwin). */
1549 OUTMSG2 (("gdbserver: kernel event OUTPUT_DEBUG_STRING_EVENT "
1550 "for pid=%d tid=%x\n",
1551 (unsigned) current_event
.dwProcessId
,
1552 (unsigned) current_event
.dwThreadId
));
1553 handle_output_debug_string (ourstatus
);
1557 OUTMSG2 (("gdbserver: kernel event unknown "
1558 "for pid=%d tid=%x code=%ld\n",
1559 (unsigned) current_event
.dwProcessId
,
1560 (unsigned) current_event
.dwThreadId
,
1561 current_event
.dwDebugEventCode
));
1565 ptid
= debug_event_ptid (¤t_event
);
1567 (struct thread_info
*) find_inferior_id (&all_threads
, ptid
);
1571 /* Wait for the inferior process to change state.
1572 STATUS will be filled in with a response code to send to GDB.
1573 Returns the signal which caused the process to stop. */
1575 win32_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
1577 struct process_info
*process
;
1578 struct regcache
*regcache
;
1582 if (!get_child_debug_event (ourstatus
))
1585 switch (ourstatus
->kind
)
1587 case TARGET_WAITKIND_EXITED
:
1588 OUTMSG2 (("Child exited with retcode = %x\n",
1589 ourstatus
->value
.integer
));
1590 win32_clear_inferiors ();
1591 return pid_to_ptid (current_event
.dwProcessId
);
1592 case TARGET_WAITKIND_STOPPED
:
1593 case TARGET_WAITKIND_LOADED
:
1594 OUTMSG2 (("Child Stopped with signal = %d \n",
1595 ourstatus
->value
.sig
));
1597 regcache
= get_thread_regcache (current_inferior
, 1);
1598 child_fetch_inferior_registers (regcache
, -1);
1600 if (ourstatus
->kind
== TARGET_WAITKIND_LOADED
1603 /* When gdb connects, we want to be stopped at the
1604 initial breakpoint, not in some dll load event. */
1605 child_continue (DBG_CONTINUE
, -1);
1609 /* We don't expose _LOADED events to gdbserver core. See
1610 the `dlls_changed' global. */
1611 if (ourstatus
->kind
== TARGET_WAITKIND_LOADED
)
1612 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1614 return debug_event_ptid (¤t_event
);
1616 OUTMSG (("Ignoring unknown internal event, %d\n", ourstatus
->kind
));
1618 case TARGET_WAITKIND_SPURIOUS
:
1619 case TARGET_WAITKIND_EXECD
:
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 static struct target_ops win32_target_ops
= {
1757 win32_create_inferior
,
1766 win32_fetch_inferior_registers
,
1767 win32_store_inferior_registers
,
1768 win32_read_inferior_memory
,
1769 win32_write_inferior_memory
,
1771 win32_request_interrupt
,
1775 win32_stopped_by_watchpoint
,
1776 win32_stopped_data_address
,
1781 wince_hostio_last_error
,
1783 hostio_last_error_from_errno
,
1787 /* Initialize the Win32 backend. */
1789 initialize_low (void)
1791 set_target_ops (&win32_target_ops
);
1792 if (the_low_target
.breakpoint
!= NULL
)
1793 set_breakpoint_data (the_low_target
.breakpoint
,
1794 the_low_target
.breakpoint_len
);
1795 the_low_target
.arch_setup ();