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"
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 gdb_signal last_sig
= GDB_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 const struct target_desc
*win32_tdesc
;
91 #define NUM_REGS (the_low_target.num_regs)
93 typedef BOOL (WINAPI
*winapi_DebugActiveProcessStop
) (DWORD dwProcessId
);
94 typedef BOOL (WINAPI
*winapi_DebugSetProcessKillOnExit
) (BOOL KillOnExit
);
95 typedef BOOL (WINAPI
*winapi_DebugBreakProcess
) (HANDLE
);
96 typedef BOOL (WINAPI
*winapi_GenerateConsoleCtrlEvent
) (DWORD
, DWORD
);
98 static void win32_resume (struct thread_resume
*resume_info
, size_t n
);
100 /* Get the thread ID from the current selected inferior (the current
103 current_inferior_ptid (void)
105 return ((struct inferior_list_entry
*) current_inferior
)->id
;
108 /* The current debug event from WaitForDebugEvent. */
110 debug_event_ptid (DEBUG_EVENT
*event
)
112 return ptid_build (event
->dwProcessId
, event
->dwThreadId
, 0);
115 /* Get the thread context of the thread associated with TH. */
118 win32_get_thread_context (win32_thread_info
*th
)
120 memset (&th
->context
, 0, sizeof (CONTEXT
));
121 (*the_low_target
.get_thread_context
) (th
, ¤t_event
);
123 memcpy (&th
->base_context
, &th
->context
, sizeof (CONTEXT
));
127 /* Set the thread context of the thread associated with TH. */
130 win32_set_thread_context (win32_thread_info
*th
)
133 /* Calling SuspendThread on a thread that is running kernel code
134 will report that the suspending was successful, but in fact, that
135 will often not be true. In those cases, the context returned by
136 GetThreadContext will not be correct by the time the thread
137 stops, hence we can't set that context back into the thread when
138 resuming - it will most likelly crash the inferior.
139 Unfortunately, there is no way to know when the thread will
140 really stop. To work around it, we'll only write the context
141 back to the thread when either the user or GDB explicitly change
142 it between stopping and resuming. */
143 if (memcmp (&th
->context
, &th
->base_context
, sizeof (CONTEXT
)) != 0)
145 (*the_low_target
.set_thread_context
) (th
, ¤t_event
);
148 /* Find a thread record given a thread id. If GET_CONTEXT is set then
149 also retrieve the context for this thread. */
150 static win32_thread_info
*
151 thread_rec (ptid_t ptid
, int get_context
)
153 struct thread_info
*thread
;
154 win32_thread_info
*th
;
156 thread
= (struct thread_info
*) find_inferior_id (&all_threads
, ptid
);
160 th
= inferior_target_data (thread
);
161 if (get_context
&& th
->context
.ContextFlags
== 0)
165 if (SuspendThread (th
->h
) == (DWORD
) -1)
167 DWORD err
= GetLastError ();
168 OUTMSG (("warning: SuspendThread failed in thread_rec, "
169 "(error %d): %s\n", (int) err
, strwinerror (err
)));
175 win32_get_thread_context (th
);
181 /* Add a thread to the thread list. */
182 static win32_thread_info
*
183 child_add_thread (DWORD pid
, DWORD tid
, HANDLE h
, void *tlb
)
185 win32_thread_info
*th
;
186 ptid_t ptid
= ptid_build (pid
, tid
, 0);
188 if ((th
= thread_rec (ptid
, FALSE
)))
191 th
= xcalloc (1, sizeof (*th
));
194 th
->thread_local_base
= (CORE_ADDR
) (uintptr_t) tlb
;
196 add_thread (ptid
, th
);
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
)
284 uintptr_t addr
= (uintptr_t) memaddr
;
288 success
= WriteProcessMemory (current_process_handle
, (LPVOID
) addr
,
289 (LPCVOID
) our
, len
, &done
);
291 lasterror
= GetLastError ();
292 FlushInstructionCache (current_process_handle
, (LPCVOID
) addr
, len
);
296 success
= ReadProcessMemory (current_process_handle
, (LPCVOID
) addr
,
297 (LPVOID
) our
, len
, &done
);
299 lasterror
= GetLastError ();
301 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
304 return success
? done
: -1;
307 /* Clear out any old thread list and reinitialize it to a pristine
310 child_init_thread_list (void)
312 for_each_inferior (&all_threads
, delete_thread_info
);
316 do_initial_child_stuff (HANDLE proch
, DWORD pid
, int attached
)
318 struct process_info
*proc
;
320 last_sig
= GDB_SIGNAL_0
;
322 current_process_handle
= proch
;
323 current_process_id
= pid
;
326 soft_interrupt_requested
= 0;
327 faked_breakpoint
= 0;
329 memset (¤t_event
, 0, sizeof (current_event
));
331 proc
= add_process (pid
, attached
);
332 proc
->tdesc
= win32_tdesc
;
333 child_init_thread_list ();
335 if (the_low_target
.initial_stuff
!= NULL
)
336 (*the_low_target
.initial_stuff
) ();
339 /* Resume all artificially suspended threads if we are continuing
342 continue_one_thread (struct inferior_list_entry
*this_thread
, void *id_ptr
)
344 struct thread_info
*thread
= (struct thread_info
*) this_thread
;
345 int thread_id
= * (int *) id_ptr
;
346 win32_thread_info
*th
= inferior_target_data (thread
);
348 if ((thread_id
== -1 || thread_id
== th
->tid
)
351 if (th
->context
.ContextFlags
)
353 win32_set_thread_context (th
);
354 th
->context
.ContextFlags
= 0;
357 if (ResumeThread (th
->h
) == (DWORD
) -1)
359 DWORD err
= GetLastError ();
360 OUTMSG (("warning: ResumeThread failed in continue_one_thread, "
361 "(error %d): %s\n", (int) err
, strwinerror (err
)));
370 child_continue (DWORD continue_status
, int thread_id
)
372 /* The inferior will only continue after the ContinueDebugEvent
374 find_inferior (&all_threads
, continue_one_thread
, &thread_id
);
375 faked_breakpoint
= 0;
377 if (!ContinueDebugEvent (current_event
.dwProcessId
,
378 current_event
.dwThreadId
,
385 /* Fetch register(s) from the current thread context. */
387 child_fetch_inferior_registers (struct regcache
*regcache
, int r
)
390 win32_thread_info
*th
= thread_rec (current_inferior_ptid (), TRUE
);
391 if (r
== -1 || r
> NUM_REGS
)
392 child_fetch_inferior_registers (regcache
, NUM_REGS
);
394 for (regno
= 0; regno
< r
; regno
++)
395 (*the_low_target
.fetch_inferior_register
) (regcache
, th
, regno
);
398 /* Store a new register value into the current thread context. We don't
399 change the program's context until later, when we resume it. */
401 child_store_inferior_registers (struct regcache
*regcache
, int r
)
404 win32_thread_info
*th
= thread_rec (current_inferior_ptid (), TRUE
);
405 if (r
== -1 || r
== 0 || r
> NUM_REGS
)
406 child_store_inferior_registers (regcache
, NUM_REGS
);
408 for (regno
= 0; regno
< r
; regno
++)
409 (*the_low_target
.store_inferior_register
) (regcache
, th
, regno
);
412 /* Map the Windows error number in ERROR to a locale-dependent error
413 message string and return a pointer to it. Typically, the values
414 for ERROR come from GetLastError.
416 The string pointed to shall not be modified by the application,
417 but may be overwritten by a subsequent call to strwinerror
419 The strwinerror function does not change the current setting
423 strwinerror (DWORD error
)
425 static char buf
[1024];
427 DWORD lasterr
= GetLastError ();
428 DWORD chars
= FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
429 | FORMAT_MESSAGE_ALLOCATE_BUFFER
,
432 0, /* Default language */
438 /* If there is an \r\n appended, zap it. */
440 && msgbuf
[chars
- 2] == '\r'
441 && msgbuf
[chars
- 1] == '\n')
447 if (chars
> ((COUNTOF (buf
)) - 1))
449 chars
= COUNTOF (buf
) - 1;
454 wcstombs (buf
, msgbuf
, chars
+ 1);
456 strncpy (buf
, msgbuf
, chars
+ 1);
461 sprintf (buf
, "unknown win32 error (%u)", (unsigned) error
);
463 SetLastError (lasterr
);
468 create_process (const char *program
, char *args
,
469 DWORD flags
, PROCESS_INFORMATION
*pi
)
474 wchar_t *p
, *wprogram
, *wargs
;
477 wprogram
= alloca ((strlen (program
) + 1) * sizeof (wchar_t));
478 mbstowcs (wprogram
, program
, strlen (program
) + 1);
480 for (p
= wprogram
; *p
; ++p
)
484 argslen
= strlen (args
);
485 wargs
= alloca ((argslen
+ 1) * sizeof (wchar_t));
486 mbstowcs (wargs
, args
, argslen
+ 1);
488 ret
= CreateProcessW (wprogram
, /* image name */
489 wargs
, /* command line */
490 NULL
, /* security, not supported */
491 NULL
, /* thread, not supported */
492 FALSE
, /* inherit handles, not supported */
493 flags
, /* start flags */
494 NULL
, /* environment, not supported */
495 NULL
, /* current directory, not supported */
496 NULL
, /* start info, not supported */
499 STARTUPINFOA si
= { sizeof (STARTUPINFOA
) };
501 ret
= CreateProcessA (program
, /* image name */
502 args
, /* command line */
505 TRUE
, /* inherit handles */
506 flags
, /* start flags */
507 NULL
, /* environment */
508 NULL
, /* current directory */
509 &si
, /* start info */
516 /* Start a new process.
517 PROGRAM is a path to the program to execute.
518 ARGS is a standard NULL-terminated array of arguments,
519 to be passed to the inferior as ``argv''.
520 Returns the new PID on success, -1 on failure. Registers the new
521 process with the process list. */
523 win32_create_inferior (char *program
, char **program_args
)
526 char real_path
[PATH_MAX
];
527 char *orig_path
, *new_path
, *path_ptr
;
534 PROCESS_INFORMATION pi
;
537 /* win32_wait needs to know we're not attaching. */
541 error ("No executable specified, specify executable to debug.\n");
543 flags
= DEBUG_PROCESS
| DEBUG_ONLY_THIS_PROCESS
;
547 path_ptr
= getenv ("PATH");
550 int size
= cygwin_conv_path_list (CCP_POSIX_TO_WIN_A
, path_ptr
, NULL
, 0);
551 orig_path
= alloca (strlen (path_ptr
) + 1);
552 new_path
= alloca (size
);
553 strcpy (orig_path
, path_ptr
);
554 cygwin_conv_path_list (CCP_POSIX_TO_WIN_A
, path_ptr
, new_path
, size
);
555 setenv ("PATH", new_path
, 1);
557 cygwin_conv_path (CCP_POSIX_TO_WIN_A
, program
, real_path
, PATH_MAX
);
562 for (argc
= 1; program_args
[argc
]; argc
++)
563 argslen
+= strlen (program_args
[argc
]) + 1;
564 args
= alloca (argslen
);
566 for (argc
= 1; program_args
[argc
]; argc
++)
568 /* FIXME: Can we do better about quoting? How does Cygwin
571 strcat (args
, program_args
[argc
]);
573 OUTMSG2 (("Command line is \"%s\"\n", args
));
575 #ifdef CREATE_NEW_PROCESS_GROUP
576 flags
|= CREATE_NEW_PROCESS_GROUP
;
579 ret
= create_process (program
, args
, flags
, &pi
);
580 err
= GetLastError ();
581 if (!ret
&& err
== ERROR_FILE_NOT_FOUND
)
583 char *exename
= alloca (strlen (program
) + 5);
584 strcat (strcpy (exename
, program
), ".exe");
585 ret
= create_process (exename
, args
, flags
, &pi
);
586 err
= GetLastError ();
591 setenv ("PATH", orig_path
, 1);
596 error ("Error creating process \"%s%s\", (error %d): %s\n",
597 program
, args
, (int) err
, strwinerror (err
));
601 OUTMSG2 (("Process created: %s\n", (char *) args
));
605 /* On Windows CE this handle can't be closed. The OS reuses
606 it in the debug events, while the 9x/NT versions of Windows
607 probably use a DuplicateHandle'd one. */
608 CloseHandle (pi
.hThread
);
611 do_initial_child_stuff (pi
.hProcess
, pi
.dwProcessId
, 0);
613 return current_process_id
;
616 /* Attach to a running process.
617 PID is the process ID to attach to, specified by the user
618 or a higher layer. */
620 win32_attach (unsigned long pid
)
623 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
626 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
628 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
630 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
632 h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
635 if (DebugActiveProcess (pid
))
637 if (DebugSetProcessKillOnExit
!= NULL
)
638 DebugSetProcessKillOnExit (FALSE
);
640 /* win32_wait needs to know we're attaching. */
642 do_initial_child_stuff (h
, pid
, 1);
649 err
= GetLastError ();
650 error ("Attach to process failed (error %d): %s\n",
651 (int) err
, strwinerror (err
));
654 /* Handle OUTPUT_DEBUG_STRING_EVENT from child process. */
656 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
658 #define READ_BUFFER_LEN 1024
660 char s
[READ_BUFFER_LEN
+ 1] = { 0 };
661 DWORD nbytes
= current_event
.u
.DebugString
.nDebugStringLength
;
666 if (nbytes
> READ_BUFFER_LEN
)
667 nbytes
= READ_BUFFER_LEN
;
669 addr
= (CORE_ADDR
) (size_t) current_event
.u
.DebugString
.lpDebugStringData
;
671 if (current_event
.u
.DebugString
.fUnicode
)
673 /* The event tells us how many bytes, not chars, even
675 WCHAR buffer
[(READ_BUFFER_LEN
+ 1) / sizeof (WCHAR
)] = { 0 };
676 if (read_inferior_memory (addr
, (unsigned char *) buffer
, nbytes
) != 0)
678 wcstombs (s
, buffer
, (nbytes
+ 1) / sizeof (WCHAR
));
682 if (read_inferior_memory (addr
, (unsigned char *) s
, nbytes
) != 0)
686 if (strncmp (s
, "cYg", 3) != 0)
696 #undef READ_BUFFER_LEN
700 win32_clear_inferiors (void)
702 if (current_process_handle
!= NULL
)
703 CloseHandle (current_process_handle
);
705 for_each_inferior (&all_threads
, delete_thread_info
);
709 /* Kill all inferiors. */
713 struct process_info
*process
;
715 if (current_process_handle
== NULL
)
718 TerminateProcess (current_process_handle
, 0);
721 if (!child_continue (DBG_CONTINUE
, -1))
723 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
725 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
727 else if (current_event
.dwDebugEventCode
== OUTPUT_DEBUG_STRING_EVENT
)
729 struct target_waitstatus our_status
= { 0 };
730 handle_output_debug_string (&our_status
);
734 win32_clear_inferiors ();
736 process
= find_process_pid (pid
);
737 remove_process (process
);
741 /* Detach from inferior PID. */
743 win32_detach (int pid
)
745 struct process_info
*process
;
746 winapi_DebugActiveProcessStop DebugActiveProcessStop
= NULL
;
747 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
749 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
751 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
753 DebugActiveProcessStop
= GETPROCADDRESS (dll
, DebugActiveProcessStop
);
754 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
756 if (DebugSetProcessKillOnExit
== NULL
757 || DebugActiveProcessStop
== NULL
)
761 struct thread_resume resume
;
762 resume
.thread
= minus_one_ptid
;
763 resume
.kind
= resume_continue
;
765 win32_resume (&resume
, 1);
768 if (!DebugActiveProcessStop (current_process_id
))
771 DebugSetProcessKillOnExit (FALSE
);
772 process
= find_process_pid (pid
);
773 remove_process (process
);
775 win32_clear_inferiors ();
780 win32_mourn (struct process_info
*process
)
782 remove_process (process
);
785 /* Wait for inferiors to end. */
789 HANDLE h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
792 WaitForSingleObject (h
, INFINITE
);
797 /* Return 1 iff the thread with thread ID TID is alive. */
799 win32_thread_alive (ptid_t ptid
)
803 /* Our thread list is reliable; don't bother to poll target
805 if (find_inferior_id (&all_threads
, ptid
) != NULL
)
812 /* Resume the inferior process. RESUME_INFO describes how we want
815 win32_resume (struct thread_resume
*resume_info
, size_t n
)
820 win32_thread_info
*th
;
821 DWORD continue_status
= DBG_CONTINUE
;
824 /* This handles the very limited set of resume packets that GDB can
825 currently produce. */
827 if (n
== 1 && ptid_equal (resume_info
[0].thread
, minus_one_ptid
))
832 /* Yes, we're ignoring resume_info[0].thread. It'd be tricky to make
833 the Windows resume code do the right thing for thread switching. */
834 tid
= current_event
.dwThreadId
;
836 if (!ptid_equal (resume_info
[0].thread
, minus_one_ptid
))
838 sig
= resume_info
[0].sig
;
839 step
= resume_info
[0].kind
== resume_step
;
847 if (sig
!= GDB_SIGNAL_0
)
849 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
851 OUTMSG (("Cannot continue with signal %d here.\n", sig
));
853 else if (sig
== last_sig
)
854 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
856 OUTMSG (("Can only continue with recieved signal %d.\n", last_sig
));
859 last_sig
= GDB_SIGNAL_0
;
861 /* Get context for the currently selected thread. */
862 ptid
= debug_event_ptid (¤t_event
);
863 th
= thread_rec (ptid
, FALSE
);
866 if (th
->context
.ContextFlags
)
868 /* Move register values from the inferior into the thread
869 context structure. */
870 regcache_invalidate ();
874 if (the_low_target
.single_step
!= NULL
)
875 (*the_low_target
.single_step
) (th
);
877 error ("Single stepping is not supported "
878 "in this configuration.\n");
881 win32_set_thread_context (th
);
882 th
->context
.ContextFlags
= 0;
886 /* Allow continuing with the same signal that interrupted us.
887 Otherwise complain. */
889 child_continue (continue_status
, tid
);
893 win32_add_one_solib (const char *name
, CORE_ADDR load_addr
)
895 char buf
[MAX_PATH
+ 1];
896 char buf2
[MAX_PATH
+ 1];
899 WIN32_FIND_DATA w32_fd
;
900 WCHAR wname
[MAX_PATH
+ 1];
901 mbstowcs (wname
, name
, MAX_PATH
);
902 HANDLE h
= FindFirstFile (wname
, &w32_fd
);
904 WIN32_FIND_DATAA w32_fd
;
905 HANDLE h
= FindFirstFileA (name
, &w32_fd
);
908 if (h
== INVALID_HANDLE_VALUE
)
916 char cwd
[MAX_PATH
+ 1];
918 if (GetCurrentDirectoryA (MAX_PATH
+ 1, cwd
))
920 p
= strrchr (buf
, '\\');
923 SetCurrentDirectoryA (buf
);
924 GetFullPathNameA (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
925 SetCurrentDirectoryA (cwd
);
932 if (strcasecmp (buf
, "ntdll.dll") == 0)
934 GetSystemDirectoryA (buf
, sizeof (buf
));
935 strcat (buf
, "\\ntdll.dll");
940 cygwin_conv_path (CCP_WIN_A_TO_POSIX
, buf
, buf2
, sizeof (buf2
));
945 loaded_dll (buf2
, load_addr
);
949 get_image_name (HANDLE h
, void *address
, int unicode
)
951 static char buf
[(2 * MAX_PATH
) + 1];
952 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
958 /* Attempt to read the name of the dll that was detected.
959 This is documented to work only when actively debugging
960 a program. It will not work for attached processes. */
965 /* Windows CE reports the address of the image name,
966 instead of an address of a pointer into the image name. */
967 address_ptr
= address
;
969 /* See if we could read the address of a string, and that the
970 address isn't null. */
971 if (!ReadProcessMemory (h
, address
, &address_ptr
,
972 sizeof (address_ptr
), &done
)
973 || done
!= sizeof (address_ptr
)
978 /* Find the length of the string */
979 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
980 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
984 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
987 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
988 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
991 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
997 typedef BOOL (WINAPI
*winapi_EnumProcessModules
) (HANDLE
, HMODULE
*,
999 typedef BOOL (WINAPI
*winapi_GetModuleInformation
) (HANDLE
, HMODULE
,
1000 LPMODULEINFO
, DWORD
);
1001 typedef DWORD (WINAPI
*winapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
,
1004 static winapi_EnumProcessModules win32_EnumProcessModules
;
1005 static winapi_GetModuleInformation win32_GetModuleInformation
;
1006 static winapi_GetModuleFileNameExA win32_GetModuleFileNameExA
;
1011 static int psapi_loaded
= 0;
1012 static HMODULE dll
= NULL
;
1017 dll
= LoadLibrary (TEXT("psapi.dll"));
1020 win32_EnumProcessModules
=
1021 GETPROCADDRESS (dll
, EnumProcessModules
);
1022 win32_GetModuleInformation
=
1023 GETPROCADDRESS (dll
, GetModuleInformation
);
1024 win32_GetModuleFileNameExA
=
1025 GETPROCADDRESS (dll
, GetModuleFileNameExA
);
1028 return (win32_EnumProcessModules
!= NULL
1029 && win32_GetModuleInformation
!= NULL
1030 && win32_GetModuleFileNameExA
!= NULL
);
1034 psapi_get_dll_name (LPVOID BaseAddress
, char *dll_name_ret
)
1040 HMODULE
*DllHandle
= dh_buf
;
1048 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
1053 if (!ok
|| !cbNeeded
)
1056 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
1060 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
1067 for (i
= 0; i
< ((size_t) cbNeeded
/ sizeof (HMODULE
)); i
++)
1069 if (!(*win32_GetModuleInformation
) (current_process_handle
,
1074 DWORD err
= GetLastError ();
1075 error ("Can't get module info: (error %d): %s\n",
1076 (int) err
, strwinerror (err
));
1079 if (mi
.lpBaseOfDll
== BaseAddress
)
1081 len
= (*win32_GetModuleFileNameExA
) (current_process_handle
,
1087 DWORD err
= GetLastError ();
1088 error ("Error getting dll name: (error %d): %s\n",
1089 (int) err
, strwinerror (err
));
1096 dll_name_ret
[0] = '\0';
1100 typedef HANDLE (WINAPI
*winapi_CreateToolhelp32Snapshot
) (DWORD
, DWORD
);
1101 typedef BOOL (WINAPI
*winapi_Module32First
) (HANDLE
, LPMODULEENTRY32
);
1102 typedef BOOL (WINAPI
*winapi_Module32Next
) (HANDLE
, LPMODULEENTRY32
);
1104 static winapi_CreateToolhelp32Snapshot win32_CreateToolhelp32Snapshot
;
1105 static winapi_Module32First win32_Module32First
;
1106 static winapi_Module32Next win32_Module32Next
;
1108 typedef BOOL (WINAPI
*winapi_CloseToolhelp32Snapshot
) (HANDLE
);
1109 static winapi_CloseToolhelp32Snapshot win32_CloseToolhelp32Snapshot
;
1113 load_toolhelp (void)
1115 static int toolhelp_loaded
= 0;
1116 static HMODULE dll
= NULL
;
1118 if (!toolhelp_loaded
)
1120 toolhelp_loaded
= 1;
1122 dll
= GetModuleHandle (_T("KERNEL32.DLL"));
1124 dll
= LoadLibrary (L
"TOOLHELP.DLL");
1129 win32_CreateToolhelp32Snapshot
=
1130 GETPROCADDRESS (dll
, CreateToolhelp32Snapshot
);
1131 win32_Module32First
= GETPROCADDRESS (dll
, Module32First
);
1132 win32_Module32Next
= GETPROCADDRESS (dll
, Module32Next
);
1134 win32_CloseToolhelp32Snapshot
=
1135 GETPROCADDRESS (dll
, CloseToolhelp32Snapshot
);
1139 return (win32_CreateToolhelp32Snapshot
!= NULL
1140 && win32_Module32First
!= NULL
1141 && win32_Module32Next
!= NULL
1143 && win32_CloseToolhelp32Snapshot
!= NULL
1149 toolhelp_get_dll_name (LPVOID BaseAddress
, char *dll_name_ret
)
1151 HANDLE snapshot_module
;
1152 MODULEENTRY32 modEntry
= { sizeof (MODULEENTRY32
) };
1155 if (!load_toolhelp ())
1158 snapshot_module
= win32_CreateToolhelp32Snapshot (TH32CS_SNAPMODULE
,
1159 current_event
.dwProcessId
);
1160 if (snapshot_module
== INVALID_HANDLE_VALUE
)
1163 /* Ignore the first module, which is the exe. */
1164 if (win32_Module32First (snapshot_module
, &modEntry
))
1165 while (win32_Module32Next (snapshot_module
, &modEntry
))
1166 if (modEntry
.modBaseAddr
== BaseAddress
)
1169 wcstombs (dll_name_ret
, modEntry
.szExePath
, MAX_PATH
+ 1);
1171 strcpy (dll_name_ret
, modEntry
.szExePath
);
1178 win32_CloseToolhelp32Snapshot (snapshot_module
);
1180 CloseHandle (snapshot_module
);
1186 handle_load_dll (void)
1188 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
1189 char dll_buf
[MAX_PATH
+ 1];
1190 char *dll_name
= NULL
;
1191 CORE_ADDR load_addr
;
1193 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
1195 /* Windows does not report the image name of the dlls in the debug
1196 event on attaches. We resort to iterating over the list of
1197 loaded dlls looking for a match by image base. */
1198 if (!psapi_get_dll_name (event
->lpBaseOfDll
, dll_buf
))
1200 if (!server_waiting
)
1201 /* On some versions of Windows and Windows CE, we can't create
1202 toolhelp snapshots while the inferior is stopped in a
1203 LOAD_DLL_DEBUG_EVENT due to a dll load, but we can while
1204 Windows is reporting the already loaded dlls. */
1205 toolhelp_get_dll_name (event
->lpBaseOfDll
, dll_buf
);
1210 if (*dll_name
== '\0')
1211 dll_name
= get_image_name (current_process_handle
,
1212 event
->lpImageName
, event
->fUnicode
);
1216 /* The symbols in a dll are offset by 0x1000, which is the
1217 offset from 0 of the first byte in an image - because
1218 of the file header and the section alignment. */
1220 load_addr
= (CORE_ADDR
) (uintptr_t) event
->lpBaseOfDll
+ 0x1000;
1221 win32_add_one_solib (dll_name
, load_addr
);
1225 handle_unload_dll (void)
1227 CORE_ADDR load_addr
=
1228 (CORE_ADDR
) (uintptr_t) current_event
.u
.UnloadDll
.lpBaseOfDll
;
1229 load_addr
+= 0x1000;
1230 unloaded_dll (NULL
, load_addr
);
1234 handle_exception (struct target_waitstatus
*ourstatus
)
1236 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1238 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1242 case EXCEPTION_ACCESS_VIOLATION
:
1243 OUTMSG2 (("EXCEPTION_ACCESS_VIOLATION"));
1244 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1246 case STATUS_STACK_OVERFLOW
:
1247 OUTMSG2 (("STATUS_STACK_OVERFLOW"));
1248 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1250 case STATUS_FLOAT_DENORMAL_OPERAND
:
1251 OUTMSG2 (("STATUS_FLOAT_DENORMAL_OPERAND"));
1252 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1254 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1255 OUTMSG2 (("EXCEPTION_ARRAY_BOUNDS_EXCEEDED"));
1256 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1258 case STATUS_FLOAT_INEXACT_RESULT
:
1259 OUTMSG2 (("STATUS_FLOAT_INEXACT_RESULT"));
1260 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1262 case STATUS_FLOAT_INVALID_OPERATION
:
1263 OUTMSG2 (("STATUS_FLOAT_INVALID_OPERATION"));
1264 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1266 case STATUS_FLOAT_OVERFLOW
:
1267 OUTMSG2 (("STATUS_FLOAT_OVERFLOW"));
1268 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1270 case STATUS_FLOAT_STACK_CHECK
:
1271 OUTMSG2 (("STATUS_FLOAT_STACK_CHECK"));
1272 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1274 case STATUS_FLOAT_UNDERFLOW
:
1275 OUTMSG2 (("STATUS_FLOAT_UNDERFLOW"));
1276 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1278 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1279 OUTMSG2 (("STATUS_FLOAT_DIVIDE_BY_ZERO"));
1280 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1282 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1283 OUTMSG2 (("STATUS_INTEGER_DIVIDE_BY_ZERO"));
1284 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1286 case STATUS_INTEGER_OVERFLOW
:
1287 OUTMSG2 (("STATUS_INTEGER_OVERFLOW"));
1288 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1290 case EXCEPTION_BREAKPOINT
:
1291 OUTMSG2 (("EXCEPTION_BREAKPOINT"));
1292 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1294 /* Remove the initial breakpoint. */
1295 check_breakpoints ((CORE_ADDR
) (long) current_event
1296 .u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1300 OUTMSG2 (("DBG_CONTROL_C"));
1301 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1303 case DBG_CONTROL_BREAK
:
1304 OUTMSG2 (("DBG_CONTROL_BREAK"));
1305 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1307 case EXCEPTION_SINGLE_STEP
:
1308 OUTMSG2 (("EXCEPTION_SINGLE_STEP"));
1309 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1311 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1312 OUTMSG2 (("EXCEPTION_ILLEGAL_INSTRUCTION"));
1313 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1315 case EXCEPTION_PRIV_INSTRUCTION
:
1316 OUTMSG2 (("EXCEPTION_PRIV_INSTRUCTION"));
1317 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1319 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1320 OUTMSG2 (("EXCEPTION_NONCONTINUABLE_EXCEPTION"));
1321 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1324 if (current_event
.u
.Exception
.dwFirstChance
)
1326 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1329 OUTMSG2 (("gdbserver: unknown target exception 0x%08x at 0x%s",
1330 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1331 phex_nz ((uintptr_t) current_event
.u
.Exception
.ExceptionRecord
.
1332 ExceptionAddress
, sizeof (uintptr_t))));
1333 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1337 last_sig
= ourstatus
->value
.sig
;
1342 suspend_one_thread (struct inferior_list_entry
*entry
)
1344 struct thread_info
*thread
= (struct thread_info
*) entry
;
1345 win32_thread_info
*th
= inferior_target_data (thread
);
1349 if (SuspendThread (th
->h
) == (DWORD
) -1)
1351 DWORD err
= GetLastError ();
1352 OUTMSG (("warning: SuspendThread failed in suspend_one_thread, "
1353 "(error %d): %s\n", (int) err
, strwinerror (err
)));
1361 fake_breakpoint_event (void)
1363 OUTMSG2(("fake_breakpoint_event\n"));
1365 faked_breakpoint
= 1;
1367 memset (¤t_event
, 0, sizeof (current_event
));
1368 current_event
.dwThreadId
= main_thread_id
;
1369 current_event
.dwDebugEventCode
= EXCEPTION_DEBUG_EVENT
;
1370 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1371 = EXCEPTION_BREAKPOINT
;
1373 for_each_inferior (&all_threads
, suspend_one_thread
);
1378 auto_delete_breakpoint (CORE_ADDR stop_pc
)
1384 /* Get the next event from the child. */
1387 get_child_debug_event (struct target_waitstatus
*ourstatus
)
1391 last_sig
= GDB_SIGNAL_0
;
1392 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1394 /* Check if GDB sent us an interrupt request. */
1395 check_remote_input_interrupt_request ();
1397 if (soft_interrupt_requested
)
1399 soft_interrupt_requested
= 0;
1400 fake_breakpoint_event ();
1409 /* WinCE doesn't set an initial breakpoint automatically. To
1410 stop the inferior, we flush all currently pending debug
1411 events -- the thread list and the dll list are always
1412 reported immediatelly without delay, then, we suspend all
1413 threads and pretend we saw a trap at the current PC of the
1416 Contrary to desktop Windows, Windows CE *does* report the dll
1417 names on LOAD_DLL_DEBUG_EVENTs resulting from a
1418 DebugActiveProcess call. This limits the way we can detect
1419 if all the dlls have already been reported. If we get a real
1420 debug event before leaving attaching, the worst that will
1421 happen is the user will see a spurious breakpoint. */
1423 current_event
.dwDebugEventCode
= 0;
1424 if (!WaitForDebugEvent (¤t_event
, 0))
1426 OUTMSG2(("no attach events left\n"));
1427 fake_breakpoint_event ();
1431 OUTMSG2(("got attach event\n"));
1436 /* Keep the wait time low enough for confortable remote
1437 interruption, but high enough so gdbserver doesn't become a
1439 if (!WaitForDebugEvent (¤t_event
, 250))
1441 DWORD e
= GetLastError();
1443 if (e
== ERROR_PIPE_NOT_CONNECTED
)
1445 /* This will happen if the loader fails to succesfully
1446 load the application, e.g., if the main executable
1447 tries to pull in a non-existing export from a
1449 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1450 ourstatus
->value
.integer
= 1;
1460 switch (current_event
.dwDebugEventCode
)
1462 case CREATE_THREAD_DEBUG_EVENT
:
1463 OUTMSG2 (("gdbserver: kernel event CREATE_THREAD_DEBUG_EVENT "
1464 "for pid=%u tid=%x)\n",
1465 (unsigned) current_event
.dwProcessId
,
1466 (unsigned) current_event
.dwThreadId
));
1468 /* Record the existence of this thread. */
1469 child_add_thread (current_event
.dwProcessId
,
1470 current_event
.dwThreadId
,
1471 current_event
.u
.CreateThread
.hThread
,
1472 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1475 case EXIT_THREAD_DEBUG_EVENT
:
1476 OUTMSG2 (("gdbserver: kernel event EXIT_THREAD_DEBUG_EVENT "
1477 "for pid=%u tid=%x\n",
1478 (unsigned) current_event
.dwProcessId
,
1479 (unsigned) current_event
.dwThreadId
));
1480 child_delete_thread (current_event
.dwProcessId
,
1481 current_event
.dwThreadId
);
1483 current_inferior
= (struct thread_info
*) all_threads
.head
;
1486 case CREATE_PROCESS_DEBUG_EVENT
:
1487 OUTMSG2 (("gdbserver: kernel event CREATE_PROCESS_DEBUG_EVENT "
1488 "for pid=%u tid=%x\n",
1489 (unsigned) current_event
.dwProcessId
,
1490 (unsigned) current_event
.dwThreadId
));
1491 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1493 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1494 main_thread_id
= current_event
.dwThreadId
;
1496 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
1497 ourstatus
->value
.execd_pathname
= "Main executable";
1499 /* Add the main thread. */
1500 child_add_thread (current_event
.dwProcessId
,
1502 current_event
.u
.CreateProcessInfo
.hThread
,
1503 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
);
1505 ourstatus
->value
.related_pid
= debug_event_ptid (¤t_event
);
1509 /* Windows CE doesn't set the initial breakpoint
1510 automatically like the desktop versions of Windows do.
1511 We add it explicitly here. It will be removed as soon as
1513 set_breakpoint_at ((CORE_ADDR
) (long) current_event
.u
1514 .CreateProcessInfo
.lpStartAddress
,
1515 auto_delete_breakpoint
);
1520 case EXIT_PROCESS_DEBUG_EVENT
:
1521 OUTMSG2 (("gdbserver: kernel event EXIT_PROCESS_DEBUG_EVENT "
1522 "for pid=%u tid=%x\n",
1523 (unsigned) current_event
.dwProcessId
,
1524 (unsigned) current_event
.dwThreadId
));
1525 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1526 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1527 child_continue (DBG_CONTINUE
, -1);
1528 CloseHandle (current_process_handle
);
1529 current_process_handle
= NULL
;
1532 case LOAD_DLL_DEBUG_EVENT
:
1533 OUTMSG2 (("gdbserver: kernel event LOAD_DLL_DEBUG_EVENT "
1534 "for pid=%u tid=%x\n",
1535 (unsigned) current_event
.dwProcessId
,
1536 (unsigned) current_event
.dwThreadId
));
1537 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1540 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1541 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1544 case UNLOAD_DLL_DEBUG_EVENT
:
1545 OUTMSG2 (("gdbserver: kernel event UNLOAD_DLL_DEBUG_EVENT "
1546 "for pid=%u tid=%x\n",
1547 (unsigned) current_event
.dwProcessId
,
1548 (unsigned) current_event
.dwThreadId
));
1549 handle_unload_dll ();
1550 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1551 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1554 case EXCEPTION_DEBUG_EVENT
:
1555 OUTMSG2 (("gdbserver: kernel event EXCEPTION_DEBUG_EVENT "
1556 "for pid=%u tid=%x\n",
1557 (unsigned) current_event
.dwProcessId
,
1558 (unsigned) current_event
.dwThreadId
));
1559 handle_exception (ourstatus
);
1562 case OUTPUT_DEBUG_STRING_EVENT
:
1563 /* A message from the kernel (or Cygwin). */
1564 OUTMSG2 (("gdbserver: kernel event OUTPUT_DEBUG_STRING_EVENT "
1565 "for pid=%u tid=%x\n",
1566 (unsigned) current_event
.dwProcessId
,
1567 (unsigned) current_event
.dwThreadId
));
1568 handle_output_debug_string (ourstatus
);
1572 OUTMSG2 (("gdbserver: kernel event unknown "
1573 "for pid=%u tid=%x code=%x\n",
1574 (unsigned) current_event
.dwProcessId
,
1575 (unsigned) current_event
.dwThreadId
,
1576 (unsigned) current_event
.dwDebugEventCode
));
1580 ptid
= debug_event_ptid (¤t_event
);
1582 (struct thread_info
*) find_inferior_id (&all_threads
, ptid
);
1586 /* Wait for the inferior process to change state.
1587 STATUS will be filled in with a response code to send to GDB.
1588 Returns the signal which caused the process to stop. */
1590 win32_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
1592 struct regcache
*regcache
;
1596 if (!get_child_debug_event (ourstatus
))
1599 switch (ourstatus
->kind
)
1601 case TARGET_WAITKIND_EXITED
:
1602 OUTMSG2 (("Child exited with retcode = %x\n",
1603 ourstatus
->value
.integer
));
1604 win32_clear_inferiors ();
1605 return pid_to_ptid (current_event
.dwProcessId
);
1606 case TARGET_WAITKIND_STOPPED
:
1607 case TARGET_WAITKIND_LOADED
:
1608 OUTMSG2 (("Child Stopped with signal = %d \n",
1609 ourstatus
->value
.sig
));
1611 regcache
= get_thread_regcache (current_inferior
, 1);
1612 child_fetch_inferior_registers (regcache
, -1);
1614 if (ourstatus
->kind
== TARGET_WAITKIND_LOADED
1617 /* When gdb connects, we want to be stopped at the
1618 initial breakpoint, not in some dll load event. */
1619 child_continue (DBG_CONTINUE
, -1);
1623 /* We don't expose _LOADED events to gdbserver core. See
1624 the `dlls_changed' global. */
1625 if (ourstatus
->kind
== TARGET_WAITKIND_LOADED
)
1626 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1628 return debug_event_ptid (¤t_event
);
1630 OUTMSG (("Ignoring unknown internal event, %d\n", ourstatus
->kind
));
1632 case TARGET_WAITKIND_SPURIOUS
:
1633 case TARGET_WAITKIND_EXECD
:
1634 /* do nothing, just continue */
1635 child_continue (DBG_CONTINUE
, -1);
1641 /* Fetch registers from the inferior process.
1642 If REGNO is -1, fetch all registers; otherwise, fetch at least REGNO. */
1644 win32_fetch_inferior_registers (struct regcache
*regcache
, int regno
)
1646 child_fetch_inferior_registers (regcache
, regno
);
1649 /* Store registers to the inferior process.
1650 If REGNO is -1, store all registers; otherwise, store at least REGNO. */
1652 win32_store_inferior_registers (struct regcache
*regcache
, int regno
)
1654 child_store_inferior_registers (regcache
, regno
);
1657 /* Read memory from the inferior process. This should generally be
1658 called through read_inferior_memory, which handles breakpoint shadowing.
1659 Read LEN bytes at MEMADDR into a buffer at MYADDR. */
1661 win32_read_inferior_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
1663 return child_xfer_memory (memaddr
, (char *) myaddr
, len
, 0, 0) != len
;
1666 /* Write memory to the inferior process. This should generally be
1667 called through write_inferior_memory, which handles breakpoint shadowing.
1668 Write LEN bytes from the buffer at MYADDR to MEMADDR.
1669 Returns 0 on success and errno on failure. */
1671 win32_write_inferior_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
,
1674 return child_xfer_memory (memaddr
, (char *) myaddr
, len
, 1, 0) != len
;
1677 /* Send an interrupt request to the inferior process. */
1679 win32_request_interrupt (void)
1681 winapi_DebugBreakProcess DebugBreakProcess
;
1682 winapi_GenerateConsoleCtrlEvent GenerateConsoleCtrlEvent
;
1685 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
1687 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
1690 GenerateConsoleCtrlEvent
= GETPROCADDRESS (dll
, GenerateConsoleCtrlEvent
);
1692 if (GenerateConsoleCtrlEvent
!= NULL
1693 && GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, current_process_id
))
1696 /* GenerateConsoleCtrlEvent can fail if process id being debugged is
1697 not a process group id.
1698 Fallback to XP/Vista 'DebugBreakProcess', which generates a
1699 breakpoint exception in the interior process. */
1701 DebugBreakProcess
= GETPROCADDRESS (dll
, DebugBreakProcess
);
1703 if (DebugBreakProcess
!= NULL
1704 && DebugBreakProcess (current_process_handle
))
1707 /* Last resort, suspend all threads manually. */
1708 soft_interrupt_requested
= 1;
1713 win32_error_to_fileio_error (DWORD err
)
1717 case ERROR_BAD_PATHNAME
:
1718 case ERROR_FILE_NOT_FOUND
:
1719 case ERROR_INVALID_NAME
:
1720 case ERROR_PATH_NOT_FOUND
:
1721 return FILEIO_ENOENT
;
1723 case ERROR_IO_DEVICE
:
1724 case ERROR_OPEN_FAILED
:
1726 case ERROR_INVALID_HANDLE
:
1727 return FILEIO_EBADF
;
1728 case ERROR_ACCESS_DENIED
:
1729 case ERROR_SHARING_VIOLATION
:
1730 return FILEIO_EACCES
;
1731 case ERROR_NOACCESS
:
1732 return FILEIO_EFAULT
;
1734 return FILEIO_EBUSY
;
1735 case ERROR_ALREADY_EXISTS
:
1736 case ERROR_FILE_EXISTS
:
1737 return FILEIO_EEXIST
;
1738 case ERROR_BAD_DEVICE
:
1739 return FILEIO_ENODEV
;
1740 case ERROR_DIRECTORY
:
1741 return FILEIO_ENOTDIR
;
1742 case ERROR_FILENAME_EXCED_RANGE
:
1743 case ERROR_INVALID_DATA
:
1744 case ERROR_INVALID_PARAMETER
:
1745 case ERROR_NEGATIVE_SEEK
:
1746 return FILEIO_EINVAL
;
1747 case ERROR_TOO_MANY_OPEN_FILES
:
1748 return FILEIO_EMFILE
;
1749 case ERROR_HANDLE_DISK_FULL
:
1750 case ERROR_DISK_FULL
:
1751 return FILEIO_ENOSPC
;
1752 case ERROR_WRITE_PROTECT
:
1753 return FILEIO_EROFS
;
1754 case ERROR_NOT_SUPPORTED
:
1755 return FILEIO_ENOSYS
;
1758 return FILEIO_EUNKNOWN
;
1762 wince_hostio_last_error (char *buf
)
1764 DWORD winerr
= GetLastError ();
1765 int fileio_err
= win32_error_to_fileio_error (winerr
);
1766 sprintf (buf
, "F-1,%x", fileio_err
);
1770 /* Write Windows OS Thread Information Block address. */
1773 win32_get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
1775 win32_thread_info
*th
;
1776 th
= thread_rec (ptid
, 0);
1780 *addr
= th
->thread_local_base
;
1784 static struct target_ops win32_target_ops
= {
1785 win32_create_inferior
,
1794 win32_fetch_inferior_registers
,
1795 win32_store_inferior_registers
,
1796 NULL
, /* prepare_to_access_memory */
1797 NULL
, /* done_accessing_memory */
1798 win32_read_inferior_memory
,
1799 win32_write_inferior_memory
,
1800 NULL
, /* lookup_symbols */
1801 win32_request_interrupt
,
1802 NULL
, /* read_auxv */
1805 win32_stopped_by_watchpoint
,
1806 win32_stopped_data_address
,
1807 NULL
, /* read_offsets */
1808 NULL
, /* get_tls_address */
1809 NULL
, /* qxfer_spu */
1811 wince_hostio_last_error
,
1813 hostio_last_error_from_errno
,
1815 NULL
, /* qxfer_osdata */
1816 NULL
, /* qxfer_siginfo */
1817 NULL
, /* supports_non_stop */
1819 NULL
, /* start_non_stop */
1820 NULL
, /* supports_multi_process */
1821 NULL
, /* handle_monitor_command */
1822 NULL
, /* core_of_thread */
1823 NULL
, /* read_loadmap */
1824 NULL
, /* process_qsupported */
1825 NULL
, /* supports_tracepoints */
1827 NULL
, /* write_pc */
1828 NULL
, /* thread_stopped */
1829 win32_get_tib_address
1832 /* Initialize the Win32 backend. */
1834 initialize_low (void)
1836 set_target_ops (&win32_target_ops
);
1837 if (the_low_target
.breakpoint
!= NULL
)
1838 set_breakpoint_data (the_low_target
.breakpoint
,
1839 the_low_target
.breakpoint_len
);
1840 the_low_target
.arch_setup ();