1 /* Target-vector operations for controlling windows child processes, for GDB.
3 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
4 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
6 Contributed by Cygnus Solutions, A Red Hat Company.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 /* Originally by Steve Chamberlain, sac@cygnus.com */
26 #include "frame.h" /* required by inferior.h */
29 #include "exceptions.h"
32 #include "completer.h"
36 #include <sys/types.h>
43 #include <sys/cygwin.h>
50 #include "gdb_obstack.h"
51 #include "gdb_string.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 "windows-tdep.h"
65 #include "windows-nat.h"
67 #include "complaints.h"
69 #define AdjustTokenPrivileges dyn_AdjustTokenPrivileges
70 #define DebugActiveProcessStop dyn_DebugActiveProcessStop
71 #define DebugBreakProcess dyn_DebugBreakProcess
72 #define DebugSetProcessKillOnExit dyn_DebugSetProcessKillOnExit
73 #define EnumProcessModules dyn_EnumProcessModules
75 #define GetModuleFileNameExA dyn_GetModuleFileNameExA
77 #define GetModuleFileNameExW dyn_GetModuleFileNameExW
79 #define GetModuleInformation dyn_GetModuleInformation
80 #define LookupPrivilegeValueA dyn_LookupPrivilegeValueA
81 #define OpenProcessToken dyn_OpenProcessToken
83 static BOOL
WINAPI (*AdjustTokenPrivileges
)(HANDLE
, BOOL
, PTOKEN_PRIVILEGES
,
84 DWORD
, PTOKEN_PRIVILEGES
, PDWORD
);
85 static BOOL
WINAPI (*DebugActiveProcessStop
) (DWORD
);
86 static BOOL
WINAPI (*DebugBreakProcess
) (HANDLE
);
87 static BOOL
WINAPI (*DebugSetProcessKillOnExit
) (BOOL
);
88 static BOOL
WINAPI (*EnumProcessModules
) (HANDLE
, HMODULE
*, DWORD
,
91 static DWORD
WINAPI (*GetModuleFileNameExA
) (HANDLE
, HMODULE
, LPSTR
,
94 static DWORD
WINAPI (*GetModuleFileNameExW
) (HANDLE
, HMODULE
, LPWSTR
,
97 static BOOL
WINAPI (*GetModuleInformation
) (HANDLE
, HMODULE
, LPMODULEINFO
,
99 static BOOL
WINAPI (*LookupPrivilegeValueA
)(LPCSTR
, LPCSTR
, PLUID
);
100 static BOOL
WINAPI (*OpenProcessToken
)(HANDLE
, DWORD
, PHANDLE
);
102 static struct target_ops windows_ops
;
105 /* The starting and ending address of the cygwin1.dll text segment. */
106 static CORE_ADDR cygwin_load_start
;
107 static CORE_ADDR cygwin_load_end
;
110 static int have_saved_context
; /* True if we've saved context from a cygwin signal. */
111 static CONTEXT saved_context
; /* Containes the saved context from a cygwin signal. */
113 /* If we're not using the old Cygwin header file set, define the
114 following which never should have been in the generic Win32 API
115 headers in the first place since they were our own invention... */
116 #ifndef _GNU_H_WINDOWS_H
119 FLAG_TRACE_BIT
= 0x100,
120 CONTEXT_DEBUGGER
= (CONTEXT_FULL
| CONTEXT_FLOATING_POINT
)
124 #ifndef CONTEXT_EXTENDED_REGISTERS
125 /* This macro is only defined on ia32. It only makes sense on this target,
126 so define it as zero if not already defined. */
127 #define CONTEXT_EXTENDED_REGISTERS 0
130 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \
131 | CONTEXT_EXTENDED_REGISTERS
133 static uintptr_t dr
[8];
134 static int debug_registers_changed
;
135 static int debug_registers_used
;
137 static int windows_initialization_done
;
138 #define DR6_CLEAR_VALUE 0xffff0ff0
140 /* The string sent by cygwin when it processes a signal.
141 FIXME: This should be in a cygwin include file. */
142 #ifndef _CYGWIN_SIGNAL_STRING
143 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
146 #define CHECK(x) check (x, __FILE__,__LINE__)
147 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
148 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
149 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
150 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
152 static void windows_stop (ptid_t
);
153 static int windows_thread_alive (struct target_ops
*, ptid_t
);
154 static void windows_kill_inferior (struct target_ops
*);
156 static void cygwin_set_dr (int i
, CORE_ADDR addr
);
157 static void cygwin_set_dr7 (unsigned long val
);
158 static unsigned long cygwin_get_dr6 (void);
160 static enum target_signal last_sig
= TARGET_SIGNAL_0
;
161 /* Set if a signal was received from the debugged process */
163 /* Thread information structure used to track information that is
164 not available in gdb's thread structure. */
165 typedef struct thread_info_struct
167 struct thread_info_struct
*next
;
178 static thread_info thread_head
;
180 /* The process and thread handles for the above context. */
182 static DEBUG_EVENT current_event
; /* The current debug event from
184 static HANDLE current_process_handle
; /* Currently executing process */
185 static thread_info
*current_thread
; /* Info on currently selected thread */
186 static DWORD main_thread_id
; /* Thread ID of the main thread */
188 /* Counts of things. */
189 static int exception_count
= 0;
190 static int event_count
= 0;
191 static int saw_create
;
192 static int open_process_used
= 0;
195 static int new_console
= 0;
197 static int cygwin_exceptions
= 0;
199 static int new_group
= 1;
200 static int debug_exec
= 0; /* show execution */
201 static int debug_events
= 0; /* show events from kernel */
202 static int debug_memory
= 0; /* show target memory accesses */
203 static int debug_exceptions
= 0; /* show target exceptions */
204 static int useshell
= 0; /* use shell for subprocesses */
206 /* This vector maps GDB's idea of a register's number into an offset
207 in the windows exception context vector.
209 It also contains the bit mask needed to load the register in question.
211 The contents of this table can only be computed by the units
212 that provide CPU-specific support for Windows native debugging.
213 These units should set the table by calling
214 windows_set_context_register_offsets.
216 One day we could read a reg, we could inspect the context we
217 already have loaded, if it doesn't have the bit set that we need,
218 we read that set of registers in using GetThreadContext. If the
219 context already contains what we need, we just unpack it. Then to
220 write a register, first we have to ensure that the context contains
221 the other regs of the group, and then we copy the info in and set
224 static const int *mappings
;
226 /* This vector maps the target's idea of an exception (extracted
227 from the DEBUG_EVENT structure) to GDB's idea. */
229 struct xlate_exception
232 enum target_signal us
;
235 static const struct xlate_exception
238 {EXCEPTION_ACCESS_VIOLATION
, TARGET_SIGNAL_SEGV
},
239 {STATUS_STACK_OVERFLOW
, TARGET_SIGNAL_SEGV
},
240 {EXCEPTION_BREAKPOINT
, TARGET_SIGNAL_TRAP
},
241 {DBG_CONTROL_C
, TARGET_SIGNAL_INT
},
242 {EXCEPTION_SINGLE_STEP
, TARGET_SIGNAL_TRAP
},
243 {STATUS_FLOAT_DIVIDE_BY_ZERO
, TARGET_SIGNAL_FPE
},
246 /* Set the MAPPINGS static global to OFFSETS.
247 See the description of MAPPINGS for more details. */
250 windows_set_context_register_offsets (const int *offsets
)
256 check (BOOL ok
, const char *file
, int line
)
259 printf_filtered ("error return %s:%d was %lu\n", file
, line
,
263 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
264 then also retrieve the context for this thread. If GET_CONTEXT is
265 negative, then don't suspend the thread. */
267 thread_rec (DWORD id
, int get_context
)
271 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
274 if (!th
->suspended
&& get_context
)
276 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
278 if (SuspendThread (th
->h
) == (DWORD
) -1)
280 DWORD err
= GetLastError ();
281 warning (_("SuspendThread failed. (winerr %d)"),
287 else if (get_context
< 0)
289 th
->reload_context
= 1;
297 /* Add a thread to the thread list. */
299 windows_add_thread (ptid_t ptid
, HANDLE h
)
304 gdb_assert (ptid_get_tid (ptid
) != 0);
306 id
= ptid_get_tid (ptid
);
308 if ((th
= thread_rec (id
, FALSE
)))
311 th
= XZALLOC (thread_info
);
314 th
->next
= thread_head
.next
;
315 thread_head
.next
= th
;
317 /* Set the debug registers for the new thread if they are used. */
318 if (debug_registers_used
)
320 /* Only change the value of the debug registers. */
321 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
322 CHECK (GetThreadContext (th
->h
, &th
->context
));
323 th
->context
.Dr0
= dr
[0];
324 th
->context
.Dr1
= dr
[1];
325 th
->context
.Dr2
= dr
[2];
326 th
->context
.Dr3
= dr
[3];
327 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
328 th
->context
.Dr7
= dr
[7];
329 CHECK (SetThreadContext (th
->h
, &th
->context
));
330 th
->context
.ContextFlags
= 0;
335 /* Clear out any old thread list and reintialize it to a
338 windows_init_thread_list (void)
340 thread_info
*th
= &thread_head
;
342 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
344 while (th
->next
!= NULL
)
346 thread_info
*here
= th
->next
;
347 th
->next
= here
->next
;
350 thread_head
.next
= NULL
;
353 /* Delete a thread from the list of threads */
355 windows_delete_thread (ptid_t ptid
)
360 gdb_assert (ptid_get_tid (ptid
) != 0);
362 id
= ptid_get_tid (ptid
);
365 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
));
366 delete_thread (ptid
);
368 for (th
= &thread_head
;
369 th
->next
!= NULL
&& th
->next
->id
!= id
;
373 if (th
->next
!= NULL
)
375 thread_info
*here
= th
->next
;
376 th
->next
= here
->next
;
382 do_windows_fetch_inferior_registers (struct regcache
*regcache
, int r
)
384 char *context_offset
= ((char *) ¤t_thread
->context
) + mappings
[r
];
385 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
386 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
390 return; /* Windows sometimes uses a non-existent thread id in its
393 if (current_thread
->reload_context
)
395 #ifdef __COPY_CONTEXT_SIZE
396 if (have_saved_context
)
398 /* Lie about where the program actually is stopped since cygwin has informed us that
399 we should consider the signal to have occurred at another location which is stored
400 in "saved_context. */
401 memcpy (¤t_thread
->context
, &saved_context
, __COPY_CONTEXT_SIZE
);
402 have_saved_context
= 0;
407 thread_info
*th
= current_thread
;
408 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
409 GetThreadContext (th
->h
, &th
->context
);
410 /* Copy dr values from that thread.
411 But only if there were not modified since last stop. PR gdb/2388 */
412 if (!debug_registers_changed
)
414 dr
[0] = th
->context
.Dr0
;
415 dr
[1] = th
->context
.Dr1
;
416 dr
[2] = th
->context
.Dr2
;
417 dr
[3] = th
->context
.Dr3
;
418 dr
[6] = th
->context
.Dr6
;
419 dr
[7] = th
->context
.Dr7
;
422 current_thread
->reload_context
= 0;
425 if (r
== I387_FISEG_REGNUM (tdep
))
427 l
= *((long *) context_offset
) & 0xffff;
428 regcache_raw_supply (regcache
, r
, (char *) &l
);
430 else if (r
== I387_FOP_REGNUM (tdep
))
432 l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
433 regcache_raw_supply (regcache
, r
, (char *) &l
);
436 regcache_raw_supply (regcache
, r
, context_offset
);
439 for (r
= 0; r
< gdbarch_num_regs (gdbarch
); r
++)
440 do_windows_fetch_inferior_registers (regcache
, r
);
445 windows_fetch_inferior_registers (struct target_ops
*ops
,
446 struct regcache
*regcache
, int r
)
448 current_thread
= thread_rec (ptid_get_tid (inferior_ptid
), TRUE
);
449 /* Check if current_thread exists. Windows sometimes uses a non-existent
450 thread id in its events */
452 do_windows_fetch_inferior_registers (regcache
, r
);
456 do_windows_store_inferior_registers (const struct regcache
*regcache
, int r
)
459 /* Windows sometimes uses a non-existent thread id in its events */;
461 regcache_raw_collect (regcache
, r
,
462 ((char *) ¤t_thread
->context
) + mappings
[r
]);
465 for (r
= 0; r
< gdbarch_num_regs (get_regcache_arch (regcache
)); r
++)
466 do_windows_store_inferior_registers (regcache
, r
);
470 /* Store a new register value into the current thread context */
472 windows_store_inferior_registers (struct target_ops
*ops
,
473 struct regcache
*regcache
, int r
)
475 current_thread
= thread_rec (ptid_get_tid (inferior_ptid
), TRUE
);
476 /* Check if current_thread exists. Windows sometimes uses a non-existent
477 thread id in its events */
479 do_windows_store_inferior_registers (regcache
, r
);
482 /* Get the name of a given module at at given base address. If base_address
483 is zero return the first loaded module (which is always the name of the
486 get_module_name (LPVOID base_address
, char *dll_name_ret
)
492 HMODULE
*DllHandle
= dh_buf
; /* Set to temporary storage for initial query */
495 wchar_t pathbuf
[PATH_MAX
]; /* Temporary storage prior to converting to
496 posix form. PATH_MAX is always enough
497 as long as SO_NAME_MAX_PATH_SIZE is defined
502 /* Find size of buffer needed to handle list of modules loaded in inferior */
503 if (!EnumProcessModules (current_process_handle
, DllHandle
,
504 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
507 /* Allocate correct amount of space for module list */
508 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
512 /* Get the list of modules */
513 if (!EnumProcessModules (current_process_handle
, DllHandle
, cbNeeded
,
517 for (i
= 0; i
< (int) (cbNeeded
/ sizeof (HMODULE
)); i
++)
519 /* Get information on this module */
520 if (!GetModuleInformation (current_process_handle
, DllHandle
[i
],
522 error (_("Can't get module info"));
524 if (!base_address
|| mi
.lpBaseOfDll
== base_address
)
526 /* Try to find the name of the given module */
528 /* Cygwin prefers that the path be in /x/y/z format */
529 len
= GetModuleFileNameExW (current_process_handle
,
530 DllHandle
[i
], pathbuf
, PATH_MAX
);
532 error (_("Error getting dll name: %lu."), GetLastError ());
533 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, dll_name_ret
,
535 error (_("Error converting dll name to POSIX: %d."), errno
);
537 len
= GetModuleFileNameExA (current_process_handle
,
538 DllHandle
[i
], dll_name_ret
, MAX_PATH
);
540 error (_("Error getting dll name: %u."), (unsigned) GetLastError ());
542 return 1; /* success */
547 dll_name_ret
[0] = '\0';
548 return 0; /* failure */
551 /* Encapsulate the information required in a call to
552 symbol_file_add_args */
553 struct safe_symbol_file_add_args
557 struct section_addr_info
*addrs
;
560 struct ui_file
*err
, *out
;
564 /* Maintain a linked list of "so" information. */
570 static struct so_list solib_start
, *solib_end
;
572 /* Call symbol_file_add with stderr redirected. We don't care if there
575 safe_symbol_file_add_stub (void *argv
)
577 #define p ((struct safe_symbol_file_add_args *) argv)
578 const int add_flags
= ((p
->from_tty
? SYMFILE_VERBOSE
: 0)
579 | (p
->mainline
? SYMFILE_MAINLINE
: 0));
580 p
->ret
= symbol_file_add (p
->name
, add_flags
, p
->addrs
, p
->flags
);
585 /* Restore gdb's stderr after calling symbol_file_add */
587 safe_symbol_file_add_cleanup (void *p
)
589 #define sp ((struct safe_symbol_file_add_args *)p)
590 gdb_flush (gdb_stderr
);
591 gdb_flush (gdb_stdout
);
592 ui_file_delete (gdb_stderr
);
593 ui_file_delete (gdb_stdout
);
594 gdb_stderr
= sp
->err
;
595 gdb_stdout
= sp
->out
;
599 /* symbol_file_add wrapper that prevents errors from being displayed. */
600 static struct objfile
*
601 safe_symbol_file_add (char *name
, int from_tty
,
602 struct section_addr_info
*addrs
,
603 int mainline
, int flags
)
605 struct safe_symbol_file_add_args p
;
606 struct cleanup
*cleanup
;
608 cleanup
= make_cleanup (safe_symbol_file_add_cleanup
, &p
);
612 gdb_flush (gdb_stderr
);
613 gdb_flush (gdb_stdout
);
614 gdb_stderr
= ui_file_new ();
615 gdb_stdout
= ui_file_new ();
617 p
.from_tty
= from_tty
;
619 p
.mainline
= mainline
;
621 catch_errors (safe_symbol_file_add_stub
, &p
, "", RETURN_MASK_ERROR
);
623 do_cleanups (cleanup
);
627 static struct so_list
*
628 windows_make_so (const char *name
, LPVOID load_addr
)
633 char buf
[MAX_PATH
+ 1];
634 char cwd
[MAX_PATH
+ 1];
635 WIN32_FIND_DATA w32_fd
;
636 HANDLE h
= FindFirstFile(name
, &w32_fd
);
638 if (h
== INVALID_HANDLE_VALUE
)
644 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
646 p
= strrchr (buf
, '\\');
649 SetCurrentDirectory (buf
);
650 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
651 SetCurrentDirectory (cwd
);
654 if (strcasecmp (buf
, "ntdll.dll") == 0)
656 GetSystemDirectory (buf
, sizeof (buf
));
657 strcat (buf
, "\\ntdll.dll");
660 wchar_t buf
[PATH_MAX
];
663 if (access (name
, F_OK
) != 0)
665 if (strcasecmp (name
, "ntdll.dll") == 0)
667 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
668 wcscat (buf
, L
"\\ntdll.dll");
672 so
= XZALLOC (struct so_list
);
673 so
->lm_info
= (struct lm_info
*) xmalloc (sizeof (struct lm_info
));
674 so
->lm_info
->load_addr
= load_addr
;
675 strcpy (so
->so_original_name
, name
);
677 strcpy (so
->so_name
, buf
);
680 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
681 SO_NAME_MAX_PATH_SIZE
);
684 char *rname
= canonicalize_file_name (name
);
685 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
687 strcpy (so
->so_name
, rname
);
691 error (_("dll path too long"));
693 /* Record cygwin1.dll .text start/end. */
694 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
695 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
698 asection
*text
= NULL
;
701 abfd
= bfd_openr (so
->so_name
, "pei-i386");
706 if (bfd_check_format (abfd
, bfd_object
))
707 text
= bfd_get_section_by_name (abfd
, ".text");
715 /* The symbols in a dll are offset by 0x1000, which is the the
716 offset from 0 of the first byte in an image - because of the
717 file header and the section alignment. */
718 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *) load_addr
+ 0x1000);
719 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (abfd
, text
);
729 get_image_name (HANDLE h
, void *address
, int unicode
)
732 static char buf
[PATH_MAX
];
734 static char buf
[(2 * MAX_PATH
) + 1];
736 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
742 /* Attempt to read the name of the dll that was detected.
743 This is documented to work only when actively debugging
744 a program. It will not work for attached processes. */
748 /* See if we could read the address of a string, and that the
749 address isn't null. */
750 if (!ReadProcessMemory (h
, address
, &address_ptr
, sizeof (address_ptr
), &done
)
751 || done
!= sizeof (address_ptr
) || !address_ptr
)
754 /* Find the length of the string */
755 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
756 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
760 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
763 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
764 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
767 wcstombs (buf
, unicode_address
, PATH_MAX
);
769 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
777 /* Wait for child to do something. Return pid of child, or -1 in case
778 of error; store status through argument pointer OURSTATUS. */
780 handle_load_dll (void *dummy
)
782 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
784 char dll_buf
[PATH_MAX
];
786 char dll_buf
[MAX_PATH
+ 1];
788 char *dll_name
= NULL
;
790 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
792 if (!get_module_name (event
->lpBaseOfDll
, dll_buf
))
793 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
797 if (*dll_name
== '\0')
798 dll_name
= get_image_name (current_process_handle
,
799 event
->lpImageName
, event
->fUnicode
);
803 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
804 solib_end
= solib_end
->next
;
806 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
807 host_address_to_string (solib_end
->lm_info
->load_addr
)));
813 windows_free_so (struct so_list
*so
)
821 handle_unload_dll (void *dummy
)
823 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
826 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
827 if (so
->next
->lm_info
->load_addr
== lpBaseOfDll
)
829 struct so_list
*sodel
= so
->next
;
830 so
->next
= sodel
->next
;
833 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
835 windows_free_so (sodel
);
836 solib_add (NULL
, 0, NULL
, auto_solib_add
);
840 /* We did not find any DLL that was previously loaded at this address,
841 so register a complaint. We do not report an error, because we have
842 observed that this may be happening under some circumstances. For
843 instance, running 32bit applications on x64 Windows causes us to receive
844 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
845 events are apparently caused by the WOW layer, the interface between
846 32bit and 64bit worlds). */
847 complaint (&symfile_complaints
, _("dll starting at %s not found."),
848 host_address_to_string (lpBaseOfDll
));
853 /* Clear list of loaded DLLs. */
855 windows_clear_solib (void)
857 solib_start
.next
= NULL
;
858 solib_end
= &solib_start
;
861 /* Load DLL symbol info. */
863 dll_symbol_command (char *args
, int from_tty
)
869 error (_("dll-symbols requires a file name"));
872 if (n
> 4 && strcasecmp (args
+ n
- 4, ".dll") != 0)
874 char *newargs
= (char *) alloca (n
+ 4 + 1);
875 strcpy (newargs
, args
);
876 strcat (newargs
, ".dll");
880 safe_symbol_file_add (args
, from_tty
, NULL
, 0, OBJF_SHARED
| OBJF_USERLOADED
);
883 /* Handle DEBUG_STRING output from child process.
884 Cygwin prepends its messages with a "cygwin:". Interpret this as
885 a Cygwin signal. Otherwise just print the string as a warning. */
887 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
892 if (!target_read_string
893 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
897 else if (strncmp (s
, _CYGWIN_SIGNAL_STRING
, sizeof (_CYGWIN_SIGNAL_STRING
) - 1) != 0)
900 if (strncmp (s
, "cYg", 3) != 0)
904 #ifdef __COPY_CONTEXT_SIZE
907 /* Got a cygwin signal marker. A cygwin signal is followed by the signal number
908 itself and then optionally followed by the thread id and address to saved context
909 within the DLL. If these are supplied, then the given thread is assumed to have
910 issued the signal and the context from the thread is assumed to be stored at the
911 given address in the inferior. Tell gdb to treat this like a real signal. */
913 int sig
= strtol (s
+ sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
914 int gotasig
= target_signal_from_host (sig
);
915 ourstatus
->value
.sig
= gotasig
;
920 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
921 retval
= strtoul (p
, &p
, 0);
923 retval
= main_thread_id
;
924 else if ((x
= (LPCVOID
) strtoul (p
, &p
, 0))
925 && ReadProcessMemory (current_process_handle
, x
,
926 &saved_context
, __COPY_CONTEXT_SIZE
, &n
)
927 && n
== __COPY_CONTEXT_SIZE
)
928 have_saved_context
= 1;
929 current_event
.dwThreadId
= retval
;
940 display_selector (HANDLE thread
, DWORD sel
)
943 if (GetThreadSelectorEntry (thread
, sel
, &info
))
946 printf_filtered ("0x%03lx: ", sel
);
947 if (!info
.HighWord
.Bits
.Pres
)
949 puts_filtered ("Segment not present\n");
952 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
953 (info
.HighWord
.Bits
.BaseMid
<< 16)
955 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
956 if (info
.HighWord
.Bits
.Granularity
)
957 limit
= (limit
<< 12) | 0xfff;
958 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
959 if (info
.HighWord
.Bits
.Default_Big
)
960 puts_filtered(" 32-bit ");
962 puts_filtered(" 16-bit ");
963 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
966 puts_filtered ("Data (Read-Only, Exp-up");
969 puts_filtered ("Data (Read/Write, Exp-up");
972 puts_filtered ("Unused segment (");
975 puts_filtered ("Data (Read/Write, Exp-down");
978 puts_filtered ("Code (Exec-Only, N.Conf");
981 puts_filtered ("Code (Exec/Read, N.Conf");
984 puts_filtered ("Code (Exec-Only, Conf");
987 puts_filtered ("Code (Exec/Read, Conf");
990 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
992 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
993 puts_filtered(", N.Acc");
994 puts_filtered (")\n");
995 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
996 puts_filtered("System selector ");
997 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
998 if (info
.HighWord
.Bits
.Granularity
)
999 puts_filtered ("Page granular.\n");
1001 puts_filtered ("Byte granular.\n");
1006 printf_filtered ("Invalid selector 0x%lx.\n",sel
);
1012 display_selectors (char * args
, int from_tty
)
1014 if (!current_thread
)
1016 puts_filtered ("Impossible to display selectors now.\n");
1022 puts_filtered ("Selector $cs\n");
1023 display_selector (current_thread
->h
,
1024 current_thread
->context
.SegCs
);
1025 puts_filtered ("Selector $ds\n");
1026 display_selector (current_thread
->h
,
1027 current_thread
->context
.SegDs
);
1028 puts_filtered ("Selector $es\n");
1029 display_selector (current_thread
->h
,
1030 current_thread
->context
.SegEs
);
1031 puts_filtered ("Selector $ss\n");
1032 display_selector (current_thread
->h
,
1033 current_thread
->context
.SegSs
);
1034 puts_filtered ("Selector $fs\n");
1035 display_selector (current_thread
->h
,
1036 current_thread
->context
.SegFs
);
1037 puts_filtered ("Selector $gs\n");
1038 display_selector (current_thread
->h
,
1039 current_thread
->context
.SegGs
);
1044 sel
= parse_and_eval_long (args
);
1045 printf_filtered ("Selector \"%s\"\n",args
);
1046 display_selector (current_thread
->h
, sel
);
1050 static struct cmd_list_element
*info_w32_cmdlist
= NULL
;
1053 info_w32_command (char *args
, int from_tty
)
1055 help_list (info_w32_cmdlist
, "info w32 ", class_info
, gdb_stdout
);
1059 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1060 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1061 host_address_to_string (\
1062 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1065 handle_exception (struct target_waitstatus
*ourstatus
)
1068 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1070 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1072 /* Record the context of the current thread */
1073 th
= thread_rec (current_event
.dwThreadId
, -1);
1077 case EXCEPTION_ACCESS_VIOLATION
:
1078 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1079 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1082 /* See if the access violation happened within the cygwin DLL itself. Cygwin uses
1083 a kind of exception handling to deal with passed-in invalid addresses. gdb
1084 should not treat these as real SEGVs since they will be silently handled by
1085 cygwin. A real SEGV will (theoretically) be caught by cygwin later in the process
1086 and will be sent as a cygwin-specific-signal. So, ignore SEGVs if they show up
1087 within the text segment of the DLL itself. */
1089 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
;
1090 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
&& addr
< cygwin_load_end
))
1091 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1092 && strncmp (fn
, "KERNEL32!IsBad", strlen ("KERNEL32!IsBad")) == 0))
1097 case STATUS_STACK_OVERFLOW
:
1098 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1099 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1101 case STATUS_FLOAT_DENORMAL_OPERAND
:
1102 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1103 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1105 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1106 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1107 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1109 case STATUS_FLOAT_INEXACT_RESULT
:
1110 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1111 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1113 case STATUS_FLOAT_INVALID_OPERATION
:
1114 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1115 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1117 case STATUS_FLOAT_OVERFLOW
:
1118 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1119 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1121 case STATUS_FLOAT_STACK_CHECK
:
1122 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1123 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1125 case STATUS_FLOAT_UNDERFLOW
:
1126 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1127 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1129 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1130 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1131 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1133 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1134 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1135 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1137 case STATUS_INTEGER_OVERFLOW
:
1138 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1139 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1141 case EXCEPTION_BREAKPOINT
:
1142 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1143 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1146 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1147 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1149 case DBG_CONTROL_BREAK
:
1150 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1151 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1153 case EXCEPTION_SINGLE_STEP
:
1154 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1155 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1157 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1158 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1159 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1161 case EXCEPTION_PRIV_INSTRUCTION
:
1162 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1163 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1165 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1166 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1167 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1170 /* Treat unhandled first chance exceptions specially. */
1171 if (current_event
.u
.Exception
.dwFirstChance
)
1173 printf_unfiltered ("gdb: unknown target exception 0x%08lx at %s\n",
1174 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1175 host_address_to_string (
1176 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1177 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1181 last_sig
= ourstatus
->value
.sig
;
1185 /* Resume all artificially suspended threads if we are continuing
1188 windows_continue (DWORD continue_status
, int id
)
1194 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%lx, %s);\n",
1195 current_event
.dwProcessId
, current_event
.dwThreadId
,
1196 continue_status
== DBG_CONTINUE
?
1197 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1199 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1200 if ((id
== -1 || id
== (int) th
->id
)
1203 if (debug_registers_changed
)
1205 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1206 th
->context
.Dr0
= dr
[0];
1207 th
->context
.Dr1
= dr
[1];
1208 th
->context
.Dr2
= dr
[2];
1209 th
->context
.Dr3
= dr
[3];
1210 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1211 th
->context
.Dr7
= dr
[7];
1213 if (th
->context
.ContextFlags
)
1215 CHECK (SetThreadContext (th
->h
, &th
->context
));
1216 th
->context
.ContextFlags
= 0;
1218 if (th
->suspended
> 0)
1219 (void) ResumeThread (th
->h
);
1223 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1224 current_event
.dwThreadId
,
1227 debug_registers_changed
= 0;
1231 /* Called in pathological case where Windows fails to send a
1232 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1234 fake_create_process (void)
1236 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1237 current_event
.dwProcessId
);
1238 if (current_process_handle
!= NULL
)
1239 open_process_used
= 1;
1242 error (_("OpenProcess call failed, GetLastError = %lud\n"),
1244 /* We can not debug anything in that case. */
1246 main_thread_id
= current_event
.dwThreadId
;
1247 current_thread
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1248 current_event
.dwThreadId
),
1249 current_event
.u
.CreateThread
.hThread
);
1250 return main_thread_id
;
1254 windows_resume (struct target_ops
*ops
,
1255 ptid_t ptid
, int step
, enum target_signal sig
)
1258 DWORD continue_status
= DBG_CONTINUE
;
1260 /* A specific PTID means `step only this thread id'. */
1261 int resume_all
= ptid_equal (ptid
, minus_one_ptid
);
1263 /* If we're continuing all threads, it's the current inferior that
1264 should be handled specially. */
1266 ptid
= inferior_ptid
;
1268 if (sig
!= TARGET_SIGNAL_0
)
1270 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1272 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1274 else if (sig
== last_sig
)
1275 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1278 /* This code does not seem to work, because
1279 the kernel does probably not consider changes in the ExceptionRecord
1280 structure when passing the exception to the inferior.
1281 Note that this seems possible in the exception handler itself. */
1284 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1285 if (xlate
[i
].us
== sig
)
1287 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
=
1289 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1292 if (continue_status
== DBG_CONTINUE
)
1294 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1298 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1302 last_sig
= TARGET_SIGNAL_0
;
1304 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1305 ptid_get_pid (ptid
), ptid_get_tid (ptid
), step
, sig
));
1307 /* Get context for currently selected thread */
1308 th
= thread_rec (ptid_get_tid (inferior_ptid
), FALSE
);
1313 /* Single step by setting t bit */
1314 struct regcache
*regcache
= get_current_regcache ();
1315 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1316 windows_fetch_inferior_registers (ops
, regcache
,
1317 gdbarch_ps_regnum (gdbarch
));
1318 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1321 if (th
->context
.ContextFlags
)
1323 if (debug_registers_changed
)
1325 th
->context
.Dr0
= dr
[0];
1326 th
->context
.Dr1
= dr
[1];
1327 th
->context
.Dr2
= dr
[2];
1328 th
->context
.Dr3
= dr
[3];
1329 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1330 th
->context
.Dr7
= dr
[7];
1332 CHECK (SetThreadContext (th
->h
, &th
->context
));
1333 th
->context
.ContextFlags
= 0;
1337 /* Allow continuing with the same signal that interrupted us.
1338 Otherwise complain. */
1341 windows_continue (continue_status
, -1);
1343 windows_continue (continue_status
, ptid_get_tid (ptid
));
1346 /* Ctrl-C handler used when the inferior is not run in the same console. The
1347 handler is in charge of interrupting the inferior using DebugBreakProcess.
1348 Note that this function is not available prior to Windows XP. In this case
1349 we emit a warning. */
1351 ctrl_c_handler (DWORD event_type
)
1353 const int attach_flag
= current_inferior ()->attach_flag
;
1355 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1356 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1359 /* If the inferior and the debugger share the same console, do nothing as
1360 the inferior has also received the Ctrl-C event. */
1361 if (!new_console
&& !attach_flag
)
1364 if (!DebugBreakProcess (current_process_handle
))
1366 Could not interrupt program. Press Ctrl-c in the program console."));
1368 /* Return true to tell that Ctrl-C has been handled. */
1372 /* Get the next event from the child. Return 1 if the event requires
1373 handling by WFI (or whatever). */
1375 get_windows_debug_event (struct target_ops
*ops
,
1376 int pid
, struct target_waitstatus
*ourstatus
)
1379 DWORD continue_status
, event_code
;
1381 static thread_info dummy_thread_info
;
1384 last_sig
= TARGET_SIGNAL_0
;
1386 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1390 continue_status
= DBG_CONTINUE
;
1392 event_code
= current_event
.dwDebugEventCode
;
1393 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1395 have_saved_context
= 0;
1399 case CREATE_THREAD_DEBUG_EVENT
:
1400 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1401 (unsigned) current_event
.dwProcessId
,
1402 (unsigned) current_event
.dwThreadId
,
1403 "CREATE_THREAD_DEBUG_EVENT"));
1404 if (saw_create
!= 1)
1406 struct inferior
*inf
;
1407 inf
= find_inferior_pid (current_event
.dwProcessId
);
1408 if (!saw_create
&& inf
->attach_flag
)
1410 /* Kludge around a Windows bug where first event is a create
1411 thread event. Caused when attached process does not have
1413 retval
= fake_create_process ();
1419 /* Record the existence of this thread */
1420 retval
= current_event
.dwThreadId
;
1421 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1422 current_event
.dwThreadId
),
1423 current_event
.u
.CreateThread
.hThread
);
1426 case EXIT_THREAD_DEBUG_EVENT
:
1427 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1428 (unsigned) current_event
.dwProcessId
,
1429 (unsigned) current_event
.dwThreadId
,
1430 "EXIT_THREAD_DEBUG_EVENT"));
1431 if (current_event
.dwThreadId
!= main_thread_id
)
1433 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1434 current_event
.dwThreadId
));
1435 th
= &dummy_thread_info
;
1439 case CREATE_PROCESS_DEBUG_EVENT
:
1440 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1441 (unsigned) current_event
.dwProcessId
,
1442 (unsigned) current_event
.dwThreadId
,
1443 "CREATE_PROCESS_DEBUG_EVENT"));
1444 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1445 if (++saw_create
!= 1)
1448 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1450 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1452 main_thread_id
= current_event
.dwThreadId
;
1453 /* Add the main thread */
1454 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1455 current_event
.dwThreadId
),
1456 current_event
.u
.CreateProcessInfo
.hThread
);
1457 retval
= current_event
.dwThreadId
;
1460 case EXIT_PROCESS_DEBUG_EVENT
:
1461 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1462 (unsigned) current_event
.dwProcessId
,
1463 (unsigned) current_event
.dwThreadId
,
1464 "EXIT_PROCESS_DEBUG_EVENT"));
1465 if (!windows_initialization_done
)
1467 target_terminal_ours ();
1468 target_mourn_inferior ();
1469 error (_("During startup program exited with code 0x%x."),
1470 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1472 else if (saw_create
== 1)
1474 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1475 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1476 retval
= main_thread_id
;
1480 case LOAD_DLL_DEBUG_EVENT
:
1481 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1482 (unsigned) current_event
.dwProcessId
,
1483 (unsigned) current_event
.dwThreadId
,
1484 "LOAD_DLL_DEBUG_EVENT"));
1485 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1486 if (saw_create
!= 1)
1488 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1489 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1490 ourstatus
->value
.integer
= 0;
1491 retval
= main_thread_id
;
1494 case UNLOAD_DLL_DEBUG_EVENT
:
1495 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1496 (unsigned) current_event
.dwProcessId
,
1497 (unsigned) current_event
.dwThreadId
,
1498 "UNLOAD_DLL_DEBUG_EVENT"));
1499 if (saw_create
!= 1)
1501 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1502 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1503 ourstatus
->value
.integer
= 0;
1504 retval
= main_thread_id
;
1507 case EXCEPTION_DEBUG_EVENT
:
1508 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1509 (unsigned) current_event
.dwProcessId
,
1510 (unsigned) current_event
.dwThreadId
,
1511 "EXCEPTION_DEBUG_EVENT"));
1512 if (saw_create
!= 1)
1514 switch (handle_exception (ourstatus
))
1517 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1520 retval
= current_event
.dwThreadId
;
1524 continue_status
= -1;
1529 case OUTPUT_DEBUG_STRING_EVENT
: /* message from the kernel */
1530 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1531 (unsigned) current_event
.dwProcessId
,
1532 (unsigned) current_event
.dwThreadId
,
1533 "OUTPUT_DEBUG_STRING_EVENT"));
1534 if (saw_create
!= 1)
1536 retval
= handle_output_debug_string (ourstatus
);
1540 if (saw_create
!= 1)
1542 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1543 (DWORD
) current_event
.dwProcessId
,
1544 (DWORD
) current_event
.dwThreadId
);
1545 printf_unfiltered (" unknown event code %ld\n",
1546 current_event
.dwDebugEventCode
);
1550 if (!retval
|| saw_create
!= 1)
1552 if (continue_status
== -1)
1553 windows_resume (ops
, minus_one_ptid
, 0, 1);
1555 CHECK (windows_continue (continue_status
, -1));
1559 inferior_ptid
= ptid_build (current_event
.dwProcessId
, 0,
1561 current_thread
= th
?: thread_rec (current_event
.dwThreadId
, TRUE
);
1568 /* Wait for interesting events to occur in the target process. */
1570 windows_wait (struct target_ops
*ops
,
1571 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
1575 target_terminal_ours ();
1577 /* We loop when we get a non-standard exception rather than return
1578 with a SPURIOUS because resume can try and step or modify things,
1579 which needs a current_thread->h. But some of these exceptions mark
1580 the birth or death of threads, which mean that the current thread
1581 isn't necessarily what you think it is. */
1587 /* If the user presses Ctrl-c while the debugger is waiting
1588 for an event, he expects the debugger to interrupt his program
1589 and to get the prompt back. There are two possible situations:
1591 - The debugger and the program do not share the console, in
1592 which case the Ctrl-c event only reached the debugger.
1593 In that case, the ctrl_c handler will take care of interrupting
1594 the inferior. Note that this case is working starting with
1595 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1598 - The debugger and the program share the same console, in which
1599 case both debugger and inferior will receive the Ctrl-c event.
1600 In that case the ctrl_c handler will ignore the event, as the
1601 Ctrl-c event generated inside the inferior will trigger the
1602 expected debug event.
1604 FIXME: brobecker/2008-05-20: If the inferior receives the
1605 signal first and the delay until GDB receives that signal
1606 is sufficiently long, GDB can sometimes receive the SIGINT
1607 after we have unblocked the CTRL+C handler. This would
1608 lead to the debugger stopping prematurely while handling
1609 the new-thread event that comes with the handling of the SIGINT
1610 inside the inferior, and then stop again immediately when
1611 the user tries to resume the execution in the inferior.
1612 This is a classic race that we should try to fix one day. */
1613 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1614 retval
= get_windows_debug_event (ops
, pid
, ourstatus
);
1615 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1618 return ptid_build (current_event
.dwProcessId
, 0, retval
);
1623 if (deprecated_ui_loop_hook
!= NULL
)
1624 detach
= deprecated_ui_loop_hook (0);
1627 windows_kill_inferior (ops
);
1633 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1635 extern int stop_after_trap
;
1637 struct inferior
*inf
;
1638 struct thread_info
*tp
;
1640 last_sig
= TARGET_SIGNAL_0
;
1642 exception_count
= 0;
1643 open_process_used
= 0;
1644 debug_registers_changed
= 0;
1645 debug_registers_used
= 0;
1646 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1649 cygwin_load_start
= cygwin_load_end
= 0;
1651 current_event
.dwProcessId
= pid
;
1652 memset (¤t_event
, 0, sizeof (current_event
));
1654 disable_breakpoints_in_shlibs ();
1655 windows_clear_solib ();
1656 clear_proceed_status ();
1657 init_wait_for_inferior ();
1659 inf
= current_inferior ();
1660 inferior_appeared (inf
, pid
);
1661 inf
->attach_flag
= attaching
;
1663 /* Make the new process the current inferior, so terminal handling
1664 can rely on it. When attaching, we don't know about any thread
1665 id here, but that's OK --- nothing should be referencing the
1666 current thread until we report an event out of windows_wait. */
1667 inferior_ptid
= pid_to_ptid (pid
);
1669 terminal_init_inferior_with_pgrp (pid
);
1670 target_terminal_inferior ();
1672 windows_initialization_done
= 0;
1673 inf
->stop_soon
= STOP_QUIETLY
;
1676 stop_after_trap
= 1;
1677 wait_for_inferior (0);
1678 tp
= inferior_thread ();
1679 if (tp
->stop_signal
!= TARGET_SIGNAL_TRAP
)
1680 resume (0, tp
->stop_signal
);
1685 windows_initialization_done
= 1;
1686 inf
->stop_soon
= NO_STOP_QUIETLY
;
1687 stop_after_trap
= 0;
1691 /* Try to set or remove a user privilege to the current process. Return -1
1692 if that fails, the previous setting of that privilege otherwise.
1694 This code is copied from the Cygwin source code and rearranged to allow
1695 dynamically loading of the needed symbols from advapi32 which is only
1696 available on NT/2K/XP. */
1698 set_process_privilege (const char *privilege
, BOOL enable
)
1700 HANDLE token_hdl
= NULL
;
1702 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1706 if (!OpenProcessToken (GetCurrentProcess (),
1707 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1711 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
1714 new_priv
.PrivilegeCount
= 1;
1715 new_priv
.Privileges
[0].Luid
= restore_priv
;
1716 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1718 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1719 sizeof orig_priv
, &orig_priv
, &size
))
1722 /* Disabled, otherwise every `attach' in an unprivileged user session
1723 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1724 windows_attach(). */
1725 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1726 be enabled. GetLastError () returns an correct error code, though. */
1727 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1731 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1735 CloseHandle (token_hdl
);
1740 /* Attach to process PID, then initialize for debugging it. */
1742 windows_attach (struct target_ops
*ops
, char *args
, int from_tty
)
1747 pid
= parse_pid_to_attach (args
);
1749 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1751 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1752 printf_unfiltered ("This can cause attach to fail on Windows NT/2K/XP\n");
1755 windows_init_thread_list ();
1756 ok
= DebugActiveProcess (pid
);
1762 /* Try fall back to Cygwin pid */
1763 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1766 ok
= DebugActiveProcess (pid
);
1771 error (_("Can't attach to process."));
1773 DebugSetProcessKillOnExit (FALSE
);
1777 char *exec_file
= (char *) get_exec_file (0);
1780 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1781 target_pid_to_str (pid_to_ptid (pid
)));
1783 printf_unfiltered ("Attaching to %s\n",
1784 target_pid_to_str (pid_to_ptid (pid
)));
1786 gdb_flush (gdb_stdout
);
1789 do_initial_windows_stuff (ops
, pid
, 1);
1790 target_terminal_ours ();
1794 windows_detach (struct target_ops
*ops
, char *args
, int from_tty
)
1799 windows_resume (ops
, ptid
, 0, TARGET_SIGNAL_0
);
1801 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1803 error (_("Can't detach process %lu (error %lu)"),
1804 current_event
.dwProcessId
, GetLastError ());
1807 DebugSetProcessKillOnExit (FALSE
);
1809 if (detached
&& from_tty
)
1811 char *exec_file
= get_exec_file (0);
1814 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file
,
1815 current_event
.dwProcessId
);
1816 gdb_flush (gdb_stdout
);
1819 inferior_ptid
= null_ptid
;
1820 detach_inferior (current_event
.dwProcessId
);
1822 unpush_target (ops
);
1826 windows_pid_to_exec_file (int pid
)
1829 static char path
[PATH_MAX
];
1831 /* Try to find exe name as symlink target of /proc/<pid>/exe */
1833 char procexe
[sizeof ("/proc/4294967295/exe")];
1834 sprintf (procexe
, "/proc/%u/exe", pid
);
1835 nchars
= readlink (procexe
, path
, sizeof(path
));
1836 if (nchars
> 0 && nchars
< sizeof (path
))
1838 path
[nchars
] = '\0'; /* Got it */
1842 static char path
[MAX_PATH
+ 1];
1845 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
1846 of gdb, or we're trying to debug a non-Cygwin windows executable. */
1847 if (!get_module_name (0, path
))
1853 /* Print status information about what we're accessing. */
1856 windows_files_info (struct target_ops
*ignore
)
1858 struct inferior
*inf
= current_inferior ();
1860 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1861 inf
->attach_flag
? "attached" : "child",
1862 target_pid_to_str (inferior_ptid
));
1866 windows_open (char *arg
, int from_tty
)
1868 error (_("Use the \"run\" command to start a Unix child process."));
1871 /* Start an inferior windows child process and sets inferior_ptid to its pid.
1872 EXEC_FILE is the file to run.
1873 ALLARGS is a string containing the arguments to the program.
1874 ENV is the environment vector to pass. Errors reported with error(). */
1877 windows_create_inferior (struct target_ops
*ops
, char *exec_file
,
1878 char *allargs
, char **in_env
, int from_tty
)
1882 wchar_t real_path
[PATH_MAX
];
1883 wchar_t shell
[PATH_MAX
]; /* Path to shell */
1886 wchar_t *cygallargs
;
1890 int ostdin
, ostdout
, ostderr
;
1893 char real_path
[PATH_MAX
];
1894 char shell
[MAX_PATH
+ 1]; /* Path to shell */
1899 PROCESS_INFORMATION pi
;
1902 const char *inferior_io_terminal
= get_inferior_io_terminal ();
1905 error (_("No executable specified, use `target exec'."));
1907 memset (&si
, 0, sizeof (si
));
1908 si
.cb
= sizeof (si
);
1911 flags
|= CREATE_NEW_PROCESS_GROUP
;
1914 flags
|= CREATE_NEW_CONSOLE
;
1919 flags
|= DEBUG_ONLY_THIS_PROCESS
;
1920 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
1921 PATH_MAX
* sizeof (wchar_t)) < 0)
1922 error (_("Error starting executable: %d"), errno
);
1924 len
= mbstowcs (NULL
, allargs
, 0) + 1;
1925 if (len
== (size_t) -1)
1926 error (_("Error starting executable: %d"), errno
);
1927 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
1928 mbstowcs (cygallargs
, allargs
, len
);
1932 sh
= getenv ("SHELL");
1935 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, PATH_MAX
) < 0)
1936 error (_("Error starting executable via shell: %d"), errno
);
1937 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
1938 + mbstowcs (NULL
, allargs
, 0) + 2;
1939 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
1940 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
1942 flags
|= DEBUG_PROCESS
;
1944 args
= (wchar_t *) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
1945 * sizeof (wchar_t));
1946 wcscpy (args
, toexec
);
1947 wcscat (args
, L
" ");
1948 wcscat (args
, cygallargs
);
1949 /* Prepare the environment vars for CreateProcess. */
1950 cygwin_internal (CW_SYNC_WINENV
);
1952 if (!inferior_io_terminal
)
1953 tty
= ostdin
= ostdout
= ostderr
= -1;
1956 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
1959 print_sys_errmsg (inferior_io_terminal
, errno
);
1960 ostdin
= ostdout
= ostderr
= -1;
1973 windows_init_thread_list ();
1974 ret
= CreateProcessW (0,
1975 args
, /* command line */
1976 NULL
, /* Security */
1978 TRUE
, /* inherit handles */
1979 flags
, /* start flags */
1980 NULL
, /* environment */
1981 NULL
, /* current directory */
1995 args
= alloca (strlen (toexec
) + strlen (allargs
) + 2);
1996 strcpy (args
, toexec
);
1998 strcat (args
, allargs
);
2001 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2003 if (!inferior_io_terminal
)
2004 tty
= INVALID_HANDLE_VALUE
;
2007 SECURITY_ATTRIBUTES sa
;
2008 sa
.nLength
= sizeof(sa
);
2009 sa
.lpSecurityDescriptor
= 0;
2010 sa
.bInheritHandle
= TRUE
;
2011 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2012 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2013 if (tty
== INVALID_HANDLE_VALUE
)
2014 warning (_("Warning: Failed to open TTY %s, error %#x."),
2015 inferior_io_terminal
, (unsigned) GetLastError ());
2019 si
.hStdOutput
= tty
;
2021 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2025 windows_init_thread_list ();
2026 ret
= CreateProcessA (0,
2027 args
, /* command line */
2028 NULL
, /* Security */
2030 TRUE
, /* inherit handles */
2031 flags
, /* start flags */
2032 NULL
, /* environment */
2033 NULL
, /* current directory */
2036 if (tty
!= INVALID_HANDLE_VALUE
)
2041 error (_("Error creating process %s, (error %d)."),
2042 exec_file
, (unsigned) GetLastError ());
2044 CloseHandle (pi
.hThread
);
2045 CloseHandle (pi
.hProcess
);
2047 if (useshell
&& shell
[0] != '\0')
2052 do_initial_windows_stuff (ops
, pi
.dwProcessId
, 0);
2054 /* windows_continue (DBG_CONTINUE, -1); */
2058 windows_mourn_inferior (struct target_ops
*ops
)
2060 (void) windows_continue (DBG_CONTINUE
, -1);
2061 i386_cleanup_dregs();
2062 if (open_process_used
)
2064 CHECK (CloseHandle (current_process_handle
));
2065 open_process_used
= 0;
2067 unpush_target (ops
);
2068 generic_mourn_inferior ();
2071 /* Send a SIGINT to the process group. This acts just like the user typed a
2072 ^C on the controlling terminal. */
2075 windows_stop (ptid_t ptid
)
2077 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2078 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
2079 registers_changed (); /* refresh register state */
2083 windows_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*our
, int len
,
2084 int write
, struct mem_attrib
*mem
,
2085 struct target_ops
*target
)
2090 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
2091 len
, (DWORD
) (uintptr_t) memaddr
));
2092 if (!WriteProcessMemory (current_process_handle
,
2093 (LPVOID
) (uintptr_t) memaddr
, our
,
2096 FlushInstructionCache (current_process_handle
,
2097 (LPCVOID
) (uintptr_t) memaddr
, len
);
2101 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
2102 len
, (DWORD
) (uintptr_t) memaddr
));
2103 if (!ReadProcessMemory (current_process_handle
,
2104 (LPCVOID
) (uintptr_t) memaddr
, our
,
2112 windows_kill_inferior (struct target_ops
*ops
)
2114 CHECK (TerminateProcess (current_process_handle
, 0));
2118 if (!windows_continue (DBG_CONTINUE
, -1))
2120 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
2122 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2126 target_mourn_inferior (); /* or just windows_mourn_inferior? */
2130 windows_prepare_to_store (struct regcache
*regcache
)
2132 /* Do nothing, since we can store individual regs */
2136 windows_can_run (void)
2142 windows_close (int x
)
2144 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2145 PIDGET (inferior_ptid
)));
2148 /* Convert pid to printable format. */
2150 windows_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
2152 static char buf
[80];
2154 if (ptid_get_tid (ptid
) != 0)
2156 snprintf (buf
, sizeof (buf
), "Thread %d.0x%lx",
2157 ptid_get_pid (ptid
), ptid_get_tid (ptid
));
2161 return normal_pid_to_str (ptid
);
2165 windows_xfer_shared_libraries (struct target_ops
*ops
,
2166 enum target_object object
, const char *annex
,
2167 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2168 ULONGEST offset
, LONGEST len
)
2170 struct obstack obstack
;
2178 obstack_init (&obstack
);
2179 obstack_grow_str (&obstack
, "<library-list>\n");
2180 for (so
= solib_start
.next
; so
; so
= so
->next
)
2181 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
) (uintptr_t) so
->lm_info
->load_addr
,
2182 target_gdbarch
, &obstack
);
2183 obstack_grow_str0 (&obstack
, "</library-list>\n");
2185 buf
= obstack_finish (&obstack
);
2186 len_avail
= strlen (buf
);
2187 if (offset
>= len_avail
)
2190 if (len
> len_avail
- offset
)
2191 len
= len_avail
- offset
;
2192 memcpy (readbuf
, buf
+ offset
, len
);
2194 obstack_free (&obstack
, NULL
);
2199 windows_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2200 const char *annex
, gdb_byte
*readbuf
,
2201 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
2205 case TARGET_OBJECT_MEMORY
:
2207 return (*ops
->deprecated_xfer_memory
) (offset
, readbuf
,
2208 len
, 0/*read*/, NULL
, ops
);
2210 return (*ops
->deprecated_xfer_memory
) (offset
, (gdb_byte
*) writebuf
,
2211 len
, 1/*write*/, NULL
, ops
);
2214 case TARGET_OBJECT_LIBRARIES
:
2215 return windows_xfer_shared_libraries (ops
, object
, annex
, readbuf
,
2216 writebuf
, offset
, len
);
2219 if (ops
->beneath
!= NULL
)
2220 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2221 readbuf
, writebuf
, offset
, len
);
2227 windows_get_ada_task_ptid (long lwp
, long thread
)
2229 return ptid_build (ptid_get_pid (inferior_ptid
), 0, lwp
);
2233 init_windows_ops (void)
2235 windows_ops
.to_shortname
= "child";
2236 windows_ops
.to_longname
= "Win32 child process";
2237 windows_ops
.to_doc
= "Win32 child process (started by the \"run\" command).";
2238 windows_ops
.to_open
= windows_open
;
2239 windows_ops
.to_close
= windows_close
;
2240 windows_ops
.to_attach
= windows_attach
;
2241 windows_ops
.to_attach_no_wait
= 1;
2242 windows_ops
.to_detach
= windows_detach
;
2243 windows_ops
.to_resume
= windows_resume
;
2244 windows_ops
.to_wait
= windows_wait
;
2245 windows_ops
.to_fetch_registers
= windows_fetch_inferior_registers
;
2246 windows_ops
.to_store_registers
= windows_store_inferior_registers
;
2247 windows_ops
.to_prepare_to_store
= windows_prepare_to_store
;
2248 windows_ops
.deprecated_xfer_memory
= windows_xfer_memory
;
2249 windows_ops
.to_xfer_partial
= windows_xfer_partial
;
2250 windows_ops
.to_files_info
= windows_files_info
;
2251 windows_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
2252 windows_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
2253 windows_ops
.to_terminal_init
= terminal_init_inferior
;
2254 windows_ops
.to_terminal_inferior
= terminal_inferior
;
2255 windows_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
2256 windows_ops
.to_terminal_ours
= terminal_ours
;
2257 windows_ops
.to_terminal_save_ours
= terminal_save_ours
;
2258 windows_ops
.to_terminal_info
= child_terminal_info
;
2259 windows_ops
.to_kill
= windows_kill_inferior
;
2260 windows_ops
.to_create_inferior
= windows_create_inferior
;
2261 windows_ops
.to_mourn_inferior
= windows_mourn_inferior
;
2262 windows_ops
.to_can_run
= windows_can_run
;
2263 windows_ops
.to_thread_alive
= windows_thread_alive
;
2264 windows_ops
.to_pid_to_str
= windows_pid_to_str
;
2265 windows_ops
.to_stop
= windows_stop
;
2266 windows_ops
.to_stratum
= process_stratum
;
2267 windows_ops
.to_has_all_memory
= default_child_has_all_memory
;
2268 windows_ops
.to_has_memory
= default_child_has_memory
;
2269 windows_ops
.to_has_stack
= default_child_has_stack
;
2270 windows_ops
.to_has_registers
= default_child_has_registers
;
2271 windows_ops
.to_has_execution
= default_child_has_execution
;
2272 windows_ops
.to_pid_to_exec_file
= windows_pid_to_exec_file
;
2273 windows_ops
.to_get_ada_task_ptid
= windows_get_ada_task_ptid
;
2275 i386_use_watchpoints (&windows_ops
);
2277 i386_dr_low
.set_control
= cygwin_set_dr7
;
2278 i386_dr_low
.set_addr
= cygwin_set_dr
;
2279 i386_dr_low
.reset_addr
= NULL
;
2280 i386_dr_low
.get_status
= cygwin_get_dr6
;
2282 /* i386_dr_low.debug_register_length field is set by
2283 calling i386_set_debug_register_length function
2284 in processor windows specific native file. */
2286 windows_ops
.to_magic
= OPS_MAGIC
;
2290 set_windows_aliases (char *argv0
)
2292 add_info_alias ("dll", "sharedlibrary", 1);
2296 _initialize_windows_nat (void)
2298 struct cmd_list_element
*c
;
2300 init_windows_ops ();
2303 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
2306 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
2307 _("Load dll library symbols from FILE."));
2308 set_cmd_completer (c
, filename_completer
);
2310 add_com_alias ("sharedlibrary", "dll-symbols", class_alias
, 1);
2312 add_com_alias ("add-shared-symbol-files", "dll-symbols", class_alias
, 1);
2314 add_com_alias ("assf", "dll-symbols", class_alias
, 1);
2317 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
2318 Set use of shell to start subprocess."), _("\
2319 Show use of shell to start subprocess."), NULL
,
2321 NULL
, /* FIXME: i18n: */
2322 &setlist
, &showlist
);
2324 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
, &cygwin_exceptions
, _("\
2325 Break when an exception is detected in the Cygwin DLL itself."), _("\
2326 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
2328 NULL
, /* FIXME: i18n: */
2329 &setlist
, &showlist
);
2332 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
2333 Set creation of new console when creating child process."), _("\
2334 Show creation of new console when creating child process."), NULL
,
2336 NULL
, /* FIXME: i18n: */
2337 &setlist
, &showlist
);
2339 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
2340 Set creation of new group when creating child process."), _("\
2341 Show creation of new group when creating child process."), NULL
,
2343 NULL
, /* FIXME: i18n: */
2344 &setlist
, &showlist
);
2346 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
2347 Set whether to display execution in child process."), _("\
2348 Show whether to display execution in child process."), NULL
,
2350 NULL
, /* FIXME: i18n: */
2351 &setlist
, &showlist
);
2353 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
2354 Set whether to display kernel events in child process."), _("\
2355 Show whether to display kernel events in child process."), NULL
,
2357 NULL
, /* FIXME: i18n: */
2358 &setlist
, &showlist
);
2360 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
2361 Set whether to display memory accesses in child process."), _("\
2362 Show whether to display memory accesses in child process."), NULL
,
2364 NULL
, /* FIXME: i18n: */
2365 &setlist
, &showlist
);
2367 add_setshow_boolean_cmd ("debugexceptions", class_support
,
2368 &debug_exceptions
, _("\
2369 Set whether to display kernel exceptions in child process."), _("\
2370 Show whether to display kernel exceptions in child process."), NULL
,
2372 NULL
, /* FIXME: i18n: */
2373 &setlist
, &showlist
);
2375 add_prefix_cmd ("w32", class_info
, info_w32_command
,
2376 _("Print information specific to Win32 debugging."),
2377 &info_w32_cmdlist
, "info w32 ", 0, &infolist
);
2379 add_cmd ("selector", class_info
, display_selectors
,
2380 _("Display selectors infos."),
2382 add_target (&windows_ops
);
2383 deprecated_init_ui_hook
= set_windows_aliases
;
2386 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2388 /* Pass the address ADDR to the inferior in the I'th debug register.
2389 Here we just store the address in dr array, the registers will be
2390 actually set up when windows_continue is called. */
2392 cygwin_set_dr (int i
, CORE_ADDR addr
)
2395 internal_error (__FILE__
, __LINE__
,
2396 _("Invalid register %d in cygwin_set_dr.\n"), i
);
2398 debug_registers_changed
= 1;
2399 debug_registers_used
= 1;
2402 /* Pass the value VAL to the inferior in the DR7 debug control
2403 register. Here we just store the address in D_REGS, the watchpoint
2404 will be actually set up in windows_wait. */
2406 cygwin_set_dr7 (unsigned long val
)
2408 dr
[7] = (CORE_ADDR
) val
;
2409 debug_registers_changed
= 1;
2410 debug_registers_used
= 1;
2413 /* Get the value of the DR6 debug status register from the inferior.
2414 Here we just return the value stored in dr[6]
2415 by the last call to thread_rec for current_event.dwThreadId id. */
2416 static unsigned long
2417 cygwin_get_dr6 (void)
2419 return (unsigned long) dr
[6];
2422 /* Determine if the thread referenced by "ptid" is alive
2423 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2424 it means that the thread has died. Otherwise it is assumed to be alive. */
2426 windows_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
2430 gdb_assert (ptid_get_tid (ptid
) != 0);
2431 tid
= ptid_get_tid (ptid
);
2433 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
?
2438 _initialize_check_for_gdb_ini (void)
2441 if (inhibit_gdbinit
)
2444 homedir
= getenv ("HOME");
2448 char *oldini
= (char *) alloca (strlen (homedir
) +
2449 sizeof ("/gdb.ini"));
2450 strcpy (oldini
, homedir
);
2451 p
= strchr (oldini
, '\0');
2452 if (p
> oldini
&& p
[-1] != '/')
2454 strcpy (p
, "gdb.ini");
2455 if (access (oldini
, 0) == 0)
2457 int len
= strlen (oldini
);
2458 char *newini
= alloca (len
+ 1);
2459 sprintf (newini
, "%.*s.gdbinit",
2460 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
2461 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
2466 /* Define dummy functions which always return error for the rare cases where
2467 these functions could not be found. */
2469 bad_DebugActiveProcessStop (DWORD w
)
2474 bad_DebugBreakProcess (HANDLE w
)
2479 bad_DebugSetProcessKillOnExit (BOOL w
)
2484 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
2490 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
2496 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
2502 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
2508 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
2513 /* Load any functions which may not be available in ancient versions
2516 _initialize_loadable (void)
2520 hm
= LoadLibrary ("kernel32.dll");
2523 dyn_DebugActiveProcessStop
= (void *)
2524 GetProcAddress (hm
, "DebugActiveProcessStop");
2525 dyn_DebugBreakProcess
= (void *)
2526 GetProcAddress (hm
, "DebugBreakProcess");
2527 dyn_DebugSetProcessKillOnExit
= (void *)
2528 GetProcAddress (hm
, "DebugSetProcessKillOnExit");
2531 /* Set variables to dummy versions of these processes if the function
2532 wasn't found in kernel32.dll. */
2533 if (!dyn_DebugBreakProcess
)
2534 dyn_DebugBreakProcess
= bad_DebugBreakProcess
;
2535 if (!dyn_DebugActiveProcessStop
|| !dyn_DebugSetProcessKillOnExit
)
2537 dyn_DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
2538 dyn_DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
2541 /* Load optional functions used for retrieving filename information
2542 associated with the currently debugged process or its dlls. */
2543 hm
= LoadLibrary ("psapi.dll");
2546 dyn_EnumProcessModules
= (void *)
2547 GetProcAddress (hm
, "EnumProcessModules");
2548 dyn_GetModuleInformation
= (void *)
2549 GetProcAddress (hm
, "GetModuleInformation");
2551 dyn_GetModuleFileNameExA
= (void *)
2552 GetProcAddress (hm
, "GetModuleFileNameExA");
2554 dyn_GetModuleFileNameExW
= (void *)
2555 GetProcAddress (hm
, "GetModuleFileNameExW");
2559 if (!dyn_EnumProcessModules
|| !dyn_GetModuleInformation
2561 || !dyn_GetModuleFileNameExA
2563 || !dyn_GetModuleFileNameExW
2567 /* Set variables to dummy versions of these processes if the function
2568 wasn't found in psapi.dll. */
2569 dyn_EnumProcessModules
= bad_EnumProcessModules
;
2570 dyn_GetModuleInformation
= bad_GetModuleInformation
;
2572 dyn_GetModuleFileNameExA
= bad_GetModuleFileNameExA
;
2574 dyn_GetModuleFileNameExW
= bad_GetModuleFileNameExW
;
2576 /* This will probably fail on Windows 9x/Me. Let the user know that we're
2577 missing some functionality. */
2578 warning(_("cannot automatically find executable file or library to read symbols.\nUse \"file\" or \"dll\" command to load executable/libraries directly."));
2581 hm
= LoadLibrary ("advapi32.dll");
2584 dyn_OpenProcessToken
= (void *)
2585 GetProcAddress (hm
, "OpenProcessToken");
2586 dyn_LookupPrivilegeValueA
= (void *)
2587 GetProcAddress (hm
, "LookupPrivilegeValueA");
2588 dyn_AdjustTokenPrivileges
= (void *)
2589 GetProcAddress (hm
, "AdjustTokenPrivileges");
2590 /* Only need to set one of these since if OpenProcessToken fails nothing
2592 if (!dyn_OpenProcessToken
|| !dyn_LookupPrivilegeValueA
|| !dyn_AdjustTokenPrivileges
)
2593 dyn_OpenProcessToken
= bad_OpenProcessToken
;