1 /* Target-vector operations for controlling win32 child processes, for GDB.
3 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
4 2005, 2006, 2007, 2008, 2009 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>
42 #include <sys/cygwin.h>
49 #include "gdb_obstack.h"
50 #include "gdb_string.h"
51 #include "gdbthread.h"
53 #include <sys/param.h>
58 #include "xml-support.h"
60 #include "i386-tdep.h"
61 #include "i387-tdep.h"
63 #include "i386-cygwin-tdep.h"
65 static struct target_ops win32_ops;
68 /* The starting and ending address of the cygwin1.dll text segment. */
69 static bfd_vma cygwin_load_start;
70 static bfd_vma cygwin_load_end;
73 static int have_saved_context; /* True if we've saved context from a cygwin signal. */
74 static CONTEXT saved_context; /* Containes the saved context from a cygwin signal. */
76 /* If we're not using the old Cygwin header file set, define the
77 following which never should have been in the generic Win32 API
78 headers in the first place since they were our own invention... */
79 #ifndef _GNU_H_WINDOWS_H
82 FLAG_TRACE_BIT = 0x100,
83 CONTEXT_DEBUGGER = (CONTEXT_FULL | CONTEXT_FLOATING_POINT)
88 #ifndef CONTEXT_EXTENDED_REGISTERS
89 /* This macro is only defined on ia32. It only makes sense on this target,
90 so define it as zero if not already defined. */
91 #define CONTEXT_EXTENDED_REGISTERS 0
94 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \
95 | CONTEXT_EXTENDED_REGISTERS
97 static unsigned dr[8];
98 static int debug_registers_changed;
99 static int debug_registers_used;
100 #define DR6_CLEAR_VALUE 0xffff0ff0
102 /* The string sent by cygwin when it processes a signal.
103 FIXME: This should be in a cygwin include file. */
104 #ifndef _CYGWIN_SIGNAL_STRING
105 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
108 #define CHECK(x) check (x, __FILE__,__LINE__)
109 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
110 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
111 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
112 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
114 static void win32_stop (ptid_t);
115 static int win32_win32_thread_alive (ptid_t);
116 static void win32_kill_inferior (void);
118 static enum target_signal last_sig = TARGET_SIGNAL_0;
119 /* Set if a signal was received from the debugged process */
121 /* Thread information structure used to track information that is
122 not available in gdb's thread structure. */
123 typedef struct thread_info_struct
125 struct thread_info_struct *next;
136 static thread_info thread_head;
138 /* The process and thread handles for the above context. */
140 static DEBUG_EVENT current_event; /* The current debug event from
142 static HANDLE current_process_handle; /* Currently executing process */
143 static thread_info *current_thread; /* Info on currently selected thread */
144 static DWORD main_thread_id; /* Thread ID of the main thread */
146 /* Counts of things. */
147 static int exception_count = 0;
148 static int event_count = 0;
149 static int saw_create;
150 static int open_process_used = 0;
153 static int new_console = 0;
155 static int cygwin_exceptions = 0;
157 static int new_group = 1;
158 static int debug_exec = 0; /* show execution */
159 static int debug_events = 0; /* show events from kernel */
160 static int debug_memory = 0; /* show target memory accesses */
161 static int debug_exceptions = 0; /* show target exceptions */
162 static int useshell = 0; /* use shell for subprocesses */
164 /* This vector maps GDB's idea of a register's number into an address
165 in the win32 exception context vector.
167 It also contains the bit mask needed to load the register in question.
169 One day we could read a reg, we could inspect the context we
170 already have loaded, if it doesn't have the bit set that we need,
171 we read that set of registers in using GetThreadContext. If the
172 context already contains what we need, we just unpack it. Then to
173 write a register, first we have to ensure that the context contains
174 the other regs of the group, and then we copy the info in and set
177 #define context_offset(x) ((int)&(((CONTEXT *)NULL)->x))
178 static const int mappings[] =
180 context_offset (Eax),
181 context_offset (Ecx),
182 context_offset (Edx),
183 context_offset (Ebx),
184 context_offset (Esp),
185 context_offset (Ebp),
186 context_offset (Esi),
187 context_offset (Edi),
188 context_offset (Eip),
189 context_offset (EFlags),
190 context_offset (SegCs),
191 context_offset (SegSs),
192 context_offset (SegDs),
193 context_offset (SegEs),
194 context_offset (SegFs),
195 context_offset (SegGs),
196 context_offset (FloatSave.RegisterArea[0 * 10]),
197 context_offset (FloatSave.RegisterArea[1 * 10]),
198 context_offset (FloatSave.RegisterArea[2 * 10]),
199 context_offset (FloatSave.RegisterArea[3 * 10]),
200 context_offset (FloatSave.RegisterArea[4 * 10]),
201 context_offset (FloatSave.RegisterArea[5 * 10]),
202 context_offset (FloatSave.RegisterArea[6 * 10]),
203 context_offset (FloatSave.RegisterArea[7 * 10]),
204 context_offset (FloatSave.ControlWord),
205 context_offset (FloatSave.StatusWord),
206 context_offset (FloatSave.TagWord),
207 context_offset (FloatSave.ErrorSelector),
208 context_offset (FloatSave.ErrorOffset),
209 context_offset (FloatSave.DataSelector),
210 context_offset (FloatSave.DataOffset),
211 context_offset (FloatSave.ErrorSelector)
213 context_offset (ExtendedRegisters[10*16]),
214 context_offset (ExtendedRegisters[11*16]),
215 context_offset (ExtendedRegisters[12*16]),
216 context_offset (ExtendedRegisters[13*16]),
217 context_offset (ExtendedRegisters[14*16]),
218 context_offset (ExtendedRegisters[15*16]),
219 context_offset (ExtendedRegisters[16*16]),
220 context_offset (ExtendedRegisters[17*16]),
222 context_offset (ExtendedRegisters[24])
225 #undef context_offset
227 /* This vector maps the target's idea of an exception (extracted
228 from the DEBUG_EVENT structure) to GDB's idea. */
230 struct xlate_exception
233 enum target_signal us;
236 static const struct xlate_exception
239 {EXCEPTION_ACCESS_VIOLATION, TARGET_SIGNAL_SEGV},
240 {STATUS_STACK_OVERFLOW, TARGET_SIGNAL_SEGV},
241 {EXCEPTION_BREAKPOINT, TARGET_SIGNAL_TRAP},
242 {DBG_CONTROL_C, TARGET_SIGNAL_INT},
243 {EXCEPTION_SINGLE_STEP, TARGET_SIGNAL_TRAP},
244 {STATUS_FLOAT_DIVIDE_BY_ZERO, TARGET_SIGNAL_FPE},
248 check (BOOL ok, const char *file, int line)
251 printf_filtered ("error return %s:%d was %lu\n", file, line,
255 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
256 then also retrieve the context for this thread. If GET_CONTEXT is
257 negative, then don't suspend the thread. */
259 thread_rec (DWORD id, int get_context)
263 for (th = &thread_head; (th = th->next) != NULL;)
266 if (!th->suspended && get_context)
268 if (get_context > 0 && id != current_event.dwThreadId)
270 if (SuspendThread (th->h) == (DWORD) -1)
272 DWORD err = GetLastError ();
273 warning (_("SuspendThread failed. (winerr %d)"),
279 else if (get_context < 0)
281 th->reload_context = 1;
289 /* Add a thread to the thread list. */
291 win32_add_thread (ptid_t ptid, HANDLE h)
296 gdb_assert (ptid_get_tid (ptid) != 0);
298 id = ptid_get_tid (ptid);
300 if ((th = thread_rec (id, FALSE)))
303 th = XZALLOC (thread_info);
306 th->next = thread_head.next;
307 thread_head.next = th;
309 /* Set the debug registers for the new thread if they are used. */
310 if (debug_registers_used)
312 /* Only change the value of the debug registers. */
313 th->context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
314 CHECK (GetThreadContext (th->h, &th->context));
315 th->context.Dr0 = dr[0];
316 th->context.Dr1 = dr[1];
317 th->context.Dr2 = dr[2];
318 th->context.Dr3 = dr[3];
319 th->context.Dr6 = DR6_CLEAR_VALUE;
320 th->context.Dr7 = dr[7];
321 CHECK (SetThreadContext (th->h, &th->context));
322 th->context.ContextFlags = 0;
327 /* Clear out any old thread list and reintialize it to a
330 win32_init_thread_list (void)
332 thread_info *th = &thread_head;
334 DEBUG_EVENTS (("gdb: win32_init_thread_list\n"));
336 while (th->next != NULL)
338 thread_info *here = th->next;
339 th->next = here->next;
342 thread_head.next = NULL;
345 /* Delete a thread from the list of threads */
347 win32_delete_thread (ptid_t ptid)
352 gdb_assert (ptid_get_tid (ptid) != 0);
354 id = ptid_get_tid (ptid);
357 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid));
358 delete_thread (ptid);
360 for (th = &thread_head;
361 th->next != NULL && th->next->id != id;
365 if (th->next != NULL)
367 thread_info *here = th->next;
368 th->next = here->next;
374 do_win32_fetch_inferior_registers (struct regcache *regcache, int r)
376 char *context_offset = ((char *) ¤t_thread->context) + mappings[r];
377 struct gdbarch *gdbarch = get_regcache_arch (regcache);
378 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
382 return; /* Windows sometimes uses a non-existent thread id in its
385 if (current_thread->reload_context)
387 #ifdef __COPY_CONTEXT_SIZE
388 if (have_saved_context)
390 /* Lie about where the program actually is stopped since cygwin has informed us that
391 we should consider the signal to have occurred at another location which is stored
392 in "saved_context. */
393 memcpy (¤t_thread->context, &saved_context, __COPY_CONTEXT_SIZE);
394 have_saved_context = 0;
399 thread_info *th = current_thread;
400 th->context.ContextFlags = CONTEXT_DEBUGGER_DR;
401 GetThreadContext (th->h, &th->context);
402 /* Copy dr values from that thread.
403 But only if there were not modified since last stop. PR gdb/2388 */
404 if (!debug_registers_changed)
406 dr[0] = th->context.Dr0;
407 dr[1] = th->context.Dr1;
408 dr[2] = th->context.Dr2;
409 dr[3] = th->context.Dr3;
410 dr[6] = th->context.Dr6;
411 dr[7] = th->context.Dr7;
414 current_thread->reload_context = 0;
417 if (r == I387_FISEG_REGNUM (tdep))
419 l = *((long *) context_offset) & 0xffff;
420 regcache_raw_supply (regcache, r, (char *) &l);
422 else if (r == I387_FOP_REGNUM (tdep))
424 l = (*((long *) context_offset) >> 16) & ((1 << 11) - 1);
425 regcache_raw_supply (regcache, r, (char *) &l);
428 regcache_raw_supply (regcache, r, context_offset);
431 for (r = 0; r < gdbarch_num_regs (gdbarch); r++)
432 do_win32_fetch_inferior_registers (regcache, r);
437 win32_fetch_inferior_registers (struct regcache *regcache, int r)
439 current_thread = thread_rec (ptid_get_tid (inferior_ptid), TRUE);
440 /* Check if current_thread exists. Windows sometimes uses a non-existent
441 thread id in its events */
443 do_win32_fetch_inferior_registers (regcache, r);
447 do_win32_store_inferior_registers (const struct regcache *regcache, int r)
450 /* Windows sometimes uses a non-existent thread id in its events */;
452 regcache_raw_collect (regcache, r,
453 ((char *) ¤t_thread->context) + mappings[r]);
456 for (r = 0; r < gdbarch_num_regs (get_regcache_arch (regcache)); r++)
457 do_win32_store_inferior_registers (regcache, r);
461 /* Store a new register value into the current thread context */
463 win32_store_inferior_registers (struct regcache *regcache, int r)
465 current_thread = thread_rec (ptid_get_tid (inferior_ptid), TRUE);
466 /* Check if current_thread exists. Windows sometimes uses a non-existent
467 thread id in its events */
469 do_win32_store_inferior_registers (regcache, r);
472 static int psapi_loaded = 0;
473 static BOOL WINAPI (*psapi_EnumProcessModules) (HANDLE, HMODULE *, DWORD,
475 static BOOL WINAPI (*psapi_GetModuleInformation) (HANDLE, HMODULE, LPMODULEINFO,
477 static DWORD WINAPI (*psapi_GetModuleFileNameExA) (HANDLE, HMODULE, LPSTR,
480 /* Get the name of a given module at at given base address. If base_address
481 is zero return the first loaded module (which is always the name of the
484 get_module_name (LPVOID base_address, char *dll_name_ret)
490 HMODULE *DllHandle = dh_buf; /* Set to temporary storage for initial query */
493 char pathbuf[PATH_MAX + 1]; /* Temporary storage prior to converting to
496 char *pathbuf = dll_name_ret; /* Just copy directly to passed-in arg */
499 /* If psapi_loaded < 0 either psapi.dll is not available or it does not contain
500 the needed functions. */
501 if (psapi_loaded <= 0)
505 /* Find size of buffer needed to handle list of modules loaded in inferior */
506 if (!psapi_EnumProcessModules (current_process_handle, DllHandle,
507 sizeof (HMODULE), &cbNeeded) || !cbNeeded)
510 /* Allocate correct amount of space for module list */
511 DllHandle = (HMODULE *) alloca (cbNeeded);
515 /* Get the list of modules */
516 if (!psapi_EnumProcessModules (current_process_handle, DllHandle, cbNeeded,
520 for (i = 0; i < (int) (cbNeeded / sizeof (HMODULE)); i++)
522 /* Get information on this module */
523 if (!psapi_GetModuleInformation (current_process_handle, DllHandle[i],
525 error (_("Can't get module info"));
527 if (!base_address || mi.lpBaseOfDll == base_address)
529 /* Try to find the name of the given module */
530 len = psapi_GetModuleFileNameExA (current_process_handle,
531 DllHandle[i], pathbuf, MAX_PATH);
533 error (_("Error getting dll name: %u."), (unsigned) GetLastError ());
535 /* Cygwin prefers that the path be in /x/y/z format */
536 cygwin_conv_to_full_posix_path (pathbuf, dll_name_ret);
538 return 1; /* success */
543 dll_name_ret[0] = '\0';
544 return 0; /* failure */
547 /* Encapsulate the information required in a call to
548 symbol_file_add_args */
549 struct safe_symbol_file_add_args
553 struct section_addr_info *addrs;
556 struct ui_file *err, *out;
560 /* Maintain a linked list of "so" information. */
566 static struct so_list solib_start, *solib_end;
568 /* Call symbol_file_add with stderr redirected. We don't care if there
571 safe_symbol_file_add_stub (void *argv)
573 #define p ((struct safe_symbol_file_add_args *) argv)
574 p->ret = symbol_file_add (p->name, p->from_tty, p->addrs, p->mainline, p->flags);
579 /* Restore gdb's stderr after calling symbol_file_add */
581 safe_symbol_file_add_cleanup (void *p)
583 #define sp ((struct safe_symbol_file_add_args *)p)
584 gdb_flush (gdb_stderr);
585 gdb_flush (gdb_stdout);
586 ui_file_delete (gdb_stderr);
587 ui_file_delete (gdb_stdout);
588 gdb_stderr = sp->err;
589 gdb_stdout = sp->out;
593 /* symbol_file_add wrapper that prevents errors from being displayed. */
594 static struct objfile *
595 safe_symbol_file_add (char *name, int from_tty,
596 struct section_addr_info *addrs,
597 int mainline, int flags)
599 struct safe_symbol_file_add_args p;
600 struct cleanup *cleanup;
602 cleanup = make_cleanup (safe_symbol_file_add_cleanup, &p);
606 gdb_flush (gdb_stderr);
607 gdb_flush (gdb_stdout);
608 gdb_stderr = ui_file_new ();
609 gdb_stdout = ui_file_new ();
611 p.from_tty = from_tty;
613 p.mainline = mainline;
615 catch_errors (safe_symbol_file_add_stub, &p, "", RETURN_MASK_ERROR);
617 do_cleanups (cleanup);
621 static struct so_list *
622 win32_make_so (const char *name, LPVOID load_addr)
625 char buf[MAX_PATH + 1];
626 char cwd[MAX_PATH + 1];
628 WIN32_FIND_DATA w32_fd;
629 HANDLE h = FindFirstFile(name, &w32_fd);
630 MEMORY_BASIC_INFORMATION m;
632 if (h == INVALID_HANDLE_VALUE)
638 if (GetCurrentDirectory (MAX_PATH + 1, cwd))
640 p = strrchr (buf, '\\');
643 SetCurrentDirectory (buf);
644 GetFullPathName (w32_fd.cFileName, MAX_PATH, buf, &p);
645 SetCurrentDirectory (cwd);
649 if (strcasecmp (buf, "ntdll.dll") == 0)
651 GetSystemDirectory (buf, sizeof (buf));
652 strcat (buf, "\\ntdll.dll");
654 so = XZALLOC (struct so_list);
655 so->lm_info = (struct lm_info *) xmalloc (sizeof (struct lm_info));
656 so->lm_info->load_addr = load_addr;
657 strcpy (so->so_original_name, name);
659 strcpy (so->so_name, buf);
661 cygwin_conv_to_posix_path (buf, so->so_name);
662 /* Record cygwin1.dll .text start/end. */
663 p = strchr (so->so_name, '\0') - (sizeof ("/cygwin1.dll") - 1);
664 if (p >= so->so_name && strcasecmp (p, "/cygwin1.dll") == 0)
667 asection *text = NULL;
670 abfd = bfd_openr (so->so_name, "pei-i386");
675 if (bfd_check_format (abfd, bfd_object))
676 text = bfd_get_section_by_name (abfd, ".text");
684 /* The symbols in a dll are offset by 0x1000, which is the the
685 offset from 0 of the first byte in an image - because of the
686 file header and the section alignment. */
687 cygwin_load_start = load_addr + 0x1000;
688 cygwin_load_end = cygwin_load_start + bfd_section_size (abfd, text);
698 get_image_name (HANDLE h, void *address, int unicode)
700 static char buf[(2 * MAX_PATH) + 1];
701 DWORD size = unicode ? sizeof (WCHAR) : sizeof (char);
707 /* Attempt to read the name of the dll that was detected.
708 This is documented to work only when actively debugging
709 a program. It will not work for attached processes. */
713 /* See if we could read the address of a string, and that the
714 address isn't null. */
715 if (!ReadProcessMemory (h, address, &address_ptr, sizeof (address_ptr), &done)
716 || done != sizeof (address_ptr) || !address_ptr)
719 /* Find the length of the string */
720 while (ReadProcessMemory (h, address_ptr + len++ * size, &b, size, &done)
721 && (b[0] != 0 || b[size - 1] != 0) && done == size)
725 ReadProcessMemory (h, address_ptr, buf, len, &done);
728 WCHAR *unicode_address = (WCHAR *) alloca (len * sizeof (WCHAR));
729 ReadProcessMemory (h, address_ptr, unicode_address, len * sizeof (WCHAR),
732 WideCharToMultiByte (CP_ACP, 0, unicode_address, len, buf, len, 0, 0);
738 /* Wait for child to do something. Return pid of child, or -1 in case
739 of error; store status through argument pointer OURSTATUS. */
741 handle_load_dll (void *dummy)
743 LOAD_DLL_DEBUG_INFO *event = ¤t_event.u.LoadDll;
744 char dll_buf[MAX_PATH + 1];
745 char *dll_name = NULL;
747 dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0';
749 if (!get_module_name (event->lpBaseOfDll, dll_buf))
750 dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0';
754 if (*dll_name == '\0')
755 dll_name = get_image_name (current_process_handle,
756 event->lpImageName, event->fUnicode);
760 solib_end->next = win32_make_so (dll_name, event->lpBaseOfDll);
761 solib_end = solib_end->next;
763 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at 0x%lx.\n", solib_end->so_name,
764 solib_end->lm_info->load_addr));
770 win32_free_so (struct so_list *so)
778 handle_unload_dll (void *dummy)
780 LPVOID lpBaseOfDll = current_event.u.UnloadDll.lpBaseOfDll;
783 for (so = &solib_start; so->next != NULL; so = so->next)
784 if (so->next->lm_info->load_addr == lpBaseOfDll)
786 struct so_list *sodel = so->next;
787 so->next = sodel->next;
790 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel->so_name));
792 win32_free_so (sodel);
793 solib_add (NULL, 0, NULL, auto_solib_add);
797 error (_("Error: dll starting at 0x%lx not found."), (DWORD) lpBaseOfDll);
802 /* Clear list of loaded DLLs. */
804 win32_clear_solib (void)
806 solib_start.next = NULL;
807 solib_end = &solib_start;
810 /* Load DLL symbol info. */
812 dll_symbol_command (char *args, int from_tty)
818 error (_("dll-symbols requires a file name"));
821 if (n > 4 && strcasecmp (args + n - 4, ".dll") != 0)
823 char *newargs = (char *) alloca (n + 4 + 1);
824 strcpy (newargs, args);
825 strcat (newargs, ".dll");
829 safe_symbol_file_add (args, from_tty, NULL, 0, OBJF_SHARED | OBJF_USERLOADED);
832 /* Handle DEBUG_STRING output from child process.
833 Cygwin prepends its messages with a "cygwin:". Interpret this as
834 a Cygwin signal. Otherwise just print the string as a warning. */
836 handle_output_debug_string (struct target_waitstatus *ourstatus)
841 if (!target_read_string
842 ((CORE_ADDR) (uintptr_t) current_event.u.DebugString.lpDebugStringData,
846 else if (strncmp (s, _CYGWIN_SIGNAL_STRING, sizeof (_CYGWIN_SIGNAL_STRING) - 1) != 0)
849 if (strncmp (s, "cYg", 3) != 0)
853 #ifdef __COPY_CONTEXT_SIZE
856 /* Got a cygwin signal marker. A cygwin signal is followed by the signal number
857 itself and then optionally followed by the thread id and address to saved context
858 within the DLL. If these are supplied, then the given thread is assumed to have
859 issued the signal and the context from the thread is assumed to be stored at the
860 given address in the inferior. Tell gdb to treat this like a real signal. */
862 int sig = strtol (s + sizeof (_CYGWIN_SIGNAL_STRING) - 1, &p, 0);
863 int gotasig = target_signal_from_host (sig);
864 ourstatus->value.sig = gotasig;
869 ourstatus->kind = TARGET_WAITKIND_STOPPED;
870 retval = strtoul (p, &p, 0);
872 retval = main_thread_id;
873 else if ((x = (LPCVOID) strtoul (p, &p, 0))
874 && ReadProcessMemory (current_process_handle, x,
875 &saved_context, __COPY_CONTEXT_SIZE, &n)
876 && n == __COPY_CONTEXT_SIZE)
877 have_saved_context = 1;
878 current_event.dwThreadId = retval;
889 display_selector (HANDLE thread, DWORD sel)
892 if (GetThreadSelectorEntry (thread, sel, &info))
895 printf_filtered ("0x%03lx: ", sel);
896 if (!info.HighWord.Bits.Pres)
898 puts_filtered ("Segment not present\n");
901 base = (info.HighWord.Bits.BaseHi << 24) +
902 (info.HighWord.Bits.BaseMid << 16)
904 limit = (info.HighWord.Bits.LimitHi << 16) + info.LimitLow;
905 if (info.HighWord.Bits.Granularity)
906 limit = (limit << 12) | 0xfff;
907 printf_filtered ("base=0x%08x limit=0x%08x", base, limit);
908 if (info.HighWord.Bits.Default_Big)
909 puts_filtered(" 32-bit ");
911 puts_filtered(" 16-bit ");
912 switch ((info.HighWord.Bits.Type & 0xf) >> 1)
915 puts_filtered ("Data (Read-Only, Exp-up");
918 puts_filtered ("Data (Read/Write, Exp-up");
921 puts_filtered ("Unused segment (");
924 puts_filtered ("Data (Read/Write, Exp-down");
927 puts_filtered ("Code (Exec-Only, N.Conf");
930 puts_filtered ("Code (Exec/Read, N.Conf");
933 puts_filtered ("Code (Exec-Only, Conf");
936 puts_filtered ("Code (Exec/Read, Conf");
939 printf_filtered ("Unknown type 0x%x",info.HighWord.Bits.Type);
941 if ((info.HighWord.Bits.Type & 0x1) == 0)
942 puts_filtered(", N.Acc");
943 puts_filtered (")\n");
944 if ((info.HighWord.Bits.Type & 0x10) == 0)
945 puts_filtered("System selector ");
946 printf_filtered ("Priviledge level = %d. ", info.HighWord.Bits.Dpl);
947 if (info.HighWord.Bits.Granularity)
948 puts_filtered ("Page granular.\n");
950 puts_filtered ("Byte granular.\n");
955 printf_filtered ("Invalid selector 0x%lx.\n",sel);
961 display_selectors (char * args, int from_tty)
965 puts_filtered ("Impossible to display selectors now.\n");
971 puts_filtered ("Selector $cs\n");
972 display_selector (current_thread->h,
973 current_thread->context.SegCs);
974 puts_filtered ("Selector $ds\n");
975 display_selector (current_thread->h,
976 current_thread->context.SegDs);
977 puts_filtered ("Selector $es\n");
978 display_selector (current_thread->h,
979 current_thread->context.SegEs);
980 puts_filtered ("Selector $ss\n");
981 display_selector (current_thread->h,
982 current_thread->context.SegSs);
983 puts_filtered ("Selector $fs\n");
984 display_selector (current_thread->h,
985 current_thread->context.SegFs);
986 puts_filtered ("Selector $gs\n");
987 display_selector (current_thread->h,
988 current_thread->context.SegGs);
993 sel = parse_and_eval_long (args);
994 printf_filtered ("Selector \"%s\"\n",args);
995 display_selector (current_thread->h, sel);
999 static struct cmd_list_element *info_w32_cmdlist = NULL;
1002 info_w32_command (char *args, int from_tty)
1004 help_list (info_w32_cmdlist, "info w32 ", class_info, gdb_stdout);
1008 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1009 printf_unfiltered ("gdb: Target exception %s at 0x%08lx\n", x, \
1010 current_event.u.Exception.ExceptionRecord.ExceptionAddress)
1013 handle_exception (struct target_waitstatus *ourstatus)
1016 DWORD code = current_event.u.Exception.ExceptionRecord.ExceptionCode;
1018 ourstatus->kind = TARGET_WAITKIND_STOPPED;
1020 /* Record the context of the current thread */
1021 th = thread_rec (current_event.dwThreadId, -1);
1025 case EXCEPTION_ACCESS_VIOLATION:
1026 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1027 ourstatus->value.sig = TARGET_SIGNAL_SEGV;
1030 /* See if the access violation happened within the cygwin DLL itself. Cygwin uses
1031 a kind of exception handling to deal with passed-in invalid addresses. gdb
1032 should not treat these as real SEGVs since they will be silently handled by
1033 cygwin. A real SEGV will (theoretically) be caught by cygwin later in the process
1034 and will be sent as a cygwin-specific-signal. So, ignore SEGVs if they show up
1035 within the text segment of the DLL itself. */
1037 bfd_vma addr = (bfd_vma) (uintptr_t) current_event.u.Exception.
1038 ExceptionRecord.ExceptionAddress;
1039 if ((!cygwin_exceptions && (addr >= cygwin_load_start && addr < cygwin_load_end))
1040 || (find_pc_partial_function (addr, &fn, NULL, NULL)
1041 && strncmp (fn, "KERNEL32!IsBad", strlen ("KERNEL32!IsBad")) == 0))
1046 case STATUS_STACK_OVERFLOW:
1047 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1048 ourstatus->value.sig = TARGET_SIGNAL_SEGV;
1050 case STATUS_FLOAT_DENORMAL_OPERAND:
1051 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1052 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1054 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
1055 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1056 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1058 case STATUS_FLOAT_INEXACT_RESULT:
1059 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1060 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1062 case STATUS_FLOAT_INVALID_OPERATION:
1063 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1064 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1066 case STATUS_FLOAT_OVERFLOW:
1067 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1068 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1070 case STATUS_FLOAT_STACK_CHECK:
1071 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1072 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1074 case STATUS_FLOAT_UNDERFLOW:
1075 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1076 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1078 case STATUS_FLOAT_DIVIDE_BY_ZERO:
1079 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1080 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1082 case STATUS_INTEGER_DIVIDE_BY_ZERO:
1083 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1084 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1086 case STATUS_INTEGER_OVERFLOW:
1087 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1088 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1090 case EXCEPTION_BREAKPOINT:
1091 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1092 ourstatus->value.sig = TARGET_SIGNAL_TRAP;
1095 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1096 ourstatus->value.sig = TARGET_SIGNAL_INT;
1098 case DBG_CONTROL_BREAK:
1099 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1100 ourstatus->value.sig = TARGET_SIGNAL_INT;
1102 case EXCEPTION_SINGLE_STEP:
1103 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1104 ourstatus->value.sig = TARGET_SIGNAL_TRAP;
1106 case EXCEPTION_ILLEGAL_INSTRUCTION:
1107 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1108 ourstatus->value.sig = TARGET_SIGNAL_ILL;
1110 case EXCEPTION_PRIV_INSTRUCTION:
1111 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1112 ourstatus->value.sig = TARGET_SIGNAL_ILL;
1114 case EXCEPTION_NONCONTINUABLE_EXCEPTION:
1115 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1116 ourstatus->value.sig = TARGET_SIGNAL_ILL;
1119 /* Treat unhandled first chance exceptions specially. */
1120 if (current_event.u.Exception.dwFirstChance)
1122 printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",
1123 current_event.u.Exception.ExceptionRecord.ExceptionCode,
1124 current_event.u.Exception.ExceptionRecord.ExceptionAddress);
1125 ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
1129 last_sig = ourstatus->value.sig;
1133 /* Resume all artificially suspended threads if we are continuing
1136 win32_continue (DWORD continue_status, int id)
1142 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, %s);\n",
1143 current_event.dwProcessId, current_event.dwThreadId,
1144 continue_status == DBG_CONTINUE ?
1145 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1147 for (th = &thread_head; (th = th->next) != NULL;)
1148 if ((id == -1 || id == (int) th->id)
1151 if (debug_registers_changed)
1153 th->context.ContextFlags |= CONTEXT_DEBUG_REGISTERS;
1154 th->context.Dr0 = dr[0];
1155 th->context.Dr1 = dr[1];
1156 th->context.Dr2 = dr[2];
1157 th->context.Dr3 = dr[3];
1158 th->context.Dr6 = DR6_CLEAR_VALUE;
1159 th->context.Dr7 = dr[7];
1161 if (th->context.ContextFlags)
1163 CHECK (SetThreadContext (th->h, &th->context));
1164 th->context.ContextFlags = 0;
1166 if (th->suspended > 0)
1167 (void) ResumeThread (th->h);
1171 res = ContinueDebugEvent (current_event.dwProcessId,
1172 current_event.dwThreadId,
1175 debug_registers_changed = 0;
1179 /* Called in pathological case where Windows fails to send a
1180 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1182 fake_create_process (void)
1184 current_process_handle = OpenProcess (PROCESS_ALL_ACCESS, FALSE,
1185 current_event.dwProcessId);
1186 if (current_process_handle != NULL)
1187 open_process_used = 1;
1190 error (_("OpenProcess call failed, GetLastError = %lud\n"),
1192 /* We can not debug anything in that case. */
1194 main_thread_id = current_event.dwThreadId;
1195 current_thread = win32_add_thread (ptid_build (current_event.dwProcessId, 0,
1196 current_event.dwThreadId),
1197 current_event.u.CreateThread.hThread);
1198 return main_thread_id;
1202 win32_resume (ptid_t ptid, int step, enum target_signal sig)
1205 DWORD continue_status = DBG_CONTINUE;
1207 /* A specific PTID means `step only this thread id'. */
1208 int resume_all = ptid_equal (ptid, minus_one_ptid);
1210 /* If we're continuing all threads, it's the current inferior that
1211 should be handled specially. */
1213 ptid = inferior_ptid;
1215 if (sig != TARGET_SIGNAL_0)
1217 if (current_event.dwDebugEventCode != EXCEPTION_DEBUG_EVENT)
1219 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig));
1221 else if (sig == last_sig)
1222 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1225 /* This code does not seem to work, because
1226 the kernel does probably not consider changes in the ExceptionRecord
1227 structure when passing the exception to the inferior.
1228 Note that this seems possible in the exception handler itself. */
1231 for (i = 0; xlate[i].them != -1; i++)
1232 if (xlate[i].us == sig)
1234 current_event.u.Exception.ExceptionRecord.ExceptionCode =
1236 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1239 if (continue_status == DBG_CONTINUE)
1241 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig));
1245 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1249 last_sig = TARGET_SIGNAL_0;
1251 DEBUG_EXEC (("gdb: win32_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1252 ptid_get_pid (ptid), ptid_get_tid (ptid), step, sig));
1254 /* Get context for currently selected thread */
1255 th = thread_rec (ptid_get_tid (inferior_ptid), FALSE);
1260 /* Single step by setting t bit */
1261 win32_fetch_inferior_registers (get_current_regcache (),
1262 gdbarch_ps_regnum (current_gdbarch));
1263 th->context.EFlags |= FLAG_TRACE_BIT;
1266 if (th->context.ContextFlags)
1268 if (debug_registers_changed)
1270 th->context.Dr0 = dr[0];
1271 th->context.Dr1 = dr[1];
1272 th->context.Dr2 = dr[2];
1273 th->context.Dr3 = dr[3];
1274 th->context.Dr6 = DR6_CLEAR_VALUE;
1275 th->context.Dr7 = dr[7];
1277 CHECK (SetThreadContext (th->h, &th->context));
1278 th->context.ContextFlags = 0;
1282 /* Allow continuing with the same signal that interrupted us.
1283 Otherwise complain. */
1286 win32_continue (continue_status, -1);
1288 win32_continue (continue_status, ptid_get_tid (ptid));
1291 /* Get the next event from the child. Return 1 if the event requires
1292 handling by WFI (or whatever).
1295 get_win32_debug_event (int pid, struct target_waitstatus *ourstatus)
1298 DWORD continue_status, event_code;
1300 static thread_info dummy_thread_info;
1303 last_sig = TARGET_SIGNAL_0;
1305 if (!(debug_event = WaitForDebugEvent (¤t_event, 1000)))
1309 continue_status = DBG_CONTINUE;
1311 event_code = current_event.dwDebugEventCode;
1312 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
1314 have_saved_context = 0;
1318 case CREATE_THREAD_DEBUG_EVENT:
1319 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1320 (unsigned) current_event.dwProcessId,
1321 (unsigned) current_event.dwThreadId,
1322 "CREATE_THREAD_DEBUG_EVENT"));
1323 if (saw_create != 1)
1325 struct inferior *inf;
1326 inf = find_inferior_pid (current_event.dwProcessId);
1327 if (!saw_create && inf->attach_flag)
1329 /* Kludge around a Windows bug where first event is a create
1330 thread event. Caused when attached process does not have
1332 retval = fake_create_process ();
1338 /* Record the existence of this thread */
1339 retval = current_event.dwThreadId;
1340 th = win32_add_thread (ptid_build (current_event.dwProcessId, 0,
1341 current_event.dwThreadId),
1342 current_event.u.CreateThread.hThread);
1345 case EXIT_THREAD_DEBUG_EVENT:
1346 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1347 (unsigned) current_event.dwProcessId,
1348 (unsigned) current_event.dwThreadId,
1349 "EXIT_THREAD_DEBUG_EVENT"));
1350 if (current_event.dwThreadId != main_thread_id)
1352 win32_delete_thread (ptid_build (current_event.dwProcessId, 0,
1353 current_event.dwThreadId));
1354 th = &dummy_thread_info;
1358 case CREATE_PROCESS_DEBUG_EVENT:
1359 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1360 (unsigned) current_event.dwProcessId,
1361 (unsigned) current_event.dwThreadId,
1362 "CREATE_PROCESS_DEBUG_EVENT"));
1363 CloseHandle (current_event.u.CreateProcessInfo.hFile);
1364 if (++saw_create != 1)
1367 current_process_handle = current_event.u.CreateProcessInfo.hProcess;
1369 win32_delete_thread (ptid_build (current_event.dwProcessId, 0,
1371 main_thread_id = current_event.dwThreadId;
1372 /* Add the main thread */
1373 th = win32_add_thread (ptid_build (current_event.dwProcessId, 0,
1374 current_event.dwThreadId),
1375 current_event.u.CreateProcessInfo.hThread);
1376 retval = current_event.dwThreadId;
1379 case EXIT_PROCESS_DEBUG_EVENT:
1380 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1381 (unsigned) current_event.dwProcessId,
1382 (unsigned) current_event.dwThreadId,
1383 "EXIT_PROCESS_DEBUG_EVENT"));
1384 if (saw_create != 1)
1386 ourstatus->kind = TARGET_WAITKIND_EXITED;
1387 ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode;
1388 retval = main_thread_id;
1391 case LOAD_DLL_DEBUG_EVENT:
1392 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1393 (unsigned) current_event.dwProcessId,
1394 (unsigned) current_event.dwThreadId,
1395 "LOAD_DLL_DEBUG_EVENT"));
1396 CloseHandle (current_event.u.LoadDll.hFile);
1397 if (saw_create != 1)
1399 catch_errors (handle_load_dll, NULL, (char *) "", RETURN_MASK_ALL);
1400 ourstatus->kind = TARGET_WAITKIND_LOADED;
1401 ourstatus->value.integer = 0;
1402 retval = main_thread_id;
1405 case UNLOAD_DLL_DEBUG_EVENT:
1406 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1407 (unsigned) current_event.dwProcessId,
1408 (unsigned) current_event.dwThreadId,
1409 "UNLOAD_DLL_DEBUG_EVENT"));
1410 if (saw_create != 1)
1412 catch_errors (handle_unload_dll, NULL, (char *) "", RETURN_MASK_ALL);
1413 ourstatus->kind = TARGET_WAITKIND_LOADED;
1414 ourstatus->value.integer = 0;
1415 retval = main_thread_id;
1418 case EXCEPTION_DEBUG_EVENT:
1419 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1420 (unsigned) current_event.dwProcessId,
1421 (unsigned) current_event.dwThreadId,
1422 "EXCEPTION_DEBUG_EVENT"));
1423 if (saw_create != 1)
1425 switch (handle_exception (ourstatus))
1428 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1431 retval = current_event.dwThreadId;
1435 continue_status = -1;
1440 case OUTPUT_DEBUG_STRING_EVENT: /* message from the kernel */
1441 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1442 (unsigned) current_event.dwProcessId,
1443 (unsigned) current_event.dwThreadId,
1444 "OUTPUT_DEBUG_STRING_EVENT"));
1445 if (saw_create != 1)
1447 retval = handle_output_debug_string (ourstatus);
1451 if (saw_create != 1)
1453 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1454 (DWORD) current_event.dwProcessId,
1455 (DWORD) current_event.dwThreadId);
1456 printf_unfiltered (" unknown event code %ld\n",
1457 current_event.dwDebugEventCode);
1461 if (!retval || saw_create != 1)
1463 if (continue_status == -1)
1464 win32_resume (minus_one_ptid, 0, 1);
1466 CHECK (win32_continue (continue_status, -1));
1470 inferior_ptid = ptid_build (current_event.dwProcessId, 0,
1472 current_thread = th ?: thread_rec (current_event.dwThreadId, TRUE);
1479 /* Wait for interesting events to occur in the target process. */
1481 win32_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
1485 target_terminal_ours ();
1487 /* We loop when we get a non-standard exception rather than return
1488 with a SPURIOUS because resume can try and step or modify things,
1489 which needs a current_thread->h. But some of these exceptions mark
1490 the birth or death of threads, which mean that the current thread
1491 isn't necessarily what you think it is. */
1497 /* Ignore CTRL+C signals while waiting for a debug event.
1498 FIXME: brobecker/2008-05-20: When the user presses CTRL+C while
1499 the inferior is running, both the inferior and GDB receive the
1500 associated signal. If the inferior receives the signal first
1501 and the delay until GDB receives that signal is sufficiently long,
1502 GDB can sometimes receive the SIGINT after we have unblocked
1503 the CTRL+C handler. This would lead to the debugger to stop
1504 prematurely while handling the new-thread event that comes
1505 with the handling of the SIGINT inside the inferior, and then
1506 stop again immediately when the user tries to resume the execution
1507 in the inferior. This is a classic race, and it would be nice
1508 to find a better solution to that problem. But in the meantime,
1509 the current approach already greatly mitigate this issue. */
1510 SetConsoleCtrlHandler (NULL, TRUE);
1511 retval = get_win32_debug_event (pid, ourstatus);
1512 SetConsoleCtrlHandler (NULL, FALSE);
1515 return ptid_build (current_event.dwProcessId, 0, retval);
1520 if (deprecated_ui_loop_hook != NULL)
1521 detach = deprecated_ui_loop_hook (0);
1524 win32_kill_inferior ();
1530 do_initial_win32_stuff (struct target_ops *ops, DWORD pid, int attaching)
1532 extern int stop_after_trap;
1534 struct inferior *inf;
1535 struct thread_info *tp;
1537 last_sig = TARGET_SIGNAL_0;
1539 exception_count = 0;
1540 open_process_used = 0;
1541 debug_registers_changed = 0;
1542 debug_registers_used = 0;
1543 for (i = 0; i < sizeof (dr) / sizeof (dr[0]); i++)
1546 cygwin_load_start = cygwin_load_end = 0;
1548 current_event.dwProcessId = pid;
1549 memset (¤t_event, 0, sizeof (current_event));
1551 disable_breakpoints_in_shlibs ();
1552 win32_clear_solib ();
1553 clear_proceed_status ();
1554 init_wait_for_inferior ();
1556 inf = add_inferior (pid);
1557 inf->attach_flag = attaching;
1559 /* Make the new process the current inferior, so terminal handling
1560 can rely on it. When attaching, we don't know about any thread
1561 id here, but that's OK --- nothing should be referencing the
1562 current thread until we report an event out of win32_wait. */
1563 inferior_ptid = pid_to_ptid (pid);
1565 terminal_init_inferior_with_pgrp (pid);
1566 target_terminal_inferior ();
1568 inf->stop_soon = STOP_QUIETLY;
1571 stop_after_trap = 1;
1572 wait_for_inferior (0);
1573 tp = inferior_thread ();
1574 if (tp->stop_signal != TARGET_SIGNAL_TRAP)
1575 resume (0, tp->stop_signal);
1580 inf->stop_soon = NO_STOP_QUIETLY;
1581 stop_after_trap = 0;
1585 /* Since Windows XP, detaching from a process is supported by Windows.
1586 The following code tries loading the appropriate functions dynamically.
1587 If loading these functions succeeds use them to actually detach from
1588 the inferior process, otherwise behave as usual, pretending that
1589 detach has worked. */
1590 static BOOL WINAPI (*kernel32_DebugSetProcessKillOnExit)(BOOL);
1591 static BOOL WINAPI (*kernel32_DebugActiveProcessStop)(DWORD);
1594 has_detach_ability (void)
1596 static HMODULE kernel32 = NULL;
1599 kernel32 = LoadLibrary ("kernel32.dll");
1602 if (!kernel32_DebugSetProcessKillOnExit)
1603 kernel32_DebugSetProcessKillOnExit =
1604 (void *) GetProcAddress (kernel32, "DebugSetProcessKillOnExit");
1605 if (!kernel32_DebugActiveProcessStop)
1606 kernel32_DebugActiveProcessStop =
1607 (void *) GetProcAddress (kernel32, "DebugActiveProcessStop");
1608 if (kernel32_DebugSetProcessKillOnExit
1609 && kernel32_DebugActiveProcessStop)
1615 /* Try to set or remove a user privilege to the current process. Return -1
1616 if that fails, the previous setting of that privilege otherwise.
1618 This code is copied from the Cygwin source code and rearranged to allow
1619 dynamically loading of the needed symbols from advapi32 which is only
1620 available on NT/2K/XP. */
1622 set_process_privilege (const char *privilege, BOOL enable)
1624 static HMODULE advapi32 = NULL;
1625 static BOOL WINAPI (*OpenProcessToken)(HANDLE, DWORD, PHANDLE);
1626 static BOOL WINAPI (*LookupPrivilegeValue)(LPCSTR, LPCSTR, PLUID);
1627 static BOOL WINAPI (*AdjustTokenPrivileges)(HANDLE, BOOL, PTOKEN_PRIVILEGES,
1628 DWORD, PTOKEN_PRIVILEGES, PDWORD);
1630 HANDLE token_hdl = NULL;
1632 TOKEN_PRIVILEGES new_priv, orig_priv;
1636 if (GetVersion () >= 0x80000000) /* No security availbale on 9x/Me */
1641 if (!(advapi32 = LoadLibrary ("advapi32.dll")))
1643 if (!OpenProcessToken)
1645 (void *) GetProcAddress (advapi32, "OpenProcessToken");
1646 if (!LookupPrivilegeValue)
1647 LookupPrivilegeValue =
1648 (void *) GetProcAddress (advapi32, "LookupPrivilegeValueA");
1649 if (!AdjustTokenPrivileges)
1650 AdjustTokenPrivileges =
1651 (void *) GetProcAddress (advapi32, "AdjustTokenPrivileges");
1652 if (!OpenProcessToken || !LookupPrivilegeValue || !AdjustTokenPrivileges)
1659 if (!OpenProcessToken (GetCurrentProcess (),
1660 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
1664 if (!LookupPrivilegeValue (NULL, privilege, &restore_priv))
1667 new_priv.PrivilegeCount = 1;
1668 new_priv.Privileges[0].Luid = restore_priv;
1669 new_priv.Privileges[0].Attributes = enable ? SE_PRIVILEGE_ENABLED : 0;
1671 if (!AdjustTokenPrivileges (token_hdl, FALSE, &new_priv,
1672 sizeof orig_priv, &orig_priv, &size))
1675 /* Disabled, otherwise every `attach' in an unprivileged user session
1676 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1678 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1679 be enabled. GetLastError () returns an correct error code, though. */
1680 if (enable && GetLastError () == ERROR_NOT_ALL_ASSIGNED)
1684 ret = orig_priv.Privileges[0].Attributes == SE_PRIVILEGE_ENABLED ? 1 : 0;
1688 CloseHandle (token_hdl);
1693 /* Attach to process PID, then initialize for debugging it. */
1695 win32_attach (struct target_ops *ops, char *args, int from_tty)
1701 error_no_arg (_("process-id to attach"));
1703 if (set_process_privilege (SE_DEBUG_NAME, TRUE) < 0)
1705 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1706 printf_unfiltered ("This can cause attach to fail on Windows NT/2K/XP\n");
1709 pid = strtoul (args, 0, 0); /* Windows pid */
1711 win32_init_thread_list ();
1712 ok = DebugActiveProcess (pid);
1718 /* Try fall back to Cygwin pid */
1719 pid = cygwin_internal (CW_CYGWIN_PID_TO_WINPID, pid);
1722 ok = DebugActiveProcess (pid);
1727 error (_("Can't attach to process."));
1729 if (has_detach_ability ())
1730 kernel32_DebugSetProcessKillOnExit (FALSE);
1734 char *exec_file = (char *) get_exec_file (0);
1737 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
1738 target_pid_to_str (pid_to_ptid (pid)));
1740 printf_unfiltered ("Attaching to %s\n",
1741 target_pid_to_str (pid_to_ptid (pid)));
1743 gdb_flush (gdb_stdout);
1746 do_initial_win32_stuff (ops, pid, 1);
1747 target_terminal_ours ();
1751 win32_detach (struct target_ops *ops, char *args, int from_tty)
1755 if (has_detach_ability ())
1758 win32_resume (ptid, 0, TARGET_SIGNAL_0);
1760 if (!kernel32_DebugActiveProcessStop (current_event.dwProcessId))
1762 error (_("Can't detach process %lu (error %lu)"),
1763 current_event.dwProcessId, GetLastError ());
1766 kernel32_DebugSetProcessKillOnExit (FALSE);
1768 if (detached && from_tty)
1770 char *exec_file = get_exec_file (0);
1773 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file,
1774 current_event.dwProcessId);
1775 gdb_flush (gdb_stdout);
1778 inferior_ptid = null_ptid;
1779 detach_inferior (current_event.dwProcessId);
1781 unpush_target (ops);
1785 win32_pid_to_exec_file (int pid)
1787 static char path[MAX_PATH + 1];
1790 /* Try to find exe name as symlink target of /proc/<pid>/exe */
1792 char procexe[sizeof ("/proc/4294967295/exe")];
1793 sprintf (procexe, "/proc/%u/exe", pid);
1794 nchars = readlink (procexe, path, sizeof(path));
1795 if (nchars > 0 && nchars < sizeof (path))
1797 path[nchars] = '\0'; /* Got it */
1802 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
1803 of gdb, or we're trying to debug a non-Cygwin windows executable. */
1804 if (!get_module_name (0, path))
1810 /* Print status information about what we're accessing. */
1813 win32_files_info (struct target_ops *ignore)
1815 struct inferior *inf = current_inferior ();
1817 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1818 inf->attach_flag ? "attached" : "child",
1819 target_pid_to_str (inferior_ptid));
1823 win32_open (char *arg, int from_tty)
1825 error (_("Use the \"run\" command to start a Unix child process."));
1828 /* Start an inferior win32 child process and sets inferior_ptid to its pid.
1829 EXEC_FILE is the file to run.
1830 ALLARGS is a string containing the arguments to the program.
1831 ENV is the environment vector to pass. Errors reported with error(). */
1834 win32_create_inferior (struct target_ops *ops, char *exec_file,
1835 char *allargs, char **in_env, int from_tty)
1838 PROCESS_INFORMATION pi;
1842 char real_path[MAXPATHLEN];
1844 char shell[MAX_PATH + 1]; /* Path to shell */
1847 int ostdin, ostdout, ostderr;
1848 const char *inferior_io_terminal = get_inferior_io_terminal ();
1851 error (_("No executable specified, use `target exec'."));
1853 memset (&si, 0, sizeof (si));
1854 si.cb = sizeof (si);
1859 flags = DEBUG_ONLY_THIS_PROCESS;
1860 cygwin_conv_to_win32_path (exec_file, real_path);
1866 sh = getenv ("SHELL");
1869 cygwin_conv_to_win32_path (sh, shell);
1870 newallargs = alloca (sizeof (" -c 'exec '") + strlen (exec_file)
1871 + strlen (allargs) + 2);
1872 sprintf (newallargs, " -c 'exec %s %s'", exec_file, allargs);
1873 allargs = newallargs;
1875 flags = DEBUG_PROCESS;
1879 flags = DEBUG_ONLY_THIS_PROCESS;
1883 flags |= CREATE_NEW_PROCESS_GROUP;
1886 flags |= CREATE_NEW_CONSOLE;
1888 args = alloca (strlen (toexec) + strlen (allargs) + 2);
1889 strcpy (args, toexec);
1891 strcat (args, allargs);
1894 /* Prepare the environment vars for CreateProcess. */
1895 cygwin_internal (CW_SYNC_WINENV);
1897 if (!inferior_io_terminal)
1898 tty = ostdin = ostdout = ostderr = -1;
1901 tty = open (inferior_io_terminal, O_RDWR | O_NOCTTY);
1904 print_sys_errmsg (inferior_io_terminal, errno);
1905 ostdin = ostdout = ostderr = -1;
1919 win32_init_thread_list ();
1920 ret = CreateProcess (0,
1921 args, /* command line */
1922 NULL, /* Security */
1924 TRUE, /* inherit handles */
1925 flags, /* start flags */
1926 NULL, /* environment */
1927 NULL, /* current directory */
1945 error (_("Error creating process %s, (error %d)."),
1946 exec_file, (unsigned) GetLastError ());
1948 CloseHandle (pi.hThread);
1949 CloseHandle (pi.hProcess);
1951 if (useshell && shell[0] != '\0')
1956 do_initial_win32_stuff (ops, pi.dwProcessId, 0);
1958 /* win32_continue (DBG_CONTINUE, -1); */
1962 win32_mourn_inferior (struct target_ops *ops)
1964 (void) win32_continue (DBG_CONTINUE, -1);
1965 i386_cleanup_dregs();
1966 if (open_process_used)
1968 CHECK (CloseHandle (current_process_handle));
1969 open_process_used = 0;
1971 unpush_target (ops);
1972 generic_mourn_inferior ();
1975 /* Send a SIGINT to the process group. This acts just like the user typed a
1976 ^C on the controlling terminal. */
1979 win32_stop (ptid_t ptid)
1981 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1982 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId));
1983 registers_changed (); /* refresh register state */
1987 win32_xfer_memory (CORE_ADDR memaddr, gdb_byte *our, int len,
1988 int write, struct mem_attrib *mem,
1989 struct target_ops *target)
1994 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1995 len, (DWORD) (uintptr_t) memaddr));
1996 if (!WriteProcessMemory (current_process_handle,
1997 (LPVOID) (uintptr_t) memaddr, our,
2000 FlushInstructionCache (current_process_handle,
2001 (LPCVOID) (uintptr_t) memaddr, len);
2005 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
2006 len, (DWORD) (uintptr_t) memaddr));
2007 if (!ReadProcessMemory (current_process_handle,
2008 (LPCVOID) (uintptr_t) memaddr, our,
2016 win32_kill_inferior (void)
2018 CHECK (TerminateProcess (current_process_handle, 0));
2022 if (!win32_continue (DBG_CONTINUE, -1))
2024 if (!WaitForDebugEvent (¤t_event, INFINITE))
2026 if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
2030 target_mourn_inferior (); /* or just win32_mourn_inferior? */
2034 win32_prepare_to_store (struct regcache *regcache)
2036 /* Do nothing, since we can store individual regs */
2040 win32_can_run (void)
2048 DEBUG_EVENTS (("gdb: win32_close, inferior_ptid=%d\n",
2049 PIDGET (inferior_ptid)));
2052 /* Convert pid to printable format. */
2054 win32_pid_to_str (ptid_t ptid)
2056 static char buf[80];
2058 if (ptid_get_tid (ptid) != 0)
2060 snprintf (buf, sizeof (buf), "Thread %d.0x%lx",
2061 ptid_get_pid (ptid), ptid_get_tid (ptid));
2065 return normal_pid_to_str (ptid);
2069 win32_xfer_shared_libraries (struct target_ops *ops,
2070 enum target_object object, const char *annex,
2071 gdb_byte *readbuf, const gdb_byte *writebuf,
2072 ULONGEST offset, LONGEST len)
2074 struct obstack obstack;
2082 obstack_init (&obstack);
2083 obstack_grow_str (&obstack, "<library-list>\n");
2084 for (so = solib_start.next; so; so = so->next)
2085 win32_xfer_shared_library (so->so_name, (CORE_ADDR) so->lm_info->load_addr,
2087 obstack_grow_str0 (&obstack, "</library-list>\n");
2089 buf = obstack_finish (&obstack);
2090 len_avail = strlen (buf);
2091 if (offset >= len_avail)
2094 if (len > len_avail - offset)
2095 len = len_avail - offset;
2096 memcpy (readbuf, buf + offset, len);
2098 obstack_free (&obstack, NULL);
2103 win32_xfer_partial (struct target_ops *ops, enum target_object object,
2104 const char *annex, gdb_byte *readbuf,
2105 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
2109 case TARGET_OBJECT_MEMORY:
2111 return (*ops->deprecated_xfer_memory) (offset, readbuf,
2112 len, 0/*read*/, NULL, ops);
2114 return (*ops->deprecated_xfer_memory) (offset, (gdb_byte *) writebuf,
2115 len, 1/*write*/, NULL, ops);
2118 case TARGET_OBJECT_LIBRARIES:
2119 return win32_xfer_shared_libraries (ops, object, annex, readbuf,
2120 writebuf, offset, len);
2123 if (ops->beneath != NULL)
2124 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
2125 readbuf, writebuf, offset, len);
2131 init_win32_ops (void)
2133 win32_ops.to_shortname = "child";
2134 win32_ops.to_longname = "Win32 child process";
2135 win32_ops.to_doc = "Win32 child process (started by the \"run\" command).";
2136 win32_ops.to_open = win32_open;
2137 win32_ops.to_close = win32_close;
2138 win32_ops.to_attach = win32_attach;
2139 win32_ops.to_attach_no_wait = 1;
2140 win32_ops.to_detach = win32_detach;
2141 win32_ops.to_resume = win32_resume;
2142 win32_ops.to_wait = win32_wait;
2143 win32_ops.to_fetch_registers = win32_fetch_inferior_registers;
2144 win32_ops.to_store_registers = win32_store_inferior_registers;
2145 win32_ops.to_prepare_to_store = win32_prepare_to_store;
2146 win32_ops.deprecated_xfer_memory = win32_xfer_memory;
2147 win32_ops.to_xfer_partial = win32_xfer_partial;
2148 win32_ops.to_files_info = win32_files_info;
2149 win32_ops.to_insert_breakpoint = memory_insert_breakpoint;
2150 win32_ops.to_remove_breakpoint = memory_remove_breakpoint;
2151 win32_ops.to_terminal_init = terminal_init_inferior;
2152 win32_ops.to_terminal_inferior = terminal_inferior;
2153 win32_ops.to_terminal_ours_for_output = terminal_ours_for_output;
2154 win32_ops.to_terminal_ours = terminal_ours;
2155 win32_ops.to_terminal_save_ours = terminal_save_ours;
2156 win32_ops.to_terminal_info = child_terminal_info;
2157 win32_ops.to_kill = win32_kill_inferior;
2158 win32_ops.to_create_inferior = win32_create_inferior;
2159 win32_ops.to_mourn_inferior = win32_mourn_inferior;
2160 win32_ops.to_can_run = win32_can_run;
2161 win32_ops.to_thread_alive = win32_win32_thread_alive;
2162 win32_ops.to_pid_to_str = win32_pid_to_str;
2163 win32_ops.to_stop = win32_stop;
2164 win32_ops.to_stratum = process_stratum;
2165 win32_ops.to_has_all_memory = 1;
2166 win32_ops.to_has_memory = 1;
2167 win32_ops.to_has_stack = 1;
2168 win32_ops.to_has_registers = 1;
2169 win32_ops.to_has_execution = 1;
2170 win32_ops.to_pid_to_exec_file = win32_pid_to_exec_file;
2171 win32_ops.to_magic = OPS_MAGIC;
2175 set_win32_aliases (char *argv0)
2177 add_info_alias ("dll", "sharedlibrary", 1);
2181 _initialize_win32_nat (void)
2183 struct cmd_list_element *c;
2187 c = add_com ("dll-symbols", class_files, dll_symbol_command,
2188 _("Load dll library symbols from FILE."));
2189 set_cmd_completer (c, filename_completer);
2191 add_com_alias ("sharedlibrary", "dll-symbols", class_alias, 1);
2194 add_setshow_boolean_cmd ("shell", class_support, &useshell, _("\
2195 Set use of shell to start subprocess."), _("\
2196 Show use of shell to start subprocess."), NULL,
2198 NULL, /* FIXME: i18n: */
2199 &setlist, &showlist);
2201 add_setshow_boolean_cmd ("cygwin-exceptions", class_support, &cygwin_exceptions, _("\
2202 Break when an exception is detected in the Cygwin DLL itself."), _("\
2203 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL,
2205 NULL, /* FIXME: i18n: */
2206 &setlist, &showlist);
2209 add_setshow_boolean_cmd ("new-console", class_support, &new_console, _("\
2210 Set creation of new console when creating child process."), _("\
2211 Show creation of new console when creating child process."), NULL,
2213 NULL, /* FIXME: i18n: */
2214 &setlist, &showlist);
2216 add_setshow_boolean_cmd ("new-group", class_support, &new_group, _("\
2217 Set creation of new group when creating child process."), _("\
2218 Show creation of new group when creating child process."), NULL,
2220 NULL, /* FIXME: i18n: */
2221 &setlist, &showlist);
2223 add_setshow_boolean_cmd ("debugexec", class_support, &debug_exec, _("\
2224 Set whether to display execution in child process."), _("\
2225 Show whether to display execution in child process."), NULL,
2227 NULL, /* FIXME: i18n: */
2228 &setlist, &showlist);
2230 add_setshow_boolean_cmd ("debugevents", class_support, &debug_events, _("\
2231 Set whether to display kernel events in child process."), _("\
2232 Show whether to display kernel events in child process."), NULL,
2234 NULL, /* FIXME: i18n: */
2235 &setlist, &showlist);
2237 add_setshow_boolean_cmd ("debugmemory", class_support, &debug_memory, _("\
2238 Set whether to display memory accesses in child process."), _("\
2239 Show whether to display memory accesses in child process."), NULL,
2241 NULL, /* FIXME: i18n: */
2242 &setlist, &showlist);
2244 add_setshow_boolean_cmd ("debugexceptions", class_support,
2245 &debug_exceptions, _("\
2246 Set whether to display kernel exceptions in child process."), _("\
2247 Show whether to display kernel exceptions in child process."), NULL,
2249 NULL, /* FIXME: i18n: */
2250 &setlist, &showlist);
2252 add_prefix_cmd ("w32", class_info, info_w32_command,
2253 _("Print information specific to Win32 debugging."),
2254 &info_w32_cmdlist, "info w32 ", 0, &infolist);
2256 add_cmd ("selector", class_info, display_selectors,
2257 _("Display selectors infos."),
2259 add_target (&win32_ops);
2260 deprecated_init_ui_hook = set_win32_aliases;
2263 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2265 /* Pass the address ADDR to the inferior in the I'th debug register.
2266 Here we just store the address in dr array, the registers will be
2267 actually set up when win32_continue is called. */
2269 cygwin_set_dr (int i, CORE_ADDR addr)
2272 internal_error (__FILE__, __LINE__,
2273 _("Invalid register %d in cygwin_set_dr.\n"), i);
2274 dr[i] = (unsigned) addr;
2275 debug_registers_changed = 1;
2276 debug_registers_used = 1;
2279 /* Pass the value VAL to the inferior in the DR7 debug control
2280 register. Here we just store the address in D_REGS, the watchpoint
2281 will be actually set up in win32_wait. */
2283 cygwin_set_dr7 (unsigned val)
2286 debug_registers_changed = 1;
2287 debug_registers_used = 1;
2290 /* Get the value of the DR6 debug status register from the inferior.
2291 Here we just return the value stored in dr[6]
2292 by the last call to thread_rec for current_event.dwThreadId id. */
2294 cygwin_get_dr6 (void)
2299 /* Determine if the thread referenced by "ptid" is alive
2300 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2301 it means that the thread has died. Otherwise it is assumed to be alive. */
2303 win32_win32_thread_alive (ptid_t ptid)
2307 gdb_assert (ptid_get_tid (ptid) != 0);
2308 tid = ptid_get_tid (ptid);
2310 return WaitForSingleObject (thread_rec (tid, FALSE)->h, 0) == WAIT_OBJECT_0 ?
2315 _initialize_check_for_gdb_ini (void)
2318 if (inhibit_gdbinit)
2321 homedir = getenv ("HOME");
2325 char *oldini = (char *) alloca (strlen (homedir) +
2326 sizeof ("/gdb.ini"));
2327 strcpy (oldini, homedir);
2328 p = strchr (oldini, '\0');
2329 if (p > oldini && p[-1] != '/')
2331 strcpy (p, "gdb.ini");
2332 if (access (oldini, 0) == 0)
2334 int len = strlen (oldini);
2335 char *newini = alloca (len + 1);
2336 sprintf (newini, "%.*s.gdbinit",
2337 (int) (len - (sizeof ("gdb.ini") - 1)), oldini);
2338 warning (_("obsolete '%s' found. Rename to '%s'."), oldini, newini);
2344 _initialize_psapi (void)
2346 /* Load optional functions used for retrieving filename information
2347 associated with the currently debugged process or its dlls. */
2350 HMODULE psapi_module_handle;
2354 psapi_module_handle = LoadLibrary ("psapi.dll");
2355 if (psapi_module_handle)
2357 psapi_EnumProcessModules = (void *) GetProcAddress (psapi_module_handle, "EnumProcessModules");
2358 psapi_GetModuleInformation = (void *) GetProcAddress (psapi_module_handle, "GetModuleInformation");
2359 psapi_GetModuleFileNameExA = (void *) GetProcAddress (psapi_module_handle, "GetModuleFileNameExA");
2361 if (psapi_EnumProcessModules != NULL
2362 && psapi_GetModuleInformation != NULL
2363 && psapi_GetModuleFileNameExA != NULL)
2368 /* This will probably fail on Windows 9x/Me. Let the user know that we're
2369 missing some functionality. */
2370 if (psapi_loaded < 0)
2371 warning(_("cannot automatically find executable file or library to read symbols. Use \"file\" or \"dll\" command to load executable/libraries directly."));