1 /* Low level interface to Windows debugging, for gdbserver.
2 Copyright (C) 2006-2013 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"
27 #include "gdbthread.h"
39 #include <sys/cygwin.h>
42 #define OUTMSG(X) do { printf X; fflush (stderr); } while (0)
55 #define _T(x) TEXT (x)
59 #define COUNTOF(STR) (sizeof (STR) / sizeof ((STR)[0]))
63 # define GETPROCADDRESS(DLL, PROC) \
64 ((winapi_ ## PROC) GetProcAddress (DLL, TEXT (#PROC)))
66 # define GETPROCADDRESS(DLL, PROC) \
67 ((winapi_ ## PROC) GetProcAddress (DLL, #PROC))
70 int using_threads
= 1;
73 static int attaching
= 0;
74 static HANDLE current_process_handle
= NULL
;
75 static DWORD current_process_id
= 0;
76 static DWORD main_thread_id
= 0;
77 static enum gdb_signal last_sig
= GDB_SIGNAL_0
;
79 /* The current debug event from WaitForDebugEvent. */
80 static DEBUG_EVENT current_event
;
82 /* Non zero if an interrupt request is to be satisfied by suspending
84 static int soft_interrupt_requested
= 0;
86 /* Non zero if the inferior is stopped in a simulated breakpoint done
87 by suspending all the threads. */
88 static int faked_breakpoint
= 0;
90 const struct target_desc
*win32_tdesc
;
92 #define NUM_REGS (the_low_target.num_regs)
94 typedef BOOL (WINAPI
*winapi_DebugActiveProcessStop
) (DWORD dwProcessId
);
95 typedef BOOL (WINAPI
*winapi_DebugSetProcessKillOnExit
) (BOOL KillOnExit
);
96 typedef BOOL (WINAPI
*winapi_DebugBreakProcess
) (HANDLE
);
97 typedef BOOL (WINAPI
*winapi_GenerateConsoleCtrlEvent
) (DWORD
, DWORD
);
99 static void win32_resume (struct thread_resume
*resume_info
, size_t n
);
101 /* Get the thread ID from the current selected inferior (the current
104 current_inferior_ptid (void)
106 return ((struct inferior_list_entry
*) current_inferior
)->id
;
109 /* The current debug event from WaitForDebugEvent. */
111 debug_event_ptid (DEBUG_EVENT
*event
)
113 return ptid_build (event
->dwProcessId
, event
->dwThreadId
, 0);
116 /* Get the thread context of the thread associated with TH. */
119 win32_get_thread_context (win32_thread_info
*th
)
121 memset (&th
->context
, 0, sizeof (CONTEXT
));
122 (*the_low_target
.get_thread_context
) (th
, ¤t_event
);
124 memcpy (&th
->base_context
, &th
->context
, sizeof (CONTEXT
));
128 /* Set the thread context of the thread associated with TH. */
131 win32_set_thread_context (win32_thread_info
*th
)
134 /* Calling SuspendThread on a thread that is running kernel code
135 will report that the suspending was successful, but in fact, that
136 will often not be true. In those cases, the context returned by
137 GetThreadContext will not be correct by the time the thread
138 stops, hence we can't set that context back into the thread when
139 resuming - it will most likelly crash the inferior.
140 Unfortunately, there is no way to know when the thread will
141 really stop. To work around it, we'll only write the context
142 back to the thread when either the user or GDB explicitly change
143 it between stopping and resuming. */
144 if (memcmp (&th
->context
, &th
->base_context
, sizeof (CONTEXT
)) != 0)
146 (*the_low_target
.set_thread_context
) (th
, ¤t_event
);
149 /* Find a thread record given a thread id. If GET_CONTEXT is set then
150 also retrieve the context for this thread. */
151 static win32_thread_info
*
152 thread_rec (ptid_t ptid
, int get_context
)
154 struct thread_info
*thread
;
155 win32_thread_info
*th
;
157 thread
= (struct thread_info
*) find_inferior_id (&all_threads
, ptid
);
161 th
= inferior_target_data (thread
);
162 if (get_context
&& th
->context
.ContextFlags
== 0)
166 if (SuspendThread (th
->h
) == (DWORD
) -1)
168 DWORD err
= GetLastError ();
169 OUTMSG (("warning: SuspendThread failed in thread_rec, "
170 "(error %d): %s\n", (int) err
, strwinerror (err
)));
176 win32_get_thread_context (th
);
182 /* Add a thread to the thread list. */
183 static win32_thread_info
*
184 child_add_thread (DWORD pid
, DWORD tid
, HANDLE h
, void *tlb
)
186 win32_thread_info
*th
;
187 ptid_t ptid
= ptid_build (pid
, tid
, 0);
189 if ((th
= thread_rec (ptid
, FALSE
)))
192 th
= xcalloc (1, sizeof (*th
));
195 th
->thread_local_base
= (CORE_ADDR
) (uintptr_t) tlb
;
197 add_thread (ptid
, th
);
199 if (the_low_target
.thread_added
!= NULL
)
200 (*the_low_target
.thread_added
) (th
);
205 /* Delete a thread from the list of threads. */
207 delete_thread_info (struct inferior_list_entry
*thread
)
209 win32_thread_info
*th
= inferior_target_data ((struct thread_info
*) thread
);
211 remove_thread ((struct thread_info
*) thread
);
216 /* Delete a thread from the list of threads. */
218 child_delete_thread (DWORD pid
, DWORD tid
)
220 struct inferior_list_entry
*thread
;
223 /* If the last thread is exiting, just return. */
224 if (all_threads
.head
== all_threads
.tail
)
227 ptid
= ptid_build (pid
, tid
, 0);
228 thread
= find_inferior_id (&all_threads
, ptid
);
232 delete_thread_info (thread
);
235 /* These watchpoint related wrapper functions simply pass on the function call
236 if the low target has registered a corresponding function. */
239 win32_insert_point (char type
, CORE_ADDR addr
, int len
)
241 if (the_low_target
.insert_point
!= NULL
)
242 return the_low_target
.insert_point (type
, addr
, len
);
244 /* Unsupported (see target.h). */
249 win32_remove_point (char type
, CORE_ADDR addr
, int len
)
251 if (the_low_target
.remove_point
!= NULL
)
252 return the_low_target
.remove_point (type
, addr
, len
);
254 /* Unsupported (see target.h). */
259 win32_stopped_by_watchpoint (void)
261 if (the_low_target
.stopped_by_watchpoint
!= NULL
)
262 return the_low_target
.stopped_by_watchpoint ();
268 win32_stopped_data_address (void)
270 if (the_low_target
.stopped_data_address
!= NULL
)
271 return the_low_target
.stopped_data_address ();
277 /* Transfer memory from/to the debugged process. */
279 child_xfer_memory (CORE_ADDR memaddr
, char *our
, int len
,
280 int write
, struct target_ops
*target
)
285 uintptr_t addr
= (uintptr_t) memaddr
;
289 success
= WriteProcessMemory (current_process_handle
, (LPVOID
) addr
,
290 (LPCVOID
) our
, len
, &done
);
292 lasterror
= GetLastError ();
293 FlushInstructionCache (current_process_handle
, (LPCVOID
) addr
, len
);
297 success
= ReadProcessMemory (current_process_handle
, (LPCVOID
) addr
,
298 (LPVOID
) our
, len
, &done
);
300 lasterror
= GetLastError ();
302 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
305 return success
? done
: -1;
308 /* Clear out any old thread list and reinitialize it to a pristine
311 child_init_thread_list (void)
313 for_each_inferior (&all_threads
, delete_thread_info
);
317 do_initial_child_stuff (HANDLE proch
, DWORD pid
, int attached
)
319 struct process_info
*proc
;
321 last_sig
= GDB_SIGNAL_0
;
323 current_process_handle
= proch
;
324 current_process_id
= pid
;
327 soft_interrupt_requested
= 0;
328 faked_breakpoint
= 0;
330 memset (¤t_event
, 0, sizeof (current_event
));
332 proc
= add_process (pid
, attached
);
333 proc
->tdesc
= win32_tdesc
;
334 child_init_thread_list ();
336 if (the_low_target
.initial_stuff
!= NULL
)
337 (*the_low_target
.initial_stuff
) ();
340 /* Resume all artificially suspended threads if we are continuing
343 continue_one_thread (struct inferior_list_entry
*this_thread
, void *id_ptr
)
345 struct thread_info
*thread
= (struct thread_info
*) this_thread
;
346 int thread_id
= * (int *) id_ptr
;
347 win32_thread_info
*th
= inferior_target_data (thread
);
349 if ((thread_id
== -1 || thread_id
== th
->tid
)
352 if (th
->context
.ContextFlags
)
354 win32_set_thread_context (th
);
355 th
->context
.ContextFlags
= 0;
358 if (ResumeThread (th
->h
) == (DWORD
) -1)
360 DWORD err
= GetLastError ();
361 OUTMSG (("warning: ResumeThread failed in continue_one_thread, "
362 "(error %d): %s\n", (int) err
, strwinerror (err
)));
371 child_continue (DWORD continue_status
, int thread_id
)
373 /* The inferior will only continue after the ContinueDebugEvent
375 find_inferior (&all_threads
, continue_one_thread
, &thread_id
);
376 faked_breakpoint
= 0;
378 if (!ContinueDebugEvent (current_event
.dwProcessId
,
379 current_event
.dwThreadId
,
386 /* Fetch register(s) from the current thread context. */
388 child_fetch_inferior_registers (struct regcache
*regcache
, int r
)
391 win32_thread_info
*th
= thread_rec (current_inferior_ptid (), TRUE
);
392 if (r
== -1 || r
> NUM_REGS
)
393 child_fetch_inferior_registers (regcache
, NUM_REGS
);
395 for (regno
= 0; regno
< r
; regno
++)
396 (*the_low_target
.fetch_inferior_register
) (regcache
, th
, regno
);
399 /* Store a new register value into the current thread context. We don't
400 change the program's context until later, when we resume it. */
402 child_store_inferior_registers (struct regcache
*regcache
, int r
)
405 win32_thread_info
*th
= thread_rec (current_inferior_ptid (), TRUE
);
406 if (r
== -1 || r
== 0 || r
> NUM_REGS
)
407 child_store_inferior_registers (regcache
, NUM_REGS
);
409 for (regno
= 0; regno
< r
; regno
++)
410 (*the_low_target
.store_inferior_register
) (regcache
, th
, regno
);
413 /* Map the Windows error number in ERROR to a locale-dependent error
414 message string and return a pointer to it. Typically, the values
415 for ERROR come from GetLastError.
417 The string pointed to shall not be modified by the application,
418 but may be overwritten by a subsequent call to strwinerror
420 The strwinerror function does not change the current setting
424 strwinerror (DWORD error
)
426 static char buf
[1024];
428 DWORD lasterr
= GetLastError ();
429 DWORD chars
= FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
430 | FORMAT_MESSAGE_ALLOCATE_BUFFER
,
433 0, /* Default language */
439 /* If there is an \r\n appended, zap it. */
441 && msgbuf
[chars
- 2] == '\r'
442 && msgbuf
[chars
- 1] == '\n')
448 if (chars
> ((COUNTOF (buf
)) - 1))
450 chars
= COUNTOF (buf
) - 1;
455 wcstombs (buf
, msgbuf
, chars
+ 1);
457 strncpy (buf
, msgbuf
, chars
+ 1);
462 sprintf (buf
, "unknown win32 error (%u)", (unsigned) error
);
464 SetLastError (lasterr
);
469 create_process (const char *program
, char *args
,
470 DWORD flags
, PROCESS_INFORMATION
*pi
)
475 wchar_t *p
, *wprogram
, *wargs
;
478 wprogram
= alloca ((strlen (program
) + 1) * sizeof (wchar_t));
479 mbstowcs (wprogram
, program
, strlen (program
) + 1);
481 for (p
= wprogram
; *p
; ++p
)
485 argslen
= strlen (args
);
486 wargs
= alloca ((argslen
+ 1) * sizeof (wchar_t));
487 mbstowcs (wargs
, args
, argslen
+ 1);
489 ret
= CreateProcessW (wprogram
, /* image name */
490 wargs
, /* command line */
491 NULL
, /* security, not supported */
492 NULL
, /* thread, not supported */
493 FALSE
, /* inherit handles, not supported */
494 flags
, /* start flags */
495 NULL
, /* environment, not supported */
496 NULL
, /* current directory, not supported */
497 NULL
, /* start info, not supported */
500 STARTUPINFOA si
= { sizeof (STARTUPINFOA
) };
502 ret
= CreateProcessA (program
, /* image name */
503 args
, /* command line */
506 TRUE
, /* inherit handles */
507 flags
, /* start flags */
508 NULL
, /* environment */
509 NULL
, /* current directory */
510 &si
, /* start info */
517 /* Start a new process.
518 PROGRAM is a path to the program to execute.
519 ARGS is a standard NULL-terminated array of arguments,
520 to be passed to the inferior as ``argv''.
521 Returns the new PID on success, -1 on failure. Registers the new
522 process with the process list. */
524 win32_create_inferior (char *program
, char **program_args
)
527 char real_path
[PATH_MAX
];
528 char *orig_path
, *new_path
, *path_ptr
;
535 PROCESS_INFORMATION pi
;
538 /* win32_wait needs to know we're not attaching. */
542 error ("No executable specified, specify executable to debug.\n");
544 flags
= DEBUG_PROCESS
| DEBUG_ONLY_THIS_PROCESS
;
548 path_ptr
= getenv ("PATH");
551 int size
= cygwin_conv_path_list (CCP_POSIX_TO_WIN_A
, path_ptr
, NULL
, 0);
552 orig_path
= alloca (strlen (path_ptr
) + 1);
553 new_path
= alloca (size
);
554 strcpy (orig_path
, path_ptr
);
555 cygwin_conv_path_list (CCP_POSIX_TO_WIN_A
, path_ptr
, new_path
, size
);
556 setenv ("PATH", new_path
, 1);
558 cygwin_conv_path (CCP_POSIX_TO_WIN_A
, program
, real_path
, PATH_MAX
);
563 for (argc
= 1; program_args
[argc
]; argc
++)
564 argslen
+= strlen (program_args
[argc
]) + 1;
565 args
= alloca (argslen
);
567 for (argc
= 1; program_args
[argc
]; argc
++)
569 /* FIXME: Can we do better about quoting? How does Cygwin
572 strcat (args
, program_args
[argc
]);
574 OUTMSG2 (("Command line is \"%s\"\n", args
));
576 #ifdef CREATE_NEW_PROCESS_GROUP
577 flags
|= CREATE_NEW_PROCESS_GROUP
;
580 ret
= create_process (program
, args
, flags
, &pi
);
581 err
= GetLastError ();
582 if (!ret
&& err
== ERROR_FILE_NOT_FOUND
)
584 char *exename
= alloca (strlen (program
) + 5);
585 strcat (strcpy (exename
, program
), ".exe");
586 ret
= create_process (exename
, args
, flags
, &pi
);
587 err
= GetLastError ();
592 setenv ("PATH", orig_path
, 1);
597 error ("Error creating process \"%s%s\", (error %d): %s\n",
598 program
, args
, (int) err
, strwinerror (err
));
602 OUTMSG2 (("Process created: %s\n", (char *) args
));
606 /* On Windows CE this handle can't be closed. The OS reuses
607 it in the debug events, while the 9x/NT versions of Windows
608 probably use a DuplicateHandle'd one. */
609 CloseHandle (pi
.hThread
);
612 do_initial_child_stuff (pi
.hProcess
, pi
.dwProcessId
, 0);
614 return current_process_id
;
617 /* Attach to a running process.
618 PID is the process ID to attach to, specified by the user
619 or a higher layer. */
621 win32_attach (unsigned long pid
)
624 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
627 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
629 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
631 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
633 h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
636 if (DebugActiveProcess (pid
))
638 if (DebugSetProcessKillOnExit
!= NULL
)
639 DebugSetProcessKillOnExit (FALSE
);
641 /* win32_wait needs to know we're attaching. */
643 do_initial_child_stuff (h
, pid
, 1);
650 err
= GetLastError ();
651 error ("Attach to process failed (error %d): %s\n",
652 (int) err
, strwinerror (err
));
655 /* Handle OUTPUT_DEBUG_STRING_EVENT from child process. */
657 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
659 #define READ_BUFFER_LEN 1024
661 char s
[READ_BUFFER_LEN
+ 1] = { 0 };
662 DWORD nbytes
= current_event
.u
.DebugString
.nDebugStringLength
;
667 if (nbytes
> READ_BUFFER_LEN
)
668 nbytes
= READ_BUFFER_LEN
;
670 addr
= (CORE_ADDR
) (size_t) current_event
.u
.DebugString
.lpDebugStringData
;
672 if (current_event
.u
.DebugString
.fUnicode
)
674 /* The event tells us how many bytes, not chars, even
676 WCHAR buffer
[(READ_BUFFER_LEN
+ 1) / sizeof (WCHAR
)] = { 0 };
677 if (read_inferior_memory (addr
, (unsigned char *) buffer
, nbytes
) != 0)
679 wcstombs (s
, buffer
, (nbytes
+ 1) / sizeof (WCHAR
));
683 if (read_inferior_memory (addr
, (unsigned char *) s
, nbytes
) != 0)
687 if (strncmp (s
, "cYg", 3) != 0)
697 #undef READ_BUFFER_LEN
701 win32_clear_inferiors (void)
703 if (current_process_handle
!= NULL
)
704 CloseHandle (current_process_handle
);
706 for_each_inferior (&all_threads
, delete_thread_info
);
710 /* Kill all inferiors. */
714 struct process_info
*process
;
716 if (current_process_handle
== NULL
)
719 TerminateProcess (current_process_handle
, 0);
722 if (!child_continue (DBG_CONTINUE
, -1))
724 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
726 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
728 else if (current_event
.dwDebugEventCode
== OUTPUT_DEBUG_STRING_EVENT
)
730 struct target_waitstatus our_status
= { 0 };
731 handle_output_debug_string (&our_status
);
735 win32_clear_inferiors ();
737 process
= find_process_pid (pid
);
738 remove_process (process
);
742 /* Detach from inferior PID. */
744 win32_detach (int pid
)
746 struct process_info
*process
;
747 winapi_DebugActiveProcessStop DebugActiveProcessStop
= NULL
;
748 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
750 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
752 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
754 DebugActiveProcessStop
= GETPROCADDRESS (dll
, DebugActiveProcessStop
);
755 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
757 if (DebugSetProcessKillOnExit
== NULL
758 || DebugActiveProcessStop
== NULL
)
762 struct thread_resume resume
;
763 resume
.thread
= minus_one_ptid
;
764 resume
.kind
= resume_continue
;
766 win32_resume (&resume
, 1);
769 if (!DebugActiveProcessStop (current_process_id
))
772 DebugSetProcessKillOnExit (FALSE
);
773 process
= find_process_pid (pid
);
774 remove_process (process
);
776 win32_clear_inferiors ();
781 win32_mourn (struct process_info
*process
)
783 remove_process (process
);
786 /* Wait for inferiors to end. */
790 HANDLE h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
793 WaitForSingleObject (h
, INFINITE
);
798 /* Return 1 iff the thread with thread ID TID is alive. */
800 win32_thread_alive (ptid_t ptid
)
804 /* Our thread list is reliable; don't bother to poll target
806 if (find_inferior_id (&all_threads
, ptid
) != NULL
)
813 /* Resume the inferior process. RESUME_INFO describes how we want
816 win32_resume (struct thread_resume
*resume_info
, size_t n
)
821 win32_thread_info
*th
;
822 DWORD continue_status
= DBG_CONTINUE
;
825 /* This handles the very limited set of resume packets that GDB can
826 currently produce. */
828 if (n
== 1 && ptid_equal (resume_info
[0].thread
, minus_one_ptid
))
833 /* Yes, we're ignoring resume_info[0].thread. It'd be tricky to make
834 the Windows resume code do the right thing for thread switching. */
835 tid
= current_event
.dwThreadId
;
837 if (!ptid_equal (resume_info
[0].thread
, minus_one_ptid
))
839 sig
= resume_info
[0].sig
;
840 step
= resume_info
[0].kind
== resume_step
;
848 if (sig
!= GDB_SIGNAL_0
)
850 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
852 OUTMSG (("Cannot continue with signal %d here.\n", sig
));
854 else if (sig
== last_sig
)
855 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
857 OUTMSG (("Can only continue with recieved signal %d.\n", last_sig
));
860 last_sig
= GDB_SIGNAL_0
;
862 /* Get context for the currently selected thread. */
863 ptid
= debug_event_ptid (¤t_event
);
864 th
= thread_rec (ptid
, FALSE
);
867 if (th
->context
.ContextFlags
)
869 /* Move register values from the inferior into the thread
870 context structure. */
871 regcache_invalidate ();
875 if (the_low_target
.single_step
!= NULL
)
876 (*the_low_target
.single_step
) (th
);
878 error ("Single stepping is not supported "
879 "in this configuration.\n");
882 win32_set_thread_context (th
);
883 th
->context
.ContextFlags
= 0;
887 /* Allow continuing with the same signal that interrupted us.
888 Otherwise complain. */
890 child_continue (continue_status
, tid
);
894 win32_add_one_solib (const char *name
, CORE_ADDR load_addr
)
896 char buf
[MAX_PATH
+ 1];
897 char buf2
[MAX_PATH
+ 1];
900 WIN32_FIND_DATA w32_fd
;
901 WCHAR wname
[MAX_PATH
+ 1];
902 mbstowcs (wname
, name
, MAX_PATH
);
903 HANDLE h
= FindFirstFile (wname
, &w32_fd
);
905 WIN32_FIND_DATAA w32_fd
;
906 HANDLE h
= FindFirstFileA (name
, &w32_fd
);
909 if (h
== INVALID_HANDLE_VALUE
)
917 char cwd
[MAX_PATH
+ 1];
919 if (GetCurrentDirectoryA (MAX_PATH
+ 1, cwd
))
921 p
= strrchr (buf
, '\\');
924 SetCurrentDirectoryA (buf
);
925 GetFullPathNameA (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
926 SetCurrentDirectoryA (cwd
);
933 if (strcasecmp (buf
, "ntdll.dll") == 0)
935 GetSystemDirectoryA (buf
, sizeof (buf
));
936 strcat (buf
, "\\ntdll.dll");
941 cygwin_conv_path (CCP_WIN_A_TO_POSIX
, buf
, buf2
, sizeof (buf2
));
946 loaded_dll (buf2
, load_addr
);
950 get_image_name (HANDLE h
, void *address
, int unicode
)
952 static char buf
[(2 * MAX_PATH
) + 1];
953 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
959 /* Attempt to read the name of the dll that was detected.
960 This is documented to work only when actively debugging
961 a program. It will not work for attached processes. */
966 /* Windows CE reports the address of the image name,
967 instead of an address of a pointer into the image name. */
968 address_ptr
= address
;
970 /* See if we could read the address of a string, and that the
971 address isn't null. */
972 if (!ReadProcessMemory (h
, address
, &address_ptr
,
973 sizeof (address_ptr
), &done
)
974 || done
!= sizeof (address_ptr
)
979 /* Find the length of the string */
980 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
981 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
985 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
988 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
989 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
992 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
998 typedef BOOL (WINAPI
*winapi_EnumProcessModules
) (HANDLE
, HMODULE
*,
1000 typedef BOOL (WINAPI
*winapi_GetModuleInformation
) (HANDLE
, HMODULE
,
1001 LPMODULEINFO
, DWORD
);
1002 typedef DWORD (WINAPI
*winapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
,
1005 static winapi_EnumProcessModules win32_EnumProcessModules
;
1006 static winapi_GetModuleInformation win32_GetModuleInformation
;
1007 static winapi_GetModuleFileNameExA win32_GetModuleFileNameExA
;
1012 static int psapi_loaded
= 0;
1013 static HMODULE dll
= NULL
;
1018 dll
= LoadLibrary (TEXT("psapi.dll"));
1021 win32_EnumProcessModules
=
1022 GETPROCADDRESS (dll
, EnumProcessModules
);
1023 win32_GetModuleInformation
=
1024 GETPROCADDRESS (dll
, GetModuleInformation
);
1025 win32_GetModuleFileNameExA
=
1026 GETPROCADDRESS (dll
, GetModuleFileNameExA
);
1029 return (win32_EnumProcessModules
!= NULL
1030 && win32_GetModuleInformation
!= NULL
1031 && win32_GetModuleFileNameExA
!= NULL
);
1035 psapi_get_dll_name (LPVOID BaseAddress
, char *dll_name_ret
)
1041 HMODULE
*DllHandle
= dh_buf
;
1049 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
1054 if (!ok
|| !cbNeeded
)
1057 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
1061 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
1068 for (i
= 0; i
< ((size_t) cbNeeded
/ sizeof (HMODULE
)); i
++)
1070 if (!(*win32_GetModuleInformation
) (current_process_handle
,
1075 DWORD err
= GetLastError ();
1076 error ("Can't get module info: (error %d): %s\n",
1077 (int) err
, strwinerror (err
));
1080 if (mi
.lpBaseOfDll
== BaseAddress
)
1082 len
= (*win32_GetModuleFileNameExA
) (current_process_handle
,
1088 DWORD err
= GetLastError ();
1089 error ("Error getting dll name: (error %d): %s\n",
1090 (int) err
, strwinerror (err
));
1097 dll_name_ret
[0] = '\0';
1101 typedef HANDLE (WINAPI
*winapi_CreateToolhelp32Snapshot
) (DWORD
, DWORD
);
1102 typedef BOOL (WINAPI
*winapi_Module32First
) (HANDLE
, LPMODULEENTRY32
);
1103 typedef BOOL (WINAPI
*winapi_Module32Next
) (HANDLE
, LPMODULEENTRY32
);
1105 static winapi_CreateToolhelp32Snapshot win32_CreateToolhelp32Snapshot
;
1106 static winapi_Module32First win32_Module32First
;
1107 static winapi_Module32Next win32_Module32Next
;
1109 typedef BOOL (WINAPI
*winapi_CloseToolhelp32Snapshot
) (HANDLE
);
1110 static winapi_CloseToolhelp32Snapshot win32_CloseToolhelp32Snapshot
;
1114 load_toolhelp (void)
1116 static int toolhelp_loaded
= 0;
1117 static HMODULE dll
= NULL
;
1119 if (!toolhelp_loaded
)
1121 toolhelp_loaded
= 1;
1123 dll
= GetModuleHandle (_T("KERNEL32.DLL"));
1125 dll
= LoadLibrary (L
"TOOLHELP.DLL");
1130 win32_CreateToolhelp32Snapshot
=
1131 GETPROCADDRESS (dll
, CreateToolhelp32Snapshot
);
1132 win32_Module32First
= GETPROCADDRESS (dll
, Module32First
);
1133 win32_Module32Next
= GETPROCADDRESS (dll
, Module32Next
);
1135 win32_CloseToolhelp32Snapshot
=
1136 GETPROCADDRESS (dll
, CloseToolhelp32Snapshot
);
1140 return (win32_CreateToolhelp32Snapshot
!= NULL
1141 && win32_Module32First
!= NULL
1142 && win32_Module32Next
!= NULL
1144 && win32_CloseToolhelp32Snapshot
!= NULL
1150 toolhelp_get_dll_name (LPVOID BaseAddress
, char *dll_name_ret
)
1152 HANDLE snapshot_module
;
1153 MODULEENTRY32 modEntry
= { sizeof (MODULEENTRY32
) };
1156 if (!load_toolhelp ())
1159 snapshot_module
= win32_CreateToolhelp32Snapshot (TH32CS_SNAPMODULE
,
1160 current_event
.dwProcessId
);
1161 if (snapshot_module
== INVALID_HANDLE_VALUE
)
1164 /* Ignore the first module, which is the exe. */
1165 if (win32_Module32First (snapshot_module
, &modEntry
))
1166 while (win32_Module32Next (snapshot_module
, &modEntry
))
1167 if (modEntry
.modBaseAddr
== BaseAddress
)
1170 wcstombs (dll_name_ret
, modEntry
.szExePath
, MAX_PATH
+ 1);
1172 strcpy (dll_name_ret
, modEntry
.szExePath
);
1179 win32_CloseToolhelp32Snapshot (snapshot_module
);
1181 CloseHandle (snapshot_module
);
1187 handle_load_dll (void)
1189 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
1190 char dll_buf
[MAX_PATH
+ 1];
1191 char *dll_name
= NULL
;
1192 CORE_ADDR load_addr
;
1194 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
1196 /* Windows does not report the image name of the dlls in the debug
1197 event on attaches. We resort to iterating over the list of
1198 loaded dlls looking for a match by image base. */
1199 if (!psapi_get_dll_name (event
->lpBaseOfDll
, dll_buf
))
1201 if (!server_waiting
)
1202 /* On some versions of Windows and Windows CE, we can't create
1203 toolhelp snapshots while the inferior is stopped in a
1204 LOAD_DLL_DEBUG_EVENT due to a dll load, but we can while
1205 Windows is reporting the already loaded dlls. */
1206 toolhelp_get_dll_name (event
->lpBaseOfDll
, dll_buf
);
1211 if (*dll_name
== '\0')
1212 dll_name
= get_image_name (current_process_handle
,
1213 event
->lpImageName
, event
->fUnicode
);
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. */
1221 load_addr
= (CORE_ADDR
) (uintptr_t) event
->lpBaseOfDll
+ 0x1000;
1222 win32_add_one_solib (dll_name
, load_addr
);
1226 handle_unload_dll (void)
1228 CORE_ADDR load_addr
=
1229 (CORE_ADDR
) (uintptr_t) current_event
.u
.UnloadDll
.lpBaseOfDll
;
1230 load_addr
+= 0x1000;
1231 unloaded_dll (NULL
, load_addr
);
1235 handle_exception (struct target_waitstatus
*ourstatus
)
1237 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1239 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1243 case EXCEPTION_ACCESS_VIOLATION
:
1244 OUTMSG2 (("EXCEPTION_ACCESS_VIOLATION"));
1245 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1247 case STATUS_STACK_OVERFLOW
:
1248 OUTMSG2 (("STATUS_STACK_OVERFLOW"));
1249 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1251 case STATUS_FLOAT_DENORMAL_OPERAND
:
1252 OUTMSG2 (("STATUS_FLOAT_DENORMAL_OPERAND"));
1253 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1255 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1256 OUTMSG2 (("EXCEPTION_ARRAY_BOUNDS_EXCEEDED"));
1257 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1259 case STATUS_FLOAT_INEXACT_RESULT
:
1260 OUTMSG2 (("STATUS_FLOAT_INEXACT_RESULT"));
1261 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1263 case STATUS_FLOAT_INVALID_OPERATION
:
1264 OUTMSG2 (("STATUS_FLOAT_INVALID_OPERATION"));
1265 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1267 case STATUS_FLOAT_OVERFLOW
:
1268 OUTMSG2 (("STATUS_FLOAT_OVERFLOW"));
1269 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1271 case STATUS_FLOAT_STACK_CHECK
:
1272 OUTMSG2 (("STATUS_FLOAT_STACK_CHECK"));
1273 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1275 case STATUS_FLOAT_UNDERFLOW
:
1276 OUTMSG2 (("STATUS_FLOAT_UNDERFLOW"));
1277 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1279 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1280 OUTMSG2 (("STATUS_FLOAT_DIVIDE_BY_ZERO"));
1281 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1283 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1284 OUTMSG2 (("STATUS_INTEGER_DIVIDE_BY_ZERO"));
1285 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1287 case STATUS_INTEGER_OVERFLOW
:
1288 OUTMSG2 (("STATUS_INTEGER_OVERFLOW"));
1289 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1291 case EXCEPTION_BREAKPOINT
:
1292 OUTMSG2 (("EXCEPTION_BREAKPOINT"));
1293 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1295 /* Remove the initial breakpoint. */
1296 check_breakpoints ((CORE_ADDR
) (long) current_event
1297 .u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1301 OUTMSG2 (("DBG_CONTROL_C"));
1302 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1304 case DBG_CONTROL_BREAK
:
1305 OUTMSG2 (("DBG_CONTROL_BREAK"));
1306 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1308 case EXCEPTION_SINGLE_STEP
:
1309 OUTMSG2 (("EXCEPTION_SINGLE_STEP"));
1310 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1312 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1313 OUTMSG2 (("EXCEPTION_ILLEGAL_INSTRUCTION"));
1314 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1316 case EXCEPTION_PRIV_INSTRUCTION
:
1317 OUTMSG2 (("EXCEPTION_PRIV_INSTRUCTION"));
1318 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1320 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1321 OUTMSG2 (("EXCEPTION_NONCONTINUABLE_EXCEPTION"));
1322 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1325 if (current_event
.u
.Exception
.dwFirstChance
)
1327 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1330 OUTMSG2 (("gdbserver: unknown target exception 0x%08x at 0x%s",
1331 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1332 phex_nz ((uintptr_t) current_event
.u
.Exception
.ExceptionRecord
.
1333 ExceptionAddress
, sizeof (uintptr_t))));
1334 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1338 last_sig
= ourstatus
->value
.sig
;
1343 suspend_one_thread (struct inferior_list_entry
*entry
)
1345 struct thread_info
*thread
= (struct thread_info
*) entry
;
1346 win32_thread_info
*th
= inferior_target_data (thread
);
1350 if (SuspendThread (th
->h
) == (DWORD
) -1)
1352 DWORD err
= GetLastError ();
1353 OUTMSG (("warning: SuspendThread failed in suspend_one_thread, "
1354 "(error %d): %s\n", (int) err
, strwinerror (err
)));
1362 fake_breakpoint_event (void)
1364 OUTMSG2(("fake_breakpoint_event\n"));
1366 faked_breakpoint
= 1;
1368 memset (¤t_event
, 0, sizeof (current_event
));
1369 current_event
.dwThreadId
= main_thread_id
;
1370 current_event
.dwDebugEventCode
= EXCEPTION_DEBUG_EVENT
;
1371 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1372 = EXCEPTION_BREAKPOINT
;
1374 for_each_inferior (&all_threads
, suspend_one_thread
);
1379 auto_delete_breakpoint (CORE_ADDR stop_pc
)
1385 /* Get the next event from the child. */
1388 get_child_debug_event (struct target_waitstatus
*ourstatus
)
1392 last_sig
= GDB_SIGNAL_0
;
1393 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1395 /* Check if GDB sent us an interrupt request. */
1396 check_remote_input_interrupt_request ();
1398 if (soft_interrupt_requested
)
1400 soft_interrupt_requested
= 0;
1401 fake_breakpoint_event ();
1410 /* WinCE doesn't set an initial breakpoint automatically. To
1411 stop the inferior, we flush all currently pending debug
1412 events -- the thread list and the dll list are always
1413 reported immediatelly without delay, then, we suspend all
1414 threads and pretend we saw a trap at the current PC of the
1417 Contrary to desktop Windows, Windows CE *does* report the dll
1418 names on LOAD_DLL_DEBUG_EVENTs resulting from a
1419 DebugActiveProcess call. This limits the way we can detect
1420 if all the dlls have already been reported. If we get a real
1421 debug event before leaving attaching, the worst that will
1422 happen is the user will see a spurious breakpoint. */
1424 current_event
.dwDebugEventCode
= 0;
1425 if (!WaitForDebugEvent (¤t_event
, 0))
1427 OUTMSG2(("no attach events left\n"));
1428 fake_breakpoint_event ();
1432 OUTMSG2(("got attach event\n"));
1437 /* Keep the wait time low enough for confortable remote
1438 interruption, but high enough so gdbserver doesn't become a
1440 if (!WaitForDebugEvent (¤t_event
, 250))
1442 DWORD e
= GetLastError();
1444 if (e
== ERROR_PIPE_NOT_CONNECTED
)
1446 /* This will happen if the loader fails to succesfully
1447 load the application, e.g., if the main executable
1448 tries to pull in a non-existing export from a
1450 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1451 ourstatus
->value
.integer
= 1;
1461 switch (current_event
.dwDebugEventCode
)
1463 case CREATE_THREAD_DEBUG_EVENT
:
1464 OUTMSG2 (("gdbserver: kernel event CREATE_THREAD_DEBUG_EVENT "
1465 "for pid=%u tid=%x)\n",
1466 (unsigned) current_event
.dwProcessId
,
1467 (unsigned) current_event
.dwThreadId
));
1469 /* Record the existence of this thread. */
1470 child_add_thread (current_event
.dwProcessId
,
1471 current_event
.dwThreadId
,
1472 current_event
.u
.CreateThread
.hThread
,
1473 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1476 case EXIT_THREAD_DEBUG_EVENT
:
1477 OUTMSG2 (("gdbserver: kernel event EXIT_THREAD_DEBUG_EVENT "
1478 "for pid=%u tid=%x\n",
1479 (unsigned) current_event
.dwProcessId
,
1480 (unsigned) current_event
.dwThreadId
));
1481 child_delete_thread (current_event
.dwProcessId
,
1482 current_event
.dwThreadId
);
1484 current_inferior
= (struct thread_info
*) all_threads
.head
;
1487 case CREATE_PROCESS_DEBUG_EVENT
:
1488 OUTMSG2 (("gdbserver: kernel event CREATE_PROCESS_DEBUG_EVENT "
1489 "for pid=%u tid=%x\n",
1490 (unsigned) current_event
.dwProcessId
,
1491 (unsigned) current_event
.dwThreadId
));
1492 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1494 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1495 main_thread_id
= current_event
.dwThreadId
;
1497 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
1498 ourstatus
->value
.execd_pathname
= "Main executable";
1500 /* Add the main thread. */
1501 child_add_thread (current_event
.dwProcessId
,
1503 current_event
.u
.CreateProcessInfo
.hThread
,
1504 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
);
1506 ourstatus
->value
.related_pid
= debug_event_ptid (¤t_event
);
1510 /* Windows CE doesn't set the initial breakpoint
1511 automatically like the desktop versions of Windows do.
1512 We add it explicitly here. It will be removed as soon as
1514 set_breakpoint_at ((CORE_ADDR
) (long) current_event
.u
1515 .CreateProcessInfo
.lpStartAddress
,
1516 auto_delete_breakpoint
);
1521 case EXIT_PROCESS_DEBUG_EVENT
:
1522 OUTMSG2 (("gdbserver: kernel event EXIT_PROCESS_DEBUG_EVENT "
1523 "for pid=%u tid=%x\n",
1524 (unsigned) current_event
.dwProcessId
,
1525 (unsigned) current_event
.dwThreadId
));
1526 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1527 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1528 child_continue (DBG_CONTINUE
, -1);
1529 CloseHandle (current_process_handle
);
1530 current_process_handle
= NULL
;
1533 case LOAD_DLL_DEBUG_EVENT
:
1534 OUTMSG2 (("gdbserver: kernel event LOAD_DLL_DEBUG_EVENT "
1535 "for pid=%u tid=%x\n",
1536 (unsigned) current_event
.dwProcessId
,
1537 (unsigned) current_event
.dwThreadId
));
1538 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1541 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1542 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1545 case UNLOAD_DLL_DEBUG_EVENT
:
1546 OUTMSG2 (("gdbserver: kernel event UNLOAD_DLL_DEBUG_EVENT "
1547 "for pid=%u tid=%x\n",
1548 (unsigned) current_event
.dwProcessId
,
1549 (unsigned) current_event
.dwThreadId
));
1550 handle_unload_dll ();
1551 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1552 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1555 case EXCEPTION_DEBUG_EVENT
:
1556 OUTMSG2 (("gdbserver: kernel event EXCEPTION_DEBUG_EVENT "
1557 "for pid=%u tid=%x\n",
1558 (unsigned) current_event
.dwProcessId
,
1559 (unsigned) current_event
.dwThreadId
));
1560 handle_exception (ourstatus
);
1563 case OUTPUT_DEBUG_STRING_EVENT
:
1564 /* A message from the kernel (or Cygwin). */
1565 OUTMSG2 (("gdbserver: kernel event OUTPUT_DEBUG_STRING_EVENT "
1566 "for pid=%u tid=%x\n",
1567 (unsigned) current_event
.dwProcessId
,
1568 (unsigned) current_event
.dwThreadId
));
1569 handle_output_debug_string (ourstatus
);
1573 OUTMSG2 (("gdbserver: kernel event unknown "
1574 "for pid=%u tid=%x code=%x\n",
1575 (unsigned) current_event
.dwProcessId
,
1576 (unsigned) current_event
.dwThreadId
,
1577 (unsigned) current_event
.dwDebugEventCode
));
1581 ptid
= debug_event_ptid (¤t_event
);
1583 (struct thread_info
*) find_inferior_id (&all_threads
, ptid
);
1587 /* Wait for the inferior process to change state.
1588 STATUS will be filled in with a response code to send to GDB.
1589 Returns the signal which caused the process to stop. */
1591 win32_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
1593 struct regcache
*regcache
;
1597 if (!get_child_debug_event (ourstatus
))
1600 switch (ourstatus
->kind
)
1602 case TARGET_WAITKIND_EXITED
:
1603 OUTMSG2 (("Child exited with retcode = %x\n",
1604 ourstatus
->value
.integer
));
1605 win32_clear_inferiors ();
1606 return pid_to_ptid (current_event
.dwProcessId
);
1607 case TARGET_WAITKIND_STOPPED
:
1608 case TARGET_WAITKIND_LOADED
:
1609 OUTMSG2 (("Child Stopped with signal = %d \n",
1610 ourstatus
->value
.sig
));
1612 regcache
= get_thread_regcache (current_inferior
, 1);
1613 child_fetch_inferior_registers (regcache
, -1);
1615 if (ourstatus
->kind
== TARGET_WAITKIND_LOADED
1618 /* When gdb connects, we want to be stopped at the
1619 initial breakpoint, not in some dll load event. */
1620 child_continue (DBG_CONTINUE
, -1);
1624 /* We don't expose _LOADED events to gdbserver core. See
1625 the `dlls_changed' global. */
1626 if (ourstatus
->kind
== TARGET_WAITKIND_LOADED
)
1627 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1629 return debug_event_ptid (¤t_event
);
1631 OUTMSG (("Ignoring unknown internal event, %d\n", ourstatus
->kind
));
1633 case TARGET_WAITKIND_SPURIOUS
:
1634 case TARGET_WAITKIND_EXECD
:
1635 /* do nothing, just continue */
1636 child_continue (DBG_CONTINUE
, -1);
1642 /* Fetch registers from the inferior process.
1643 If REGNO is -1, fetch all registers; otherwise, fetch at least REGNO. */
1645 win32_fetch_inferior_registers (struct regcache
*regcache
, int regno
)
1647 child_fetch_inferior_registers (regcache
, regno
);
1650 /* Store registers to the inferior process.
1651 If REGNO is -1, store all registers; otherwise, store at least REGNO. */
1653 win32_store_inferior_registers (struct regcache
*regcache
, int regno
)
1655 child_store_inferior_registers (regcache
, regno
);
1658 /* Read memory from the inferior process. This should generally be
1659 called through read_inferior_memory, which handles breakpoint shadowing.
1660 Read LEN bytes at MEMADDR into a buffer at MYADDR. */
1662 win32_read_inferior_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
1664 return child_xfer_memory (memaddr
, (char *) myaddr
, len
, 0, 0) != len
;
1667 /* Write memory to the inferior process. This should generally be
1668 called through write_inferior_memory, which handles breakpoint shadowing.
1669 Write LEN bytes from the buffer at MYADDR to MEMADDR.
1670 Returns 0 on success and errno on failure. */
1672 win32_write_inferior_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
,
1675 return child_xfer_memory (memaddr
, (char *) myaddr
, len
, 1, 0) != len
;
1678 /* Send an interrupt request to the inferior process. */
1680 win32_request_interrupt (void)
1682 winapi_DebugBreakProcess DebugBreakProcess
;
1683 winapi_GenerateConsoleCtrlEvent GenerateConsoleCtrlEvent
;
1686 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
1688 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
1691 GenerateConsoleCtrlEvent
= GETPROCADDRESS (dll
, GenerateConsoleCtrlEvent
);
1693 if (GenerateConsoleCtrlEvent
!= NULL
1694 && GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, current_process_id
))
1697 /* GenerateConsoleCtrlEvent can fail if process id being debugged is
1698 not a process group id.
1699 Fallback to XP/Vista 'DebugBreakProcess', which generates a
1700 breakpoint exception in the interior process. */
1702 DebugBreakProcess
= GETPROCADDRESS (dll
, DebugBreakProcess
);
1704 if (DebugBreakProcess
!= NULL
1705 && DebugBreakProcess (current_process_handle
))
1708 /* Last resort, suspend all threads manually. */
1709 soft_interrupt_requested
= 1;
1714 win32_error_to_fileio_error (DWORD err
)
1718 case ERROR_BAD_PATHNAME
:
1719 case ERROR_FILE_NOT_FOUND
:
1720 case ERROR_INVALID_NAME
:
1721 case ERROR_PATH_NOT_FOUND
:
1722 return FILEIO_ENOENT
;
1724 case ERROR_IO_DEVICE
:
1725 case ERROR_OPEN_FAILED
:
1727 case ERROR_INVALID_HANDLE
:
1728 return FILEIO_EBADF
;
1729 case ERROR_ACCESS_DENIED
:
1730 case ERROR_SHARING_VIOLATION
:
1731 return FILEIO_EACCES
;
1732 case ERROR_NOACCESS
:
1733 return FILEIO_EFAULT
;
1735 return FILEIO_EBUSY
;
1736 case ERROR_ALREADY_EXISTS
:
1737 case ERROR_FILE_EXISTS
:
1738 return FILEIO_EEXIST
;
1739 case ERROR_BAD_DEVICE
:
1740 return FILEIO_ENODEV
;
1741 case ERROR_DIRECTORY
:
1742 return FILEIO_ENOTDIR
;
1743 case ERROR_FILENAME_EXCED_RANGE
:
1744 case ERROR_INVALID_DATA
:
1745 case ERROR_INVALID_PARAMETER
:
1746 case ERROR_NEGATIVE_SEEK
:
1747 return FILEIO_EINVAL
;
1748 case ERROR_TOO_MANY_OPEN_FILES
:
1749 return FILEIO_EMFILE
;
1750 case ERROR_HANDLE_DISK_FULL
:
1751 case ERROR_DISK_FULL
:
1752 return FILEIO_ENOSPC
;
1753 case ERROR_WRITE_PROTECT
:
1754 return FILEIO_EROFS
;
1755 case ERROR_NOT_SUPPORTED
:
1756 return FILEIO_ENOSYS
;
1759 return FILEIO_EUNKNOWN
;
1763 wince_hostio_last_error (char *buf
)
1765 DWORD winerr
= GetLastError ();
1766 int fileio_err
= win32_error_to_fileio_error (winerr
);
1767 sprintf (buf
, "F-1,%x", fileio_err
);
1771 /* Write Windows OS Thread Information Block address. */
1774 win32_get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
1776 win32_thread_info
*th
;
1777 th
= thread_rec (ptid
, 0);
1781 *addr
= th
->thread_local_base
;
1785 static struct target_ops win32_target_ops
= {
1786 win32_create_inferior
,
1795 win32_fetch_inferior_registers
,
1796 win32_store_inferior_registers
,
1797 NULL
, /* prepare_to_access_memory */
1798 NULL
, /* done_accessing_memory */
1799 win32_read_inferior_memory
,
1800 win32_write_inferior_memory
,
1801 NULL
, /* lookup_symbols */
1802 win32_request_interrupt
,
1803 NULL
, /* read_auxv */
1806 win32_stopped_by_watchpoint
,
1807 win32_stopped_data_address
,
1808 NULL
, /* read_offsets */
1809 NULL
, /* get_tls_address */
1810 NULL
, /* qxfer_spu */
1812 wince_hostio_last_error
,
1814 hostio_last_error_from_errno
,
1816 NULL
, /* qxfer_osdata */
1817 NULL
, /* qxfer_siginfo */
1818 NULL
, /* supports_non_stop */
1820 NULL
, /* start_non_stop */
1821 NULL
, /* supports_multi_process */
1822 NULL
, /* handle_monitor_command */
1823 NULL
, /* core_of_thread */
1824 NULL
, /* read_loadmap */
1825 NULL
, /* process_qsupported */
1826 NULL
, /* supports_tracepoints */
1828 NULL
, /* write_pc */
1829 NULL
, /* thread_stopped */
1830 win32_get_tib_address
1833 /* Initialize the Win32 backend. */
1835 initialize_low (void)
1837 set_target_ops (&win32_target_ops
);
1838 if (the_low_target
.breakpoint
!= NULL
)
1839 set_breakpoint_data (the_low_target
.breakpoint
,
1840 the_low_target
.breakpoint_len
);
1841 the_low_target
.arch_setup ();