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"
40 #include <sys/cygwin.h>
43 #define OUTMSG(X) do { printf X; fflush (stderr); } while (0)
56 #define _T(x) TEXT (x)
60 #define COUNTOF(STR) (sizeof (STR) / sizeof ((STR)[0]))
64 # define GETPROCADDRESS(DLL, PROC) \
65 ((winapi_ ## PROC) GetProcAddress (DLL, TEXT (#PROC)))
67 # define GETPROCADDRESS(DLL, PROC) \
68 ((winapi_ ## PROC) GetProcAddress (DLL, #PROC))
71 int using_threads
= 1;
74 static int attaching
= 0;
75 static HANDLE current_process_handle
= NULL
;
76 static DWORD current_process_id
= 0;
77 static DWORD main_thread_id
= 0;
78 static enum gdb_signal last_sig
= GDB_SIGNAL_0
;
80 /* The current debug event from WaitForDebugEvent. */
81 static DEBUG_EVENT current_event
;
83 /* Non zero if an interrupt request is to be satisfied by suspending
85 static int soft_interrupt_requested
= 0;
87 /* Non zero if the inferior is stopped in a simulated breakpoint done
88 by suspending all the threads. */
89 static int faked_breakpoint
= 0;
91 const struct target_desc
*win32_tdesc
;
93 #define NUM_REGS (the_low_target.num_regs)
95 typedef BOOL (WINAPI
*winapi_DebugActiveProcessStop
) (DWORD dwProcessId
);
96 typedef BOOL (WINAPI
*winapi_DebugSetProcessKillOnExit
) (BOOL KillOnExit
);
97 typedef BOOL (WINAPI
*winapi_DebugBreakProcess
) (HANDLE
);
98 typedef BOOL (WINAPI
*winapi_GenerateConsoleCtrlEvent
) (DWORD
, DWORD
);
100 static void win32_resume (struct thread_resume
*resume_info
, size_t n
);
102 /* Get the thread ID from the current selected inferior (the current
105 current_inferior_ptid (void)
107 return ((struct inferior_list_entry
*) current_inferior
)->id
;
110 /* The current debug event from WaitForDebugEvent. */
112 debug_event_ptid (DEBUG_EVENT
*event
)
114 return ptid_build (event
->dwProcessId
, event
->dwThreadId
, 0);
117 /* Get the thread context of the thread associated with TH. */
120 win32_get_thread_context (win32_thread_info
*th
)
122 memset (&th
->context
, 0, sizeof (CONTEXT
));
123 (*the_low_target
.get_thread_context
) (th
, ¤t_event
);
125 memcpy (&th
->base_context
, &th
->context
, sizeof (CONTEXT
));
129 /* Set the thread context of the thread associated with TH. */
132 win32_set_thread_context (win32_thread_info
*th
)
135 /* Calling SuspendThread on a thread that is running kernel code
136 will report that the suspending was successful, but in fact, that
137 will often not be true. In those cases, the context returned by
138 GetThreadContext will not be correct by the time the thread
139 stops, hence we can't set that context back into the thread when
140 resuming - it will most likelly crash the inferior.
141 Unfortunately, there is no way to know when the thread will
142 really stop. To work around it, we'll only write the context
143 back to the thread when either the user or GDB explicitly change
144 it between stopping and resuming. */
145 if (memcmp (&th
->context
, &th
->base_context
, sizeof (CONTEXT
)) != 0)
147 (*the_low_target
.set_thread_context
) (th
, ¤t_event
);
150 /* Find a thread record given a thread id. If GET_CONTEXT is set then
151 also retrieve the context for this thread. */
152 static win32_thread_info
*
153 thread_rec (ptid_t ptid
, int get_context
)
155 struct thread_info
*thread
;
156 win32_thread_info
*th
;
158 thread
= (struct thread_info
*) find_inferior_id (&all_threads
, ptid
);
162 th
= inferior_target_data (thread
);
163 if (get_context
&& th
->context
.ContextFlags
== 0)
167 if (SuspendThread (th
->h
) == (DWORD
) -1)
169 DWORD err
= GetLastError ();
170 OUTMSG (("warning: SuspendThread failed in thread_rec, "
171 "(error %d): %s\n", (int) err
, strwinerror (err
)));
177 win32_get_thread_context (th
);
183 /* Add a thread to the thread list. */
184 static win32_thread_info
*
185 child_add_thread (DWORD pid
, DWORD tid
, HANDLE h
, void *tlb
)
187 win32_thread_info
*th
;
188 ptid_t ptid
= ptid_build (pid
, tid
, 0);
190 if ((th
= thread_rec (ptid
, FALSE
)))
193 th
= xcalloc (1, sizeof (*th
));
196 th
->thread_local_base
= (CORE_ADDR
) (uintptr_t) tlb
;
198 add_thread (ptid
, th
);
200 if (the_low_target
.thread_added
!= NULL
)
201 (*the_low_target
.thread_added
) (th
);
206 /* Delete a thread from the list of threads. */
208 delete_thread_info (struct inferior_list_entry
*thread
)
210 win32_thread_info
*th
= inferior_target_data ((struct thread_info
*) thread
);
212 remove_thread ((struct thread_info
*) thread
);
217 /* Delete a thread from the list of threads. */
219 child_delete_thread (DWORD pid
, DWORD tid
)
221 struct inferior_list_entry
*thread
;
224 /* If the last thread is exiting, just return. */
225 if (all_threads
.head
== all_threads
.tail
)
228 ptid
= ptid_build (pid
, tid
, 0);
229 thread
= find_inferior_id (&all_threads
, ptid
);
233 delete_thread_info (thread
);
236 /* These watchpoint related wrapper functions simply pass on the function call
237 if the low target has registered a corresponding function. */
240 win32_insert_point (char type
, CORE_ADDR addr
, int len
)
242 if (the_low_target
.insert_point
!= NULL
)
243 return the_low_target
.insert_point (type
, addr
, len
);
245 /* Unsupported (see target.h). */
250 win32_remove_point (char type
, CORE_ADDR addr
, int len
)
252 if (the_low_target
.remove_point
!= NULL
)
253 return the_low_target
.remove_point (type
, addr
, len
);
255 /* Unsupported (see target.h). */
260 win32_stopped_by_watchpoint (void)
262 if (the_low_target
.stopped_by_watchpoint
!= NULL
)
263 return the_low_target
.stopped_by_watchpoint ();
269 win32_stopped_data_address (void)
271 if (the_low_target
.stopped_data_address
!= NULL
)
272 return the_low_target
.stopped_data_address ();
278 /* Transfer memory from/to the debugged process. */
280 child_xfer_memory (CORE_ADDR memaddr
, char *our
, int len
,
281 int write
, struct target_ops
*target
)
286 uintptr_t addr
= (uintptr_t) memaddr
;
290 success
= WriteProcessMemory (current_process_handle
, (LPVOID
) addr
,
291 (LPCVOID
) our
, len
, &done
);
293 lasterror
= GetLastError ();
294 FlushInstructionCache (current_process_handle
, (LPCVOID
) addr
, len
);
298 success
= ReadProcessMemory (current_process_handle
, (LPCVOID
) addr
,
299 (LPVOID
) our
, len
, &done
);
301 lasterror
= GetLastError ();
303 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
306 return success
? done
: -1;
309 /* Clear out any old thread list and reinitialize it to a pristine
312 child_init_thread_list (void)
314 for_each_inferior (&all_threads
, delete_thread_info
);
318 do_initial_child_stuff (HANDLE proch
, DWORD pid
, int attached
)
320 struct process_info
*proc
;
322 last_sig
= GDB_SIGNAL_0
;
324 current_process_handle
= proch
;
325 current_process_id
= pid
;
328 soft_interrupt_requested
= 0;
329 faked_breakpoint
= 0;
331 memset (¤t_event
, 0, sizeof (current_event
));
333 proc
= add_process (pid
, attached
);
334 proc
->tdesc
= win32_tdesc
;
335 child_init_thread_list ();
337 if (the_low_target
.initial_stuff
!= NULL
)
338 (*the_low_target
.initial_stuff
) ();
341 /* Resume all artificially suspended threads if we are continuing
344 continue_one_thread (struct inferior_list_entry
*this_thread
, void *id_ptr
)
346 struct thread_info
*thread
= (struct thread_info
*) this_thread
;
347 int thread_id
= * (int *) id_ptr
;
348 win32_thread_info
*th
= inferior_target_data (thread
);
350 if ((thread_id
== -1 || thread_id
== th
->tid
)
353 if (th
->context
.ContextFlags
)
355 win32_set_thread_context (th
);
356 th
->context
.ContextFlags
= 0;
359 if (ResumeThread (th
->h
) == (DWORD
) -1)
361 DWORD err
= GetLastError ();
362 OUTMSG (("warning: ResumeThread failed in continue_one_thread, "
363 "(error %d): %s\n", (int) err
, strwinerror (err
)));
372 child_continue (DWORD continue_status
, int thread_id
)
374 /* The inferior will only continue after the ContinueDebugEvent
376 find_inferior (&all_threads
, continue_one_thread
, &thread_id
);
377 faked_breakpoint
= 0;
379 if (!ContinueDebugEvent (current_event
.dwProcessId
,
380 current_event
.dwThreadId
,
387 /* Fetch register(s) from the current thread context. */
389 child_fetch_inferior_registers (struct regcache
*regcache
, int r
)
392 win32_thread_info
*th
= thread_rec (current_inferior_ptid (), TRUE
);
393 if (r
== -1 || r
> NUM_REGS
)
394 child_fetch_inferior_registers (regcache
, NUM_REGS
);
396 for (regno
= 0; regno
< r
; regno
++)
397 (*the_low_target
.fetch_inferior_register
) (regcache
, th
, regno
);
400 /* Store a new register value into the current thread context. We don't
401 change the program's context until later, when we resume it. */
403 child_store_inferior_registers (struct regcache
*regcache
, int r
)
406 win32_thread_info
*th
= thread_rec (current_inferior_ptid (), TRUE
);
407 if (r
== -1 || r
== 0 || r
> NUM_REGS
)
408 child_store_inferior_registers (regcache
, NUM_REGS
);
410 for (regno
= 0; regno
< r
; regno
++)
411 (*the_low_target
.store_inferior_register
) (regcache
, th
, regno
);
414 /* Map the Windows error number in ERROR to a locale-dependent error
415 message string and return a pointer to it. Typically, the values
416 for ERROR come from GetLastError.
418 The string pointed to shall not be modified by the application,
419 but may be overwritten by a subsequent call to strwinerror
421 The strwinerror function does not change the current setting
425 strwinerror (DWORD error
)
427 static char buf
[1024];
429 DWORD lasterr
= GetLastError ();
430 DWORD chars
= FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
431 | FORMAT_MESSAGE_ALLOCATE_BUFFER
,
434 0, /* Default language */
440 /* If there is an \r\n appended, zap it. */
442 && msgbuf
[chars
- 2] == '\r'
443 && msgbuf
[chars
- 1] == '\n')
449 if (chars
> ((COUNTOF (buf
)) - 1))
451 chars
= COUNTOF (buf
) - 1;
456 wcstombs (buf
, msgbuf
, chars
+ 1);
458 strncpy (buf
, msgbuf
, chars
+ 1);
463 sprintf (buf
, "unknown win32 error (%u)", (unsigned) error
);
465 SetLastError (lasterr
);
470 create_process (const char *program
, char *args
,
471 DWORD flags
, PROCESS_INFORMATION
*pi
)
476 wchar_t *p
, *wprogram
, *wargs
;
479 wprogram
= alloca ((strlen (program
) + 1) * sizeof (wchar_t));
480 mbstowcs (wprogram
, program
, strlen (program
) + 1);
482 for (p
= wprogram
; *p
; ++p
)
486 argslen
= strlen (args
);
487 wargs
= alloca ((argslen
+ 1) * sizeof (wchar_t));
488 mbstowcs (wargs
, args
, argslen
+ 1);
490 ret
= CreateProcessW (wprogram
, /* image name */
491 wargs
, /* command line */
492 NULL
, /* security, not supported */
493 NULL
, /* thread, not supported */
494 FALSE
, /* inherit handles, not supported */
495 flags
, /* start flags */
496 NULL
, /* environment, not supported */
497 NULL
, /* current directory, not supported */
498 NULL
, /* start info, not supported */
501 STARTUPINFOA si
= { sizeof (STARTUPINFOA
) };
503 ret
= CreateProcessA (program
, /* image name */
504 args
, /* command line */
507 TRUE
, /* inherit handles */
508 flags
, /* start flags */
509 NULL
, /* environment */
510 NULL
, /* current directory */
511 &si
, /* start info */
518 /* Start a new process.
519 PROGRAM is a path to the program to execute.
520 ARGS is a standard NULL-terminated array of arguments,
521 to be passed to the inferior as ``argv''.
522 Returns the new PID on success, -1 on failure. Registers the new
523 process with the process list. */
525 win32_create_inferior (char *program
, char **program_args
)
528 char real_path
[PATH_MAX
];
529 char *orig_path
, *new_path
, *path_ptr
;
536 PROCESS_INFORMATION pi
;
539 /* win32_wait needs to know we're not attaching. */
543 error ("No executable specified, specify executable to debug.\n");
545 flags
= DEBUG_PROCESS
| DEBUG_ONLY_THIS_PROCESS
;
549 path_ptr
= getenv ("PATH");
552 int size
= cygwin_conv_path_list (CCP_POSIX_TO_WIN_A
, path_ptr
, NULL
, 0);
553 orig_path
= alloca (strlen (path_ptr
) + 1);
554 new_path
= alloca (size
);
555 strcpy (orig_path
, path_ptr
);
556 cygwin_conv_path_list (CCP_POSIX_TO_WIN_A
, path_ptr
, new_path
, size
);
557 setenv ("PATH", new_path
, 1);
559 cygwin_conv_path (CCP_POSIX_TO_WIN_A
, program
, real_path
, PATH_MAX
);
564 for (argc
= 1; program_args
[argc
]; argc
++)
565 argslen
+= strlen (program_args
[argc
]) + 1;
566 args
= alloca (argslen
);
568 for (argc
= 1; program_args
[argc
]; argc
++)
570 /* FIXME: Can we do better about quoting? How does Cygwin
573 strcat (args
, program_args
[argc
]);
575 OUTMSG2 (("Command line is \"%s\"\n", args
));
577 #ifdef CREATE_NEW_PROCESS_GROUP
578 flags
|= CREATE_NEW_PROCESS_GROUP
;
581 ret
= create_process (program
, args
, flags
, &pi
);
582 err
= GetLastError ();
583 if (!ret
&& err
== ERROR_FILE_NOT_FOUND
)
585 char *exename
= alloca (strlen (program
) + 5);
586 strcat (strcpy (exename
, program
), ".exe");
587 ret
= create_process (exename
, args
, flags
, &pi
);
588 err
= GetLastError ();
593 setenv ("PATH", orig_path
, 1);
598 error ("Error creating process \"%s%s\", (error %d): %s\n",
599 program
, args
, (int) err
, strwinerror (err
));
603 OUTMSG2 (("Process created: %s\n", (char *) args
));
607 /* On Windows CE this handle can't be closed. The OS reuses
608 it in the debug events, while the 9x/NT versions of Windows
609 probably use a DuplicateHandle'd one. */
610 CloseHandle (pi
.hThread
);
613 do_initial_child_stuff (pi
.hProcess
, pi
.dwProcessId
, 0);
615 return current_process_id
;
618 /* Attach to a running process.
619 PID is the process ID to attach to, specified by the user
620 or a higher layer. */
622 win32_attach (unsigned long pid
)
625 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
628 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
630 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
632 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
634 h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
637 if (DebugActiveProcess (pid
))
639 if (DebugSetProcessKillOnExit
!= NULL
)
640 DebugSetProcessKillOnExit (FALSE
);
642 /* win32_wait needs to know we're attaching. */
644 do_initial_child_stuff (h
, pid
, 1);
651 err
= GetLastError ();
652 error ("Attach to process failed (error %d): %s\n",
653 (int) err
, strwinerror (err
));
656 /* Handle OUTPUT_DEBUG_STRING_EVENT from child process. */
658 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
660 #define READ_BUFFER_LEN 1024
662 char s
[READ_BUFFER_LEN
+ 1] = { 0 };
663 DWORD nbytes
= current_event
.u
.DebugString
.nDebugStringLength
;
668 if (nbytes
> READ_BUFFER_LEN
)
669 nbytes
= READ_BUFFER_LEN
;
671 addr
= (CORE_ADDR
) (size_t) current_event
.u
.DebugString
.lpDebugStringData
;
673 if (current_event
.u
.DebugString
.fUnicode
)
675 /* The event tells us how many bytes, not chars, even
677 WCHAR buffer
[(READ_BUFFER_LEN
+ 1) / sizeof (WCHAR
)] = { 0 };
678 if (read_inferior_memory (addr
, (unsigned char *) buffer
, nbytes
) != 0)
680 wcstombs (s
, buffer
, (nbytes
+ 1) / sizeof (WCHAR
));
684 if (read_inferior_memory (addr
, (unsigned char *) s
, nbytes
) != 0)
688 if (strncmp (s
, "cYg", 3) != 0)
698 #undef READ_BUFFER_LEN
702 win32_clear_inferiors (void)
704 if (current_process_handle
!= NULL
)
705 CloseHandle (current_process_handle
);
707 for_each_inferior (&all_threads
, delete_thread_info
);
711 /* Kill all inferiors. */
715 struct process_info
*process
;
717 if (current_process_handle
== NULL
)
720 TerminateProcess (current_process_handle
, 0);
723 if (!child_continue (DBG_CONTINUE
, -1))
725 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
727 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
729 else if (current_event
.dwDebugEventCode
== OUTPUT_DEBUG_STRING_EVENT
)
731 struct target_waitstatus our_status
= { 0 };
732 handle_output_debug_string (&our_status
);
736 win32_clear_inferiors ();
738 process
= find_process_pid (pid
);
739 remove_process (process
);
743 /* Detach from inferior PID. */
745 win32_detach (int pid
)
747 struct process_info
*process
;
748 winapi_DebugActiveProcessStop DebugActiveProcessStop
= NULL
;
749 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
751 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
753 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
755 DebugActiveProcessStop
= GETPROCADDRESS (dll
, DebugActiveProcessStop
);
756 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
758 if (DebugSetProcessKillOnExit
== NULL
759 || DebugActiveProcessStop
== NULL
)
763 struct thread_resume resume
;
764 resume
.thread
= minus_one_ptid
;
765 resume
.kind
= resume_continue
;
767 win32_resume (&resume
, 1);
770 if (!DebugActiveProcessStop (current_process_id
))
773 DebugSetProcessKillOnExit (FALSE
);
774 process
= find_process_pid (pid
);
775 remove_process (process
);
777 win32_clear_inferiors ();
782 win32_mourn (struct process_info
*process
)
784 remove_process (process
);
787 /* Wait for inferiors to end. */
791 HANDLE h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
794 WaitForSingleObject (h
, INFINITE
);
799 /* Return 1 iff the thread with thread ID TID is alive. */
801 win32_thread_alive (ptid_t ptid
)
805 /* Our thread list is reliable; don't bother to poll target
807 if (find_inferior_id (&all_threads
, ptid
) != NULL
)
814 /* Resume the inferior process. RESUME_INFO describes how we want
817 win32_resume (struct thread_resume
*resume_info
, size_t n
)
822 win32_thread_info
*th
;
823 DWORD continue_status
= DBG_CONTINUE
;
826 /* This handles the very limited set of resume packets that GDB can
827 currently produce. */
829 if (n
== 1 && ptid_equal (resume_info
[0].thread
, minus_one_ptid
))
834 /* Yes, we're ignoring resume_info[0].thread. It'd be tricky to make
835 the Windows resume code do the right thing for thread switching. */
836 tid
= current_event
.dwThreadId
;
838 if (!ptid_equal (resume_info
[0].thread
, minus_one_ptid
))
840 sig
= resume_info
[0].sig
;
841 step
= resume_info
[0].kind
== resume_step
;
849 if (sig
!= GDB_SIGNAL_0
)
851 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
853 OUTMSG (("Cannot continue with signal %d here.\n", sig
));
855 else if (sig
== last_sig
)
856 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
858 OUTMSG (("Can only continue with recieved signal %d.\n", last_sig
));
861 last_sig
= GDB_SIGNAL_0
;
863 /* Get context for the currently selected thread. */
864 ptid
= debug_event_ptid (¤t_event
);
865 th
= thread_rec (ptid
, FALSE
);
868 if (th
->context
.ContextFlags
)
870 /* Move register values from the inferior into the thread
871 context structure. */
872 regcache_invalidate ();
876 if (the_low_target
.single_step
!= NULL
)
877 (*the_low_target
.single_step
) (th
);
879 error ("Single stepping is not supported "
880 "in this configuration.\n");
883 win32_set_thread_context (th
);
884 th
->context
.ContextFlags
= 0;
888 /* Allow continuing with the same signal that interrupted us.
889 Otherwise complain. */
891 child_continue (continue_status
, tid
);
895 win32_add_one_solib (const char *name
, CORE_ADDR load_addr
)
897 char buf
[MAX_PATH
+ 1];
898 char buf2
[MAX_PATH
+ 1];
901 WIN32_FIND_DATA w32_fd
;
902 WCHAR wname
[MAX_PATH
+ 1];
903 mbstowcs (wname
, name
, MAX_PATH
);
904 HANDLE h
= FindFirstFile (wname
, &w32_fd
);
906 WIN32_FIND_DATAA w32_fd
;
907 HANDLE h
= FindFirstFileA (name
, &w32_fd
);
910 if (h
== INVALID_HANDLE_VALUE
)
918 char cwd
[MAX_PATH
+ 1];
920 if (GetCurrentDirectoryA (MAX_PATH
+ 1, cwd
))
922 p
= strrchr (buf
, '\\');
925 SetCurrentDirectoryA (buf
);
926 GetFullPathNameA (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
927 SetCurrentDirectoryA (cwd
);
934 if (strcasecmp (buf
, "ntdll.dll") == 0)
936 GetSystemDirectoryA (buf
, sizeof (buf
));
937 strcat (buf
, "\\ntdll.dll");
942 cygwin_conv_path (CCP_WIN_A_TO_POSIX
, buf
, buf2
, sizeof (buf2
));
947 loaded_dll (buf2
, load_addr
);
951 get_image_name (HANDLE h
, void *address
, int unicode
)
953 static char buf
[(2 * MAX_PATH
) + 1];
954 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
960 /* Attempt to read the name of the dll that was detected.
961 This is documented to work only when actively debugging
962 a program. It will not work for attached processes. */
967 /* Windows CE reports the address of the image name,
968 instead of an address of a pointer into the image name. */
969 address_ptr
= address
;
971 /* See if we could read the address of a string, and that the
972 address isn't null. */
973 if (!ReadProcessMemory (h
, address
, &address_ptr
,
974 sizeof (address_ptr
), &done
)
975 || done
!= sizeof (address_ptr
)
980 /* Find the length of the string */
981 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
982 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
986 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
989 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
990 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
993 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
999 typedef BOOL (WINAPI
*winapi_EnumProcessModules
) (HANDLE
, HMODULE
*,
1001 typedef BOOL (WINAPI
*winapi_GetModuleInformation
) (HANDLE
, HMODULE
,
1002 LPMODULEINFO
, DWORD
);
1003 typedef DWORD (WINAPI
*winapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
,
1006 static winapi_EnumProcessModules win32_EnumProcessModules
;
1007 static winapi_GetModuleInformation win32_GetModuleInformation
;
1008 static winapi_GetModuleFileNameExA win32_GetModuleFileNameExA
;
1013 static int psapi_loaded
= 0;
1014 static HMODULE dll
= NULL
;
1019 dll
= LoadLibrary (TEXT("psapi.dll"));
1022 win32_EnumProcessModules
=
1023 GETPROCADDRESS (dll
, EnumProcessModules
);
1024 win32_GetModuleInformation
=
1025 GETPROCADDRESS (dll
, GetModuleInformation
);
1026 win32_GetModuleFileNameExA
=
1027 GETPROCADDRESS (dll
, GetModuleFileNameExA
);
1030 return (win32_EnumProcessModules
!= NULL
1031 && win32_GetModuleInformation
!= NULL
1032 && win32_GetModuleFileNameExA
!= NULL
);
1036 psapi_get_dll_name (LPVOID BaseAddress
, char *dll_name_ret
)
1042 HMODULE
*DllHandle
= dh_buf
;
1050 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
1055 if (!ok
|| !cbNeeded
)
1058 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
1062 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
1069 for (i
= 0; i
< ((size_t) cbNeeded
/ sizeof (HMODULE
)); i
++)
1071 if (!(*win32_GetModuleInformation
) (current_process_handle
,
1076 DWORD err
= GetLastError ();
1077 error ("Can't get module info: (error %d): %s\n",
1078 (int) err
, strwinerror (err
));
1081 if (mi
.lpBaseOfDll
== BaseAddress
)
1083 len
= (*win32_GetModuleFileNameExA
) (current_process_handle
,
1089 DWORD err
= GetLastError ();
1090 error ("Error getting dll name: (error %d): %s\n",
1091 (int) err
, strwinerror (err
));
1098 dll_name_ret
[0] = '\0';
1102 typedef HANDLE (WINAPI
*winapi_CreateToolhelp32Snapshot
) (DWORD
, DWORD
);
1103 typedef BOOL (WINAPI
*winapi_Module32First
) (HANDLE
, LPMODULEENTRY32
);
1104 typedef BOOL (WINAPI
*winapi_Module32Next
) (HANDLE
, LPMODULEENTRY32
);
1106 static winapi_CreateToolhelp32Snapshot win32_CreateToolhelp32Snapshot
;
1107 static winapi_Module32First win32_Module32First
;
1108 static winapi_Module32Next win32_Module32Next
;
1110 typedef BOOL (WINAPI
*winapi_CloseToolhelp32Snapshot
) (HANDLE
);
1111 static winapi_CloseToolhelp32Snapshot win32_CloseToolhelp32Snapshot
;
1115 load_toolhelp (void)
1117 static int toolhelp_loaded
= 0;
1118 static HMODULE dll
= NULL
;
1120 if (!toolhelp_loaded
)
1122 toolhelp_loaded
= 1;
1124 dll
= GetModuleHandle (_T("KERNEL32.DLL"));
1126 dll
= LoadLibrary (L
"TOOLHELP.DLL");
1131 win32_CreateToolhelp32Snapshot
=
1132 GETPROCADDRESS (dll
, CreateToolhelp32Snapshot
);
1133 win32_Module32First
= GETPROCADDRESS (dll
, Module32First
);
1134 win32_Module32Next
= GETPROCADDRESS (dll
, Module32Next
);
1136 win32_CloseToolhelp32Snapshot
=
1137 GETPROCADDRESS (dll
, CloseToolhelp32Snapshot
);
1141 return (win32_CreateToolhelp32Snapshot
!= NULL
1142 && win32_Module32First
!= NULL
1143 && win32_Module32Next
!= NULL
1145 && win32_CloseToolhelp32Snapshot
!= NULL
1151 toolhelp_get_dll_name (LPVOID BaseAddress
, char *dll_name_ret
)
1153 HANDLE snapshot_module
;
1154 MODULEENTRY32 modEntry
= { sizeof (MODULEENTRY32
) };
1157 if (!load_toolhelp ())
1160 snapshot_module
= win32_CreateToolhelp32Snapshot (TH32CS_SNAPMODULE
,
1161 current_event
.dwProcessId
);
1162 if (snapshot_module
== INVALID_HANDLE_VALUE
)
1165 /* Ignore the first module, which is the exe. */
1166 if (win32_Module32First (snapshot_module
, &modEntry
))
1167 while (win32_Module32Next (snapshot_module
, &modEntry
))
1168 if (modEntry
.modBaseAddr
== BaseAddress
)
1171 wcstombs (dll_name_ret
, modEntry
.szExePath
, MAX_PATH
+ 1);
1173 strcpy (dll_name_ret
, modEntry
.szExePath
);
1180 win32_CloseToolhelp32Snapshot (snapshot_module
);
1182 CloseHandle (snapshot_module
);
1188 handle_load_dll (void)
1190 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
1191 char dll_buf
[MAX_PATH
+ 1];
1192 char *dll_name
= NULL
;
1193 CORE_ADDR load_addr
;
1195 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
1197 /* Windows does not report the image name of the dlls in the debug
1198 event on attaches. We resort to iterating over the list of
1199 loaded dlls looking for a match by image base. */
1200 if (!psapi_get_dll_name (event
->lpBaseOfDll
, dll_buf
))
1202 if (!server_waiting
)
1203 /* On some versions of Windows and Windows CE, we can't create
1204 toolhelp snapshots while the inferior is stopped in a
1205 LOAD_DLL_DEBUG_EVENT due to a dll load, but we can while
1206 Windows is reporting the already loaded dlls. */
1207 toolhelp_get_dll_name (event
->lpBaseOfDll
, dll_buf
);
1212 if (*dll_name
== '\0')
1213 dll_name
= get_image_name (current_process_handle
,
1214 event
->lpImageName
, event
->fUnicode
);
1218 /* The symbols in a dll are offset by 0x1000, which is the
1219 offset from 0 of the first byte in an image - because
1220 of the file header and the section alignment. */
1222 load_addr
= (CORE_ADDR
) (uintptr_t) event
->lpBaseOfDll
+ 0x1000;
1223 win32_add_one_solib (dll_name
, load_addr
);
1227 handle_unload_dll (void)
1229 CORE_ADDR load_addr
=
1230 (CORE_ADDR
) (uintptr_t) current_event
.u
.UnloadDll
.lpBaseOfDll
;
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_inferior
= (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
);
1542 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1543 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1546 case UNLOAD_DLL_DEBUG_EVENT
:
1547 OUTMSG2 (("gdbserver: kernel event UNLOAD_DLL_DEBUG_EVENT "
1548 "for pid=%u tid=%x\n",
1549 (unsigned) current_event
.dwProcessId
,
1550 (unsigned) current_event
.dwThreadId
));
1551 handle_unload_dll ();
1552 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1553 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1556 case EXCEPTION_DEBUG_EVENT
:
1557 OUTMSG2 (("gdbserver: kernel event EXCEPTION_DEBUG_EVENT "
1558 "for pid=%u tid=%x\n",
1559 (unsigned) current_event
.dwProcessId
,
1560 (unsigned) current_event
.dwThreadId
));
1561 handle_exception (ourstatus
);
1564 case OUTPUT_DEBUG_STRING_EVENT
:
1565 /* A message from the kernel (or Cygwin). */
1566 OUTMSG2 (("gdbserver: kernel event OUTPUT_DEBUG_STRING_EVENT "
1567 "for pid=%u tid=%x\n",
1568 (unsigned) current_event
.dwProcessId
,
1569 (unsigned) current_event
.dwThreadId
));
1570 handle_output_debug_string (ourstatus
);
1574 OUTMSG2 (("gdbserver: kernel event unknown "
1575 "for pid=%u tid=%x code=%x\n",
1576 (unsigned) current_event
.dwProcessId
,
1577 (unsigned) current_event
.dwThreadId
,
1578 (unsigned) current_event
.dwDebugEventCode
));
1582 ptid
= debug_event_ptid (¤t_event
);
1584 (struct thread_info
*) find_inferior_id (&all_threads
, ptid
);
1588 /* Wait for the inferior process to change state.
1589 STATUS will be filled in with a response code to send to GDB.
1590 Returns the signal which caused the process to stop. */
1592 win32_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
1594 struct regcache
*regcache
;
1598 if (!get_child_debug_event (ourstatus
))
1601 switch (ourstatus
->kind
)
1603 case TARGET_WAITKIND_EXITED
:
1604 OUTMSG2 (("Child exited with retcode = %x\n",
1605 ourstatus
->value
.integer
));
1606 win32_clear_inferiors ();
1607 return pid_to_ptid (current_event
.dwProcessId
);
1608 case TARGET_WAITKIND_STOPPED
:
1609 case TARGET_WAITKIND_LOADED
:
1610 OUTMSG2 (("Child Stopped with signal = %d \n",
1611 ourstatus
->value
.sig
));
1613 regcache
= get_thread_regcache (current_inferior
, 1);
1614 child_fetch_inferior_registers (regcache
, -1);
1616 if (ourstatus
->kind
== TARGET_WAITKIND_LOADED
1619 /* When gdb connects, we want to be stopped at the
1620 initial breakpoint, not in some dll load event. */
1621 child_continue (DBG_CONTINUE
, -1);
1625 /* We don't expose _LOADED events to gdbserver core. See
1626 the `dlls_changed' global. */
1627 if (ourstatus
->kind
== TARGET_WAITKIND_LOADED
)
1628 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
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
,
1796 win32_fetch_inferior_registers
,
1797 win32_store_inferior_registers
,
1798 NULL
, /* prepare_to_access_memory */
1799 NULL
, /* done_accessing_memory */
1800 win32_read_inferior_memory
,
1801 win32_write_inferior_memory
,
1802 NULL
, /* lookup_symbols */
1803 win32_request_interrupt
,
1804 NULL
, /* read_auxv */
1807 win32_stopped_by_watchpoint
,
1808 win32_stopped_data_address
,
1809 NULL
, /* read_offsets */
1810 NULL
, /* get_tls_address */
1811 NULL
, /* qxfer_spu */
1813 wince_hostio_last_error
,
1815 hostio_last_error_from_errno
,
1817 NULL
, /* qxfer_osdata */
1818 NULL
, /* qxfer_siginfo */
1819 NULL
, /* supports_non_stop */
1821 NULL
, /* start_non_stop */
1822 NULL
, /* supports_multi_process */
1823 NULL
, /* handle_monitor_command */
1824 NULL
, /* core_of_thread */
1825 NULL
, /* read_loadmap */
1826 NULL
, /* process_qsupported */
1827 NULL
, /* supports_tracepoints */
1829 NULL
, /* write_pc */
1830 NULL
, /* thread_stopped */
1831 win32_get_tib_address
1834 /* Initialize the Win32 backend. */
1836 initialize_low (void)
1838 set_target_ops (&win32_target_ops
);
1839 if (the_low_target
.breakpoint
!= NULL
)
1840 set_breakpoint_data (the_low_target
.breakpoint
,
1841 the_low_target
.breakpoint_len
);
1842 the_low_target
.arch_setup ();