projects / deliverable / binutils-gdb.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
[C++/mingw] ser-tcp.c casts
[deliverable/binutils-gdb.git] / gdb / gdbserver / win32-low.c
... / ...
CommitLineData
1/* Low level interface to Windows debugging, for gdbserver.
2 Copyright (C) 2006-2015 Free Software Foundation, Inc.
3
4 Contributed by Leo Zayas. Based on "win32-nat.c" from GDB.
5
6 This file is part of GDB.
7
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.
12
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.
17
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/>. */
20
21#include "server.h"
22#include "regcache.h"
23#include "gdb/fileio.h"
24#include "mem-break.h"
25#include "win32-low.h"
26#include "gdbthread.h"
27#include "dll.h"
28#include "hostio.h"
29#include <windows.h>
30#include <winnt.h>
31#include <imagehlp.h>
32#include <tlhelp32.h>
33#include <psapi.h>
34#include <process.h>
35
36#ifndef USE_WIN32API
37#include <sys/cygwin.h>
38#endif
39
40#define OUTMSG(X) do { printf X; fflush (stderr); } while (0)
41
42#define OUTMSG2(X) \
43 do \
44 { \
45 if (debug_threads) \
46 { \
47 printf X; \
48 fflush (stderr); \
49 } \
50 } while (0)
51
52#ifndef _T
53#define _T(x) TEXT (x)
54#endif
55
56#ifndef COUNTOF
57#define COUNTOF(STR) (sizeof (STR) / sizeof ((STR)[0]))
58#endif
59
60#ifdef _WIN32_WCE
61# define GETPROCADDRESS(DLL, PROC) \
62 ((winapi_ ## PROC) GetProcAddress (DLL, TEXT (#PROC)))
63#else
64# define GETPROCADDRESS(DLL, PROC) \
65 ((winapi_ ## PROC) GetProcAddress (DLL, #PROC))
66#endif
67
68int using_threads = 1;
69
70/* Globals. */
71static int attaching = 0;
72static HANDLE current_process_handle = NULL;
73static DWORD current_process_id = 0;
74static DWORD main_thread_id = 0;
75static enum gdb_signal last_sig = GDB_SIGNAL_0;
76
77/* The current debug event from WaitForDebugEvent. */
78static DEBUG_EVENT current_event;
79
80/* A status that hasn't been reported to the core yet, and so
81 win32_wait should return it next, instead of fetching the next
82 debug event off the win32 API. */
83static struct target_waitstatus cached_status;
84
85/* Non zero if an interrupt request is to be satisfied by suspending
86 all threads. */
87static int soft_interrupt_requested = 0;
88
89/* Non zero if the inferior is stopped in a simulated breakpoint done
90 by suspending all the threads. */
91static int faked_breakpoint = 0;
92
93const struct target_desc *win32_tdesc;
94
95#define NUM_REGS (the_low_target.num_regs)
96
97typedef BOOL (WINAPI *winapi_DebugActiveProcessStop) (DWORD dwProcessId);
98typedef BOOL (WINAPI *winapi_DebugSetProcessKillOnExit) (BOOL KillOnExit);
99typedef BOOL (WINAPI *winapi_DebugBreakProcess) (HANDLE);
100typedef BOOL (WINAPI *winapi_GenerateConsoleCtrlEvent) (DWORD, DWORD);
101
102static ptid_t win32_wait (ptid_t ptid, struct target_waitstatus *ourstatus,
103 int options);
104static void win32_resume (struct thread_resume *resume_info, size_t n);
105#ifndef _WIN32_WCE
106static void win32_add_all_dlls (void);
107#endif
108
109/* Get the thread ID from the current selected inferior (the current
110 thread). */
111static ptid_t
112current_thread_ptid (void)
113{
114 return current_ptid;
115}
116
117/* The current debug event from WaitForDebugEvent. */
118static ptid_t
119debug_event_ptid (DEBUG_EVENT *event)
120{
121 return ptid_build (event->dwProcessId, event->dwThreadId, 0);
122}
123
124/* Get the thread context of the thread associated with TH. */
125
126static void
127win32_get_thread_context (win32_thread_info *th)
128{
129 memset (&th->context, 0, sizeof (CONTEXT));
130 (*the_low_target.get_thread_context) (th);
131#ifdef _WIN32_WCE
132 memcpy (&th->base_context, &th->context, sizeof (CONTEXT));
133#endif
134}
135
136/* Set the thread context of the thread associated with TH. */
137
138static void
139win32_set_thread_context (win32_thread_info *th)
140{
141#ifdef _WIN32_WCE
142 /* Calling SuspendThread on a thread that is running kernel code
143 will report that the suspending was successful, but in fact, that
144 will often not be true. In those cases, the context returned by
145 GetThreadContext will not be correct by the time the thread
146 stops, hence we can't set that context back into the thread when
147 resuming - it will most likelly crash the inferior.
148 Unfortunately, there is no way to know when the thread will
149 really stop. To work around it, we'll only write the context
150 back to the thread when either the user or GDB explicitly change
151 it between stopping and resuming. */
152 if (memcmp (&th->context, &th->base_context, sizeof (CONTEXT)) != 0)
153#endif
154 SetThreadContext (th->h, &th->context);
155}
156
157/* Set the thread context of the thread associated with TH. */
158
159static void
160win32_prepare_to_resume (win32_thread_info *th)
161{
162 if (the_low_target.prepare_to_resume != NULL)
163 (*the_low_target.prepare_to_resume) (th);
164}
165
166/* See win32-low.h. */
167
168void
169win32_require_context (win32_thread_info *th)
170{
171 if (th->context.ContextFlags == 0)
172 {
173 if (!th->suspended)
174 {
175 if (SuspendThread (th->h) == (DWORD) -1)
176 {
177 DWORD err = GetLastError ();
178 OUTMSG (("warning: SuspendThread failed in thread_rec, "
179 "(error %d): %s\n", (int) err, strwinerror (err)));
180 }
181 else
182 th->suspended = 1;
183 }
184
185 win32_get_thread_context (th);
186 }
187}
188
189/* Find a thread record given a thread id. If GET_CONTEXT is set then
190 also retrieve the context for this thread. */
191static win32_thread_info *
192thread_rec (ptid_t ptid, int get_context)
193{
194 struct thread_info *thread;
195 win32_thread_info *th;
196
197 thread = (struct thread_info *) find_inferior_id (&all_threads, ptid);
198 if (thread == NULL)
199 return NULL;
200
201 th = (win32_thread_info *) inferior_target_data (thread);
202 if (get_context)
203 win32_require_context (th);
204 return th;
205}
206
207/* Add a thread to the thread list. */
208static win32_thread_info *
209child_add_thread (DWORD pid, DWORD tid, HANDLE h, void *tlb)
210{
211 win32_thread_info *th;
212 ptid_t ptid = ptid_build (pid, tid, 0);
213
214 if ((th = thread_rec (ptid, FALSE)))
215 return th;
216
217 th = XCNEW (win32_thread_info);
218 th->tid = tid;
219 th->h = h;
220 th->thread_local_base = (CORE_ADDR) (uintptr_t) tlb;
221
222 add_thread (ptid, th);
223
224 if (the_low_target.thread_added != NULL)
225 (*the_low_target.thread_added) (th);
226
227 return th;
228}
229
230/* Delete a thread from the list of threads. */
231static void
232delete_thread_info (struct inferior_list_entry *entry)
233{
234 struct thread_info *thread = (struct thread_info *) entry;
235 win32_thread_info *th = (win32_thread_info *) inferior_target_data (thread);
236
237 remove_thread (thread);
238 CloseHandle (th->h);
239 free (th);
240}
241
242/* Delete a thread from the list of threads. */
243static void
244child_delete_thread (DWORD pid, DWORD tid)
245{
246 struct inferior_list_entry *thread;
247 ptid_t ptid;
248
249 /* If the last thread is exiting, just return. */
250 if (one_inferior_p (&all_threads))
251 return;
252
253 ptid = ptid_build (pid, tid, 0);
254 thread = find_inferior_id (&all_threads, ptid);
255 if (thread == NULL)
256 return;
257
258 delete_thread_info (thread);
259}
260
261/* These watchpoint related wrapper functions simply pass on the function call
262 if the low target has registered a corresponding function. */
263
264static int
265win32_supports_z_point_type (char z_type)
266{
267 return (the_low_target.supports_z_point_type != NULL
268 && the_low_target.supports_z_point_type (z_type));
269}
270
271static int
272win32_insert_point (enum raw_bkpt_type type, CORE_ADDR addr,
273 int size, struct raw_breakpoint *bp)
274{
275 if (the_low_target.insert_point != NULL)
276 return the_low_target.insert_point (type, addr, size, bp);
277 else
278 /* Unsupported (see target.h). */
279 return 1;
280}
281
282static int
283win32_remove_point (enum raw_bkpt_type type, CORE_ADDR addr,
284 int size, struct raw_breakpoint *bp)
285{
286 if (the_low_target.remove_point != NULL)
287 return the_low_target.remove_point (type, addr, size, bp);
288 else
289 /* Unsupported (see target.h). */
290 return 1;
291}
292
293static int
294win32_stopped_by_watchpoint (void)
295{
296 if (the_low_target.stopped_by_watchpoint != NULL)
297 return the_low_target.stopped_by_watchpoint ();
298 else
299 return 0;
300}
301
302static CORE_ADDR
303win32_stopped_data_address (void)
304{
305 if (the_low_target.stopped_data_address != NULL)
306 return the_low_target.stopped_data_address ();
307 else
308 return 0;
309}
310
311
312/* Transfer memory from/to the debugged process. */
313static int
314child_xfer_memory (CORE_ADDR memaddr, char *our, int len,
315 int write, struct target_ops *target)
316{
317 BOOL success;
318 SIZE_T done = 0;
319 DWORD lasterror = 0;
320 uintptr_t addr = (uintptr_t) memaddr;
321
322 if (write)
323 {
324 success = WriteProcessMemory (current_process_handle, (LPVOID) addr,
325 (LPCVOID) our, len, &done);
326 if (!success)
327 lasterror = GetLastError ();
328 FlushInstructionCache (current_process_handle, (LPCVOID) addr, len);
329 }
330 else
331 {
332 success = ReadProcessMemory (current_process_handle, (LPCVOID) addr,
333 (LPVOID) our, len, &done);
334 if (!success)
335 lasterror = GetLastError ();
336 }
337 if (!success && lasterror == ERROR_PARTIAL_COPY && done > 0)
338 return done;
339 else
340 return success ? done : -1;
341}
342
343/* Clear out any old thread list and reinitialize it to a pristine
344 state. */
345static void
346child_init_thread_list (void)
347{
348 for_each_inferior (&all_threads, delete_thread_info);
349}
350
351/* Zero during the child initialization phase, and nonzero otherwise. */
352
353static int child_initialization_done = 0;
354
355static void
356do_initial_child_stuff (HANDLE proch, DWORD pid, int attached)
357{
358 struct process_info *proc;
359
360 last_sig = GDB_SIGNAL_0;
361
362 current_process_handle = proch;
363 current_process_id = pid;
364 main_thread_id = 0;
365
366 soft_interrupt_requested = 0;
367 faked_breakpoint = 0;
368
369 memset (&current_event, 0, sizeof (current_event));
370
371 proc = add_process (pid, attached);
372 proc->tdesc = win32_tdesc;
373 child_init_thread_list ();
374 child_initialization_done = 0;
375
376 if (the_low_target.initial_stuff != NULL)
377 (*the_low_target.initial_stuff) ();
378
379 cached_status.kind = TARGET_WAITKIND_IGNORE;
380
381 /* Flush all currently pending debug events (thread and dll list) up
382 to the initial breakpoint. */
383 while (1)
384 {
385 struct target_waitstatus status;
386
387 win32_wait (minus_one_ptid, &status, 0);
388
389 /* Note win32_wait doesn't return thread events. */
390 if (status.kind != TARGET_WAITKIND_LOADED)
391 {
392 cached_status = status;
393 break;
394 }
395
396 {
397 struct thread_resume resume;
398
399 resume.thread = minus_one_ptid;
400 resume.kind = resume_continue;
401 resume.sig = 0;
402
403 win32_resume (&resume, 1);
404 }
405 }
406
407#ifndef _WIN32_WCE
408 /* Now that the inferior has been started and all DLLs have been mapped,
409 we can iterate over all DLLs and load them in.
410
411 We avoid doing it any earlier because, on certain versions of Windows,
412 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
413 we have seen on Windows 8.1 that the ntdll.dll load event does not
414 include the DLL name, preventing us from creating an associated SO.
415 A possible explanation is that ntdll.dll might be mapped before
416 the SO info gets created by the Windows system -- ntdll.dll is
417 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
418 do not seem to suffer from that problem.
419
420 Rather than try to work around this sort of issue, it is much
421 simpler to just ignore DLL load/unload events during the startup
422 phase, and then process them all in one batch now. */
423 win32_add_all_dlls ();
424#endif
425
426 child_initialization_done = 1;
427}
428
429/* Resume all artificially suspended threads if we are continuing
430 execution. */
431static int
432continue_one_thread (struct inferior_list_entry *this_thread, void *id_ptr)
433{
434 struct thread_info *thread = (struct thread_info *) this_thread;
435 int thread_id = * (int *) id_ptr;
436 win32_thread_info *th = (win32_thread_info *) inferior_target_data (thread);
437
438 if (thread_id == -1 || thread_id == th->tid)
439 {
440 win32_prepare_to_resume (th);
441
442 if (th->suspended)
443 {
444 if (th->context.ContextFlags)
445 {
446 win32_set_thread_context (th);
447 th->context.ContextFlags = 0;
448 }
449
450 if (ResumeThread (th->h) == (DWORD) -1)
451 {
452 DWORD err = GetLastError ();
453 OUTMSG (("warning: ResumeThread failed in continue_one_thread, "
454 "(error %d): %s\n", (int) err, strwinerror (err)));
455 }
456 th->suspended = 0;
457 }
458 }
459
460 return 0;
461}
462
463static BOOL
464child_continue (DWORD continue_status, int thread_id)
465{
466 /* The inferior will only continue after the ContinueDebugEvent
467 call. */
468 find_inferior (&all_threads, continue_one_thread, &thread_id);
469 faked_breakpoint = 0;
470
471 if (!ContinueDebugEvent (current_event.dwProcessId,
472 current_event.dwThreadId,
473 continue_status))
474 return FALSE;
475
476 return TRUE;
477}
478
479/* Fetch register(s) from the current thread context. */
480static void
481child_fetch_inferior_registers (struct regcache *regcache, int r)
482{
483 int regno;
484 win32_thread_info *th = thread_rec (current_thread_ptid (), TRUE);
485 if (r == -1 || r > NUM_REGS)
486 child_fetch_inferior_registers (regcache, NUM_REGS);
487 else
488 for (regno = 0; regno < r; regno++)
489 (*the_low_target.fetch_inferior_register) (regcache, th, regno);
490}
491
492/* Store a new register value into the current thread context. We don't
493 change the program's context until later, when we resume it. */
494static void
495child_store_inferior_registers (struct regcache *regcache, int r)
496{
497 int regno;
498 win32_thread_info *th = thread_rec (current_thread_ptid (), TRUE);
499 if (r == -1 || r == 0 || r > NUM_REGS)
500 child_store_inferior_registers (regcache, NUM_REGS);
501 else
502 for (regno = 0; regno < r; regno++)
503 (*the_low_target.store_inferior_register) (regcache, th, regno);
504}
505
506/* Map the Windows error number in ERROR to a locale-dependent error
507 message string and return a pointer to it. Typically, the values
508 for ERROR come from GetLastError.
509
510 The string pointed to shall not be modified by the application,
511 but may be overwritten by a subsequent call to strwinerror
512
513 The strwinerror function does not change the current setting
514 of GetLastError. */
515
516char *
517strwinerror (DWORD error)
518{
519 static char buf[1024];
520 TCHAR *msgbuf;
521 DWORD lasterr = GetLastError ();
522 DWORD chars = FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
523 | FORMAT_MESSAGE_ALLOCATE_BUFFER,
524 NULL,
525 error,
526 0, /* Default language */
527 (LPTSTR) &msgbuf,
528 0,
529 NULL);
530 if (chars != 0)
531 {
532 /* If there is an \r\n appended, zap it. */
533 if (chars >= 2
534 && msgbuf[chars - 2] == '\r'
535 && msgbuf[chars - 1] == '\n')
536 {
537 chars -= 2;
538 msgbuf[chars] = 0;
539 }
540
541 if (chars > ((COUNTOF (buf)) - 1))
542 {
543 chars = COUNTOF (buf) - 1;
544 msgbuf [chars] = 0;
545 }
546
547#ifdef UNICODE
548 wcstombs (buf, msgbuf, chars + 1);
549#else
550 strncpy (buf, msgbuf, chars + 1);
551#endif
552 LocalFree (msgbuf);
553 }
554 else
555 sprintf (buf, "unknown win32 error (%u)", (unsigned) error);
556
557 SetLastError (lasterr);
558 return buf;
559}
560
561static BOOL
562create_process (const char *program, char *args,
563 DWORD flags, PROCESS_INFORMATION *pi)
564{
565 BOOL ret;
566
567#ifdef _WIN32_WCE
568 wchar_t *p, *wprogram, *wargs;
569 size_t argslen;
570
571 wprogram = alloca ((strlen (program) + 1) * sizeof (wchar_t));
572 mbstowcs (wprogram, program, strlen (program) + 1);
573
574 for (p = wprogram; *p; ++p)
575 if (L'/' == *p)
576 *p = L'\\';
577
578 argslen = strlen (args);
579 wargs = alloca ((argslen + 1) * sizeof (wchar_t));
580 mbstowcs (wargs, args, argslen + 1);
581
582 ret = CreateProcessW (wprogram, /* image name */
583 wargs, /* command line */
584 NULL, /* security, not supported */
585 NULL, /* thread, not supported */
586 FALSE, /* inherit handles, not supported */
587 flags, /* start flags */
588 NULL, /* environment, not supported */
589 NULL, /* current directory, not supported */
590 NULL, /* start info, not supported */
591 pi); /* proc info */
592#else
593 STARTUPINFOA si = { sizeof (STARTUPINFOA) };
594
595 ret = CreateProcessA (program, /* image name */
596 args, /* command line */
597 NULL, /* security */
598 NULL, /* thread */
599 TRUE, /* inherit handles */
600 flags, /* start flags */
601 NULL, /* environment */
602 NULL, /* current directory */
603 &si, /* start info */
604 pi); /* proc info */
605#endif
606
607 return ret;
608}
609
610/* Start a new process.
611 PROGRAM is a path to the program to execute.
612 ARGS is a standard NULL-terminated array of arguments,
613 to be passed to the inferior as ``argv''.
614 Returns the new PID on success, -1 on failure. Registers the new
615 process with the process list. */
616static int
617win32_create_inferior (char *program, char **program_args)
618{
619#ifndef USE_WIN32API
620 char real_path[PATH_MAX];
621 char *orig_path, *new_path, *path_ptr;
622#endif
623 BOOL ret;
624 DWORD flags;
625 char *args;
626 int argslen;
627 int argc;
628 PROCESS_INFORMATION pi;
629 DWORD err;
630
631 /* win32_wait needs to know we're not attaching. */
632 attaching = 0;
633
634 if (!program)
635 error ("No executable specified, specify executable to debug.\n");
636
637 flags = DEBUG_PROCESS | DEBUG_ONLY_THIS_PROCESS;
638
639#ifndef USE_WIN32API
640 orig_path = NULL;
641 path_ptr = getenv ("PATH");
642 if (path_ptr)
643 {
644 int size = cygwin_conv_path_list (CCP_POSIX_TO_WIN_A, path_ptr, NULL, 0);
645 orig_path = alloca (strlen (path_ptr) + 1);
646 new_path = alloca (size);
647 strcpy (orig_path, path_ptr);
648 cygwin_conv_path_list (CCP_POSIX_TO_WIN_A, path_ptr, new_path, size);
649 setenv ("PATH", new_path, 1);
650 }
651 cygwin_conv_path (CCP_POSIX_TO_WIN_A, program, real_path, PATH_MAX);
652 program = real_path;
653#endif
654
655 argslen = 1;
656 for (argc = 1; program_args[argc]; argc++)
657 argslen += strlen (program_args[argc]) + 1;
658 args = (char *) alloca (argslen);
659 args[0] = '\0';
660 for (argc = 1; program_args[argc]; argc++)
661 {
662 /* FIXME: Can we do better about quoting? How does Cygwin
663 handle this? */
664 strcat (args, " ");
665 strcat (args, program_args[argc]);
666 }
667 OUTMSG2 (("Command line is \"%s\"\n", args));
668
669#ifdef CREATE_NEW_PROCESS_GROUP
670 flags |= CREATE_NEW_PROCESS_GROUP;
671#endif
672
673 ret = create_process (program, args, flags, &pi);
674 err = GetLastError ();
675 if (!ret && err == ERROR_FILE_NOT_FOUND)
676 {
677 char *exename = (char *) alloca (strlen (program) + 5);
678 strcat (strcpy (exename, program), ".exe");
679 ret = create_process (exename, args, flags, &pi);
680 err = GetLastError ();
681 }
682
683#ifndef USE_WIN32API
684 if (orig_path)
685 setenv ("PATH", orig_path, 1);
686#endif
687
688 if (!ret)
689 {
690 error ("Error creating process \"%s%s\", (error %d): %s\n",
691 program, args, (int) err, strwinerror (err));
692 }
693 else
694 {
695 OUTMSG2 (("Process created: %s\n", (char *) args));
696 }
697
698#ifndef _WIN32_WCE
699 /* On Windows CE this handle can't be closed. The OS reuses
700 it in the debug events, while the 9x/NT versions of Windows
701 probably use a DuplicateHandle'd one. */
702 CloseHandle (pi.hThread);
703#endif
704
705 do_initial_child_stuff (pi.hProcess, pi.dwProcessId, 0);
706
707 return current_process_id;
708}
709
710/* Attach to a running process.
711 PID is the process ID to attach to, specified by the user
712 or a higher layer. */
713static int
714win32_attach (unsigned long pid)
715{
716 HANDLE h;
717 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit = NULL;
718 DWORD err;
719#ifdef _WIN32_WCE
720 HMODULE dll = GetModuleHandle (_T("COREDLL.DLL"));
721#else
722 HMODULE dll = GetModuleHandle (_T("KERNEL32.DLL"));
723#endif
724 DebugSetProcessKillOnExit = GETPROCADDRESS (dll, DebugSetProcessKillOnExit);
725
726 h = OpenProcess (PROCESS_ALL_ACCESS, FALSE, pid);
727 if (h != NULL)
728 {
729 if (DebugActiveProcess (pid))
730 {
731 if (DebugSetProcessKillOnExit != NULL)
732 DebugSetProcessKillOnExit (FALSE);
733
734 /* win32_wait needs to know we're attaching. */
735 attaching = 1;
736 do_initial_child_stuff (h, pid, 1);
737 return 0;
738 }
739
740 CloseHandle (h);
741 }
742
743 err = GetLastError ();
744 error ("Attach to process failed (error %d): %s\n",
745 (int) err, strwinerror (err));
746}
747
748/* Handle OUTPUT_DEBUG_STRING_EVENT from child process. */
749static void
750handle_output_debug_string (struct target_waitstatus *ourstatus)
751{
752#define READ_BUFFER_LEN 1024
753 CORE_ADDR addr;
754 char s[READ_BUFFER_LEN + 1] = { 0 };
755 DWORD nbytes = current_event.u.DebugString.nDebugStringLength;
756
757 if (nbytes == 0)
758 return;
759
760 if (nbytes > READ_BUFFER_LEN)
761 nbytes = READ_BUFFER_LEN;
762
763 addr = (CORE_ADDR) (size_t) current_event.u.DebugString.lpDebugStringData;
764
765 if (current_event.u.DebugString.fUnicode)
766 {
767 /* The event tells us how many bytes, not chars, even
768 in Unicode. */
769 WCHAR buffer[(READ_BUFFER_LEN + 1) / sizeof (WCHAR)] = { 0 };
770 if (read_inferior_memory (addr, (unsigned char *) buffer, nbytes) != 0)
771 return;
772 wcstombs (s, buffer, (nbytes + 1) / sizeof (WCHAR));
773 }
774 else
775 {
776 if (read_inferior_memory (addr, (unsigned char *) s, nbytes) != 0)
777 return;
778 }
779
780 if (!startswith (s, "cYg"))
781 {
782 if (!server_waiting)
783 {
784 OUTMSG2(("%s", s));
785 return;
786 }
787
788 monitor_output (s);
789 }
790#undef READ_BUFFER_LEN
791}
792
793static void
794win32_clear_inferiors (void)
795{
796 if (current_process_handle != NULL)
797 CloseHandle (current_process_handle);
798
799 for_each_inferior (&all_threads, delete_thread_info);
800 clear_inferiors ();
801}
802
803/* Kill all inferiors. */
804static int
805win32_kill (int pid)
806{
807 struct process_info *process;
808
809 if (current_process_handle == NULL)
810 return -1;
811
812 TerminateProcess (current_process_handle, 0);
813 for (;;)
814 {
815 if (!child_continue (DBG_CONTINUE, -1))
816 break;
817 if (!WaitForDebugEvent (&current_event, INFINITE))
818 break;
819 if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
820 break;
821 else if (current_event.dwDebugEventCode == OUTPUT_DEBUG_STRING_EVENT)
822 {
823 struct target_waitstatus our_status = { 0 };
824 handle_output_debug_string (&our_status);
825 }
826 }
827
828 win32_clear_inferiors ();
829
830 process = find_process_pid (pid);
831 remove_process (process);
832 return 0;
833}
834
835/* Detach from inferior PID. */
836static int
837win32_detach (int pid)
838{
839 struct process_info *process;
840 winapi_DebugActiveProcessStop DebugActiveProcessStop = NULL;
841 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit = NULL;
842#ifdef _WIN32_WCE
843 HMODULE dll = GetModuleHandle (_T("COREDLL.DLL"));
844#else
845 HMODULE dll = GetModuleHandle (_T("KERNEL32.DLL"));
846#endif
847 DebugActiveProcessStop = GETPROCADDRESS (dll, DebugActiveProcessStop);
848 DebugSetProcessKillOnExit = GETPROCADDRESS (dll, DebugSetProcessKillOnExit);
849
850 if (DebugSetProcessKillOnExit == NULL
851 || DebugActiveProcessStop == NULL)
852 return -1;
853
854 {
855 struct thread_resume resume;
856 resume.thread = minus_one_ptid;
857 resume.kind = resume_continue;
858 resume.sig = 0;
859 win32_resume (&resume, 1);
860 }
861
862 if (!DebugActiveProcessStop (current_process_id))
863 return -1;
864
865 DebugSetProcessKillOnExit (FALSE);
866 process = find_process_pid (pid);
867 remove_process (process);
868
869 win32_clear_inferiors ();
870 return 0;
871}
872
873static void
874win32_mourn (struct process_info *process)
875{
876 remove_process (process);
877}
878
879/* Wait for inferiors to end. */
880static void
881win32_join (int pid)
882{
883 HANDLE h = OpenProcess (PROCESS_ALL_ACCESS, FALSE, pid);
884 if (h != NULL)
885 {
886 WaitForSingleObject (h, INFINITE);
887 CloseHandle (h);
888 }
889}
890
891/* Return 1 iff the thread with thread ID TID is alive. */
892static int
893win32_thread_alive (ptid_t ptid)
894{
895 int res;
896
897 /* Our thread list is reliable; don't bother to poll target
898 threads. */
899 if (find_inferior_id (&all_threads, ptid) != NULL)
900 res = 1;
901 else
902 res = 0;
903 return res;
904}
905
906/* Resume the inferior process. RESUME_INFO describes how we want
907 to resume. */
908static void
909win32_resume (struct thread_resume *resume_info, size_t n)
910{
911 DWORD tid;
912 enum gdb_signal sig;
913 int step;
914 win32_thread_info *th;
915 DWORD continue_status = DBG_CONTINUE;
916 ptid_t ptid;
917
918 /* This handles the very limited set of resume packets that GDB can
919 currently produce. */
920
921 if (n == 1 && ptid_equal (resume_info[0].thread, minus_one_ptid))
922 tid = -1;
923 else if (n > 1)
924 tid = -1;
925 else
926 /* Yes, we're ignoring resume_info[0].thread. It'd be tricky to make
927 the Windows resume code do the right thing for thread switching. */
928 tid = current_event.dwThreadId;
929
930 if (!ptid_equal (resume_info[0].thread, minus_one_ptid))
931 {
932 sig = resume_info[0].sig;
933 step = resume_info[0].kind == resume_step;
934 }
935 else
936 {
937 sig = 0;
938 step = 0;
939 }
940
941 if (sig != GDB_SIGNAL_0)
942 {
943 if (current_event.dwDebugEventCode != EXCEPTION_DEBUG_EVENT)
944 {
945 OUTMSG (("Cannot continue with signal %d here.\n", sig));
946 }
947 else if (sig == last_sig)
948 continue_status = DBG_EXCEPTION_NOT_HANDLED;
949 else
950 OUTMSG (("Can only continue with recieved signal %d.\n", last_sig));
951 }
952
953 last_sig = GDB_SIGNAL_0;
954
955 /* Get context for the currently selected thread. */
956 ptid = debug_event_ptid (&current_event);
957 th = thread_rec (ptid, FALSE);
958 if (th)
959 {
960 win32_prepare_to_resume (th);
961
962 if (th->context.ContextFlags)
963 {
964 /* Move register values from the inferior into the thread
965 context structure. */
966 regcache_invalidate ();
967
968 if (step)
969 {
970 if (the_low_target.single_step != NULL)
971 (*the_low_target.single_step) (th);
972 else
973 error ("Single stepping is not supported "
974 "in this configuration.\n");
975 }
976
977 win32_set_thread_context (th);
978 th->context.ContextFlags = 0;
979 }
980 }
981
982 /* Allow continuing with the same signal that interrupted us.
983 Otherwise complain. */
984
985 child_continue (continue_status, tid);
986}
987
988static void
989win32_add_one_solib (const char *name, CORE_ADDR load_addr)
990{
991 char buf[MAX_PATH + 1];
992 char buf2[MAX_PATH + 1];
993
994#ifdef _WIN32_WCE
995 WIN32_FIND_DATA w32_fd;
996 WCHAR wname[MAX_PATH + 1];
997 mbstowcs (wname, name, MAX_PATH);
998 HANDLE h = FindFirstFile (wname, &w32_fd);
999#else
1000 WIN32_FIND_DATAA w32_fd;
1001 HANDLE h = FindFirstFileA (name, &w32_fd);
1002#endif
1003
1004 /* The symbols in a dll are offset by 0x1000, which is the
1005 offset from 0 of the first byte in an image - because
1006 of the file header and the section alignment. */
1007 load_addr += 0x1000;
1008
1009 if (h == INVALID_HANDLE_VALUE)
1010 strcpy (buf, name);
1011 else
1012 {
1013 FindClose (h);
1014 strcpy (buf, name);
1015#ifndef _WIN32_WCE
1016 {
1017 char cwd[MAX_PATH + 1];
1018 char *p;
1019 if (GetCurrentDirectoryA (MAX_PATH + 1, cwd))
1020 {
1021 p = strrchr (buf, '\\');
1022 if (p)
1023 p[1] = '\0';
1024 SetCurrentDirectoryA (buf);
1025 GetFullPathNameA (w32_fd.cFileName, MAX_PATH, buf, &p);
1026 SetCurrentDirectoryA (cwd);
1027 }
1028 }
1029#endif
1030 }
1031
1032#ifndef _WIN32_WCE
1033 if (strcasecmp (buf, "ntdll.dll") == 0)
1034 {
1035 GetSystemDirectoryA (buf, sizeof (buf));
1036 strcat (buf, "\\ntdll.dll");
1037 }
1038#endif
1039
1040#ifdef __CYGWIN__
1041 cygwin_conv_path (CCP_WIN_A_TO_POSIX, buf, buf2, sizeof (buf2));
1042#else
1043 strcpy (buf2, buf);
1044#endif
1045
1046 loaded_dll (buf2, load_addr);
1047}
1048
1049static char *
1050get_image_name (HANDLE h, void *address, int unicode)
1051{
1052 static char buf[(2 * MAX_PATH) + 1];
1053 DWORD size = unicode ? sizeof (WCHAR) : sizeof (char);
1054 char *address_ptr;
1055 int len = 0;
1056 char b[2];
1057 SIZE_T done;
1058
1059 /* Attempt to read the name of the dll that was detected.
1060 This is documented to work only when actively debugging
1061 a program. It will not work for attached processes. */
1062 if (address == NULL)
1063 return NULL;
1064
1065#ifdef _WIN32_WCE
1066 /* Windows CE reports the address of the image name,
1067 instead of an address of a pointer into the image name. */
1068 address_ptr = address;
1069#else
1070 /* See if we could read the address of a string, and that the
1071 address isn't null. */
1072 if (!ReadProcessMemory (h, address, &address_ptr,
1073 sizeof (address_ptr), &done)
1074 || done != sizeof (address_ptr)
1075 || !address_ptr)
1076 return NULL;
1077#endif
1078
1079 /* Find the length of the string */
1080 while (ReadProcessMemory (h, address_ptr + len++ * size, &b, size, &done)
1081 && (b[0] != 0 || b[size - 1] != 0) && done == size)
1082 continue;
1083
1084 if (!unicode)
1085 ReadProcessMemory (h, address_ptr, buf, len, &done);
1086 else
1087 {
1088 WCHAR *unicode_address = XALLOCAVEC (WCHAR, len);
1089 ReadProcessMemory (h, address_ptr, unicode_address, len * sizeof (WCHAR),
1090 &done);
1091
1092 WideCharToMultiByte (CP_ACP, 0, unicode_address, len, buf, len, 0, 0);
1093 }
1094
1095 return buf;
1096}
1097
1098typedef BOOL (WINAPI *winapi_EnumProcessModules) (HANDLE, HMODULE *,
1099 DWORD, LPDWORD);
1100typedef BOOL (WINAPI *winapi_GetModuleInformation) (HANDLE, HMODULE,
1101 LPMODULEINFO, DWORD);
1102typedef DWORD (WINAPI *winapi_GetModuleFileNameExA) (HANDLE, HMODULE,
1103 LPSTR, DWORD);
1104
1105static winapi_EnumProcessModules win32_EnumProcessModules;
1106static winapi_GetModuleInformation win32_GetModuleInformation;
1107static winapi_GetModuleFileNameExA win32_GetModuleFileNameExA;
1108
1109static BOOL
1110load_psapi (void)
1111{
1112 static int psapi_loaded = 0;
1113 static HMODULE dll = NULL;
1114
1115 if (!psapi_loaded)
1116 {
1117 psapi_loaded = 1;
1118 dll = LoadLibrary (TEXT("psapi.dll"));
1119 if (!dll)
1120 return FALSE;
1121 win32_EnumProcessModules =
1122 GETPROCADDRESS (dll, EnumProcessModules);
1123 win32_GetModuleInformation =
1124 GETPROCADDRESS (dll, GetModuleInformation);
1125 win32_GetModuleFileNameExA =
1126 GETPROCADDRESS (dll, GetModuleFileNameExA);
1127 }
1128
1129 return (win32_EnumProcessModules != NULL
1130 && win32_GetModuleInformation != NULL
1131 && win32_GetModuleFileNameExA != NULL);
1132}
1133
1134#ifndef _WIN32_WCE
1135
1136/* Iterate over all DLLs currently mapped by our inferior, and
1137 add them to our list of solibs. */
1138
1139static void
1140win32_add_all_dlls (void)
1141{
1142 size_t i;
1143 HMODULE dh_buf[1];
1144 HMODULE *DllHandle = dh_buf;
1145 DWORD cbNeeded;
1146 BOOL ok;
1147
1148 if (!load_psapi ())
1149 return;
1150
1151 cbNeeded = 0;
1152 ok = (*win32_EnumProcessModules) (current_process_handle,
1153 DllHandle,
1154 sizeof (HMODULE),
1155 &cbNeeded);
1156
1157 if (!ok || !cbNeeded)
1158 return;
1159
1160 DllHandle = (HMODULE *) alloca (cbNeeded);
1161 if (!DllHandle)
1162 return;
1163
1164 ok = (*win32_EnumProcessModules) (current_process_handle,
1165 DllHandle,
1166 cbNeeded,
1167 &cbNeeded);
1168 if (!ok)
1169 return;
1170
1171 for (i = 1; i < ((size_t) cbNeeded / sizeof (HMODULE)); i++)
1172 {
1173 MODULEINFO mi;
1174 char dll_name[MAX_PATH];
1175
1176 if (!(*win32_GetModuleInformation) (current_process_handle,
1177 DllHandle[i],
1178 &mi,
1179 sizeof (mi)))
1180 continue;
1181 if ((*win32_GetModuleFileNameExA) (current_process_handle,
1182 DllHandle[i],
1183 dll_name,
1184 MAX_PATH) == 0)
1185 continue;
1186 win32_add_one_solib (dll_name, (CORE_ADDR) (uintptr_t) mi.lpBaseOfDll);
1187 }
1188}
1189#endif
1190
1191typedef HANDLE (WINAPI *winapi_CreateToolhelp32Snapshot) (DWORD, DWORD);
1192typedef BOOL (WINAPI *winapi_Module32First) (HANDLE, LPMODULEENTRY32);
1193typedef BOOL (WINAPI *winapi_Module32Next) (HANDLE, LPMODULEENTRY32);
1194
1195/* Handle a DLL load event.
1196
1197 This function assumes that this event did not occur during inferior
1198 initialization, where their event info may be incomplete (see
1199 do_initial_child_stuff and win32_add_all_dlls for more info on
1200 how we handle DLL loading during that phase). */
1201
1202static void
1203handle_load_dll (void)
1204{
1205 LOAD_DLL_DEBUG_INFO *event = &current_event.u.LoadDll;
1206 char *dll_name;
1207
1208 dll_name = get_image_name (current_process_handle,
1209 event->lpImageName, event->fUnicode);
1210 if (!dll_name)
1211 return;
1212
1213 win32_add_one_solib (dll_name, (CORE_ADDR) (uintptr_t) event->lpBaseOfDll);
1214}
1215
1216/* Handle a DLL unload event.
1217
1218 This function assumes that this event did not occur during inferior
1219 initialization, where their event info may be incomplete (see
1220 do_initial_child_stuff and win32_add_one_solib for more info
1221 on how we handle DLL loading during that phase). */
1222
1223static void
1224handle_unload_dll (void)
1225{
1226 CORE_ADDR load_addr =
1227 (CORE_ADDR) (uintptr_t) current_event.u.UnloadDll.lpBaseOfDll;
1228
1229 /* The symbols in a dll are offset by 0x1000, which is the
1230 offset from 0 of the first byte in an image - because
1231 of the file header and the section alignment. */
1232 load_addr += 0x1000;
1233 unloaded_dll (NULL, load_addr);
1234}
1235
1236static void
1237handle_exception (struct target_waitstatus *ourstatus)
1238{
1239 DWORD code = current_event.u.Exception.ExceptionRecord.ExceptionCode;
1240
1241 ourstatus->kind = TARGET_WAITKIND_STOPPED;
1242
1243 switch (code)
1244 {
1245 case EXCEPTION_ACCESS_VIOLATION:
1246 OUTMSG2 (("EXCEPTION_ACCESS_VIOLATION"));
1247 ourstatus->value.sig = GDB_SIGNAL_SEGV;
1248 break;
1249 case STATUS_STACK_OVERFLOW:
1250 OUTMSG2 (("STATUS_STACK_OVERFLOW"));
1251 ourstatus->value.sig = GDB_SIGNAL_SEGV;
1252 break;
1253 case STATUS_FLOAT_DENORMAL_OPERAND:
1254 OUTMSG2 (("STATUS_FLOAT_DENORMAL_OPERAND"));
1255 ourstatus->value.sig = GDB_SIGNAL_FPE;
1256 break;
1257 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
1258 OUTMSG2 (("EXCEPTION_ARRAY_BOUNDS_EXCEEDED"));
1259 ourstatus->value.sig = GDB_SIGNAL_FPE;
1260 break;
1261 case STATUS_FLOAT_INEXACT_RESULT:
1262 OUTMSG2 (("STATUS_FLOAT_INEXACT_RESULT"));
1263 ourstatus->value.sig = GDB_SIGNAL_FPE;
1264 break;
1265 case STATUS_FLOAT_INVALID_OPERATION:
1266 OUTMSG2 (("STATUS_FLOAT_INVALID_OPERATION"));
1267 ourstatus->value.sig = GDB_SIGNAL_FPE;
1268 break;
1269 case STATUS_FLOAT_OVERFLOW:
1270 OUTMSG2 (("STATUS_FLOAT_OVERFLOW"));
1271 ourstatus->value.sig = GDB_SIGNAL_FPE;
1272 break;
1273 case STATUS_FLOAT_STACK_CHECK:
1274 OUTMSG2 (("STATUS_FLOAT_STACK_CHECK"));
1275 ourstatus->value.sig = GDB_SIGNAL_FPE;
1276 break;
1277 case STATUS_FLOAT_UNDERFLOW:
1278 OUTMSG2 (("STATUS_FLOAT_UNDERFLOW"));
1279 ourstatus->value.sig = GDB_SIGNAL_FPE;
1280 break;
1281 case STATUS_FLOAT_DIVIDE_BY_ZERO:
1282 OUTMSG2 (("STATUS_FLOAT_DIVIDE_BY_ZERO"));
1283 ourstatus->value.sig = GDB_SIGNAL_FPE;
1284 break;
1285 case STATUS_INTEGER_DIVIDE_BY_ZERO:
1286 OUTMSG2 (("STATUS_INTEGER_DIVIDE_BY_ZERO"));
1287 ourstatus->value.sig = GDB_SIGNAL_FPE;
1288 break;
1289 case STATUS_INTEGER_OVERFLOW:
1290 OUTMSG2 (("STATUS_INTEGER_OVERFLOW"));
1291 ourstatus->value.sig = GDB_SIGNAL_FPE;
1292 break;
1293 case EXCEPTION_BREAKPOINT:
1294 OUTMSG2 (("EXCEPTION_BREAKPOINT"));
1295 ourstatus->value.sig = GDB_SIGNAL_TRAP;
1296#ifdef _WIN32_WCE
1297 /* Remove the initial breakpoint. */
1298 check_breakpoints ((CORE_ADDR) (long) current_event
1299 .u.Exception.ExceptionRecord.ExceptionAddress);
1300#endif
1301 break;
1302 case DBG_CONTROL_C:
1303 OUTMSG2 (("DBG_CONTROL_C"));
1304 ourstatus->value.sig = GDB_SIGNAL_INT;
1305 break;
1306 case DBG_CONTROL_BREAK:
1307 OUTMSG2 (("DBG_CONTROL_BREAK"));
1308 ourstatus->value.sig = GDB_SIGNAL_INT;
1309 break;
1310 case EXCEPTION_SINGLE_STEP:
1311 OUTMSG2 (("EXCEPTION_SINGLE_STEP"));
1312 ourstatus->value.sig = GDB_SIGNAL_TRAP;
1313 break;
1314 case EXCEPTION_ILLEGAL_INSTRUCTION:
1315 OUTMSG2 (("EXCEPTION_ILLEGAL_INSTRUCTION"));
1316 ourstatus->value.sig = GDB_SIGNAL_ILL;
1317 break;
1318 case EXCEPTION_PRIV_INSTRUCTION:
1319 OUTMSG2 (("EXCEPTION_PRIV_INSTRUCTION"));
1320 ourstatus->value.sig = GDB_SIGNAL_ILL;
1321 break;
1322 case EXCEPTION_NONCONTINUABLE_EXCEPTION:
1323 OUTMSG2 (("EXCEPTION_NONCONTINUABLE_EXCEPTION"));
1324 ourstatus->value.sig = GDB_SIGNAL_ILL;
1325 break;
1326 default:
1327 if (current_event.u.Exception.dwFirstChance)
1328 {
1329 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
1330 return;
1331 }
1332 OUTMSG2 (("gdbserver: unknown target exception 0x%08x at 0x%s",
1333 (unsigned) current_event.u.Exception.ExceptionRecord.ExceptionCode,
1334 phex_nz ((uintptr_t) current_event.u.Exception.ExceptionRecord.
1335 ExceptionAddress, sizeof (uintptr_t))));
1336 ourstatus->value.sig = GDB_SIGNAL_UNKNOWN;
1337 break;
1338 }
1339 OUTMSG2 (("\n"));
1340 last_sig = ourstatus->value.sig;
1341}
1342
1343
1344static void
1345suspend_one_thread (struct inferior_list_entry *entry)
1346{
1347 struct thread_info *thread = (struct thread_info *) entry;
1348 win32_thread_info *th = (win32_thread_info *) inferior_target_data (thread);
1349
1350 if (!th->suspended)
1351 {
1352 if (SuspendThread (th->h) == (DWORD) -1)
1353 {
1354 DWORD err = GetLastError ();
1355 OUTMSG (("warning: SuspendThread failed in suspend_one_thread, "
1356 "(error %d): %s\n", (int) err, strwinerror (err)));
1357 }
1358 else
1359 th->suspended = 1;
1360 }
1361}
1362
1363static void
1364fake_breakpoint_event (void)
1365{
1366 OUTMSG2(("fake_breakpoint_event\n"));
1367
1368 faked_breakpoint = 1;
1369
1370 memset (&current_event, 0, sizeof (current_event));
1371 current_event.dwThreadId = main_thread_id;
1372 current_event.dwDebugEventCode = EXCEPTION_DEBUG_EVENT;
1373 current_event.u.Exception.ExceptionRecord.ExceptionCode
1374 = EXCEPTION_BREAKPOINT;
1375
1376 for_each_inferior (&all_threads, suspend_one_thread);
1377}
1378
1379#ifdef _WIN32_WCE
1380static int
1381auto_delete_breakpoint (CORE_ADDR stop_pc)
1382{
1383 return 1;
1384}
1385#endif
1386
1387/* Get the next event from the child. */
1388
1389static int
1390get_child_debug_event (struct target_waitstatus *ourstatus)
1391{
1392 ptid_t ptid;
1393
1394 last_sig = GDB_SIGNAL_0;
1395 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
1396
1397 /* Check if GDB sent us an interrupt request. */
1398 check_remote_input_interrupt_request ();
1399
1400 if (soft_interrupt_requested)
1401 {
1402 soft_interrupt_requested = 0;
1403 fake_breakpoint_event ();
1404 goto gotevent;
1405 }
1406
1407#ifndef _WIN32_WCE
1408 attaching = 0;
1409#else
1410 if (attaching)
1411 {
1412 /* WinCE doesn't set an initial breakpoint automatically. To
1413 stop the inferior, we flush all currently pending debug
1414 events -- the thread list and the dll list are always
1415 reported immediatelly without delay, then, we suspend all
1416 threads and pretend we saw a trap at the current PC of the
1417 main thread.
1418
1419 Contrary to desktop Windows, Windows CE *does* report the dll
1420 names on LOAD_DLL_DEBUG_EVENTs resulting from a
1421 DebugActiveProcess call. This limits the way we can detect
1422 if all the dlls have already been reported. If we get a real
1423 debug event before leaving attaching, the worst that will
1424 happen is the user will see a spurious breakpoint. */
1425
1426 current_event.dwDebugEventCode = 0;
1427 if (!WaitForDebugEvent (&current_event, 0))
1428 {
1429 OUTMSG2(("no attach events left\n"));
1430 fake_breakpoint_event ();
1431 attaching = 0;
1432 }
1433 else
1434 OUTMSG2(("got attach event\n"));
1435 }
1436 else
1437#endif
1438 {
1439 /* Keep the wait time low enough for confortable remote
1440 interruption, but high enough so gdbserver doesn't become a
1441 bottleneck. */
1442 if (!WaitForDebugEvent (&current_event, 250))
1443 {
1444 DWORD e = GetLastError();
1445
1446 if (e == ERROR_PIPE_NOT_CONNECTED)
1447 {
1448 /* This will happen if the loader fails to succesfully
1449 load the application, e.g., if the main executable
1450 tries to pull in a non-existing export from a
1451 DLL. */
1452 ourstatus->kind = TARGET_WAITKIND_EXITED;
1453 ourstatus->value.integer = 1;
1454 return 1;
1455 }
1456
1457 return 0;
1458 }
1459 }
1460
1461 gotevent:
1462
1463 switch (current_event.dwDebugEventCode)
1464 {
1465 case CREATE_THREAD_DEBUG_EVENT:
1466 OUTMSG2 (("gdbserver: kernel event CREATE_THREAD_DEBUG_EVENT "
1467 "for pid=%u tid=%x)\n",
1468 (unsigned) current_event.dwProcessId,
1469 (unsigned) current_event.dwThreadId));
1470
1471 /* Record the existence of this thread. */
1472 child_add_thread (current_event.dwProcessId,
1473 current_event.dwThreadId,
1474 current_event.u.CreateThread.hThread,
1475 current_event.u.CreateThread.lpThreadLocalBase);
1476 break;
1477
1478 case EXIT_THREAD_DEBUG_EVENT:
1479 OUTMSG2 (("gdbserver: kernel event EXIT_THREAD_DEBUG_EVENT "
1480 "for pid=%u tid=%x\n",
1481 (unsigned) current_event.dwProcessId,
1482 (unsigned) current_event.dwThreadId));
1483 child_delete_thread (current_event.dwProcessId,
1484 current_event.dwThreadId);
1485
1486 current_thread = (struct thread_info *) all_threads.head;
1487 return 1;
1488
1489 case CREATE_PROCESS_DEBUG_EVENT:
1490 OUTMSG2 (("gdbserver: kernel event CREATE_PROCESS_DEBUG_EVENT "
1491 "for pid=%u tid=%x\n",
1492 (unsigned) current_event.dwProcessId,
1493 (unsigned) current_event.dwThreadId));
1494 CloseHandle (current_event.u.CreateProcessInfo.hFile);
1495
1496 current_process_handle = current_event.u.CreateProcessInfo.hProcess;
1497 main_thread_id = current_event.dwThreadId;
1498
1499 ourstatus->kind = TARGET_WAITKIND_EXECD;
1500 ourstatus->value.execd_pathname = "Main executable";
1501
1502 /* Add the main thread. */
1503 child_add_thread (current_event.dwProcessId,
1504 main_thread_id,
1505 current_event.u.CreateProcessInfo.hThread,
1506 current_event.u.CreateProcessInfo.lpThreadLocalBase);
1507
1508 ourstatus->value.related_pid = debug_event_ptid (&current_event);
1509#ifdef _WIN32_WCE
1510 if (!attaching)
1511 {
1512 /* Windows CE doesn't set the initial breakpoint
1513 automatically like the desktop versions of Windows do.
1514 We add it explicitly here. It will be removed as soon as
1515 it is hit. */
1516 set_breakpoint_at ((CORE_ADDR) (long) current_event.u
1517 .CreateProcessInfo.lpStartAddress,
1518 auto_delete_breakpoint);
1519 }
1520#endif
1521 break;
1522
1523 case EXIT_PROCESS_DEBUG_EVENT:
1524 OUTMSG2 (("gdbserver: kernel event EXIT_PROCESS_DEBUG_EVENT "
1525 "for pid=%u tid=%x\n",
1526 (unsigned) current_event.dwProcessId,
1527 (unsigned) current_event.dwThreadId));
1528 ourstatus->kind = TARGET_WAITKIND_EXITED;
1529 ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode;
1530 child_continue (DBG_CONTINUE, -1);
1531 CloseHandle (current_process_handle);
1532 current_process_handle = NULL;
1533 break;
1534
1535 case LOAD_DLL_DEBUG_EVENT:
1536 OUTMSG2 (("gdbserver: kernel event LOAD_DLL_DEBUG_EVENT "
1537 "for pid=%u tid=%x\n",
1538 (unsigned) current_event.dwProcessId,
1539 (unsigned) current_event.dwThreadId));
1540 CloseHandle (current_event.u.LoadDll.hFile);
1541 if (! child_initialization_done)
1542 break;
1543 handle_load_dll ();
1544
1545 ourstatus->kind = TARGET_WAITKIND_LOADED;
1546 ourstatus->value.sig = GDB_SIGNAL_TRAP;
1547 break;
1548
1549 case UNLOAD_DLL_DEBUG_EVENT:
1550 OUTMSG2 (("gdbserver: kernel event UNLOAD_DLL_DEBUG_EVENT "
1551 "for pid=%u tid=%x\n",
1552 (unsigned) current_event.dwProcessId,
1553 (unsigned) current_event.dwThreadId));
1554 if (! child_initialization_done)
1555 break;
1556 handle_unload_dll ();
1557 ourstatus->kind = TARGET_WAITKIND_LOADED;
1558 ourstatus->value.sig = GDB_SIGNAL_TRAP;
1559 break;
1560
1561 case EXCEPTION_DEBUG_EVENT:
1562 OUTMSG2 (("gdbserver: kernel event EXCEPTION_DEBUG_EVENT "
1563 "for pid=%u tid=%x\n",
1564 (unsigned) current_event.dwProcessId,
1565 (unsigned) current_event.dwThreadId));
1566 handle_exception (ourstatus);
1567 break;
1568
1569 case OUTPUT_DEBUG_STRING_EVENT:
1570 /* A message from the kernel (or Cygwin). */
1571 OUTMSG2 (("gdbserver: kernel event OUTPUT_DEBUG_STRING_EVENT "
1572 "for pid=%u tid=%x\n",
1573 (unsigned) current_event.dwProcessId,
1574 (unsigned) current_event.dwThreadId));
1575 handle_output_debug_string (ourstatus);
1576 break;
1577
1578 default:
1579 OUTMSG2 (("gdbserver: kernel event unknown "
1580 "for pid=%u tid=%x code=%x\n",
1581 (unsigned) current_event.dwProcessId,
1582 (unsigned) current_event.dwThreadId,
1583 (unsigned) current_event.dwDebugEventCode));
1584 break;
1585 }
1586
1587 ptid = debug_event_ptid (&current_event);
1588 current_thread =
1589 (struct thread_info *) find_inferior_id (&all_threads, ptid);
1590 return 1;
1591}
1592
1593/* Wait for the inferior process to change state.
1594 STATUS will be filled in with a response code to send to GDB.
1595 Returns the signal which caused the process to stop. */
1596static ptid_t
1597win32_wait (ptid_t ptid, struct target_waitstatus *ourstatus, int options)
1598{
1599 struct regcache *regcache;
1600
1601 if (cached_status.kind != TARGET_WAITKIND_IGNORE)
1602 {
1603 /* The core always does a wait after creating the inferior, and
1604 do_initial_child_stuff already ran the inferior to the
1605 initial breakpoint (or an exit, if creating the process
1606 fails). Report it now. */
1607 *ourstatus = cached_status;
1608 cached_status.kind = TARGET_WAITKIND_IGNORE;
1609 return debug_event_ptid (&current_event);
1610 }
1611
1612 while (1)
1613 {
1614 if (!get_child_debug_event (ourstatus))
1615 continue;
1616
1617 switch (ourstatus->kind)
1618 {
1619 case TARGET_WAITKIND_EXITED:
1620 OUTMSG2 (("Child exited with retcode = %x\n",
1621 ourstatus->value.integer));
1622 win32_clear_inferiors ();
1623 return pid_to_ptid (current_event.dwProcessId);
1624 case TARGET_WAITKIND_STOPPED:
1625 case TARGET_WAITKIND_LOADED:
1626 OUTMSG2 (("Child Stopped with signal = %d \n",
1627 ourstatus->value.sig));
1628
1629 regcache = get_thread_regcache (current_thread, 1);
1630 child_fetch_inferior_registers (regcache, -1);
1631 return debug_event_ptid (&current_event);
1632 default:
1633 OUTMSG (("Ignoring unknown internal event, %d\n", ourstatus->kind));
1634 /* fall-through */
1635 case TARGET_WAITKIND_SPURIOUS:
1636 case TARGET_WAITKIND_EXECD:
1637 /* do nothing, just continue */
1638 child_continue (DBG_CONTINUE, -1);
1639 break;
1640 }
1641 }
1642}
1643
1644/* Fetch registers from the inferior process.
1645 If REGNO is -1, fetch all registers; otherwise, fetch at least REGNO. */
1646static void
1647win32_fetch_inferior_registers (struct regcache *regcache, int regno)
1648{
1649 child_fetch_inferior_registers (regcache, regno);
1650}
1651
1652/* Store registers to the inferior process.
1653 If REGNO is -1, store all registers; otherwise, store at least REGNO. */
1654static void
1655win32_store_inferior_registers (struct regcache *regcache, int regno)
1656{
1657 child_store_inferior_registers (regcache, regno);
1658}
1659
1660/* Read memory from the inferior process. This should generally be
1661 called through read_inferior_memory, which handles breakpoint shadowing.
1662 Read LEN bytes at MEMADDR into a buffer at MYADDR. */
1663static int
1664win32_read_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
1665{
1666 return child_xfer_memory (memaddr, (char *) myaddr, len, 0, 0) != len;
1667}
1668
1669/* Write memory to the inferior process. This should generally be
1670 called through write_inferior_memory, which handles breakpoint shadowing.
1671 Write LEN bytes from the buffer at MYADDR to MEMADDR.
1672 Returns 0 on success and errno on failure. */
1673static int
1674win32_write_inferior_memory (CORE_ADDR memaddr, const unsigned char *myaddr,
1675 int len)
1676{
1677 return child_xfer_memory (memaddr, (char *) myaddr, len, 1, 0) != len;
1678}
1679
1680/* Send an interrupt request to the inferior process. */
1681static void
1682win32_request_interrupt (void)
1683{
1684 winapi_DebugBreakProcess DebugBreakProcess;
1685 winapi_GenerateConsoleCtrlEvent GenerateConsoleCtrlEvent;
1686
1687#ifdef _WIN32_WCE
1688 HMODULE dll = GetModuleHandle (_T("COREDLL.DLL"));
1689#else
1690 HMODULE dll = GetModuleHandle (_T("KERNEL32.DLL"));
1691#endif
1692
1693 GenerateConsoleCtrlEvent = GETPROCADDRESS (dll, GenerateConsoleCtrlEvent);
1694
1695 if (GenerateConsoleCtrlEvent != NULL
1696 && GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT, current_process_id))
1697 return;
1698
1699 /* GenerateConsoleCtrlEvent can fail if process id being debugged is
1700 not a process group id.
1701 Fallback to XP/Vista 'DebugBreakProcess', which generates a
1702 breakpoint exception in the interior process. */
1703
1704 DebugBreakProcess = GETPROCADDRESS (dll, DebugBreakProcess);
1705
1706 if (DebugBreakProcess != NULL
1707 && DebugBreakProcess (current_process_handle))
1708 return;
1709
1710 /* Last resort, suspend all threads manually. */
1711 soft_interrupt_requested = 1;
1712}
1713
1714#ifdef _WIN32_WCE
1715int
1716win32_error_to_fileio_error (DWORD err)
1717{
1718 switch (err)
1719 {
1720 case ERROR_BAD_PATHNAME:
1721 case ERROR_FILE_NOT_FOUND:
1722 case ERROR_INVALID_NAME:
1723 case ERROR_PATH_NOT_FOUND:
1724 return FILEIO_ENOENT;
1725 case ERROR_CRC:
1726 case ERROR_IO_DEVICE:
1727 case ERROR_OPEN_FAILED:
1728 return FILEIO_EIO;
1729 case ERROR_INVALID_HANDLE:
1730 return FILEIO_EBADF;
1731 case ERROR_ACCESS_DENIED:
1732 case ERROR_SHARING_VIOLATION:
1733 return FILEIO_EACCES;
1734 case ERROR_NOACCESS:
1735 return FILEIO_EFAULT;
1736 case ERROR_BUSY:
1737 return FILEIO_EBUSY;
1738 case ERROR_ALREADY_EXISTS:
1739 case ERROR_FILE_EXISTS:
1740 return FILEIO_EEXIST;
1741 case ERROR_BAD_DEVICE:
1742 return FILEIO_ENODEV;
1743 case ERROR_DIRECTORY:
1744 return FILEIO_ENOTDIR;
1745 case ERROR_FILENAME_EXCED_RANGE:
1746 case ERROR_INVALID_DATA:
1747 case ERROR_INVALID_PARAMETER:
1748 case ERROR_NEGATIVE_SEEK:
1749 return FILEIO_EINVAL;
1750 case ERROR_TOO_MANY_OPEN_FILES:
1751 return FILEIO_EMFILE;
1752 case ERROR_HANDLE_DISK_FULL:
1753 case ERROR_DISK_FULL:
1754 return FILEIO_ENOSPC;
1755 case ERROR_WRITE_PROTECT:
1756 return FILEIO_EROFS;
1757 case ERROR_NOT_SUPPORTED:
1758 return FILEIO_ENOSYS;
1759 }
1760
1761 return FILEIO_EUNKNOWN;
1762}
1763
1764static void
1765wince_hostio_last_error (char *buf)
1766{
1767 DWORD winerr = GetLastError ();
1768 int fileio_err = win32_error_to_fileio_error (winerr);
1769 sprintf (buf, "F-1,%x", fileio_err);
1770}
1771#endif
1772
1773/* Write Windows OS Thread Information Block address. */
1774
1775static int
1776win32_get_tib_address (ptid_t ptid, CORE_ADDR *addr)
1777{
1778 win32_thread_info *th;
1779 th = thread_rec (ptid, 0);
1780 if (th == NULL)
1781 return 0;
1782 if (addr != NULL)
1783 *addr = th->thread_local_base;
1784 return 1;
1785}
1786
1787/* Implementation of the target_ops method "sw_breakpoint_from_kind". */
1788
1789static const gdb_byte *
1790win32_sw_breakpoint_from_kind (int kind, int *size)
1791{
1792 *size = the_low_target.breakpoint_len;
1793 return the_low_target.breakpoint;
1794}
1795
1796static struct target_ops win32_target_ops = {
1797 win32_create_inferior,
1798 NULL, /* arch_setup */
1799 win32_attach,
1800 win32_kill,
1801 win32_detach,
1802 win32_mourn,
1803 win32_join,
1804 win32_thread_alive,
1805 win32_resume,
1806 win32_wait,
1807 win32_fetch_inferior_registers,
1808 win32_store_inferior_registers,
1809 NULL, /* prepare_to_access_memory */
1810 NULL, /* done_accessing_memory */
1811 win32_read_inferior_memory,
1812 win32_write_inferior_memory,
1813 NULL, /* lookup_symbols */
1814 win32_request_interrupt,
1815 NULL, /* read_auxv */
1816 win32_supports_z_point_type,
1817 win32_insert_point,
1818 win32_remove_point,
1819 NULL, /* stopped_by_sw_breakpoint */
1820 NULL, /* supports_stopped_by_sw_breakpoint */
1821 NULL, /* stopped_by_hw_breakpoint */
1822 NULL, /* supports_stopped_by_hw_breakpoint */
1823 target_can_do_hardware_single_step,
1824 win32_stopped_by_watchpoint,
1825 win32_stopped_data_address,
1826 NULL, /* read_offsets */
1827 NULL, /* get_tls_address */
1828 NULL, /* qxfer_spu */
1829#ifdef _WIN32_WCE
1830 wince_hostio_last_error,
1831#else
1832 hostio_last_error_from_errno,
1833#endif
1834 NULL, /* qxfer_osdata */
1835 NULL, /* qxfer_siginfo */
1836 NULL, /* supports_non_stop */
1837 NULL, /* async */
1838 NULL, /* start_non_stop */
1839 NULL, /* supports_multi_process */
1840 NULL, /* supports_fork_events */
1841 NULL, /* supports_vfork_events */
1842 NULL, /* supports_exec_events */
1843 NULL, /* handle_new_gdb_connection */
1844 NULL, /* handle_monitor_command */
1845 NULL, /* core_of_thread */
1846 NULL, /* read_loadmap */
1847 NULL, /* process_qsupported */
1848 NULL, /* supports_tracepoints */
1849 NULL, /* read_pc */
1850 NULL, /* write_pc */
1851 NULL, /* thread_stopped */
1852 win32_get_tib_address,
1853 NULL, /* pause_all */
1854 NULL, /* unpause_all */
1855 NULL, /* stabilize_threads */
1856 NULL, /* install_fast_tracepoint_jump_pad */
1857 NULL, /* emit_ops */
1858 NULL, /* supports_disable_randomization */
1859 NULL, /* get_min_fast_tracepoint_insn_len */
1860 NULL, /* qxfer_libraries_svr4 */
1861 NULL, /* support_agent */
1862 NULL, /* support_btrace */
1863 NULL, /* enable_btrace */
1864 NULL, /* disable_btrace */
1865 NULL, /* read_btrace */
1866 NULL, /* read_btrace_conf */
1867 NULL, /* supports_range_stepping */
1868 NULL, /* pid_to_exec_file */
1869 NULL, /* multifs_open */
1870 NULL, /* multifs_unlink */
1871 NULL, /* multifs_readlink */
1872 NULL, /* breakpoint_kind_from_pc */
1873 win32_sw_breakpoint_from_kind,
1874};
1875
1876/* Initialize the Win32 backend. */
1877void
1878initialize_low (void)
1879{
1880 set_target_ops (&win32_target_ops);
1881 the_low_target.arch_setup ();
1882}
GDB Binutils - Deliverables
This page took 0.068237 seconds and 4 git commands to generate.