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 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 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \
89 | CONTEXT_EXTENDED_REGISTERS
91 static unsigned dr[8];
92 static int debug_registers_changed;
93 static int debug_registers_used;
94 #define DR6_CLEAR_VALUE 0xffff0ff0
96 /* The string sent by cygwin when it processes a signal.
97 FIXME: This should be in a cygwin include file. */
98 #ifndef _CYGWIN_SIGNAL_STRING
99 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
102 #define CHECK(x) check (x, __FILE__,__LINE__)
103 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
104 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
105 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
106 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
108 static void win32_stop (void);
109 static int win32_win32_thread_alive (ptid_t);
110 static void win32_kill_inferior (void);
112 static enum target_signal last_sig = TARGET_SIGNAL_0;
113 /* Set if a signal was received from the debugged process */
115 /* Thread information structure used to track information that is
116 not available in gdb's thread structure. */
117 typedef struct thread_info_struct
119 struct thread_info_struct *next;
130 static thread_info thread_head;
132 /* The process and thread handles for the above context. */
134 static DEBUG_EVENT current_event; /* The current debug event from
136 static HANDLE current_process_handle; /* Currently executing process */
137 static thread_info *current_thread; /* Info on currently selected thread */
138 static DWORD main_thread_id; /* Thread ID of the main thread */
140 /* Counts of things. */
141 static int exception_count = 0;
142 static int event_count = 0;
143 static int saw_create;
146 static int new_console = 0;
148 static int cygwin_exceptions = 0;
150 static int new_group = 1;
151 static int debug_exec = 0; /* show execution */
152 static int debug_events = 0; /* show events from kernel */
153 static int debug_memory = 0; /* show target memory accesses */
154 static int debug_exceptions = 0; /* show target exceptions */
155 static int useshell = 0; /* use shell for subprocesses */
157 /* This vector maps GDB's idea of a register's number into an address
158 in the win32 exception context vector.
160 It also contains the bit mask needed to load the register in question.
162 One day we could read a reg, we could inspect the context we
163 already have loaded, if it doesn't have the bit set that we need,
164 we read that set of registers in using GetThreadContext. If the
165 context already contains what we need, we just unpack it. Then to
166 write a register, first we have to ensure that the context contains
167 the other regs of the group, and then we copy the info in and set
170 #define context_offset(x) ((int)&(((CONTEXT *)NULL)->x))
171 static const int mappings[] =
173 context_offset (Eax),
174 context_offset (Ecx),
175 context_offset (Edx),
176 context_offset (Ebx),
177 context_offset (Esp),
178 context_offset (Ebp),
179 context_offset (Esi),
180 context_offset (Edi),
181 context_offset (Eip),
182 context_offset (EFlags),
183 context_offset (SegCs),
184 context_offset (SegSs),
185 context_offset (SegDs),
186 context_offset (SegEs),
187 context_offset (SegFs),
188 context_offset (SegGs),
189 context_offset (FloatSave.RegisterArea[0 * 10]),
190 context_offset (FloatSave.RegisterArea[1 * 10]),
191 context_offset (FloatSave.RegisterArea[2 * 10]),
192 context_offset (FloatSave.RegisterArea[3 * 10]),
193 context_offset (FloatSave.RegisterArea[4 * 10]),
194 context_offset (FloatSave.RegisterArea[5 * 10]),
195 context_offset (FloatSave.RegisterArea[6 * 10]),
196 context_offset (FloatSave.RegisterArea[7 * 10]),
197 context_offset (FloatSave.ControlWord),
198 context_offset (FloatSave.StatusWord),
199 context_offset (FloatSave.TagWord),
200 context_offset (FloatSave.ErrorSelector),
201 context_offset (FloatSave.ErrorOffset),
202 context_offset (FloatSave.DataSelector),
203 context_offset (FloatSave.DataOffset),
204 context_offset (FloatSave.ErrorSelector)
206 context_offset (ExtendedRegisters[10*16]),
207 context_offset (ExtendedRegisters[11*16]),
208 context_offset (ExtendedRegisters[12*16]),
209 context_offset (ExtendedRegisters[13*16]),
210 context_offset (ExtendedRegisters[14*16]),
211 context_offset (ExtendedRegisters[15*16]),
212 context_offset (ExtendedRegisters[16*16]),
213 context_offset (ExtendedRegisters[17*16]),
215 context_offset (ExtendedRegisters[24])
218 #undef context_offset
220 /* This vector maps the target's idea of an exception (extracted
221 from the DEBUG_EVENT structure) to GDB's idea. */
223 struct xlate_exception
226 enum target_signal us;
229 static const struct xlate_exception
232 {EXCEPTION_ACCESS_VIOLATION, TARGET_SIGNAL_SEGV},
233 {STATUS_STACK_OVERFLOW, TARGET_SIGNAL_SEGV},
234 {EXCEPTION_BREAKPOINT, TARGET_SIGNAL_TRAP},
235 {DBG_CONTROL_C, TARGET_SIGNAL_INT},
236 {EXCEPTION_SINGLE_STEP, TARGET_SIGNAL_TRAP},
237 {STATUS_FLOAT_DIVIDE_BY_ZERO, TARGET_SIGNAL_FPE},
241 check (BOOL ok, const char *file, int line)
244 printf_filtered ("error return %s:%d was %lu\n", file, line,
248 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
249 then also retrieve the context for this thread. If GET_CONTEXT is
250 negative, then don't suspend the thread. */
252 thread_rec (DWORD id, int get_context)
256 for (th = &thread_head; (th = th->next) != NULL;)
259 if (!th->suspended && get_context)
261 if (get_context > 0 && id != current_event.dwThreadId)
263 if (SuspendThread (th->h) == (DWORD) -1)
265 DWORD err = GetLastError ();
266 warning (_("SuspendThread failed. (winerr %d)"),
272 else if (get_context < 0)
274 th->reload_context = 1;
282 /* Add a thread to the thread list */
284 win32_add_thread (DWORD id, HANDLE h)
288 if ((th = thread_rec (id, FALSE)))
291 th = XZALLOC (thread_info);
294 th->next = thread_head.next;
295 thread_head.next = th;
296 add_thread (pid_to_ptid (id));
297 /* Set the debug registers for the new thread in they are used. */
298 if (debug_registers_used)
300 /* Only change the value of the debug registers. */
301 th->context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
302 CHECK (GetThreadContext (th->h, &th->context));
303 th->context.Dr0 = dr[0];
304 th->context.Dr1 = dr[1];
305 th->context.Dr2 = dr[2];
306 th->context.Dr3 = dr[3];
307 th->context.Dr6 = DR6_CLEAR_VALUE;
308 th->context.Dr7 = dr[7];
309 CHECK (SetThreadContext (th->h, &th->context));
310 th->context.ContextFlags = 0;
315 /* Clear out any old thread list and reintialize it to a
318 win32_init_thread_list (void)
320 thread_info *th = &thread_head;
322 DEBUG_EVENTS (("gdb: win32_init_thread_list\n"));
324 while (th->next != NULL)
326 thread_info *here = th->next;
327 th->next = here->next;
328 (void) CloseHandle (here->h);
331 thread_head.next = NULL;
334 /* Delete a thread from the list of threads */
336 win32_delete_thread (DWORD id)
341 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (pid_to_ptid (id)));
342 delete_thread (pid_to_ptid (id));
344 for (th = &thread_head;
345 th->next != NULL && th->next->id != id;
349 if (th->next != NULL)
351 thread_info *here = th->next;
352 th->next = here->next;
353 CloseHandle (here->h);
359 do_win32_fetch_inferior_registers (struct regcache *regcache, int r)
361 char *context_offset = ((char *) ¤t_thread->context) + mappings[r];
365 return; /* Windows sometimes uses a non-existent thread id in its
368 if (current_thread->reload_context)
370 #ifdef __COPY_CONTEXT_SIZE
371 if (have_saved_context)
373 /* Lie about where the program actually is stopped since cygwin has informed us that
374 we should consider the signal to have occurred at another location which is stored
375 in "saved_context. */
376 memcpy (¤t_thread->context, &saved_context, __COPY_CONTEXT_SIZE);
377 have_saved_context = 0;
382 thread_info *th = current_thread;
383 th->context.ContextFlags = CONTEXT_DEBUGGER_DR;
384 GetThreadContext (th->h, &th->context);
385 /* Copy dr values from that thread. */
386 dr[0] = th->context.Dr0;
387 dr[1] = th->context.Dr1;
388 dr[2] = th->context.Dr2;
389 dr[3] = th->context.Dr3;
390 dr[6] = th->context.Dr6;
391 dr[7] = th->context.Dr7;
393 current_thread->reload_context = 0;
396 #define I387_ST0_REGNUM I386_ST0_REGNUM
398 if (r == I387_FISEG_REGNUM)
400 l = *((long *) context_offset) & 0xffff;
401 regcache_raw_supply (regcache, r, (char *) &l);
403 else if (r == I387_FOP_REGNUM)
405 l = (*((long *) context_offset) >> 16) & ((1 << 11) - 1);
406 regcache_raw_supply (regcache, r, (char *) &l);
409 regcache_raw_supply (regcache, r, context_offset);
412 for (r = 0; r < gdbarch_num_regs (get_regcache_arch (regcache)); r++)
413 do_win32_fetch_inferior_registers (regcache, r);
416 #undef I387_ST0_REGNUM
420 win32_fetch_inferior_registers (struct regcache *regcache, int r)
422 current_thread = thread_rec (PIDGET (inferior_ptid), TRUE);
423 /* Check if current_thread exists. Windows sometimes uses a non-existent
424 thread id in its events */
426 do_win32_fetch_inferior_registers (regcache, r);
430 do_win32_store_inferior_registers (const struct regcache *regcache, int r)
433 /* Windows sometimes uses a non-existent thread id in its events */;
435 regcache_raw_collect (regcache, r,
436 ((char *) ¤t_thread->context) + mappings[r]);
439 for (r = 0; r < gdbarch_num_regs (get_regcache_arch (regcache)); r++)
440 do_win32_store_inferior_registers (regcache, r);
444 /* Store a new register value into the current thread context */
446 win32_store_inferior_registers (struct regcache *regcache, int r)
448 current_thread = thread_rec (PIDGET (inferior_ptid), TRUE);
449 /* Check if current_thread exists. Windows sometimes uses a non-existent
450 thread id in its events */
452 do_win32_store_inferior_registers (regcache, r);
455 static int psapi_loaded = 0;
456 static HMODULE psapi_module_handle = NULL;
457 static BOOL WINAPI (*psapi_EnumProcessModules) (HANDLE, HMODULE *, DWORD, LPDWORD) = NULL;
458 static BOOL WINAPI (*psapi_GetModuleInformation) (HANDLE, HMODULE, LPMODULEINFO, DWORD) = NULL;
459 static DWORD WINAPI (*psapi_GetModuleFileNameExA) (HANDLE, HMODULE, LPSTR, DWORD) = NULL;
462 psapi_get_dll_name (DWORD BaseAddress, char *dll_name_ret)
468 HMODULE *DllHandle = dh_buf;
473 psapi_EnumProcessModules == NULL ||
474 psapi_GetModuleInformation == NULL ||
475 psapi_GetModuleFileNameExA == NULL)
480 psapi_module_handle = LoadLibrary ("psapi.dll");
481 if (!psapi_module_handle)
483 /* printf_unfiltered ("error loading psapi.dll: %u", GetLastError ()); */
486 psapi_EnumProcessModules = GetProcAddress (psapi_module_handle, "EnumProcessModules");
487 psapi_GetModuleInformation = GetProcAddress (psapi_module_handle, "GetModuleInformation");
488 psapi_GetModuleFileNameExA = (void *) GetProcAddress (psapi_module_handle,
489 "GetModuleFileNameExA");
490 if (psapi_EnumProcessModules == NULL ||
491 psapi_GetModuleInformation == NULL ||
492 psapi_GetModuleFileNameExA == NULL)
497 ok = (*psapi_EnumProcessModules) (current_process_handle,
502 if (!ok || !cbNeeded)
505 DllHandle = (HMODULE *) alloca (cbNeeded);
509 ok = (*psapi_EnumProcessModules) (current_process_handle,
516 for (i = 0; i < (int) (cbNeeded / sizeof (HMODULE)); i++)
518 if (!(*psapi_GetModuleInformation) (current_process_handle,
522 error (_("Can't get module info"));
524 len = (*psapi_GetModuleFileNameExA) (current_process_handle,
529 error (_("Error getting dll name: %u."), (unsigned) GetLastError ());
531 if ((DWORD) (mi.lpBaseOfDll) == BaseAddress)
536 dll_name_ret[0] = '\0';
540 /* Encapsulate the information required in a call to
541 symbol_file_add_args */
542 struct safe_symbol_file_add_args
546 struct section_addr_info *addrs;
549 struct ui_file *err, *out;
553 /* Maintain a linked list of "so" information. */
559 static struct so_list solib_start, *solib_end;
561 /* Call symbol_file_add with stderr redirected. We don't care if there
564 safe_symbol_file_add_stub (void *argv)
566 #define p ((struct safe_symbol_file_add_args *) argv)
567 struct so_list *so = &solib_start;
569 p->ret = symbol_file_add (p->name, p->from_tty, p->addrs, p->mainline, p->flags);
574 /* Restore gdb's stderr after calling symbol_file_add */
576 safe_symbol_file_add_cleanup (void *p)
578 #define sp ((struct safe_symbol_file_add_args *)p)
579 gdb_flush (gdb_stderr);
580 gdb_flush (gdb_stdout);
581 ui_file_delete (gdb_stderr);
582 ui_file_delete (gdb_stdout);
583 gdb_stderr = sp->err;
584 gdb_stdout = sp->out;
588 /* symbol_file_add wrapper that prevents errors from being displayed. */
589 static struct objfile *
590 safe_symbol_file_add (char *name, int from_tty,
591 struct section_addr_info *addrs,
592 int mainline, int flags)
594 struct safe_symbol_file_add_args p;
595 struct cleanup *cleanup;
597 cleanup = make_cleanup (safe_symbol_file_add_cleanup, &p);
601 gdb_flush (gdb_stderr);
602 gdb_flush (gdb_stdout);
603 gdb_stderr = ui_file_new ();
604 gdb_stdout = ui_file_new ();
606 p.from_tty = from_tty;
608 p.mainline = mainline;
610 catch_errors (safe_symbol_file_add_stub, &p, "", RETURN_MASK_ERROR);
612 do_cleanups (cleanup);
616 static struct so_list *
617 win32_make_so (const char *name, DWORD load_addr)
620 char buf[MAX_PATH + 1];
621 char cwd[MAX_PATH + 1];
623 WIN32_FIND_DATA w32_fd;
624 HANDLE h = FindFirstFile(name, &w32_fd);
625 MEMORY_BASIC_INFORMATION m;
627 if (h == INVALID_HANDLE_VALUE)
633 if (GetCurrentDirectory (MAX_PATH + 1, cwd))
635 p = strrchr (buf, '\\');
638 SetCurrentDirectory (buf);
639 GetFullPathName (w32_fd.cFileName, MAX_PATH, buf, &p);
640 SetCurrentDirectory (cwd);
644 if (strcasecmp (buf, "ntdll.dll") == 0)
646 GetSystemDirectory (buf, sizeof (buf));
647 strcat (buf, "\\ntdll.dll");
649 so = XZALLOC (struct so_list);
650 so->lm_info = (struct lm_info *) xmalloc (sizeof (struct lm_info));
651 so->lm_info->load_addr = load_addr;
652 strcpy (so->so_original_name, name);
654 strcpy (so->so_name, buf);
656 cygwin_conv_to_posix_path (buf, so->so_name);
657 /* Record cygwin1.dll .text start/end. */
658 p = strchr (so->so_name, '\0') - (sizeof ("/cygwin1.dll") - 1);
659 if (p >= so->so_name && strcasecmp (p, "/cygwin1.dll") == 0)
662 asection *text = NULL;
665 abfd = bfd_openr (name, "pei-i386");
670 if (bfd_check_format (abfd, bfd_object))
671 text = bfd_get_section_by_name (abfd, ".text");
679 /* The symbols in a dll are offset by 0x1000, which is the the
680 offset from 0 of the first byte in an image - because of the
681 file header and the section alignment. */
682 cygwin_load_start = load_addr + 0x1000;
683 cygwin_load_end = cygwin_load_start + bfd_section_size (abfd, text);
693 get_image_name (HANDLE h, void *address, int unicode)
695 static char buf[(2 * MAX_PATH) + 1];
696 DWORD size = unicode ? sizeof (WCHAR) : sizeof (char);
702 /* Attempt to read the name of the dll that was detected.
703 This is documented to work only when actively debugging
704 a program. It will not work for attached processes. */
708 /* See if we could read the address of a string, and that the
709 address isn't null. */
710 if (!ReadProcessMemory (h, address, &address_ptr, sizeof (address_ptr), &done)
711 || done != sizeof (address_ptr) || !address_ptr)
714 /* Find the length of the string */
715 while (ReadProcessMemory (h, address_ptr + len++ * size, &b, size, &done)
716 && (b[0] != 0 || b[size - 1] != 0) && done == size)
720 ReadProcessMemory (h, address_ptr, buf, len, &done);
723 WCHAR *unicode_address = (WCHAR *) alloca (len * sizeof (WCHAR));
724 ReadProcessMemory (h, address_ptr, unicode_address, len * sizeof (WCHAR),
727 WideCharToMultiByte (CP_ACP, 0, unicode_address, len, buf, len, 0, 0);
733 /* Wait for child to do something. Return pid of child, or -1 in case
734 of error; store status through argument pointer OURSTATUS. */
736 handle_load_dll (void *dummy)
738 LOAD_DLL_DEBUG_INFO *event = ¤t_event.u.LoadDll;
739 char dll_buf[MAX_PATH + 1];
740 char *dll_name = NULL;
742 dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0';
744 if (!psapi_get_dll_name ((DWORD) (event->lpBaseOfDll), dll_buf))
745 dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0';
749 if (*dll_name == '\0')
750 dll_name = get_image_name (current_process_handle,
751 event->lpImageName, event->fUnicode);
755 solib_end->next = win32_make_so (dll_name, (DWORD) event->lpBaseOfDll);
756 solib_end = solib_end->next;
762 win32_free_so (struct so_list *so)
770 handle_unload_dll (void *dummy)
772 DWORD lpBaseOfDll = (DWORD) current_event.u.UnloadDll.lpBaseOfDll;
775 for (so = &solib_start; so->next != NULL; so = so->next)
776 if (so->next->lm_info->load_addr == lpBaseOfDll)
778 struct so_list *sodel = so->next;
779 so->next = sodel->next;
782 win32_free_so (sodel);
783 solib_add (NULL, 0, NULL, auto_solib_add);
787 error (_("Error: dll starting at 0x%lx not found."), (DWORD) lpBaseOfDll);
792 /* Clear list of loaded DLLs. */
794 win32_clear_solib (void)
796 solib_start.next = NULL;
797 solib_end = &solib_start;
800 /* Load DLL symbol info. */
802 dll_symbol_command (char *args, int from_tty)
808 error (_("dll-symbols requires a file name"));
811 if (n > 4 && strcasecmp (args + n - 4, ".dll") != 0)
813 char *newargs = (char *) alloca (n + 4 + 1);
814 strcpy (newargs, args);
815 strcat (newargs, ".dll");
819 safe_symbol_file_add (args, from_tty, NULL, 0, OBJF_SHARED | OBJF_USERLOADED);
822 /* Handle DEBUG_STRING output from child process.
823 Cygwin prepends its messages with a "cygwin:". Interpret this as
824 a Cygwin signal. Otherwise just print the string as a warning. */
826 handle_output_debug_string (struct target_waitstatus *ourstatus)
831 if (!target_read_string
832 ((CORE_ADDR) current_event.u.DebugString.lpDebugStringData, &s, 1024, 0)
835 else if (strncmp (s, _CYGWIN_SIGNAL_STRING, sizeof (_CYGWIN_SIGNAL_STRING) - 1) != 0)
838 if (strncmp (s, "cYg", 3) != 0)
842 #ifdef __COPY_CONTEXT_SIZE
845 /* Got a cygwin signal marker. A cygwin signal is followed by the signal number
846 itself and then optionally followed by the thread id and address to saved context
847 within the DLL. If these are supplied, then the given thread is assumed to have
848 issued the signal and the context from the thread is assumed to be stored at the
849 given address in the inferior. Tell gdb to treat this like a real signal. */
851 int sig = strtol (s + sizeof (_CYGWIN_SIGNAL_STRING) - 1, &p, 0);
852 int gotasig = target_signal_from_host (sig);
853 ourstatus->value.sig = gotasig;
858 ourstatus->kind = TARGET_WAITKIND_STOPPED;
859 retval = strtoul (p, &p, 0);
861 retval = main_thread_id;
862 else if ((x = (LPCVOID) strtoul (p, &p, 0))
863 && ReadProcessMemory (current_process_handle, x,
864 &saved_context, __COPY_CONTEXT_SIZE, &n)
865 && n == __COPY_CONTEXT_SIZE)
866 have_saved_context = 1;
867 current_event.dwThreadId = retval;
878 display_selector (HANDLE thread, DWORD sel)
881 if (GetThreadSelectorEntry (thread, sel, &info))
884 printf_filtered ("0x%03lx: ", sel);
885 if (!info.HighWord.Bits.Pres)
887 puts_filtered ("Segment not present\n");
890 base = (info.HighWord.Bits.BaseHi << 24) +
891 (info.HighWord.Bits.BaseMid << 16)
893 limit = (info.HighWord.Bits.LimitHi << 16) + info.LimitLow;
894 if (info.HighWord.Bits.Granularity)
895 limit = (limit << 12) | 0xfff;
896 printf_filtered ("base=0x%08x limit=0x%08x", base, limit);
897 if (info.HighWord.Bits.Default_Big)
898 puts_filtered(" 32-bit ");
900 puts_filtered(" 16-bit ");
901 switch ((info.HighWord.Bits.Type & 0xf) >> 1)
904 puts_filtered ("Data (Read-Only, Exp-up");
907 puts_filtered ("Data (Read/Write, Exp-up");
910 puts_filtered ("Unused segment (");
913 puts_filtered ("Data (Read/Write, Exp-down");
916 puts_filtered ("Code (Exec-Only, N.Conf");
919 puts_filtered ("Code (Exec/Read, N.Conf");
922 puts_filtered ("Code (Exec-Only, Conf");
925 puts_filtered ("Code (Exec/Read, Conf");
928 printf_filtered ("Unknown type 0x%x",info.HighWord.Bits.Type);
930 if ((info.HighWord.Bits.Type & 0x1) == 0)
931 puts_filtered(", N.Acc");
932 puts_filtered (")\n");
933 if ((info.HighWord.Bits.Type & 0x10) == 0)
934 puts_filtered("System selector ");
935 printf_filtered ("Priviledge level = %d. ", info.HighWord.Bits.Dpl);
936 if (info.HighWord.Bits.Granularity)
937 puts_filtered ("Page granular.\n");
939 puts_filtered ("Byte granular.\n");
944 printf_filtered ("Invalid selector 0x%lx.\n",sel);
950 display_selectors (char * args, int from_tty)
954 puts_filtered ("Impossible to display selectors now.\n");
960 puts_filtered ("Selector $cs\n");
961 display_selector (current_thread->h,
962 current_thread->context.SegCs);
963 puts_filtered ("Selector $ds\n");
964 display_selector (current_thread->h,
965 current_thread->context.SegDs);
966 puts_filtered ("Selector $es\n");
967 display_selector (current_thread->h,
968 current_thread->context.SegEs);
969 puts_filtered ("Selector $ss\n");
970 display_selector (current_thread->h,
971 current_thread->context.SegSs);
972 puts_filtered ("Selector $fs\n");
973 display_selector (current_thread->h,
974 current_thread->context.SegFs);
975 puts_filtered ("Selector $gs\n");
976 display_selector (current_thread->h,
977 current_thread->context.SegGs);
982 sel = parse_and_eval_long (args);
983 printf_filtered ("Selector \"%s\"\n",args);
984 display_selector (current_thread->h, sel);
988 static struct cmd_list_element *info_w32_cmdlist = NULL;
991 info_w32_command (char *args, int from_tty)
993 help_list (info_w32_cmdlist, "info w32 ", class_info, gdb_stdout);
997 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
998 printf_unfiltered ("gdb: Target exception %s at 0x%08lx\n", x, \
999 (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress)
1002 handle_exception (struct target_waitstatus *ourstatus)
1005 DWORD code = current_event.u.Exception.ExceptionRecord.ExceptionCode;
1007 ourstatus->kind = TARGET_WAITKIND_STOPPED;
1009 /* Record the context of the current thread */
1010 th = thread_rec (current_event.dwThreadId, -1);
1014 case EXCEPTION_ACCESS_VIOLATION:
1015 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1016 ourstatus->value.sig = TARGET_SIGNAL_SEGV;
1019 /* See if the access violation happened within the cygwin DLL itself. Cygwin uses
1020 a kind of exception handling to deal with passed-in invalid addresses. gdb
1021 should not treat these as real SEGVs since they will be silently handled by
1022 cygwin. A real SEGV will (theoretically) be caught by cygwin later in the process
1023 and will be sent as a cygwin-specific-signal. So, ignore SEGVs if they show up
1024 within the text segment of the DLL itself. */
1026 bfd_vma addr = (bfd_vma) current_event.u.Exception.ExceptionRecord.ExceptionAddress;
1027 if ((!cygwin_exceptions && (addr >= cygwin_load_start && addr < cygwin_load_end))
1028 || (find_pc_partial_function (addr, &fn, NULL, NULL)
1029 && strncmp (fn, "KERNEL32!IsBad", strlen ("KERNEL32!IsBad")) == 0))
1034 case STATUS_STACK_OVERFLOW:
1035 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1036 ourstatus->value.sig = TARGET_SIGNAL_SEGV;
1038 case STATUS_FLOAT_DENORMAL_OPERAND:
1039 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1040 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1042 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
1043 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1044 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1046 case STATUS_FLOAT_INEXACT_RESULT:
1047 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1048 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1050 case STATUS_FLOAT_INVALID_OPERATION:
1051 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1052 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1054 case STATUS_FLOAT_OVERFLOW:
1055 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1056 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1058 case STATUS_FLOAT_STACK_CHECK:
1059 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1060 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1062 case STATUS_FLOAT_UNDERFLOW:
1063 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1064 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1066 case STATUS_FLOAT_DIVIDE_BY_ZERO:
1067 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1068 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1070 case STATUS_INTEGER_DIVIDE_BY_ZERO:
1071 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1072 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1074 case STATUS_INTEGER_OVERFLOW:
1075 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1076 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1078 case EXCEPTION_BREAKPOINT:
1079 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1080 ourstatus->value.sig = TARGET_SIGNAL_TRAP;
1083 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1084 ourstatus->value.sig = TARGET_SIGNAL_INT;
1086 case DBG_CONTROL_BREAK:
1087 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1088 ourstatus->value.sig = TARGET_SIGNAL_INT;
1090 case EXCEPTION_SINGLE_STEP:
1091 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1092 ourstatus->value.sig = TARGET_SIGNAL_TRAP;
1094 case EXCEPTION_ILLEGAL_INSTRUCTION:
1095 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1096 ourstatus->value.sig = TARGET_SIGNAL_ILL;
1098 case EXCEPTION_PRIV_INSTRUCTION:
1099 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1100 ourstatus->value.sig = TARGET_SIGNAL_ILL;
1102 case EXCEPTION_NONCONTINUABLE_EXCEPTION:
1103 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1104 ourstatus->value.sig = TARGET_SIGNAL_ILL;
1107 /* Treat unhandled first chance exceptions specially. */
1108 if (current_event.u.Exception.dwFirstChance)
1110 printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",
1111 current_event.u.Exception.ExceptionRecord.ExceptionCode,
1112 (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress);
1113 ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
1117 last_sig = ourstatus->value.sig;
1121 /* Resume all artificially suspended threads if we are continuing
1124 win32_continue (DWORD continue_status, int id)
1130 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, %s);\n",
1131 current_event.dwProcessId, current_event.dwThreadId,
1132 continue_status == DBG_CONTINUE ?
1133 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1135 for (th = &thread_head; (th = th->next) != NULL;)
1136 if ((id == -1 || id == (int) th->id)
1139 if (debug_registers_changed)
1141 th->context.ContextFlags |= CONTEXT_DEBUG_REGISTERS;
1142 th->context.Dr0 = dr[0];
1143 th->context.Dr1 = dr[1];
1144 th->context.Dr2 = dr[2];
1145 th->context.Dr3 = dr[3];
1146 th->context.Dr6 = DR6_CLEAR_VALUE;
1147 th->context.Dr7 = dr[7];
1149 if (th->context.ContextFlags)
1151 CHECK (SetThreadContext (th->h, &th->context));
1152 th->context.ContextFlags = 0;
1154 if (th->suspended > 0)
1155 (void) ResumeThread (th->h);
1159 res = ContinueDebugEvent (current_event.dwProcessId,
1160 current_event.dwThreadId,
1163 debug_registers_changed = 0;
1167 /* Called in pathological case where Windows fails to send a
1168 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1170 fake_create_process (void)
1172 current_process_handle = OpenProcess (PROCESS_ALL_ACCESS, FALSE,
1173 current_event.dwProcessId);
1174 main_thread_id = current_event.dwThreadId;
1175 current_thread = win32_add_thread (main_thread_id,
1176 current_event.u.CreateThread.hThread);
1177 return main_thread_id;
1181 win32_resume (ptid_t ptid, int step, enum target_signal sig)
1184 DWORD continue_status = DBG_CONTINUE;
1186 int pid = PIDGET (ptid);
1188 if (sig != TARGET_SIGNAL_0)
1190 if (current_event.dwDebugEventCode != EXCEPTION_DEBUG_EVENT)
1192 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig));
1194 else if (sig == last_sig)
1195 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1198 /* This code does not seem to work, because
1199 the kernel does probably not consider changes in the ExceptionRecord
1200 structure when passing the exception to the inferior.
1201 Note that this seems possible in the exception handler itself. */
1204 for (i = 0; xlate[i].them != -1; i++)
1205 if (xlate[i].us == sig)
1207 current_event.u.Exception.ExceptionRecord.ExceptionCode =
1209 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1212 if (continue_status == DBG_CONTINUE)
1214 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig));
1218 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1222 last_sig = TARGET_SIGNAL_0;
1224 DEBUG_EXEC (("gdb: win32_resume (pid=%d, step=%d, sig=%d);\n",
1227 /* Get context for currently selected thread */
1228 th = thread_rec (current_event.dwThreadId, FALSE);
1233 /* Single step by setting t bit */
1234 win32_fetch_inferior_registers (get_current_regcache (),
1235 gdbarch_ps_regnum (current_gdbarch));
1236 th->context.EFlags |= FLAG_TRACE_BIT;
1239 if (th->context.ContextFlags)
1241 if (debug_registers_changed)
1243 th->context.Dr0 = dr[0];
1244 th->context.Dr1 = dr[1];
1245 th->context.Dr2 = dr[2];
1246 th->context.Dr3 = dr[3];
1247 th->context.Dr6 = DR6_CLEAR_VALUE;
1248 th->context.Dr7 = dr[7];
1250 CHECK (SetThreadContext (th->h, &th->context));
1251 th->context.ContextFlags = 0;
1255 /* Allow continuing with the same signal that interrupted us.
1256 Otherwise complain. */
1258 win32_continue (continue_status, pid);
1261 /* Get the next event from the child. Return 1 if the event requires
1262 handling by WFI (or whatever).
1265 get_win32_debug_event (int pid, struct target_waitstatus *ourstatus)
1268 DWORD continue_status, event_code;
1270 static thread_info dummy_thread_info;
1274 last_sig = TARGET_SIGNAL_0;
1276 if (!(debug_event = WaitForDebugEvent (¤t_event, 1000)))
1280 continue_status = DBG_CONTINUE;
1282 event_code = current_event.dwDebugEventCode;
1283 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
1285 have_saved_context = 0;
1289 case CREATE_THREAD_DEBUG_EVENT:
1290 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1291 (unsigned) current_event.dwProcessId,
1292 (unsigned) current_event.dwThreadId,
1293 "CREATE_THREAD_DEBUG_EVENT"));
1294 if (saw_create != 1)
1296 if (!saw_create && attach_flag)
1298 /* Kludge around a Windows bug where first event is a create
1299 thread event. Caused when attached process does not have
1301 retval = ourstatus->value.related_pid = fake_create_process ();
1306 /* Record the existence of this thread */
1307 th = win32_add_thread (current_event.dwThreadId,
1308 current_event.u.CreateThread.hThread);
1310 printf_unfiltered ("[New %s]\n",
1312 pid_to_ptid (current_event.dwThreadId)));
1313 retval = current_event.dwThreadId;
1316 case EXIT_THREAD_DEBUG_EVENT:
1317 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1318 (unsigned) current_event.dwProcessId,
1319 (unsigned) current_event.dwThreadId,
1320 "EXIT_THREAD_DEBUG_EVENT"));
1321 if (current_event.dwThreadId != main_thread_id)
1323 win32_delete_thread (current_event.dwThreadId);
1324 th = &dummy_thread_info;
1328 case CREATE_PROCESS_DEBUG_EVENT:
1329 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1330 (unsigned) current_event.dwProcessId,
1331 (unsigned) current_event.dwThreadId,
1332 "CREATE_PROCESS_DEBUG_EVENT"));
1333 CloseHandle (current_event.u.CreateProcessInfo.hFile);
1334 if (++saw_create != 1)
1336 CloseHandle (current_event.u.CreateProcessInfo.hProcess);
1340 current_process_handle = current_event.u.CreateProcessInfo.hProcess;
1342 win32_delete_thread (main_thread_id);
1343 main_thread_id = current_event.dwThreadId;
1344 /* Add the main thread */
1345 th = win32_add_thread (main_thread_id,
1346 current_event.u.CreateProcessInfo.hThread);
1347 retval = ourstatus->value.related_pid = current_event.dwThreadId;
1350 case EXIT_PROCESS_DEBUG_EVENT:
1351 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1352 (unsigned) current_event.dwProcessId,
1353 (unsigned) current_event.dwThreadId,
1354 "EXIT_PROCESS_DEBUG_EVENT"));
1355 if (saw_create != 1)
1357 ourstatus->kind = TARGET_WAITKIND_EXITED;
1358 ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode;
1359 CloseHandle (current_process_handle);
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. */
1466 int retval = get_win32_debug_event (pid, ourstatus);
1468 return pid_to_ptid (retval);
1473 if (deprecated_ui_loop_hook != NULL)
1474 detach = deprecated_ui_loop_hook (0);
1477 win32_kill_inferior ();
1483 do_initial_win32_stuff (DWORD pid)
1485 extern int stop_after_trap;
1488 last_sig = TARGET_SIGNAL_0;
1490 exception_count = 0;
1491 debug_registers_changed = 0;
1492 debug_registers_used = 0;
1493 for (i = 0; i < sizeof (dr) / sizeof (dr[0]); i++)
1496 cygwin_load_start = cygwin_load_end = 0;
1498 current_event.dwProcessId = pid;
1499 memset (¤t_event, 0, sizeof (current_event));
1500 push_target (&win32_ops);
1501 disable_breakpoints_in_shlibs ();
1502 win32_clear_solib ();
1503 clear_proceed_status ();
1504 init_wait_for_inferior ();
1506 terminal_init_inferior_with_pgrp (pid);
1507 target_terminal_inferior ();
1511 stop_after_trap = 1;
1512 wait_for_inferior ();
1513 if (stop_signal != TARGET_SIGNAL_TRAP)
1514 resume (0, stop_signal);
1518 stop_after_trap = 0;
1522 /* Since Windows XP, detaching from a process is supported by Windows.
1523 The following code tries loading the appropriate functions dynamically.
1524 If loading these functions succeeds use them to actually detach from
1525 the inferior process, otherwise behave as usual, pretending that
1526 detach has worked. */
1527 static BOOL WINAPI (*DebugSetProcessKillOnExit)(BOOL);
1528 static BOOL WINAPI (*DebugActiveProcessStop)(DWORD);
1531 has_detach_ability (void)
1533 static HMODULE kernel32 = NULL;
1536 kernel32 = LoadLibrary ("kernel32.dll");
1539 if (!DebugSetProcessKillOnExit)
1540 DebugSetProcessKillOnExit = GetProcAddress (kernel32,
1541 "DebugSetProcessKillOnExit");
1542 if (!DebugActiveProcessStop)
1543 DebugActiveProcessStop = GetProcAddress (kernel32,
1544 "DebugActiveProcessStop");
1545 if (DebugSetProcessKillOnExit && DebugActiveProcessStop)
1551 /* Try to set or remove a user privilege to the current process. Return -1
1552 if that fails, the previous setting of that privilege otherwise.
1554 This code is copied from the Cygwin source code and rearranged to allow
1555 dynamically loading of the needed symbols from advapi32 which is only
1556 available on NT/2K/XP. */
1558 set_process_privilege (const char *privilege, BOOL enable)
1560 static HMODULE advapi32 = NULL;
1561 static BOOL WINAPI (*OpenProcessToken)(HANDLE, DWORD, PHANDLE);
1562 static BOOL WINAPI (*LookupPrivilegeValue)(LPCSTR, LPCSTR, PLUID);
1563 static BOOL WINAPI (*AdjustTokenPrivileges)(HANDLE, BOOL, PTOKEN_PRIVILEGES,
1564 DWORD, PTOKEN_PRIVILEGES, PDWORD);
1566 HANDLE token_hdl = NULL;
1568 TOKEN_PRIVILEGES new_priv, orig_priv;
1572 if (GetVersion () >= 0x80000000) /* No security availbale on 9x/Me */
1577 if (!(advapi32 = LoadLibrary ("advapi32.dll")))
1579 if (!OpenProcessToken)
1580 OpenProcessToken = GetProcAddress (advapi32, "OpenProcessToken");
1581 if (!LookupPrivilegeValue)
1582 LookupPrivilegeValue = GetProcAddress (advapi32,
1583 "LookupPrivilegeValueA");
1584 if (!AdjustTokenPrivileges)
1585 AdjustTokenPrivileges = GetProcAddress (advapi32,
1586 "AdjustTokenPrivileges");
1587 if (!OpenProcessToken || !LookupPrivilegeValue || !AdjustTokenPrivileges)
1594 if (!OpenProcessToken (GetCurrentProcess (),
1595 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
1599 if (!LookupPrivilegeValue (NULL, privilege, &restore_priv))
1602 new_priv.PrivilegeCount = 1;
1603 new_priv.Privileges[0].Luid = restore_priv;
1604 new_priv.Privileges[0].Attributes = enable ? SE_PRIVILEGE_ENABLED : 0;
1606 if (!AdjustTokenPrivileges (token_hdl, FALSE, &new_priv,
1607 sizeof orig_priv, &orig_priv, &size))
1610 /* Disabled, otherwise every `attach' in an unprivileged user session
1611 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1613 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1614 be enabled. GetLastError () returns an correct error code, though. */
1615 if (enable && GetLastError () == ERROR_NOT_ALL_ASSIGNED)
1619 ret = orig_priv.Privileges[0].Attributes == SE_PRIVILEGE_ENABLED ? 1 : 0;
1623 CloseHandle (token_hdl);
1628 /* Attach to process PID, then initialize for debugging it. */
1630 win32_attach (char *args, int from_tty)
1636 error_no_arg (_("process-id to attach"));
1638 if (set_process_privilege (SE_DEBUG_NAME, TRUE) < 0)
1640 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1641 printf_unfiltered ("This can cause attach to fail on Windows NT/2K/XP\n");
1644 pid = strtoul (args, 0, 0); /* Windows pid */
1646 win32_init_thread_list ();
1647 ok = DebugActiveProcess (pid);
1653 /* Try fall back to Cygwin pid */
1654 pid = cygwin_internal (CW_CYGWIN_PID_TO_WINPID, pid);
1657 ok = DebugActiveProcess (pid);
1662 error (_("Can't attach to process."));
1664 if (has_detach_ability ())
1665 DebugSetProcessKillOnExit (FALSE);
1671 char *exec_file = (char *) get_exec_file (0);
1674 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
1675 target_pid_to_str (pid_to_ptid (pid)));
1677 printf_unfiltered ("Attaching to %s\n",
1678 target_pid_to_str (pid_to_ptid (pid)));
1680 gdb_flush (gdb_stdout);
1683 do_initial_win32_stuff (pid);
1684 target_terminal_ours ();
1688 win32_detach (char *args, int from_tty)
1692 if (has_detach_ability ())
1695 win32_resume (ptid, 0, TARGET_SIGNAL_0);
1697 if (!DebugActiveProcessStop (current_event.dwProcessId))
1699 error (_("Can't detach process %lu (error %lu)"),
1700 current_event.dwProcessId, GetLastError ());
1703 DebugSetProcessKillOnExit (FALSE);
1705 if (detached && from_tty)
1707 char *exec_file = get_exec_file (0);
1710 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file,
1711 current_event.dwProcessId);
1712 gdb_flush (gdb_stdout);
1714 inferior_ptid = null_ptid;
1715 unpush_target (&win32_ops);
1719 win32_pid_to_exec_file (int pid)
1721 /* Try to find the process path using the Cygwin internal process list
1722 pid isn't a valid pid, unfortunately. Use current_event.dwProcessId
1725 static char path[MAX_PATH + 1];
1726 char *path_ptr = NULL;
1729 /* TODO: Also find native Windows processes using CW_GETPINFO_FULL. */
1731 struct external_pinfo *pinfo;
1733 cygwin_internal (CW_LOCK_PINFO, 1000);
1735 (pinfo = (struct external_pinfo *)
1736 cygwin_internal (CW_GETPINFO, cpid | CW_NEXTPID));
1739 if (pinfo->dwProcessId == current_event.dwProcessId) /* Got it */
1741 cygwin_conv_to_full_posix_path (pinfo->progname, path);
1746 cygwin_internal (CW_UNLOCK_PINFO);
1752 /* Print status information about what we're accessing. */
1755 win32_files_info (struct target_ops *ignore)
1757 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1758 attach_flag ? "attached" : "child", target_pid_to_str (inferior_ptid));
1762 win32_open (char *arg, int from_tty)
1764 error (_("Use the \"run\" command to start a Unix child process."));
1767 /* Start an inferior win32 child process and sets inferior_ptid to its pid.
1768 EXEC_FILE is the file to run.
1769 ALLARGS is a string containing the arguments to the program.
1770 ENV is the environment vector to pass. Errors reported with error(). */
1773 win32_create_inferior (char *exec_file, char *allargs, char **in_env,
1777 PROCESS_INFORMATION pi;
1781 char real_path[MAXPATHLEN];
1783 char shell[MAX_PATH + 1]; /* Path to shell */
1786 int ostdin, ostdout, ostderr;
1787 const char *inferior_io_terminal = get_inferior_io_terminal ();
1790 error (_("No executable specified, use `target exec'."));
1792 memset (&si, 0, sizeof (si));
1793 si.cb = sizeof (si);
1798 flags = DEBUG_ONLY_THIS_PROCESS;
1799 cygwin_conv_to_win32_path (exec_file, real_path);
1805 sh = getenv ("SHELL");
1808 cygwin_conv_to_win32_path (sh, shell);
1809 newallargs = alloca (sizeof (" -c 'exec '") + strlen (exec_file)
1810 + strlen (allargs) + 2);
1811 sprintf (newallargs, " -c 'exec %s %s'", exec_file, allargs);
1812 allargs = newallargs;
1814 flags = DEBUG_PROCESS;
1818 flags = DEBUG_ONLY_THIS_PROCESS;
1822 flags |= CREATE_NEW_PROCESS_GROUP;
1825 flags |= CREATE_NEW_CONSOLE;
1829 args = alloca (strlen (toexec) + strlen (allargs) + 2);
1830 strcpy (args, toexec);
1832 strcat (args, allargs);
1835 /* Prepare the environment vars for CreateProcess. */
1836 cygwin_internal (CW_SYNC_WINENV);
1838 if (!inferior_io_terminal)
1839 tty = ostdin = ostdout = ostderr = -1;
1842 tty = open (inferior_io_terminal, O_RDWR | O_NOCTTY);
1845 print_sys_errmsg (inferior_io_terminal, errno);
1846 ostdin = ostdout = ostderr = -1;
1860 win32_init_thread_list ();
1861 ret = CreateProcess (0,
1862 args, /* command line */
1863 NULL, /* Security */
1865 TRUE, /* inherit handles */
1866 flags, /* start flags */
1867 NULL, /* environment */
1868 NULL, /* current directory */
1886 error (_("Error creating process %s, (error %d)."),
1887 exec_file, (unsigned) GetLastError ());
1889 CloseHandle (pi.hThread);
1890 CloseHandle (pi.hProcess);
1892 if (useshell && shell[0] != '\0')
1897 do_initial_win32_stuff (pi.dwProcessId);
1899 /* win32_continue (DBG_CONTINUE, -1); */
1903 win32_mourn_inferior (void)
1905 (void) win32_continue (DBG_CONTINUE, -1);
1906 i386_cleanup_dregs();
1907 unpush_target (&win32_ops);
1908 generic_mourn_inferior ();
1911 /* Send a SIGINT to the process group. This acts just like the user typed a
1912 ^C on the controlling terminal. */
1917 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1918 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId));
1919 registers_changed (); /* refresh register state */
1923 win32_xfer_memory (CORE_ADDR memaddr, gdb_byte *our, int len,
1924 int write, struct mem_attrib *mem,
1925 struct target_ops *target)
1930 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1931 len, (DWORD) memaddr));
1932 if (!WriteProcessMemory (current_process_handle, (LPVOID) memaddr, our,
1935 FlushInstructionCache (current_process_handle, (LPCVOID) memaddr, len);
1939 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
1940 len, (DWORD) memaddr));
1941 if (!ReadProcessMemory (current_process_handle, (LPCVOID) memaddr, our,
1949 win32_kill_inferior (void)
1951 CHECK (TerminateProcess (current_process_handle, 0));
1955 if (!win32_continue (DBG_CONTINUE, -1))
1957 if (!WaitForDebugEvent (¤t_event, INFINITE))
1959 if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
1963 CHECK (CloseHandle (current_process_handle));
1965 /* this may fail in an attached process so don't check. */
1966 if (current_thread && current_thread->h)
1967 (void) CloseHandle (current_thread->h);
1968 target_mourn_inferior (); /* or just win32_mourn_inferior? */
1972 win32_prepare_to_store (struct regcache *regcache)
1974 /* Do nothing, since we can store individual regs */
1978 win32_can_run (void)
1986 DEBUG_EVENTS (("gdb: win32_close, inferior_ptid=%d\n",
1987 PIDGET (inferior_ptid)));
1990 /* Convert pid to printable format. */
1992 win32_pid_to_str (ptid_t ptid)
1994 static char buf[80];
1995 int pid = PIDGET (ptid);
1997 if ((DWORD) pid == current_event.dwProcessId)
1998 sprintf (buf, "process %d", pid);
2000 sprintf (buf, "thread %ld.0x%x", current_event.dwProcessId, pid);
2005 win32_xfer_shared_libraries (struct target_ops *ops,
2006 enum target_object object, const char *annex,
2007 gdb_byte *readbuf, const gdb_byte *writebuf,
2008 ULONGEST offset, LONGEST len)
2010 struct obstack obstack;
2018 obstack_init (&obstack);
2019 obstack_grow_str (&obstack, "<library-list>\n");
2020 for (so = solib_start.next; so; so = so->next)
2021 win32_xfer_shared_library (so->so_name, so->lm_info->load_addr, &obstack);
2022 obstack_grow_str0 (&obstack, "</library-list>\n");
2024 buf = obstack_finish (&obstack);
2025 len_avail = strlen (buf);
2026 if (offset >= len_avail)
2029 if (len > len_avail - offset)
2030 len = len_avail - offset;
2031 memcpy (readbuf, buf + offset, len);
2033 obstack_free (&obstack, NULL);
2038 win32_xfer_partial (struct target_ops *ops, enum target_object object,
2039 const char *annex, gdb_byte *readbuf,
2040 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
2044 case TARGET_OBJECT_MEMORY:
2046 return (*ops->deprecated_xfer_memory) (offset, readbuf,
2047 len, 0/*write*/, NULL, ops);
2049 return (*ops->deprecated_xfer_memory) (offset, (gdb_byte *) writebuf,
2050 len, 1/*write*/, NULL, ops);
2053 case TARGET_OBJECT_LIBRARIES:
2054 return win32_xfer_shared_libraries (ops, object, annex, readbuf,
2055 writebuf, offset, len);
2058 if (ops->beneath != NULL)
2059 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
2060 readbuf, writebuf, offset, len);
2066 init_win32_ops (void)
2068 win32_ops.to_shortname = "child";
2069 win32_ops.to_longname = "Win32 child process";
2070 win32_ops.to_doc = "Win32 child process (started by the \"run\" command).";
2071 win32_ops.to_open = win32_open;
2072 win32_ops.to_close = win32_close;
2073 win32_ops.to_attach = win32_attach;
2074 win32_ops.to_detach = win32_detach;
2075 win32_ops.to_resume = win32_resume;
2076 win32_ops.to_wait = win32_wait;
2077 win32_ops.to_fetch_registers = win32_fetch_inferior_registers;
2078 win32_ops.to_store_registers = win32_store_inferior_registers;
2079 win32_ops.to_prepare_to_store = win32_prepare_to_store;
2080 win32_ops.deprecated_xfer_memory = win32_xfer_memory;
2081 win32_ops.to_xfer_partial = win32_xfer_partial;
2082 win32_ops.to_files_info = win32_files_info;
2083 win32_ops.to_insert_breakpoint = memory_insert_breakpoint;
2084 win32_ops.to_remove_breakpoint = memory_remove_breakpoint;
2085 win32_ops.to_terminal_init = terminal_init_inferior;
2086 win32_ops.to_terminal_inferior = terminal_inferior;
2087 win32_ops.to_terminal_ours_for_output = terminal_ours_for_output;
2088 win32_ops.to_terminal_ours = terminal_ours;
2089 win32_ops.to_terminal_save_ours = terminal_save_ours;
2090 win32_ops.to_terminal_info = child_terminal_info;
2091 win32_ops.to_kill = win32_kill_inferior;
2092 win32_ops.to_create_inferior = win32_create_inferior;
2093 win32_ops.to_mourn_inferior = win32_mourn_inferior;
2094 win32_ops.to_can_run = win32_can_run;
2095 win32_ops.to_thread_alive = win32_win32_thread_alive;
2096 win32_ops.to_pid_to_str = win32_pid_to_str;
2097 win32_ops.to_stop = win32_stop;
2098 win32_ops.to_stratum = process_stratum;
2099 win32_ops.to_has_all_memory = 1;
2100 win32_ops.to_has_memory = 1;
2101 win32_ops.to_has_stack = 1;
2102 win32_ops.to_has_registers = 1;
2103 win32_ops.to_has_execution = 1;
2104 win32_ops.to_magic = OPS_MAGIC;
2105 win32_ops.to_pid_to_exec_file = win32_pid_to_exec_file;
2109 set_win32_aliases (char *argv0)
2111 add_info_alias ("dll", "sharedlibrary", 1);
2115 _initialize_win32_nat (void)
2117 struct cmd_list_element *c;
2121 c = add_com ("dll-symbols", class_files, dll_symbol_command,
2122 _("Load dll library symbols from FILE."));
2123 set_cmd_completer (c, filename_completer);
2125 add_com_alias ("sharedlibrary", "dll-symbols", class_alias, 1);
2128 add_setshow_boolean_cmd ("shell", class_support, &useshell, _("\
2129 Set use of shell to start subprocess."), _("\
2130 Show use of shell to start subprocess."), NULL,
2132 NULL, /* FIXME: i18n: */
2133 &setlist, &showlist);
2135 add_setshow_boolean_cmd ("cygwin-exceptions", class_support, &cygwin_exceptions, _("\
2136 Break when an exception is detected in the Cygwin DLL itself."), _("\
2137 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL,
2139 NULL, /* FIXME: i18n: */
2140 &setlist, &showlist);
2143 add_setshow_boolean_cmd ("new-console", class_support, &new_console, _("\
2144 Set creation of new console when creating child process."), _("\
2145 Show creation of new console when creating child process."), NULL,
2147 NULL, /* FIXME: i18n: */
2148 &setlist, &showlist);
2150 add_setshow_boolean_cmd ("new-group", class_support, &new_group, _("\
2151 Set creation of new group when creating child process."), _("\
2152 Show creation of new group when creating child process."), NULL,
2154 NULL, /* FIXME: i18n: */
2155 &setlist, &showlist);
2157 add_setshow_boolean_cmd ("debugexec", class_support, &debug_exec, _("\
2158 Set whether to display execution in child process."), _("\
2159 Show whether to display execution in child process."), NULL,
2161 NULL, /* FIXME: i18n: */
2162 &setlist, &showlist);
2164 add_setshow_boolean_cmd ("debugevents", class_support, &debug_events, _("\
2165 Set whether to display kernel events in child process."), _("\
2166 Show whether to display kernel events in child process."), NULL,
2168 NULL, /* FIXME: i18n: */
2169 &setlist, &showlist);
2171 add_setshow_boolean_cmd ("debugmemory", class_support, &debug_memory, _("\
2172 Set whether to display memory accesses in child process."), _("\
2173 Show whether to display memory accesses in child process."), NULL,
2175 NULL, /* FIXME: i18n: */
2176 &setlist, &showlist);
2178 add_setshow_boolean_cmd ("debugexceptions", class_support,
2179 &debug_exceptions, _("\
2180 Set whether to display kernel exceptions in child process."), _("\
2181 Show whether to display kernel exceptions in child process."), NULL,
2183 NULL, /* FIXME: i18n: */
2184 &setlist, &showlist);
2186 add_prefix_cmd ("w32", class_info, info_w32_command,
2187 _("Print information specific to Win32 debugging."),
2188 &info_w32_cmdlist, "info w32 ", 0, &infolist);
2190 add_cmd ("selector", class_info, display_selectors,
2191 _("Display selectors infos."),
2193 add_target (&win32_ops);
2194 deprecated_init_ui_hook = set_win32_aliases;
2197 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2199 /* Pass the address ADDR to the inferior in the I'th debug register.
2200 Here we just store the address in dr array, the registers will be
2201 actually set up when win32_continue is called. */
2203 cygwin_set_dr (int i, CORE_ADDR addr)
2206 internal_error (__FILE__, __LINE__,
2207 _("Invalid register %d in cygwin_set_dr.\n"), i);
2208 dr[i] = (unsigned) addr;
2209 debug_registers_changed = 1;
2210 debug_registers_used = 1;
2213 /* Pass the value VAL to the inferior in the DR7 debug control
2214 register. Here we just store the address in D_REGS, the watchpoint
2215 will be actually set up in win32_wait. */
2217 cygwin_set_dr7 (unsigned val)
2220 debug_registers_changed = 1;
2221 debug_registers_used = 1;
2224 /* Get the value of the DR6 debug status register from the inferior.
2225 Here we just return the value stored in dr[6]
2226 by the last call to thread_rec for current_event.dwThreadId id. */
2228 cygwin_get_dr6 (void)
2233 /* Determine if the thread referenced by "pid" is alive
2234 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2235 it means that the pid has died. Otherwise it is assumed to be alive. */
2237 win32_win32_thread_alive (ptid_t ptid)
2239 int pid = PIDGET (ptid);
2241 return WaitForSingleObject (thread_rec (pid, FALSE)->h, 0) == WAIT_OBJECT_0 ?
2246 _initialize_check_for_gdb_ini (void)
2249 if (inhibit_gdbinit)
2252 homedir = getenv ("HOME");
2256 char *oldini = (char *) alloca (strlen (homedir) +
2257 sizeof ("/gdb.ini"));
2258 strcpy (oldini, homedir);
2259 p = strchr (oldini, '\0');
2260 if (p > oldini && p[-1] != '/')
2262 strcpy (p, "gdb.ini");
2263 if (access (oldini, 0) == 0)
2265 int len = strlen (oldini);
2266 char *newini = alloca (len + 1);
2267 sprintf (newini, "%.*s.gdbinit",
2268 (int) (len - (sizeof ("gdb.ini") - 1)), oldini);
2269 warning (_("obsolete '%s' found. Rename to '%s'."), oldini, newini);