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 /* Clear out any old thread list and reinitialize it to a pristine
247 child_init_thread_list (void)
249 for_each_inferior (&all_threads
, delete_thread_info
);
253 do_initial_child_stuff (HANDLE proch
, DWORD pid
)
255 last_sig
= TARGET_SIGNAL_0
;
257 current_process_handle
= proch
;
258 current_process_id
= pid
;
261 soft_interrupt_requested
= 0;
262 faked_breakpoint
= 0;
264 memset (¤t_event
, 0, sizeof (current_event
));
266 child_init_thread_list ();
268 if (the_low_target
.initial_stuff
!= NULL
)
269 (*the_low_target
.initial_stuff
) ();
272 /* Resume all artificially suspended threads if we are continuing
275 continue_one_thread (struct inferior_list_entry
*this_thread
, void *id_ptr
)
277 struct thread_info
*thread
= (struct thread_info
*) this_thread
;
278 int thread_id
= * (int *) id_ptr
;
279 win32_thread_info
*th
= inferior_target_data (thread
);
281 if ((thread_id
== -1 || thread_id
== th
->tid
)
284 if (th
->context
.ContextFlags
)
286 win32_set_thread_context (th
);
287 th
->context
.ContextFlags
= 0;
290 if (ResumeThread (th
->h
) == (DWORD
) -1)
292 DWORD err
= GetLastError ();
293 OUTMSG (("warning: ResumeThread failed in continue_one_thread, "
294 "(error %d): %s\n", (int) err
, strwinerror (err
)));
303 child_continue (DWORD continue_status
, int thread_id
)
305 /* The inferior will only continue after the ContinueDebugEvent
307 find_inferior (&all_threads
, continue_one_thread
, &thread_id
);
308 faked_breakpoint
= 0;
310 if (!ContinueDebugEvent (current_event
.dwProcessId
,
311 current_event
.dwThreadId
,
318 /* Fetch register(s) from the current thread context. */
320 child_fetch_inferior_registers (int r
)
323 win32_thread_info
*th
= thread_rec (current_inferior_tid (), TRUE
);
324 if (r
== -1 || r
== 0 || r
> NUM_REGS
)
325 child_fetch_inferior_registers (NUM_REGS
);
327 for (regno
= 0; regno
< r
; regno
++)
328 (*the_low_target
.fetch_inferior_register
) (th
, regno
);
331 /* Store a new register value into the current thread context. We don't
332 change the program's context until later, when we resume it. */
334 child_store_inferior_registers (int r
)
337 win32_thread_info
*th
= thread_rec (current_inferior_tid (), TRUE
);
338 if (r
== -1 || r
== 0 || r
> NUM_REGS
)
339 child_store_inferior_registers (NUM_REGS
);
341 for (regno
= 0; regno
< r
; regno
++)
342 (*the_low_target
.store_inferior_register
) (th
, regno
);
345 /* Map the Windows error number in ERROR to a locale-dependent error
346 message string and return a pointer to it. Typically, the values
347 for ERROR come from GetLastError.
349 The string pointed to shall not be modified by the application,
350 but may be overwritten by a subsequent call to strwinerror
352 The strwinerror function does not change the current setting
356 strwinerror (DWORD error
)
358 static char buf
[1024];
360 DWORD lasterr
= GetLastError ();
361 DWORD chars
= FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
362 | FORMAT_MESSAGE_ALLOCATE_BUFFER
,
365 0, /* Default language */
371 /* If there is an \r\n appended, zap it. */
373 && msgbuf
[chars
- 2] == '\r'
374 && msgbuf
[chars
- 1] == '\n')
380 if (chars
> ((COUNTOF (buf
)) - 1))
382 chars
= COUNTOF (buf
) - 1;
387 wcstombs (buf
, msgbuf
, chars
+ 1);
389 strncpy (buf
, msgbuf
, chars
+ 1);
394 sprintf (buf
, "unknown win32 error (%ld)", error
);
396 SetLastError (lasterr
);
401 create_process (const char *program
, char *args
,
402 DWORD flags
, PROCESS_INFORMATION
*pi
)
407 wchar_t *p
, *wprogram
, *wargs
;
410 wprogram
= alloca ((strlen (program
) + 1) * sizeof (wchar_t));
411 mbstowcs (wprogram
, program
, strlen (program
) + 1);
413 for (p
= wprogram
; *p
; ++p
)
417 argslen
= strlen (args
);
418 wargs
= alloca ((argslen
+ 1) * sizeof (wchar_t));
419 mbstowcs (wargs
, args
, argslen
+ 1);
421 ret
= CreateProcessW (wprogram
, /* image name */
422 wargs
, /* command line */
423 NULL
, /* security, not supported */
424 NULL
, /* thread, not supported */
425 FALSE
, /* inherit handles, not supported */
426 flags
, /* start flags */
427 NULL
, /* environment, not supported */
428 NULL
, /* current directory, not supported */
429 NULL
, /* start info, not supported */
432 STARTUPINFOA si
= { sizeof (STARTUPINFOA
) };
434 ret
= CreateProcessA (program
, /* image name */
435 args
, /* command line */
438 TRUE
, /* inherit handles */
439 flags
, /* start flags */
440 NULL
, /* environment */
441 NULL
, /* current directory */
442 &si
, /* start info */
449 /* Start a new process.
450 PROGRAM is a path to the program to execute.
451 ARGS is a standard NULL-terminated array of arguments,
452 to be passed to the inferior as ``argv''.
453 Returns the new PID on success, -1 on failure. Registers the new
454 process with the process list. */
456 win32_create_inferior (char *program
, char **program_args
)
459 char real_path
[MAXPATHLEN
];
460 char *orig_path
, *new_path
, *path_ptr
;
467 PROCESS_INFORMATION pi
;
470 /* win32_wait needs to know we're not attaching. */
474 error ("No executable specified, specify executable to debug.\n");
476 flags
= DEBUG_PROCESS
| DEBUG_ONLY_THIS_PROCESS
;
480 path_ptr
= getenv ("PATH");
483 orig_path
= alloca (strlen (path_ptr
) + 1);
484 new_path
= alloca (cygwin_posix_to_win32_path_list_buf_size (path_ptr
));
485 strcpy (orig_path
, path_ptr
);
486 cygwin_posix_to_win32_path_list (path_ptr
, new_path
);
487 setenv ("PATH", new_path
, 1);
489 cygwin_conv_to_win32_path (program
, real_path
);
494 for (argc
= 1; program_args
[argc
]; argc
++)
495 argslen
+= strlen (program_args
[argc
]) + 1;
496 args
= alloca (argslen
);
498 for (argc
= 1; program_args
[argc
]; argc
++)
500 /* FIXME: Can we do better about quoting? How does Cygwin
503 strcat (args
, program_args
[argc
]);
505 OUTMSG2 (("Command line is \"%s\"\n", args
));
507 #ifdef CREATE_NEW_PROCESS_GROUP
508 flags
|= CREATE_NEW_PROCESS_GROUP
;
511 ret
= create_process (program
, args
, flags
, &pi
);
512 err
= GetLastError ();
513 if (!ret
&& err
== ERROR_FILE_NOT_FOUND
)
515 char *exename
= alloca (strlen (program
) + 5);
516 strcat (strcpy (exename
, program
), ".exe");
517 ret
= create_process (exename
, args
, flags
, &pi
);
518 err
= GetLastError ();
523 setenv ("PATH", orig_path
, 1);
528 error ("Error creating process \"%s%s\", (error %d): %s\n",
529 program
, args
, (int) err
, strwinerror (err
));
533 OUTMSG2 (("Process created: %s\n", (char *) args
));
537 /* On Windows CE this handle can't be closed. The OS reuses
538 it in the debug events, while the 9x/NT versions of Windows
539 probably use a DuplicateHandle'd one. */
540 CloseHandle (pi
.hThread
);
543 do_initial_child_stuff (pi
.hProcess
, pi
.dwProcessId
);
545 return current_process_id
;
548 /* Attach to a running process.
549 PID is the process ID to attach to, specified by the user
550 or a higher layer. */
552 win32_attach (unsigned long pid
)
555 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
558 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
560 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
562 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
564 h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
567 if (DebugActiveProcess (pid
))
569 if (DebugSetProcessKillOnExit
!= NULL
)
570 DebugSetProcessKillOnExit (FALSE
);
572 /* win32_wait needs to know we're attaching. */
574 do_initial_child_stuff (h
, pid
);
581 err
= GetLastError ();
582 error ("Attach to process failed (error %d): %s\n",
583 (int) err
, strwinerror (err
));
586 /* Handle OUTPUT_DEBUG_STRING_EVENT from child process. */
588 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
590 #define READ_BUFFER_LEN 1024
592 char s
[READ_BUFFER_LEN
+ 1] = { 0 };
593 DWORD nbytes
= current_event
.u
.DebugString
.nDebugStringLength
;
598 if (nbytes
> READ_BUFFER_LEN
)
599 nbytes
= READ_BUFFER_LEN
;
601 addr
= (CORE_ADDR
) (size_t) current_event
.u
.DebugString
.lpDebugStringData
;
603 if (current_event
.u
.DebugString
.fUnicode
)
605 /* The event tells us how many bytes, not chars, even
607 WCHAR buffer
[(READ_BUFFER_LEN
+ 1) / sizeof (WCHAR
)] = { 0 };
608 if (read_inferior_memory (addr
, (unsigned char *) buffer
, nbytes
) != 0)
610 wcstombs (s
, buffer
, (nbytes
+ 1) / sizeof (WCHAR
));
614 if (read_inferior_memory (addr
, (unsigned char *) s
, nbytes
) != 0)
618 if (strncmp (s
, "cYg", 3) != 0)
628 #undef READ_BUFFER_LEN
632 win32_clear_inferiors (void)
634 if (current_process_handle
!= NULL
)
635 CloseHandle (current_process_handle
);
637 for_each_inferior (&all_threads
, delete_thread_info
);
641 /* Kill all inferiors. */
645 if (current_process_handle
== NULL
)
648 TerminateProcess (current_process_handle
, 0);
651 if (!child_continue (DBG_CONTINUE
, -1))
653 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
655 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
657 else if (current_event
.dwDebugEventCode
== OUTPUT_DEBUG_STRING_EVENT
)
659 struct target_waitstatus our_status
= { 0 };
660 handle_output_debug_string (&our_status
);
664 win32_clear_inferiors ();
667 /* Detach from all inferiors. */
671 winapi_DebugActiveProcessStop DebugActiveProcessStop
= NULL
;
672 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
674 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
676 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
678 DebugActiveProcessStop
= GETPROCADDRESS (dll
, DebugActiveProcessStop
);
679 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
681 if (DebugSetProcessKillOnExit
== NULL
682 || DebugActiveProcessStop
== NULL
)
686 struct thread_resume resume
;
688 resume
.kind
= resume_continue
;
690 win32_resume (&resume
, 1);
693 if (!DebugActiveProcessStop (current_process_id
))
696 DebugSetProcessKillOnExit (FALSE
);
698 win32_clear_inferiors ();
702 /* Wait for inferiors to end. */
706 extern unsigned long signal_pid
;
708 HANDLE h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, signal_pid
);
711 WaitForSingleObject (h
, INFINITE
);
716 /* Return 1 iff the thread with thread ID TID is alive. */
718 win32_thread_alive (unsigned long tid
)
722 /* Our thread list is reliable; don't bother to poll target
724 if (find_inferior_id (&all_threads
, tid
) != NULL
)
731 /* Resume the inferior process. RESUME_INFO describes how we want
734 win32_resume (struct thread_resume
*resume_info
, size_t n
)
737 enum target_signal sig
;
739 win32_thread_info
*th
;
740 DWORD continue_status
= DBG_CONTINUE
;
742 /* This handles the very limited set of resume packets that GDB can
743 currently produce. */
745 if (n
== 1 && resume_info
[0].thread
== -1)
750 /* Yes, we're ignoring resume_info[0].thread. It'd be tricky to make
751 the Windows resume code do the right thing for thread switching. */
752 tid
= current_event
.dwThreadId
;
754 if (resume_info
[0].thread
!= -1)
756 sig
= resume_info
[0].sig
;
757 step
= resume_info
[0].kind
== resume_step
;
765 if (sig
!= TARGET_SIGNAL_0
)
767 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
769 OUTMSG (("Cannot continue with signal %d here.\n", sig
));
771 else if (sig
== last_sig
)
772 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
774 OUTMSG (("Can only continue with recieved signal %d.\n", last_sig
));
777 last_sig
= TARGET_SIGNAL_0
;
779 /* Get context for the currently selected thread. */
780 th
= thread_rec (current_event
.dwThreadId
, FALSE
);
783 if (th
->context
.ContextFlags
)
785 /* Move register values from the inferior into the thread
786 context structure. */
787 regcache_invalidate ();
791 if (the_low_target
.single_step
!= NULL
)
792 (*the_low_target
.single_step
) (th
);
794 error ("Single stepping is not supported "
795 "in this configuration.\n");
798 win32_set_thread_context (th
);
799 th
->context
.ContextFlags
= 0;
803 /* Allow continuing with the same signal that interrupted us.
804 Otherwise complain. */
806 child_continue (continue_status
, tid
);
810 win32_add_one_solib (const char *name
, CORE_ADDR load_addr
)
812 char buf
[MAX_PATH
+ 1];
813 char buf2
[MAX_PATH
+ 1];
816 WIN32_FIND_DATA w32_fd
;
817 WCHAR wname
[MAX_PATH
+ 1];
818 mbstowcs (wname
, name
, MAX_PATH
);
819 HANDLE h
= FindFirstFile (wname
, &w32_fd
);
821 WIN32_FIND_DATAA w32_fd
;
822 HANDLE h
= FindFirstFileA (name
, &w32_fd
);
825 if (h
== INVALID_HANDLE_VALUE
)
833 char cwd
[MAX_PATH
+ 1];
835 if (GetCurrentDirectoryA (MAX_PATH
+ 1, cwd
))
837 p
= strrchr (buf
, '\\');
840 SetCurrentDirectoryA (buf
);
841 GetFullPathNameA (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
842 SetCurrentDirectoryA (cwd
);
849 cygwin_conv_to_posix_path (buf
, buf2
);
854 loaded_dll (buf2
, load_addr
);
858 get_image_name (HANDLE h
, void *address
, int unicode
)
860 static char buf
[(2 * MAX_PATH
) + 1];
861 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
867 /* Attempt to read the name of the dll that was detected.
868 This is documented to work only when actively debugging
869 a program. It will not work for attached processes. */
874 /* Windows CE reports the address of the image name,
875 instead of an address of a pointer into the image name. */
876 address_ptr
= address
;
878 /* See if we could read the address of a string, and that the
879 address isn't null. */
880 if (!ReadProcessMemory (h
, address
, &address_ptr
,
881 sizeof (address_ptr
), &done
)
882 || done
!= sizeof (address_ptr
)
887 /* Find the length of the string */
888 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
889 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
893 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
896 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
897 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
900 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
906 typedef BOOL (WINAPI
*winapi_EnumProcessModules
) (HANDLE
, HMODULE
*,
908 typedef BOOL (WINAPI
*winapi_GetModuleInformation
) (HANDLE
, HMODULE
,
909 LPMODULEINFO
, DWORD
);
910 typedef DWORD (WINAPI
*winapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
,
913 static winapi_EnumProcessModules win32_EnumProcessModules
;
914 static winapi_GetModuleInformation win32_GetModuleInformation
;
915 static winapi_GetModuleFileNameExA win32_GetModuleFileNameExA
;
920 static int psapi_loaded
= 0;
921 static HMODULE dll
= NULL
;
926 dll
= LoadLibrary (TEXT("psapi.dll"));
929 win32_EnumProcessModules
=
930 GETPROCADDRESS (dll
, EnumProcessModules
);
931 win32_GetModuleInformation
=
932 GETPROCADDRESS (dll
, GetModuleInformation
);
933 win32_GetModuleFileNameExA
=
934 GETPROCADDRESS (dll
, GetModuleFileNameExA
);
937 return (win32_EnumProcessModules
!= NULL
938 && win32_GetModuleInformation
!= NULL
939 && win32_GetModuleFileNameExA
!= NULL
);
943 psapi_get_dll_name (DWORD BaseAddress
, char *dll_name_ret
)
949 HMODULE
*DllHandle
= dh_buf
;
957 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
962 if (!ok
|| !cbNeeded
)
965 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
969 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
976 for (i
= 0; i
< ((size_t) cbNeeded
/ sizeof (HMODULE
)); i
++)
978 if (!(*win32_GetModuleInformation
) (current_process_handle
,
983 DWORD err
= GetLastError ();
984 error ("Can't get module info: (error %d): %s\n",
985 (int) err
, strwinerror (err
));
988 if ((DWORD
) (mi
.lpBaseOfDll
) == BaseAddress
)
990 len
= (*win32_GetModuleFileNameExA
) (current_process_handle
,
996 DWORD err
= GetLastError ();
997 error ("Error getting dll name: (error %d): %s\n",
998 (int) err
, strwinerror (err
));
1005 dll_name_ret
[0] = '\0';
1009 typedef HANDLE (WINAPI
*winapi_CreateToolhelp32Snapshot
) (DWORD
, DWORD
);
1010 typedef BOOL (WINAPI
*winapi_Module32First
) (HANDLE
, LPMODULEENTRY32
);
1011 typedef BOOL (WINAPI
*winapi_Module32Next
) (HANDLE
, LPMODULEENTRY32
);
1013 static winapi_CreateToolhelp32Snapshot win32_CreateToolhelp32Snapshot
;
1014 static winapi_Module32First win32_Module32First
;
1015 static winapi_Module32Next win32_Module32Next
;
1017 typedef BOOL (WINAPI
*winapi_CloseToolhelp32Snapshot
) (HANDLE
);
1018 static winapi_CloseToolhelp32Snapshot win32_CloseToolhelp32Snapshot
;
1022 load_toolhelp (void)
1024 static int toolhelp_loaded
= 0;
1025 static HMODULE dll
= NULL
;
1027 if (!toolhelp_loaded
)
1029 toolhelp_loaded
= 1;
1031 dll
= GetModuleHandle (_T("KERNEL32.DLL"));
1033 dll
= LoadLibrary (L
"TOOLHELP.DLL");
1038 win32_CreateToolhelp32Snapshot
=
1039 GETPROCADDRESS (dll
, CreateToolhelp32Snapshot
);
1040 win32_Module32First
= GETPROCADDRESS (dll
, Module32First
);
1041 win32_Module32Next
= GETPROCADDRESS (dll
, Module32Next
);
1043 win32_CloseToolhelp32Snapshot
=
1044 GETPROCADDRESS (dll
, CloseToolhelp32Snapshot
);
1048 return (win32_CreateToolhelp32Snapshot
!= NULL
1049 && win32_Module32First
!= NULL
1050 && win32_Module32Next
!= NULL
1052 && win32_CloseToolhelp32Snapshot
!= NULL
1058 toolhelp_get_dll_name (DWORD BaseAddress
, char *dll_name_ret
)
1060 HANDLE snapshot_module
;
1061 MODULEENTRY32 modEntry
= { sizeof (MODULEENTRY32
) };
1064 if (!load_toolhelp ())
1067 snapshot_module
= win32_CreateToolhelp32Snapshot (TH32CS_SNAPMODULE
,
1068 current_event
.dwProcessId
);
1069 if (snapshot_module
== INVALID_HANDLE_VALUE
)
1072 /* Ignore the first module, which is the exe. */
1073 if (win32_Module32First (snapshot_module
, &modEntry
))
1074 while (win32_Module32Next (snapshot_module
, &modEntry
))
1075 if ((DWORD
) modEntry
.modBaseAddr
== BaseAddress
)
1078 wcstombs (dll_name_ret
, modEntry
.szExePath
, MAX_PATH
+ 1);
1080 strcpy (dll_name_ret
, modEntry
.szExePath
);
1087 win32_CloseToolhelp32Snapshot (snapshot_module
);
1089 CloseHandle (snapshot_module
);
1095 handle_load_dll (void)
1097 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
1098 char dll_buf
[MAX_PATH
+ 1];
1099 char *dll_name
= NULL
;
1102 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
1104 /* Windows does not report the image name of the dlls in the debug
1105 event on attaches. We resort to iterating over the list of
1106 loaded dlls looking for a match by image base. */
1107 if (!psapi_get_dll_name ((DWORD
) event
->lpBaseOfDll
, dll_buf
))
1109 if (!server_waiting
)
1110 /* On some versions of Windows and Windows CE, we can't create
1111 toolhelp snapshots while the inferior is stopped in a
1112 LOAD_DLL_DEBUG_EVENT due to a dll load, but we can while
1113 Windows is reporting the already loaded dlls. */
1114 toolhelp_get_dll_name ((DWORD
) event
->lpBaseOfDll
, dll_buf
);
1119 if (*dll_name
== '\0')
1120 dll_name
= get_image_name (current_process_handle
,
1121 event
->lpImageName
, event
->fUnicode
);
1125 /* The symbols in a dll are offset by 0x1000, which is the
1126 the offset from 0 of the first byte in an image - because
1127 of the file header and the section alignment. */
1129 load_addr
= (DWORD
) event
->lpBaseOfDll
+ 0x1000;
1130 win32_add_one_solib (dll_name
, load_addr
);
1134 handle_unload_dll (void)
1136 CORE_ADDR load_addr
=
1137 (CORE_ADDR
) (DWORD
) current_event
.u
.UnloadDll
.lpBaseOfDll
;
1138 load_addr
+= 0x1000;
1139 unloaded_dll (NULL
, load_addr
);
1143 handle_exception (struct target_waitstatus
*ourstatus
)
1145 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1147 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1151 case EXCEPTION_ACCESS_VIOLATION
:
1152 OUTMSG2 (("EXCEPTION_ACCESS_VIOLATION"));
1153 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1155 case STATUS_STACK_OVERFLOW
:
1156 OUTMSG2 (("STATUS_STACK_OVERFLOW"));
1157 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1159 case STATUS_FLOAT_DENORMAL_OPERAND
:
1160 OUTMSG2 (("STATUS_FLOAT_DENORMAL_OPERAND"));
1161 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1163 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1164 OUTMSG2 (("EXCEPTION_ARRAY_BOUNDS_EXCEEDED"));
1165 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1167 case STATUS_FLOAT_INEXACT_RESULT
:
1168 OUTMSG2 (("STATUS_FLOAT_INEXACT_RESULT"));
1169 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1171 case STATUS_FLOAT_INVALID_OPERATION
:
1172 OUTMSG2 (("STATUS_FLOAT_INVALID_OPERATION"));
1173 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1175 case STATUS_FLOAT_OVERFLOW
:
1176 OUTMSG2 (("STATUS_FLOAT_OVERFLOW"));
1177 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1179 case STATUS_FLOAT_STACK_CHECK
:
1180 OUTMSG2 (("STATUS_FLOAT_STACK_CHECK"));
1181 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1183 case STATUS_FLOAT_UNDERFLOW
:
1184 OUTMSG2 (("STATUS_FLOAT_UNDERFLOW"));
1185 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1187 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1188 OUTMSG2 (("STATUS_FLOAT_DIVIDE_BY_ZERO"));
1189 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1191 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1192 OUTMSG2 (("STATUS_INTEGER_DIVIDE_BY_ZERO"));
1193 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1195 case STATUS_INTEGER_OVERFLOW
:
1196 OUTMSG2 (("STATUS_INTEGER_OVERFLOW"));
1197 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1199 case EXCEPTION_BREAKPOINT
:
1200 OUTMSG2 (("EXCEPTION_BREAKPOINT"));
1201 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1203 /* Remove the initial breakpoint. */
1204 check_breakpoints ((CORE_ADDR
) (long) current_event
1205 .u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1209 OUTMSG2 (("DBG_CONTROL_C"));
1210 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1212 case DBG_CONTROL_BREAK
:
1213 OUTMSG2 (("DBG_CONTROL_BREAK"));
1214 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1216 case EXCEPTION_SINGLE_STEP
:
1217 OUTMSG2 (("EXCEPTION_SINGLE_STEP"));
1218 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1220 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1221 OUTMSG2 (("EXCEPTION_ILLEGAL_INSTRUCTION"));
1222 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1224 case EXCEPTION_PRIV_INSTRUCTION
:
1225 OUTMSG2 (("EXCEPTION_PRIV_INSTRUCTION"));
1226 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1228 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1229 OUTMSG2 (("EXCEPTION_NONCONTINUABLE_EXCEPTION"));
1230 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1233 if (current_event
.u
.Exception
.dwFirstChance
)
1235 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1238 OUTMSG2 (("gdbserver: unknown target exception 0x%08lx at 0x%08lx",
1239 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1240 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.
1242 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1246 last_sig
= ourstatus
->value
.sig
;
1251 suspend_one_thread (struct inferior_list_entry
*entry
)
1253 struct thread_info
*thread
= (struct thread_info
*) entry
;
1254 win32_thread_info
*th
= inferior_target_data (thread
);
1258 if (SuspendThread (th
->h
) == (DWORD
) -1)
1260 DWORD err
= GetLastError ();
1261 OUTMSG (("warning: SuspendThread failed in suspend_one_thread, "
1262 "(error %d): %s\n", (int) err
, strwinerror (err
)));
1270 fake_breakpoint_event (void)
1272 OUTMSG2(("fake_breakpoint_event\n"));
1274 faked_breakpoint
= 1;
1276 memset (¤t_event
, 0, sizeof (current_event
));
1277 current_event
.dwThreadId
= main_thread_id
;
1278 current_event
.dwDebugEventCode
= EXCEPTION_DEBUG_EVENT
;
1279 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1280 = EXCEPTION_BREAKPOINT
;
1282 for_each_inferior (&all_threads
, suspend_one_thread
);
1287 auto_delete_breakpoint (CORE_ADDR stop_pc
)
1293 /* Get the next event from the child. */
1296 get_child_debug_event (struct target_waitstatus
*ourstatus
)
1298 last_sig
= TARGET_SIGNAL_0
;
1299 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1301 /* Check if GDB sent us an interrupt request. */
1302 check_remote_input_interrupt_request ();
1304 if (soft_interrupt_requested
)
1306 soft_interrupt_requested
= 0;
1307 fake_breakpoint_event ();
1316 /* WinCE doesn't set an initial breakpoint automatically. To
1317 stop the inferior, we flush all currently pending debug
1318 events -- the thread list and the dll list are always
1319 reported immediatelly without delay, then, we suspend all
1320 threads and pretend we saw a trap at the current PC of the
1323 Contrary to desktop Windows, Windows CE *does* report the dll
1324 names on LOAD_DLL_DEBUG_EVENTs resulting from a
1325 DebugActiveProcess call. This limits the way we can detect
1326 if all the dlls have already been reported. If we get a real
1327 debug event before leaving attaching, the worst that will
1328 happen is the user will see a spurious breakpoint. */
1330 current_event
.dwDebugEventCode
= 0;
1331 if (!WaitForDebugEvent (¤t_event
, 0))
1333 OUTMSG2(("no attach events left\n"));
1334 fake_breakpoint_event ();
1338 OUTMSG2(("got attach event\n"));
1343 /* Keep the wait time low enough for confortable remote
1344 interruption, but high enough so gdbserver doesn't become a
1346 if (!WaitForDebugEvent (¤t_event
, 250))
1353 (struct thread_info
*) find_inferior_id (&all_threads
,
1354 current_event
.dwThreadId
);
1356 switch (current_event
.dwDebugEventCode
)
1358 case CREATE_THREAD_DEBUG_EVENT
:
1359 OUTMSG2 (("gdbserver: kernel event CREATE_THREAD_DEBUG_EVENT "
1360 "for pid=%d tid=%x)\n",
1361 (unsigned) current_event
.dwProcessId
,
1362 (unsigned) current_event
.dwThreadId
));
1364 /* Record the existence of this thread. */
1365 child_add_thread (current_event
.dwThreadId
,
1366 current_event
.u
.CreateThread
.hThread
);
1369 case EXIT_THREAD_DEBUG_EVENT
:
1370 OUTMSG2 (("gdbserver: kernel event EXIT_THREAD_DEBUG_EVENT "
1371 "for pid=%d tid=%x\n",
1372 (unsigned) current_event
.dwProcessId
,
1373 (unsigned) current_event
.dwThreadId
));
1374 child_delete_thread (current_event
.dwThreadId
);
1377 case CREATE_PROCESS_DEBUG_EVENT
:
1378 OUTMSG2 (("gdbserver: kernel event CREATE_PROCESS_DEBUG_EVENT "
1379 "for pid=%d tid=%x\n",
1380 (unsigned) current_event
.dwProcessId
,
1381 (unsigned) current_event
.dwThreadId
));
1382 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1384 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1385 main_thread_id
= current_event
.dwThreadId
;
1387 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
1388 ourstatus
->value
.execd_pathname
= "Main executable";
1390 /* Add the main thread. */
1391 child_add_thread (main_thread_id
,
1392 current_event
.u
.CreateProcessInfo
.hThread
);
1394 ourstatus
->value
.related_pid
= current_event
.dwThreadId
;
1398 /* Windows CE doesn't set the initial breakpoint
1399 automatically like the desktop versions of Windows do.
1400 We add it explicitly here. It will be removed as soon as
1402 set_breakpoint_at ((CORE_ADDR
) (long) current_event
.u
1403 .CreateProcessInfo
.lpStartAddress
,
1404 auto_delete_breakpoint
);
1409 case EXIT_PROCESS_DEBUG_EVENT
:
1410 OUTMSG2 (("gdbserver: kernel event EXIT_PROCESS_DEBUG_EVENT "
1411 "for pid=%d tid=%x\n",
1412 (unsigned) current_event
.dwProcessId
,
1413 (unsigned) current_event
.dwThreadId
));
1414 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1415 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1416 child_continue (DBG_CONTINUE
, -1);
1417 CloseHandle (current_process_handle
);
1418 current_process_handle
= NULL
;
1421 case LOAD_DLL_DEBUG_EVENT
:
1422 OUTMSG2 (("gdbserver: kernel event LOAD_DLL_DEBUG_EVENT "
1423 "for pid=%d tid=%x\n",
1424 (unsigned) current_event
.dwProcessId
,
1425 (unsigned) current_event
.dwThreadId
));
1426 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1429 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1430 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1433 case UNLOAD_DLL_DEBUG_EVENT
:
1434 OUTMSG2 (("gdbserver: kernel event UNLOAD_DLL_DEBUG_EVENT "
1435 "for pid=%d tid=%x\n",
1436 (unsigned) current_event
.dwProcessId
,
1437 (unsigned) current_event
.dwThreadId
));
1438 handle_unload_dll ();
1439 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1440 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1443 case EXCEPTION_DEBUG_EVENT
:
1444 OUTMSG2 (("gdbserver: kernel event EXCEPTION_DEBUG_EVENT "
1445 "for pid=%d tid=%x\n",
1446 (unsigned) current_event
.dwProcessId
,
1447 (unsigned) current_event
.dwThreadId
));
1448 handle_exception (ourstatus
);
1451 case OUTPUT_DEBUG_STRING_EVENT
:
1452 /* A message from the kernel (or Cygwin). */
1453 OUTMSG2 (("gdbserver: kernel event OUTPUT_DEBUG_STRING_EVENT "
1454 "for pid=%d tid=%x\n",
1455 (unsigned) current_event
.dwProcessId
,
1456 (unsigned) current_event
.dwThreadId
));
1457 handle_output_debug_string (ourstatus
);
1461 OUTMSG2 (("gdbserver: kernel event unknown "
1462 "for pid=%d tid=%x code=%ld\n",
1463 (unsigned) current_event
.dwProcessId
,
1464 (unsigned) current_event
.dwThreadId
,
1465 current_event
.dwDebugEventCode
));
1470 (struct thread_info
*) find_inferior_id (&all_threads
,
1471 current_event
.dwThreadId
);
1475 /* Wait for the inferior process to change state.
1476 STATUS will be filled in with a response code to send to GDB.
1477 Returns the signal which caused the process to stop. */
1478 static unsigned long
1479 win32_wait (struct target_waitstatus
*ourstatus
, int options
)
1483 if (!get_child_debug_event (ourstatus
))
1486 switch (ourstatus
->kind
)
1488 case TARGET_WAITKIND_EXITED
:
1489 OUTMSG2 (("Child exited with retcode = %x\n",
1490 ourstatus
->value
.integer
));
1492 win32_clear_inferiors ();
1493 return current_event
.dwProcessId
;
1494 case TARGET_WAITKIND_STOPPED
:
1495 case TARGET_WAITKIND_LOADED
:
1496 OUTMSG2 (("Child Stopped with signal = %d \n",
1497 our_status
.value
.sig
));
1499 child_fetch_inferior_registers (-1);
1501 if (ourstatus
->kind
== TARGET_WAITKIND_LOADED
1504 /* When gdb connects, we want to be stopped at the
1505 initial breakpoint, not in some dll load event. */
1506 child_continue (DBG_CONTINUE
, -1);
1510 /* We don't expose _LOADED events to gdbserver core. See
1511 the `dlls_changed' global. */
1512 if (ourstatus
->kind
== TARGET_WAITKIND_LOADED
)
1513 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1515 return current_event
.dwThreadId
;
1517 OUTMSG (("Ignoring unknown internal event, %d\n", ourstatus
->kind
));
1519 case TARGET_WAITKIND_SPURIOUS
:
1520 case TARGET_WAITKIND_EXECD
:
1521 /* do nothing, just continue */
1522 child_continue (DBG_CONTINUE
, -1);
1528 /* Fetch registers from the inferior process.
1529 If REGNO is -1, fetch all registers; otherwise, fetch at least REGNO. */
1531 win32_fetch_inferior_registers (int regno
)
1533 child_fetch_inferior_registers (regno
);
1536 /* Store registers to the inferior process.
1537 If REGNO is -1, store all registers; otherwise, store at least REGNO. */
1539 win32_store_inferior_registers (int regno
)
1541 child_store_inferior_registers (regno
);
1544 /* Read memory from the inferior process. This should generally be
1545 called through read_inferior_memory, which handles breakpoint shadowing.
1546 Read LEN bytes at MEMADDR into a buffer at MYADDR. */
1548 win32_read_inferior_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
1550 return child_xfer_memory (memaddr
, (char *) myaddr
, len
, 0, 0) != len
;
1553 /* Write memory to the inferior process. This should generally be
1554 called through write_inferior_memory, which handles breakpoint shadowing.
1555 Write LEN bytes from the buffer at MYADDR to MEMADDR.
1556 Returns 0 on success and errno on failure. */
1558 win32_write_inferior_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
,
1561 return child_xfer_memory (memaddr
, (char *) myaddr
, len
, 1, 0) != len
;
1564 /* Send an interrupt request to the inferior process. */
1566 win32_request_interrupt (void)
1568 winapi_DebugBreakProcess DebugBreakProcess
;
1569 winapi_GenerateConsoleCtrlEvent GenerateConsoleCtrlEvent
;
1572 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
1574 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
1577 GenerateConsoleCtrlEvent
= GETPROCADDRESS (dll
, GenerateConsoleCtrlEvent
);
1579 if (GenerateConsoleCtrlEvent
!= NULL
1580 && GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, current_process_id
))
1583 /* GenerateConsoleCtrlEvent can fail if process id being debugged is
1584 not a process group id.
1585 Fallback to XP/Vista 'DebugBreakProcess', which generates a
1586 breakpoint exception in the interior process. */
1588 DebugBreakProcess
= GETPROCADDRESS (dll
, DebugBreakProcess
);
1590 if (DebugBreakProcess
!= NULL
1591 && DebugBreakProcess (current_process_handle
))
1594 /* Last resort, suspend all threads manually. */
1595 soft_interrupt_requested
= 1;
1600 win32_error_to_fileio_error (DWORD err
)
1604 case ERROR_BAD_PATHNAME
:
1605 case ERROR_FILE_NOT_FOUND
:
1606 case ERROR_INVALID_NAME
:
1607 case ERROR_PATH_NOT_FOUND
:
1608 return FILEIO_ENOENT
;
1610 case ERROR_IO_DEVICE
:
1611 case ERROR_OPEN_FAILED
:
1613 case ERROR_INVALID_HANDLE
:
1614 return FILEIO_EBADF
;
1615 case ERROR_ACCESS_DENIED
:
1616 case ERROR_SHARING_VIOLATION
:
1617 return FILEIO_EACCES
;
1618 case ERROR_NOACCESS
:
1619 return FILEIO_EFAULT
;
1621 return FILEIO_EBUSY
;
1622 case ERROR_ALREADY_EXISTS
:
1623 case ERROR_FILE_EXISTS
:
1624 return FILEIO_EEXIST
;
1625 case ERROR_BAD_DEVICE
:
1626 return FILEIO_ENODEV
;
1627 case ERROR_DIRECTORY
:
1628 return FILEIO_ENOTDIR
;
1629 case ERROR_FILENAME_EXCED_RANGE
:
1630 case ERROR_INVALID_DATA
:
1631 case ERROR_INVALID_PARAMETER
:
1632 case ERROR_NEGATIVE_SEEK
:
1633 return FILEIO_EINVAL
;
1634 case ERROR_TOO_MANY_OPEN_FILES
:
1635 return FILEIO_EMFILE
;
1636 case ERROR_HANDLE_DISK_FULL
:
1637 case ERROR_DISK_FULL
:
1638 return FILEIO_ENOSPC
;
1639 case ERROR_WRITE_PROTECT
:
1640 return FILEIO_EROFS
;
1641 case ERROR_NOT_SUPPORTED
:
1642 return FILEIO_ENOSYS
;
1645 return FILEIO_EUNKNOWN
;
1649 wince_hostio_last_error (char *buf
)
1651 DWORD winerr
= GetLastError ();
1652 int fileio_err
= win32_error_to_fileio_error (winerr
);
1653 sprintf (buf
, "F-1,%x", fileio_err
);
1657 static struct target_ops win32_target_ops
= {
1658 win32_create_inferior
,
1666 win32_fetch_inferior_registers
,
1667 win32_store_inferior_registers
,
1668 win32_read_inferior_memory
,
1669 win32_write_inferior_memory
,
1671 win32_request_interrupt
,
1681 wince_hostio_last_error
,
1683 hostio_last_error_from_errno
,
1687 /* Initialize the Win32 backend. */
1689 initialize_low (void)
1691 set_target_ops (&win32_target_ops
);
1692 if (the_low_target
.breakpoint
!= NULL
)
1693 set_breakpoint_data (the_low_target
.breakpoint
,
1694 the_low_target
.breakpoint_len
);
1695 the_low_target
.arch_setup ();