1 /* Target-vector operations for controlling windows child processes, for GDB.
3 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
4 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
6 Contributed by Cygnus Solutions, A Red Hat Company.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 /* Originally by Steve Chamberlain, sac@cygnus.com */
26 #include "frame.h" /* required by inferior.h */
29 #include "exceptions.h"
32 #include "completer.h"
36 #include <sys/types.h>
43 #include <sys/cygwin.h>
44 #include <cygwin/version.h>
51 #include "gdb_obstack.h"
52 #include "gdb_string.h"
53 #include "gdbthread.h"
55 #include <sys/param.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
79 static BOOL WINAPI (*AdjustTokenPrivileges)(HANDLE, BOOL, PTOKEN_PRIVILEGES,
80 DWORD, PTOKEN_PRIVILEGES, PDWORD);
81 static BOOL WINAPI (*DebugActiveProcessStop) (DWORD);
82 static BOOL WINAPI (*DebugBreakProcess) (HANDLE);
83 static BOOL WINAPI (*DebugSetProcessKillOnExit) (BOOL);
84 static BOOL WINAPI (*EnumProcessModules) (HANDLE, HMODULE *, DWORD,
86 static BOOL WINAPI (*GetModuleInformation) (HANDLE, HMODULE, LPMODULEINFO,
88 static BOOL WINAPI (*LookupPrivilegeValueA)(LPCSTR, LPCSTR, PLUID);
89 static BOOL WINAPI (*OpenProcessToken)(HANDLE, DWORD, PHANDLE);
91 static struct target_ops windows_ops;
95 #undef GetModuleFileNameEx
98 # define __PMAX (MAX_PATH + 1)
99 static DWORD WINAPI (*GetModuleFileNameEx) (HANDLE, HMODULE, LPSTR, DWORD);
100 # define STARTUPINFO STARTUPINFOA
101 # define CreateProcess CreateProcessA
102 # define GetModuleFileNameEx_name "GetModuleFileNameExA"
103 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
105 # define __PMAX PATH_MAX
106 /* The starting and ending address of the cygwin1.dll text segment. */
107 static CORE_ADDR cygwin_load_start;
108 static CORE_ADDR cygwin_load_end;
109 # if CYGWIN_VERSION_DLL_MAKE_COMBINED(CYGWIN_VERSION_API_MAJOR,CYGWIN_VERSION_API_MINOR) >= 181
111 typedef wchar_t cygwin_buf_t;
112 static DWORD WINAPI (*GetModuleFileNameEx) (HANDLE, HMODULE, LPWSTR, DWORD);
113 # define STARTUPINFO STARTUPINFOW
114 # define CreateProcess CreateProcessW
115 # define GetModuleFileNameEx_name "GetModuleFileNameExW"
116 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExW
118 # define CCP_POSIX_TO_WIN_W 1
119 # define CCP_WIN_W_TO_POSIX 3
120 # define cygwin_conv_path(op, from, to, size) \
121 (op == CCP_WIN_W_TO_POSIX) ? \
122 cygwin_conv_to_full_posix_path (from, to) : \
123 cygwin_conv_to_win32_path (from, to)
124 typedef char cygwin_buf_t;
125 static DWORD WINAPI (*GetModuleFileNameEx) (HANDLE, HMODULE, LPSTR, DWORD);
126 # define STARTUPINFO STARTUPINFOA
127 # define CreateProcess CreateProcessA
128 # define GetModuleFileNameEx_name "GetModuleFileNameExA"
129 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
130 # define CW_SET_DOS_FILE_WARNING -1 /* no-op this for older Cygwin */
134 static int have_saved_context; /* True if we've saved context from a cygwin signal. */
135 static CONTEXT saved_context; /* Containes the saved context from a cygwin signal. */
137 /* If we're not using the old Cygwin header file set, define the
138 following which never should have been in the generic Win32 API
139 headers in the first place since they were our own invention... */
140 #ifndef _GNU_H_WINDOWS_H
143 FLAG_TRACE_BIT = 0x100,
144 CONTEXT_DEBUGGER = (CONTEXT_FULL | CONTEXT_FLOATING_POINT)
148 #ifndef CONTEXT_EXTENDED_REGISTERS
149 /* This macro is only defined on ia32. It only makes sense on this target,
150 so define it as zero if not already defined. */
151 #define CONTEXT_EXTENDED_REGISTERS 0
154 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \
155 | CONTEXT_EXTENDED_REGISTERS
157 static uintptr_t dr[8];
158 static int debug_registers_changed;
159 static int debug_registers_used;
161 static int windows_initialization_done;
162 #define DR6_CLEAR_VALUE 0xffff0ff0
164 /* The string sent by cygwin when it processes a signal.
165 FIXME: This should be in a cygwin include file. */
166 #ifndef _CYGWIN_SIGNAL_STRING
167 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
170 #define CHECK(x) check (x, __FILE__,__LINE__)
171 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
172 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
173 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
174 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
176 static void windows_stop (ptid_t);
177 static int windows_thread_alive (struct target_ops *, ptid_t);
178 static void windows_kill_inferior (struct target_ops *);
180 static void cygwin_set_dr (int i, CORE_ADDR addr);
181 static void cygwin_set_dr7 (unsigned long val);
182 static unsigned long cygwin_get_dr6 (void);
184 static enum target_signal last_sig = TARGET_SIGNAL_0;
185 /* Set if a signal was received from the debugged process */
187 /* Thread information structure used to track information that is
188 not available in gdb's thread structure. */
189 typedef struct thread_info_struct
191 struct thread_info_struct *next;
194 CORE_ADDR thread_local_base;
203 static thread_info thread_head;
205 /* The process and thread handles for the above context. */
207 static DEBUG_EVENT current_event; /* The current debug event from
209 static HANDLE current_process_handle; /* Currently executing process */
210 static thread_info *current_thread; /* Info on currently selected thread */
211 static DWORD main_thread_id; /* Thread ID of the main thread */
213 /* Counts of things. */
214 static int exception_count = 0;
215 static int event_count = 0;
216 static int saw_create;
217 static int open_process_used = 0;
220 static int new_console = 0;
222 static int cygwin_exceptions = 0;
224 static int new_group = 1;
225 static int debug_exec = 0; /* show execution */
226 static int debug_events = 0; /* show events from kernel */
227 static int debug_memory = 0; /* show target memory accesses */
228 static int debug_exceptions = 0; /* show target exceptions */
229 static int useshell = 0; /* use shell for subprocesses */
231 /* This vector maps GDB's idea of a register's number into an offset
232 in the windows exception context vector.
234 It also contains the bit mask needed to load the register in question.
236 The contents of this table can only be computed by the units
237 that provide CPU-specific support for Windows native debugging.
238 These units should set the table by calling
239 windows_set_context_register_offsets.
241 One day we could read a reg, we could inspect the context we
242 already have loaded, if it doesn't have the bit set that we need,
243 we read that set of registers in using GetThreadContext. If the
244 context already contains what we need, we just unpack it. Then to
245 write a register, first we have to ensure that the context contains
246 the other regs of the group, and then we copy the info in and set
249 static const int *mappings;
251 /* This vector maps the target's idea of an exception (extracted
252 from the DEBUG_EVENT structure) to GDB's idea. */
254 struct xlate_exception
257 enum target_signal us;
260 static const struct xlate_exception
263 {EXCEPTION_ACCESS_VIOLATION, TARGET_SIGNAL_SEGV},
264 {STATUS_STACK_OVERFLOW, TARGET_SIGNAL_SEGV},
265 {EXCEPTION_BREAKPOINT, TARGET_SIGNAL_TRAP},
266 {DBG_CONTROL_C, TARGET_SIGNAL_INT},
267 {EXCEPTION_SINGLE_STEP, TARGET_SIGNAL_TRAP},
268 {STATUS_FLOAT_DIVIDE_BY_ZERO, TARGET_SIGNAL_FPE},
271 /* Set the MAPPINGS static global to OFFSETS.
272 See the description of MAPPINGS for more details. */
275 windows_set_context_register_offsets (const int *offsets)
281 check (BOOL ok, const char *file, int line)
284 printf_filtered ("error return %s:%d was %lu\n", file, line,
288 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
289 then also retrieve the context for this thread. If GET_CONTEXT is
290 negative, then don't suspend the thread. */
292 thread_rec (DWORD id, int get_context)
296 for (th = &thread_head; (th = th->next) != NULL;)
299 if (!th->suspended && get_context)
301 if (get_context > 0 && id != current_event.dwThreadId)
303 if (SuspendThread (th->h) == (DWORD) -1)
305 DWORD err = GetLastError ();
306 warning (_("SuspendThread failed. (winerr %d)"),
312 else if (get_context < 0)
314 th->reload_context = 1;
322 /* Add a thread to the thread list. */
324 windows_add_thread (ptid_t ptid, HANDLE h, void *tlb)
329 gdb_assert (ptid_get_tid (ptid) != 0);
331 id = ptid_get_tid (ptid);
333 if ((th = thread_rec (id, FALSE)))
336 th = XZALLOC (thread_info);
339 th->thread_local_base = (CORE_ADDR) (uintptr_t) tlb;
340 th->next = thread_head.next;
341 thread_head.next = th;
343 /* Set the debug registers for the new thread if they are used. */
344 if (debug_registers_used)
346 /* Only change the value of the debug registers. */
347 th->context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
348 CHECK (GetThreadContext (th->h, &th->context));
349 th->context.Dr0 = dr[0];
350 th->context.Dr1 = dr[1];
351 th->context.Dr2 = dr[2];
352 th->context.Dr3 = dr[3];
353 th->context.Dr6 = DR6_CLEAR_VALUE;
354 th->context.Dr7 = dr[7];
355 CHECK (SetThreadContext (th->h, &th->context));
356 th->context.ContextFlags = 0;
361 /* Clear out any old thread list and reintialize it to a
364 windows_init_thread_list (void)
366 thread_info *th = &thread_head;
368 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
370 while (th->next != NULL)
372 thread_info *here = th->next;
373 th->next = here->next;
376 thread_head.next = NULL;
379 /* Delete a thread from the list of threads */
381 windows_delete_thread (ptid_t ptid)
386 gdb_assert (ptid_get_tid (ptid) != 0);
388 id = ptid_get_tid (ptid);
391 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid));
392 delete_thread (ptid);
394 for (th = &thread_head;
395 th->next != NULL && th->next->id != id;
399 if (th->next != NULL)
401 thread_info *here = th->next;
402 th->next = here->next;
408 do_windows_fetch_inferior_registers (struct regcache *regcache, int r)
410 char *context_offset = ((char *) ¤t_thread->context) + mappings[r];
411 struct gdbarch *gdbarch = get_regcache_arch (regcache);
412 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
416 return; /* Windows sometimes uses a non-existent thread id in its
419 if (current_thread->reload_context)
421 #ifdef __COPY_CONTEXT_SIZE
422 if (have_saved_context)
424 /* Lie about where the program actually is stopped since cygwin has informed us that
425 we should consider the signal to have occurred at another location which is stored
426 in "saved_context. */
427 memcpy (¤t_thread->context, &saved_context, __COPY_CONTEXT_SIZE);
428 have_saved_context = 0;
433 thread_info *th = current_thread;
434 th->context.ContextFlags = CONTEXT_DEBUGGER_DR;
435 GetThreadContext (th->h, &th->context);
436 /* Copy dr values from that thread.
437 But only if there were not modified since last stop. PR gdb/2388 */
438 if (!debug_registers_changed)
440 dr[0] = th->context.Dr0;
441 dr[1] = th->context.Dr1;
442 dr[2] = th->context.Dr2;
443 dr[3] = th->context.Dr3;
444 dr[6] = th->context.Dr6;
445 dr[7] = th->context.Dr7;
448 current_thread->reload_context = 0;
451 if (r == I387_FISEG_REGNUM (tdep))
453 l = *((long *) context_offset) & 0xffff;
454 regcache_raw_supply (regcache, r, (char *) &l);
456 else if (r == I387_FOP_REGNUM (tdep))
458 l = (*((long *) context_offset) >> 16) & ((1 << 11) - 1);
459 regcache_raw_supply (regcache, r, (char *) &l);
462 regcache_raw_supply (regcache, r, context_offset);
465 for (r = 0; r < gdbarch_num_regs (gdbarch); r++)
466 do_windows_fetch_inferior_registers (regcache, r);
471 windows_fetch_inferior_registers (struct target_ops *ops,
472 struct regcache *regcache, int r)
474 current_thread = thread_rec (ptid_get_tid (inferior_ptid), TRUE);
475 /* Check if current_thread exists. Windows sometimes uses a non-existent
476 thread id in its events */
478 do_windows_fetch_inferior_registers (regcache, r);
482 do_windows_store_inferior_registers (const struct regcache *regcache, int r)
485 /* Windows sometimes uses a non-existent thread id in its events */;
487 regcache_raw_collect (regcache, r,
488 ((char *) ¤t_thread->context) + mappings[r]);
491 for (r = 0; r < gdbarch_num_regs (get_regcache_arch (regcache)); r++)
492 do_windows_store_inferior_registers (regcache, r);
496 /* Store a new register value into the current thread context */
498 windows_store_inferior_registers (struct target_ops *ops,
499 struct regcache *regcache, int r)
501 current_thread = thread_rec (ptid_get_tid (inferior_ptid), TRUE);
502 /* Check if current_thread exists. Windows sometimes uses a non-existent
503 thread id in its events */
505 do_windows_store_inferior_registers (regcache, r);
508 /* Get the name of a given module at at given base address. If base_address
509 is zero return the first loaded module (which is always the name of the
512 get_module_name (LPVOID base_address, char *dll_name_ret)
518 HMODULE *DllHandle = dh_buf; /* Set to temporary storage for initial query */
521 cygwin_buf_t pathbuf[__PMAX]; /* Temporary storage prior to converting to
522 posix form. __PMAX is always enough
523 as long as SO_NAME_MAX_PATH_SIZE is defined
528 /* Find size of buffer needed to handle list of modules loaded in inferior */
529 if (!EnumProcessModules (current_process_handle, DllHandle,
530 sizeof (HMODULE), &cbNeeded) || !cbNeeded)
533 /* Allocate correct amount of space for module list */
534 DllHandle = (HMODULE *) alloca (cbNeeded);
538 /* Get the list of modules */
539 if (!EnumProcessModules (current_process_handle, DllHandle, cbNeeded,
543 for (i = 0; i < (int) (cbNeeded / sizeof (HMODULE)); i++)
545 /* Get information on this module */
546 if (!GetModuleInformation (current_process_handle, DllHandle[i],
548 error (_("Can't get module info"));
550 if (!base_address || mi.lpBaseOfDll == base_address)
552 /* Try to find the name of the given module */
554 /* Cygwin prefers that the path be in /x/y/z format */
555 len = GetModuleFileNameEx (current_process_handle,
556 DllHandle[i], pathbuf, __PMAX);
558 error (_("Error getting dll name: %lu."), GetLastError ());
559 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX, pathbuf, dll_name_ret,
561 error (_("Error converting dll name to POSIX: %d."), errno);
563 len = GetModuleFileNameEx (current_process_handle,
564 DllHandle[i], dll_name_ret, __PMAX);
566 error (_("Error getting dll name: %u."), (unsigned) GetLastError ());
568 return 1; /* success */
573 dll_name_ret[0] = '\0';
574 return 0; /* failure */
577 /* Encapsulate the information required in a call to
578 symbol_file_add_args */
579 struct safe_symbol_file_add_args
583 struct section_addr_info *addrs;
586 struct ui_file *err, *out;
590 /* Maintain a linked list of "so" information. */
596 static struct so_list solib_start, *solib_end;
598 /* Call symbol_file_add with stderr redirected. We don't care if there
601 safe_symbol_file_add_stub (void *argv)
603 #define p ((struct safe_symbol_file_add_args *) argv)
604 const int add_flags = ((p->from_tty ? SYMFILE_VERBOSE : 0)
605 | (p->mainline ? SYMFILE_MAINLINE : 0));
606 p->ret = symbol_file_add (p->name, add_flags, p->addrs, p->flags);
611 /* Restore gdb's stderr after calling symbol_file_add */
613 safe_symbol_file_add_cleanup (void *p)
615 #define sp ((struct safe_symbol_file_add_args *)p)
616 gdb_flush (gdb_stderr);
617 gdb_flush (gdb_stdout);
618 ui_file_delete (gdb_stderr);
619 ui_file_delete (gdb_stdout);
620 gdb_stderr = sp->err;
621 gdb_stdout = sp->out;
625 /* symbol_file_add wrapper that prevents errors from being displayed. */
626 static struct objfile *
627 safe_symbol_file_add (char *name, int from_tty,
628 struct section_addr_info *addrs,
629 int mainline, int flags)
631 struct safe_symbol_file_add_args p;
632 struct cleanup *cleanup;
634 cleanup = make_cleanup (safe_symbol_file_add_cleanup, &p);
638 gdb_flush (gdb_stderr);
639 gdb_flush (gdb_stdout);
640 gdb_stderr = ui_file_new ();
641 gdb_stdout = ui_file_new ();
643 p.from_tty = from_tty;
645 p.mainline = mainline;
647 catch_errors (safe_symbol_file_add_stub, &p, "", RETURN_MASK_ERROR);
649 do_cleanups (cleanup);
653 static struct so_list *
654 windows_make_so (const char *name, LPVOID load_addr)
661 WIN32_FIND_DATA w32_fd;
662 HANDLE h = FindFirstFile(name, &w32_fd);
664 if (h == INVALID_HANDLE_VALUE)
670 if (GetCurrentDirectory (MAX_PATH + 1, cwd))
672 p = strrchr (buf, '\\');
675 SetCurrentDirectory (buf);
676 GetFullPathName (w32_fd.cFileName, MAX_PATH, buf, &p);
677 SetCurrentDirectory (cwd);
680 if (strcasecmp (buf, "ntdll.dll") == 0)
682 GetSystemDirectory (buf, sizeof (buf));
683 strcat (buf, "\\ntdll.dll");
686 cygwin_buf_t buf[__PMAX];
689 if (access (name, F_OK) != 0)
691 if (strcasecmp (name, "ntdll.dll") == 0)
694 GetSystemDirectoryW (buf, sizeof (buf) / sizeof (wchar_t));
695 wcscat (buf, L"\\ntdll.dll");
699 GetSystemDirectoryA (buf, sizeof (buf) / sizeof (wchar_t));
700 strcat (buf, "\\ntdll.dll");
705 so = XZALLOC (struct so_list);
706 so->lm_info = (struct lm_info *) xmalloc (sizeof (struct lm_info));
707 so->lm_info->load_addr = load_addr;
708 strcpy (so->so_original_name, name);
710 strcpy (so->so_name, buf);
713 cygwin_conv_path (CCP_WIN_W_TO_POSIX, buf, so->so_name,
714 SO_NAME_MAX_PATH_SIZE);
717 char *rname = realpath (name, NULL);
718 if (rname && strlen (rname) < SO_NAME_MAX_PATH_SIZE)
720 strcpy (so->so_name, rname);
724 error (_("dll path too long"));
726 /* Record cygwin1.dll .text start/end. */
727 p = strchr (so->so_name, '\0') - (sizeof ("/cygwin1.dll") - 1);
728 if (p >= so->so_name && strcasecmp (p, "/cygwin1.dll") == 0)
731 asection *text = NULL;
734 abfd = bfd_openr (so->so_name, "pei-i386");
739 if (bfd_check_format (abfd, bfd_object))
740 text = bfd_get_section_by_name (abfd, ".text");
748 /* The symbols in a dll are offset by 0x1000, which is the the
749 offset from 0 of the first byte in an image - because of the
750 file header and the section alignment. */
751 cygwin_load_start = (CORE_ADDR) (uintptr_t) ((char *) load_addr + 0x1000);
752 cygwin_load_end = cygwin_load_start + bfd_section_size (abfd, text);
762 get_image_name (HANDLE h, void *address, int unicode)
765 static char buf[__PMAX];
767 static char buf[(2 * __PMAX) + 1];
769 DWORD size = unicode ? sizeof (WCHAR) : sizeof (char);
775 /* Attempt to read the name of the dll that was detected.
776 This is documented to work only when actively debugging
777 a program. It will not work for attached processes. */
781 /* See if we could read the address of a string, and that the
782 address isn't null. */
783 if (!ReadProcessMemory (h, address, &address_ptr, sizeof (address_ptr), &done)
784 || done != sizeof (address_ptr) || !address_ptr)
787 /* Find the length of the string */
788 while (ReadProcessMemory (h, address_ptr + len++ * size, &b, size, &done)
789 && (b[0] != 0 || b[size - 1] != 0) && done == size)
793 ReadProcessMemory (h, address_ptr, buf, len, &done);
796 WCHAR *unicode_address = (WCHAR *) alloca (len * sizeof (WCHAR));
797 ReadProcessMemory (h, address_ptr, unicode_address, len * sizeof (WCHAR),
800 wcstombs (buf, unicode_address, __PMAX);
802 WideCharToMultiByte (CP_ACP, 0, unicode_address, len, buf, sizeof buf,
810 /* Wait for child to do something. Return pid of child, or -1 in case
811 of error; store status through argument pointer OURSTATUS. */
813 handle_load_dll (void *dummy)
815 LOAD_DLL_DEBUG_INFO *event = ¤t_event.u.LoadDll;
816 char dll_buf[__PMAX];
817 char *dll_name = NULL;
819 dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0';
821 if (!get_module_name (event->lpBaseOfDll, dll_buf))
822 dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0';
826 if (*dll_name == '\0')
827 dll_name = get_image_name (current_process_handle,
828 event->lpImageName, event->fUnicode);
832 solib_end->next = windows_make_so (dll_name, event->lpBaseOfDll);
833 solib_end = solib_end->next;
835 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end->so_name,
836 host_address_to_string (solib_end->lm_info->load_addr)));
842 windows_free_so (struct so_list *so)
850 handle_unload_dll (void *dummy)
852 LPVOID lpBaseOfDll = current_event.u.UnloadDll.lpBaseOfDll;
855 for (so = &solib_start; so->next != NULL; so = so->next)
856 if (so->next->lm_info->load_addr == lpBaseOfDll)
858 struct so_list *sodel = so->next;
859 so->next = sodel->next;
862 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel->so_name));
864 windows_free_so (sodel);
865 solib_add (NULL, 0, NULL, auto_solib_add);
869 /* We did not find any DLL that was previously loaded at this address,
870 so register a complaint. We do not report an error, because we have
871 observed that this may be happening under some circumstances. For
872 instance, running 32bit applications on x64 Windows causes us to receive
873 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
874 events are apparently caused by the WOW layer, the interface between
875 32bit and 64bit worlds). */
876 complaint (&symfile_complaints, _("dll starting at %s not found."),
877 host_address_to_string (lpBaseOfDll));
882 /* Clear list of loaded DLLs. */
884 windows_clear_solib (void)
886 solib_start.next = NULL;
887 solib_end = &solib_start;
890 /* Load DLL symbol info. */
892 dll_symbol_command (char *args, int from_tty)
898 error (_("dll-symbols requires a file name"));
901 if (n > 4 && strcasecmp (args + n - 4, ".dll") != 0)
903 char *newargs = (char *) alloca (n + 4 + 1);
904 strcpy (newargs, args);
905 strcat (newargs, ".dll");
909 safe_symbol_file_add (args, from_tty, NULL, 0, OBJF_SHARED | OBJF_USERLOADED);
912 /* Handle DEBUG_STRING output from child process.
913 Cygwin prepends its messages with a "cygwin:". Interpret this as
914 a Cygwin signal. Otherwise just print the string as a warning. */
916 handle_output_debug_string (struct target_waitstatus *ourstatus)
921 if (!target_read_string
922 ((CORE_ADDR) (uintptr_t) current_event.u.DebugString.lpDebugStringData,
926 else if (strncmp (s, _CYGWIN_SIGNAL_STRING, sizeof (_CYGWIN_SIGNAL_STRING) - 1) != 0)
929 if (strncmp (s, "cYg", 3) != 0)
933 #ifdef __COPY_CONTEXT_SIZE
936 /* Got a cygwin signal marker. A cygwin signal is followed by the signal number
937 itself and then optionally followed by the thread id and address to saved context
938 within the DLL. If these are supplied, then the given thread is assumed to have
939 issued the signal and the context from the thread is assumed to be stored at the
940 given address in the inferior. Tell gdb to treat this like a real signal. */
942 int sig = strtol (s + sizeof (_CYGWIN_SIGNAL_STRING) - 1, &p, 0);
943 int gotasig = target_signal_from_host (sig);
944 ourstatus->value.sig = gotasig;
949 ourstatus->kind = TARGET_WAITKIND_STOPPED;
950 retval = strtoul (p, &p, 0);
952 retval = main_thread_id;
953 else if ((x = (LPCVOID) strtoul (p, &p, 0))
954 && ReadProcessMemory (current_process_handle, x,
955 &saved_context, __COPY_CONTEXT_SIZE, &n)
956 && n == __COPY_CONTEXT_SIZE)
957 have_saved_context = 1;
958 current_event.dwThreadId = retval;
969 display_selector (HANDLE thread, DWORD sel)
972 if (GetThreadSelectorEntry (thread, sel, &info))
975 printf_filtered ("0x%03lx: ", sel);
976 if (!info.HighWord.Bits.Pres)
978 puts_filtered ("Segment not present\n");
981 base = (info.HighWord.Bits.BaseHi << 24) +
982 (info.HighWord.Bits.BaseMid << 16)
984 limit = (info.HighWord.Bits.LimitHi << 16) + info.LimitLow;
985 if (info.HighWord.Bits.Granularity)
986 limit = (limit << 12) | 0xfff;
987 printf_filtered ("base=0x%08x limit=0x%08x", base, limit);
988 if (info.HighWord.Bits.Default_Big)
989 puts_filtered(" 32-bit ");
991 puts_filtered(" 16-bit ");
992 switch ((info.HighWord.Bits.Type & 0xf) >> 1)
995 puts_filtered ("Data (Read-Only, Exp-up");
998 puts_filtered ("Data (Read/Write, Exp-up");
1001 puts_filtered ("Unused segment (");
1004 puts_filtered ("Data (Read/Write, Exp-down");
1007 puts_filtered ("Code (Exec-Only, N.Conf");
1010 puts_filtered ("Code (Exec/Read, N.Conf");
1013 puts_filtered ("Code (Exec-Only, Conf");
1016 puts_filtered ("Code (Exec/Read, Conf");
1019 printf_filtered ("Unknown type 0x%x",info.HighWord.Bits.Type);
1021 if ((info.HighWord.Bits.Type & 0x1) == 0)
1022 puts_filtered(", N.Acc");
1023 puts_filtered (")\n");
1024 if ((info.HighWord.Bits.Type & 0x10) == 0)
1025 puts_filtered("System selector ");
1026 printf_filtered ("Priviledge level = %d. ", info.HighWord.Bits.Dpl);
1027 if (info.HighWord.Bits.Granularity)
1028 puts_filtered ("Page granular.\n");
1030 puts_filtered ("Byte granular.\n");
1035 DWORD err = GetLastError ();
1036 if (err == ERROR_NOT_SUPPORTED)
1037 printf_filtered ("Function not supported\n");
1039 printf_filtered ("Invalid selector 0x%lx.\n",sel);
1045 display_selectors (char * args, int from_tty)
1047 if (!current_thread)
1049 puts_filtered ("Impossible to display selectors now.\n");
1055 puts_filtered ("Selector $cs\n");
1056 display_selector (current_thread->h,
1057 current_thread->context.SegCs);
1058 puts_filtered ("Selector $ds\n");
1059 display_selector (current_thread->h,
1060 current_thread->context.SegDs);
1061 puts_filtered ("Selector $es\n");
1062 display_selector (current_thread->h,
1063 current_thread->context.SegEs);
1064 puts_filtered ("Selector $ss\n");
1065 display_selector (current_thread->h,
1066 current_thread->context.SegSs);
1067 puts_filtered ("Selector $fs\n");
1068 display_selector (current_thread->h,
1069 current_thread->context.SegFs);
1070 puts_filtered ("Selector $gs\n");
1071 display_selector (current_thread->h,
1072 current_thread->context.SegGs);
1077 sel = parse_and_eval_long (args);
1078 printf_filtered ("Selector \"%s\"\n",args);
1079 display_selector (current_thread->h, sel);
1083 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1084 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1085 host_address_to_string (\
1086 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1089 handle_exception (struct target_waitstatus *ourstatus)
1092 DWORD code = current_event.u.Exception.ExceptionRecord.ExceptionCode;
1094 ourstatus->kind = TARGET_WAITKIND_STOPPED;
1096 /* Record the context of the current thread */
1097 th = thread_rec (current_event.dwThreadId, -1);
1101 case EXCEPTION_ACCESS_VIOLATION:
1102 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1103 ourstatus->value.sig = TARGET_SIGNAL_SEGV;
1106 /* See if the access violation happened within the cygwin DLL itself. Cygwin uses
1107 a kind of exception handling to deal with passed-in invalid addresses. gdb
1108 should not treat these as real SEGVs since they will be silently handled by
1109 cygwin. A real SEGV will (theoretically) be caught by cygwin later in the process
1110 and will be sent as a cygwin-specific-signal. So, ignore SEGVs if they show up
1111 within the text segment of the DLL itself. */
1113 CORE_ADDR addr = (CORE_ADDR) (uintptr_t) current_event.u.Exception.ExceptionRecord.ExceptionAddress;
1114 if ((!cygwin_exceptions && (addr >= cygwin_load_start && addr < cygwin_load_end))
1115 || (find_pc_partial_function (addr, &fn, NULL, NULL)
1116 && strncmp (fn, "KERNEL32!IsBad", strlen ("KERNEL32!IsBad")) == 0))
1121 case STATUS_STACK_OVERFLOW:
1122 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1123 ourstatus->value.sig = TARGET_SIGNAL_SEGV;
1125 case STATUS_FLOAT_DENORMAL_OPERAND:
1126 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1127 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1129 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
1130 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1131 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1133 case STATUS_FLOAT_INEXACT_RESULT:
1134 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1135 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1137 case STATUS_FLOAT_INVALID_OPERATION:
1138 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1139 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1141 case STATUS_FLOAT_OVERFLOW:
1142 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1143 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1145 case STATUS_FLOAT_STACK_CHECK:
1146 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1147 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1149 case STATUS_FLOAT_UNDERFLOW:
1150 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1151 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1153 case STATUS_FLOAT_DIVIDE_BY_ZERO:
1154 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1155 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1157 case STATUS_INTEGER_DIVIDE_BY_ZERO:
1158 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1159 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1161 case STATUS_INTEGER_OVERFLOW:
1162 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1163 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1165 case EXCEPTION_BREAKPOINT:
1166 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1167 ourstatus->value.sig = TARGET_SIGNAL_TRAP;
1170 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1171 ourstatus->value.sig = TARGET_SIGNAL_INT;
1173 case DBG_CONTROL_BREAK:
1174 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1175 ourstatus->value.sig = TARGET_SIGNAL_INT;
1177 case EXCEPTION_SINGLE_STEP:
1178 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1179 ourstatus->value.sig = TARGET_SIGNAL_TRAP;
1181 case EXCEPTION_ILLEGAL_INSTRUCTION:
1182 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1183 ourstatus->value.sig = TARGET_SIGNAL_ILL;
1185 case EXCEPTION_PRIV_INSTRUCTION:
1186 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1187 ourstatus->value.sig = TARGET_SIGNAL_ILL;
1189 case EXCEPTION_NONCONTINUABLE_EXCEPTION:
1190 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1191 ourstatus->value.sig = TARGET_SIGNAL_ILL;
1194 /* Treat unhandled first chance exceptions specially. */
1195 if (current_event.u.Exception.dwFirstChance)
1197 printf_unfiltered ("gdb: unknown target exception 0x%08lx at %s\n",
1198 current_event.u.Exception.ExceptionRecord.ExceptionCode,
1199 host_address_to_string (
1200 current_event.u.Exception.ExceptionRecord.ExceptionAddress));
1201 ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
1205 last_sig = ourstatus->value.sig;
1209 /* Resume all artificially suspended threads if we are continuing
1212 windows_continue (DWORD continue_status, int id)
1218 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%lx, %s);\n",
1219 current_event.dwProcessId, current_event.dwThreadId,
1220 continue_status == DBG_CONTINUE ?
1221 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1223 for (th = &thread_head; (th = th->next) != NULL;)
1224 if ((id == -1 || id == (int) th->id)
1227 if (debug_registers_changed)
1229 th->context.ContextFlags |= CONTEXT_DEBUG_REGISTERS;
1230 th->context.Dr0 = dr[0];
1231 th->context.Dr1 = dr[1];
1232 th->context.Dr2 = dr[2];
1233 th->context.Dr3 = dr[3];
1234 th->context.Dr6 = DR6_CLEAR_VALUE;
1235 th->context.Dr7 = dr[7];
1237 if (th->context.ContextFlags)
1239 CHECK (SetThreadContext (th->h, &th->context));
1240 th->context.ContextFlags = 0;
1242 if (th->suspended > 0)
1243 (void) ResumeThread (th->h);
1247 res = ContinueDebugEvent (current_event.dwProcessId,
1248 current_event.dwThreadId,
1251 debug_registers_changed = 0;
1255 /* Called in pathological case where Windows fails to send a
1256 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1258 fake_create_process (void)
1260 current_process_handle = OpenProcess (PROCESS_ALL_ACCESS, FALSE,
1261 current_event.dwProcessId);
1262 if (current_process_handle != NULL)
1263 open_process_used = 1;
1266 error (_("OpenProcess call failed, GetLastError = %lud\n"),
1268 /* We can not debug anything in that case. */
1270 main_thread_id = current_event.dwThreadId;
1271 current_thread = windows_add_thread (
1272 ptid_build (current_event.dwProcessId, 0,
1273 current_event.dwThreadId),
1274 current_event.u.CreateThread.hThread,
1275 current_event.u.CreateThread.lpThreadLocalBase);
1276 return main_thread_id;
1280 windows_resume (struct target_ops *ops,
1281 ptid_t ptid, int step, enum target_signal sig)
1284 DWORD continue_status = DBG_CONTINUE;
1286 /* A specific PTID means `step only this thread id'. */
1287 int resume_all = ptid_equal (ptid, minus_one_ptid);
1289 /* If we're continuing all threads, it's the current inferior that
1290 should be handled specially. */
1292 ptid = inferior_ptid;
1294 if (sig != TARGET_SIGNAL_0)
1296 if (current_event.dwDebugEventCode != EXCEPTION_DEBUG_EVENT)
1298 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig));
1300 else if (sig == last_sig)
1301 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1304 /* This code does not seem to work, because
1305 the kernel does probably not consider changes in the ExceptionRecord
1306 structure when passing the exception to the inferior.
1307 Note that this seems possible in the exception handler itself. */
1310 for (i = 0; xlate[i].them != -1; i++)
1311 if (xlate[i].us == sig)
1313 current_event.u.Exception.ExceptionRecord.ExceptionCode =
1315 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1318 if (continue_status == DBG_CONTINUE)
1320 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig));
1324 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1328 last_sig = TARGET_SIGNAL_0;
1330 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1331 ptid_get_pid (ptid), ptid_get_tid (ptid), step, sig));
1333 /* Get context for currently selected thread */
1334 th = thread_rec (ptid_get_tid (inferior_ptid), FALSE);
1339 /* Single step by setting t bit */
1340 struct regcache *regcache = get_current_regcache ();
1341 struct gdbarch *gdbarch = get_regcache_arch (regcache);
1342 windows_fetch_inferior_registers (ops, regcache,
1343 gdbarch_ps_regnum (gdbarch));
1344 th->context.EFlags |= FLAG_TRACE_BIT;
1347 if (th->context.ContextFlags)
1349 if (debug_registers_changed)
1351 th->context.Dr0 = dr[0];
1352 th->context.Dr1 = dr[1];
1353 th->context.Dr2 = dr[2];
1354 th->context.Dr3 = dr[3];
1355 th->context.Dr6 = DR6_CLEAR_VALUE;
1356 th->context.Dr7 = dr[7];
1358 CHECK (SetThreadContext (th->h, &th->context));
1359 th->context.ContextFlags = 0;
1363 /* Allow continuing with the same signal that interrupted us.
1364 Otherwise complain. */
1367 windows_continue (continue_status, -1);
1369 windows_continue (continue_status, ptid_get_tid (ptid));
1372 /* Ctrl-C handler used when the inferior is not run in the same console. The
1373 handler is in charge of interrupting the inferior using DebugBreakProcess.
1374 Note that this function is not available prior to Windows XP. In this case
1375 we emit a warning. */
1377 ctrl_c_handler (DWORD event_type)
1379 const int attach_flag = current_inferior ()->attach_flag;
1381 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1382 if (event_type != CTRL_C_EVENT && event_type != CTRL_BREAK_EVENT)
1385 /* If the inferior and the debugger share the same console, do nothing as
1386 the inferior has also received the Ctrl-C event. */
1387 if (!new_console && !attach_flag)
1390 if (!DebugBreakProcess (current_process_handle))
1392 Could not interrupt program. Press Ctrl-c in the program console."));
1394 /* Return true to tell that Ctrl-C has been handled. */
1398 /* Get the next event from the child. Return 1 if the event requires
1399 handling by WFI (or whatever). */
1401 get_windows_debug_event (struct target_ops *ops,
1402 int pid, struct target_waitstatus *ourstatus)
1405 DWORD continue_status, event_code;
1407 static thread_info dummy_thread_info;
1410 last_sig = TARGET_SIGNAL_0;
1412 if (!(debug_event = WaitForDebugEvent (¤t_event, 1000)))
1416 continue_status = DBG_CONTINUE;
1418 event_code = current_event.dwDebugEventCode;
1419 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
1421 have_saved_context = 0;
1425 case CREATE_THREAD_DEBUG_EVENT:
1426 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1427 (unsigned) current_event.dwProcessId,
1428 (unsigned) current_event.dwThreadId,
1429 "CREATE_THREAD_DEBUG_EVENT"));
1430 if (saw_create != 1)
1432 struct inferior *inf;
1433 inf = find_inferior_pid (current_event.dwProcessId);
1434 if (!saw_create && inf->attach_flag)
1436 /* Kludge around a Windows bug where first event is a create
1437 thread event. Caused when attached process does not have
1439 retval = fake_create_process ();
1445 /* Record the existence of this thread */
1446 retval = current_event.dwThreadId;
1447 th = windows_add_thread (ptid_build (current_event.dwProcessId, 0,
1448 current_event.dwThreadId),
1449 current_event.u.CreateThread.hThread,
1450 current_event.u.CreateThread.lpThreadLocalBase);
1454 case EXIT_THREAD_DEBUG_EVENT:
1455 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1456 (unsigned) current_event.dwProcessId,
1457 (unsigned) current_event.dwThreadId,
1458 "EXIT_THREAD_DEBUG_EVENT"));
1460 if (current_event.dwThreadId != main_thread_id)
1462 windows_delete_thread (ptid_build (current_event.dwProcessId, 0,
1463 current_event.dwThreadId));
1464 th = &dummy_thread_info;
1468 case CREATE_PROCESS_DEBUG_EVENT:
1469 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1470 (unsigned) current_event.dwProcessId,
1471 (unsigned) current_event.dwThreadId,
1472 "CREATE_PROCESS_DEBUG_EVENT"));
1473 CloseHandle (current_event.u.CreateProcessInfo.hFile);
1474 if (++saw_create != 1)
1477 current_process_handle = current_event.u.CreateProcessInfo.hProcess;
1479 windows_delete_thread (ptid_build (current_event.dwProcessId, 0,
1481 main_thread_id = current_event.dwThreadId;
1482 /* Add the main thread */
1483 th = windows_add_thread (ptid_build (current_event.dwProcessId, 0,
1484 current_event.dwThreadId),
1485 current_event.u.CreateProcessInfo.hThread,
1486 current_event.u.CreateProcessInfo.lpThreadLocalBase);
1487 retval = current_event.dwThreadId;
1490 case EXIT_PROCESS_DEBUG_EVENT:
1491 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1492 (unsigned) current_event.dwProcessId,
1493 (unsigned) current_event.dwThreadId,
1494 "EXIT_PROCESS_DEBUG_EVENT"));
1495 if (!windows_initialization_done)
1497 target_terminal_ours ();
1498 target_mourn_inferior ();
1499 error (_("During startup program exited with code 0x%x."),
1500 (unsigned int) current_event.u.ExitProcess.dwExitCode);
1502 else if (saw_create == 1)
1504 ourstatus->kind = TARGET_WAITKIND_EXITED;
1505 ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode;
1506 retval = main_thread_id;
1510 case LOAD_DLL_DEBUG_EVENT:
1511 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1512 (unsigned) current_event.dwProcessId,
1513 (unsigned) current_event.dwThreadId,
1514 "LOAD_DLL_DEBUG_EVENT"));
1515 CloseHandle (current_event.u.LoadDll.hFile);
1516 if (saw_create != 1)
1518 catch_errors (handle_load_dll, NULL, (char *) "", RETURN_MASK_ALL);
1519 ourstatus->kind = TARGET_WAITKIND_LOADED;
1520 ourstatus->value.integer = 0;
1521 retval = main_thread_id;
1524 case UNLOAD_DLL_DEBUG_EVENT:
1525 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1526 (unsigned) current_event.dwProcessId,
1527 (unsigned) current_event.dwThreadId,
1528 "UNLOAD_DLL_DEBUG_EVENT"));
1529 if (saw_create != 1)
1531 catch_errors (handle_unload_dll, NULL, (char *) "", RETURN_MASK_ALL);
1532 ourstatus->kind = TARGET_WAITKIND_LOADED;
1533 ourstatus->value.integer = 0;
1534 retval = main_thread_id;
1537 case EXCEPTION_DEBUG_EVENT:
1538 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1539 (unsigned) current_event.dwProcessId,
1540 (unsigned) current_event.dwThreadId,
1541 "EXCEPTION_DEBUG_EVENT"));
1542 if (saw_create != 1)
1544 switch (handle_exception (ourstatus))
1547 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1550 retval = current_event.dwThreadId;
1554 continue_status = -1;
1559 case OUTPUT_DEBUG_STRING_EVENT: /* message from the kernel */
1560 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1561 (unsigned) current_event.dwProcessId,
1562 (unsigned) current_event.dwThreadId,
1563 "OUTPUT_DEBUG_STRING_EVENT"));
1564 if (saw_create != 1)
1566 retval = handle_output_debug_string (ourstatus);
1570 if (saw_create != 1)
1572 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1573 (DWORD) current_event.dwProcessId,
1574 (DWORD) current_event.dwThreadId);
1575 printf_unfiltered (" unknown event code %ld\n",
1576 current_event.dwDebugEventCode);
1580 if (!retval || saw_create != 1)
1582 if (continue_status == -1)
1583 windows_resume (ops, minus_one_ptid, 0, 1);
1585 CHECK (windows_continue (continue_status, -1));
1589 inferior_ptid = ptid_build (current_event.dwProcessId, 0,
1591 current_thread = th ?: thread_rec (current_event.dwThreadId, TRUE);
1598 /* Wait for interesting events to occur in the target process. */
1600 windows_wait (struct target_ops *ops,
1601 ptid_t ptid, struct target_waitstatus *ourstatus, int options)
1605 target_terminal_ours ();
1607 /* We loop when we get a non-standard exception rather than return
1608 with a SPURIOUS because resume can try and step or modify things,
1609 which needs a current_thread->h. But some of these exceptions mark
1610 the birth or death of threads, which mean that the current thread
1611 isn't necessarily what you think it is. */
1617 /* If the user presses Ctrl-c while the debugger is waiting
1618 for an event, he expects the debugger to interrupt his program
1619 and to get the prompt back. There are two possible situations:
1621 - The debugger and the program do not share the console, in
1622 which case the Ctrl-c event only reached the debugger.
1623 In that case, the ctrl_c handler will take care of interrupting
1624 the inferior. Note that this case is working starting with
1625 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1628 - The debugger and the program share the same console, in which
1629 case both debugger and inferior will receive the Ctrl-c event.
1630 In that case the ctrl_c handler will ignore the event, as the
1631 Ctrl-c event generated inside the inferior will trigger the
1632 expected debug event.
1634 FIXME: brobecker/2008-05-20: If the inferior receives the
1635 signal first and the delay until GDB receives that signal
1636 is sufficiently long, GDB can sometimes receive the SIGINT
1637 after we have unblocked the CTRL+C handler. This would
1638 lead to the debugger stopping prematurely while handling
1639 the new-thread event that comes with the handling of the SIGINT
1640 inside the inferior, and then stop again immediately when
1641 the user tries to resume the execution in the inferior.
1642 This is a classic race that we should try to fix one day. */
1643 SetConsoleCtrlHandler (&ctrl_c_handler, TRUE);
1644 retval = get_windows_debug_event (ops, pid, ourstatus);
1645 SetConsoleCtrlHandler (&ctrl_c_handler, FALSE);
1648 return ptid_build (current_event.dwProcessId, 0, retval);
1653 if (deprecated_ui_loop_hook != NULL)
1654 detach = deprecated_ui_loop_hook (0);
1657 windows_kill_inferior (ops);
1663 do_initial_windows_stuff (struct target_ops *ops, DWORD pid, int attaching)
1665 extern int stop_after_trap;
1667 struct inferior *inf;
1668 struct thread_info *tp;
1670 last_sig = TARGET_SIGNAL_0;
1672 exception_count = 0;
1673 open_process_used = 0;
1674 debug_registers_changed = 0;
1675 debug_registers_used = 0;
1676 for (i = 0; i < sizeof (dr) / sizeof (dr[0]); i++)
1679 cygwin_load_start = cygwin_load_end = 0;
1681 current_event.dwProcessId = pid;
1682 memset (¤t_event, 0, sizeof (current_event));
1684 disable_breakpoints_in_shlibs ();
1685 windows_clear_solib ();
1686 clear_proceed_status ();
1687 init_wait_for_inferior ();
1689 inf = current_inferior ();
1690 inferior_appeared (inf, pid);
1691 inf->attach_flag = attaching;
1693 /* Make the new process the current inferior, so terminal handling
1694 can rely on it. When attaching, we don't know about any thread
1695 id here, but that's OK --- nothing should be referencing the
1696 current thread until we report an event out of windows_wait. */
1697 inferior_ptid = pid_to_ptid (pid);
1699 terminal_init_inferior_with_pgrp (pid);
1700 target_terminal_inferior ();
1702 windows_initialization_done = 0;
1703 inf->stop_soon = STOP_QUIETLY;
1706 stop_after_trap = 1;
1707 wait_for_inferior (0);
1708 tp = inferior_thread ();
1709 if (tp->stop_signal != TARGET_SIGNAL_TRAP)
1710 resume (0, tp->stop_signal);
1715 windows_initialization_done = 1;
1716 inf->stop_soon = NO_STOP_QUIETLY;
1717 stop_after_trap = 0;
1721 /* Try to set or remove a user privilege to the current process. Return -1
1722 if that fails, the previous setting of that privilege otherwise.
1724 This code is copied from the Cygwin source code and rearranged to allow
1725 dynamically loading of the needed symbols from advapi32 which is only
1726 available on NT/2K/XP. */
1728 set_process_privilege (const char *privilege, BOOL enable)
1730 HANDLE token_hdl = NULL;
1732 TOKEN_PRIVILEGES new_priv, orig_priv;
1736 if (!OpenProcessToken (GetCurrentProcess (),
1737 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
1741 if (!LookupPrivilegeValueA (NULL, privilege, &restore_priv))
1744 new_priv.PrivilegeCount = 1;
1745 new_priv.Privileges[0].Luid = restore_priv;
1746 new_priv.Privileges[0].Attributes = enable ? SE_PRIVILEGE_ENABLED : 0;
1748 if (!AdjustTokenPrivileges (token_hdl, FALSE, &new_priv,
1749 sizeof orig_priv, &orig_priv, &size))
1752 /* Disabled, otherwise every `attach' in an unprivileged user session
1753 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1754 windows_attach(). */
1755 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1756 be enabled. GetLastError () returns an correct error code, though. */
1757 if (enable && GetLastError () == ERROR_NOT_ALL_ASSIGNED)
1761 ret = orig_priv.Privileges[0].Attributes == SE_PRIVILEGE_ENABLED ? 1 : 0;
1765 CloseHandle (token_hdl);
1770 /* Attach to process PID, then initialize for debugging it. */
1772 windows_attach (struct target_ops *ops, char *args, int from_tty)
1777 pid = parse_pid_to_attach (args);
1779 if (set_process_privilege (SE_DEBUG_NAME, TRUE) < 0)
1781 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1782 printf_unfiltered ("This can cause attach to fail on Windows NT/2K/XP\n");
1785 windows_init_thread_list ();
1786 ok = DebugActiveProcess (pid);
1792 /* Try fall back to Cygwin pid */
1793 pid = cygwin_internal (CW_CYGWIN_PID_TO_WINPID, pid);
1796 ok = DebugActiveProcess (pid);
1801 error (_("Can't attach to process."));
1803 DebugSetProcessKillOnExit (FALSE);
1807 char *exec_file = (char *) get_exec_file (0);
1810 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
1811 target_pid_to_str (pid_to_ptid (pid)));
1813 printf_unfiltered ("Attaching to %s\n",
1814 target_pid_to_str (pid_to_ptid (pid)));
1816 gdb_flush (gdb_stdout);
1819 do_initial_windows_stuff (ops, pid, 1);
1820 target_terminal_ours ();
1824 windows_detach (struct target_ops *ops, char *args, int from_tty)
1829 windows_resume (ops, ptid, 0, TARGET_SIGNAL_0);
1831 if (!DebugActiveProcessStop (current_event.dwProcessId))
1833 error (_("Can't detach process %lu (error %lu)"),
1834 current_event.dwProcessId, GetLastError ());
1837 DebugSetProcessKillOnExit (FALSE);
1839 if (detached && from_tty)
1841 char *exec_file = get_exec_file (0);
1844 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file,
1845 current_event.dwProcessId);
1846 gdb_flush (gdb_stdout);
1849 inferior_ptid = null_ptid;
1850 detach_inferior (current_event.dwProcessId);
1852 unpush_target (ops);
1856 windows_pid_to_exec_file (int pid)
1858 static char path[__PMAX];
1860 /* Try to find exe name as symlink target of /proc/<pid>/exe */
1862 char procexe[sizeof ("/proc/4294967295/exe")];
1863 sprintf (procexe, "/proc/%u/exe", pid);
1864 nchars = readlink (procexe, path, sizeof(path));
1865 if (nchars > 0 && nchars < sizeof (path))
1867 path[nchars] = '\0'; /* Got it */
1872 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
1873 of gdb, or we're trying to debug a non-Cygwin windows executable. */
1874 if (!get_module_name (0, path))
1880 /* Print status information about what we're accessing. */
1883 windows_files_info (struct target_ops *ignore)
1885 struct inferior *inf = current_inferior ();
1887 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1888 inf->attach_flag ? "attached" : "child",
1889 target_pid_to_str (inferior_ptid));
1893 windows_open (char *arg, int from_tty)
1895 error (_("Use the \"run\" command to start a Unix child process."));
1898 /* Start an inferior windows child process and sets inferior_ptid to its pid.
1899 EXEC_FILE is the file to run.
1900 ALLARGS is a string containing the arguments to the program.
1901 ENV is the environment vector to pass. Errors reported with error(). */
1904 windows_create_inferior (struct target_ops *ops, char *exec_file,
1905 char *allargs, char **in_env, int from_tty)
1909 cygwin_buf_t real_path[__PMAX];
1910 cygwin_buf_t shell[__PMAX]; /* Path to shell */
1912 cygwin_buf_t *toexec;
1913 cygwin_buf_t *cygallargs;
1917 int ostdin, ostdout, ostderr;
1919 char real_path[__PMAX];
1920 char shell[__PMAX]; /* Path to shell */
1925 PROCESS_INFORMATION pi;
1928 const char *inferior_io_terminal = get_inferior_io_terminal ();
1931 error (_("No executable specified, use `target exec'."));
1933 memset (&si, 0, sizeof (si));
1934 si.cb = sizeof (si);
1937 flags |= CREATE_NEW_PROCESS_GROUP;
1940 flags |= CREATE_NEW_CONSOLE;
1945 flags |= DEBUG_ONLY_THIS_PROCESS;
1946 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W, exec_file, real_path,
1947 __PMAX * sizeof (cygwin_buf_t)) < 0)
1948 error (_("Error starting executable: %d"), errno);
1951 len = mbstowcs (NULL, allargs, 0) + 1;
1952 if (len == (size_t) -1)
1953 error (_("Error starting executable: %d"), errno);
1954 cygallargs = (wchar_t *) alloca (len * sizeof (wchar_t));
1955 mbstowcs (cygallargs, allargs, len);
1957 cygallargs = allargs;
1962 sh = getenv ("SHELL");
1965 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W, sh, shell, __PMAX) < 0)
1966 error (_("Error starting executable via shell: %d"), errno);
1968 len = sizeof (L" -c 'exec '") + mbstowcs (NULL, exec_file, 0)
1969 + mbstowcs (NULL, allargs, 0) + 2;
1970 cygallargs = (wchar_t *) alloca (len * sizeof (wchar_t));
1971 swprintf (cygallargs, len, L" -c 'exec %s %s'", exec_file, allargs);
1973 cygallargs = (char *) alloca (sizeof (" -c 'exec '") + strlen (exec_file)
1974 + strlen (allargs) + 2);
1975 sprintf (cygallargs, " -c 'exec %s %s'", exec_file, allargs);
1978 flags |= DEBUG_PROCESS;
1982 args = (cygwin_buf_t *) alloca ((wcslen (toexec) + wcslen (cygallargs) + 2)
1983 * sizeof (wchar_t));
1984 wcscpy (args, toexec);
1985 wcscat (args, L" ");
1986 wcscat (args, cygallargs);
1988 args = (cygwin_buf_t *) alloca (strlen (toexec) + strlen (cygallargs) + 2);
1989 strcpy (args, toexec);
1991 strcat (args, cygallargs);
1994 /* Prepare the environment vars for CreateProcess. */
1995 cygwin_internal (CW_SYNC_WINENV);
1997 if (!inferior_io_terminal)
1998 tty = ostdin = ostdout = ostderr = -1;
2001 tty = open (inferior_io_terminal, O_RDWR | O_NOCTTY);
2004 print_sys_errmsg (inferior_io_terminal, errno);
2005 ostdin = ostdout = ostderr = -1;
2018 windows_init_thread_list ();
2019 ret = CreateProcess (0,
2020 args, /* command line */
2021 NULL, /* Security */
2023 TRUE, /* inherit handles */
2024 flags, /* start flags */
2025 NULL, /* environment */
2026 NULL, /* current directory */
2041 args = alloca (strlen (toexec) + strlen (allargs) + 2);
2042 strcpy (args, toexec);
2044 strcat (args, allargs);
2046 flags |= DEBUG_ONLY_THIS_PROCESS;
2048 if (!inferior_io_terminal)
2049 tty = INVALID_HANDLE_VALUE;
2052 SECURITY_ATTRIBUTES sa;
2053 sa.nLength = sizeof(sa);
2054 sa.lpSecurityDescriptor = 0;
2055 sa.bInheritHandle = TRUE;
2056 tty = CreateFileA (inferior_io_terminal, GENERIC_READ | GENERIC_WRITE,
2057 0, &sa, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
2058 if (tty == INVALID_HANDLE_VALUE)
2059 warning (_("Warning: Failed to open TTY %s, error %#x."),
2060 inferior_io_terminal, (unsigned) GetLastError ());
2064 si.hStdOutput = tty;
2066 si.dwFlags |= STARTF_USESTDHANDLES;
2070 windows_init_thread_list ();
2071 ret = CreateProcessA (0,
2072 args, /* command line */
2073 NULL, /* Security */
2075 TRUE, /* inherit handles */
2076 flags, /* start flags */
2077 NULL, /* environment */
2078 NULL, /* current directory */
2081 if (tty != INVALID_HANDLE_VALUE)
2086 error (_("Error creating process %s, (error %d)."),
2087 exec_file, (unsigned) GetLastError ());
2089 CloseHandle (pi.hThread);
2090 CloseHandle (pi.hProcess);
2092 if (useshell && shell[0] != '\0')
2097 do_initial_windows_stuff (ops, pi.dwProcessId, 0);
2099 /* windows_continue (DBG_CONTINUE, -1); */
2103 windows_mourn_inferior (struct target_ops *ops)
2105 (void) windows_continue (DBG_CONTINUE, -1);
2106 i386_cleanup_dregs();
2107 if (open_process_used)
2109 CHECK (CloseHandle (current_process_handle));
2110 open_process_used = 0;
2112 unpush_target (ops);
2113 generic_mourn_inferior ();
2116 /* Send a SIGINT to the process group. This acts just like the user typed a
2117 ^C on the controlling terminal. */
2120 windows_stop (ptid_t ptid)
2122 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2123 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId));
2124 registers_changed (); /* refresh register state */
2128 windows_xfer_memory (CORE_ADDR memaddr, gdb_byte *our, int len,
2129 int write, struct mem_attrib *mem,
2130 struct target_ops *target)
2135 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
2136 len, (DWORD) (uintptr_t) memaddr));
2137 if (!WriteProcessMemory (current_process_handle,
2138 (LPVOID) (uintptr_t) memaddr, our,
2141 FlushInstructionCache (current_process_handle,
2142 (LPCVOID) (uintptr_t) memaddr, len);
2146 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
2147 len, (DWORD) (uintptr_t) memaddr));
2148 if (!ReadProcessMemory (current_process_handle,
2149 (LPCVOID) (uintptr_t) memaddr, our,
2157 windows_kill_inferior (struct target_ops *ops)
2159 CHECK (TerminateProcess (current_process_handle, 0));
2163 if (!windows_continue (DBG_CONTINUE, -1))
2165 if (!WaitForDebugEvent (¤t_event, INFINITE))
2167 if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
2171 target_mourn_inferior (); /* or just windows_mourn_inferior? */
2175 windows_prepare_to_store (struct regcache *regcache)
2177 /* Do nothing, since we can store individual regs */
2181 windows_can_run (void)
2187 windows_close (int x)
2189 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2190 PIDGET (inferior_ptid)));
2193 /* Convert pid to printable format. */
2195 windows_pid_to_str (struct target_ops *ops, ptid_t ptid)
2197 static char buf[80];
2199 if (ptid_get_tid (ptid) != 0)
2201 snprintf (buf, sizeof (buf), "Thread %d.0x%lx",
2202 ptid_get_pid (ptid), ptid_get_tid (ptid));
2206 return normal_pid_to_str (ptid);
2210 windows_xfer_shared_libraries (struct target_ops *ops,
2211 enum target_object object, const char *annex,
2212 gdb_byte *readbuf, const gdb_byte *writebuf,
2213 ULONGEST offset, LONGEST len)
2215 struct obstack obstack;
2223 obstack_init (&obstack);
2224 obstack_grow_str (&obstack, "<library-list>\n");
2225 for (so = solib_start.next; so; so = so->next)
2226 windows_xfer_shared_library (so->so_name, (CORE_ADDR) (uintptr_t) so->lm_info->load_addr,
2227 target_gdbarch, &obstack);
2228 obstack_grow_str0 (&obstack, "</library-list>\n");
2230 buf = obstack_finish (&obstack);
2231 len_avail = strlen (buf);
2232 if (offset >= len_avail)
2235 if (len > len_avail - offset)
2236 len = len_avail - offset;
2237 memcpy (readbuf, buf + offset, len);
2239 obstack_free (&obstack, NULL);
2244 windows_xfer_partial (struct target_ops *ops, enum target_object object,
2245 const char *annex, gdb_byte *readbuf,
2246 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
2250 case TARGET_OBJECT_MEMORY:
2252 return (*ops->deprecated_xfer_memory) (offset, readbuf,
2253 len, 0/*read*/, NULL, ops);
2255 return (*ops->deprecated_xfer_memory) (offset, (gdb_byte *) writebuf,
2256 len, 1/*write*/, NULL, ops);
2259 case TARGET_OBJECT_LIBRARIES:
2260 return windows_xfer_shared_libraries (ops, object, annex, readbuf,
2261 writebuf, offset, len);
2264 if (ops->beneath != NULL)
2265 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
2266 readbuf, writebuf, offset, len);
2271 /* Provide thread local base, i.e. Thread Information Block address.
2272 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
2275 windows_get_tib_address (ptid_t ptid, CORE_ADDR *addr)
2279 th = thread_rec (ptid_get_tid (ptid), 0);
2284 *addr = th->thread_local_base;
2290 windows_get_ada_task_ptid (long lwp, long thread)
2292 return ptid_build (ptid_get_pid (inferior_ptid), 0, lwp);
2296 init_windows_ops (void)
2298 windows_ops.to_shortname = "child";
2299 windows_ops.to_longname = "Win32 child process";
2300 windows_ops.to_doc = "Win32 child process (started by the \"run\" command).";
2301 windows_ops.to_open = windows_open;
2302 windows_ops.to_close = windows_close;
2303 windows_ops.to_attach = windows_attach;
2304 windows_ops.to_attach_no_wait = 1;
2305 windows_ops.to_detach = windows_detach;
2306 windows_ops.to_resume = windows_resume;
2307 windows_ops.to_wait = windows_wait;
2308 windows_ops.to_fetch_registers = windows_fetch_inferior_registers;
2309 windows_ops.to_store_registers = windows_store_inferior_registers;
2310 windows_ops.to_prepare_to_store = windows_prepare_to_store;
2311 windows_ops.deprecated_xfer_memory = windows_xfer_memory;
2312 windows_ops.to_xfer_partial = windows_xfer_partial;
2313 windows_ops.to_files_info = windows_files_info;
2314 windows_ops.to_insert_breakpoint = memory_insert_breakpoint;
2315 windows_ops.to_remove_breakpoint = memory_remove_breakpoint;
2316 windows_ops.to_terminal_init = terminal_init_inferior;
2317 windows_ops.to_terminal_inferior = terminal_inferior;
2318 windows_ops.to_terminal_ours_for_output = terminal_ours_for_output;
2319 windows_ops.to_terminal_ours = terminal_ours;
2320 windows_ops.to_terminal_save_ours = terminal_save_ours;
2321 windows_ops.to_terminal_info = child_terminal_info;
2322 windows_ops.to_kill = windows_kill_inferior;
2323 windows_ops.to_create_inferior = windows_create_inferior;
2324 windows_ops.to_mourn_inferior = windows_mourn_inferior;
2325 windows_ops.to_can_run = windows_can_run;
2326 windows_ops.to_thread_alive = windows_thread_alive;
2327 windows_ops.to_pid_to_str = windows_pid_to_str;
2328 windows_ops.to_stop = windows_stop;
2329 windows_ops.to_stratum = process_stratum;
2330 windows_ops.to_has_all_memory = default_child_has_all_memory;
2331 windows_ops.to_has_memory = default_child_has_memory;
2332 windows_ops.to_has_stack = default_child_has_stack;
2333 windows_ops.to_has_registers = default_child_has_registers;
2334 windows_ops.to_has_execution = default_child_has_execution;
2335 windows_ops.to_pid_to_exec_file = windows_pid_to_exec_file;
2336 windows_ops.to_get_ada_task_ptid = windows_get_ada_task_ptid;
2337 windows_ops.to_get_tib_address = windows_get_tib_address;
2339 i386_use_watchpoints (&windows_ops);
2341 i386_dr_low.set_control = cygwin_set_dr7;
2342 i386_dr_low.set_addr = cygwin_set_dr;
2343 i386_dr_low.reset_addr = NULL;
2344 i386_dr_low.get_status = cygwin_get_dr6;
2346 /* i386_dr_low.debug_register_length field is set by
2347 calling i386_set_debug_register_length function
2348 in processor windows specific native file. */
2350 windows_ops.to_magic = OPS_MAGIC;
2354 set_windows_aliases (char *argv0)
2356 add_info_alias ("dll", "sharedlibrary", 1);
2360 _initialize_windows_nat (void)
2362 struct cmd_list_element *c;
2364 init_windows_ops ();
2367 cygwin_internal (CW_SET_DOS_FILE_WARNING, 0);
2370 c = add_com ("dll-symbols", class_files, dll_symbol_command,
2371 _("Load dll library symbols from FILE."));
2372 set_cmd_completer (c, filename_completer);
2374 add_com_alias ("sharedlibrary", "dll-symbols", class_alias, 1);
2376 add_com_alias ("add-shared-symbol-files", "dll-symbols", class_alias, 1);
2378 add_com_alias ("assf", "dll-symbols", class_alias, 1);
2381 add_setshow_boolean_cmd ("shell", class_support, &useshell, _("\
2382 Set use of shell to start subprocess."), _("\
2383 Show use of shell to start subprocess."), NULL,
2385 NULL, /* FIXME: i18n: */
2386 &setlist, &showlist);
2388 add_setshow_boolean_cmd ("cygwin-exceptions", class_support, &cygwin_exceptions, _("\
2389 Break when an exception is detected in the Cygwin DLL itself."), _("\
2390 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL,
2392 NULL, /* FIXME: i18n: */
2393 &setlist, &showlist);
2396 add_setshow_boolean_cmd ("new-console", class_support, &new_console, _("\
2397 Set creation of new console when creating child process."), _("\
2398 Show creation of new console when creating child process."), NULL,
2400 NULL, /* FIXME: i18n: */
2401 &setlist, &showlist);
2403 add_setshow_boolean_cmd ("new-group", class_support, &new_group, _("\
2404 Set creation of new group when creating child process."), _("\
2405 Show creation of new group when creating child process."), NULL,
2407 NULL, /* FIXME: i18n: */
2408 &setlist, &showlist);
2410 add_setshow_boolean_cmd ("debugexec", class_support, &debug_exec, _("\
2411 Set whether to display execution in child process."), _("\
2412 Show whether to display execution in child process."), NULL,
2414 NULL, /* FIXME: i18n: */
2415 &setlist, &showlist);
2417 add_setshow_boolean_cmd ("debugevents", class_support, &debug_events, _("\
2418 Set whether to display kernel events in child process."), _("\
2419 Show whether to display kernel events in child process."), NULL,
2421 NULL, /* FIXME: i18n: */
2422 &setlist, &showlist);
2424 add_setshow_boolean_cmd ("debugmemory", class_support, &debug_memory, _("\
2425 Set whether to display memory accesses in child process."), _("\
2426 Show whether to display memory accesses in child process."), NULL,
2428 NULL, /* FIXME: i18n: */
2429 &setlist, &showlist);
2431 add_setshow_boolean_cmd ("debugexceptions", class_support,
2432 &debug_exceptions, _("\
2433 Set whether to display kernel exceptions in child process."), _("\
2434 Show whether to display kernel exceptions in child process."), NULL,
2436 NULL, /* FIXME: i18n: */
2437 &setlist, &showlist);
2439 init_w32_command_list ();
2441 add_cmd ("selector", class_info, display_selectors,
2442 _("Display selectors infos."),
2444 add_target (&windows_ops);
2445 deprecated_init_ui_hook = set_windows_aliases;
2448 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2450 /* Pass the address ADDR to the inferior in the I'th debug register.
2451 Here we just store the address in dr array, the registers will be
2452 actually set up when windows_continue is called. */
2454 cygwin_set_dr (int i, CORE_ADDR addr)
2457 internal_error (__FILE__, __LINE__,
2458 _("Invalid register %d in cygwin_set_dr.\n"), i);
2460 debug_registers_changed = 1;
2461 debug_registers_used = 1;
2464 /* Pass the value VAL to the inferior in the DR7 debug control
2465 register. Here we just store the address in D_REGS, the watchpoint
2466 will be actually set up in windows_wait. */
2468 cygwin_set_dr7 (unsigned long val)
2470 dr[7] = (CORE_ADDR) val;
2471 debug_registers_changed = 1;
2472 debug_registers_used = 1;
2475 /* Get the value of the DR6 debug status register from the inferior.
2476 Here we just return the value stored in dr[6]
2477 by the last call to thread_rec for current_event.dwThreadId id. */
2478 static unsigned long
2479 cygwin_get_dr6 (void)
2481 return (unsigned long) dr[6];
2484 /* Determine if the thread referenced by "ptid" is alive
2485 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2486 it means that the thread has died. Otherwise it is assumed to be alive. */
2488 windows_thread_alive (struct target_ops *ops, ptid_t ptid)
2492 gdb_assert (ptid_get_tid (ptid) != 0);
2493 tid = ptid_get_tid (ptid);
2495 return WaitForSingleObject (thread_rec (tid, FALSE)->h, 0) == WAIT_OBJECT_0 ?
2500 _initialize_check_for_gdb_ini (void)
2503 if (inhibit_gdbinit)
2506 homedir = getenv ("HOME");
2510 char *oldini = (char *) alloca (strlen (homedir) +
2511 sizeof ("/gdb.ini"));
2512 strcpy (oldini, homedir);
2513 p = strchr (oldini, '\0');
2514 if (p > oldini && p[-1] != '/')
2516 strcpy (p, "gdb.ini");
2517 if (access (oldini, 0) == 0)
2519 int len = strlen (oldini);
2520 char *newini = alloca (len + 1);
2521 sprintf (newini, "%.*s.gdbinit",
2522 (int) (len - (sizeof ("gdb.ini") - 1)), oldini);
2523 warning (_("obsolete '%s' found. Rename to '%s'."), oldini, newini);
2528 /* Define dummy functions which always return error for the rare cases where
2529 these functions could not be found. */
2531 bad_DebugActiveProcessStop (DWORD w)
2536 bad_DebugBreakProcess (HANDLE w)
2541 bad_DebugSetProcessKillOnExit (BOOL w)
2546 bad_EnumProcessModules (HANDLE w, HMODULE *x, DWORD y, LPDWORD z)
2553 bad_GetModuleFileNameExW (HANDLE w, HMODULE x, LPWSTR y, DWORD z)
2559 bad_GetModuleFileNameExA (HANDLE w, HMODULE x, LPSTR y, DWORD z)
2566 bad_GetModuleInformation (HANDLE w, HMODULE x, LPMODULEINFO y, DWORD z)
2572 bad_OpenProcessToken (HANDLE w, DWORD x, PHANDLE y)
2577 /* Load any functions which may not be available in ancient versions
2580 _initialize_loadable (void)
2584 hm = LoadLibrary ("kernel32.dll");
2587 DebugActiveProcessStop = (void *)
2588 GetProcAddress (hm, "DebugActiveProcessStop");
2589 DebugBreakProcess = (void *)
2590 GetProcAddress (hm, "DebugBreakProcess");
2591 DebugSetProcessKillOnExit = (void *)
2592 GetProcAddress (hm, "DebugSetProcessKillOnExit");
2595 /* Set variables to dummy versions of these processes if the function
2596 wasn't found in kernel32.dll. */
2597 if (!DebugBreakProcess)
2598 DebugBreakProcess = bad_DebugBreakProcess;
2599 if (!DebugActiveProcessStop || !DebugSetProcessKillOnExit)
2601 DebugActiveProcessStop = bad_DebugActiveProcessStop;
2602 DebugSetProcessKillOnExit = bad_DebugSetProcessKillOnExit;
2605 /* Load optional functions used for retrieving filename information
2606 associated with the currently debugged process or its dlls. */
2607 hm = LoadLibrary ("psapi.dll");
2610 EnumProcessModules = (void *)
2611 GetProcAddress (hm, "EnumProcessModules");
2612 GetModuleInformation = (void *)
2613 GetProcAddress (hm, "GetModuleInformation");
2614 GetModuleFileNameEx = (void *)
2615 GetProcAddress (hm, GetModuleFileNameEx_name);
2618 if (!EnumProcessModules || !GetModuleInformation || !GetModuleFileNameEx)
2620 /* Set variables to dummy versions of these processes if the function
2621 wasn't found in psapi.dll. */
2622 EnumProcessModules = bad_EnumProcessModules;
2623 GetModuleInformation = bad_GetModuleInformation;
2624 GetModuleFileNameEx = bad_GetModuleFileNameEx;
2625 /* This will probably fail on Windows 9x/Me. Let the user know that we're
2626 missing some functionality. */
2627 warning(_("cannot automatically find executable file or library to read symbols.\nUse \"file\" or \"dll\" command to load executable/libraries directly."));
2630 hm = LoadLibrary ("advapi32.dll");
2633 OpenProcessToken = (void *) GetProcAddress (hm, "OpenProcessToken");
2634 LookupPrivilegeValueA = (void *)
2635 GetProcAddress (hm, "LookupPrivilegeValueA");
2636 AdjustTokenPrivileges = (void *)
2637 GetProcAddress (hm, "AdjustTokenPrivileges");
2638 /* Only need to set one of these since if OpenProcessToken fails nothing
2640 if (!OpenProcessToken || !LookupPrivilegeValueA || !AdjustTokenPrivileges)
2641 OpenProcessToken = bad_OpenProcessToken;