1 /* Low level interface to Windows debugging, for gdbserver.
2 Copyright (C) 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
4 Contributed by Leo Zayas. Based on "win32-nat.c" from GDB.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "gdb/signals.h"
24 #include "gdb/fileio.h"
25 #include "mem-break.h"
26 #include "win32-low.h"
33 #include <sys/param.h>
38 #include <sys/cygwin.h>
43 #define OUTMSG(X) do { printf X; fflush (stdout); } while (0)
45 #define OUTMSG2(X) do { printf X; fflush (stdout); } while (0)
47 #define OUTMSG2(X) do ; while (0)
51 #define _T(x) TEXT (x)
55 #define COUNTOF(STR) (sizeof (STR) / sizeof ((STR)[0]))
59 # define GETPROCADDRESS(DLL, PROC) \
60 ((winapi_ ## PROC) GetProcAddress (DLL, TEXT (#PROC)))
62 # define GETPROCADDRESS(DLL, PROC) \
63 ((winapi_ ## PROC) GetProcAddress (DLL, #PROC))
66 int using_threads
= 1;
69 static int attaching
= 0;
70 static HANDLE current_process_handle
= NULL
;
71 static DWORD current_process_id
= 0;
72 static DWORD main_thread_id
= 0;
73 static enum target_signal last_sig
= TARGET_SIGNAL_0
;
75 /* The current debug event from WaitForDebugEvent. */
76 static DEBUG_EVENT current_event
;
78 /* Non zero if an interrupt request is to be satisfied by suspending
80 static int soft_interrupt_requested
= 0;
82 /* Non zero if the inferior is stopped in a simulated breakpoint done
83 by suspending all the threads. */
84 static int faked_breakpoint
= 0;
86 #define NUM_REGS (the_low_target.num_regs)
88 typedef BOOL
WINAPI (*winapi_DebugActiveProcessStop
) (DWORD dwProcessId
);
89 typedef BOOL
WINAPI (*winapi_DebugSetProcessKillOnExit
) (BOOL KillOnExit
);
90 typedef BOOL
WINAPI (*winapi_DebugBreakProcess
) (HANDLE
);
91 typedef BOOL
WINAPI (*winapi_GenerateConsoleCtrlEvent
) (DWORD
, DWORD
);
93 static void win32_resume (struct thread_resume
*resume_info
, size_t n
);
95 /* Get the thread ID from the current selected inferior (the current
98 current_inferior_tid (void)
100 win32_thread_info
*th
= inferior_target_data (current_inferior
);
104 /* Get the thread context of the thread associated with TH. */
107 win32_get_thread_context (win32_thread_info
*th
)
109 memset (&th
->context
, 0, sizeof (CONTEXT
));
110 (*the_low_target
.get_thread_context
) (th
, ¤t_event
);
112 memcpy (&th
->base_context
, &th
->context
, sizeof (CONTEXT
));
116 /* Set the thread context of the thread associated with TH. */
119 win32_set_thread_context (win32_thread_info
*th
)
122 /* Calling SuspendThread on a thread that is running kernel code
123 will report that the suspending was successful, but in fact, that
124 will often not be true. In those cases, the context returned by
125 GetThreadContext will not be correct by the time the thread
126 stops, hence we can't set that context back into the thread when
127 resuming - it will most likelly crash the inferior.
128 Unfortunately, there is no way to know when the thread will
129 really stop. To work around it, we'll only write the context
130 back to the thread when either the user or GDB explicitly change
131 it between stopping and resuming. */
132 if (memcmp (&th
->context
, &th
->base_context
, sizeof (CONTEXT
)) != 0)
134 (*the_low_target
.set_thread_context
) (th
, ¤t_event
);
137 /* Find a thread record given a thread id. If GET_CONTEXT is set then
138 also retrieve the context for this thread. */
139 static win32_thread_info
*
140 thread_rec (DWORD id
, int get_context
)
142 struct thread_info
*thread
;
143 win32_thread_info
*th
;
145 thread
= (struct thread_info
*) find_inferior_id (&all_threads
, id
);
149 th
= inferior_target_data (thread
);
150 if (get_context
&& th
->context
.ContextFlags
== 0)
154 if (SuspendThread (th
->h
) == (DWORD
) -1)
156 DWORD err
= GetLastError ();
157 OUTMSG (("warning: SuspendThread failed in thread_rec, "
158 "(error %d): %s\n", (int) err
, strwinerror (err
)));
164 win32_get_thread_context (th
);
170 /* Add a thread to the thread list. */
171 static win32_thread_info
*
172 child_add_thread (DWORD tid
, HANDLE h
)
174 win32_thread_info
*th
;
176 if ((th
= thread_rec (tid
, FALSE
)))
179 th
= xcalloc (1, sizeof (*th
));
183 add_thread (tid
, th
, (unsigned int) tid
);
184 set_inferior_regcache_data ((struct thread_info
*)
185 find_inferior_id (&all_threads
, tid
),
186 new_register_cache ());
188 if (the_low_target
.thread_added
!= NULL
)
189 (*the_low_target
.thread_added
) (th
);
194 /* Delete a thread from the list of threads. */
196 delete_thread_info (struct inferior_list_entry
*thread
)
198 win32_thread_info
*th
= inferior_target_data ((struct thread_info
*) thread
);
200 remove_thread ((struct thread_info
*) thread
);
205 /* Delete a thread from the list of threads. */
207 child_delete_thread (DWORD id
)
209 struct inferior_list_entry
*thread
;
211 /* If the last thread is exiting, just return. */
212 if (all_threads
.head
== all_threads
.tail
)
215 thread
= find_inferior_id (&all_threads
, id
);
219 delete_thread_info (thread
);
222 /* Transfer memory from/to the debugged process. */
224 child_xfer_memory (CORE_ADDR memaddr
, char *our
, int len
,
225 int write
, struct target_ops
*target
)
228 long addr
= (long) memaddr
;
232 WriteProcessMemory (current_process_handle
, (LPVOID
) addr
,
233 (LPCVOID
) our
, len
, &done
);
234 FlushInstructionCache (current_process_handle
, (LPCVOID
) addr
, len
);
238 ReadProcessMemory (current_process_handle
, (LPCVOID
) addr
, (LPVOID
) our
,
244 /* Generally, what has the program done? */
247 /* The program has exited. The exit status is in value.integer. */
248 TARGET_WAITKIND_EXITED
,
250 /* The program has stopped with a signal. Which signal is in
252 TARGET_WAITKIND_STOPPED
,
254 /* The program is letting us know that it dynamically loaded
255 or unloaded something. */
256 TARGET_WAITKIND_LOADED
,
258 /* The program has exec'ed a new executable file. The new file's
259 pathname is pointed to by value.execd_pathname. */
260 TARGET_WAITKIND_EXECD
,
262 /* Nothing interesting happened, but we stopped anyway. We take the
263 chance to check if GDB requested an interrupt. */
264 TARGET_WAITKIND_SPURIOUS
,
267 struct target_waitstatus
269 enum target_waitkind kind
;
271 /* Forked child pid, execd pathname, exit status or signal number. */
275 enum target_signal sig
;
277 char *execd_pathname
;
283 /* Clear out any old thread list and reinitialize it to a pristine
286 child_init_thread_list (void)
288 for_each_inferior (&all_threads
, delete_thread_info
);
292 do_initial_child_stuff (HANDLE proch
, DWORD pid
)
294 last_sig
= TARGET_SIGNAL_0
;
296 current_process_handle
= proch
;
297 current_process_id
= pid
;
300 soft_interrupt_requested
= 0;
301 faked_breakpoint
= 0;
303 memset (¤t_event
, 0, sizeof (current_event
));
305 child_init_thread_list ();
307 if (the_low_target
.initial_stuff
!= NULL
)
308 (*the_low_target
.initial_stuff
) ();
311 /* Resume all artificially suspended threads if we are continuing
314 continue_one_thread (struct inferior_list_entry
*this_thread
, void *id_ptr
)
316 struct thread_info
*thread
= (struct thread_info
*) this_thread
;
317 int thread_id
= * (int *) id_ptr
;
318 win32_thread_info
*th
= inferior_target_data (thread
);
320 if ((thread_id
== -1 || thread_id
== th
->tid
)
323 if (th
->context
.ContextFlags
)
325 win32_set_thread_context (th
);
326 th
->context
.ContextFlags
= 0;
329 if (ResumeThread (th
->h
) == (DWORD
) -1)
331 DWORD err
= GetLastError ();
332 OUTMSG (("warning: ResumeThread failed in continue_one_thread, "
333 "(error %d): %s\n", (int) err
, strwinerror (err
)));
342 child_continue (DWORD continue_status
, int thread_id
)
344 /* The inferior will only continue after the ContinueDebugEvent
346 find_inferior (&all_threads
, continue_one_thread
, &thread_id
);
347 faked_breakpoint
= 0;
349 if (!ContinueDebugEvent (current_event
.dwProcessId
,
350 current_event
.dwThreadId
,
357 /* Fetch register(s) from the current thread context. */
359 child_fetch_inferior_registers (int r
)
362 win32_thread_info
*th
= thread_rec (current_inferior_tid (), TRUE
);
363 if (r
== -1 || r
== 0 || r
> NUM_REGS
)
364 child_fetch_inferior_registers (NUM_REGS
);
366 for (regno
= 0; regno
< r
; regno
++)
367 (*the_low_target
.fetch_inferior_register
) (th
, regno
);
370 /* Store a new register value into the current thread context. We don't
371 change the program's context until later, when we resume it. */
373 child_store_inferior_registers (int r
)
376 win32_thread_info
*th
= thread_rec (current_inferior_tid (), TRUE
);
377 if (r
== -1 || r
== 0 || r
> NUM_REGS
)
378 child_store_inferior_registers (NUM_REGS
);
380 for (regno
= 0; regno
< r
; regno
++)
381 (*the_low_target
.store_inferior_register
) (th
, regno
);
384 /* Map the Windows error number in ERROR to a locale-dependent error
385 message string and return a pointer to it. Typically, the values
386 for ERROR come from GetLastError.
388 The string pointed to shall not be modified by the application,
389 but may be overwritten by a subsequent call to strwinerror
391 The strwinerror function does not change the current setting
395 strwinerror (DWORD error
)
397 static char buf
[1024];
399 DWORD lasterr
= GetLastError ();
400 DWORD chars
= FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
401 | FORMAT_MESSAGE_ALLOCATE_BUFFER
,
404 0, /* Default language */
410 /* If there is an \r\n appended, zap it. */
412 && msgbuf
[chars
- 2] == '\r'
413 && msgbuf
[chars
- 1] == '\n')
419 if (chars
> ((COUNTOF (buf
)) - 1))
421 chars
= COUNTOF (buf
) - 1;
426 wcstombs (buf
, msgbuf
, chars
+ 1);
428 strncpy (buf
, msgbuf
, chars
+ 1);
433 sprintf (buf
, "unknown win32 error (%ld)", error
);
435 SetLastError (lasterr
);
440 create_process (const char *program
, char *args
,
441 DWORD flags
, PROCESS_INFORMATION
*pi
)
446 wchar_t *p
, *wprogram
, *wargs
;
449 wprogram
= alloca ((strlen (program
) + 1) * sizeof (wchar_t));
450 mbstowcs (wprogram
, program
, strlen (program
) + 1);
452 for (p
= wprogram
; *p
; ++p
)
456 argslen
= strlen (args
);
457 wargs
= alloca ((argslen
+ 1) * sizeof (wchar_t));
458 mbstowcs (wargs
, args
, argslen
+ 1);
460 ret
= CreateProcessW (wprogram
, /* image name */
461 wargs
, /* command line */
462 NULL
, /* security, not supported */
463 NULL
, /* thread, not supported */
464 FALSE
, /* inherit handles, not supported */
465 flags
, /* start flags */
466 NULL
, /* environment, not supported */
467 NULL
, /* current directory, not supported */
468 NULL
, /* start info, not supported */
471 STARTUPINFOA si
= { sizeof (STARTUPINFOA
) };
473 ret
= CreateProcessA (program
, /* image name */
474 args
, /* command line */
477 TRUE
, /* inherit handles */
478 flags
, /* start flags */
479 NULL
, /* environment */
480 NULL
, /* current directory */
481 &si
, /* start info */
488 /* Start a new process.
489 PROGRAM is a path to the program to execute.
490 ARGS is a standard NULL-terminated array of arguments,
491 to be passed to the inferior as ``argv''.
492 Returns the new PID on success, -1 on failure. Registers the new
493 process with the process list. */
495 win32_create_inferior (char *program
, char **program_args
)
498 char real_path
[MAXPATHLEN
];
499 char *orig_path
, *new_path
, *path_ptr
;
506 PROCESS_INFORMATION pi
;
509 /* win32_wait needs to know we're not attaching. */
513 error ("No executable specified, specify executable to debug.\n");
515 flags
= DEBUG_PROCESS
| DEBUG_ONLY_THIS_PROCESS
;
519 path_ptr
= getenv ("PATH");
522 orig_path
= alloca (strlen (path_ptr
) + 1);
523 new_path
= alloca (cygwin_posix_to_win32_path_list_buf_size (path_ptr
));
524 strcpy (orig_path
, path_ptr
);
525 cygwin_posix_to_win32_path_list (path_ptr
, new_path
);
526 setenv ("PATH", new_path
, 1);
528 cygwin_conv_to_win32_path (program
, real_path
);
533 for (argc
= 1; program_args
[argc
]; argc
++)
534 argslen
+= strlen (program_args
[argc
]) + 1;
535 args
= alloca (argslen
);
537 for (argc
= 1; program_args
[argc
]; argc
++)
539 /* FIXME: Can we do better about quoting? How does Cygwin
542 strcat (args
, program_args
[argc
]);
544 OUTMSG2 (("Command line is \"%s\"\n", args
));
546 #ifdef CREATE_NEW_PROCESS_GROUP
547 flags
|= CREATE_NEW_PROCESS_GROUP
;
550 ret
= create_process (program
, args
, flags
, &pi
);
551 err
= GetLastError ();
552 if (!ret
&& err
== ERROR_FILE_NOT_FOUND
)
554 char *exename
= alloca (strlen (program
) + 5);
555 strcat (strcpy (exename
, program
), ".exe");
556 ret
= create_process (exename
, args
, flags
, &pi
);
557 err
= GetLastError ();
562 setenv ("PATH", orig_path
, 1);
567 error ("Error creating process \"%s%s\", (error %d): %s\n",
568 program
, args
, (int) err
, strwinerror (err
));
572 OUTMSG2 (("Process created: %s\n", (char *) args
));
576 /* On Windows CE this handle can't be closed. The OS reuses
577 it in the debug events, while the 9x/NT versions of Windows
578 probably use a DuplicateHandle'd one. */
579 CloseHandle (pi
.hThread
);
582 do_initial_child_stuff (pi
.hProcess
, pi
.dwProcessId
);
584 return current_process_id
;
587 /* Attach to a running process.
588 PID is the process ID to attach to, specified by the user
589 or a higher layer. */
591 win32_attach (unsigned long pid
)
594 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
597 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
599 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
601 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
603 h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
606 if (DebugActiveProcess (pid
))
608 if (DebugSetProcessKillOnExit
!= NULL
)
609 DebugSetProcessKillOnExit (FALSE
);
611 /* win32_wait needs to know we're attaching. */
613 do_initial_child_stuff (h
, pid
);
620 err
= GetLastError ();
621 error ("Attach to process failed (error %d): %s\n",
622 (int) err
, strwinerror (err
));
625 /* Handle OUTPUT_DEBUG_STRING_EVENT from child process. */
627 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
629 #define READ_BUFFER_LEN 1024
631 char s
[READ_BUFFER_LEN
+ 1] = { 0 };
632 DWORD nbytes
= current_event
.u
.DebugString
.nDebugStringLength
;
637 if (nbytes
> READ_BUFFER_LEN
)
638 nbytes
= READ_BUFFER_LEN
;
640 addr
= (CORE_ADDR
) (size_t) current_event
.u
.DebugString
.lpDebugStringData
;
642 if (current_event
.u
.DebugString
.fUnicode
)
644 /* The event tells us how many bytes, not chars, even
646 WCHAR buffer
[(READ_BUFFER_LEN
+ 1) / sizeof (WCHAR
)] = { 0 };
647 if (read_inferior_memory (addr
, (unsigned char *) buffer
, nbytes
) != 0)
649 wcstombs (s
, buffer
, (nbytes
+ 1) / sizeof (WCHAR
));
653 if (read_inferior_memory (addr
, (unsigned char *) s
, nbytes
) != 0)
657 if (strncmp (s
, "cYg", 3) != 0)
667 #undef READ_BUFFER_LEN
671 win32_clear_inferiors (void)
673 if (current_process_handle
!= NULL
)
674 CloseHandle (current_process_handle
);
676 for_each_inferior (&all_threads
, delete_thread_info
);
680 /* Kill all inferiors. */
684 if (current_process_handle
== NULL
)
687 TerminateProcess (current_process_handle
, 0);
690 if (!child_continue (DBG_CONTINUE
, -1))
692 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
694 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
696 else if (current_event
.dwDebugEventCode
== OUTPUT_DEBUG_STRING_EVENT
)
698 struct target_waitstatus our_status
= { 0 };
699 handle_output_debug_string (&our_status
);
703 win32_clear_inferiors ();
706 /* Detach from all inferiors. */
710 winapi_DebugActiveProcessStop DebugActiveProcessStop
= NULL
;
711 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
713 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
715 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
717 DebugActiveProcessStop
= GETPROCADDRESS (dll
, DebugActiveProcessStop
);
718 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
720 if (DebugSetProcessKillOnExit
== NULL
721 || DebugActiveProcessStop
== NULL
)
725 struct thread_resume resume
;
729 win32_resume (&resume
, 1);
732 if (!DebugActiveProcessStop (current_process_id
))
735 DebugSetProcessKillOnExit (FALSE
);
737 win32_clear_inferiors ();
741 /* Wait for inferiors to end. */
745 extern unsigned long signal_pid
;
747 HANDLE h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, signal_pid
);
750 WaitForSingleObject (h
, INFINITE
);
755 /* Return 1 iff the thread with thread ID TID is alive. */
757 win32_thread_alive (unsigned long tid
)
761 /* Our thread list is reliable; don't bother to poll target
763 if (find_inferior_id (&all_threads
, tid
) != NULL
)
770 /* Resume the inferior process. RESUME_INFO describes how we want
773 win32_resume (struct thread_resume
*resume_info
, size_t n
)
776 enum target_signal sig
;
778 win32_thread_info
*th
;
779 DWORD continue_status
= DBG_CONTINUE
;
781 /* This handles the very limited set of resume packets that GDB can
782 currently produce. */
784 if (n
== 1 && resume_info
[0].thread
== -1)
789 /* Yes, we're ignoring resume_info[0].thread. It'd be tricky to make
790 the Windows resume code do the right thing for thread switching. */
791 tid
= current_event
.dwThreadId
;
793 if (resume_info
[0].thread
!= -1)
795 sig
= resume_info
[0].sig
;
796 step
= resume_info
[0].step
;
804 if (sig
!= TARGET_SIGNAL_0
)
806 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
808 OUTMSG (("Cannot continue with signal %d here.\n", sig
));
810 else if (sig
== last_sig
)
811 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
813 OUTMSG (("Can only continue with recieved signal %d.\n", last_sig
));
816 last_sig
= TARGET_SIGNAL_0
;
818 /* Get context for the currently selected thread. */
819 th
= thread_rec (current_event
.dwThreadId
, FALSE
);
822 if (th
->context
.ContextFlags
)
824 /* Move register values from the inferior into the thread
825 context structure. */
826 regcache_invalidate ();
830 if (the_low_target
.single_step
!= NULL
)
831 (*the_low_target
.single_step
) (th
);
833 error ("Single stepping is not supported "
834 "in this configuration.\n");
837 win32_set_thread_context (th
);
838 th
->context
.ContextFlags
= 0;
842 /* Allow continuing with the same signal that interrupted us.
843 Otherwise complain. */
845 child_continue (continue_status
, tid
);
849 win32_add_one_solib (const char *name
, CORE_ADDR load_addr
)
851 char buf
[MAX_PATH
+ 1];
852 char buf2
[MAX_PATH
+ 1];
855 WIN32_FIND_DATA w32_fd
;
856 WCHAR wname
[MAX_PATH
+ 1];
857 mbstowcs (wname
, name
, MAX_PATH
);
858 HANDLE h
= FindFirstFile (wname
, &w32_fd
);
860 WIN32_FIND_DATAA w32_fd
;
861 HANDLE h
= FindFirstFileA (name
, &w32_fd
);
864 if (h
== INVALID_HANDLE_VALUE
)
872 char cwd
[MAX_PATH
+ 1];
874 if (GetCurrentDirectoryA (MAX_PATH
+ 1, cwd
))
876 p
= strrchr (buf
, '\\');
879 SetCurrentDirectoryA (buf
);
880 GetFullPathNameA (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
881 SetCurrentDirectoryA (cwd
);
888 cygwin_conv_to_posix_path (buf
, buf2
);
893 loaded_dll (buf2
, load_addr
);
897 get_image_name (HANDLE h
, void *address
, int unicode
)
899 static char buf
[(2 * MAX_PATH
) + 1];
900 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
906 /* Attempt to read the name of the dll that was detected.
907 This is documented to work only when actively debugging
908 a program. It will not work for attached processes. */
913 /* Windows CE reports the address of the image name,
914 instead of an address of a pointer into the image name. */
915 address_ptr
= address
;
917 /* See if we could read the address of a string, and that the
918 address isn't null. */
919 if (!ReadProcessMemory (h
, address
, &address_ptr
,
920 sizeof (address_ptr
), &done
)
921 || done
!= sizeof (address_ptr
)
926 /* Find the length of the string */
927 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
928 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
932 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
935 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
936 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
939 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
945 typedef BOOL (WINAPI
*winapi_EnumProcessModules
) (HANDLE
, HMODULE
*,
947 typedef BOOL (WINAPI
*winapi_GetModuleInformation
) (HANDLE
, HMODULE
,
948 LPMODULEINFO
, DWORD
);
949 typedef DWORD (WINAPI
*winapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
,
952 static winapi_EnumProcessModules win32_EnumProcessModules
;
953 static winapi_GetModuleInformation win32_GetModuleInformation
;
954 static winapi_GetModuleFileNameExA win32_GetModuleFileNameExA
;
959 static int psapi_loaded
= 0;
960 static HMODULE dll
= NULL
;
965 dll
= LoadLibrary (TEXT("psapi.dll"));
968 win32_EnumProcessModules
=
969 GETPROCADDRESS (dll
, EnumProcessModules
);
970 win32_GetModuleInformation
=
971 GETPROCADDRESS (dll
, GetModuleInformation
);
972 win32_GetModuleFileNameExA
=
973 GETPROCADDRESS (dll
, GetModuleFileNameExA
);
976 return (win32_EnumProcessModules
!= NULL
977 && win32_GetModuleInformation
!= NULL
978 && win32_GetModuleFileNameExA
!= NULL
);
982 psapi_get_dll_name (DWORD BaseAddress
, char *dll_name_ret
)
988 HMODULE
*DllHandle
= dh_buf
;
996 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
1001 if (!ok
|| !cbNeeded
)
1004 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
1008 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
1015 for (i
= 0; i
< ((size_t) cbNeeded
/ sizeof (HMODULE
)); i
++)
1017 if (!(*win32_GetModuleInformation
) (current_process_handle
,
1022 DWORD err
= GetLastError ();
1023 error ("Can't get module info: (error %d): %s\n",
1024 (int) err
, strwinerror (err
));
1027 if ((DWORD
) (mi
.lpBaseOfDll
) == BaseAddress
)
1029 len
= (*win32_GetModuleFileNameExA
) (current_process_handle
,
1035 DWORD err
= GetLastError ();
1036 error ("Error getting dll name: (error %d): %s\n",
1037 (int) err
, strwinerror (err
));
1044 dll_name_ret
[0] = '\0';
1048 typedef HANDLE (WINAPI
*winapi_CreateToolhelp32Snapshot
) (DWORD
, DWORD
);
1049 typedef BOOL (WINAPI
*winapi_Module32First
) (HANDLE
, LPMODULEENTRY32
);
1050 typedef BOOL (WINAPI
*winapi_Module32Next
) (HANDLE
, LPMODULEENTRY32
);
1052 static winapi_CreateToolhelp32Snapshot win32_CreateToolhelp32Snapshot
;
1053 static winapi_Module32First win32_Module32First
;
1054 static winapi_Module32Next win32_Module32Next
;
1056 typedef BOOL (WINAPI
*winapi_CloseToolhelp32Snapshot
) (HANDLE
);
1057 static winapi_CloseToolhelp32Snapshot win32_CloseToolhelp32Snapshot
;
1061 load_toolhelp (void)
1063 static int toolhelp_loaded
= 0;
1064 static HMODULE dll
= NULL
;
1066 if (!toolhelp_loaded
)
1068 toolhelp_loaded
= 1;
1070 dll
= GetModuleHandle (_T("KERNEL32.DLL"));
1072 dll
= LoadLibrary (L
"TOOLHELP.DLL");
1077 win32_CreateToolhelp32Snapshot
=
1078 GETPROCADDRESS (dll
, CreateToolhelp32Snapshot
);
1079 win32_Module32First
= GETPROCADDRESS (dll
, Module32First
);
1080 win32_Module32Next
= GETPROCADDRESS (dll
, Module32Next
);
1082 win32_CloseToolhelp32Snapshot
=
1083 GETPROCADDRESS (dll
, CloseToolhelp32Snapshot
);
1087 return (win32_CreateToolhelp32Snapshot
!= NULL
1088 && win32_Module32First
!= NULL
1089 && win32_Module32Next
!= NULL
1091 && win32_CloseToolhelp32Snapshot
!= NULL
1097 toolhelp_get_dll_name (DWORD BaseAddress
, char *dll_name_ret
)
1099 HANDLE snapshot_module
;
1100 MODULEENTRY32 modEntry
= { sizeof (MODULEENTRY32
) };
1103 if (!load_toolhelp ())
1106 snapshot_module
= win32_CreateToolhelp32Snapshot (TH32CS_SNAPMODULE
,
1107 current_event
.dwProcessId
);
1108 if (snapshot_module
== INVALID_HANDLE_VALUE
)
1111 /* Ignore the first module, which is the exe. */
1112 if (win32_Module32First (snapshot_module
, &modEntry
))
1113 while (win32_Module32Next (snapshot_module
, &modEntry
))
1114 if ((DWORD
) modEntry
.modBaseAddr
== BaseAddress
)
1117 wcstombs (dll_name_ret
, modEntry
.szExePath
, MAX_PATH
+ 1);
1119 strcpy (dll_name_ret
, modEntry
.szExePath
);
1126 win32_CloseToolhelp32Snapshot (snapshot_module
);
1128 CloseHandle (snapshot_module
);
1134 handle_load_dll (void)
1136 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
1137 char dll_buf
[MAX_PATH
+ 1];
1138 char *dll_name
= NULL
;
1141 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
1143 /* Windows does not report the image name of the dlls in the debug
1144 event on attaches. We resort to iterating over the list of
1145 loaded dlls looking for a match by image base. */
1146 if (!psapi_get_dll_name ((DWORD
) event
->lpBaseOfDll
, dll_buf
))
1148 if (!server_waiting
)
1149 /* On some versions of Windows and Windows CE, we can't create
1150 toolhelp snapshots while the inferior is stopped in a
1151 LOAD_DLL_DEBUG_EVENT due to a dll load, but we can while
1152 Windows is reporting the already loaded dlls. */
1153 toolhelp_get_dll_name ((DWORD
) event
->lpBaseOfDll
, dll_buf
);
1158 if (*dll_name
== '\0')
1159 dll_name
= get_image_name (current_process_handle
,
1160 event
->lpImageName
, event
->fUnicode
);
1164 /* The symbols in a dll are offset by 0x1000, which is the
1165 the offset from 0 of the first byte in an image - because
1166 of the file header and the section alignment. */
1168 load_addr
= (DWORD
) event
->lpBaseOfDll
+ 0x1000;
1169 win32_add_one_solib (dll_name
, load_addr
);
1173 handle_unload_dll (void)
1175 CORE_ADDR load_addr
=
1176 (CORE_ADDR
) (DWORD
) current_event
.u
.UnloadDll
.lpBaseOfDll
;
1177 load_addr
+= 0x1000;
1178 unloaded_dll (NULL
, load_addr
);
1182 handle_exception (struct target_waitstatus
*ourstatus
)
1184 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1186 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1190 case EXCEPTION_ACCESS_VIOLATION
:
1191 OUTMSG2 (("EXCEPTION_ACCESS_VIOLATION"));
1192 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1194 case STATUS_STACK_OVERFLOW
:
1195 OUTMSG2 (("STATUS_STACK_OVERFLOW"));
1196 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1198 case STATUS_FLOAT_DENORMAL_OPERAND
:
1199 OUTMSG2 (("STATUS_FLOAT_DENORMAL_OPERAND"));
1200 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1202 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1203 OUTMSG2 (("EXCEPTION_ARRAY_BOUNDS_EXCEEDED"));
1204 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1206 case STATUS_FLOAT_INEXACT_RESULT
:
1207 OUTMSG2 (("STATUS_FLOAT_INEXACT_RESULT"));
1208 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1210 case STATUS_FLOAT_INVALID_OPERATION
:
1211 OUTMSG2 (("STATUS_FLOAT_INVALID_OPERATION"));
1212 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1214 case STATUS_FLOAT_OVERFLOW
:
1215 OUTMSG2 (("STATUS_FLOAT_OVERFLOW"));
1216 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1218 case STATUS_FLOAT_STACK_CHECK
:
1219 OUTMSG2 (("STATUS_FLOAT_STACK_CHECK"));
1220 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1222 case STATUS_FLOAT_UNDERFLOW
:
1223 OUTMSG2 (("STATUS_FLOAT_UNDERFLOW"));
1224 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1226 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1227 OUTMSG2 (("STATUS_FLOAT_DIVIDE_BY_ZERO"));
1228 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1230 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1231 OUTMSG2 (("STATUS_INTEGER_DIVIDE_BY_ZERO"));
1232 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1234 case STATUS_INTEGER_OVERFLOW
:
1235 OUTMSG2 (("STATUS_INTEGER_OVERFLOW"));
1236 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1238 case EXCEPTION_BREAKPOINT
:
1239 OUTMSG2 (("EXCEPTION_BREAKPOINT"));
1240 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1242 /* Remove the initial breakpoint. */
1243 check_breakpoints ((CORE_ADDR
) (long) current_event
1244 .u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1248 OUTMSG2 (("DBG_CONTROL_C"));
1249 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1251 case DBG_CONTROL_BREAK
:
1252 OUTMSG2 (("DBG_CONTROL_BREAK"));
1253 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1255 case EXCEPTION_SINGLE_STEP
:
1256 OUTMSG2 (("EXCEPTION_SINGLE_STEP"));
1257 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1259 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1260 OUTMSG2 (("EXCEPTION_ILLEGAL_INSTRUCTION"));
1261 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1263 case EXCEPTION_PRIV_INSTRUCTION
:
1264 OUTMSG2 (("EXCEPTION_PRIV_INSTRUCTION"));
1265 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1267 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1268 OUTMSG2 (("EXCEPTION_NONCONTINUABLE_EXCEPTION"));
1269 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1272 if (current_event
.u
.Exception
.dwFirstChance
)
1274 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1277 OUTMSG2 (("gdbserver: unknown target exception 0x%08lx at 0x%08lx",
1278 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1279 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.
1281 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1285 last_sig
= ourstatus
->value
.sig
;
1290 suspend_one_thread (struct inferior_list_entry
*entry
)
1292 struct thread_info
*thread
= (struct thread_info
*) entry
;
1293 win32_thread_info
*th
= inferior_target_data (thread
);
1297 if (SuspendThread (th
->h
) == (DWORD
) -1)
1299 DWORD err
= GetLastError ();
1300 OUTMSG (("warning: SuspendThread failed in suspend_one_thread, "
1301 "(error %d): %s\n", (int) err
, strwinerror (err
)));
1309 fake_breakpoint_event (void)
1311 OUTMSG2(("fake_breakpoint_event\n"));
1313 faked_breakpoint
= 1;
1315 memset (¤t_event
, 0, sizeof (current_event
));
1316 current_event
.dwThreadId
= main_thread_id
;
1317 current_event
.dwDebugEventCode
= EXCEPTION_DEBUG_EVENT
;
1318 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1319 = EXCEPTION_BREAKPOINT
;
1321 for_each_inferior (&all_threads
, suspend_one_thread
);
1326 auto_delete_breakpoint (CORE_ADDR stop_pc
)
1332 /* Get the next event from the child. */
1335 get_child_debug_event (struct target_waitstatus
*ourstatus
)
1337 last_sig
= TARGET_SIGNAL_0
;
1338 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1340 /* Check if GDB sent us an interrupt request. */
1341 check_remote_input_interrupt_request ();
1343 if (soft_interrupt_requested
)
1345 soft_interrupt_requested
= 0;
1346 fake_breakpoint_event ();
1355 /* WinCE doesn't set an initial breakpoint automatically. To
1356 stop the inferior, we flush all currently pending debug
1357 events -- the thread list and the dll list are always
1358 reported immediatelly without delay, then, we suspend all
1359 threads and pretend we saw a trap at the current PC of the
1362 Contrary to desktop Windows, Windows CE *does* report the dll
1363 names on LOAD_DLL_DEBUG_EVENTs resulting from a
1364 DebugActiveProcess call. This limits the way we can detect
1365 if all the dlls have already been reported. If we get a real
1366 debug event before leaving attaching, the worst that will
1367 happen is the user will see a spurious breakpoint. */
1369 current_event
.dwDebugEventCode
= 0;
1370 if (!WaitForDebugEvent (¤t_event
, 0))
1372 OUTMSG2(("no attach events left\n"));
1373 fake_breakpoint_event ();
1377 OUTMSG2(("got attach event\n"));
1382 /* Keep the wait time low enough for confortable remote
1383 interruption, but high enough so gdbserver doesn't become a
1385 if (!WaitForDebugEvent (¤t_event
, 250))
1392 (struct thread_info
*) find_inferior_id (&all_threads
,
1393 current_event
.dwThreadId
);
1395 switch (current_event
.dwDebugEventCode
)
1397 case CREATE_THREAD_DEBUG_EVENT
:
1398 OUTMSG2 (("gdbserver: kernel event CREATE_THREAD_DEBUG_EVENT "
1399 "for pid=%d tid=%x)\n",
1400 (unsigned) current_event
.dwProcessId
,
1401 (unsigned) current_event
.dwThreadId
));
1403 /* Record the existence of this thread. */
1404 child_add_thread (current_event
.dwThreadId
,
1405 current_event
.u
.CreateThread
.hThread
);
1408 case EXIT_THREAD_DEBUG_EVENT
:
1409 OUTMSG2 (("gdbserver: kernel event EXIT_THREAD_DEBUG_EVENT "
1410 "for pid=%d tid=%x\n",
1411 (unsigned) current_event
.dwProcessId
,
1412 (unsigned) current_event
.dwThreadId
));
1413 child_delete_thread (current_event
.dwThreadId
);
1416 case CREATE_PROCESS_DEBUG_EVENT
:
1417 OUTMSG2 (("gdbserver: kernel event CREATE_PROCESS_DEBUG_EVENT "
1418 "for pid=%d tid=%x\n",
1419 (unsigned) current_event
.dwProcessId
,
1420 (unsigned) current_event
.dwThreadId
));
1421 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1423 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1424 main_thread_id
= current_event
.dwThreadId
;
1426 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
1427 ourstatus
->value
.execd_pathname
= "Main executable";
1429 /* Add the main thread. */
1430 child_add_thread (main_thread_id
,
1431 current_event
.u
.CreateProcessInfo
.hThread
);
1433 ourstatus
->value
.related_pid
= current_event
.dwThreadId
;
1437 /* Windows CE doesn't set the initial breakpoint
1438 automatically like the desktop versions of Windows do.
1439 We add it explicitly here. It will be removed as soon as
1441 set_breakpoint_at ((CORE_ADDR
) (long) current_event
.u
1442 .CreateProcessInfo
.lpStartAddress
,
1443 auto_delete_breakpoint
);
1448 case EXIT_PROCESS_DEBUG_EVENT
:
1449 OUTMSG2 (("gdbserver: kernel event EXIT_PROCESS_DEBUG_EVENT "
1450 "for pid=%d tid=%x\n",
1451 (unsigned) current_event
.dwProcessId
,
1452 (unsigned) current_event
.dwThreadId
));
1453 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1454 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1455 child_continue (DBG_CONTINUE
, -1);
1456 CloseHandle (current_process_handle
);
1457 current_process_handle
= NULL
;
1460 case LOAD_DLL_DEBUG_EVENT
:
1461 OUTMSG2 (("gdbserver: kernel event LOAD_DLL_DEBUG_EVENT "
1462 "for pid=%d tid=%x\n",
1463 (unsigned) current_event
.dwProcessId
,
1464 (unsigned) current_event
.dwThreadId
));
1465 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1468 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1469 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1472 case UNLOAD_DLL_DEBUG_EVENT
:
1473 OUTMSG2 (("gdbserver: kernel event UNLOAD_DLL_DEBUG_EVENT "
1474 "for pid=%d tid=%x\n",
1475 (unsigned) current_event
.dwProcessId
,
1476 (unsigned) current_event
.dwThreadId
));
1477 handle_unload_dll ();
1478 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1479 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1482 case EXCEPTION_DEBUG_EVENT
:
1483 OUTMSG2 (("gdbserver: kernel event EXCEPTION_DEBUG_EVENT "
1484 "for pid=%d tid=%x\n",
1485 (unsigned) current_event
.dwProcessId
,
1486 (unsigned) current_event
.dwThreadId
));
1487 handle_exception (ourstatus
);
1490 case OUTPUT_DEBUG_STRING_EVENT
:
1491 /* A message from the kernel (or Cygwin). */
1492 OUTMSG2 (("gdbserver: kernel event OUTPUT_DEBUG_STRING_EVENT "
1493 "for pid=%d tid=%x\n",
1494 (unsigned) current_event
.dwProcessId
,
1495 (unsigned) current_event
.dwThreadId
));
1496 handle_output_debug_string (ourstatus
);
1500 OUTMSG2 (("gdbserver: kernel event unknown "
1501 "for pid=%d tid=%x code=%ld\n",
1502 (unsigned) current_event
.dwProcessId
,
1503 (unsigned) current_event
.dwThreadId
,
1504 current_event
.dwDebugEventCode
));
1509 (struct thread_info
*) find_inferior_id (&all_threads
,
1510 current_event
.dwThreadId
);
1514 /* Wait for the inferior process to change state.
1515 STATUS will be filled in with a response code to send to GDB.
1516 Returns the signal which caused the process to stop. */
1517 static unsigned char
1518 win32_wait (char *status
)
1520 struct target_waitstatus our_status
;
1526 if (!get_child_debug_event (&our_status
))
1529 switch (our_status
.kind
)
1531 case TARGET_WAITKIND_EXITED
:
1532 OUTMSG2 (("Child exited with retcode = %x\n",
1533 our_status
.value
.integer
));
1536 win32_clear_inferiors ();
1537 return our_status
.value
.integer
;
1538 case TARGET_WAITKIND_STOPPED
:
1539 case TARGET_WAITKIND_LOADED
:
1540 OUTMSG2 (("Child Stopped with signal = %d \n",
1541 our_status
.value
.sig
));
1545 child_fetch_inferior_registers (-1);
1547 if (our_status
.kind
== TARGET_WAITKIND_LOADED
1550 /* When gdb connects, we want to be stopped at the
1551 initial breakpoint, not in some dll load event. */
1552 child_continue (DBG_CONTINUE
, -1);
1556 return our_status
.value
.sig
;
1558 OUTMSG (("Ignoring unknown internal event, %d\n", our_status
.kind
));
1560 case TARGET_WAITKIND_SPURIOUS
:
1561 case TARGET_WAITKIND_EXECD
:
1562 /* do nothing, just continue */
1563 child_continue (DBG_CONTINUE
, -1);
1569 /* Fetch registers from the inferior process.
1570 If REGNO is -1, fetch all registers; otherwise, fetch at least REGNO. */
1572 win32_fetch_inferior_registers (int regno
)
1574 child_fetch_inferior_registers (regno
);
1577 /* Store registers to the inferior process.
1578 If REGNO is -1, store all registers; otherwise, store at least REGNO. */
1580 win32_store_inferior_registers (int regno
)
1582 child_store_inferior_registers (regno
);
1585 /* Read memory from the inferior process. This should generally be
1586 called through read_inferior_memory, which handles breakpoint shadowing.
1587 Read LEN bytes at MEMADDR into a buffer at MYADDR. */
1589 win32_read_inferior_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
1591 return child_xfer_memory (memaddr
, (char *) myaddr
, len
, 0, 0) != len
;
1594 /* Write memory to the inferior process. This should generally be
1595 called through write_inferior_memory, which handles breakpoint shadowing.
1596 Write LEN bytes from the buffer at MYADDR to MEMADDR.
1597 Returns 0 on success and errno on failure. */
1599 win32_write_inferior_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
,
1602 return child_xfer_memory (memaddr
, (char *) myaddr
, len
, 1, 0) != len
;
1605 /* Send an interrupt request to the inferior process. */
1607 win32_request_interrupt (void)
1609 winapi_DebugBreakProcess DebugBreakProcess
;
1610 winapi_GenerateConsoleCtrlEvent GenerateConsoleCtrlEvent
;
1613 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
1615 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
1618 GenerateConsoleCtrlEvent
= GETPROCADDRESS (dll
, GenerateConsoleCtrlEvent
);
1620 if (GenerateConsoleCtrlEvent
!= NULL
1621 && GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, current_process_id
))
1624 /* GenerateConsoleCtrlEvent can fail if process id being debugged is
1625 not a process group id.
1626 Fallback to XP/Vista 'DebugBreakProcess', which generates a
1627 breakpoint exception in the interior process. */
1629 DebugBreakProcess
= GETPROCADDRESS (dll
, DebugBreakProcess
);
1631 if (DebugBreakProcess
!= NULL
1632 && DebugBreakProcess (current_process_handle
))
1635 /* Last resort, suspend all threads manually. */
1636 soft_interrupt_requested
= 1;
1641 win32_error_to_fileio_error (DWORD err
)
1645 case ERROR_BAD_PATHNAME
:
1646 case ERROR_FILE_NOT_FOUND
:
1647 case ERROR_INVALID_NAME
:
1648 case ERROR_PATH_NOT_FOUND
:
1649 return FILEIO_ENOENT
;
1651 case ERROR_IO_DEVICE
:
1652 case ERROR_OPEN_FAILED
:
1654 case ERROR_INVALID_HANDLE
:
1655 return FILEIO_EBADF
;
1656 case ERROR_ACCESS_DENIED
:
1657 case ERROR_SHARING_VIOLATION
:
1658 return FILEIO_EACCES
;
1659 case ERROR_NOACCESS
:
1660 return FILEIO_EFAULT
;
1662 return FILEIO_EBUSY
;
1663 case ERROR_ALREADY_EXISTS
:
1664 case ERROR_FILE_EXISTS
:
1665 return FILEIO_EEXIST
;
1666 case ERROR_BAD_DEVICE
:
1667 return FILEIO_ENODEV
;
1668 case ERROR_DIRECTORY
:
1669 return FILEIO_ENOTDIR
;
1670 case ERROR_FILENAME_EXCED_RANGE
:
1671 case ERROR_INVALID_DATA
:
1672 case ERROR_INVALID_PARAMETER
:
1673 case ERROR_NEGATIVE_SEEK
:
1674 return FILEIO_EINVAL
;
1675 case ERROR_TOO_MANY_OPEN_FILES
:
1676 return FILEIO_EMFILE
;
1677 case ERROR_HANDLE_DISK_FULL
:
1678 case ERROR_DISK_FULL
:
1679 return FILEIO_ENOSPC
;
1680 case ERROR_WRITE_PROTECT
:
1681 return FILEIO_EROFS
;
1682 case ERROR_NOT_SUPPORTED
:
1683 return FILEIO_ENOSYS
;
1686 return FILEIO_EUNKNOWN
;
1690 wince_hostio_last_error (char *buf
)
1692 DWORD winerr
= GetLastError ();
1693 int fileio_err
= win32_error_to_fileio_error (winerr
);
1694 sprintf (buf
, "F-1,%x", fileio_err
);
1698 static struct target_ops win32_target_ops
= {
1699 win32_create_inferior
,
1707 win32_fetch_inferior_registers
,
1708 win32_store_inferior_registers
,
1709 win32_read_inferior_memory
,
1710 win32_write_inferior_memory
,
1712 win32_request_interrupt
,
1722 wince_hostio_last_error
,
1724 hostio_last_error_from_errno
,
1728 /* Initialize the Win32 backend. */
1730 initialize_low (void)
1732 set_target_ops (&win32_target_ops
);
1733 if (the_low_target
.breakpoint
!= NULL
)
1734 set_breakpoint_data (the_low_target
.breakpoint
,
1735 the_low_target
.breakpoint_len
);
1736 the_low_target
.arch_setup ();