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_ptid (void)
100 return ((struct inferior_list_entry
*) current_inferior
)->id
;
103 /* The current debug event from WaitForDebugEvent. */
105 debug_event_ptid (DEBUG_EVENT
*event
)
107 return ptid_build (event
->dwProcessId
, event
->dwThreadId
, 0);
110 /* Get the thread context of the thread associated with TH. */
113 win32_get_thread_context (win32_thread_info
*th
)
115 memset (&th
->context
, 0, sizeof (CONTEXT
));
116 (*the_low_target
.get_thread_context
) (th
, ¤t_event
);
118 memcpy (&th
->base_context
, &th
->context
, sizeof (CONTEXT
));
122 /* Set the thread context of the thread associated with TH. */
125 win32_set_thread_context (win32_thread_info
*th
)
128 /* Calling SuspendThread on a thread that is running kernel code
129 will report that the suspending was successful, but in fact, that
130 will often not be true. In those cases, the context returned by
131 GetThreadContext will not be correct by the time the thread
132 stops, hence we can't set that context back into the thread when
133 resuming - it will most likelly crash the inferior.
134 Unfortunately, there is no way to know when the thread will
135 really stop. To work around it, we'll only write the context
136 back to the thread when either the user or GDB explicitly change
137 it between stopping and resuming. */
138 if (memcmp (&th
->context
, &th
->base_context
, sizeof (CONTEXT
)) != 0)
140 (*the_low_target
.set_thread_context
) (th
, ¤t_event
);
143 /* Find a thread record given a thread id. If GET_CONTEXT is set then
144 also retrieve the context for this thread. */
145 static win32_thread_info
*
146 thread_rec (ptid_t ptid
, int get_context
)
148 struct thread_info
*thread
;
149 win32_thread_info
*th
;
151 thread
= (struct thread_info
*) find_inferior_id (&all_threads
, ptid
);
155 th
= inferior_target_data (thread
);
156 if (get_context
&& th
->context
.ContextFlags
== 0)
160 if (SuspendThread (th
->h
) == (DWORD
) -1)
162 DWORD err
= GetLastError ();
163 OUTMSG (("warning: SuspendThread failed in thread_rec, "
164 "(error %d): %s\n", (int) err
, strwinerror (err
)));
170 win32_get_thread_context (th
);
176 /* Add a thread to the thread list. */
177 static win32_thread_info
*
178 child_add_thread (DWORD pid
, DWORD tid
, HANDLE h
)
180 win32_thread_info
*th
;
181 ptid_t ptid
= ptid_build (pid
, tid
, 0);
183 if ((th
= thread_rec (ptid
, FALSE
)))
186 th
= xcalloc (1, sizeof (*th
));
190 add_thread (ptid
, th
);
191 set_inferior_regcache_data ((struct thread_info
*)
192 find_inferior_id (&all_threads
, ptid
),
193 new_register_cache ());
195 if (the_low_target
.thread_added
!= NULL
)
196 (*the_low_target
.thread_added
) (th
);
201 /* Delete a thread from the list of threads. */
203 delete_thread_info (struct inferior_list_entry
*thread
)
205 win32_thread_info
*th
= inferior_target_data ((struct thread_info
*) thread
);
207 remove_thread ((struct thread_info
*) thread
);
212 /* Delete a thread from the list of threads. */
214 child_delete_thread (DWORD pid
, DWORD tid
)
216 struct inferior_list_entry
*thread
;
219 /* If the last thread is exiting, just return. */
220 if (all_threads
.head
== all_threads
.tail
)
223 ptid
= ptid_build (pid
, tid
, 0);
224 thread
= find_inferior_id (&all_threads
, ptid
);
228 delete_thread_info (thread
);
231 /* These watchpoint related wrapper functions simply pass on the function call
232 if the low target has registered a corresponding function. */
235 win32_insert_point (char type
, CORE_ADDR addr
, int len
)
237 if (the_low_target
.insert_point
!= NULL
)
238 return the_low_target
.insert_point (type
, addr
, len
);
240 /* Unsupported (see target.h). */
245 win32_remove_point (char type
, CORE_ADDR addr
, int len
)
247 if (the_low_target
.remove_point
!= NULL
)
248 return the_low_target
.remove_point (type
, addr
, len
);
250 /* Unsupported (see target.h). */
255 win32_stopped_by_watchpoint (void)
257 if (the_low_target
.stopped_by_watchpoint
!= NULL
)
258 return the_low_target
.stopped_by_watchpoint ();
264 win32_stopped_data_address (void)
266 if (the_low_target
.stopped_data_address
!= NULL
)
267 return the_low_target
.stopped_data_address ();
273 /* Transfer memory from/to the debugged process. */
275 child_xfer_memory (CORE_ADDR memaddr
, char *our
, int len
,
276 int write
, struct target_ops
*target
)
279 long addr
= (long) memaddr
;
283 WriteProcessMemory (current_process_handle
, (LPVOID
) addr
,
284 (LPCVOID
) our
, len
, &done
);
285 FlushInstructionCache (current_process_handle
, (LPCVOID
) addr
, len
);
289 ReadProcessMemory (current_process_handle
, (LPCVOID
) addr
, (LPVOID
) our
,
295 /* Clear out any old thread list and reinitialize it to a pristine
298 child_init_thread_list (void)
300 for_each_inferior (&all_threads
, delete_thread_info
);
304 do_initial_child_stuff (HANDLE proch
, DWORD pid
, int attached
)
306 last_sig
= TARGET_SIGNAL_0
;
308 current_process_handle
= proch
;
309 current_process_id
= pid
;
312 soft_interrupt_requested
= 0;
313 faked_breakpoint
= 0;
315 memset (¤t_event
, 0, sizeof (current_event
));
317 add_process (pid
, attached
);
318 child_init_thread_list ();
320 if (the_low_target
.initial_stuff
!= NULL
)
321 (*the_low_target
.initial_stuff
) ();
324 /* Resume all artificially suspended threads if we are continuing
327 continue_one_thread (struct inferior_list_entry
*this_thread
, void *id_ptr
)
329 struct thread_info
*thread
= (struct thread_info
*) this_thread
;
330 int thread_id
= * (int *) id_ptr
;
331 win32_thread_info
*th
= inferior_target_data (thread
);
333 if ((thread_id
== -1 || thread_id
== th
->tid
)
336 if (th
->context
.ContextFlags
)
338 win32_set_thread_context (th
);
339 th
->context
.ContextFlags
= 0;
342 if (ResumeThread (th
->h
) == (DWORD
) -1)
344 DWORD err
= GetLastError ();
345 OUTMSG (("warning: ResumeThread failed in continue_one_thread, "
346 "(error %d): %s\n", (int) err
, strwinerror (err
)));
355 child_continue (DWORD continue_status
, int thread_id
)
357 /* The inferior will only continue after the ContinueDebugEvent
359 find_inferior (&all_threads
, continue_one_thread
, &thread_id
);
360 faked_breakpoint
= 0;
362 if (!ContinueDebugEvent (current_event
.dwProcessId
,
363 current_event
.dwThreadId
,
370 /* Fetch register(s) from the current thread context. */
372 child_fetch_inferior_registers (int r
)
375 win32_thread_info
*th
= thread_rec (current_inferior_ptid (), TRUE
);
376 if (r
== -1 || r
> NUM_REGS
)
377 child_fetch_inferior_registers (NUM_REGS
);
379 for (regno
= 0; regno
< r
; regno
++)
380 (*the_low_target
.fetch_inferior_register
) (th
, regno
);
383 /* Store a new register value into the current thread context. We don't
384 change the program's context until later, when we resume it. */
386 child_store_inferior_registers (int r
)
389 win32_thread_info
*th
= thread_rec (current_inferior_ptid (), TRUE
);
390 if (r
== -1 || r
== 0 || r
> NUM_REGS
)
391 child_store_inferior_registers (NUM_REGS
);
393 for (regno
= 0; regno
< r
; regno
++)
394 (*the_low_target
.store_inferior_register
) (th
, regno
);
397 /* Map the Windows error number in ERROR to a locale-dependent error
398 message string and return a pointer to it. Typically, the values
399 for ERROR come from GetLastError.
401 The string pointed to shall not be modified by the application,
402 but may be overwritten by a subsequent call to strwinerror
404 The strwinerror function does not change the current setting
408 strwinerror (DWORD error
)
410 static char buf
[1024];
412 DWORD lasterr
= GetLastError ();
413 DWORD chars
= FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
414 | FORMAT_MESSAGE_ALLOCATE_BUFFER
,
417 0, /* Default language */
423 /* If there is an \r\n appended, zap it. */
425 && msgbuf
[chars
- 2] == '\r'
426 && msgbuf
[chars
- 1] == '\n')
432 if (chars
> ((COUNTOF (buf
)) - 1))
434 chars
= COUNTOF (buf
) - 1;
439 wcstombs (buf
, msgbuf
, chars
+ 1);
441 strncpy (buf
, msgbuf
, chars
+ 1);
446 sprintf (buf
, "unknown win32 error (%ld)", error
);
448 SetLastError (lasterr
);
453 create_process (const char *program
, char *args
,
454 DWORD flags
, PROCESS_INFORMATION
*pi
)
459 wchar_t *p
, *wprogram
, *wargs
;
462 wprogram
= alloca ((strlen (program
) + 1) * sizeof (wchar_t));
463 mbstowcs (wprogram
, program
, strlen (program
) + 1);
465 for (p
= wprogram
; *p
; ++p
)
469 argslen
= strlen (args
);
470 wargs
= alloca ((argslen
+ 1) * sizeof (wchar_t));
471 mbstowcs (wargs
, args
, argslen
+ 1);
473 ret
= CreateProcessW (wprogram
, /* image name */
474 wargs
, /* command line */
475 NULL
, /* security, not supported */
476 NULL
, /* thread, not supported */
477 FALSE
, /* inherit handles, not supported */
478 flags
, /* start flags */
479 NULL
, /* environment, not supported */
480 NULL
, /* current directory, not supported */
481 NULL
, /* start info, not supported */
484 STARTUPINFOA si
= { sizeof (STARTUPINFOA
) };
486 ret
= CreateProcessA (program
, /* image name */
487 args
, /* command line */
490 TRUE
, /* inherit handles */
491 flags
, /* start flags */
492 NULL
, /* environment */
493 NULL
, /* current directory */
494 &si
, /* start info */
501 /* Start a new process.
502 PROGRAM is a path to the program to execute.
503 ARGS is a standard NULL-terminated array of arguments,
504 to be passed to the inferior as ``argv''.
505 Returns the new PID on success, -1 on failure. Registers the new
506 process with the process list. */
508 win32_create_inferior (char *program
, char **program_args
)
511 char real_path
[MAXPATHLEN
];
512 char *orig_path
, *new_path
, *path_ptr
;
519 PROCESS_INFORMATION pi
;
522 /* win32_wait needs to know we're not attaching. */
526 error ("No executable specified, specify executable to debug.\n");
528 flags
= DEBUG_PROCESS
| DEBUG_ONLY_THIS_PROCESS
;
532 path_ptr
= getenv ("PATH");
535 orig_path
= alloca (strlen (path_ptr
) + 1);
536 new_path
= alloca (cygwin_posix_to_win32_path_list_buf_size (path_ptr
));
537 strcpy (orig_path
, path_ptr
);
538 cygwin_posix_to_win32_path_list (path_ptr
, new_path
);
539 setenv ("PATH", new_path
, 1);
541 cygwin_conv_to_win32_path (program
, real_path
);
546 for (argc
= 1; program_args
[argc
]; argc
++)
547 argslen
+= strlen (program_args
[argc
]) + 1;
548 args
= alloca (argslen
);
550 for (argc
= 1; program_args
[argc
]; argc
++)
552 /* FIXME: Can we do better about quoting? How does Cygwin
555 strcat (args
, program_args
[argc
]);
557 OUTMSG2 (("Command line is \"%s\"\n", args
));
559 #ifdef CREATE_NEW_PROCESS_GROUP
560 flags
|= CREATE_NEW_PROCESS_GROUP
;
563 ret
= create_process (program
, args
, flags
, &pi
);
564 err
= GetLastError ();
565 if (!ret
&& err
== ERROR_FILE_NOT_FOUND
)
567 char *exename
= alloca (strlen (program
) + 5);
568 strcat (strcpy (exename
, program
), ".exe");
569 ret
= create_process (exename
, args
, flags
, &pi
);
570 err
= GetLastError ();
575 setenv ("PATH", orig_path
, 1);
580 error ("Error creating process \"%s%s\", (error %d): %s\n",
581 program
, args
, (int) err
, strwinerror (err
));
585 OUTMSG2 (("Process created: %s\n", (char *) args
));
589 /* On Windows CE this handle can't be closed. The OS reuses
590 it in the debug events, while the 9x/NT versions of Windows
591 probably use a DuplicateHandle'd one. */
592 CloseHandle (pi
.hThread
);
595 do_initial_child_stuff (pi
.hProcess
, pi
.dwProcessId
, 0);
597 return current_process_id
;
600 /* Attach to a running process.
601 PID is the process ID to attach to, specified by the user
602 or a higher layer. */
604 win32_attach (unsigned long pid
)
607 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
610 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
612 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
614 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
616 h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
619 if (DebugActiveProcess (pid
))
621 if (DebugSetProcessKillOnExit
!= NULL
)
622 DebugSetProcessKillOnExit (FALSE
);
624 /* win32_wait needs to know we're attaching. */
626 do_initial_child_stuff (h
, pid
, 1);
633 err
= GetLastError ();
634 error ("Attach to process failed (error %d): %s\n",
635 (int) err
, strwinerror (err
));
638 /* Handle OUTPUT_DEBUG_STRING_EVENT from child process. */
640 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
642 #define READ_BUFFER_LEN 1024
644 char s
[READ_BUFFER_LEN
+ 1] = { 0 };
645 DWORD nbytes
= current_event
.u
.DebugString
.nDebugStringLength
;
650 if (nbytes
> READ_BUFFER_LEN
)
651 nbytes
= READ_BUFFER_LEN
;
653 addr
= (CORE_ADDR
) (size_t) current_event
.u
.DebugString
.lpDebugStringData
;
655 if (current_event
.u
.DebugString
.fUnicode
)
657 /* The event tells us how many bytes, not chars, even
659 WCHAR buffer
[(READ_BUFFER_LEN
+ 1) / sizeof (WCHAR
)] = { 0 };
660 if (read_inferior_memory (addr
, (unsigned char *) buffer
, nbytes
) != 0)
662 wcstombs (s
, buffer
, (nbytes
+ 1) / sizeof (WCHAR
));
666 if (read_inferior_memory (addr
, (unsigned char *) s
, nbytes
) != 0)
670 if (strncmp (s
, "cYg", 3) != 0)
680 #undef READ_BUFFER_LEN
684 win32_clear_inferiors (void)
686 if (current_process_handle
!= NULL
)
687 CloseHandle (current_process_handle
);
689 for_each_inferior (&all_threads
, delete_thread_info
);
693 /* Kill all inferiors. */
697 struct process_info
*process
;
699 if (current_process_handle
== NULL
)
702 TerminateProcess (current_process_handle
, 0);
705 if (!child_continue (DBG_CONTINUE
, -1))
707 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
709 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
711 else if (current_event
.dwDebugEventCode
== OUTPUT_DEBUG_STRING_EVENT
)
713 struct target_waitstatus our_status
= { 0 };
714 handle_output_debug_string (&our_status
);
718 win32_clear_inferiors ();
720 process
= find_process_pid (pid
);
721 remove_process (process
);
725 /* Detach from inferior PID. */
727 win32_detach (int pid
)
729 struct process_info
*process
;
730 winapi_DebugActiveProcessStop DebugActiveProcessStop
= NULL
;
731 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit
= NULL
;
733 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
735 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
737 DebugActiveProcessStop
= GETPROCADDRESS (dll
, DebugActiveProcessStop
);
738 DebugSetProcessKillOnExit
= GETPROCADDRESS (dll
, DebugSetProcessKillOnExit
);
740 if (DebugSetProcessKillOnExit
== NULL
741 || DebugActiveProcessStop
== NULL
)
745 struct thread_resume resume
;
746 resume
.thread
= minus_one_ptid
;
747 resume
.kind
= resume_continue
;
749 win32_resume (&resume
, 1);
752 if (!DebugActiveProcessStop (current_process_id
))
755 DebugSetProcessKillOnExit (FALSE
);
756 process
= find_process_pid (pid
);
757 remove_process (process
);
759 win32_clear_inferiors ();
763 /* Wait for inferiors to end. */
767 HANDLE h
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, pid
);
770 WaitForSingleObject (h
, INFINITE
);
775 /* Return 1 iff the thread with thread ID TID is alive. */
777 win32_thread_alive (ptid_t ptid
)
781 /* Our thread list is reliable; don't bother to poll target
783 if (find_inferior_id (&all_threads
, ptid
) != NULL
)
790 /* Resume the inferior process. RESUME_INFO describes how we want
793 win32_resume (struct thread_resume
*resume_info
, size_t n
)
796 enum target_signal sig
;
798 win32_thread_info
*th
;
799 DWORD continue_status
= DBG_CONTINUE
;
802 /* This handles the very limited set of resume packets that GDB can
803 currently produce. */
805 if (n
== 1 && ptid_equal (resume_info
[0].thread
, minus_one_ptid
))
810 /* Yes, we're ignoring resume_info[0].thread. It'd be tricky to make
811 the Windows resume code do the right thing for thread switching. */
812 tid
= current_event
.dwThreadId
;
814 if (!ptid_equal (resume_info
[0].thread
, minus_one_ptid
))
816 sig
= resume_info
[0].sig
;
817 step
= resume_info
[0].kind
== resume_step
;
825 if (sig
!= TARGET_SIGNAL_0
)
827 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
829 OUTMSG (("Cannot continue with signal %d here.\n", sig
));
831 else if (sig
== last_sig
)
832 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
834 OUTMSG (("Can only continue with recieved signal %d.\n", last_sig
));
837 last_sig
= TARGET_SIGNAL_0
;
839 /* Get context for the currently selected thread. */
840 ptid
= debug_event_ptid (¤t_event
);
841 th
= thread_rec (ptid
, FALSE
);
844 if (th
->context
.ContextFlags
)
846 /* Move register values from the inferior into the thread
847 context structure. */
848 regcache_invalidate ();
852 if (the_low_target
.single_step
!= NULL
)
853 (*the_low_target
.single_step
) (th
);
855 error ("Single stepping is not supported "
856 "in this configuration.\n");
859 win32_set_thread_context (th
);
860 th
->context
.ContextFlags
= 0;
864 /* Allow continuing with the same signal that interrupted us.
865 Otherwise complain. */
867 child_continue (continue_status
, tid
);
871 win32_add_one_solib (const char *name
, CORE_ADDR load_addr
)
873 char buf
[MAX_PATH
+ 1];
874 char buf2
[MAX_PATH
+ 1];
877 WIN32_FIND_DATA w32_fd
;
878 WCHAR wname
[MAX_PATH
+ 1];
879 mbstowcs (wname
, name
, MAX_PATH
);
880 HANDLE h
= FindFirstFile (wname
, &w32_fd
);
882 WIN32_FIND_DATAA w32_fd
;
883 HANDLE h
= FindFirstFileA (name
, &w32_fd
);
886 if (h
== INVALID_HANDLE_VALUE
)
894 char cwd
[MAX_PATH
+ 1];
896 if (GetCurrentDirectoryA (MAX_PATH
+ 1, cwd
))
898 p
= strrchr (buf
, '\\');
901 SetCurrentDirectoryA (buf
);
902 GetFullPathNameA (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
903 SetCurrentDirectoryA (cwd
);
910 if (strcasecmp (buf
, "ntdll.dll") == 0)
912 GetSystemDirectoryA (buf
, sizeof (buf
));
913 strcat (buf
, "\\ntdll.dll");
918 cygwin_conv_to_posix_path (buf
, buf2
);
923 loaded_dll (buf2
, load_addr
);
927 get_image_name (HANDLE h
, void *address
, int unicode
)
929 static char buf
[(2 * MAX_PATH
) + 1];
930 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
936 /* Attempt to read the name of the dll that was detected.
937 This is documented to work only when actively debugging
938 a program. It will not work for attached processes. */
943 /* Windows CE reports the address of the image name,
944 instead of an address of a pointer into the image name. */
945 address_ptr
= address
;
947 /* See if we could read the address of a string, and that the
948 address isn't null. */
949 if (!ReadProcessMemory (h
, address
, &address_ptr
,
950 sizeof (address_ptr
), &done
)
951 || done
!= sizeof (address_ptr
)
956 /* Find the length of the string */
957 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
958 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
962 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
965 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
966 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
969 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
975 typedef BOOL (WINAPI
*winapi_EnumProcessModules
) (HANDLE
, HMODULE
*,
977 typedef BOOL (WINAPI
*winapi_GetModuleInformation
) (HANDLE
, HMODULE
,
978 LPMODULEINFO
, DWORD
);
979 typedef DWORD (WINAPI
*winapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
,
982 static winapi_EnumProcessModules win32_EnumProcessModules
;
983 static winapi_GetModuleInformation win32_GetModuleInformation
;
984 static winapi_GetModuleFileNameExA win32_GetModuleFileNameExA
;
989 static int psapi_loaded
= 0;
990 static HMODULE dll
= NULL
;
995 dll
= LoadLibrary (TEXT("psapi.dll"));
998 win32_EnumProcessModules
=
999 GETPROCADDRESS (dll
, EnumProcessModules
);
1000 win32_GetModuleInformation
=
1001 GETPROCADDRESS (dll
, GetModuleInformation
);
1002 win32_GetModuleFileNameExA
=
1003 GETPROCADDRESS (dll
, GetModuleFileNameExA
);
1006 return (win32_EnumProcessModules
!= NULL
1007 && win32_GetModuleInformation
!= NULL
1008 && win32_GetModuleFileNameExA
!= NULL
);
1012 psapi_get_dll_name (DWORD BaseAddress
, char *dll_name_ret
)
1018 HMODULE
*DllHandle
= dh_buf
;
1026 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
1031 if (!ok
|| !cbNeeded
)
1034 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
1038 ok
= (*win32_EnumProcessModules
) (current_process_handle
,
1045 for (i
= 0; i
< ((size_t) cbNeeded
/ sizeof (HMODULE
)); i
++)
1047 if (!(*win32_GetModuleInformation
) (current_process_handle
,
1052 DWORD err
= GetLastError ();
1053 error ("Can't get module info: (error %d): %s\n",
1054 (int) err
, strwinerror (err
));
1057 if ((DWORD
) (mi
.lpBaseOfDll
) == BaseAddress
)
1059 len
= (*win32_GetModuleFileNameExA
) (current_process_handle
,
1065 DWORD err
= GetLastError ();
1066 error ("Error getting dll name: (error %d): %s\n",
1067 (int) err
, strwinerror (err
));
1074 dll_name_ret
[0] = '\0';
1078 typedef HANDLE (WINAPI
*winapi_CreateToolhelp32Snapshot
) (DWORD
, DWORD
);
1079 typedef BOOL (WINAPI
*winapi_Module32First
) (HANDLE
, LPMODULEENTRY32
);
1080 typedef BOOL (WINAPI
*winapi_Module32Next
) (HANDLE
, LPMODULEENTRY32
);
1082 static winapi_CreateToolhelp32Snapshot win32_CreateToolhelp32Snapshot
;
1083 static winapi_Module32First win32_Module32First
;
1084 static winapi_Module32Next win32_Module32Next
;
1086 typedef BOOL (WINAPI
*winapi_CloseToolhelp32Snapshot
) (HANDLE
);
1087 static winapi_CloseToolhelp32Snapshot win32_CloseToolhelp32Snapshot
;
1091 load_toolhelp (void)
1093 static int toolhelp_loaded
= 0;
1094 static HMODULE dll
= NULL
;
1096 if (!toolhelp_loaded
)
1098 toolhelp_loaded
= 1;
1100 dll
= GetModuleHandle (_T("KERNEL32.DLL"));
1102 dll
= LoadLibrary (L
"TOOLHELP.DLL");
1107 win32_CreateToolhelp32Snapshot
=
1108 GETPROCADDRESS (dll
, CreateToolhelp32Snapshot
);
1109 win32_Module32First
= GETPROCADDRESS (dll
, Module32First
);
1110 win32_Module32Next
= GETPROCADDRESS (dll
, Module32Next
);
1112 win32_CloseToolhelp32Snapshot
=
1113 GETPROCADDRESS (dll
, CloseToolhelp32Snapshot
);
1117 return (win32_CreateToolhelp32Snapshot
!= NULL
1118 && win32_Module32First
!= NULL
1119 && win32_Module32Next
!= NULL
1121 && win32_CloseToolhelp32Snapshot
!= NULL
1127 toolhelp_get_dll_name (DWORD BaseAddress
, char *dll_name_ret
)
1129 HANDLE snapshot_module
;
1130 MODULEENTRY32 modEntry
= { sizeof (MODULEENTRY32
) };
1133 if (!load_toolhelp ())
1136 snapshot_module
= win32_CreateToolhelp32Snapshot (TH32CS_SNAPMODULE
,
1137 current_event
.dwProcessId
);
1138 if (snapshot_module
== INVALID_HANDLE_VALUE
)
1141 /* Ignore the first module, which is the exe. */
1142 if (win32_Module32First (snapshot_module
, &modEntry
))
1143 while (win32_Module32Next (snapshot_module
, &modEntry
))
1144 if ((DWORD
) modEntry
.modBaseAddr
== BaseAddress
)
1147 wcstombs (dll_name_ret
, modEntry
.szExePath
, MAX_PATH
+ 1);
1149 strcpy (dll_name_ret
, modEntry
.szExePath
);
1156 win32_CloseToolhelp32Snapshot (snapshot_module
);
1158 CloseHandle (snapshot_module
);
1164 handle_load_dll (void)
1166 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
1167 char dll_buf
[MAX_PATH
+ 1];
1168 char *dll_name
= NULL
;
1171 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
1173 /* Windows does not report the image name of the dlls in the debug
1174 event on attaches. We resort to iterating over the list of
1175 loaded dlls looking for a match by image base. */
1176 if (!psapi_get_dll_name ((DWORD
) event
->lpBaseOfDll
, dll_buf
))
1178 if (!server_waiting
)
1179 /* On some versions of Windows and Windows CE, we can't create
1180 toolhelp snapshots while the inferior is stopped in a
1181 LOAD_DLL_DEBUG_EVENT due to a dll load, but we can while
1182 Windows is reporting the already loaded dlls. */
1183 toolhelp_get_dll_name ((DWORD
) event
->lpBaseOfDll
, dll_buf
);
1188 if (*dll_name
== '\0')
1189 dll_name
= get_image_name (current_process_handle
,
1190 event
->lpImageName
, event
->fUnicode
);
1194 /* The symbols in a dll are offset by 0x1000, which is the
1195 the offset from 0 of the first byte in an image - because
1196 of the file header and the section alignment. */
1198 load_addr
= (DWORD
) event
->lpBaseOfDll
+ 0x1000;
1199 win32_add_one_solib (dll_name
, load_addr
);
1203 handle_unload_dll (void)
1205 CORE_ADDR load_addr
=
1206 (CORE_ADDR
) (DWORD
) current_event
.u
.UnloadDll
.lpBaseOfDll
;
1207 load_addr
+= 0x1000;
1208 unloaded_dll (NULL
, load_addr
);
1212 handle_exception (struct target_waitstatus
*ourstatus
)
1214 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1216 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1220 case EXCEPTION_ACCESS_VIOLATION
:
1221 OUTMSG2 (("EXCEPTION_ACCESS_VIOLATION"));
1222 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1224 case STATUS_STACK_OVERFLOW
:
1225 OUTMSG2 (("STATUS_STACK_OVERFLOW"));
1226 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1228 case STATUS_FLOAT_DENORMAL_OPERAND
:
1229 OUTMSG2 (("STATUS_FLOAT_DENORMAL_OPERAND"));
1230 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1232 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1233 OUTMSG2 (("EXCEPTION_ARRAY_BOUNDS_EXCEEDED"));
1234 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1236 case STATUS_FLOAT_INEXACT_RESULT
:
1237 OUTMSG2 (("STATUS_FLOAT_INEXACT_RESULT"));
1238 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1240 case STATUS_FLOAT_INVALID_OPERATION
:
1241 OUTMSG2 (("STATUS_FLOAT_INVALID_OPERATION"));
1242 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1244 case STATUS_FLOAT_OVERFLOW
:
1245 OUTMSG2 (("STATUS_FLOAT_OVERFLOW"));
1246 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1248 case STATUS_FLOAT_STACK_CHECK
:
1249 OUTMSG2 (("STATUS_FLOAT_STACK_CHECK"));
1250 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1252 case STATUS_FLOAT_UNDERFLOW
:
1253 OUTMSG2 (("STATUS_FLOAT_UNDERFLOW"));
1254 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1256 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1257 OUTMSG2 (("STATUS_FLOAT_DIVIDE_BY_ZERO"));
1258 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1260 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1261 OUTMSG2 (("STATUS_INTEGER_DIVIDE_BY_ZERO"));
1262 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1264 case STATUS_INTEGER_OVERFLOW
:
1265 OUTMSG2 (("STATUS_INTEGER_OVERFLOW"));
1266 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1268 case EXCEPTION_BREAKPOINT
:
1269 OUTMSG2 (("EXCEPTION_BREAKPOINT"));
1270 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1272 /* Remove the initial breakpoint. */
1273 check_breakpoints ((CORE_ADDR
) (long) current_event
1274 .u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1278 OUTMSG2 (("DBG_CONTROL_C"));
1279 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1281 case DBG_CONTROL_BREAK
:
1282 OUTMSG2 (("DBG_CONTROL_BREAK"));
1283 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1285 case EXCEPTION_SINGLE_STEP
:
1286 OUTMSG2 (("EXCEPTION_SINGLE_STEP"));
1287 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1289 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1290 OUTMSG2 (("EXCEPTION_ILLEGAL_INSTRUCTION"));
1291 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1293 case EXCEPTION_PRIV_INSTRUCTION
:
1294 OUTMSG2 (("EXCEPTION_PRIV_INSTRUCTION"));
1295 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1297 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1298 OUTMSG2 (("EXCEPTION_NONCONTINUABLE_EXCEPTION"));
1299 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1302 if (current_event
.u
.Exception
.dwFirstChance
)
1304 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1307 OUTMSG2 (("gdbserver: unknown target exception 0x%08lx at 0x%08lx",
1308 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1309 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.
1311 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1315 last_sig
= ourstatus
->value
.sig
;
1320 suspend_one_thread (struct inferior_list_entry
*entry
)
1322 struct thread_info
*thread
= (struct thread_info
*) entry
;
1323 win32_thread_info
*th
= inferior_target_data (thread
);
1327 if (SuspendThread (th
->h
) == (DWORD
) -1)
1329 DWORD err
= GetLastError ();
1330 OUTMSG (("warning: SuspendThread failed in suspend_one_thread, "
1331 "(error %d): %s\n", (int) err
, strwinerror (err
)));
1339 fake_breakpoint_event (void)
1341 OUTMSG2(("fake_breakpoint_event\n"));
1343 faked_breakpoint
= 1;
1345 memset (¤t_event
, 0, sizeof (current_event
));
1346 current_event
.dwThreadId
= main_thread_id
;
1347 current_event
.dwDebugEventCode
= EXCEPTION_DEBUG_EVENT
;
1348 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1349 = EXCEPTION_BREAKPOINT
;
1351 for_each_inferior (&all_threads
, suspend_one_thread
);
1356 auto_delete_breakpoint (CORE_ADDR stop_pc
)
1362 /* Get the next event from the child. */
1365 get_child_debug_event (struct target_waitstatus
*ourstatus
)
1369 last_sig
= TARGET_SIGNAL_0
;
1370 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1372 /* Check if GDB sent us an interrupt request. */
1373 check_remote_input_interrupt_request ();
1375 if (soft_interrupt_requested
)
1377 soft_interrupt_requested
= 0;
1378 fake_breakpoint_event ();
1387 /* WinCE doesn't set an initial breakpoint automatically. To
1388 stop the inferior, we flush all currently pending debug
1389 events -- the thread list and the dll list are always
1390 reported immediatelly without delay, then, we suspend all
1391 threads and pretend we saw a trap at the current PC of the
1394 Contrary to desktop Windows, Windows CE *does* report the dll
1395 names on LOAD_DLL_DEBUG_EVENTs resulting from a
1396 DebugActiveProcess call. This limits the way we can detect
1397 if all the dlls have already been reported. If we get a real
1398 debug event before leaving attaching, the worst that will
1399 happen is the user will see a spurious breakpoint. */
1401 current_event
.dwDebugEventCode
= 0;
1402 if (!WaitForDebugEvent (¤t_event
, 0))
1404 OUTMSG2(("no attach events left\n"));
1405 fake_breakpoint_event ();
1409 OUTMSG2(("got attach event\n"));
1414 /* Keep the wait time low enough for confortable remote
1415 interruption, but high enough so gdbserver doesn't become a
1417 if (!WaitForDebugEvent (¤t_event
, 250))
1419 DWORD e
= GetLastError();
1421 if (e
== ERROR_PIPE_NOT_CONNECTED
)
1423 /* This will happen if the loader fails to succesfully
1424 load the application, e.g., if the main executable
1425 tries to pull in a non-existing export from a
1427 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1428 ourstatus
->value
.integer
= 1;
1438 ptid
= debug_event_ptid (¤t_event
);
1440 (struct thread_info
*) find_inferior_id (&all_threads
, ptid
);
1442 switch (current_event
.dwDebugEventCode
)
1444 case CREATE_THREAD_DEBUG_EVENT
:
1445 OUTMSG2 (("gdbserver: kernel event CREATE_THREAD_DEBUG_EVENT "
1446 "for pid=%d tid=%x)\n",
1447 (unsigned) current_event
.dwProcessId
,
1448 (unsigned) current_event
.dwThreadId
));
1450 /* Record the existence of this thread. */
1451 child_add_thread (current_event
.dwProcessId
,
1452 current_event
.dwThreadId
,
1453 current_event
.u
.CreateThread
.hThread
);
1456 case EXIT_THREAD_DEBUG_EVENT
:
1457 OUTMSG2 (("gdbserver: kernel event EXIT_THREAD_DEBUG_EVENT "
1458 "for pid=%d tid=%x\n",
1459 (unsigned) current_event
.dwProcessId
,
1460 (unsigned) current_event
.dwThreadId
));
1461 child_delete_thread (current_event
.dwProcessId
,
1462 current_event
.dwThreadId
);
1465 case CREATE_PROCESS_DEBUG_EVENT
:
1466 OUTMSG2 (("gdbserver: kernel event CREATE_PROCESS_DEBUG_EVENT "
1467 "for pid=%d tid=%x\n",
1468 (unsigned) current_event
.dwProcessId
,
1469 (unsigned) current_event
.dwThreadId
));
1470 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1472 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1473 main_thread_id
= current_event
.dwThreadId
;
1475 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
1476 ourstatus
->value
.execd_pathname
= "Main executable";
1478 /* Add the main thread. */
1479 child_add_thread (current_event
.dwProcessId
,
1481 current_event
.u
.CreateProcessInfo
.hThread
);
1483 ourstatus
->value
.related_pid
= debug_event_ptid (¤t_event
);
1487 /* Windows CE doesn't set the initial breakpoint
1488 automatically like the desktop versions of Windows do.
1489 We add it explicitly here. It will be removed as soon as
1491 set_breakpoint_at ((CORE_ADDR
) (long) current_event
.u
1492 .CreateProcessInfo
.lpStartAddress
,
1493 auto_delete_breakpoint
);
1498 case EXIT_PROCESS_DEBUG_EVENT
:
1499 OUTMSG2 (("gdbserver: kernel event EXIT_PROCESS_DEBUG_EVENT "
1500 "for pid=%d tid=%x\n",
1501 (unsigned) current_event
.dwProcessId
,
1502 (unsigned) current_event
.dwThreadId
));
1503 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1504 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1505 child_continue (DBG_CONTINUE
, -1);
1506 CloseHandle (current_process_handle
);
1507 current_process_handle
= NULL
;
1510 case LOAD_DLL_DEBUG_EVENT
:
1511 OUTMSG2 (("gdbserver: kernel event LOAD_DLL_DEBUG_EVENT "
1512 "for pid=%d tid=%x\n",
1513 (unsigned) current_event
.dwProcessId
,
1514 (unsigned) current_event
.dwThreadId
));
1515 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1518 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1519 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1522 case UNLOAD_DLL_DEBUG_EVENT
:
1523 OUTMSG2 (("gdbserver: kernel event UNLOAD_DLL_DEBUG_EVENT "
1524 "for pid=%d tid=%x\n",
1525 (unsigned) current_event
.dwProcessId
,
1526 (unsigned) current_event
.dwThreadId
));
1527 handle_unload_dll ();
1528 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1529 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1532 case EXCEPTION_DEBUG_EVENT
:
1533 OUTMSG2 (("gdbserver: kernel event EXCEPTION_DEBUG_EVENT "
1534 "for pid=%d tid=%x\n",
1535 (unsigned) current_event
.dwProcessId
,
1536 (unsigned) current_event
.dwThreadId
));
1537 handle_exception (ourstatus
);
1540 case OUTPUT_DEBUG_STRING_EVENT
:
1541 /* A message from the kernel (or Cygwin). */
1542 OUTMSG2 (("gdbserver: kernel event OUTPUT_DEBUG_STRING_EVENT "
1543 "for pid=%d tid=%x\n",
1544 (unsigned) current_event
.dwProcessId
,
1545 (unsigned) current_event
.dwThreadId
));
1546 handle_output_debug_string (ourstatus
);
1550 OUTMSG2 (("gdbserver: kernel event unknown "
1551 "for pid=%d tid=%x code=%ld\n",
1552 (unsigned) current_event
.dwProcessId
,
1553 (unsigned) current_event
.dwThreadId
,
1554 current_event
.dwDebugEventCode
));
1559 (struct thread_info
*) find_inferior_id (&all_threads
, ptid
);
1563 /* Wait for the inferior process to change state.
1564 STATUS will be filled in with a response code to send to GDB.
1565 Returns the signal which caused the process to stop. */
1567 win32_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
1569 struct process_info
*process
;
1573 if (!get_child_debug_event (ourstatus
))
1576 switch (ourstatus
->kind
)
1578 case TARGET_WAITKIND_EXITED
:
1579 OUTMSG2 (("Child exited with retcode = %x\n",
1580 ourstatus
->value
.integer
));
1582 process
= find_process_pid (current_process_id
);
1583 remove_process (process
);
1584 win32_clear_inferiors ();
1585 return pid_to_ptid (current_event
.dwProcessId
);
1586 case TARGET_WAITKIND_STOPPED
:
1587 case TARGET_WAITKIND_LOADED
:
1588 OUTMSG2 (("Child Stopped with signal = %d \n",
1589 our_status
.value
.sig
));
1591 child_fetch_inferior_registers (-1);
1593 if (ourstatus
->kind
== TARGET_WAITKIND_LOADED
1596 /* When gdb connects, we want to be stopped at the
1597 initial breakpoint, not in some dll load event. */
1598 child_continue (DBG_CONTINUE
, -1);
1602 /* We don't expose _LOADED events to gdbserver core. See
1603 the `dlls_changed' global. */
1604 if (ourstatus
->kind
== TARGET_WAITKIND_LOADED
)
1605 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1607 return debug_event_ptid (¤t_event
);
1609 OUTMSG (("Ignoring unknown internal event, %d\n", ourstatus
->kind
));
1611 case TARGET_WAITKIND_SPURIOUS
:
1612 case TARGET_WAITKIND_EXECD
:
1613 /* do nothing, just continue */
1614 child_continue (DBG_CONTINUE
, -1);
1620 /* Fetch registers from the inferior process.
1621 If REGNO is -1, fetch all registers; otherwise, fetch at least REGNO. */
1623 win32_fetch_inferior_registers (int regno
)
1625 child_fetch_inferior_registers (regno
);
1628 /* Store registers to the inferior process.
1629 If REGNO is -1, store all registers; otherwise, store at least REGNO. */
1631 win32_store_inferior_registers (int regno
)
1633 child_store_inferior_registers (regno
);
1636 /* Read memory from the inferior process. This should generally be
1637 called through read_inferior_memory, which handles breakpoint shadowing.
1638 Read LEN bytes at MEMADDR into a buffer at MYADDR. */
1640 win32_read_inferior_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
1642 return child_xfer_memory (memaddr
, (char *) myaddr
, len
, 0, 0) != len
;
1645 /* Write memory to the inferior process. This should generally be
1646 called through write_inferior_memory, which handles breakpoint shadowing.
1647 Write LEN bytes from the buffer at MYADDR to MEMADDR.
1648 Returns 0 on success and errno on failure. */
1650 win32_write_inferior_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
,
1653 return child_xfer_memory (memaddr
, (char *) myaddr
, len
, 1, 0) != len
;
1656 /* Send an interrupt request to the inferior process. */
1658 win32_request_interrupt (void)
1660 winapi_DebugBreakProcess DebugBreakProcess
;
1661 winapi_GenerateConsoleCtrlEvent GenerateConsoleCtrlEvent
;
1664 HMODULE dll
= GetModuleHandle (_T("COREDLL.DLL"));
1666 HMODULE dll
= GetModuleHandle (_T("KERNEL32.DLL"));
1669 GenerateConsoleCtrlEvent
= GETPROCADDRESS (dll
, GenerateConsoleCtrlEvent
);
1671 if (GenerateConsoleCtrlEvent
!= NULL
1672 && GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, current_process_id
))
1675 /* GenerateConsoleCtrlEvent can fail if process id being debugged is
1676 not a process group id.
1677 Fallback to XP/Vista 'DebugBreakProcess', which generates a
1678 breakpoint exception in the interior process. */
1680 DebugBreakProcess
= GETPROCADDRESS (dll
, DebugBreakProcess
);
1682 if (DebugBreakProcess
!= NULL
1683 && DebugBreakProcess (current_process_handle
))
1686 /* Last resort, suspend all threads manually. */
1687 soft_interrupt_requested
= 1;
1692 win32_error_to_fileio_error (DWORD err
)
1696 case ERROR_BAD_PATHNAME
:
1697 case ERROR_FILE_NOT_FOUND
:
1698 case ERROR_INVALID_NAME
:
1699 case ERROR_PATH_NOT_FOUND
:
1700 return FILEIO_ENOENT
;
1702 case ERROR_IO_DEVICE
:
1703 case ERROR_OPEN_FAILED
:
1705 case ERROR_INVALID_HANDLE
:
1706 return FILEIO_EBADF
;
1707 case ERROR_ACCESS_DENIED
:
1708 case ERROR_SHARING_VIOLATION
:
1709 return FILEIO_EACCES
;
1710 case ERROR_NOACCESS
:
1711 return FILEIO_EFAULT
;
1713 return FILEIO_EBUSY
;
1714 case ERROR_ALREADY_EXISTS
:
1715 case ERROR_FILE_EXISTS
:
1716 return FILEIO_EEXIST
;
1717 case ERROR_BAD_DEVICE
:
1718 return FILEIO_ENODEV
;
1719 case ERROR_DIRECTORY
:
1720 return FILEIO_ENOTDIR
;
1721 case ERROR_FILENAME_EXCED_RANGE
:
1722 case ERROR_INVALID_DATA
:
1723 case ERROR_INVALID_PARAMETER
:
1724 case ERROR_NEGATIVE_SEEK
:
1725 return FILEIO_EINVAL
;
1726 case ERROR_TOO_MANY_OPEN_FILES
:
1727 return FILEIO_EMFILE
;
1728 case ERROR_HANDLE_DISK_FULL
:
1729 case ERROR_DISK_FULL
:
1730 return FILEIO_ENOSPC
;
1731 case ERROR_WRITE_PROTECT
:
1732 return FILEIO_EROFS
;
1733 case ERROR_NOT_SUPPORTED
:
1734 return FILEIO_ENOSYS
;
1737 return FILEIO_EUNKNOWN
;
1741 wince_hostio_last_error (char *buf
)
1743 DWORD winerr
= GetLastError ();
1744 int fileio_err
= win32_error_to_fileio_error (winerr
);
1745 sprintf (buf
, "F-1,%x", fileio_err
);
1749 static struct target_ops win32_target_ops
= {
1750 win32_create_inferior
,
1758 win32_fetch_inferior_registers
,
1759 win32_store_inferior_registers
,
1760 win32_read_inferior_memory
,
1761 win32_write_inferior_memory
,
1763 win32_request_interrupt
,
1767 win32_stopped_by_watchpoint
,
1768 win32_stopped_data_address
,
1773 wince_hostio_last_error
,
1775 hostio_last_error_from_errno
,
1779 /* Initialize the Win32 backend. */
1781 initialize_low (void)
1783 set_target_ops (&win32_target_ops
);
1784 if (the_low_target
.breakpoint
!= NULL
)
1785 set_breakpoint_data (the_low_target
.breakpoint
,
1786 the_low_target
.breakpoint_len
);
1787 the_low_target
.arch_setup ();