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 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 "gdb_stdint.h"
52 #include "gdbthread.h"
54 #include <sys/param.h>
59 #include "xml-support.h"
61 #include "i386-tdep.h"
62 #include "i387-tdep.h"
64 #include "i386-cygwin-tdep.h"
66 static struct target_ops win32_ops;
69 /* The starting and ending address of the cygwin1.dll text segment. */
70 static bfd_vma cygwin_load_start;
71 static bfd_vma cygwin_load_end;
74 static int have_saved_context; /* True if we've saved context from a cygwin signal. */
75 static CONTEXT saved_context; /* Containes the saved context from a cygwin signal. */
77 /* If we're not using the old Cygwin header file set, define the
78 following which never should have been in the generic Win32 API
79 headers in the first place since they were our own invention... */
80 #ifndef _GNU_H_WINDOWS_H
83 FLAG_TRACE_BIT = 0x100,
84 CONTEXT_DEBUGGER = (CONTEXT_FULL | CONTEXT_FLOATING_POINT)
89 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \
90 | CONTEXT_EXTENDED_REGISTERS
92 static unsigned dr[8];
93 static int debug_registers_changed;
94 static int debug_registers_used;
95 #define DR6_CLEAR_VALUE 0xffff0ff0
97 /* The string sent by cygwin when it processes a signal.
98 FIXME: This should be in a cygwin include file. */
99 #ifndef _CYGWIN_SIGNAL_STRING
100 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
103 #define CHECK(x) check (x, __FILE__,__LINE__)
104 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
105 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
106 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
107 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
109 static void win32_stop (void);
110 static int win32_win32_thread_alive (ptid_t);
111 static void win32_kill_inferior (void);
113 static enum target_signal last_sig = TARGET_SIGNAL_0;
114 /* Set if a signal was received from the debugged process */
116 /* Thread information structure used to track information that is
117 not available in gdb's thread structure. */
118 typedef struct thread_info_struct
120 struct thread_info_struct *next;
131 static thread_info thread_head;
133 /* The process and thread handles for the above context. */
135 static DEBUG_EVENT current_event; /* The current debug event from
137 static HANDLE current_process_handle; /* Currently executing process */
138 static thread_info *current_thread; /* Info on currently selected thread */
139 static DWORD main_thread_id; /* Thread ID of the main thread */
141 /* Counts of things. */
142 static int exception_count = 0;
143 static int event_count = 0;
144 static int saw_create;
145 static int open_process_used = 0;
148 static int new_console = 0;
150 static int cygwin_exceptions = 0;
152 static int new_group = 1;
153 static int debug_exec = 0; /* show execution */
154 static int debug_events = 0; /* show events from kernel */
155 static int debug_memory = 0; /* show target memory accesses */
156 static int debug_exceptions = 0; /* show target exceptions */
157 static int useshell = 0; /* use shell for subprocesses */
159 /* This vector maps GDB's idea of a register's number into an address
160 in the win32 exception context vector.
162 It also contains the bit mask needed to load the register in question.
164 One day we could read a reg, we could inspect the context we
165 already have loaded, if it doesn't have the bit set that we need,
166 we read that set of registers in using GetThreadContext. If the
167 context already contains what we need, we just unpack it. Then to
168 write a register, first we have to ensure that the context contains
169 the other regs of the group, and then we copy the info in and set
172 #define context_offset(x) ((int)&(((CONTEXT *)NULL)->x))
173 static const int mappings[] =
175 context_offset (Eax),
176 context_offset (Ecx),
177 context_offset (Edx),
178 context_offset (Ebx),
179 context_offset (Esp),
180 context_offset (Ebp),
181 context_offset (Esi),
182 context_offset (Edi),
183 context_offset (Eip),
184 context_offset (EFlags),
185 context_offset (SegCs),
186 context_offset (SegSs),
187 context_offset (SegDs),
188 context_offset (SegEs),
189 context_offset (SegFs),
190 context_offset (SegGs),
191 context_offset (FloatSave.RegisterArea[0 * 10]),
192 context_offset (FloatSave.RegisterArea[1 * 10]),
193 context_offset (FloatSave.RegisterArea[2 * 10]),
194 context_offset (FloatSave.RegisterArea[3 * 10]),
195 context_offset (FloatSave.RegisterArea[4 * 10]),
196 context_offset (FloatSave.RegisterArea[5 * 10]),
197 context_offset (FloatSave.RegisterArea[6 * 10]),
198 context_offset (FloatSave.RegisterArea[7 * 10]),
199 context_offset (FloatSave.ControlWord),
200 context_offset (FloatSave.StatusWord),
201 context_offset (FloatSave.TagWord),
202 context_offset (FloatSave.ErrorSelector),
203 context_offset (FloatSave.ErrorOffset),
204 context_offset (FloatSave.DataSelector),
205 context_offset (FloatSave.DataOffset),
206 context_offset (FloatSave.ErrorSelector)
208 context_offset (ExtendedRegisters[10*16]),
209 context_offset (ExtendedRegisters[11*16]),
210 context_offset (ExtendedRegisters[12*16]),
211 context_offset (ExtendedRegisters[13*16]),
212 context_offset (ExtendedRegisters[14*16]),
213 context_offset (ExtendedRegisters[15*16]),
214 context_offset (ExtendedRegisters[16*16]),
215 context_offset (ExtendedRegisters[17*16]),
217 context_offset (ExtendedRegisters[24])
220 #undef context_offset
222 /* This vector maps the target's idea of an exception (extracted
223 from the DEBUG_EVENT structure) to GDB's idea. */
225 struct xlate_exception
228 enum target_signal us;
231 static const struct xlate_exception
234 {EXCEPTION_ACCESS_VIOLATION, TARGET_SIGNAL_SEGV},
235 {STATUS_STACK_OVERFLOW, TARGET_SIGNAL_SEGV},
236 {EXCEPTION_BREAKPOINT, TARGET_SIGNAL_TRAP},
237 {DBG_CONTROL_C, TARGET_SIGNAL_INT},
238 {EXCEPTION_SINGLE_STEP, TARGET_SIGNAL_TRAP},
239 {STATUS_FLOAT_DIVIDE_BY_ZERO, TARGET_SIGNAL_FPE},
243 check (BOOL ok, const char *file, int line)
246 printf_filtered ("error return %s:%d was %lu\n", file, line,
250 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
251 then also retrieve the context for this thread. If GET_CONTEXT is
252 negative, then don't suspend the thread. */
254 thread_rec (DWORD id, int get_context)
258 for (th = &thread_head; (th = th->next) != NULL;)
261 if (!th->suspended && get_context)
263 if (get_context > 0 && id != current_event.dwThreadId)
265 if (SuspendThread (th->h) == (DWORD) -1)
267 DWORD err = GetLastError ();
268 warning (_("SuspendThread failed. (winerr %d)"),
274 else if (get_context < 0)
276 th->reload_context = 1;
284 /* Add a thread to the thread list */
286 win32_add_thread (DWORD id, HANDLE h)
290 if ((th = thread_rec (id, FALSE)))
293 th = XZALLOC (thread_info);
296 th->next = thread_head.next;
297 thread_head.next = th;
298 add_thread (pid_to_ptid (id));
299 /* Set the debug registers for the new thread in they are used. */
300 if (debug_registers_used)
302 /* Only change the value of the debug registers. */
303 th->context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
304 CHECK (GetThreadContext (th->h, &th->context));
305 th->context.Dr0 = dr[0];
306 th->context.Dr1 = dr[1];
307 th->context.Dr2 = dr[2];
308 th->context.Dr3 = dr[3];
309 th->context.Dr6 = DR6_CLEAR_VALUE;
310 th->context.Dr7 = dr[7];
311 CHECK (SetThreadContext (th->h, &th->context));
312 th->context.ContextFlags = 0;
317 /* Clear out any old thread list and reintialize it to a
320 win32_init_thread_list (void)
322 thread_info *th = &thread_head;
324 DEBUG_EVENTS (("gdb: win32_init_thread_list\n"));
326 while (th->next != NULL)
328 thread_info *here = th->next;
329 th->next = here->next;
332 thread_head.next = NULL;
335 /* Delete a thread from the list of threads */
337 win32_delete_thread (DWORD id)
342 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (pid_to_ptid (id)));
343 delete_thread (pid_to_ptid (id));
345 for (th = &thread_head;
346 th->next != NULL && th->next->id != id;
350 if (th->next != NULL)
352 thread_info *here = th->next;
353 th->next = here->next;
359 do_win32_fetch_inferior_registers (struct regcache *regcache, int r)
361 char *context_offset = ((char *) ¤t_thread->context) + mappings[r];
362 struct gdbarch *gdbarch = get_regcache_arch (regcache);
363 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
367 return; /* Windows sometimes uses a non-existent thread id in its
370 if (current_thread->reload_context)
372 #ifdef __COPY_CONTEXT_SIZE
373 if (have_saved_context)
375 /* Lie about where the program actually is stopped since cygwin has informed us that
376 we should consider the signal to have occurred at another location which is stored
377 in "saved_context. */
378 memcpy (¤t_thread->context, &saved_context, __COPY_CONTEXT_SIZE);
379 have_saved_context = 0;
384 thread_info *th = current_thread;
385 th->context.ContextFlags = CONTEXT_DEBUGGER_DR;
386 GetThreadContext (th->h, &th->context);
387 /* Copy dr values from that thread.
388 But only if there were not modified since last stop. PR gdb/2388 */
389 if (!debug_registers_changed)
391 dr[0] = th->context.Dr0;
392 dr[1] = th->context.Dr1;
393 dr[2] = th->context.Dr2;
394 dr[3] = th->context.Dr3;
395 dr[6] = th->context.Dr6;
396 dr[7] = th->context.Dr7;
399 current_thread->reload_context = 0;
402 if (r == I387_FISEG_REGNUM (tdep))
404 l = *((long *) context_offset) & 0xffff;
405 regcache_raw_supply (regcache, r, (char *) &l);
407 else if (r == I387_FOP_REGNUM (tdep))
409 l = (*((long *) context_offset) >> 16) & ((1 << 11) - 1);
410 regcache_raw_supply (regcache, r, (char *) &l);
413 regcache_raw_supply (regcache, r, context_offset);
416 for (r = 0; r < gdbarch_num_regs (gdbarch); r++)
417 do_win32_fetch_inferior_registers (regcache, r);
422 win32_fetch_inferior_registers (struct regcache *regcache, int r)
424 current_thread = thread_rec (PIDGET (inferior_ptid), TRUE);
425 /* Check if current_thread exists. Windows sometimes uses a non-existent
426 thread id in its events */
428 do_win32_fetch_inferior_registers (regcache, r);
432 do_win32_store_inferior_registers (const struct regcache *regcache, int r)
435 /* Windows sometimes uses a non-existent thread id in its events */;
437 regcache_raw_collect (regcache, r,
438 ((char *) ¤t_thread->context) + mappings[r]);
441 for (r = 0; r < gdbarch_num_regs (get_regcache_arch (regcache)); r++)
442 do_win32_store_inferior_registers (regcache, r);
446 /* Store a new register value into the current thread context */
448 win32_store_inferior_registers (struct regcache *regcache, int r)
450 current_thread = thread_rec (PIDGET (inferior_ptid), TRUE);
451 /* Check if current_thread exists. Windows sometimes uses a non-existent
452 thread id in its events */
454 do_win32_store_inferior_registers (regcache, r);
457 static int psapi_loaded = 0;
458 static BOOL WINAPI (*psapi_EnumProcessModules) (HANDLE, HMODULE *, DWORD,
460 static BOOL WINAPI (*psapi_GetModuleInformation) (HANDLE, HMODULE, LPMODULEINFO,
462 static DWORD WINAPI (*psapi_GetModuleFileNameExA) (HANDLE, HMODULE, LPSTR,
465 /* Get the name of a given module at at given base address. If base_address
466 is zero return the first loaded module (which is always the name of the
469 get_module_name (DWORD base_address, char *dll_name_ret)
475 HMODULE *DllHandle = dh_buf; /* Set to temporary storage for initial query */
478 char pathbuf[PATH_MAX + 1]; /* Temporary storage prior to converting to
481 char *pathbuf = dll_name_ret; /* Just copy directly to passed-in arg */
484 /* If psapi_loaded < 0 either psapi.dll is not available or it does not contain
485 the needed functions. */
486 if (psapi_loaded <= 0)
490 /* Find size of buffer needed to handle list of modules loaded in inferior */
491 if (!psapi_EnumProcessModules (current_process_handle, DllHandle,
492 sizeof (HMODULE), &cbNeeded) || !cbNeeded)
495 /* Allocate correct amount of space for module list */
496 DllHandle = (HMODULE *) alloca (cbNeeded);
500 /* Get the list of modules */
501 if (!psapi_EnumProcessModules (current_process_handle, DllHandle, cbNeeded,
505 for (i = 0; i < (int) (cbNeeded / sizeof (HMODULE)); i++)
507 /* Get information on this module */
508 if (!psapi_GetModuleInformation (current_process_handle, DllHandle[i],
510 error (_("Can't get module info"));
512 if (!base_address || (DWORD) (mi.lpBaseOfDll) == base_address)
514 /* Try to find the name of the given module */
515 len = psapi_GetModuleFileNameExA (current_process_handle,
516 DllHandle[i], pathbuf, MAX_PATH);
518 error (_("Error getting dll name: %u."), (unsigned) GetLastError ());
520 /* Cygwin prefers that the path be in /x/y/z format */
521 cygwin_conv_to_full_posix_path (pathbuf, dll_name_ret);
523 return 1; /* success */
528 dll_name_ret[0] = '\0';
529 return 0; /* failure */
532 /* Encapsulate the information required in a call to
533 symbol_file_add_args */
534 struct safe_symbol_file_add_args
538 struct section_addr_info *addrs;
541 struct ui_file *err, *out;
545 /* Maintain a linked list of "so" information. */
551 static struct so_list solib_start, *solib_end;
553 /* Call symbol_file_add with stderr redirected. We don't care if there
556 safe_symbol_file_add_stub (void *argv)
558 #define p ((struct safe_symbol_file_add_args *) argv)
559 struct so_list *so = &solib_start;
561 p->ret = symbol_file_add (p->name, p->from_tty, p->addrs, p->mainline, p->flags);
566 /* Restore gdb's stderr after calling symbol_file_add */
568 safe_symbol_file_add_cleanup (void *p)
570 #define sp ((struct safe_symbol_file_add_args *)p)
571 gdb_flush (gdb_stderr);
572 gdb_flush (gdb_stdout);
573 ui_file_delete (gdb_stderr);
574 ui_file_delete (gdb_stdout);
575 gdb_stderr = sp->err;
576 gdb_stdout = sp->out;
580 /* symbol_file_add wrapper that prevents errors from being displayed. */
581 static struct objfile *
582 safe_symbol_file_add (char *name, int from_tty,
583 struct section_addr_info *addrs,
584 int mainline, int flags)
586 struct safe_symbol_file_add_args p;
587 struct cleanup *cleanup;
589 cleanup = make_cleanup (safe_symbol_file_add_cleanup, &p);
593 gdb_flush (gdb_stderr);
594 gdb_flush (gdb_stdout);
595 gdb_stderr = ui_file_new ();
596 gdb_stdout = ui_file_new ();
598 p.from_tty = from_tty;
600 p.mainline = mainline;
602 catch_errors (safe_symbol_file_add_stub, &p, "", RETURN_MASK_ERROR);
604 do_cleanups (cleanup);
608 static struct so_list *
609 win32_make_so (const char *name, DWORD load_addr)
612 char buf[MAX_PATH + 1];
613 char cwd[MAX_PATH + 1];
615 WIN32_FIND_DATA w32_fd;
616 HANDLE h = FindFirstFile(name, &w32_fd);
617 MEMORY_BASIC_INFORMATION m;
619 if (h == INVALID_HANDLE_VALUE)
625 if (GetCurrentDirectory (MAX_PATH + 1, cwd))
627 p = strrchr (buf, '\\');
630 SetCurrentDirectory (buf);
631 GetFullPathName (w32_fd.cFileName, MAX_PATH, buf, &p);
632 SetCurrentDirectory (cwd);
636 if (strcasecmp (buf, "ntdll.dll") == 0)
638 GetSystemDirectory (buf, sizeof (buf));
639 strcat (buf, "\\ntdll.dll");
641 so = XZALLOC (struct so_list);
642 so->lm_info = (struct lm_info *) xmalloc (sizeof (struct lm_info));
643 so->lm_info->load_addr = load_addr;
644 strcpy (so->so_original_name, name);
646 strcpy (so->so_name, buf);
648 cygwin_conv_to_posix_path (buf, so->so_name);
649 /* Record cygwin1.dll .text start/end. */
650 p = strchr (so->so_name, '\0') - (sizeof ("/cygwin1.dll") - 1);
651 if (p >= so->so_name && strcasecmp (p, "/cygwin1.dll") == 0)
654 asection *text = NULL;
657 abfd = bfd_openr (so->so_name, "pei-i386");
662 if (bfd_check_format (abfd, bfd_object))
663 text = bfd_get_section_by_name (abfd, ".text");
671 /* The symbols in a dll are offset by 0x1000, which is the the
672 offset from 0 of the first byte in an image - because of the
673 file header and the section alignment. */
674 cygwin_load_start = load_addr + 0x1000;
675 cygwin_load_end = cygwin_load_start + bfd_section_size (abfd, text);
685 get_image_name (HANDLE h, void *address, int unicode)
687 static char buf[(2 * MAX_PATH) + 1];
688 DWORD size = unicode ? sizeof (WCHAR) : sizeof (char);
694 /* Attempt to read the name of the dll that was detected.
695 This is documented to work only when actively debugging
696 a program. It will not work for attached processes. */
700 /* See if we could read the address of a string, and that the
701 address isn't null. */
702 if (!ReadProcessMemory (h, address, &address_ptr, sizeof (address_ptr), &done)
703 || done != sizeof (address_ptr) || !address_ptr)
706 /* Find the length of the string */
707 while (ReadProcessMemory (h, address_ptr + len++ * size, &b, size, &done)
708 && (b[0] != 0 || b[size - 1] != 0) && done == size)
712 ReadProcessMemory (h, address_ptr, buf, len, &done);
715 WCHAR *unicode_address = (WCHAR *) alloca (len * sizeof (WCHAR));
716 ReadProcessMemory (h, address_ptr, unicode_address, len * sizeof (WCHAR),
719 WideCharToMultiByte (CP_ACP, 0, unicode_address, len, buf, len, 0, 0);
725 /* Wait for child to do something. Return pid of child, or -1 in case
726 of error; store status through argument pointer OURSTATUS. */
728 handle_load_dll (void *dummy)
730 LOAD_DLL_DEBUG_INFO *event = ¤t_event.u.LoadDll;
731 char dll_buf[MAX_PATH + 1];
732 char *dll_name = NULL;
734 dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0';
736 if (!get_module_name ((DWORD) event->lpBaseOfDll, dll_buf))
737 dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0';
741 if (*dll_name == '\0')
742 dll_name = get_image_name (current_process_handle,
743 event->lpImageName, event->fUnicode);
747 solib_end->next = win32_make_so (dll_name, (DWORD) event->lpBaseOfDll);
748 solib_end = solib_end->next;
750 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at 0x%lx.\n", solib_end->so_name,
751 (DWORD) solib_end->lm_info->load_addr));
757 win32_free_so (struct so_list *so)
765 handle_unload_dll (void *dummy)
767 DWORD lpBaseOfDll = (DWORD) current_event.u.UnloadDll.lpBaseOfDll;
770 for (so = &solib_start; so->next != NULL; so = so->next)
771 if (so->next->lm_info->load_addr == lpBaseOfDll)
773 struct so_list *sodel = so->next;
774 so->next = sodel->next;
777 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel->so_name));
779 win32_free_so (sodel);
780 solib_add (NULL, 0, NULL, auto_solib_add);
784 error (_("Error: dll starting at 0x%lx not found."), (DWORD) lpBaseOfDll);
789 /* Clear list of loaded DLLs. */
791 win32_clear_solib (void)
793 solib_start.next = NULL;
794 solib_end = &solib_start;
797 /* Load DLL symbol info. */
799 dll_symbol_command (char *args, int from_tty)
805 error (_("dll-symbols requires a file name"));
808 if (n > 4 && strcasecmp (args + n - 4, ".dll") != 0)
810 char *newargs = (char *) alloca (n + 4 + 1);
811 strcpy (newargs, args);
812 strcat (newargs, ".dll");
816 safe_symbol_file_add (args, from_tty, NULL, 0, OBJF_SHARED | OBJF_USERLOADED);
819 /* Handle DEBUG_STRING output from child process.
820 Cygwin prepends its messages with a "cygwin:". Interpret this as
821 a Cygwin signal. Otherwise just print the string as a warning. */
823 handle_output_debug_string (struct target_waitstatus *ourstatus)
828 if (!target_read_string
829 ((CORE_ADDR) (uintptr_t) current_event.u.DebugString.lpDebugStringData,
833 else if (strncmp (s, _CYGWIN_SIGNAL_STRING, sizeof (_CYGWIN_SIGNAL_STRING) - 1) != 0)
836 if (strncmp (s, "cYg", 3) != 0)
840 #ifdef __COPY_CONTEXT_SIZE
843 /* Got a cygwin signal marker. A cygwin signal is followed by the signal number
844 itself and then optionally followed by the thread id and address to saved context
845 within the DLL. If these are supplied, then the given thread is assumed to have
846 issued the signal and the context from the thread is assumed to be stored at the
847 given address in the inferior. Tell gdb to treat this like a real signal. */
849 int sig = strtol (s + sizeof (_CYGWIN_SIGNAL_STRING) - 1, &p, 0);
850 int gotasig = target_signal_from_host (sig);
851 ourstatus->value.sig = gotasig;
856 ourstatus->kind = TARGET_WAITKIND_STOPPED;
857 retval = strtoul (p, &p, 0);
859 retval = main_thread_id;
860 else if ((x = (LPCVOID) strtoul (p, &p, 0))
861 && ReadProcessMemory (current_process_handle, x,
862 &saved_context, __COPY_CONTEXT_SIZE, &n)
863 && n == __COPY_CONTEXT_SIZE)
864 have_saved_context = 1;
865 current_event.dwThreadId = retval;
876 display_selector (HANDLE thread, DWORD sel)
879 if (GetThreadSelectorEntry (thread, sel, &info))
882 printf_filtered ("0x%03lx: ", sel);
883 if (!info.HighWord.Bits.Pres)
885 puts_filtered ("Segment not present\n");
888 base = (info.HighWord.Bits.BaseHi << 24) +
889 (info.HighWord.Bits.BaseMid << 16)
891 limit = (info.HighWord.Bits.LimitHi << 16) + info.LimitLow;
892 if (info.HighWord.Bits.Granularity)
893 limit = (limit << 12) | 0xfff;
894 printf_filtered ("base=0x%08x limit=0x%08x", base, limit);
895 if (info.HighWord.Bits.Default_Big)
896 puts_filtered(" 32-bit ");
898 puts_filtered(" 16-bit ");
899 switch ((info.HighWord.Bits.Type & 0xf) >> 1)
902 puts_filtered ("Data (Read-Only, Exp-up");
905 puts_filtered ("Data (Read/Write, Exp-up");
908 puts_filtered ("Unused segment (");
911 puts_filtered ("Data (Read/Write, Exp-down");
914 puts_filtered ("Code (Exec-Only, N.Conf");
917 puts_filtered ("Code (Exec/Read, N.Conf");
920 puts_filtered ("Code (Exec-Only, Conf");
923 puts_filtered ("Code (Exec/Read, Conf");
926 printf_filtered ("Unknown type 0x%x",info.HighWord.Bits.Type);
928 if ((info.HighWord.Bits.Type & 0x1) == 0)
929 puts_filtered(", N.Acc");
930 puts_filtered (")\n");
931 if ((info.HighWord.Bits.Type & 0x10) == 0)
932 puts_filtered("System selector ");
933 printf_filtered ("Priviledge level = %d. ", info.HighWord.Bits.Dpl);
934 if (info.HighWord.Bits.Granularity)
935 puts_filtered ("Page granular.\n");
937 puts_filtered ("Byte granular.\n");
942 printf_filtered ("Invalid selector 0x%lx.\n",sel);
948 display_selectors (char * args, int from_tty)
952 puts_filtered ("Impossible to display selectors now.\n");
958 puts_filtered ("Selector $cs\n");
959 display_selector (current_thread->h,
960 current_thread->context.SegCs);
961 puts_filtered ("Selector $ds\n");
962 display_selector (current_thread->h,
963 current_thread->context.SegDs);
964 puts_filtered ("Selector $es\n");
965 display_selector (current_thread->h,
966 current_thread->context.SegEs);
967 puts_filtered ("Selector $ss\n");
968 display_selector (current_thread->h,
969 current_thread->context.SegSs);
970 puts_filtered ("Selector $fs\n");
971 display_selector (current_thread->h,
972 current_thread->context.SegFs);
973 puts_filtered ("Selector $gs\n");
974 display_selector (current_thread->h,
975 current_thread->context.SegGs);
980 sel = parse_and_eval_long (args);
981 printf_filtered ("Selector \"%s\"\n",args);
982 display_selector (current_thread->h, sel);
986 static struct cmd_list_element *info_w32_cmdlist = NULL;
989 info_w32_command (char *args, int from_tty)
991 help_list (info_w32_cmdlist, "info w32 ", class_info, gdb_stdout);
995 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
996 printf_unfiltered ("gdb: Target exception %s at 0x%08lx\n", x, \
997 (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress)
1000 handle_exception (struct target_waitstatus *ourstatus)
1003 DWORD code = current_event.u.Exception.ExceptionRecord.ExceptionCode;
1005 ourstatus->kind = TARGET_WAITKIND_STOPPED;
1007 /* Record the context of the current thread */
1008 th = thread_rec (current_event.dwThreadId, -1);
1012 case EXCEPTION_ACCESS_VIOLATION:
1013 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1014 ourstatus->value.sig = TARGET_SIGNAL_SEGV;
1017 /* See if the access violation happened within the cygwin DLL itself. Cygwin uses
1018 a kind of exception handling to deal with passed-in invalid addresses. gdb
1019 should not treat these as real SEGVs since they will be silently handled by
1020 cygwin. A real SEGV will (theoretically) be caught by cygwin later in the process
1021 and will be sent as a cygwin-specific-signal. So, ignore SEGVs if they show up
1022 within the text segment of the DLL itself. */
1024 bfd_vma addr = (bfd_vma) (uintptr_t) current_event.u.Exception.
1025 ExceptionRecord.ExceptionAddress;
1026 if ((!cygwin_exceptions && (addr >= cygwin_load_start && addr < cygwin_load_end))
1027 || (find_pc_partial_function (addr, &fn, NULL, NULL)
1028 && strncmp (fn, "KERNEL32!IsBad", strlen ("KERNEL32!IsBad")) == 0))
1033 case STATUS_STACK_OVERFLOW:
1034 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1035 ourstatus->value.sig = TARGET_SIGNAL_SEGV;
1037 case STATUS_FLOAT_DENORMAL_OPERAND:
1038 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1039 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1041 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
1042 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1043 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1045 case STATUS_FLOAT_INEXACT_RESULT:
1046 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1047 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1049 case STATUS_FLOAT_INVALID_OPERATION:
1050 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1051 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1053 case STATUS_FLOAT_OVERFLOW:
1054 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1055 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1057 case STATUS_FLOAT_STACK_CHECK:
1058 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1059 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1061 case STATUS_FLOAT_UNDERFLOW:
1062 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1063 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1065 case STATUS_FLOAT_DIVIDE_BY_ZERO:
1066 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1067 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1069 case STATUS_INTEGER_DIVIDE_BY_ZERO:
1070 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1071 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1073 case STATUS_INTEGER_OVERFLOW:
1074 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1075 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1077 case EXCEPTION_BREAKPOINT:
1078 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1079 ourstatus->value.sig = TARGET_SIGNAL_TRAP;
1082 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1083 ourstatus->value.sig = TARGET_SIGNAL_INT;
1085 case DBG_CONTROL_BREAK:
1086 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1087 ourstatus->value.sig = TARGET_SIGNAL_INT;
1089 case EXCEPTION_SINGLE_STEP:
1090 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1091 ourstatus->value.sig = TARGET_SIGNAL_TRAP;
1093 case EXCEPTION_ILLEGAL_INSTRUCTION:
1094 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1095 ourstatus->value.sig = TARGET_SIGNAL_ILL;
1097 case EXCEPTION_PRIV_INSTRUCTION:
1098 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1099 ourstatus->value.sig = TARGET_SIGNAL_ILL;
1101 case EXCEPTION_NONCONTINUABLE_EXCEPTION:
1102 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1103 ourstatus->value.sig = TARGET_SIGNAL_ILL;
1106 /* Treat unhandled first chance exceptions specially. */
1107 if (current_event.u.Exception.dwFirstChance)
1109 printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",
1110 current_event.u.Exception.ExceptionRecord.ExceptionCode,
1111 (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress);
1112 ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
1116 last_sig = ourstatus->value.sig;
1120 /* Resume all artificially suspended threads if we are continuing
1123 win32_continue (DWORD continue_status, int id)
1129 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, %s);\n",
1130 current_event.dwProcessId, current_event.dwThreadId,
1131 continue_status == DBG_CONTINUE ?
1132 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1134 for (th = &thread_head; (th = th->next) != NULL;)
1135 if ((id == -1 || id == (int) th->id)
1138 if (debug_registers_changed)
1140 th->context.ContextFlags |= CONTEXT_DEBUG_REGISTERS;
1141 th->context.Dr0 = dr[0];
1142 th->context.Dr1 = dr[1];
1143 th->context.Dr2 = dr[2];
1144 th->context.Dr3 = dr[3];
1145 th->context.Dr6 = DR6_CLEAR_VALUE;
1146 th->context.Dr7 = dr[7];
1148 if (th->context.ContextFlags)
1150 CHECK (SetThreadContext (th->h, &th->context));
1151 th->context.ContextFlags = 0;
1153 if (th->suspended > 0)
1154 (void) ResumeThread (th->h);
1158 res = ContinueDebugEvent (current_event.dwProcessId,
1159 current_event.dwThreadId,
1162 debug_registers_changed = 0;
1166 /* Called in pathological case where Windows fails to send a
1167 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1169 fake_create_process (void)
1171 current_process_handle = OpenProcess (PROCESS_ALL_ACCESS, FALSE,
1172 current_event.dwProcessId);
1173 if (current_process_handle != NULL)
1174 open_process_used = 1;
1177 error (_("OpenProcess call failed, GetLastError = %lud\n"),
1179 /* We can not debug anything in that case. */
1181 main_thread_id = current_event.dwThreadId;
1182 current_thread = win32_add_thread (main_thread_id,
1183 current_event.u.CreateThread.hThread);
1184 return main_thread_id;
1188 win32_resume (ptid_t ptid, int step, enum target_signal sig)
1191 DWORD continue_status = DBG_CONTINUE;
1193 int pid = PIDGET (ptid);
1195 if (sig != TARGET_SIGNAL_0)
1197 if (current_event.dwDebugEventCode != EXCEPTION_DEBUG_EVENT)
1199 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig));
1201 else if (sig == last_sig)
1202 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1205 /* This code does not seem to work, because
1206 the kernel does probably not consider changes in the ExceptionRecord
1207 structure when passing the exception to the inferior.
1208 Note that this seems possible in the exception handler itself. */
1211 for (i = 0; xlate[i].them != -1; i++)
1212 if (xlate[i].us == sig)
1214 current_event.u.Exception.ExceptionRecord.ExceptionCode =
1216 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1219 if (continue_status == DBG_CONTINUE)
1221 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig));
1225 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1229 last_sig = TARGET_SIGNAL_0;
1231 DEBUG_EXEC (("gdb: win32_resume (pid=%d, step=%d, sig=%d);\n",
1234 /* Get context for currently selected thread */
1235 th = thread_rec (PIDGET (inferior_ptid), FALSE);
1240 /* Single step by setting t bit */
1241 win32_fetch_inferior_registers (get_current_regcache (),
1242 gdbarch_ps_regnum (current_gdbarch));
1243 th->context.EFlags |= FLAG_TRACE_BIT;
1246 if (th->context.ContextFlags)
1248 if (debug_registers_changed)
1250 th->context.Dr0 = dr[0];
1251 th->context.Dr1 = dr[1];
1252 th->context.Dr2 = dr[2];
1253 th->context.Dr3 = dr[3];
1254 th->context.Dr6 = DR6_CLEAR_VALUE;
1255 th->context.Dr7 = dr[7];
1257 CHECK (SetThreadContext (th->h, &th->context));
1258 th->context.ContextFlags = 0;
1262 /* Allow continuing with the same signal that interrupted us.
1263 Otherwise complain. */
1265 win32_continue (continue_status, pid);
1268 /* Get the next event from the child. Return 1 if the event requires
1269 handling by WFI (or whatever).
1272 get_win32_debug_event (int pid, struct target_waitstatus *ourstatus)
1275 DWORD continue_status, event_code;
1277 static thread_info dummy_thread_info;
1281 last_sig = TARGET_SIGNAL_0;
1283 if (!(debug_event = WaitForDebugEvent (¤t_event, 1000)))
1287 continue_status = DBG_CONTINUE;
1289 event_code = current_event.dwDebugEventCode;
1290 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
1292 have_saved_context = 0;
1296 case CREATE_THREAD_DEBUG_EVENT:
1297 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1298 (unsigned) current_event.dwProcessId,
1299 (unsigned) current_event.dwThreadId,
1300 "CREATE_THREAD_DEBUG_EVENT"));
1301 if (saw_create != 1)
1303 if (!saw_create && attach_flag)
1305 /* Kludge around a Windows bug where first event is a create
1306 thread event. Caused when attached process does not have
1308 retval = ourstatus->value.related_pid = fake_create_process ();
1314 /* Record the existence of this thread */
1315 th = win32_add_thread (current_event.dwThreadId,
1316 current_event.u.CreateThread.hThread);
1317 retval = current_event.dwThreadId;
1320 case EXIT_THREAD_DEBUG_EVENT:
1321 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1322 (unsigned) current_event.dwProcessId,
1323 (unsigned) current_event.dwThreadId,
1324 "EXIT_THREAD_DEBUG_EVENT"));
1325 if (current_event.dwThreadId != main_thread_id)
1327 win32_delete_thread (current_event.dwThreadId);
1328 th = &dummy_thread_info;
1332 case CREATE_PROCESS_DEBUG_EVENT:
1333 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1334 (unsigned) current_event.dwProcessId,
1335 (unsigned) current_event.dwThreadId,
1336 "CREATE_PROCESS_DEBUG_EVENT"));
1337 CloseHandle (current_event.u.CreateProcessInfo.hFile);
1338 if (++saw_create != 1)
1341 current_process_handle = current_event.u.CreateProcessInfo.hProcess;
1343 win32_delete_thread (main_thread_id);
1344 main_thread_id = current_event.dwThreadId;
1345 /* Add the main thread */
1346 th = win32_add_thread (main_thread_id,
1347 current_event.u.CreateProcessInfo.hThread);
1348 retval = ourstatus->value.related_pid = current_event.dwThreadId;
1351 case EXIT_PROCESS_DEBUG_EVENT:
1352 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1353 (unsigned) current_event.dwProcessId,
1354 (unsigned) current_event.dwThreadId,
1355 "EXIT_PROCESS_DEBUG_EVENT"));
1356 if (saw_create != 1)
1358 ourstatus->kind = TARGET_WAITKIND_EXITED;
1359 ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode;
1360 retval = main_thread_id;
1363 case LOAD_DLL_DEBUG_EVENT:
1364 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1365 (unsigned) current_event.dwProcessId,
1366 (unsigned) current_event.dwThreadId,
1367 "LOAD_DLL_DEBUG_EVENT"));
1368 CloseHandle (current_event.u.LoadDll.hFile);
1369 if (saw_create != 1)
1371 catch_errors (handle_load_dll, NULL, (char *) "", RETURN_MASK_ALL);
1372 ourstatus->kind = TARGET_WAITKIND_LOADED;
1373 ourstatus->value.integer = 0;
1374 retval = main_thread_id;
1377 case UNLOAD_DLL_DEBUG_EVENT:
1378 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1379 (unsigned) current_event.dwProcessId,
1380 (unsigned) current_event.dwThreadId,
1381 "UNLOAD_DLL_DEBUG_EVENT"));
1382 if (saw_create != 1)
1384 catch_errors (handle_unload_dll, NULL, (char *) "", RETURN_MASK_ALL);
1385 ourstatus->kind = TARGET_WAITKIND_LOADED;
1386 ourstatus->value.integer = 0;
1387 retval = main_thread_id;
1390 case EXCEPTION_DEBUG_EVENT:
1391 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1392 (unsigned) current_event.dwProcessId,
1393 (unsigned) current_event.dwThreadId,
1394 "EXCEPTION_DEBUG_EVENT"));
1395 if (saw_create != 1)
1397 switch (handle_exception (ourstatus))
1400 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1403 retval = current_event.dwThreadId;
1407 continue_status = -1;
1412 case OUTPUT_DEBUG_STRING_EVENT: /* message from the kernel */
1413 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1414 (unsigned) current_event.dwProcessId,
1415 (unsigned) current_event.dwThreadId,
1416 "OUTPUT_DEBUG_STRING_EVENT"));
1417 if (saw_create != 1)
1419 retval = handle_output_debug_string (ourstatus);
1423 if (saw_create != 1)
1425 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1426 (DWORD) current_event.dwProcessId,
1427 (DWORD) current_event.dwThreadId);
1428 printf_unfiltered (" unknown event code %ld\n",
1429 current_event.dwDebugEventCode);
1433 if (!retval || saw_create != 1)
1435 if (continue_status == -1)
1436 win32_resume (ptid, 0, 1);
1438 CHECK (win32_continue (continue_status, -1));
1442 inferior_ptid = pid_to_ptid (retval);
1443 current_thread = th ?: thread_rec (current_event.dwThreadId, TRUE);
1450 /* Wait for interesting events to occur in the target process. */
1452 win32_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
1454 int pid = PIDGET (ptid);
1456 target_terminal_ours ();
1458 /* We loop when we get a non-standard exception rather than return
1459 with a SPURIOUS because resume can try and step or modify things,
1460 which needs a current_thread->h. But some of these exceptions mark
1461 the birth or death of threads, which mean that the current thread
1462 isn't necessarily what you think it is. */
1468 /* Ignore CTRL+C signals while waiting for a debug event.
1469 FIXME: brobecker/2008-05-20: When the user presses CTRL+C while
1470 the inferior is running, both the inferior and GDB receive the
1471 associated signal. If the inferior receives the signal first
1472 and the delay until GDB receives that signal is sufficiently long,
1473 GDB can sometimes receive the SIGINT after we have unblocked
1474 the CTRL+C handler. This would lead to the debugger to stop
1475 prematurely while handling the new-thread event that comes
1476 with the handling of the SIGINT inside the inferior, and then
1477 stop again immediately when the user tries to resume the execution
1478 in the inferior. This is a classic race, and it would be nice
1479 to find a better solution to that problem. But in the meantime,
1480 the current approach already greatly mitigate this issue. */
1481 SetConsoleCtrlHandler (NULL, TRUE);
1482 retval = get_win32_debug_event (pid, ourstatus);
1483 SetConsoleCtrlHandler (NULL, FALSE);
1486 return pid_to_ptid (retval);
1491 if (deprecated_ui_loop_hook != NULL)
1492 detach = deprecated_ui_loop_hook (0);
1495 win32_kill_inferior ();
1501 do_initial_win32_stuff (DWORD pid)
1503 extern int stop_after_trap;
1506 last_sig = TARGET_SIGNAL_0;
1508 exception_count = 0;
1509 open_process_used = 0;
1510 debug_registers_changed = 0;
1511 debug_registers_used = 0;
1512 for (i = 0; i < sizeof (dr) / sizeof (dr[0]); i++)
1515 cygwin_load_start = cygwin_load_end = 0;
1517 current_event.dwProcessId = pid;
1518 memset (¤t_event, 0, sizeof (current_event));
1519 push_target (&win32_ops);
1520 disable_breakpoints_in_shlibs ();
1521 win32_clear_solib ();
1522 clear_proceed_status ();
1523 init_wait_for_inferior ();
1525 terminal_init_inferior_with_pgrp (pid);
1526 target_terminal_inferior ();
1530 stop_after_trap = 1;
1531 wait_for_inferior (0);
1532 if (stop_signal != TARGET_SIGNAL_TRAP)
1533 resume (0, stop_signal);
1537 stop_after_trap = 0;
1541 /* Since Windows XP, detaching from a process is supported by Windows.
1542 The following code tries loading the appropriate functions dynamically.
1543 If loading these functions succeeds use them to actually detach from
1544 the inferior process, otherwise behave as usual, pretending that
1545 detach has worked. */
1546 static BOOL WINAPI (*DebugSetProcessKillOnExit)(BOOL);
1547 static BOOL WINAPI (*DebugActiveProcessStop)(DWORD);
1550 has_detach_ability (void)
1552 static HMODULE kernel32 = NULL;
1555 kernel32 = LoadLibrary ("kernel32.dll");
1558 if (!DebugSetProcessKillOnExit)
1559 DebugSetProcessKillOnExit = GetProcAddress (kernel32,
1560 "DebugSetProcessKillOnExit");
1561 if (!DebugActiveProcessStop)
1562 DebugActiveProcessStop = GetProcAddress (kernel32,
1563 "DebugActiveProcessStop");
1564 if (DebugSetProcessKillOnExit && DebugActiveProcessStop)
1570 /* Try to set or remove a user privilege to the current process. Return -1
1571 if that fails, the previous setting of that privilege otherwise.
1573 This code is copied from the Cygwin source code and rearranged to allow
1574 dynamically loading of the needed symbols from advapi32 which is only
1575 available on NT/2K/XP. */
1577 set_process_privilege (const char *privilege, BOOL enable)
1579 static HMODULE advapi32 = NULL;
1580 static BOOL WINAPI (*OpenProcessToken)(HANDLE, DWORD, PHANDLE);
1581 static BOOL WINAPI (*LookupPrivilegeValue)(LPCSTR, LPCSTR, PLUID);
1582 static BOOL WINAPI (*AdjustTokenPrivileges)(HANDLE, BOOL, PTOKEN_PRIVILEGES,
1583 DWORD, PTOKEN_PRIVILEGES, PDWORD);
1585 HANDLE token_hdl = NULL;
1587 TOKEN_PRIVILEGES new_priv, orig_priv;
1591 if (GetVersion () >= 0x80000000) /* No security availbale on 9x/Me */
1596 if (!(advapi32 = LoadLibrary ("advapi32.dll")))
1598 if (!OpenProcessToken)
1599 OpenProcessToken = GetProcAddress (advapi32, "OpenProcessToken");
1600 if (!LookupPrivilegeValue)
1601 LookupPrivilegeValue = GetProcAddress (advapi32,
1602 "LookupPrivilegeValueA");
1603 if (!AdjustTokenPrivileges)
1604 AdjustTokenPrivileges = GetProcAddress (advapi32,
1605 "AdjustTokenPrivileges");
1606 if (!OpenProcessToken || !LookupPrivilegeValue || !AdjustTokenPrivileges)
1613 if (!OpenProcessToken (GetCurrentProcess (),
1614 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
1618 if (!LookupPrivilegeValue (NULL, privilege, &restore_priv))
1621 new_priv.PrivilegeCount = 1;
1622 new_priv.Privileges[0].Luid = restore_priv;
1623 new_priv.Privileges[0].Attributes = enable ? SE_PRIVILEGE_ENABLED : 0;
1625 if (!AdjustTokenPrivileges (token_hdl, FALSE, &new_priv,
1626 sizeof orig_priv, &orig_priv, &size))
1629 /* Disabled, otherwise every `attach' in an unprivileged user session
1630 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1632 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1633 be enabled. GetLastError () returns an correct error code, though. */
1634 if (enable && GetLastError () == ERROR_NOT_ALL_ASSIGNED)
1638 ret = orig_priv.Privileges[0].Attributes == SE_PRIVILEGE_ENABLED ? 1 : 0;
1642 CloseHandle (token_hdl);
1647 /* Attach to process PID, then initialize for debugging it. */
1649 win32_attach (char *args, int from_tty)
1655 error_no_arg (_("process-id to attach"));
1657 if (set_process_privilege (SE_DEBUG_NAME, TRUE) < 0)
1659 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1660 printf_unfiltered ("This can cause attach to fail on Windows NT/2K/XP\n");
1663 pid = strtoul (args, 0, 0); /* Windows pid */
1665 win32_init_thread_list ();
1666 ok = DebugActiveProcess (pid);
1672 /* Try fall back to Cygwin pid */
1673 pid = cygwin_internal (CW_CYGWIN_PID_TO_WINPID, pid);
1676 ok = DebugActiveProcess (pid);
1681 error (_("Can't attach to process."));
1683 if (has_detach_ability ())
1684 DebugSetProcessKillOnExit (FALSE);
1690 char *exec_file = (char *) get_exec_file (0);
1693 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
1694 target_pid_to_str (pid_to_ptid (pid)));
1696 printf_unfiltered ("Attaching to %s\n",
1697 target_pid_to_str (pid_to_ptid (pid)));
1699 gdb_flush (gdb_stdout);
1702 do_initial_win32_stuff (pid);
1703 target_terminal_ours ();
1707 win32_detach (char *args, int from_tty)
1711 if (has_detach_ability ())
1714 win32_resume (ptid, 0, TARGET_SIGNAL_0);
1716 if (!DebugActiveProcessStop (current_event.dwProcessId))
1718 error (_("Can't detach process %lu (error %lu)"),
1719 current_event.dwProcessId, GetLastError ());
1722 DebugSetProcessKillOnExit (FALSE);
1724 if (detached && from_tty)
1726 char *exec_file = get_exec_file (0);
1729 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file,
1730 current_event.dwProcessId);
1731 gdb_flush (gdb_stdout);
1733 inferior_ptid = null_ptid;
1734 unpush_target (&win32_ops);
1738 win32_pid_to_exec_file (int pid)
1740 static char path[MAX_PATH + 1];
1743 /* Try to find exe name as symlink target of /proc/<pid>/exe */
1745 char procexe[sizeof ("/proc/4294967295/exe")];
1746 sprintf (procexe, "/proc/%lu/exe", current_event.dwProcessId);
1747 nchars = readlink (procexe, path, sizeof(path));
1748 if (nchars > 0 && nchars < sizeof (path))
1750 path[nchars] = '\0'; /* Got it */
1755 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
1756 of gdb, or we're trying to debug a non-Cygwin windows executable. */
1757 if (!get_module_name (0, path))
1763 /* Print status information about what we're accessing. */
1766 win32_files_info (struct target_ops *ignore)
1768 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1769 attach_flag ? "attached" : "child", target_pid_to_str (inferior_ptid));
1773 win32_open (char *arg, int from_tty)
1775 error (_("Use the \"run\" command to start a Unix child process."));
1778 /* Start an inferior win32 child process and sets inferior_ptid to its pid.
1779 EXEC_FILE is the file to run.
1780 ALLARGS is a string containing the arguments to the program.
1781 ENV is the environment vector to pass. Errors reported with error(). */
1784 win32_create_inferior (char *exec_file, char *allargs, char **in_env,
1788 PROCESS_INFORMATION pi;
1792 char real_path[MAXPATHLEN];
1794 char shell[MAX_PATH + 1]; /* Path to shell */
1797 int ostdin, ostdout, ostderr;
1798 const char *inferior_io_terminal = get_inferior_io_terminal ();
1801 error (_("No executable specified, use `target exec'."));
1803 memset (&si, 0, sizeof (si));
1804 si.cb = sizeof (si);
1809 flags = DEBUG_ONLY_THIS_PROCESS;
1810 cygwin_conv_to_win32_path (exec_file, real_path);
1816 sh = getenv ("SHELL");
1819 cygwin_conv_to_win32_path (sh, shell);
1820 newallargs = alloca (sizeof (" -c 'exec '") + strlen (exec_file)
1821 + strlen (allargs) + 2);
1822 sprintf (newallargs, " -c 'exec %s %s'", exec_file, allargs);
1823 allargs = newallargs;
1825 flags = DEBUG_PROCESS;
1829 flags = DEBUG_ONLY_THIS_PROCESS;
1833 flags |= CREATE_NEW_PROCESS_GROUP;
1836 flags |= CREATE_NEW_CONSOLE;
1840 args = alloca (strlen (toexec) + strlen (allargs) + 2);
1841 strcpy (args, toexec);
1843 strcat (args, allargs);
1846 /* Prepare the environment vars for CreateProcess. */
1847 cygwin_internal (CW_SYNC_WINENV);
1849 if (!inferior_io_terminal)
1850 tty = ostdin = ostdout = ostderr = -1;
1853 tty = open (inferior_io_terminal, O_RDWR | O_NOCTTY);
1856 print_sys_errmsg (inferior_io_terminal, errno);
1857 ostdin = ostdout = ostderr = -1;
1871 win32_init_thread_list ();
1872 ret = CreateProcess (0,
1873 args, /* command line */
1874 NULL, /* Security */
1876 TRUE, /* inherit handles */
1877 flags, /* start flags */
1878 NULL, /* environment */
1879 NULL, /* current directory */
1897 error (_("Error creating process %s, (error %d)."),
1898 exec_file, (unsigned) GetLastError ());
1900 CloseHandle (pi.hThread);
1901 CloseHandle (pi.hProcess);
1903 if (useshell && shell[0] != '\0')
1908 do_initial_win32_stuff (pi.dwProcessId);
1910 /* win32_continue (DBG_CONTINUE, -1); */
1914 win32_mourn_inferior (void)
1916 (void) win32_continue (DBG_CONTINUE, -1);
1917 i386_cleanup_dregs();
1918 if (open_process_used)
1920 CHECK (CloseHandle (current_process_handle));
1921 open_process_used = 0;
1923 unpush_target (&win32_ops);
1924 generic_mourn_inferior ();
1927 /* Send a SIGINT to the process group. This acts just like the user typed a
1928 ^C on the controlling terminal. */
1933 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1934 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId));
1935 registers_changed (); /* refresh register state */
1939 win32_xfer_memory (CORE_ADDR memaddr, gdb_byte *our, int len,
1940 int write, struct mem_attrib *mem,
1941 struct target_ops *target)
1946 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1947 len, (DWORD) (uintptr_t) memaddr));
1948 if (!WriteProcessMemory (current_process_handle,
1949 (LPVOID) (uintptr_t) memaddr, our,
1952 FlushInstructionCache (current_process_handle,
1953 (LPCVOID) (uintptr_t) memaddr, len);
1957 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
1958 len, (DWORD) (uintptr_t) memaddr));
1959 if (!ReadProcessMemory (current_process_handle,
1960 (LPCVOID) (uintptr_t) memaddr, our,
1968 win32_kill_inferior (void)
1970 CHECK (TerminateProcess (current_process_handle, 0));
1974 if (!win32_continue (DBG_CONTINUE, -1))
1976 if (!WaitForDebugEvent (¤t_event, INFINITE))
1978 if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
1982 target_mourn_inferior (); /* or just win32_mourn_inferior? */
1986 win32_prepare_to_store (struct regcache *regcache)
1988 /* Do nothing, since we can store individual regs */
1992 win32_can_run (void)
2000 DEBUG_EVENTS (("gdb: win32_close, inferior_ptid=%d\n",
2001 PIDGET (inferior_ptid)));
2004 /* Convert pid to printable format. */
2006 win32_pid_to_str (ptid_t ptid)
2008 static char buf[80];
2009 int pid = PIDGET (ptid);
2011 if ((DWORD) pid == current_event.dwProcessId)
2012 sprintf (buf, "process %d", pid);
2014 sprintf (buf, "thread %ld.0x%x", current_event.dwProcessId, pid);
2019 win32_xfer_shared_libraries (struct target_ops *ops,
2020 enum target_object object, const char *annex,
2021 gdb_byte *readbuf, const gdb_byte *writebuf,
2022 ULONGEST offset, LONGEST len)
2024 struct obstack obstack;
2032 obstack_init (&obstack);
2033 obstack_grow_str (&obstack, "<library-list>\n");
2034 for (so = solib_start.next; so; so = so->next)
2035 win32_xfer_shared_library (so->so_name, so->lm_info->load_addr, &obstack);
2036 obstack_grow_str0 (&obstack, "</library-list>\n");
2038 buf = obstack_finish (&obstack);
2039 len_avail = strlen (buf);
2040 if (offset >= len_avail)
2043 if (len > len_avail - offset)
2044 len = len_avail - offset;
2045 memcpy (readbuf, buf + offset, len);
2047 obstack_free (&obstack, NULL);
2052 win32_xfer_partial (struct target_ops *ops, enum target_object object,
2053 const char *annex, gdb_byte *readbuf,
2054 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
2058 case TARGET_OBJECT_MEMORY:
2060 return (*ops->deprecated_xfer_memory) (offset, readbuf,
2061 len, 0/*read*/, NULL, ops);
2063 return (*ops->deprecated_xfer_memory) (offset, (gdb_byte *) writebuf,
2064 len, 1/*write*/, NULL, ops);
2067 case TARGET_OBJECT_LIBRARIES:
2068 return win32_xfer_shared_libraries (ops, object, annex, readbuf,
2069 writebuf, offset, len);
2072 if (ops->beneath != NULL)
2073 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
2074 readbuf, writebuf, offset, len);
2080 init_win32_ops (void)
2082 win32_ops.to_shortname = "child";
2083 win32_ops.to_longname = "Win32 child process";
2084 win32_ops.to_doc = "Win32 child process (started by the \"run\" command).";
2085 win32_ops.to_open = win32_open;
2086 win32_ops.to_close = win32_close;
2087 win32_ops.to_attach = win32_attach;
2088 win32_ops.to_detach = win32_detach;
2089 win32_ops.to_resume = win32_resume;
2090 win32_ops.to_wait = win32_wait;
2091 win32_ops.to_fetch_registers = win32_fetch_inferior_registers;
2092 win32_ops.to_store_registers = win32_store_inferior_registers;
2093 win32_ops.to_prepare_to_store = win32_prepare_to_store;
2094 win32_ops.deprecated_xfer_memory = win32_xfer_memory;
2095 win32_ops.to_xfer_partial = win32_xfer_partial;
2096 win32_ops.to_files_info = win32_files_info;
2097 win32_ops.to_insert_breakpoint = memory_insert_breakpoint;
2098 win32_ops.to_remove_breakpoint = memory_remove_breakpoint;
2099 win32_ops.to_terminal_init = terminal_init_inferior;
2100 win32_ops.to_terminal_inferior = terminal_inferior;
2101 win32_ops.to_terminal_ours_for_output = terminal_ours_for_output;
2102 win32_ops.to_terminal_ours = terminal_ours;
2103 win32_ops.to_terminal_save_ours = terminal_save_ours;
2104 win32_ops.to_terminal_info = child_terminal_info;
2105 win32_ops.to_kill = win32_kill_inferior;
2106 win32_ops.to_create_inferior = win32_create_inferior;
2107 win32_ops.to_mourn_inferior = win32_mourn_inferior;
2108 win32_ops.to_can_run = win32_can_run;
2109 win32_ops.to_thread_alive = win32_win32_thread_alive;
2110 win32_ops.to_pid_to_str = win32_pid_to_str;
2111 win32_ops.to_stop = win32_stop;
2112 win32_ops.to_stratum = process_stratum;
2113 win32_ops.to_has_all_memory = 1;
2114 win32_ops.to_has_memory = 1;
2115 win32_ops.to_has_stack = 1;
2116 win32_ops.to_has_registers = 1;
2117 win32_ops.to_has_execution = 1;
2118 win32_ops.to_magic = OPS_MAGIC;
2119 win32_ops.to_pid_to_exec_file = win32_pid_to_exec_file;
2123 set_win32_aliases (char *argv0)
2125 add_info_alias ("dll", "sharedlibrary", 1);
2129 _initialize_win32_nat (void)
2131 struct cmd_list_element *c;
2135 c = add_com ("dll-symbols", class_files, dll_symbol_command,
2136 _("Load dll library symbols from FILE."));
2137 set_cmd_completer (c, filename_completer);
2139 add_com_alias ("sharedlibrary", "dll-symbols", class_alias, 1);
2142 add_setshow_boolean_cmd ("shell", class_support, &useshell, _("\
2143 Set use of shell to start subprocess."), _("\
2144 Show use of shell to start subprocess."), NULL,
2146 NULL, /* FIXME: i18n: */
2147 &setlist, &showlist);
2149 add_setshow_boolean_cmd ("cygwin-exceptions", class_support, &cygwin_exceptions, _("\
2150 Break when an exception is detected in the Cygwin DLL itself."), _("\
2151 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL,
2153 NULL, /* FIXME: i18n: */
2154 &setlist, &showlist);
2157 add_setshow_boolean_cmd ("new-console", class_support, &new_console, _("\
2158 Set creation of new console when creating child process."), _("\
2159 Show creation of new console when creating child process."), NULL,
2161 NULL, /* FIXME: i18n: */
2162 &setlist, &showlist);
2164 add_setshow_boolean_cmd ("new-group", class_support, &new_group, _("\
2165 Set creation of new group when creating child process."), _("\
2166 Show creation of new group when creating child process."), NULL,
2168 NULL, /* FIXME: i18n: */
2169 &setlist, &showlist);
2171 add_setshow_boolean_cmd ("debugexec", class_support, &debug_exec, _("\
2172 Set whether to display execution in child process."), _("\
2173 Show whether to display execution in child process."), NULL,
2175 NULL, /* FIXME: i18n: */
2176 &setlist, &showlist);
2178 add_setshow_boolean_cmd ("debugevents", class_support, &debug_events, _("\
2179 Set whether to display kernel events in child process."), _("\
2180 Show whether to display kernel events in child process."), NULL,
2182 NULL, /* FIXME: i18n: */
2183 &setlist, &showlist);
2185 add_setshow_boolean_cmd ("debugmemory", class_support, &debug_memory, _("\
2186 Set whether to display memory accesses in child process."), _("\
2187 Show whether to display memory accesses in child process."), NULL,
2189 NULL, /* FIXME: i18n: */
2190 &setlist, &showlist);
2192 add_setshow_boolean_cmd ("debugexceptions", class_support,
2193 &debug_exceptions, _("\
2194 Set whether to display kernel exceptions in child process."), _("\
2195 Show whether to display kernel exceptions in child process."), NULL,
2197 NULL, /* FIXME: i18n: */
2198 &setlist, &showlist);
2200 add_prefix_cmd ("w32", class_info, info_w32_command,
2201 _("Print information specific to Win32 debugging."),
2202 &info_w32_cmdlist, "info w32 ", 0, &infolist);
2204 add_cmd ("selector", class_info, display_selectors,
2205 _("Display selectors infos."),
2207 add_target (&win32_ops);
2208 deprecated_init_ui_hook = set_win32_aliases;
2211 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2213 /* Pass the address ADDR to the inferior in the I'th debug register.
2214 Here we just store the address in dr array, the registers will be
2215 actually set up when win32_continue is called. */
2217 cygwin_set_dr (int i, CORE_ADDR addr)
2220 internal_error (__FILE__, __LINE__,
2221 _("Invalid register %d in cygwin_set_dr.\n"), i);
2222 dr[i] = (unsigned) addr;
2223 debug_registers_changed = 1;
2224 debug_registers_used = 1;
2227 /* Pass the value VAL to the inferior in the DR7 debug control
2228 register. Here we just store the address in D_REGS, the watchpoint
2229 will be actually set up in win32_wait. */
2231 cygwin_set_dr7 (unsigned val)
2234 debug_registers_changed = 1;
2235 debug_registers_used = 1;
2238 /* Get the value of the DR6 debug status register from the inferior.
2239 Here we just return the value stored in dr[6]
2240 by the last call to thread_rec for current_event.dwThreadId id. */
2242 cygwin_get_dr6 (void)
2247 /* Determine if the thread referenced by "pid" is alive
2248 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2249 it means that the pid has died. Otherwise it is assumed to be alive. */
2251 win32_win32_thread_alive (ptid_t ptid)
2253 int pid = PIDGET (ptid);
2255 return WaitForSingleObject (thread_rec (pid, FALSE)->h, 0) == WAIT_OBJECT_0 ?
2260 _initialize_check_for_gdb_ini (void)
2263 if (inhibit_gdbinit)
2266 homedir = getenv ("HOME");
2270 char *oldini = (char *) alloca (strlen (homedir) +
2271 sizeof ("/gdb.ini"));
2272 strcpy (oldini, homedir);
2273 p = strchr (oldini, '\0');
2274 if (p > oldini && p[-1] != '/')
2276 strcpy (p, "gdb.ini");
2277 if (access (oldini, 0) == 0)
2279 int len = strlen (oldini);
2280 char *newini = alloca (len + 1);
2281 sprintf (newini, "%.*s.gdbinit",
2282 (int) (len - (sizeof ("gdb.ini") - 1)), oldini);
2283 warning (_("obsolete '%s' found. Rename to '%s'."), oldini, newini);
2289 _initialize_psapi (void)
2291 /* Load optional functions used for retrieving filename information
2292 associated with the currently debugged process or its dlls. */
2295 HMODULE psapi_module_handle;
2299 psapi_module_handle = LoadLibrary ("psapi.dll");
2300 if (psapi_module_handle)
2302 psapi_EnumProcessModules = (void *) GetProcAddress (psapi_module_handle, "EnumProcessModules");
2303 psapi_GetModuleInformation = (void *) GetProcAddress (psapi_module_handle, "GetModuleInformation");
2304 psapi_GetModuleFileNameExA = (void *) GetProcAddress (psapi_module_handle, "GetModuleFileNameExA");
2306 if (psapi_EnumProcessModules != NULL
2307 && psapi_GetModuleInformation != NULL
2308 && psapi_GetModuleFileNameExA != NULL)
2313 /* This will probably fail on Windows 9x/Me. Let the user know that we're
2314 missing some functionality. */
2315 if (psapi_loaded < 0)
2316 warning(_("cannot automatically find executable file or library to read symbols. Use \"file\" or \"dll\" command to load executable/libraries directly."));