1 /* Target-vector operations for controlling windows child processes, for GDB.
3 Copyright (C) 1995-2014 Free Software Foundation, Inc.
5 Contributed by Cygnus Solutions, A Red Hat Company.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 /* Originally by Steve Chamberlain, sac@cygnus.com */
25 #include "frame.h" /* required by inferior.h */
28 #include "exceptions.h"
31 #include "completer.h"
35 #include <sys/types.h>
43 #include <sys/cygwin.h>
44 #include <cygwin/version.h>
48 #include "filenames.h"
52 #include "gdb_obstack.h"
54 #include "gdbthread.h"
60 #include "xml-support.h"
62 #include "i386-tdep.h"
63 #include "i387-tdep.h"
65 #include "windows-tdep.h"
66 #include "windows-nat.h"
68 #include "complaints.h"
70 #define AdjustTokenPrivileges dyn_AdjustTokenPrivileges
71 #define DebugActiveProcessStop dyn_DebugActiveProcessStop
72 #define DebugBreakProcess dyn_DebugBreakProcess
73 #define DebugSetProcessKillOnExit dyn_DebugSetProcessKillOnExit
74 #define EnumProcessModules dyn_EnumProcessModules
75 #define GetModuleInformation dyn_GetModuleInformation
76 #define LookupPrivilegeValueA dyn_LookupPrivilegeValueA
77 #define OpenProcessToken dyn_OpenProcessToken
78 #define GetConsoleFontSize dyn_GetConsoleFontSize
79 #define GetCurrentConsoleFont dyn_GetCurrentConsoleFont
81 static BOOL WINAPI (*AdjustTokenPrivileges)(HANDLE, BOOL, PTOKEN_PRIVILEGES,
82 DWORD, PTOKEN_PRIVILEGES, PDWORD);
83 static BOOL WINAPI (*DebugActiveProcessStop) (DWORD);
84 static BOOL WINAPI (*DebugBreakProcess) (HANDLE);
85 static BOOL WINAPI (*DebugSetProcessKillOnExit) (BOOL);
86 static BOOL WINAPI (*EnumProcessModules) (HANDLE, HMODULE *, DWORD,
88 static BOOL WINAPI (*GetModuleInformation) (HANDLE, HMODULE, LPMODULEINFO,
90 static BOOL WINAPI (*LookupPrivilegeValueA)(LPCSTR, LPCSTR, PLUID);
91 static BOOL WINAPI (*OpenProcessToken)(HANDLE, DWORD, PHANDLE);
92 static BOOL WINAPI (*GetCurrentConsoleFont) (HANDLE, BOOL,
94 static COORD WINAPI (*GetConsoleFontSize) (HANDLE, DWORD);
96 static struct target_ops windows_ops;
100 #undef GetModuleFileNameEx
103 # define __PMAX (MAX_PATH + 1)
104 static DWORD WINAPI (*GetModuleFileNameEx) (HANDLE, HMODULE, LPSTR, DWORD);
105 # define STARTUPINFO STARTUPINFOA
106 # define CreateProcess CreateProcessA
107 # define GetModuleFileNameEx_name "GetModuleFileNameExA"
108 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
110 # define __PMAX PATH_MAX
111 /* The starting and ending address of the cygwin1.dll text segment. */
112 static CORE_ADDR cygwin_load_start;
113 static CORE_ADDR cygwin_load_end;
115 typedef wchar_t cygwin_buf_t;
116 static DWORD WINAPI (*GetModuleFileNameEx) (HANDLE, HMODULE,
118 # define STARTUPINFO STARTUPINFOW
119 # define CreateProcess CreateProcessW
120 # define GetModuleFileNameEx_name "GetModuleFileNameExW"
121 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExW
124 static int have_saved_context; /* True if we've saved context from a
126 static CONTEXT saved_context; /* Containes the saved context from a
129 /* If we're not using the old Cygwin header file set, define the
130 following which never should have been in the generic Win32 API
131 headers in the first place since they were our own invention... */
132 #ifndef _GNU_H_WINDOWS_H
135 FLAG_TRACE_BIT = 0x100,
136 CONTEXT_DEBUGGER = (CONTEXT_FULL | CONTEXT_FLOATING_POINT)
140 #ifndef CONTEXT_EXTENDED_REGISTERS
141 /* This macro is only defined on ia32. It only makes sense on this target,
142 so define it as zero if not already defined. */
143 #define CONTEXT_EXTENDED_REGISTERS 0
146 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \
147 | CONTEXT_EXTENDED_REGISTERS
149 static uintptr_t dr[8];
150 static int debug_registers_changed;
151 static int debug_registers_used;
153 static int windows_initialization_done;
154 #define DR6_CLEAR_VALUE 0xffff0ff0
156 /* The string sent by cygwin when it processes a signal.
157 FIXME: This should be in a cygwin include file. */
158 #ifndef _CYGWIN_SIGNAL_STRING
159 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
162 #define CHECK(x) check (x, __FILE__,__LINE__)
163 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
164 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
165 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
166 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
168 static void windows_stop (struct target_ops *self, ptid_t);
169 static int windows_thread_alive (struct target_ops *, ptid_t);
170 static void windows_kill_inferior (struct target_ops *);
172 static void cygwin_set_dr (int i, CORE_ADDR addr);
173 static void cygwin_set_dr7 (unsigned long val);
174 static CORE_ADDR cygwin_get_dr (int i);
175 static unsigned long cygwin_get_dr6 (void);
176 static unsigned long cygwin_get_dr7 (void);
178 static enum gdb_signal last_sig = GDB_SIGNAL_0;
179 /* Set if a signal was received from the debugged process. */
181 /* Thread information structure used to track information that is
182 not available in gdb's thread structure. */
183 typedef struct thread_info_struct
185 struct thread_info_struct *next;
188 CORE_ADDR thread_local_base;
197 static thread_info thread_head;
199 /* The process and thread handles for the above context. */
201 static DEBUG_EVENT current_event; /* The current debug event from
203 static HANDLE current_process_handle; /* Currently executing process */
204 static thread_info *current_thread; /* Info on currently selected thread */
205 static DWORD main_thread_id; /* Thread ID of the main thread */
207 /* Counts of things. */
208 static int exception_count = 0;
209 static int event_count = 0;
210 static int saw_create;
211 static int open_process_used = 0;
214 static int new_console = 0;
216 static int cygwin_exceptions = 0;
218 static int new_group = 1;
219 static int debug_exec = 0; /* show execution */
220 static int debug_events = 0; /* show events from kernel */
221 static int debug_memory = 0; /* show target memory accesses */
222 static int debug_exceptions = 0; /* show target exceptions */
223 static int useshell = 0; /* use shell for subprocesses */
225 /* This vector maps GDB's idea of a register's number into an offset
226 in the windows exception context vector.
228 It also contains the bit mask needed to load the register in question.
230 The contents of this table can only be computed by the units
231 that provide CPU-specific support for Windows native debugging.
232 These units should set the table by calling
233 windows_set_context_register_offsets.
235 One day we could read a reg, we could inspect the context we
236 already have loaded, if it doesn't have the bit set that we need,
237 we read that set of registers in using GetThreadContext. If the
238 context already contains what we need, we just unpack it. Then to
239 write a register, first we have to ensure that the context contains
240 the other regs of the group, and then we copy the info in and set
243 static const int *mappings;
245 /* The function to use in order to determine whether a register is
246 a segment register or not. */
247 static segment_register_p_ftype *segment_register_p;
249 /* This vector maps the target's idea of an exception (extracted
250 from the DEBUG_EVENT structure) to GDB's idea. */
252 struct xlate_exception
258 static const struct xlate_exception
261 {EXCEPTION_ACCESS_VIOLATION, GDB_SIGNAL_SEGV},
262 {STATUS_STACK_OVERFLOW, GDB_SIGNAL_SEGV},
263 {EXCEPTION_BREAKPOINT, GDB_SIGNAL_TRAP},
264 {DBG_CONTROL_C, GDB_SIGNAL_INT},
265 {EXCEPTION_SINGLE_STEP, GDB_SIGNAL_TRAP},
266 {STATUS_FLOAT_DIVIDE_BY_ZERO, GDB_SIGNAL_FPE},
269 /* Set the MAPPINGS static global to OFFSETS.
270 See the description of MAPPINGS for more details. */
273 windows_set_context_register_offsets (const int *offsets)
278 /* See windows-nat.h. */
281 windows_set_segment_register_p (segment_register_p_ftype *fun)
283 segment_register_p = fun;
287 check (BOOL ok, const char *file, int line)
290 printf_filtered ("error return %s:%d was %u\n", file, line,
291 (unsigned) GetLastError ());
294 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
295 then also retrieve the context for this thread. If GET_CONTEXT is
296 negative, then don't suspend the thread. */
298 thread_rec (DWORD id, int get_context)
302 for (th = &thread_head; (th = th->next) != NULL;)
305 if (!th->suspended && get_context)
307 if (get_context > 0 && id != current_event.dwThreadId)
309 if (SuspendThread (th->h) == (DWORD) -1)
311 DWORD err = GetLastError ();
313 warning (_("SuspendThread (tid=0x%x) failed."
315 (unsigned) id, (unsigned) err);
320 else if (get_context < 0)
322 th->reload_context = 1;
330 /* Add a thread to the thread list. */
332 windows_add_thread (ptid_t ptid, HANDLE h, void *tlb)
337 gdb_assert (ptid_get_tid (ptid) != 0);
339 id = ptid_get_tid (ptid);
341 if ((th = thread_rec (id, FALSE)))
344 th = XCNEW (thread_info);
347 th->thread_local_base = (CORE_ADDR) (uintptr_t) tlb;
348 th->next = thread_head.next;
349 thread_head.next = th;
351 /* Set the debug registers for the new thread if they are used. */
352 if (debug_registers_used)
354 /* Only change the value of the debug registers. */
355 th->context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
356 CHECK (GetThreadContext (th->h, &th->context));
357 th->context.Dr0 = dr[0];
358 th->context.Dr1 = dr[1];
359 th->context.Dr2 = dr[2];
360 th->context.Dr3 = dr[3];
361 th->context.Dr6 = DR6_CLEAR_VALUE;
362 th->context.Dr7 = dr[7];
363 CHECK (SetThreadContext (th->h, &th->context));
364 th->context.ContextFlags = 0;
369 /* Clear out any old thread list and reintialize it to a
372 windows_init_thread_list (void)
374 thread_info *th = &thread_head;
376 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
378 while (th->next != NULL)
380 thread_info *here = th->next;
381 th->next = here->next;
384 thread_head.next = NULL;
387 /* Delete a thread from the list of threads. */
389 windows_delete_thread (ptid_t ptid, DWORD exit_code)
394 gdb_assert (ptid_get_tid (ptid) != 0);
396 id = ptid_get_tid (ptid);
399 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid));
400 else if (print_thread_events && id != main_thread_id)
401 printf_unfiltered (_("[%s exited with code %u]\n"),
402 target_pid_to_str (ptid), (unsigned) exit_code);
403 delete_thread (ptid);
405 for (th = &thread_head;
406 th->next != NULL && th->next->id != id;
410 if (th->next != NULL)
412 thread_info *here = th->next;
413 th->next = here->next;
419 do_windows_fetch_inferior_registers (struct regcache *regcache, int r)
421 char *context_offset = ((char *) ¤t_thread->context) + mappings[r];
422 struct gdbarch *gdbarch = get_regcache_arch (regcache);
423 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
427 return; /* Windows sometimes uses a non-existent thread id in its
430 if (current_thread->reload_context)
432 #ifdef __COPY_CONTEXT_SIZE
433 if (have_saved_context)
435 /* Lie about where the program actually is stopped since
436 cygwin has informed us that we should consider the signal
437 to have occurred at another location which is stored in
439 memcpy (¤t_thread->context, &saved_context,
440 __COPY_CONTEXT_SIZE);
441 have_saved_context = 0;
446 thread_info *th = current_thread;
447 th->context.ContextFlags = CONTEXT_DEBUGGER_DR;
448 GetThreadContext (th->h, &th->context);
449 /* Copy dr values from that thread.
450 But only if there were not modified since last stop.
452 if (!debug_registers_changed)
454 dr[0] = th->context.Dr0;
455 dr[1] = th->context.Dr1;
456 dr[2] = th->context.Dr2;
457 dr[3] = th->context.Dr3;
458 dr[6] = th->context.Dr6;
459 dr[7] = th->context.Dr7;
462 current_thread->reload_context = 0;
465 if (r == I387_FISEG_REGNUM (tdep))
467 l = *((long *) context_offset) & 0xffff;
468 regcache_raw_supply (regcache, r, (char *) &l);
470 else if (r == I387_FOP_REGNUM (tdep))
472 l = (*((long *) context_offset) >> 16) & ((1 << 11) - 1);
473 regcache_raw_supply (regcache, r, (char *) &l);
475 else if (segment_register_p (r))
477 /* GDB treats segment registers as 32bit registers, but they are
478 in fact only 16 bits long. Make sure we do not read extra
479 bits from our source buffer. */
480 l = *((long *) context_offset) & 0xffff;
481 regcache_raw_supply (regcache, r, (char *) &l);
484 regcache_raw_supply (regcache, r, context_offset);
487 for (r = 0; r < gdbarch_num_regs (gdbarch); r++)
488 do_windows_fetch_inferior_registers (regcache, r);
493 windows_fetch_inferior_registers (struct target_ops *ops,
494 struct regcache *regcache, int r)
496 current_thread = thread_rec (ptid_get_tid (inferior_ptid), TRUE);
497 /* Check if current_thread exists. Windows sometimes uses a non-existent
498 thread id in its events. */
500 do_windows_fetch_inferior_registers (regcache, r);
504 do_windows_store_inferior_registers (const struct regcache *regcache, int r)
507 /* Windows sometimes uses a non-existent thread id in its events. */;
509 regcache_raw_collect (regcache, r,
510 ((char *) ¤t_thread->context) + mappings[r]);
513 for (r = 0; r < gdbarch_num_regs (get_regcache_arch (regcache)); r++)
514 do_windows_store_inferior_registers (regcache, r);
518 /* Store a new register value into the current thread context. */
520 windows_store_inferior_registers (struct target_ops *ops,
521 struct regcache *regcache, int r)
523 current_thread = thread_rec (ptid_get_tid (inferior_ptid), TRUE);
524 /* Check if current_thread exists. Windows sometimes uses a non-existent
525 thread id in its events. */
527 do_windows_store_inferior_registers (regcache, r);
530 /* Encapsulate the information required in a call to
531 symbol_file_add_args. */
532 struct safe_symbol_file_add_args
536 struct section_addr_info *addrs;
539 struct ui_file *err, *out;
543 /* Maintain a linked list of "so" information. */
549 static struct so_list solib_start, *solib_end;
551 /* Call symbol_file_add with stderr redirected. We don't care if there
554 safe_symbol_file_add_stub (void *argv)
556 #define p ((struct safe_symbol_file_add_args *) argv)
557 const int add_flags = ((p->from_tty ? SYMFILE_VERBOSE : 0)
558 | (p->mainline ? SYMFILE_MAINLINE : 0));
559 p->ret = symbol_file_add (p->name, add_flags, p->addrs, p->flags);
564 /* Restore gdb's stderr after calling symbol_file_add. */
566 safe_symbol_file_add_cleanup (void *p)
568 #define sp ((struct safe_symbol_file_add_args *)p)
569 gdb_flush (gdb_stderr);
570 gdb_flush (gdb_stdout);
571 ui_file_delete (gdb_stderr);
572 ui_file_delete (gdb_stdout);
573 gdb_stderr = sp->err;
574 gdb_stdout = sp->out;
578 /* symbol_file_add wrapper that prevents errors from being displayed. */
579 static struct objfile *
580 safe_symbol_file_add (char *name, int from_tty,
581 struct section_addr_info *addrs,
582 int mainline, int flags)
584 struct safe_symbol_file_add_args p;
585 struct cleanup *cleanup;
587 cleanup = make_cleanup (safe_symbol_file_add_cleanup, &p);
591 gdb_flush (gdb_stderr);
592 gdb_flush (gdb_stdout);
593 gdb_stderr = ui_file_new ();
594 gdb_stdout = ui_file_new ();
596 p.from_tty = from_tty;
598 p.mainline = mainline;
600 catch_errors (safe_symbol_file_add_stub, &p, "", RETURN_MASK_ERROR);
602 do_cleanups (cleanup);
606 static struct so_list *
607 windows_make_so (const char *name, LPVOID load_addr)
614 WIN32_FIND_DATA w32_fd;
615 HANDLE h = FindFirstFile(name, &w32_fd);
617 if (h == INVALID_HANDLE_VALUE)
623 if (GetCurrentDirectory (MAX_PATH + 1, cwd))
625 p = strrchr (buf, '\\');
628 SetCurrentDirectory (buf);
629 GetFullPathName (w32_fd.cFileName, MAX_PATH, buf, &p);
630 SetCurrentDirectory (cwd);
633 if (strcasecmp (buf, "ntdll.dll") == 0)
635 GetSystemDirectory (buf, sizeof (buf));
636 strcat (buf, "\\ntdll.dll");
639 cygwin_buf_t buf[__PMAX];
642 if (access (name, F_OK) != 0)
644 if (strcasecmp (name, "ntdll.dll") == 0)
647 GetSystemDirectoryW (buf, sizeof (buf) / sizeof (wchar_t));
648 wcscat (buf, L"\\ntdll.dll");
652 GetSystemDirectoryA (buf, sizeof (buf) / sizeof (wchar_t));
653 strcat (buf, "\\ntdll.dll");
658 so = XCNEW (struct so_list);
659 so->lm_info = (struct lm_info *) xmalloc (sizeof (struct lm_info));
660 so->lm_info->load_addr = load_addr;
661 strcpy (so->so_original_name, name);
663 strcpy (so->so_name, buf);
666 cygwin_conv_path (CCP_WIN_W_TO_POSIX, buf, so->so_name,
667 SO_NAME_MAX_PATH_SIZE);
670 char *rname = realpath (name, NULL);
671 if (rname && strlen (rname) < SO_NAME_MAX_PATH_SIZE)
673 strcpy (so->so_name, rname);
677 error (_("dll path too long"));
679 /* Record cygwin1.dll .text start/end. */
680 p = strchr (so->so_name, '\0') - (sizeof ("/cygwin1.dll") - 1);
681 if (p >= so->so_name && strcasecmp (p, "/cygwin1.dll") == 0)
684 asection *text = NULL;
687 abfd = gdb_bfd_open (so->so_name, "pei-i386", -1);
692 if (bfd_check_format (abfd, bfd_object))
693 text = bfd_get_section_by_name (abfd, ".text");
697 gdb_bfd_unref (abfd);
701 /* The symbols in a dll are offset by 0x1000, which is the
702 offset from 0 of the first byte in an image - because of the
703 file header and the section alignment. */
704 cygwin_load_start = (CORE_ADDR) (uintptr_t) ((char *)
706 cygwin_load_end = cygwin_load_start + bfd_section_size (abfd, text);
708 gdb_bfd_unref (abfd);
716 get_image_name (HANDLE h, void *address, int unicode)
719 static char buf[__PMAX];
721 static char buf[(2 * __PMAX) + 1];
723 DWORD size = unicode ? sizeof (WCHAR) : sizeof (char);
729 /* Attempt to read the name of the dll that was detected.
730 This is documented to work only when actively debugging
731 a program. It will not work for attached processes. */
735 /* See if we could read the address of a string, and that the
736 address isn't null. */
737 if (!ReadProcessMemory (h, address, &address_ptr,
738 sizeof (address_ptr), &done)
739 || done != sizeof (address_ptr) || !address_ptr)
742 /* Find the length of the string. */
743 while (ReadProcessMemory (h, address_ptr + len++ * size, &b, size, &done)
744 && (b[0] != 0 || b[size - 1] != 0) && done == size)
748 ReadProcessMemory (h, address_ptr, buf, len, &done);
751 WCHAR *unicode_address = (WCHAR *) alloca (len * sizeof (WCHAR));
752 ReadProcessMemory (h, address_ptr, unicode_address, len * sizeof (WCHAR),
755 wcstombs (buf, unicode_address, __PMAX);
757 WideCharToMultiByte (CP_ACP, 0, unicode_address, len, buf, sizeof buf,
765 /* Handle a DLL load event, and return 1.
767 This function assumes that this event did not occur during inferior
768 initialization, where their event info may be incomplete (see
769 do_initial_windows_stuff and windows_add_all_dlls for more info
770 on how we handle DLL loading during that phase). */
773 handle_load_dll (void *dummy)
775 LOAD_DLL_DEBUG_INFO *event = ¤t_event.u.LoadDll;
778 /* Try getting the DLL name via the lpImageName field of the event.
779 Note that Microsoft documents this fields as strictly optional,
780 in the sense that it might be NULL. And the first DLL event in
781 particular is explicitly documented as "likely not pass[ed]"
782 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
783 dll_name = get_image_name (current_process_handle,
784 event->lpImageName, event->fUnicode);
788 solib_end->next = windows_make_so (dll_name, event->lpBaseOfDll);
789 solib_end = solib_end->next;
791 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end->so_name,
792 host_address_to_string (solib_end->lm_info->load_addr)));
798 windows_free_so (struct so_list *so)
805 /* Handle a DLL unload event.
806 Return 1 if successful, or zero otherwise.
808 This function assumes that this event did not occur during inferior
809 initialization, where their event info may be incomplete (see
810 do_initial_windows_stuff and windows_add_all_dlls for more info
811 on how we handle DLL loading during that phase). */
814 handle_unload_dll (void *dummy)
816 LPVOID lpBaseOfDll = current_event.u.UnloadDll.lpBaseOfDll;
819 for (so = &solib_start; so->next != NULL; so = so->next)
820 if (so->next->lm_info->load_addr == lpBaseOfDll)
822 struct so_list *sodel = so->next;
824 so->next = sodel->next;
827 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel->so_name));
829 windows_free_so (sodel);
833 /* We did not find any DLL that was previously loaded at this address,
834 so register a complaint. We do not report an error, because we have
835 observed that this may be happening under some circumstances. For
836 instance, running 32bit applications on x64 Windows causes us to receive
837 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
838 events are apparently caused by the WOW layer, the interface between
839 32bit and 64bit worlds). */
840 complaint (&symfile_complaints, _("dll starting at %s not found."),
841 host_address_to_string (lpBaseOfDll));
846 /* Clear list of loaded DLLs. */
848 windows_clear_solib (void)
850 solib_start.next = NULL;
851 solib_end = &solib_start;
854 /* Load DLL symbol info. */
856 dll_symbol_command (char *args, int from_tty)
862 error (_("dll-symbols requires a file name"));
865 if (n > 4 && strcasecmp (args + n - 4, ".dll") != 0)
867 char *newargs = (char *) alloca (n + 4 + 1);
868 strcpy (newargs, args);
869 strcat (newargs, ".dll");
873 safe_symbol_file_add (args, from_tty, NULL, 0, OBJF_SHARED | OBJF_USERLOADED);
876 /* Handle DEBUG_STRING output from child process.
877 Cygwin prepends its messages with a "cygwin:". Interpret this as
878 a Cygwin signal. Otherwise just print the string as a warning. */
880 handle_output_debug_string (struct target_waitstatus *ourstatus)
885 if (!target_read_string
886 ((CORE_ADDR) (uintptr_t) current_event.u.DebugString.lpDebugStringData,
890 else if (strncmp (s, _CYGWIN_SIGNAL_STRING,
891 sizeof (_CYGWIN_SIGNAL_STRING) - 1) != 0)
894 if (strncmp (s, "cYg", 3) != 0)
898 #ifdef __COPY_CONTEXT_SIZE
901 /* Got a cygwin signal marker. A cygwin signal is followed by
902 the signal number itself and then optionally followed by the
903 thread id and address to saved context within the DLL. If
904 these are supplied, then the given thread is assumed to have
905 issued the signal and the context from the thread is assumed
906 to be stored at the given address in the inferior. Tell gdb
907 to treat this like a real signal. */
909 int sig = strtol (s + sizeof (_CYGWIN_SIGNAL_STRING) - 1, &p, 0);
910 int gotasig = gdb_signal_from_host (sig);
912 ourstatus->value.sig = gotasig;
918 ourstatus->kind = TARGET_WAITKIND_STOPPED;
919 retval = strtoul (p, &p, 0);
921 retval = main_thread_id;
922 else if ((x = (LPCVOID) (uintptr_t) strtoull (p, NULL, 0))
923 && ReadProcessMemory (current_process_handle, x,
925 __COPY_CONTEXT_SIZE, &n)
926 && n == __COPY_CONTEXT_SIZE)
927 have_saved_context = 1;
928 current_event.dwThreadId = retval;
939 display_selector (HANDLE thread, DWORD sel)
942 if (GetThreadSelectorEntry (thread, sel, &info))
945 printf_filtered ("0x%03x: ", (unsigned) sel);
946 if (!info.HighWord.Bits.Pres)
948 puts_filtered ("Segment not present\n");
951 base = (info.HighWord.Bits.BaseHi << 24) +
952 (info.HighWord.Bits.BaseMid << 16)
954 limit = (info.HighWord.Bits.LimitHi << 16) + info.LimitLow;
955 if (info.HighWord.Bits.Granularity)
956 limit = (limit << 12) | 0xfff;
957 printf_filtered ("base=0x%08x limit=0x%08x", base, limit);
958 if (info.HighWord.Bits.Default_Big)
959 puts_filtered(" 32-bit ");
961 puts_filtered(" 16-bit ");
962 switch ((info.HighWord.Bits.Type & 0xf) >> 1)
965 puts_filtered ("Data (Read-Only, Exp-up");
968 puts_filtered ("Data (Read/Write, Exp-up");
971 puts_filtered ("Unused segment (");
974 puts_filtered ("Data (Read/Write, Exp-down");
977 puts_filtered ("Code (Exec-Only, N.Conf");
980 puts_filtered ("Code (Exec/Read, N.Conf");
983 puts_filtered ("Code (Exec-Only, Conf");
986 puts_filtered ("Code (Exec/Read, Conf");
989 printf_filtered ("Unknown type 0x%x",info.HighWord.Bits.Type);
991 if ((info.HighWord.Bits.Type & 0x1) == 0)
992 puts_filtered(", N.Acc");
993 puts_filtered (")\n");
994 if ((info.HighWord.Bits.Type & 0x10) == 0)
995 puts_filtered("System selector ");
996 printf_filtered ("Priviledge level = %d. ", info.HighWord.Bits.Dpl);
997 if (info.HighWord.Bits.Granularity)
998 puts_filtered ("Page granular.\n");
1000 puts_filtered ("Byte granular.\n");
1005 DWORD err = GetLastError ();
1006 if (err == ERROR_NOT_SUPPORTED)
1007 printf_filtered ("Function not supported\n");
1009 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel);
1015 display_selectors (char * args, int from_tty)
1017 if (!current_thread)
1019 puts_filtered ("Impossible to display selectors now.\n");
1025 puts_filtered ("Selector $cs\n");
1026 display_selector (current_thread->h,
1027 current_thread->context.SegCs);
1028 puts_filtered ("Selector $ds\n");
1029 display_selector (current_thread->h,
1030 current_thread->context.SegDs);
1031 puts_filtered ("Selector $es\n");
1032 display_selector (current_thread->h,
1033 current_thread->context.SegEs);
1034 puts_filtered ("Selector $ss\n");
1035 display_selector (current_thread->h,
1036 current_thread->context.SegSs);
1037 puts_filtered ("Selector $fs\n");
1038 display_selector (current_thread->h,
1039 current_thread->context.SegFs);
1040 puts_filtered ("Selector $gs\n");
1041 display_selector (current_thread->h,
1042 current_thread->context.SegGs);
1047 sel = parse_and_eval_long (args);
1048 printf_filtered ("Selector \"%s\"\n",args);
1049 display_selector (current_thread->h, sel);
1053 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1054 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1055 host_address_to_string (\
1056 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1059 handle_exception (struct target_waitstatus *ourstatus)
1062 DWORD code = current_event.u.Exception.ExceptionRecord.ExceptionCode;
1064 ourstatus->kind = TARGET_WAITKIND_STOPPED;
1066 /* Record the context of the current thread. */
1067 th = thread_rec (current_event.dwThreadId, -1);
1071 case EXCEPTION_ACCESS_VIOLATION:
1072 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1073 ourstatus->value.sig = GDB_SIGNAL_SEGV;
1076 /* See if the access violation happened within the cygwin DLL
1077 itself. Cygwin uses a kind of exception handling to deal
1078 with passed-in invalid addresses. gdb should not treat
1079 these as real SEGVs since they will be silently handled by
1080 cygwin. A real SEGV will (theoretically) be caught by
1081 cygwin later in the process and will be sent as a
1082 cygwin-specific-signal. So, ignore SEGVs if they show up
1083 within the text segment of the DLL itself. */
1085 CORE_ADDR addr = (CORE_ADDR) (uintptr_t)
1086 current_event.u.Exception.ExceptionRecord.ExceptionAddress;
1088 if ((!cygwin_exceptions && (addr >= cygwin_load_start
1089 && addr < cygwin_load_end))
1090 || (find_pc_partial_function (addr, &fn, NULL, NULL)
1091 && strncmp (fn, "KERNEL32!IsBad",
1092 strlen ("KERNEL32!IsBad")) == 0))
1097 case STATUS_STACK_OVERFLOW:
1098 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1099 ourstatus->value.sig = GDB_SIGNAL_SEGV;
1101 case STATUS_FLOAT_DENORMAL_OPERAND:
1102 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1103 ourstatus->value.sig = GDB_SIGNAL_FPE;
1105 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
1106 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1107 ourstatus->value.sig = GDB_SIGNAL_FPE;
1109 case STATUS_FLOAT_INEXACT_RESULT:
1110 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1111 ourstatus->value.sig = GDB_SIGNAL_FPE;
1113 case STATUS_FLOAT_INVALID_OPERATION:
1114 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1115 ourstatus->value.sig = GDB_SIGNAL_FPE;
1117 case STATUS_FLOAT_OVERFLOW:
1118 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1119 ourstatus->value.sig = GDB_SIGNAL_FPE;
1121 case STATUS_FLOAT_STACK_CHECK:
1122 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1123 ourstatus->value.sig = GDB_SIGNAL_FPE;
1125 case STATUS_FLOAT_UNDERFLOW:
1126 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1127 ourstatus->value.sig = GDB_SIGNAL_FPE;
1129 case STATUS_FLOAT_DIVIDE_BY_ZERO:
1130 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1131 ourstatus->value.sig = GDB_SIGNAL_FPE;
1133 case STATUS_INTEGER_DIVIDE_BY_ZERO:
1134 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1135 ourstatus->value.sig = GDB_SIGNAL_FPE;
1137 case STATUS_INTEGER_OVERFLOW:
1138 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1139 ourstatus->value.sig = GDB_SIGNAL_FPE;
1141 case EXCEPTION_BREAKPOINT:
1142 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1143 ourstatus->value.sig = GDB_SIGNAL_TRAP;
1146 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1147 ourstatus->value.sig = GDB_SIGNAL_INT;
1149 case DBG_CONTROL_BREAK:
1150 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1151 ourstatus->value.sig = GDB_SIGNAL_INT;
1153 case EXCEPTION_SINGLE_STEP:
1154 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1155 ourstatus->value.sig = GDB_SIGNAL_TRAP;
1157 case EXCEPTION_ILLEGAL_INSTRUCTION:
1158 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1159 ourstatus->value.sig = GDB_SIGNAL_ILL;
1161 case EXCEPTION_PRIV_INSTRUCTION:
1162 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1163 ourstatus->value.sig = GDB_SIGNAL_ILL;
1165 case EXCEPTION_NONCONTINUABLE_EXCEPTION:
1166 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1167 ourstatus->value.sig = GDB_SIGNAL_ILL;
1170 /* Treat unhandled first chance exceptions specially. */
1171 if (current_event.u.Exception.dwFirstChance)
1173 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1174 (unsigned) current_event.u.Exception.ExceptionRecord.ExceptionCode,
1175 host_address_to_string (
1176 current_event.u.Exception.ExceptionRecord.ExceptionAddress));
1177 ourstatus->value.sig = GDB_SIGNAL_UNKNOWN;
1181 last_sig = ourstatus->value.sig;
1185 /* Resume all artificially suspended threads if we are continuing
1188 windows_continue (DWORD continue_status, int id)
1194 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1195 (unsigned) current_event.dwProcessId,
1196 (unsigned) current_event.dwThreadId,
1197 continue_status == DBG_CONTINUE ?
1198 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1200 for (th = &thread_head; (th = th->next) != NULL;)
1201 if ((id == -1 || id == (int) th->id)
1204 if (debug_registers_changed)
1206 th->context.ContextFlags |= CONTEXT_DEBUG_REGISTERS;
1207 th->context.Dr0 = dr[0];
1208 th->context.Dr1 = dr[1];
1209 th->context.Dr2 = dr[2];
1210 th->context.Dr3 = dr[3];
1211 th->context.Dr6 = DR6_CLEAR_VALUE;
1212 th->context.Dr7 = dr[7];
1214 if (th->context.ContextFlags)
1216 CHECK (SetThreadContext (th->h, &th->context));
1217 th->context.ContextFlags = 0;
1219 if (th->suspended > 0)
1220 (void) ResumeThread (th->h);
1224 res = ContinueDebugEvent (current_event.dwProcessId,
1225 current_event.dwThreadId,
1228 debug_registers_changed = 0;
1232 /* Called in pathological case where Windows fails to send a
1233 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1235 fake_create_process (void)
1237 current_process_handle = OpenProcess (PROCESS_ALL_ACCESS, FALSE,
1238 current_event.dwProcessId);
1239 if (current_process_handle != NULL)
1240 open_process_used = 1;
1243 error (_("OpenProcess call failed, GetLastError = %u"),
1244 (unsigned) GetLastError ());
1245 /* We can not debug anything in that case. */
1247 main_thread_id = current_event.dwThreadId;
1248 current_thread = windows_add_thread (
1249 ptid_build (current_event.dwProcessId, 0,
1250 current_event.dwThreadId),
1251 current_event.u.CreateThread.hThread,
1252 current_event.u.CreateThread.lpThreadLocalBase);
1253 return main_thread_id;
1257 windows_resume (struct target_ops *ops,
1258 ptid_t ptid, int step, enum gdb_signal sig)
1261 DWORD continue_status = DBG_CONTINUE;
1263 /* A specific PTID means `step only this thread id'. */
1264 int resume_all = ptid_equal (ptid, minus_one_ptid);
1266 /* If we're continuing all threads, it's the current inferior that
1267 should be handled specially. */
1269 ptid = inferior_ptid;
1271 if (sig != GDB_SIGNAL_0)
1273 if (current_event.dwDebugEventCode != EXCEPTION_DEBUG_EVENT)
1275 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig));
1277 else if (sig == last_sig)
1278 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1281 /* This code does not seem to work, because
1282 the kernel does probably not consider changes in the ExceptionRecord
1283 structure when passing the exception to the inferior.
1284 Note that this seems possible in the exception handler itself. */
1287 for (i = 0; xlate[i].them != -1; i++)
1288 if (xlate[i].us == sig)
1290 current_event.u.Exception.ExceptionRecord.ExceptionCode
1292 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1295 if (continue_status == DBG_CONTINUE)
1297 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig));
1301 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1305 last_sig = GDB_SIGNAL_0;
1307 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1308 ptid_get_pid (ptid), ptid_get_tid (ptid), step, sig));
1310 /* Get context for currently selected thread. */
1311 th = thread_rec (ptid_get_tid (inferior_ptid), FALSE);
1316 /* Single step by setting t bit. */
1317 struct regcache *regcache = get_current_regcache ();
1318 struct gdbarch *gdbarch = get_regcache_arch (regcache);
1319 windows_fetch_inferior_registers (ops, regcache,
1320 gdbarch_ps_regnum (gdbarch));
1321 th->context.EFlags |= FLAG_TRACE_BIT;
1324 if (th->context.ContextFlags)
1326 if (debug_registers_changed)
1328 th->context.Dr0 = dr[0];
1329 th->context.Dr1 = dr[1];
1330 th->context.Dr2 = dr[2];
1331 th->context.Dr3 = dr[3];
1332 th->context.Dr6 = DR6_CLEAR_VALUE;
1333 th->context.Dr7 = dr[7];
1335 CHECK (SetThreadContext (th->h, &th->context));
1336 th->context.ContextFlags = 0;
1340 /* Allow continuing with the same signal that interrupted us.
1341 Otherwise complain. */
1344 windows_continue (continue_status, -1);
1346 windows_continue (continue_status, ptid_get_tid (ptid));
1349 /* Ctrl-C handler used when the inferior is not run in the same console. The
1350 handler is in charge of interrupting the inferior using DebugBreakProcess.
1351 Note that this function is not available prior to Windows XP. In this case
1352 we emit a warning. */
1354 ctrl_c_handler (DWORD event_type)
1356 const int attach_flag = current_inferior ()->attach_flag;
1358 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1359 if (event_type != CTRL_C_EVENT && event_type != CTRL_BREAK_EVENT)
1362 /* If the inferior and the debugger share the same console, do nothing as
1363 the inferior has also received the Ctrl-C event. */
1364 if (!new_console && !attach_flag)
1367 if (!DebugBreakProcess (current_process_handle))
1368 warning (_("Could not interrupt program. "
1369 "Press Ctrl-c in the program console."));
1371 /* Return true to tell that Ctrl-C has been handled. */
1375 /* Get the next event from the child. Return 1 if the event requires
1376 handling by WFI (or whatever). */
1378 get_windows_debug_event (struct target_ops *ops,
1379 int pid, struct target_waitstatus *ourstatus)
1382 DWORD continue_status, event_code;
1384 static thread_info dummy_thread_info;
1387 last_sig = GDB_SIGNAL_0;
1389 if (!(debug_event = WaitForDebugEvent (¤t_event, 1000)))
1393 continue_status = DBG_CONTINUE;
1395 event_code = current_event.dwDebugEventCode;
1396 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
1398 have_saved_context = 0;
1402 case CREATE_THREAD_DEBUG_EVENT:
1403 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1404 (unsigned) current_event.dwProcessId,
1405 (unsigned) current_event.dwThreadId,
1406 "CREATE_THREAD_DEBUG_EVENT"));
1407 if (saw_create != 1)
1409 struct inferior *inf;
1410 inf = find_inferior_pid (current_event.dwProcessId);
1411 if (!saw_create && inf->attach_flag)
1413 /* Kludge around a Windows bug where first event is a create
1414 thread event. Caused when attached process does not have
1416 retval = fake_create_process ();
1422 /* Record the existence of this thread. */
1423 retval = current_event.dwThreadId;
1424 th = windows_add_thread (ptid_build (current_event.dwProcessId, 0,
1425 current_event.dwThreadId),
1426 current_event.u.CreateThread.hThread,
1427 current_event.u.CreateThread.lpThreadLocalBase);
1431 case EXIT_THREAD_DEBUG_EVENT:
1432 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1433 (unsigned) current_event.dwProcessId,
1434 (unsigned) current_event.dwThreadId,
1435 "EXIT_THREAD_DEBUG_EVENT"));
1437 if (current_event.dwThreadId != main_thread_id)
1439 windows_delete_thread (ptid_build (current_event.dwProcessId, 0,
1440 current_event.dwThreadId),
1441 current_event.u.ExitThread.dwExitCode);
1442 th = &dummy_thread_info;
1446 case CREATE_PROCESS_DEBUG_EVENT:
1447 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1448 (unsigned) current_event.dwProcessId,
1449 (unsigned) current_event.dwThreadId,
1450 "CREATE_PROCESS_DEBUG_EVENT"));
1451 CloseHandle (current_event.u.CreateProcessInfo.hFile);
1452 if (++saw_create != 1)
1455 current_process_handle = current_event.u.CreateProcessInfo.hProcess;
1457 windows_delete_thread (ptid_build (current_event.dwProcessId, 0,
1460 main_thread_id = current_event.dwThreadId;
1461 /* Add the main thread. */
1462 th = windows_add_thread (ptid_build (current_event.dwProcessId, 0,
1463 current_event.dwThreadId),
1464 current_event.u.CreateProcessInfo.hThread,
1465 current_event.u.CreateProcessInfo.lpThreadLocalBase);
1466 retval = current_event.dwThreadId;
1469 case EXIT_PROCESS_DEBUG_EVENT:
1470 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1471 (unsigned) current_event.dwProcessId,
1472 (unsigned) current_event.dwThreadId,
1473 "EXIT_PROCESS_DEBUG_EVENT"));
1474 if (!windows_initialization_done)
1476 target_terminal_ours ();
1477 target_mourn_inferior ();
1478 error (_("During startup program exited with code 0x%x."),
1479 (unsigned int) current_event.u.ExitProcess.dwExitCode);
1481 else if (saw_create == 1)
1483 ourstatus->kind = TARGET_WAITKIND_EXITED;
1484 ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode;
1485 retval = main_thread_id;
1489 case LOAD_DLL_DEBUG_EVENT:
1490 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1491 (unsigned) current_event.dwProcessId,
1492 (unsigned) current_event.dwThreadId,
1493 "LOAD_DLL_DEBUG_EVENT"));
1494 CloseHandle (current_event.u.LoadDll.hFile);
1495 if (saw_create != 1 || ! windows_initialization_done)
1497 catch_errors (handle_load_dll, NULL, (char *) "", RETURN_MASK_ALL);
1498 ourstatus->kind = TARGET_WAITKIND_LOADED;
1499 ourstatus->value.integer = 0;
1500 retval = main_thread_id;
1503 case UNLOAD_DLL_DEBUG_EVENT:
1504 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1505 (unsigned) current_event.dwProcessId,
1506 (unsigned) current_event.dwThreadId,
1507 "UNLOAD_DLL_DEBUG_EVENT"));
1508 if (saw_create != 1 || ! windows_initialization_done)
1510 catch_errors (handle_unload_dll, NULL, (char *) "", RETURN_MASK_ALL);
1511 ourstatus->kind = TARGET_WAITKIND_LOADED;
1512 ourstatus->value.integer = 0;
1513 retval = main_thread_id;
1516 case EXCEPTION_DEBUG_EVENT:
1517 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1518 (unsigned) current_event.dwProcessId,
1519 (unsigned) current_event.dwThreadId,
1520 "EXCEPTION_DEBUG_EVENT"));
1521 if (saw_create != 1)
1523 switch (handle_exception (ourstatus))
1526 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1529 retval = current_event.dwThreadId;
1533 continue_status = -1;
1538 case OUTPUT_DEBUG_STRING_EVENT: /* Message from the kernel. */
1539 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1540 (unsigned) current_event.dwProcessId,
1541 (unsigned) current_event.dwThreadId,
1542 "OUTPUT_DEBUG_STRING_EVENT"));
1543 if (saw_create != 1)
1545 retval = handle_output_debug_string (ourstatus);
1549 if (saw_create != 1)
1551 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1552 (unsigned) current_event.dwProcessId,
1553 (unsigned) current_event.dwThreadId);
1554 printf_unfiltered (" unknown event code %u\n",
1555 (unsigned) current_event.dwDebugEventCode);
1559 if (!retval || saw_create != 1)
1561 if (continue_status == -1)
1562 windows_resume (ops, minus_one_ptid, 0, 1);
1564 CHECK (windows_continue (continue_status, -1));
1568 inferior_ptid = ptid_build (current_event.dwProcessId, 0,
1570 current_thread = th ?: thread_rec (current_event.dwThreadId, TRUE);
1577 /* Wait for interesting events to occur in the target process. */
1579 windows_wait (struct target_ops *ops,
1580 ptid_t ptid, struct target_waitstatus *ourstatus, int options)
1584 target_terminal_ours ();
1586 /* We loop when we get a non-standard exception rather than return
1587 with a SPURIOUS because resume can try and step or modify things,
1588 which needs a current_thread->h. But some of these exceptions mark
1589 the birth or death of threads, which mean that the current thread
1590 isn't necessarily what you think it is. */
1596 /* If the user presses Ctrl-c while the debugger is waiting
1597 for an event, he expects the debugger to interrupt his program
1598 and to get the prompt back. There are two possible situations:
1600 - The debugger and the program do not share the console, in
1601 which case the Ctrl-c event only reached the debugger.
1602 In that case, the ctrl_c handler will take care of interrupting
1603 the inferior. Note that this case is working starting with
1604 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1607 - The debugger and the program share the same console, in which
1608 case both debugger and inferior will receive the Ctrl-c event.
1609 In that case the ctrl_c handler will ignore the event, as the
1610 Ctrl-c event generated inside the inferior will trigger the
1611 expected debug event.
1613 FIXME: brobecker/2008-05-20: If the inferior receives the
1614 signal first and the delay until GDB receives that signal
1615 is sufficiently long, GDB can sometimes receive the SIGINT
1616 after we have unblocked the CTRL+C handler. This would
1617 lead to the debugger stopping prematurely while handling
1618 the new-thread event that comes with the handling of the SIGINT
1619 inside the inferior, and then stop again immediately when
1620 the user tries to resume the execution in the inferior.
1621 This is a classic race that we should try to fix one day. */
1622 SetConsoleCtrlHandler (&ctrl_c_handler, TRUE);
1623 retval = get_windows_debug_event (ops, pid, ourstatus);
1624 SetConsoleCtrlHandler (&ctrl_c_handler, FALSE);
1627 return ptid_build (current_event.dwProcessId, 0, retval);
1632 if (deprecated_ui_loop_hook != NULL)
1633 detach = deprecated_ui_loop_hook (0);
1636 windows_kill_inferior (ops);
1641 /* Iterate over all DLLs currently mapped by our inferior, and
1642 add them to our list of solibs. */
1645 windows_add_all_dlls (void)
1648 HMODULE dummy_hmodule;
1653 if (EnumProcessModules (current_process_handle, &dummy_hmodule,
1654 sizeof (HMODULE), &cb_needed) == 0)
1660 hmodules = (HMODULE *) alloca (cb_needed);
1661 if (EnumProcessModules (current_process_handle, hmodules,
1662 cb_needed, &cb_needed) == 0)
1665 for (i = 1; i < (int) (cb_needed / sizeof (HMODULE)); i++)
1669 wchar_t dll_name[__PMAX];
1672 char dll_name[__PMAX];
1675 if (GetModuleInformation (current_process_handle, hmodules[i],
1676 &mi, sizeof (mi)) == 0)
1678 if (GetModuleFileNameEx (current_process_handle, hmodules[i],
1679 dll_name, sizeof (dll_name)) == 0)
1682 wcstombs (name, dll_name, __PMAX);
1687 solib_end->next = windows_make_so (name, mi.lpBaseOfDll);
1688 solib_end = solib_end->next;
1693 do_initial_windows_stuff (struct target_ops *ops, DWORD pid, int attaching)
1695 extern int stop_after_trap;
1697 struct inferior *inf;
1698 struct thread_info *tp;
1700 last_sig = GDB_SIGNAL_0;
1702 exception_count = 0;
1703 open_process_used = 0;
1704 debug_registers_changed = 0;
1705 debug_registers_used = 0;
1706 for (i = 0; i < sizeof (dr) / sizeof (dr[0]); i++)
1709 cygwin_load_start = cygwin_load_end = 0;
1711 current_event.dwProcessId = pid;
1712 memset (¤t_event, 0, sizeof (current_event));
1714 disable_breakpoints_in_shlibs ();
1715 windows_clear_solib ();
1716 clear_proceed_status ();
1717 init_wait_for_inferior ();
1719 inf = current_inferior ();
1720 inferior_appeared (inf, pid);
1721 inf->attach_flag = attaching;
1723 /* Make the new process the current inferior, so terminal handling
1724 can rely on it. When attaching, we don't know about any thread
1725 id here, but that's OK --- nothing should be referencing the
1726 current thread until we report an event out of windows_wait. */
1727 inferior_ptid = pid_to_ptid (pid);
1729 terminal_init_inferior_with_pgrp (pid);
1730 target_terminal_inferior ();
1732 windows_initialization_done = 0;
1733 inf->control.stop_soon = STOP_QUIETLY;
1736 stop_after_trap = 1;
1737 wait_for_inferior ();
1738 tp = inferior_thread ();
1739 if (tp->suspend.stop_signal != GDB_SIGNAL_TRAP)
1740 resume (0, tp->suspend.stop_signal);
1745 /* Now that the inferior has been started and all DLLs have been mapped,
1746 we can iterate over all DLLs and load them in.
1748 We avoid doing it any earlier because, on certain versions of Windows,
1749 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
1750 we have seen on Windows 8.1 that the ntdll.dll load event does not
1751 include the DLL name, preventing us from creating an associated SO.
1752 A possible explanation is that ntdll.dll might be mapped before
1753 the SO info gets created by the Windows system -- ntdll.dll is
1754 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
1755 do not seem to suffer from that problem.
1757 Rather than try to work around this sort of issue, it is much
1758 simpler to just ignore DLL load/unload events during the startup
1759 phase, and then process them all in one batch now. */
1760 windows_add_all_dlls ();
1762 windows_initialization_done = 1;
1763 inf->control.stop_soon = NO_STOP_QUIETLY;
1764 stop_after_trap = 0;
1768 /* Try to set or remove a user privilege to the current process. Return -1
1769 if that fails, the previous setting of that privilege otherwise.
1771 This code is copied from the Cygwin source code and rearranged to allow
1772 dynamically loading of the needed symbols from advapi32 which is only
1773 available on NT/2K/XP. */
1775 set_process_privilege (const char *privilege, BOOL enable)
1777 HANDLE token_hdl = NULL;
1779 TOKEN_PRIVILEGES new_priv, orig_priv;
1783 if (!OpenProcessToken (GetCurrentProcess (),
1784 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
1788 if (!LookupPrivilegeValueA (NULL, privilege, &restore_priv))
1791 new_priv.PrivilegeCount = 1;
1792 new_priv.Privileges[0].Luid = restore_priv;
1793 new_priv.Privileges[0].Attributes = enable ? SE_PRIVILEGE_ENABLED : 0;
1795 if (!AdjustTokenPrivileges (token_hdl, FALSE, &new_priv,
1796 sizeof orig_priv, &orig_priv, &size))
1799 /* Disabled, otherwise every `attach' in an unprivileged user session
1800 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1801 windows_attach(). */
1802 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1803 be enabled. GetLastError () returns an correct error code, though. */
1804 if (enable && GetLastError () == ERROR_NOT_ALL_ASSIGNED)
1808 ret = orig_priv.Privileges[0].Attributes == SE_PRIVILEGE_ENABLED ? 1 : 0;
1812 CloseHandle (token_hdl);
1817 /* Attach to process PID, then initialize for debugging it. */
1819 windows_attach (struct target_ops *ops, char *args, int from_tty)
1824 pid = parse_pid_to_attach (args);
1826 if (set_process_privilege (SE_DEBUG_NAME, TRUE) < 0)
1828 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1829 printf_unfiltered ("This can cause attach to "
1830 "fail on Windows NT/2K/XP\n");
1833 windows_init_thread_list ();
1834 ok = DebugActiveProcess (pid);
1840 /* Try fall back to Cygwin pid. */
1841 pid = cygwin_internal (CW_CYGWIN_PID_TO_WINPID, pid);
1844 ok = DebugActiveProcess (pid);
1849 error (_("Can't attach to process."));
1851 DebugSetProcessKillOnExit (FALSE);
1855 char *exec_file = (char *) get_exec_file (0);
1858 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
1859 target_pid_to_str (pid_to_ptid (pid)));
1861 printf_unfiltered ("Attaching to %s\n",
1862 target_pid_to_str (pid_to_ptid (pid)));
1864 gdb_flush (gdb_stdout);
1867 do_initial_windows_stuff (ops, pid, 1);
1868 target_terminal_ours ();
1872 windows_detach (struct target_ops *ops, const char *args, int from_tty)
1877 windows_resume (ops, ptid, 0, GDB_SIGNAL_0);
1879 if (!DebugActiveProcessStop (current_event.dwProcessId))
1881 error (_("Can't detach process %u (error %u)"),
1882 (unsigned) current_event.dwProcessId, (unsigned) GetLastError ());
1885 DebugSetProcessKillOnExit (FALSE);
1887 if (detached && from_tty)
1889 char *exec_file = get_exec_file (0);
1892 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file,
1893 (unsigned) current_event.dwProcessId);
1894 gdb_flush (gdb_stdout);
1897 i386_cleanup_dregs ();
1898 inferior_ptid = null_ptid;
1899 detach_inferior (current_event.dwProcessId);
1901 unpush_target (ops);
1904 /* Try to determine the executable filename.
1906 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
1908 Upon success, the filename is stored inside EXE_NAME_RET, and
1909 this function returns nonzero.
1911 Otherwise, this function returns zero and the contents of
1912 EXE_NAME_RET is undefined. */
1915 windows_get_exec_module_filename (char *exe_name_ret, size_t exe_name_max_len)
1922 if (!EnumProcessModules (current_process_handle, &dh_buf,
1923 sizeof (HMODULE), &cbNeeded) || !cbNeeded)
1926 /* We know the executable is always first in the list of modules,
1927 which we just fetched. So no need to fetch more. */
1931 /* Cygwin prefers that the path be in /x/y/z format, so extract
1932 the filename into a temporary buffer first, and then convert it
1933 to POSIX format into the destination buffer. */
1934 cygwin_buf_t *pathbuf = alloca (exe_name_max_len * sizeof (cygwin_buf_t));
1936 len = GetModuleFileNameEx (current_process_handle,
1937 dh_buf, pathbuf, exe_name_max_len);
1939 error (_("Error getting executable filename: %u."),
1940 (unsigned) GetLastError ());
1941 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX, pathbuf, exe_name_ret,
1942 exe_name_max_len) < 0)
1943 error (_("Error converting executable filename to POSIX: %d."), errno);
1946 len = GetModuleFileNameEx (current_process_handle,
1947 dh_buf, exe_name_ret, exe_name_max_len);
1949 error (_("Error getting executable filename: %u."),
1950 (unsigned) GetLastError ());
1953 return 1; /* success */
1956 /* The pid_to_exec_file target_ops method for this platform. */
1959 windows_pid_to_exec_file (struct target_ops *self, int pid)
1961 static char path[__PMAX];
1963 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
1965 char procexe[sizeof ("/proc/4294967295/exe")];
1967 xsnprintf (procexe, sizeof (procexe), "/proc/%u/exe", pid);
1968 nchars = readlink (procexe, path, sizeof(path));
1969 if (nchars > 0 && nchars < sizeof (path))
1971 path[nchars] = '\0'; /* Got it */
1976 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
1977 of gdb, or we're trying to debug a non-Cygwin windows executable. */
1978 if (!windows_get_exec_module_filename (path, sizeof (path)))
1984 /* Print status information about what we're accessing. */
1987 windows_files_info (struct target_ops *ignore)
1989 struct inferior *inf = current_inferior ();
1991 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1992 inf->attach_flag ? "attached" : "child",
1993 target_pid_to_str (inferior_ptid));
1997 windows_open (char *arg, int from_tty)
1999 error (_("Use the \"run\" command to start a Unix child process."));
2002 /* Modify CreateProcess parameters for use of a new separate console.
2004 *FLAGS: DWORD parameter for general process creation flags.
2005 *SI: STARTUPINFO structure, for which the console window size and
2006 console buffer size is filled in if GDB is running in a console.
2007 to create the new console.
2008 The size of the used font is not available on all versions of
2009 Windows OS. Furthermore, the current font might not be the default
2010 font, but this is still better than before.
2011 If the windows and buffer sizes are computed,
2012 SI->DWFLAGS is changed so that this information is used
2013 by CreateProcess function. */
2016 windows_set_console_info (STARTUPINFO *si, DWORD *flags)
2018 HANDLE hconsole = CreateFile ("CONOUT$", GENERIC_READ | GENERIC_WRITE,
2019 FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
2021 if (hconsole != INVALID_HANDLE_VALUE)
2023 CONSOLE_SCREEN_BUFFER_INFO sbinfo;
2025 CONSOLE_FONT_INFO cfi;
2027 GetCurrentConsoleFont (hconsole, FALSE, &cfi);
2028 font_size = GetConsoleFontSize (hconsole, cfi.nFont);
2029 GetConsoleScreenBufferInfo(hconsole, &sbinfo);
2030 si->dwXSize = sbinfo.srWindow.Right - sbinfo.srWindow.Left + 1;
2031 si->dwYSize = sbinfo.srWindow.Bottom - sbinfo.srWindow.Top + 1;
2033 si->dwXSize *= font_size.X;
2037 si->dwYSize *= font_size.Y;
2040 si->dwXCountChars = sbinfo.dwSize.X;
2041 si->dwYCountChars = sbinfo.dwSize.Y;
2042 si->dwFlags |= STARTF_USESIZE | STARTF_USECOUNTCHARS;
2044 *flags |= CREATE_NEW_CONSOLE;
2048 /* Function called by qsort to sort environment strings. */
2051 envvar_cmp (const void *a, const void *b)
2053 const char **p = (const char **) a;
2054 const char **q = (const char **) b;
2055 return strcasecmp (*p, *q);
2061 clear_win32_environment (char **env)
2065 wchar_t *copy = NULL, *equalpos;
2067 for (i = 0; env[i] && *env[i]; i++)
2069 len = mbstowcs (NULL, env[i], 0) + 1;
2070 copy = (wchar_t *) xrealloc (copy, len * sizeof (wchar_t));
2071 mbstowcs (copy, env[i], len);
2072 equalpos = wcschr (copy, L'=');
2075 SetEnvironmentVariableW (copy, NULL);
2081 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2082 EXEC_FILE is the file to run.
2083 ALLARGS is a string containing the arguments to the program.
2084 ENV is the environment vector to pass. Errors reported with error(). */
2087 windows_create_inferior (struct target_ops *ops, char *exec_file,
2088 char *allargs, char **in_env, int from_tty)
2092 cygwin_buf_t real_path[__PMAX];
2093 cygwin_buf_t shell[__PMAX]; /* Path to shell */
2095 cygwin_buf_t *toexec;
2096 cygwin_buf_t *cygallargs;
2098 char **old_env = NULL;
2102 int ostdin, ostdout, ostderr;
2104 char real_path[__PMAX];
2105 char shell[__PMAX]; /* Path to shell */
2117 PROCESS_INFORMATION pi;
2120 const char *inferior_io_terminal = get_inferior_io_terminal ();
2123 error (_("No executable specified, use `target exec'."));
2125 memset (&si, 0, sizeof (si));
2126 si.cb = sizeof (si);
2129 flags |= CREATE_NEW_PROCESS_GROUP;
2132 windows_set_console_info (&si, &flags);
2137 flags |= DEBUG_ONLY_THIS_PROCESS;
2138 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W, exec_file, real_path,
2139 __PMAX * sizeof (cygwin_buf_t)) < 0)
2140 error (_("Error starting executable: %d"), errno);
2143 len = mbstowcs (NULL, allargs, 0) + 1;
2144 if (len == (size_t) -1)
2145 error (_("Error starting executable: %d"), errno);
2146 cygallargs = (wchar_t *) alloca (len * sizeof (wchar_t));
2147 mbstowcs (cygallargs, allargs, len);
2149 cygallargs = allargs;
2154 sh = getenv ("SHELL");
2157 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W, sh, shell, __PMAX) < 0)
2158 error (_("Error starting executable via shell: %d"), errno);
2160 len = sizeof (L" -c 'exec '") + mbstowcs (NULL, exec_file, 0)
2161 + mbstowcs (NULL, allargs, 0) + 2;
2162 cygallargs = (wchar_t *) alloca (len * sizeof (wchar_t));
2163 swprintf (cygallargs, len, L" -c 'exec %s %s'", exec_file, allargs);
2165 len = (sizeof (" -c 'exec '") + strlen (exec_file)
2166 + strlen (allargs) + 2);
2167 cygallargs = (char *) alloca (len);
2168 xsnprintf (cygallargs, len, " -c 'exec %s %s'", exec_file, allargs);
2171 flags |= DEBUG_PROCESS;
2175 args = (cygwin_buf_t *) alloca ((wcslen (toexec) + wcslen (cygallargs) + 2)
2176 * sizeof (wchar_t));
2177 wcscpy (args, toexec);
2178 wcscat (args, L" ");
2179 wcscat (args, cygallargs);
2181 args = (cygwin_buf_t *) alloca (strlen (toexec) + strlen (cygallargs) + 2);
2182 strcpy (args, toexec);
2184 strcat (args, cygallargs);
2187 #ifdef CW_CVT_ENV_TO_WINENV
2188 /* First try to create a direct Win32 copy of the POSIX environment. */
2189 w32_env = (PWCHAR) cygwin_internal (CW_CVT_ENV_TO_WINENV, in_env);
2190 if (w32_env != (PWCHAR) -1)
2191 flags |= CREATE_UNICODE_ENVIRONMENT;
2193 /* If that fails, fall back to old method tweaking GDB's environment. */
2196 /* Reset all Win32 environment variables to avoid leftover on next run. */
2197 clear_win32_environment (environ);
2198 /* Prepare the environment vars for CreateProcess. */
2201 cygwin_internal (CW_SYNC_WINENV);
2205 if (!inferior_io_terminal)
2206 tty = ostdin = ostdout = ostderr = -1;
2209 tty = open (inferior_io_terminal, O_RDWR | O_NOCTTY);
2212 print_sys_errmsg (inferior_io_terminal, errno);
2213 ostdin = ostdout = ostderr = -1;
2226 windows_init_thread_list ();
2227 ret = CreateProcess (0,
2228 args, /* command line */
2229 NULL, /* Security */
2231 TRUE, /* inherit handles */
2232 flags, /* start flags */
2233 w32_env, /* environment */
2234 NULL, /* current directory */
2238 /* Just free the Win32 environment, if it could be created. */
2242 /* Reset all environment variables to avoid leftover on next run. */
2243 clear_win32_environment (in_env);
2244 /* Restore normal GDB environment variables. */
2246 cygwin_internal (CW_SYNC_WINENV);
2261 /* Build the command line, a space-separated list of tokens where
2262 the first token is the name of the module to be executed.
2263 To avoid ambiguities introduced by spaces in the module name,
2265 args_len = strlen (toexec) + 2 /* quotes */ + strlen (allargs) + 2;
2266 args = alloca (args_len);
2267 xsnprintf (args, args_len, "\"%s\" %s", toexec, allargs);
2269 flags |= DEBUG_ONLY_THIS_PROCESS;
2271 if (!inferior_io_terminal)
2272 tty = INVALID_HANDLE_VALUE;
2275 SECURITY_ATTRIBUTES sa;
2276 sa.nLength = sizeof(sa);
2277 sa.lpSecurityDescriptor = 0;
2278 sa.bInheritHandle = TRUE;
2279 tty = CreateFileA (inferior_io_terminal, GENERIC_READ | GENERIC_WRITE,
2280 0, &sa, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
2281 if (tty == INVALID_HANDLE_VALUE)
2282 warning (_("Warning: Failed to open TTY %s, error %#x."),
2283 inferior_io_terminal, (unsigned) GetLastError ());
2287 si.hStdOutput = tty;
2289 si.dwFlags |= STARTF_USESTDHANDLES;
2293 /* CreateProcess takes the environment list as a null terminated set of
2294 strings (i.e. two nulls terminate the list). */
2296 /* Get total size for env strings. */
2297 for (envlen = 0, i = 0; in_env[i] && *in_env[i]; i++)
2298 envlen += strlen (in_env[i]) + 1;
2300 envsize = sizeof (in_env[0]) * (i + 1);
2301 env = (char **) alloca (envsize);
2302 memcpy (env, in_env, envsize);
2303 /* Windows programs expect the environment block to be sorted. */
2304 qsort (env, i, sizeof (char *), envvar_cmp);
2306 w32env = alloca (envlen + 1);
2308 /* Copy env strings into new buffer. */
2309 for (temp = w32env, i = 0; env[i] && *env[i]; i++)
2311 strcpy (temp, env[i]);
2312 temp += strlen (temp) + 1;
2315 /* Final nil string to terminate new env. */
2318 windows_init_thread_list ();
2319 ret = CreateProcessA (0,
2320 args, /* command line */
2321 NULL, /* Security */
2323 TRUE, /* inherit handles */
2324 flags, /* start flags */
2325 w32env, /* environment */
2326 NULL, /* current directory */
2329 if (tty != INVALID_HANDLE_VALUE)
2334 error (_("Error creating process %s, (error %u)."),
2335 exec_file, (unsigned) GetLastError ());
2337 CloseHandle (pi.hThread);
2338 CloseHandle (pi.hProcess);
2340 if (useshell && shell[0] != '\0')
2345 do_initial_windows_stuff (ops, pi.dwProcessId, 0);
2347 /* windows_continue (DBG_CONTINUE, -1); */
2351 windows_mourn_inferior (struct target_ops *ops)
2353 (void) windows_continue (DBG_CONTINUE, -1);
2354 i386_cleanup_dregs();
2355 if (open_process_used)
2357 CHECK (CloseHandle (current_process_handle));
2358 open_process_used = 0;
2360 unpush_target (ops);
2361 generic_mourn_inferior ();
2364 /* Send a SIGINT to the process group. This acts just like the user typed a
2365 ^C on the controlling terminal. */
2368 windows_stop (struct target_ops *self, ptid_t ptid)
2370 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2371 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId));
2372 registers_changed (); /* refresh register state */
2375 /* Helper for windows_xfer_partial that handles memory transfers.
2376 Arguments are like target_xfer_partial. */
2378 static enum target_xfer_status
2379 windows_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
2380 ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
2384 DWORD lasterror = 0;
2386 if (writebuf != NULL)
2388 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
2389 pulongest (len), core_addr_to_string (memaddr)));
2390 success = WriteProcessMemory (current_process_handle,
2391 (LPVOID) (uintptr_t) memaddr, writebuf,
2394 lasterror = GetLastError ();
2395 FlushInstructionCache (current_process_handle,
2396 (LPCVOID) (uintptr_t) memaddr, len);
2400 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
2401 pulongest (len), core_addr_to_string (memaddr)));
2402 success = ReadProcessMemory (current_process_handle,
2403 (LPCVOID) (uintptr_t) memaddr, readbuf,
2406 lasterror = GetLastError ();
2408 *xfered_len = (ULONGEST) done;
2409 if (!success && lasterror == ERROR_PARTIAL_COPY && done > 0)
2410 return TARGET_XFER_OK;
2412 return success ? TARGET_XFER_OK : TARGET_XFER_E_IO;
2416 windows_kill_inferior (struct target_ops *ops)
2418 CHECK (TerminateProcess (current_process_handle, 0));
2422 if (!windows_continue (DBG_CONTINUE, -1))
2424 if (!WaitForDebugEvent (¤t_event, INFINITE))
2426 if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
2430 target_mourn_inferior (); /* Or just windows_mourn_inferior? */
2434 windows_prepare_to_store (struct target_ops *self, struct regcache *regcache)
2436 /* Do nothing, since we can store individual regs. */
2440 windows_can_run (struct target_ops *self)
2446 windows_close (struct target_ops *self)
2448 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2449 ptid_get_pid (inferior_ptid)));
2452 /* Convert pid to printable format. */
2454 windows_pid_to_str (struct target_ops *ops, ptid_t ptid)
2456 static char buf[80];
2458 if (ptid_get_tid (ptid) != 0)
2460 snprintf (buf, sizeof (buf), "Thread %d.0x%lx",
2461 ptid_get_pid (ptid), ptid_get_tid (ptid));
2465 return normal_pid_to_str (ptid);
2468 static enum target_xfer_status
2469 windows_xfer_shared_libraries (struct target_ops *ops,
2470 enum target_object object, const char *annex,
2471 gdb_byte *readbuf, const gdb_byte *writebuf,
2472 ULONGEST offset, ULONGEST len,
2473 ULONGEST *xfered_len)
2475 struct obstack obstack;
2481 return TARGET_XFER_E_IO;
2483 obstack_init (&obstack);
2484 obstack_grow_str (&obstack, "<library-list>\n");
2485 for (so = solib_start.next; so; so = so->next)
2486 windows_xfer_shared_library (so->so_name, (CORE_ADDR)
2487 (uintptr_t) so->lm_info->load_addr,
2488 target_gdbarch (), &obstack);
2489 obstack_grow_str0 (&obstack, "</library-list>\n");
2491 buf = obstack_finish (&obstack);
2492 len_avail = strlen (buf);
2493 if (offset >= len_avail)
2497 if (len > len_avail - offset)
2498 len = len_avail - offset;
2499 memcpy (readbuf, buf + offset, len);
2502 obstack_free (&obstack, NULL);
2503 *xfered_len = (ULONGEST) len;
2504 return TARGET_XFER_OK;
2507 static enum target_xfer_status
2508 windows_xfer_partial (struct target_ops *ops, enum target_object object,
2509 const char *annex, gdb_byte *readbuf,
2510 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
2511 ULONGEST *xfered_len)
2515 case TARGET_OBJECT_MEMORY:
2516 return windows_xfer_memory (readbuf, writebuf, offset, len, xfered_len);
2518 case TARGET_OBJECT_LIBRARIES:
2519 return windows_xfer_shared_libraries (ops, object, annex, readbuf,
2520 writebuf, offset, len, xfered_len);
2523 if (ops->beneath != NULL)
2524 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
2525 readbuf, writebuf, offset, len,
2527 return TARGET_XFER_E_IO;
2531 /* Provide thread local base, i.e. Thread Information Block address.
2532 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
2535 windows_get_tib_address (struct target_ops *self,
2536 ptid_t ptid, CORE_ADDR *addr)
2540 th = thread_rec (ptid_get_tid (ptid), 0);
2545 *addr = th->thread_local_base;
2551 windows_get_ada_task_ptid (struct target_ops *self, long lwp, long thread)
2553 return ptid_build (ptid_get_pid (inferior_ptid), 0, lwp);
2557 init_windows_ops (void)
2559 windows_ops.to_shortname = "child";
2560 windows_ops.to_longname = "Win32 child process";
2561 windows_ops.to_doc = "Win32 child process (started by the \"run\" command).";
2562 windows_ops.to_open = windows_open;
2563 windows_ops.to_close = windows_close;
2564 windows_ops.to_attach = windows_attach;
2565 windows_ops.to_attach_no_wait = 1;
2566 windows_ops.to_detach = windows_detach;
2567 windows_ops.to_resume = windows_resume;
2568 windows_ops.to_wait = windows_wait;
2569 windows_ops.to_fetch_registers = windows_fetch_inferior_registers;
2570 windows_ops.to_store_registers = windows_store_inferior_registers;
2571 windows_ops.to_prepare_to_store = windows_prepare_to_store;
2572 windows_ops.to_xfer_partial = windows_xfer_partial;
2573 windows_ops.to_files_info = windows_files_info;
2574 windows_ops.to_insert_breakpoint = memory_insert_breakpoint;
2575 windows_ops.to_remove_breakpoint = memory_remove_breakpoint;
2576 windows_ops.to_terminal_init = terminal_init_inferior;
2577 windows_ops.to_terminal_inferior = terminal_inferior;
2578 windows_ops.to_terminal_ours_for_output = terminal_ours_for_output;
2579 windows_ops.to_terminal_ours = terminal_ours;
2580 windows_ops.to_terminal_save_ours = terminal_save_ours;
2581 windows_ops.to_terminal_info = child_terminal_info;
2582 windows_ops.to_kill = windows_kill_inferior;
2583 windows_ops.to_create_inferior = windows_create_inferior;
2584 windows_ops.to_mourn_inferior = windows_mourn_inferior;
2585 windows_ops.to_can_run = windows_can_run;
2586 windows_ops.to_thread_alive = windows_thread_alive;
2587 windows_ops.to_pid_to_str = windows_pid_to_str;
2588 windows_ops.to_stop = windows_stop;
2589 windows_ops.to_stratum = process_stratum;
2590 windows_ops.to_has_all_memory = default_child_has_all_memory;
2591 windows_ops.to_has_memory = default_child_has_memory;
2592 windows_ops.to_has_stack = default_child_has_stack;
2593 windows_ops.to_has_registers = default_child_has_registers;
2594 windows_ops.to_has_execution = default_child_has_execution;
2595 windows_ops.to_pid_to_exec_file = windows_pid_to_exec_file;
2596 windows_ops.to_get_ada_task_ptid = windows_get_ada_task_ptid;
2597 windows_ops.to_get_tib_address = windows_get_tib_address;
2599 i386_use_watchpoints (&windows_ops);
2601 i386_dr_low.set_control = cygwin_set_dr7;
2602 i386_dr_low.set_addr = cygwin_set_dr;
2603 i386_dr_low.get_addr = cygwin_get_dr;
2604 i386_dr_low.get_status = cygwin_get_dr6;
2605 i386_dr_low.get_control = cygwin_get_dr7;
2607 /* i386_dr_low.debug_register_length field is set by
2608 calling i386_set_debug_register_length function
2609 in processor windows specific native file. */
2611 windows_ops.to_magic = OPS_MAGIC;
2615 set_windows_aliases (char *argv0)
2617 add_info_alias ("dll", "sharedlibrary", 1);
2620 /* -Wmissing-prototypes */
2621 extern initialize_file_ftype _initialize_windows_nat;
2624 _initialize_windows_nat (void)
2626 struct cmd_list_element *c;
2628 init_windows_ops ();
2631 cygwin_internal (CW_SET_DOS_FILE_WARNING, 0);
2634 c = add_com ("dll-symbols", class_files, dll_symbol_command,
2635 _("Load dll library symbols from FILE."));
2636 set_cmd_completer (c, filename_completer);
2637 deprecate_cmd (c, "sharedlibrary");
2639 c = add_com ("add-shared-symbol-files", class_files, dll_symbol_command,
2640 _("Load dll library symbols from FILE."));
2641 set_cmd_completer (c, filename_completer);
2642 deprecate_cmd (c, "sharedlibrary");
2644 c = add_com ("assf", class_files, dll_symbol_command,
2645 _("Load dll library symbols from FILE."));
2646 set_cmd_completer (c, filename_completer);
2647 deprecate_cmd (c, "sharedlibrary");
2650 add_setshow_boolean_cmd ("shell", class_support, &useshell, _("\
2651 Set use of shell to start subprocess."), _("\
2652 Show use of shell to start subprocess."), NULL,
2654 NULL, /* FIXME: i18n: */
2655 &setlist, &showlist);
2657 add_setshow_boolean_cmd ("cygwin-exceptions", class_support,
2658 &cygwin_exceptions, _("\
2659 Break when an exception is detected in the Cygwin DLL itself."), _("\
2660 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL,
2662 NULL, /* FIXME: i18n: */
2663 &setlist, &showlist);
2666 add_setshow_boolean_cmd ("new-console", class_support, &new_console, _("\
2667 Set creation of new console when creating child process."), _("\
2668 Show creation of new console when creating child process."), NULL,
2670 NULL, /* FIXME: i18n: */
2671 &setlist, &showlist);
2673 add_setshow_boolean_cmd ("new-group", class_support, &new_group, _("\
2674 Set creation of new group when creating child process."), _("\
2675 Show creation of new group when creating child process."), NULL,
2677 NULL, /* FIXME: i18n: */
2678 &setlist, &showlist);
2680 add_setshow_boolean_cmd ("debugexec", class_support, &debug_exec, _("\
2681 Set whether to display execution in child process."), _("\
2682 Show whether to display execution in child process."), NULL,
2684 NULL, /* FIXME: i18n: */
2685 &setlist, &showlist);
2687 add_setshow_boolean_cmd ("debugevents", class_support, &debug_events, _("\
2688 Set whether to display kernel events in child process."), _("\
2689 Show whether to display kernel events in child process."), NULL,
2691 NULL, /* FIXME: i18n: */
2692 &setlist, &showlist);
2694 add_setshow_boolean_cmd ("debugmemory", class_support, &debug_memory, _("\
2695 Set whether to display memory accesses in child process."), _("\
2696 Show whether to display memory accesses in child process."), NULL,
2698 NULL, /* FIXME: i18n: */
2699 &setlist, &showlist);
2701 add_setshow_boolean_cmd ("debugexceptions", class_support,
2702 &debug_exceptions, _("\
2703 Set whether to display kernel exceptions in child process."), _("\
2704 Show whether to display kernel exceptions in child process."), NULL,
2706 NULL, /* FIXME: i18n: */
2707 &setlist, &showlist);
2709 init_w32_command_list ();
2711 add_cmd ("selector", class_info, display_selectors,
2712 _("Display selectors infos."),
2714 add_target (&windows_ops);
2715 deprecated_init_ui_hook = set_windows_aliases;
2718 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2720 /* Pass the address ADDR to the inferior in the I'th debug register.
2721 Here we just store the address in dr array, the registers will be
2722 actually set up when windows_continue is called. */
2724 cygwin_set_dr (int i, CORE_ADDR addr)
2727 internal_error (__FILE__, __LINE__,
2728 _("Invalid register %d in cygwin_set_dr.\n"), i);
2730 debug_registers_changed = 1;
2731 debug_registers_used = 1;
2734 /* Pass the value VAL to the inferior in the DR7 debug control
2735 register. Here we just store the address in D_REGS, the watchpoint
2736 will be actually set up in windows_wait. */
2738 cygwin_set_dr7 (unsigned long val)
2740 dr[7] = (CORE_ADDR) val;
2741 debug_registers_changed = 1;
2742 debug_registers_used = 1;
2745 /* Get the value of debug register I from the inferior. */
2748 cygwin_get_dr (int i)
2753 /* Get the value of the DR6 debug status register from the inferior.
2754 Here we just return the value stored in dr[6]
2755 by the last call to thread_rec for current_event.dwThreadId id. */
2756 static unsigned long
2757 cygwin_get_dr6 (void)
2759 return (unsigned long) dr[6];
2762 /* Get the value of the DR7 debug status register from the inferior.
2763 Here we just return the value stored in dr[7] by the last call to
2764 thread_rec for current_event.dwThreadId id. */
2766 static unsigned long
2767 cygwin_get_dr7 (void)
2769 return (unsigned long) dr[7];
2772 /* Determine if the thread referenced by "ptid" is alive
2773 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2774 it means that the thread has died. Otherwise it is assumed to be alive. */
2776 windows_thread_alive (struct target_ops *ops, ptid_t ptid)
2780 gdb_assert (ptid_get_tid (ptid) != 0);
2781 tid = ptid_get_tid (ptid);
2783 return WaitForSingleObject (thread_rec (tid, FALSE)->h, 0) == WAIT_OBJECT_0
2787 /* -Wmissing-prototypes */
2788 extern initialize_file_ftype _initialize_check_for_gdb_ini;
2791 _initialize_check_for_gdb_ini (void)
2794 if (inhibit_gdbinit)
2797 homedir = getenv ("HOME");
2801 char *oldini = (char *) alloca (strlen (homedir) +
2802 sizeof ("/gdb.ini"));
2803 strcpy (oldini, homedir);
2804 p = strchr (oldini, '\0');
2805 if (p > oldini && !IS_DIR_SEPARATOR (p[-1]))
2807 strcpy (p, "gdb.ini");
2808 if (access (oldini, 0) == 0)
2810 int len = strlen (oldini);
2811 char *newini = alloca (len + 1);
2813 xsnprintf (newini, len + 1, "%.*s.gdbinit",
2814 (int) (len - (sizeof ("gdb.ini") - 1)), oldini);
2815 warning (_("obsolete '%s' found. Rename to '%s'."), oldini, newini);
2820 /* Define dummy functions which always return error for the rare cases where
2821 these functions could not be found. */
2823 bad_DebugActiveProcessStop (DWORD w)
2828 bad_DebugBreakProcess (HANDLE w)
2833 bad_DebugSetProcessKillOnExit (BOOL w)
2838 bad_EnumProcessModules (HANDLE w, HMODULE *x, DWORD y, LPDWORD z)
2845 bad_GetModuleFileNameExW (HANDLE w, HMODULE x, LPWSTR y, DWORD z)
2851 bad_GetModuleFileNameExA (HANDLE w, HMODULE x, LPSTR y, DWORD z)
2858 bad_GetModuleInformation (HANDLE w, HMODULE x, LPMODULEINFO y, DWORD z)
2864 bad_OpenProcessToken (HANDLE w, DWORD x, PHANDLE y)
2870 bad_GetCurrentConsoleFont (HANDLE w, BOOL bMaxWindow, CONSOLE_FONT_INFO *f)
2876 bad_GetConsoleFontSize (HANDLE w, DWORD nFont)
2884 /* -Wmissing-prototypes */
2885 extern initialize_file_ftype _initialize_loadable;
2887 /* Load any functions which may not be available in ancient versions
2891 _initialize_loadable (void)
2895 hm = LoadLibrary ("kernel32.dll");
2898 DebugActiveProcessStop = (void *)
2899 GetProcAddress (hm, "DebugActiveProcessStop");
2900 DebugBreakProcess = (void *)
2901 GetProcAddress (hm, "DebugBreakProcess");
2902 DebugSetProcessKillOnExit = (void *)
2903 GetProcAddress (hm, "DebugSetProcessKillOnExit");
2904 GetConsoleFontSize = (void *)
2905 GetProcAddress (hm, "GetConsoleFontSize");
2906 GetCurrentConsoleFont = (void *)
2907 GetProcAddress (hm, "GetCurrentConsoleFont");
2910 /* Set variables to dummy versions of these processes if the function
2911 wasn't found in kernel32.dll. */
2912 if (!DebugBreakProcess)
2913 DebugBreakProcess = bad_DebugBreakProcess;
2914 if (!DebugActiveProcessStop || !DebugSetProcessKillOnExit)
2916 DebugActiveProcessStop = bad_DebugActiveProcessStop;
2917 DebugSetProcessKillOnExit = bad_DebugSetProcessKillOnExit;
2919 if (!GetConsoleFontSize)
2920 GetConsoleFontSize = bad_GetConsoleFontSize;
2921 if (!GetCurrentConsoleFont)
2922 GetCurrentConsoleFont = bad_GetCurrentConsoleFont;
2924 /* Load optional functions used for retrieving filename information
2925 associated with the currently debugged process or its dlls. */
2926 hm = LoadLibrary ("psapi.dll");
2929 EnumProcessModules = (void *)
2930 GetProcAddress (hm, "EnumProcessModules");
2931 GetModuleInformation = (void *)
2932 GetProcAddress (hm, "GetModuleInformation");
2933 GetModuleFileNameEx = (void *)
2934 GetProcAddress (hm, GetModuleFileNameEx_name);
2937 if (!EnumProcessModules || !GetModuleInformation || !GetModuleFileNameEx)
2939 /* Set variables to dummy versions of these processes if the function
2940 wasn't found in psapi.dll. */
2941 EnumProcessModules = bad_EnumProcessModules;
2942 GetModuleInformation = bad_GetModuleInformation;
2943 GetModuleFileNameEx = bad_GetModuleFileNameEx;
2944 /* This will probably fail on Windows 9x/Me. Let the user know
2945 that we're missing some functionality. */
2947 cannot automatically find executable file or library to read symbols.\n\
2948 Use \"file\" or \"dll\" command to load executable/libraries directly."));
2951 hm = LoadLibrary ("advapi32.dll");
2954 OpenProcessToken = (void *) GetProcAddress (hm, "OpenProcessToken");
2955 LookupPrivilegeValueA = (void *)
2956 GetProcAddress (hm, "LookupPrivilegeValueA");
2957 AdjustTokenPrivileges = (void *)
2958 GetProcAddress (hm, "AdjustTokenPrivileges");
2959 /* Only need to set one of these since if OpenProcessToken fails nothing
2961 if (!OpenProcessToken || !LookupPrivilegeValueA
2962 || !AdjustTokenPrivileges)
2963 OpenProcessToken = bad_OpenProcessToken;