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 printf_filtered ("Invalid selector 0x%lx.\n",sel);
1041 display_selectors (char * args, int from_tty)
1043 if (!current_thread)
1045 puts_filtered ("Impossible to display selectors now.\n");
1051 puts_filtered ("Selector $cs\n");
1052 display_selector (current_thread->h,
1053 current_thread->context.SegCs);
1054 puts_filtered ("Selector $ds\n");
1055 display_selector (current_thread->h,
1056 current_thread->context.SegDs);
1057 puts_filtered ("Selector $es\n");
1058 display_selector (current_thread->h,
1059 current_thread->context.SegEs);
1060 puts_filtered ("Selector $ss\n");
1061 display_selector (current_thread->h,
1062 current_thread->context.SegSs);
1063 puts_filtered ("Selector $fs\n");
1064 display_selector (current_thread->h,
1065 current_thread->context.SegFs);
1066 puts_filtered ("Selector $gs\n");
1067 display_selector (current_thread->h,
1068 current_thread->context.SegGs);
1073 sel = parse_and_eval_long (args);
1074 printf_filtered ("Selector \"%s\"\n",args);
1075 display_selector (current_thread->h, sel);
1079 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1080 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1081 host_address_to_string (\
1082 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1085 handle_exception (struct target_waitstatus *ourstatus)
1088 DWORD code = current_event.u.Exception.ExceptionRecord.ExceptionCode;
1090 ourstatus->kind = TARGET_WAITKIND_STOPPED;
1092 /* Record the context of the current thread */
1093 th = thread_rec (current_event.dwThreadId, -1);
1097 case EXCEPTION_ACCESS_VIOLATION:
1098 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1099 ourstatus->value.sig = TARGET_SIGNAL_SEGV;
1102 /* See if the access violation happened within the cygwin DLL itself. Cygwin uses
1103 a kind of exception handling to deal with passed-in invalid addresses. gdb
1104 should not treat these as real SEGVs since they will be silently handled by
1105 cygwin. A real SEGV will (theoretically) be caught by cygwin later in the process
1106 and will be sent as a cygwin-specific-signal. So, ignore SEGVs if they show up
1107 within the text segment of the DLL itself. */
1109 CORE_ADDR addr = (CORE_ADDR) (uintptr_t) current_event.u.Exception.ExceptionRecord.ExceptionAddress;
1110 if ((!cygwin_exceptions && (addr >= cygwin_load_start && addr < cygwin_load_end))
1111 || (find_pc_partial_function (addr, &fn, NULL, NULL)
1112 && strncmp (fn, "KERNEL32!IsBad", strlen ("KERNEL32!IsBad")) == 0))
1117 case STATUS_STACK_OVERFLOW:
1118 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1119 ourstatus->value.sig = TARGET_SIGNAL_SEGV;
1121 case STATUS_FLOAT_DENORMAL_OPERAND:
1122 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1123 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1125 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
1126 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1127 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1129 case STATUS_FLOAT_INEXACT_RESULT:
1130 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1131 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1133 case STATUS_FLOAT_INVALID_OPERATION:
1134 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1135 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1137 case STATUS_FLOAT_OVERFLOW:
1138 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1139 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1141 case STATUS_FLOAT_STACK_CHECK:
1142 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1143 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1145 case STATUS_FLOAT_UNDERFLOW:
1146 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1147 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1149 case STATUS_FLOAT_DIVIDE_BY_ZERO:
1150 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1151 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1153 case STATUS_INTEGER_DIVIDE_BY_ZERO:
1154 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1155 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1157 case STATUS_INTEGER_OVERFLOW:
1158 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1159 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1161 case EXCEPTION_BREAKPOINT:
1162 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1163 ourstatus->value.sig = TARGET_SIGNAL_TRAP;
1166 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1167 ourstatus->value.sig = TARGET_SIGNAL_INT;
1169 case DBG_CONTROL_BREAK:
1170 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1171 ourstatus->value.sig = TARGET_SIGNAL_INT;
1173 case EXCEPTION_SINGLE_STEP:
1174 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1175 ourstatus->value.sig = TARGET_SIGNAL_TRAP;
1177 case EXCEPTION_ILLEGAL_INSTRUCTION:
1178 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1179 ourstatus->value.sig = TARGET_SIGNAL_ILL;
1181 case EXCEPTION_PRIV_INSTRUCTION:
1182 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1183 ourstatus->value.sig = TARGET_SIGNAL_ILL;
1185 case EXCEPTION_NONCONTINUABLE_EXCEPTION:
1186 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1187 ourstatus->value.sig = TARGET_SIGNAL_ILL;
1190 /* Treat unhandled first chance exceptions specially. */
1191 if (current_event.u.Exception.dwFirstChance)
1193 printf_unfiltered ("gdb: unknown target exception 0x%08lx at %s\n",
1194 current_event.u.Exception.ExceptionRecord.ExceptionCode,
1195 host_address_to_string (
1196 current_event.u.Exception.ExceptionRecord.ExceptionAddress));
1197 ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
1201 last_sig = ourstatus->value.sig;
1205 /* Resume all artificially suspended threads if we are continuing
1208 windows_continue (DWORD continue_status, int id)
1214 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%lx, %s);\n",
1215 current_event.dwProcessId, current_event.dwThreadId,
1216 continue_status == DBG_CONTINUE ?
1217 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1219 for (th = &thread_head; (th = th->next) != NULL;)
1220 if ((id == -1 || id == (int) th->id)
1223 if (debug_registers_changed)
1225 th->context.ContextFlags |= CONTEXT_DEBUG_REGISTERS;
1226 th->context.Dr0 = dr[0];
1227 th->context.Dr1 = dr[1];
1228 th->context.Dr2 = dr[2];
1229 th->context.Dr3 = dr[3];
1230 th->context.Dr6 = DR6_CLEAR_VALUE;
1231 th->context.Dr7 = dr[7];
1233 if (th->context.ContextFlags)
1235 CHECK (SetThreadContext (th->h, &th->context));
1236 th->context.ContextFlags = 0;
1238 if (th->suspended > 0)
1239 (void) ResumeThread (th->h);
1243 res = ContinueDebugEvent (current_event.dwProcessId,
1244 current_event.dwThreadId,
1247 debug_registers_changed = 0;
1251 /* Called in pathological case where Windows fails to send a
1252 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1254 fake_create_process (void)
1256 current_process_handle = OpenProcess (PROCESS_ALL_ACCESS, FALSE,
1257 current_event.dwProcessId);
1258 if (current_process_handle != NULL)
1259 open_process_used = 1;
1262 error (_("OpenProcess call failed, GetLastError = %lud\n"),
1264 /* We can not debug anything in that case. */
1266 main_thread_id = current_event.dwThreadId;
1267 current_thread = windows_add_thread (
1268 ptid_build (current_event.dwProcessId, 0,
1269 current_event.dwThreadId),
1270 current_event.u.CreateThread.hThread,
1271 current_event.u.CreateThread.lpThreadLocalBase);
1272 return main_thread_id;
1276 windows_resume (struct target_ops *ops,
1277 ptid_t ptid, int step, enum target_signal sig)
1280 DWORD continue_status = DBG_CONTINUE;
1282 /* A specific PTID means `step only this thread id'. */
1283 int resume_all = ptid_equal (ptid, minus_one_ptid);
1285 /* If we're continuing all threads, it's the current inferior that
1286 should be handled specially. */
1288 ptid = inferior_ptid;
1290 if (sig != TARGET_SIGNAL_0)
1292 if (current_event.dwDebugEventCode != EXCEPTION_DEBUG_EVENT)
1294 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig));
1296 else if (sig == last_sig)
1297 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1300 /* This code does not seem to work, because
1301 the kernel does probably not consider changes in the ExceptionRecord
1302 structure when passing the exception to the inferior.
1303 Note that this seems possible in the exception handler itself. */
1306 for (i = 0; xlate[i].them != -1; i++)
1307 if (xlate[i].us == sig)
1309 current_event.u.Exception.ExceptionRecord.ExceptionCode =
1311 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1314 if (continue_status == DBG_CONTINUE)
1316 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig));
1320 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1324 last_sig = TARGET_SIGNAL_0;
1326 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1327 ptid_get_pid (ptid), ptid_get_tid (ptid), step, sig));
1329 /* Get context for currently selected thread */
1330 th = thread_rec (ptid_get_tid (inferior_ptid), FALSE);
1335 /* Single step by setting t bit */
1336 struct regcache *regcache = get_current_regcache ();
1337 struct gdbarch *gdbarch = get_regcache_arch (regcache);
1338 windows_fetch_inferior_registers (ops, regcache,
1339 gdbarch_ps_regnum (gdbarch));
1340 th->context.EFlags |= FLAG_TRACE_BIT;
1343 if (th->context.ContextFlags)
1345 if (debug_registers_changed)
1347 th->context.Dr0 = dr[0];
1348 th->context.Dr1 = dr[1];
1349 th->context.Dr2 = dr[2];
1350 th->context.Dr3 = dr[3];
1351 th->context.Dr6 = DR6_CLEAR_VALUE;
1352 th->context.Dr7 = dr[7];
1354 CHECK (SetThreadContext (th->h, &th->context));
1355 th->context.ContextFlags = 0;
1359 /* Allow continuing with the same signal that interrupted us.
1360 Otherwise complain. */
1363 windows_continue (continue_status, -1);
1365 windows_continue (continue_status, ptid_get_tid (ptid));
1368 /* Ctrl-C handler used when the inferior is not run in the same console. The
1369 handler is in charge of interrupting the inferior using DebugBreakProcess.
1370 Note that this function is not available prior to Windows XP. In this case
1371 we emit a warning. */
1373 ctrl_c_handler (DWORD event_type)
1375 const int attach_flag = current_inferior ()->attach_flag;
1377 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1378 if (event_type != CTRL_C_EVENT && event_type != CTRL_BREAK_EVENT)
1381 /* If the inferior and the debugger share the same console, do nothing as
1382 the inferior has also received the Ctrl-C event. */
1383 if (!new_console && !attach_flag)
1386 if (!DebugBreakProcess (current_process_handle))
1388 Could not interrupt program. Press Ctrl-c in the program console."));
1390 /* Return true to tell that Ctrl-C has been handled. */
1394 /* Get the next event from the child. Return 1 if the event requires
1395 handling by WFI (or whatever). */
1397 get_windows_debug_event (struct target_ops *ops,
1398 int pid, struct target_waitstatus *ourstatus)
1401 DWORD continue_status, event_code;
1403 static thread_info dummy_thread_info;
1406 last_sig = TARGET_SIGNAL_0;
1408 if (!(debug_event = WaitForDebugEvent (¤t_event, 1000)))
1412 continue_status = DBG_CONTINUE;
1414 event_code = current_event.dwDebugEventCode;
1415 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
1417 have_saved_context = 0;
1421 case CREATE_THREAD_DEBUG_EVENT:
1422 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1423 (unsigned) current_event.dwProcessId,
1424 (unsigned) current_event.dwThreadId,
1425 "CREATE_THREAD_DEBUG_EVENT"));
1426 if (saw_create != 1)
1428 struct inferior *inf;
1429 inf = find_inferior_pid (current_event.dwProcessId);
1430 if (!saw_create && inf->attach_flag)
1432 /* Kludge around a Windows bug where first event is a create
1433 thread event. Caused when attached process does not have
1435 retval = fake_create_process ();
1441 /* Record the existence of this thread */
1442 retval = current_event.dwThreadId;
1443 th = windows_add_thread (ptid_build (current_event.dwProcessId, 0,
1444 current_event.dwThreadId),
1445 current_event.u.CreateThread.hThread,
1446 current_event.u.CreateThread.lpThreadLocalBase);
1450 case EXIT_THREAD_DEBUG_EVENT:
1451 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1452 (unsigned) current_event.dwProcessId,
1453 (unsigned) current_event.dwThreadId,
1454 "EXIT_THREAD_DEBUG_EVENT"));
1456 if (current_event.dwThreadId != main_thread_id)
1458 windows_delete_thread (ptid_build (current_event.dwProcessId, 0,
1459 current_event.dwThreadId));
1460 th = &dummy_thread_info;
1464 case CREATE_PROCESS_DEBUG_EVENT:
1465 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1466 (unsigned) current_event.dwProcessId,
1467 (unsigned) current_event.dwThreadId,
1468 "CREATE_PROCESS_DEBUG_EVENT"));
1469 CloseHandle (current_event.u.CreateProcessInfo.hFile);
1470 if (++saw_create != 1)
1473 current_process_handle = current_event.u.CreateProcessInfo.hProcess;
1475 windows_delete_thread (ptid_build (current_event.dwProcessId, 0,
1477 main_thread_id = current_event.dwThreadId;
1478 /* Add the main thread */
1479 th = windows_add_thread (ptid_build (current_event.dwProcessId, 0,
1480 current_event.dwThreadId),
1481 current_event.u.CreateProcessInfo.hThread,
1482 current_event.u.CreateProcessInfo.lpThreadLocalBase);
1483 retval = current_event.dwThreadId;
1486 case EXIT_PROCESS_DEBUG_EVENT:
1487 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1488 (unsigned) current_event.dwProcessId,
1489 (unsigned) current_event.dwThreadId,
1490 "EXIT_PROCESS_DEBUG_EVENT"));
1491 if (!windows_initialization_done)
1493 target_terminal_ours ();
1494 target_mourn_inferior ();
1495 error (_("During startup program exited with code 0x%x."),
1496 (unsigned int) current_event.u.ExitProcess.dwExitCode);
1498 else if (saw_create == 1)
1500 ourstatus->kind = TARGET_WAITKIND_EXITED;
1501 ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode;
1502 retval = main_thread_id;
1506 case LOAD_DLL_DEBUG_EVENT:
1507 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1508 (unsigned) current_event.dwProcessId,
1509 (unsigned) current_event.dwThreadId,
1510 "LOAD_DLL_DEBUG_EVENT"));
1511 CloseHandle (current_event.u.LoadDll.hFile);
1512 if (saw_create != 1)
1514 catch_errors (handle_load_dll, NULL, (char *) "", RETURN_MASK_ALL);
1515 ourstatus->kind = TARGET_WAITKIND_LOADED;
1516 ourstatus->value.integer = 0;
1517 retval = main_thread_id;
1520 case UNLOAD_DLL_DEBUG_EVENT:
1521 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1522 (unsigned) current_event.dwProcessId,
1523 (unsigned) current_event.dwThreadId,
1524 "UNLOAD_DLL_DEBUG_EVENT"));
1525 if (saw_create != 1)
1527 catch_errors (handle_unload_dll, NULL, (char *) "", RETURN_MASK_ALL);
1528 ourstatus->kind = TARGET_WAITKIND_LOADED;
1529 ourstatus->value.integer = 0;
1530 retval = main_thread_id;
1533 case EXCEPTION_DEBUG_EVENT:
1534 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1535 (unsigned) current_event.dwProcessId,
1536 (unsigned) current_event.dwThreadId,
1537 "EXCEPTION_DEBUG_EVENT"));
1538 if (saw_create != 1)
1540 switch (handle_exception (ourstatus))
1543 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1546 retval = current_event.dwThreadId;
1550 continue_status = -1;
1555 case OUTPUT_DEBUG_STRING_EVENT: /* message from the kernel */
1556 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1557 (unsigned) current_event.dwProcessId,
1558 (unsigned) current_event.dwThreadId,
1559 "OUTPUT_DEBUG_STRING_EVENT"));
1560 if (saw_create != 1)
1562 retval = handle_output_debug_string (ourstatus);
1566 if (saw_create != 1)
1568 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1569 (DWORD) current_event.dwProcessId,
1570 (DWORD) current_event.dwThreadId);
1571 printf_unfiltered (" unknown event code %ld\n",
1572 current_event.dwDebugEventCode);
1576 if (!retval || saw_create != 1)
1578 if (continue_status == -1)
1579 windows_resume (ops, minus_one_ptid, 0, 1);
1581 CHECK (windows_continue (continue_status, -1));
1585 inferior_ptid = ptid_build (current_event.dwProcessId, 0,
1587 current_thread = th ?: thread_rec (current_event.dwThreadId, TRUE);
1594 /* Wait for interesting events to occur in the target process. */
1596 windows_wait (struct target_ops *ops,
1597 ptid_t ptid, struct target_waitstatus *ourstatus, int options)
1601 target_terminal_ours ();
1603 /* We loop when we get a non-standard exception rather than return
1604 with a SPURIOUS because resume can try and step or modify things,
1605 which needs a current_thread->h. But some of these exceptions mark
1606 the birth or death of threads, which mean that the current thread
1607 isn't necessarily what you think it is. */
1613 /* If the user presses Ctrl-c while the debugger is waiting
1614 for an event, he expects the debugger to interrupt his program
1615 and to get the prompt back. There are two possible situations:
1617 - The debugger and the program do not share the console, in
1618 which case the Ctrl-c event only reached the debugger.
1619 In that case, the ctrl_c handler will take care of interrupting
1620 the inferior. Note that this case is working starting with
1621 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1624 - The debugger and the program share the same console, in which
1625 case both debugger and inferior will receive the Ctrl-c event.
1626 In that case the ctrl_c handler will ignore the event, as the
1627 Ctrl-c event generated inside the inferior will trigger the
1628 expected debug event.
1630 FIXME: brobecker/2008-05-20: If the inferior receives the
1631 signal first and the delay until GDB receives that signal
1632 is sufficiently long, GDB can sometimes receive the SIGINT
1633 after we have unblocked the CTRL+C handler. This would
1634 lead to the debugger stopping prematurely while handling
1635 the new-thread event that comes with the handling of the SIGINT
1636 inside the inferior, and then stop again immediately when
1637 the user tries to resume the execution in the inferior.
1638 This is a classic race that we should try to fix one day. */
1639 SetConsoleCtrlHandler (&ctrl_c_handler, TRUE);
1640 retval = get_windows_debug_event (ops, pid, ourstatus);
1641 SetConsoleCtrlHandler (&ctrl_c_handler, FALSE);
1644 return ptid_build (current_event.dwProcessId, 0, retval);
1649 if (deprecated_ui_loop_hook != NULL)
1650 detach = deprecated_ui_loop_hook (0);
1653 windows_kill_inferior (ops);
1659 do_initial_windows_stuff (struct target_ops *ops, DWORD pid, int attaching)
1661 extern int stop_after_trap;
1663 struct inferior *inf;
1664 struct thread_info *tp;
1666 last_sig = TARGET_SIGNAL_0;
1668 exception_count = 0;
1669 open_process_used = 0;
1670 debug_registers_changed = 0;
1671 debug_registers_used = 0;
1672 for (i = 0; i < sizeof (dr) / sizeof (dr[0]); i++)
1675 cygwin_load_start = cygwin_load_end = 0;
1677 current_event.dwProcessId = pid;
1678 memset (¤t_event, 0, sizeof (current_event));
1680 disable_breakpoints_in_shlibs ();
1681 windows_clear_solib ();
1682 clear_proceed_status ();
1683 init_wait_for_inferior ();
1685 inf = current_inferior ();
1686 inferior_appeared (inf, pid);
1687 inf->attach_flag = attaching;
1689 /* Make the new process the current inferior, so terminal handling
1690 can rely on it. When attaching, we don't know about any thread
1691 id here, but that's OK --- nothing should be referencing the
1692 current thread until we report an event out of windows_wait. */
1693 inferior_ptid = pid_to_ptid (pid);
1695 terminal_init_inferior_with_pgrp (pid);
1696 target_terminal_inferior ();
1698 windows_initialization_done = 0;
1699 inf->stop_soon = STOP_QUIETLY;
1702 stop_after_trap = 1;
1703 wait_for_inferior (0);
1704 tp = inferior_thread ();
1705 if (tp->stop_signal != TARGET_SIGNAL_TRAP)
1706 resume (0, tp->stop_signal);
1711 windows_initialization_done = 1;
1712 inf->stop_soon = NO_STOP_QUIETLY;
1713 stop_after_trap = 0;
1717 /* Try to set or remove a user privilege to the current process. Return -1
1718 if that fails, the previous setting of that privilege otherwise.
1720 This code is copied from the Cygwin source code and rearranged to allow
1721 dynamically loading of the needed symbols from advapi32 which is only
1722 available on NT/2K/XP. */
1724 set_process_privilege (const char *privilege, BOOL enable)
1726 HANDLE token_hdl = NULL;
1728 TOKEN_PRIVILEGES new_priv, orig_priv;
1732 if (!OpenProcessToken (GetCurrentProcess (),
1733 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
1737 if (!LookupPrivilegeValueA (NULL, privilege, &restore_priv))
1740 new_priv.PrivilegeCount = 1;
1741 new_priv.Privileges[0].Luid = restore_priv;
1742 new_priv.Privileges[0].Attributes = enable ? SE_PRIVILEGE_ENABLED : 0;
1744 if (!AdjustTokenPrivileges (token_hdl, FALSE, &new_priv,
1745 sizeof orig_priv, &orig_priv, &size))
1748 /* Disabled, otherwise every `attach' in an unprivileged user session
1749 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1750 windows_attach(). */
1751 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1752 be enabled. GetLastError () returns an correct error code, though. */
1753 if (enable && GetLastError () == ERROR_NOT_ALL_ASSIGNED)
1757 ret = orig_priv.Privileges[0].Attributes == SE_PRIVILEGE_ENABLED ? 1 : 0;
1761 CloseHandle (token_hdl);
1766 /* Attach to process PID, then initialize for debugging it. */
1768 windows_attach (struct target_ops *ops, char *args, int from_tty)
1773 pid = parse_pid_to_attach (args);
1775 if (set_process_privilege (SE_DEBUG_NAME, TRUE) < 0)
1777 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1778 printf_unfiltered ("This can cause attach to fail on Windows NT/2K/XP\n");
1781 windows_init_thread_list ();
1782 ok = DebugActiveProcess (pid);
1788 /* Try fall back to Cygwin pid */
1789 pid = cygwin_internal (CW_CYGWIN_PID_TO_WINPID, pid);
1792 ok = DebugActiveProcess (pid);
1797 error (_("Can't attach to process."));
1799 DebugSetProcessKillOnExit (FALSE);
1803 char *exec_file = (char *) get_exec_file (0);
1806 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
1807 target_pid_to_str (pid_to_ptid (pid)));
1809 printf_unfiltered ("Attaching to %s\n",
1810 target_pid_to_str (pid_to_ptid (pid)));
1812 gdb_flush (gdb_stdout);
1815 do_initial_windows_stuff (ops, pid, 1);
1816 target_terminal_ours ();
1820 windows_detach (struct target_ops *ops, char *args, int from_tty)
1825 windows_resume (ops, ptid, 0, TARGET_SIGNAL_0);
1827 if (!DebugActiveProcessStop (current_event.dwProcessId))
1829 error (_("Can't detach process %lu (error %lu)"),
1830 current_event.dwProcessId, GetLastError ());
1833 DebugSetProcessKillOnExit (FALSE);
1835 if (detached && from_tty)
1837 char *exec_file = get_exec_file (0);
1840 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file,
1841 current_event.dwProcessId);
1842 gdb_flush (gdb_stdout);
1845 inferior_ptid = null_ptid;
1846 detach_inferior (current_event.dwProcessId);
1848 unpush_target (ops);
1852 windows_pid_to_exec_file (int pid)
1854 static char path[__PMAX];
1856 /* Try to find exe name as symlink target of /proc/<pid>/exe */
1858 char procexe[sizeof ("/proc/4294967295/exe")];
1859 sprintf (procexe, "/proc/%u/exe", pid);
1860 nchars = readlink (procexe, path, sizeof(path));
1861 if (nchars > 0 && nchars < sizeof (path))
1863 path[nchars] = '\0'; /* Got it */
1868 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
1869 of gdb, or we're trying to debug a non-Cygwin windows executable. */
1870 if (!get_module_name (0, path))
1876 /* Print status information about what we're accessing. */
1879 windows_files_info (struct target_ops *ignore)
1881 struct inferior *inf = current_inferior ();
1883 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1884 inf->attach_flag ? "attached" : "child",
1885 target_pid_to_str (inferior_ptid));
1889 windows_open (char *arg, int from_tty)
1891 error (_("Use the \"run\" command to start a Unix child process."));
1894 /* Start an inferior windows child process and sets inferior_ptid to its pid.
1895 EXEC_FILE is the file to run.
1896 ALLARGS is a string containing the arguments to the program.
1897 ENV is the environment vector to pass. Errors reported with error(). */
1900 windows_create_inferior (struct target_ops *ops, char *exec_file,
1901 char *allargs, char **in_env, int from_tty)
1905 cygwin_buf_t real_path[__PMAX];
1906 cygwin_buf_t shell[__PMAX]; /* Path to shell */
1908 cygwin_buf_t *toexec;
1909 cygwin_buf_t *cygallargs;
1913 int ostdin, ostdout, ostderr;
1915 char real_path[__PMAX];
1916 char shell[__PMAX]; /* Path to shell */
1921 PROCESS_INFORMATION pi;
1924 const char *inferior_io_terminal = get_inferior_io_terminal ();
1927 error (_("No executable specified, use `target exec'."));
1929 memset (&si, 0, sizeof (si));
1930 si.cb = sizeof (si);
1933 flags |= CREATE_NEW_PROCESS_GROUP;
1936 flags |= CREATE_NEW_CONSOLE;
1941 flags |= DEBUG_ONLY_THIS_PROCESS;
1942 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W, exec_file, real_path,
1943 __PMAX * sizeof (cygwin_buf_t)) < 0)
1944 error (_("Error starting executable: %d"), errno);
1947 len = mbstowcs (NULL, allargs, 0) + 1;
1948 if (len == (size_t) -1)
1949 error (_("Error starting executable: %d"), errno);
1950 cygallargs = (wchar_t *) alloca (len * sizeof (wchar_t));
1951 mbstowcs (cygallargs, allargs, len);
1953 cygallargs = allargs;
1958 sh = getenv ("SHELL");
1961 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W, sh, shell, __PMAX) < 0)
1962 error (_("Error starting executable via shell: %d"), errno);
1964 len = sizeof (L" -c 'exec '") + mbstowcs (NULL, exec_file, 0)
1965 + mbstowcs (NULL, allargs, 0) + 2;
1966 cygallargs = (wchar_t *) alloca (len * sizeof (wchar_t));
1967 swprintf (cygallargs, len, L" -c 'exec %s %s'", exec_file, allargs);
1969 cygallargs = (char *) alloca (sizeof (" -c 'exec '") + strlen (exec_file)
1970 + strlen (allargs) + 2);
1971 sprintf (cygallargs, " -c 'exec %s %s'", exec_file, allargs);
1974 flags |= DEBUG_PROCESS;
1978 args = (cygwin_buf_t *) alloca ((wcslen (toexec) + wcslen (cygallargs) + 2)
1979 * sizeof (wchar_t));
1980 wcscpy (args, toexec);
1981 wcscat (args, L" ");
1982 wcscat (args, cygallargs);
1984 args = (cygwin_buf_t *) alloca (strlen (toexec) + strlen (cygallargs) + 2);
1985 strcpy (args, toexec);
1987 strcat (args, cygallargs);
1990 /* Prepare the environment vars for CreateProcess. */
1991 cygwin_internal (CW_SYNC_WINENV);
1993 if (!inferior_io_terminal)
1994 tty = ostdin = ostdout = ostderr = -1;
1997 tty = open (inferior_io_terminal, O_RDWR | O_NOCTTY);
2000 print_sys_errmsg (inferior_io_terminal, errno);
2001 ostdin = ostdout = ostderr = -1;
2014 windows_init_thread_list ();
2015 ret = CreateProcess (0,
2016 args, /* command line */
2017 NULL, /* Security */
2019 TRUE, /* inherit handles */
2020 flags, /* start flags */
2021 NULL, /* environment */
2022 NULL, /* current directory */
2037 args = alloca (strlen (toexec) + strlen (allargs) + 2);
2038 strcpy (args, toexec);
2040 strcat (args, allargs);
2042 flags |= DEBUG_ONLY_THIS_PROCESS;
2044 if (!inferior_io_terminal)
2045 tty = INVALID_HANDLE_VALUE;
2048 SECURITY_ATTRIBUTES sa;
2049 sa.nLength = sizeof(sa);
2050 sa.lpSecurityDescriptor = 0;
2051 sa.bInheritHandle = TRUE;
2052 tty = CreateFileA (inferior_io_terminal, GENERIC_READ | GENERIC_WRITE,
2053 0, &sa, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
2054 if (tty == INVALID_HANDLE_VALUE)
2055 warning (_("Warning: Failed to open TTY %s, error %#x."),
2056 inferior_io_terminal, (unsigned) GetLastError ());
2060 si.hStdOutput = tty;
2062 si.dwFlags |= STARTF_USESTDHANDLES;
2066 windows_init_thread_list ();
2067 ret = CreateProcessA (0,
2068 args, /* command line */
2069 NULL, /* Security */
2071 TRUE, /* inherit handles */
2072 flags, /* start flags */
2073 NULL, /* environment */
2074 NULL, /* current directory */
2077 if (tty != INVALID_HANDLE_VALUE)
2082 error (_("Error creating process %s, (error %d)."),
2083 exec_file, (unsigned) GetLastError ());
2085 CloseHandle (pi.hThread);
2086 CloseHandle (pi.hProcess);
2088 if (useshell && shell[0] != '\0')
2093 do_initial_windows_stuff (ops, pi.dwProcessId, 0);
2095 /* windows_continue (DBG_CONTINUE, -1); */
2099 windows_mourn_inferior (struct target_ops *ops)
2101 (void) windows_continue (DBG_CONTINUE, -1);
2102 i386_cleanup_dregs();
2103 if (open_process_used)
2105 CHECK (CloseHandle (current_process_handle));
2106 open_process_used = 0;
2108 unpush_target (ops);
2109 generic_mourn_inferior ();
2112 /* Send a SIGINT to the process group. This acts just like the user typed a
2113 ^C on the controlling terminal. */
2116 windows_stop (ptid_t ptid)
2118 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2119 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId));
2120 registers_changed (); /* refresh register state */
2124 windows_xfer_memory (CORE_ADDR memaddr, gdb_byte *our, int len,
2125 int write, struct mem_attrib *mem,
2126 struct target_ops *target)
2131 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
2132 len, (DWORD) (uintptr_t) memaddr));
2133 if (!WriteProcessMemory (current_process_handle,
2134 (LPVOID) (uintptr_t) memaddr, our,
2137 FlushInstructionCache (current_process_handle,
2138 (LPCVOID) (uintptr_t) memaddr, len);
2142 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
2143 len, (DWORD) (uintptr_t) memaddr));
2144 if (!ReadProcessMemory (current_process_handle,
2145 (LPCVOID) (uintptr_t) memaddr, our,
2153 windows_kill_inferior (struct target_ops *ops)
2155 CHECK (TerminateProcess (current_process_handle, 0));
2159 if (!windows_continue (DBG_CONTINUE, -1))
2161 if (!WaitForDebugEvent (¤t_event, INFINITE))
2163 if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
2167 target_mourn_inferior (); /* or just windows_mourn_inferior? */
2171 windows_prepare_to_store (struct regcache *regcache)
2173 /* Do nothing, since we can store individual regs */
2177 windows_can_run (void)
2183 windows_close (int x)
2185 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2186 PIDGET (inferior_ptid)));
2189 /* Convert pid to printable format. */
2191 windows_pid_to_str (struct target_ops *ops, ptid_t ptid)
2193 static char buf[80];
2195 if (ptid_get_tid (ptid) != 0)
2197 snprintf (buf, sizeof (buf), "Thread %d.0x%lx",
2198 ptid_get_pid (ptid), ptid_get_tid (ptid));
2202 return normal_pid_to_str (ptid);
2206 windows_xfer_shared_libraries (struct target_ops *ops,
2207 enum target_object object, const char *annex,
2208 gdb_byte *readbuf, const gdb_byte *writebuf,
2209 ULONGEST offset, LONGEST len)
2211 struct obstack obstack;
2219 obstack_init (&obstack);
2220 obstack_grow_str (&obstack, "<library-list>\n");
2221 for (so = solib_start.next; so; so = so->next)
2222 windows_xfer_shared_library (so->so_name, (CORE_ADDR) (uintptr_t) so->lm_info->load_addr,
2223 target_gdbarch, &obstack);
2224 obstack_grow_str0 (&obstack, "</library-list>\n");
2226 buf = obstack_finish (&obstack);
2227 len_avail = strlen (buf);
2228 if (offset >= len_avail)
2231 if (len > len_avail - offset)
2232 len = len_avail - offset;
2233 memcpy (readbuf, buf + offset, len);
2235 obstack_free (&obstack, NULL);
2240 windows_xfer_partial (struct target_ops *ops, enum target_object object,
2241 const char *annex, gdb_byte *readbuf,
2242 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
2246 case TARGET_OBJECT_MEMORY:
2248 return (*ops->deprecated_xfer_memory) (offset, readbuf,
2249 len, 0/*read*/, NULL, ops);
2251 return (*ops->deprecated_xfer_memory) (offset, (gdb_byte *) writebuf,
2252 len, 1/*write*/, NULL, ops);
2255 case TARGET_OBJECT_LIBRARIES:
2256 return windows_xfer_shared_libraries (ops, object, annex, readbuf,
2257 writebuf, offset, len);
2260 if (ops->beneath != NULL)
2261 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
2262 readbuf, writebuf, offset, len);
2267 /* Provide thread local base, i.e. Thread Information Block address.
2268 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
2271 windows_get_tib_address (ptid_t ptid, CORE_ADDR *addr)
2275 th = thread_rec (ptid_get_tid (ptid), 0);
2280 *addr = th->thread_local_base;
2286 windows_get_ada_task_ptid (long lwp, long thread)
2288 return ptid_build (ptid_get_pid (inferior_ptid), 0, lwp);
2292 init_windows_ops (void)
2294 windows_ops.to_shortname = "child";
2295 windows_ops.to_longname = "Win32 child process";
2296 windows_ops.to_doc = "Win32 child process (started by the \"run\" command).";
2297 windows_ops.to_open = windows_open;
2298 windows_ops.to_close = windows_close;
2299 windows_ops.to_attach = windows_attach;
2300 windows_ops.to_attach_no_wait = 1;
2301 windows_ops.to_detach = windows_detach;
2302 windows_ops.to_resume = windows_resume;
2303 windows_ops.to_wait = windows_wait;
2304 windows_ops.to_fetch_registers = windows_fetch_inferior_registers;
2305 windows_ops.to_store_registers = windows_store_inferior_registers;
2306 windows_ops.to_prepare_to_store = windows_prepare_to_store;
2307 windows_ops.deprecated_xfer_memory = windows_xfer_memory;
2308 windows_ops.to_xfer_partial = windows_xfer_partial;
2309 windows_ops.to_files_info = windows_files_info;
2310 windows_ops.to_insert_breakpoint = memory_insert_breakpoint;
2311 windows_ops.to_remove_breakpoint = memory_remove_breakpoint;
2312 windows_ops.to_terminal_init = terminal_init_inferior;
2313 windows_ops.to_terminal_inferior = terminal_inferior;
2314 windows_ops.to_terminal_ours_for_output = terminal_ours_for_output;
2315 windows_ops.to_terminal_ours = terminal_ours;
2316 windows_ops.to_terminal_save_ours = terminal_save_ours;
2317 windows_ops.to_terminal_info = child_terminal_info;
2318 windows_ops.to_kill = windows_kill_inferior;
2319 windows_ops.to_create_inferior = windows_create_inferior;
2320 windows_ops.to_mourn_inferior = windows_mourn_inferior;
2321 windows_ops.to_can_run = windows_can_run;
2322 windows_ops.to_thread_alive = windows_thread_alive;
2323 windows_ops.to_pid_to_str = windows_pid_to_str;
2324 windows_ops.to_stop = windows_stop;
2325 windows_ops.to_stratum = process_stratum;
2326 windows_ops.to_has_all_memory = default_child_has_all_memory;
2327 windows_ops.to_has_memory = default_child_has_memory;
2328 windows_ops.to_has_stack = default_child_has_stack;
2329 windows_ops.to_has_registers = default_child_has_registers;
2330 windows_ops.to_has_execution = default_child_has_execution;
2331 windows_ops.to_pid_to_exec_file = windows_pid_to_exec_file;
2332 windows_ops.to_get_ada_task_ptid = windows_get_ada_task_ptid;
2333 windows_ops.to_get_tib_address = windows_get_tib_address;
2335 i386_use_watchpoints (&windows_ops);
2337 i386_dr_low.set_control = cygwin_set_dr7;
2338 i386_dr_low.set_addr = cygwin_set_dr;
2339 i386_dr_low.reset_addr = NULL;
2340 i386_dr_low.get_status = cygwin_get_dr6;
2342 /* i386_dr_low.debug_register_length field is set by
2343 calling i386_set_debug_register_length function
2344 in processor windows specific native file. */
2346 windows_ops.to_magic = OPS_MAGIC;
2350 set_windows_aliases (char *argv0)
2352 add_info_alias ("dll", "sharedlibrary", 1);
2356 _initialize_windows_nat (void)
2358 struct cmd_list_element *c;
2360 init_windows_ops ();
2363 cygwin_internal (CW_SET_DOS_FILE_WARNING, 0);
2366 c = add_com ("dll-symbols", class_files, dll_symbol_command,
2367 _("Load dll library symbols from FILE."));
2368 set_cmd_completer (c, filename_completer);
2370 add_com_alias ("sharedlibrary", "dll-symbols", class_alias, 1);
2372 add_com_alias ("add-shared-symbol-files", "dll-symbols", class_alias, 1);
2374 add_com_alias ("assf", "dll-symbols", class_alias, 1);
2377 add_setshow_boolean_cmd ("shell", class_support, &useshell, _("\
2378 Set use of shell to start subprocess."), _("\
2379 Show use of shell to start subprocess."), NULL,
2381 NULL, /* FIXME: i18n: */
2382 &setlist, &showlist);
2384 add_setshow_boolean_cmd ("cygwin-exceptions", class_support, &cygwin_exceptions, _("\
2385 Break when an exception is detected in the Cygwin DLL itself."), _("\
2386 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL,
2388 NULL, /* FIXME: i18n: */
2389 &setlist, &showlist);
2392 add_setshow_boolean_cmd ("new-console", class_support, &new_console, _("\
2393 Set creation of new console when creating child process."), _("\
2394 Show creation of new console when creating child process."), NULL,
2396 NULL, /* FIXME: i18n: */
2397 &setlist, &showlist);
2399 add_setshow_boolean_cmd ("new-group", class_support, &new_group, _("\
2400 Set creation of new group when creating child process."), _("\
2401 Show creation of new group when creating child process."), NULL,
2403 NULL, /* FIXME: i18n: */
2404 &setlist, &showlist);
2406 add_setshow_boolean_cmd ("debugexec", class_support, &debug_exec, _("\
2407 Set whether to display execution in child process."), _("\
2408 Show whether to display execution in child process."), NULL,
2410 NULL, /* FIXME: i18n: */
2411 &setlist, &showlist);
2413 add_setshow_boolean_cmd ("debugevents", class_support, &debug_events, _("\
2414 Set whether to display kernel events in child process."), _("\
2415 Show whether to display kernel events in child process."), NULL,
2417 NULL, /* FIXME: i18n: */
2418 &setlist, &showlist);
2420 add_setshow_boolean_cmd ("debugmemory", class_support, &debug_memory, _("\
2421 Set whether to display memory accesses in child process."), _("\
2422 Show whether to display memory accesses in child process."), NULL,
2424 NULL, /* FIXME: i18n: */
2425 &setlist, &showlist);
2427 add_setshow_boolean_cmd ("debugexceptions", class_support,
2428 &debug_exceptions, _("\
2429 Set whether to display kernel exceptions in child process."), _("\
2430 Show whether to display kernel exceptions in child process."), NULL,
2432 NULL, /* FIXME: i18n: */
2433 &setlist, &showlist);
2435 init_w32_command_list ();
2437 add_cmd ("selector", class_info, display_selectors,
2438 _("Display selectors infos."),
2440 add_target (&windows_ops);
2441 deprecated_init_ui_hook = set_windows_aliases;
2444 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2446 /* Pass the address ADDR to the inferior in the I'th debug register.
2447 Here we just store the address in dr array, the registers will be
2448 actually set up when windows_continue is called. */
2450 cygwin_set_dr (int i, CORE_ADDR addr)
2453 internal_error (__FILE__, __LINE__,
2454 _("Invalid register %d in cygwin_set_dr.\n"), i);
2456 debug_registers_changed = 1;
2457 debug_registers_used = 1;
2460 /* Pass the value VAL to the inferior in the DR7 debug control
2461 register. Here we just store the address in D_REGS, the watchpoint
2462 will be actually set up in windows_wait. */
2464 cygwin_set_dr7 (unsigned long val)
2466 dr[7] = (CORE_ADDR) val;
2467 debug_registers_changed = 1;
2468 debug_registers_used = 1;
2471 /* Get the value of the DR6 debug status register from the inferior.
2472 Here we just return the value stored in dr[6]
2473 by the last call to thread_rec for current_event.dwThreadId id. */
2474 static unsigned long
2475 cygwin_get_dr6 (void)
2477 return (unsigned long) dr[6];
2480 /* Determine if the thread referenced by "ptid" is alive
2481 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2482 it means that the thread has died. Otherwise it is assumed to be alive. */
2484 windows_thread_alive (struct target_ops *ops, ptid_t ptid)
2488 gdb_assert (ptid_get_tid (ptid) != 0);
2489 tid = ptid_get_tid (ptid);
2491 return WaitForSingleObject (thread_rec (tid, FALSE)->h, 0) == WAIT_OBJECT_0 ?
2496 _initialize_check_for_gdb_ini (void)
2499 if (inhibit_gdbinit)
2502 homedir = getenv ("HOME");
2506 char *oldini = (char *) alloca (strlen (homedir) +
2507 sizeof ("/gdb.ini"));
2508 strcpy (oldini, homedir);
2509 p = strchr (oldini, '\0');
2510 if (p > oldini && p[-1] != '/')
2512 strcpy (p, "gdb.ini");
2513 if (access (oldini, 0) == 0)
2515 int len = strlen (oldini);
2516 char *newini = alloca (len + 1);
2517 sprintf (newini, "%.*s.gdbinit",
2518 (int) (len - (sizeof ("gdb.ini") - 1)), oldini);
2519 warning (_("obsolete '%s' found. Rename to '%s'."), oldini, newini);
2524 /* Define dummy functions which always return error for the rare cases where
2525 these functions could not be found. */
2527 bad_DebugActiveProcessStop (DWORD w)
2532 bad_DebugBreakProcess (HANDLE w)
2537 bad_DebugSetProcessKillOnExit (BOOL w)
2542 bad_EnumProcessModules (HANDLE w, HMODULE *x, DWORD y, LPDWORD z)
2549 bad_GetModuleFileNameExW (HANDLE w, HMODULE x, LPWSTR y, DWORD z)
2555 bad_GetModuleFileNameExA (HANDLE w, HMODULE x, LPSTR y, DWORD z)
2562 bad_GetModuleInformation (HANDLE w, HMODULE x, LPMODULEINFO y, DWORD z)
2568 bad_OpenProcessToken (HANDLE w, DWORD x, PHANDLE y)
2573 /* Load any functions which may not be available in ancient versions
2576 _initialize_loadable (void)
2580 hm = LoadLibrary ("kernel32.dll");
2583 DebugActiveProcessStop = (void *)
2584 GetProcAddress (hm, "DebugActiveProcessStop");
2585 DebugBreakProcess = (void *)
2586 GetProcAddress (hm, "DebugBreakProcess");
2587 DebugSetProcessKillOnExit = (void *)
2588 GetProcAddress (hm, "DebugSetProcessKillOnExit");
2591 /* Set variables to dummy versions of these processes if the function
2592 wasn't found in kernel32.dll. */
2593 if (!DebugBreakProcess)
2594 DebugBreakProcess = bad_DebugBreakProcess;
2595 if (!DebugActiveProcessStop || !DebugSetProcessKillOnExit)
2597 DebugActiveProcessStop = bad_DebugActiveProcessStop;
2598 DebugSetProcessKillOnExit = bad_DebugSetProcessKillOnExit;
2601 /* Load optional functions used for retrieving filename information
2602 associated with the currently debugged process or its dlls. */
2603 hm = LoadLibrary ("psapi.dll");
2606 EnumProcessModules = (void *)
2607 GetProcAddress (hm, "EnumProcessModules");
2608 GetModuleInformation = (void *)
2609 GetProcAddress (hm, "GetModuleInformation");
2610 GetModuleFileNameEx = (void *)
2611 GetProcAddress (hm, GetModuleFileNameEx_name);
2614 if (!EnumProcessModules || !GetModuleInformation || !GetModuleFileNameEx)
2616 /* Set variables to dummy versions of these processes if the function
2617 wasn't found in psapi.dll. */
2618 EnumProcessModules = bad_EnumProcessModules;
2619 GetModuleInformation = bad_GetModuleInformation;
2620 GetModuleFileNameEx = bad_GetModuleFileNameEx;
2621 /* This will probably fail on Windows 9x/Me. Let the user know that we're
2622 missing some functionality. */
2623 warning(_("cannot automatically find executable file or library to read symbols.\nUse \"file\" or \"dll\" command to load executable/libraries directly."));
2626 hm = LoadLibrary ("advapi32.dll");
2629 OpenProcessToken = (void *) GetProcAddress (hm, "OpenProcessToken");
2630 LookupPrivilegeValueA = (void *)
2631 GetProcAddress (hm, "LookupPrivilegeValueA");
2632 AdjustTokenPrivileges = (void *)
2633 GetProcAddress (hm, "AdjustTokenPrivileges");
2634 /* Only need to set one of these since if OpenProcessToken fails nothing
2636 if (!OpenProcessToken || !LookupPrivilegeValueA || !AdjustTokenPrivileges)
2637 OpenProcessToken = bad_OpenProcessToken;