1 /* Target-vector operations for controlling windows child processes, for GDB.
3 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
4 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
6 Contributed by Cygnus Solutions, A Red Hat Company.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 /* Originally by Steve Chamberlain, sac@cygnus.com */
26 #include "frame.h" /* required by inferior.h */
29 #include "exceptions.h"
32 #include "completer.h"
36 #include <sys/types.h>
43 #include <sys/cygwin.h>
44 #include <cygwin/version.h>
51 #include "gdb_obstack.h"
52 #include "gdb_string.h"
53 #include "gdbthread.h"
55 #include <sys/param.h>
60 #include "xml-support.h"
62 #include "i386-tdep.h"
63 #include "i387-tdep.h"
65 #include "windows-tdep.h"
66 #include "windows-nat.h"
68 #include "complaints.h"
70 #define AdjustTokenPrivileges dyn_AdjustTokenPrivileges
71 #define DebugActiveProcessStop dyn_DebugActiveProcessStop
72 #define DebugBreakProcess dyn_DebugBreakProcess
73 #define DebugSetProcessKillOnExit dyn_DebugSetProcessKillOnExit
74 #define EnumProcessModules dyn_EnumProcessModules
75 #define GetModuleInformation dyn_GetModuleInformation
76 #define LookupPrivilegeValueA dyn_LookupPrivilegeValueA
77 #define OpenProcessToken dyn_OpenProcessToken
79 static BOOL
WINAPI (*AdjustTokenPrivileges
)(HANDLE
, BOOL
, PTOKEN_PRIVILEGES
,
80 DWORD
, PTOKEN_PRIVILEGES
, PDWORD
);
81 static BOOL
WINAPI (*DebugActiveProcessStop
) (DWORD
);
82 static BOOL
WINAPI (*DebugBreakProcess
) (HANDLE
);
83 static BOOL
WINAPI (*DebugSetProcessKillOnExit
) (BOOL
);
84 static BOOL
WINAPI (*EnumProcessModules
) (HANDLE
, HMODULE
*, DWORD
,
86 static BOOL
WINAPI (*GetModuleInformation
) (HANDLE
, HMODULE
, LPMODULEINFO
,
88 static BOOL
WINAPI (*LookupPrivilegeValueA
)(LPCSTR
, LPCSTR
, PLUID
);
89 static BOOL
WINAPI (*OpenProcessToken
)(HANDLE
, DWORD
, PHANDLE
);
91 static struct target_ops windows_ops
;
95 #undef GetModuleFileNameEx
98 # define __PMAX (MAX_PATH + 1)
99 static DWORD
WINAPI (*GetModuleFileNameEx
) (HANDLE
, HMODULE
, LPSTR
, DWORD
);
100 # define STARTUPINFO STARTUPINFOA
101 # define CreateProcess CreateProcessA
102 # define GetModuleFileNameEx_name "GetModuleFileNameExA"
103 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
105 # define __PMAX PATH_MAX
106 /* The starting and ending address of the cygwin1.dll text segment. */
107 static CORE_ADDR cygwin_load_start
;
108 static CORE_ADDR cygwin_load_end
;
109 # if CYGWIN_VERSION_DLL_MAKE_COMBINED(CYGWIN_VERSION_API_MAJOR,CYGWIN_VERSION_API_MINOR) >= 181
111 typedef wchar_t cygwin_buf_t
;
112 static DWORD
WINAPI (*GetModuleFileNameEx
) (HANDLE
, HMODULE
, LPWSTR
, DWORD
);
113 # define STARTUPINFO STARTUPINFOW
114 # define CreateProcess CreateProcessW
115 # define GetModuleFileNameEx_name "GetModuleFileNameExW"
116 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExW
118 # define cygwin_conv_path(op, from, to, size) cygwin_conv_to_full_posix_path (from, to)
119 typedef char cygwin_buf_t
;
120 static DWORD
WINAPI (*GetModuleFileNameEx
) (HANDLE
, HMODULE
, LPSTR
, DWORD
);
121 # define STARTUPINFO STARTUPINFOA
122 # define CreateProcess CreateProcessA
123 # define GetModuleFileNameEx_name "GetModuleFileNameExA"
124 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
128 static int have_saved_context
; /* True if we've saved context from a cygwin signal. */
129 static CONTEXT saved_context
; /* Containes the saved context from a cygwin signal. */
131 /* If we're not using the old Cygwin header file set, define the
132 following which never should have been in the generic Win32 API
133 headers in the first place since they were our own invention... */
134 #ifndef _GNU_H_WINDOWS_H
137 FLAG_TRACE_BIT
= 0x100,
138 CONTEXT_DEBUGGER
= (CONTEXT_FULL
| CONTEXT_FLOATING_POINT
)
142 #ifndef CONTEXT_EXTENDED_REGISTERS
143 /* This macro is only defined on ia32. It only makes sense on this target,
144 so define it as zero if not already defined. */
145 #define CONTEXT_EXTENDED_REGISTERS 0
148 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \
149 | CONTEXT_EXTENDED_REGISTERS
151 static uintptr_t dr
[8];
152 static int debug_registers_changed
;
153 static int debug_registers_used
;
155 static int windows_initialization_done
;
156 #define DR6_CLEAR_VALUE 0xffff0ff0
158 /* The string sent by cygwin when it processes a signal.
159 FIXME: This should be in a cygwin include file. */
160 #ifndef _CYGWIN_SIGNAL_STRING
161 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
164 #define CHECK(x) check (x, __FILE__,__LINE__)
165 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
166 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
167 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
168 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
170 static void windows_stop (ptid_t
);
171 static int windows_thread_alive (struct target_ops
*, ptid_t
);
172 static void windows_kill_inferior (struct target_ops
*);
174 static void cygwin_set_dr (int i
, CORE_ADDR addr
);
175 static void cygwin_set_dr7 (unsigned long val
);
176 static unsigned long cygwin_get_dr6 (void);
178 static enum target_signal last_sig
= TARGET_SIGNAL_0
;
179 /* Set if a signal was received from the debugged process */
181 /* Thread information structure used to track information that is
182 not available in gdb's thread structure. */
183 typedef struct thread_info_struct
185 struct thread_info_struct
*next
;
196 static thread_info thread_head
;
198 /* The process and thread handles for the above context. */
200 static DEBUG_EVENT current_event
; /* The current debug event from
202 static HANDLE current_process_handle
; /* Currently executing process */
203 static thread_info
*current_thread
; /* Info on currently selected thread */
204 static DWORD main_thread_id
; /* Thread ID of the main thread */
206 /* Counts of things. */
207 static int exception_count
= 0;
208 static int event_count
= 0;
209 static int saw_create
;
210 static int open_process_used
= 0;
213 static int new_console
= 0;
215 static int cygwin_exceptions
= 0;
217 static int new_group
= 1;
218 static int debug_exec
= 0; /* show execution */
219 static int debug_events
= 0; /* show events from kernel */
220 static int debug_memory
= 0; /* show target memory accesses */
221 static int debug_exceptions
= 0; /* show target exceptions */
222 static int useshell
= 0; /* use shell for subprocesses */
224 /* This vector maps GDB's idea of a register's number into an offset
225 in the windows exception context vector.
227 It also contains the bit mask needed to load the register in question.
229 The contents of this table can only be computed by the units
230 that provide CPU-specific support for Windows native debugging.
231 These units should set the table by calling
232 windows_set_context_register_offsets.
234 One day we could read a reg, we could inspect the context we
235 already have loaded, if it doesn't have the bit set that we need,
236 we read that set of registers in using GetThreadContext. If the
237 context already contains what we need, we just unpack it. Then to
238 write a register, first we have to ensure that the context contains
239 the other regs of the group, and then we copy the info in and set
242 static const int *mappings
;
244 /* This vector maps the target's idea of an exception (extracted
245 from the DEBUG_EVENT structure) to GDB's idea. */
247 struct xlate_exception
250 enum target_signal us
;
253 static const struct xlate_exception
256 {EXCEPTION_ACCESS_VIOLATION
, TARGET_SIGNAL_SEGV
},
257 {STATUS_STACK_OVERFLOW
, TARGET_SIGNAL_SEGV
},
258 {EXCEPTION_BREAKPOINT
, TARGET_SIGNAL_TRAP
},
259 {DBG_CONTROL_C
, TARGET_SIGNAL_INT
},
260 {EXCEPTION_SINGLE_STEP
, TARGET_SIGNAL_TRAP
},
261 {STATUS_FLOAT_DIVIDE_BY_ZERO
, TARGET_SIGNAL_FPE
},
264 /* Set the MAPPINGS static global to OFFSETS.
265 See the description of MAPPINGS for more details. */
268 windows_set_context_register_offsets (const int *offsets
)
274 check (BOOL ok
, const char *file
, int line
)
277 printf_filtered ("error return %s:%d was %lu\n", file
, line
,
281 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
282 then also retrieve the context for this thread. If GET_CONTEXT is
283 negative, then don't suspend the thread. */
285 thread_rec (DWORD id
, int get_context
)
289 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
292 if (!th
->suspended
&& get_context
)
294 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
296 if (SuspendThread (th
->h
) == (DWORD
) -1)
298 DWORD err
= GetLastError ();
299 warning (_("SuspendThread failed. (winerr %d)"),
305 else if (get_context
< 0)
307 th
->reload_context
= 1;
315 /* Add a thread to the thread list. */
317 windows_add_thread (ptid_t ptid
, HANDLE h
)
322 gdb_assert (ptid_get_tid (ptid
) != 0);
324 id
= ptid_get_tid (ptid
);
326 if ((th
= thread_rec (id
, FALSE
)))
329 th
= XZALLOC (thread_info
);
332 th
->next
= thread_head
.next
;
333 thread_head
.next
= th
;
335 /* Set the debug registers for the new thread if they are used. */
336 if (debug_registers_used
)
338 /* Only change the value of the debug registers. */
339 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
340 CHECK (GetThreadContext (th
->h
, &th
->context
));
341 th
->context
.Dr0
= dr
[0];
342 th
->context
.Dr1
= dr
[1];
343 th
->context
.Dr2
= dr
[2];
344 th
->context
.Dr3
= dr
[3];
345 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
346 th
->context
.Dr7
= dr
[7];
347 CHECK (SetThreadContext (th
->h
, &th
->context
));
348 th
->context
.ContextFlags
= 0;
353 /* Clear out any old thread list and reintialize it to a
356 windows_init_thread_list (void)
358 thread_info
*th
= &thread_head
;
360 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
362 while (th
->next
!= NULL
)
364 thread_info
*here
= th
->next
;
365 th
->next
= here
->next
;
368 thread_head
.next
= NULL
;
371 /* Delete a thread from the list of threads */
373 windows_delete_thread (ptid_t ptid
)
378 gdb_assert (ptid_get_tid (ptid
) != 0);
380 id
= ptid_get_tid (ptid
);
383 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
));
384 delete_thread (ptid
);
386 for (th
= &thread_head
;
387 th
->next
!= NULL
&& th
->next
->id
!= id
;
391 if (th
->next
!= NULL
)
393 thread_info
*here
= th
->next
;
394 th
->next
= here
->next
;
400 do_windows_fetch_inferior_registers (struct regcache
*regcache
, int r
)
402 char *context_offset
= ((char *) ¤t_thread
->context
) + mappings
[r
];
403 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
404 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
408 return; /* Windows sometimes uses a non-existent thread id in its
411 if (current_thread
->reload_context
)
413 #ifdef __COPY_CONTEXT_SIZE
414 if (have_saved_context
)
416 /* Lie about where the program actually is stopped since cygwin has informed us that
417 we should consider the signal to have occurred at another location which is stored
418 in "saved_context. */
419 memcpy (¤t_thread
->context
, &saved_context
, __COPY_CONTEXT_SIZE
);
420 have_saved_context
= 0;
425 thread_info
*th
= current_thread
;
426 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
427 GetThreadContext (th
->h
, &th
->context
);
428 /* Copy dr values from that thread.
429 But only if there were not modified since last stop. PR gdb/2388 */
430 if (!debug_registers_changed
)
432 dr
[0] = th
->context
.Dr0
;
433 dr
[1] = th
->context
.Dr1
;
434 dr
[2] = th
->context
.Dr2
;
435 dr
[3] = th
->context
.Dr3
;
436 dr
[6] = th
->context
.Dr6
;
437 dr
[7] = th
->context
.Dr7
;
440 current_thread
->reload_context
= 0;
443 if (r
== I387_FISEG_REGNUM (tdep
))
445 l
= *((long *) context_offset
) & 0xffff;
446 regcache_raw_supply (regcache
, r
, (char *) &l
);
448 else if (r
== I387_FOP_REGNUM (tdep
))
450 l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
451 regcache_raw_supply (regcache
, r
, (char *) &l
);
454 regcache_raw_supply (regcache
, r
, context_offset
);
457 for (r
= 0; r
< gdbarch_num_regs (gdbarch
); r
++)
458 do_windows_fetch_inferior_registers (regcache
, r
);
463 windows_fetch_inferior_registers (struct target_ops
*ops
,
464 struct regcache
*regcache
, int r
)
466 current_thread
= thread_rec (ptid_get_tid (inferior_ptid
), TRUE
);
467 /* Check if current_thread exists. Windows sometimes uses a non-existent
468 thread id in its events */
470 do_windows_fetch_inferior_registers (regcache
, r
);
474 do_windows_store_inferior_registers (const struct regcache
*regcache
, int r
)
477 /* Windows sometimes uses a non-existent thread id in its events */;
479 regcache_raw_collect (regcache
, r
,
480 ((char *) ¤t_thread
->context
) + mappings
[r
]);
483 for (r
= 0; r
< gdbarch_num_regs (get_regcache_arch (regcache
)); r
++)
484 do_windows_store_inferior_registers (regcache
, r
);
488 /* Store a new register value into the current thread context */
490 windows_store_inferior_registers (struct target_ops
*ops
,
491 struct regcache
*regcache
, int r
)
493 current_thread
= thread_rec (ptid_get_tid (inferior_ptid
), TRUE
);
494 /* Check if current_thread exists. Windows sometimes uses a non-existent
495 thread id in its events */
497 do_windows_store_inferior_registers (regcache
, r
);
500 /* Get the name of a given module at at given base address. If base_address
501 is zero return the first loaded module (which is always the name of the
504 get_module_name (LPVOID base_address
, char *dll_name_ret
)
510 HMODULE
*DllHandle
= dh_buf
; /* Set to temporary storage for initial query */
513 cygwin_buf_t pathbuf
[__PMAX
]; /* Temporary storage prior to converting to
514 posix form. __PMAX is always enough
515 as long as SO_NAME_MAX_PATH_SIZE is defined
520 /* Find size of buffer needed to handle list of modules loaded in inferior */
521 if (!EnumProcessModules (current_process_handle
, DllHandle
,
522 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
525 /* Allocate correct amount of space for module list */
526 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
530 /* Get the list of modules */
531 if (!EnumProcessModules (current_process_handle
, DllHandle
, cbNeeded
,
535 for (i
= 0; i
< (int) (cbNeeded
/ sizeof (HMODULE
)); i
++)
537 /* Get information on this module */
538 if (!GetModuleInformation (current_process_handle
, DllHandle
[i
],
540 error (_("Can't get module info"));
542 if (!base_address
|| mi
.lpBaseOfDll
== base_address
)
544 /* Try to find the name of the given module */
546 /* Cygwin prefers that the path be in /x/y/z format */
547 len
= GetModuleFileNameEx (current_process_handle
,
548 DllHandle
[i
], pathbuf
, __PMAX
);
550 error (_("Error getting dll name: %lu."), GetLastError ());
551 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, dll_name_ret
,
553 error (_("Error converting dll name to POSIX: %d."), errno
);
555 len
= GetModuleFileNameEx (current_process_handle
,
556 DllHandle
[i
], dll_name_ret
, __PMAX
);
558 error (_("Error getting dll name: %u."), (unsigned) GetLastError ());
560 return 1; /* success */
565 dll_name_ret
[0] = '\0';
566 return 0; /* failure */
569 /* Encapsulate the information required in a call to
570 symbol_file_add_args */
571 struct safe_symbol_file_add_args
575 struct section_addr_info
*addrs
;
578 struct ui_file
*err
, *out
;
582 /* Maintain a linked list of "so" information. */
588 static struct so_list solib_start
, *solib_end
;
590 /* Call symbol_file_add with stderr redirected. We don't care if there
593 safe_symbol_file_add_stub (void *argv
)
595 #define p ((struct safe_symbol_file_add_args *) argv)
596 const int add_flags
= ((p
->from_tty
? SYMFILE_VERBOSE
: 0)
597 | (p
->mainline
? SYMFILE_MAINLINE
: 0));
598 p
->ret
= symbol_file_add (p
->name
, add_flags
, p
->addrs
, p
->flags
);
603 /* Restore gdb's stderr after calling symbol_file_add */
605 safe_symbol_file_add_cleanup (void *p
)
607 #define sp ((struct safe_symbol_file_add_args *)p)
608 gdb_flush (gdb_stderr
);
609 gdb_flush (gdb_stdout
);
610 ui_file_delete (gdb_stderr
);
611 ui_file_delete (gdb_stdout
);
612 gdb_stderr
= sp
->err
;
613 gdb_stdout
= sp
->out
;
617 /* symbol_file_add wrapper that prevents errors from being displayed. */
618 static struct objfile
*
619 safe_symbol_file_add (char *name
, int from_tty
,
620 struct section_addr_info
*addrs
,
621 int mainline
, int flags
)
623 struct safe_symbol_file_add_args p
;
624 struct cleanup
*cleanup
;
626 cleanup
= make_cleanup (safe_symbol_file_add_cleanup
, &p
);
630 gdb_flush (gdb_stderr
);
631 gdb_flush (gdb_stdout
);
632 gdb_stderr
= ui_file_new ();
633 gdb_stdout
= ui_file_new ();
635 p
.from_tty
= from_tty
;
637 p
.mainline
= mainline
;
639 catch_errors (safe_symbol_file_add_stub
, &p
, "", RETURN_MASK_ERROR
);
641 do_cleanups (cleanup
);
645 static struct so_list
*
646 windows_make_so (const char *name
, LPVOID load_addr
)
653 WIN32_FIND_DATA w32_fd
;
654 HANDLE h
= FindFirstFile(name
, &w32_fd
);
656 if (h
== INVALID_HANDLE_VALUE
)
662 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
664 p
= strrchr (buf
, '\\');
667 SetCurrentDirectory (buf
);
668 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
669 SetCurrentDirectory (cwd
);
672 if (strcasecmp (buf
, "ntdll.dll") == 0)
674 GetSystemDirectory (buf
, sizeof (buf
));
675 strcat (buf
, "\\ntdll.dll");
678 cygwin_buf_t buf
[__PMAX
];
681 if (access (name
, F_OK
) != 0)
683 if (strcasecmp (name
, "ntdll.dll") == 0)
686 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
687 wcscat (buf
, L
"\\ntdll.dll");
691 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
692 strcat (buf
, "\\ntdll.dll");
697 so
= XZALLOC (struct so_list
);
698 so
->lm_info
= (struct lm_info
*) xmalloc (sizeof (struct lm_info
));
699 so
->lm_info
->load_addr
= load_addr
;
700 strcpy (so
->so_original_name
, name
);
702 strcpy (so
->so_name
, buf
);
705 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
706 SO_NAME_MAX_PATH_SIZE
);
709 char *rname
= canonicalize_file_name (name
);
710 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
712 strcpy (so
->so_name
, rname
);
716 error (_("dll path too long"));
718 /* Record cygwin1.dll .text start/end. */
719 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
720 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
723 asection
*text
= NULL
;
726 abfd
= bfd_openr (so
->so_name
, "pei-i386");
731 if (bfd_check_format (abfd
, bfd_object
))
732 text
= bfd_get_section_by_name (abfd
, ".text");
740 /* The symbols in a dll are offset by 0x1000, which is the the
741 offset from 0 of the first byte in an image - because of the
742 file header and the section alignment. */
743 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *) load_addr
+ 0x1000);
744 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (abfd
, text
);
754 get_image_name (HANDLE h
, void *address
, int unicode
)
757 static char buf
[__PMAX
];
759 static char buf
[(2 * __PMAX
) + 1];
761 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
767 /* Attempt to read the name of the dll that was detected.
768 This is documented to work only when actively debugging
769 a program. It will not work for attached processes. */
773 /* See if we could read the address of a string, and that the
774 address isn't null. */
775 if (!ReadProcessMemory (h
, address
, &address_ptr
, sizeof (address_ptr
), &done
)
776 || done
!= sizeof (address_ptr
) || !address_ptr
)
779 /* Find the length of the string */
780 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
781 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
785 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
788 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
789 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
792 wcstombs (buf
, unicode_address
, __PMAX
);
794 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
802 /* Wait for child to do something. Return pid of child, or -1 in case
803 of error; store status through argument pointer OURSTATUS. */
805 handle_load_dll (void *dummy
)
807 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
808 char dll_buf
[__PMAX
];
809 char *dll_name
= NULL
;
811 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
813 if (!get_module_name (event
->lpBaseOfDll
, dll_buf
))
814 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
818 if (*dll_name
== '\0')
819 dll_name
= get_image_name (current_process_handle
,
820 event
->lpImageName
, event
->fUnicode
);
824 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
825 solib_end
= solib_end
->next
;
827 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
828 host_address_to_string (solib_end
->lm_info
->load_addr
)));
834 windows_free_so (struct so_list
*so
)
842 handle_unload_dll (void *dummy
)
844 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
847 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
848 if (so
->next
->lm_info
->load_addr
== lpBaseOfDll
)
850 struct so_list
*sodel
= so
->next
;
851 so
->next
= sodel
->next
;
854 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
856 windows_free_so (sodel
);
857 solib_add (NULL
, 0, NULL
, auto_solib_add
);
861 /* We did not find any DLL that was previously loaded at this address,
862 so register a complaint. We do not report an error, because we have
863 observed that this may be happening under some circumstances. For
864 instance, running 32bit applications on x64 Windows causes us to receive
865 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
866 events are apparently caused by the WOW layer, the interface between
867 32bit and 64bit worlds). */
868 complaint (&symfile_complaints
, _("dll starting at %s not found."),
869 host_address_to_string (lpBaseOfDll
));
874 /* Clear list of loaded DLLs. */
876 windows_clear_solib (void)
878 solib_start
.next
= NULL
;
879 solib_end
= &solib_start
;
882 /* Load DLL symbol info. */
884 dll_symbol_command (char *args
, int from_tty
)
890 error (_("dll-symbols requires a file name"));
893 if (n
> 4 && strcasecmp (args
+ n
- 4, ".dll") != 0)
895 char *newargs
= (char *) alloca (n
+ 4 + 1);
896 strcpy (newargs
, args
);
897 strcat (newargs
, ".dll");
901 safe_symbol_file_add (args
, from_tty
, NULL
, 0, OBJF_SHARED
| OBJF_USERLOADED
);
904 /* Handle DEBUG_STRING output from child process.
905 Cygwin prepends its messages with a "cygwin:". Interpret this as
906 a Cygwin signal. Otherwise just print the string as a warning. */
908 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
913 if (!target_read_string
914 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
918 else if (strncmp (s
, _CYGWIN_SIGNAL_STRING
, sizeof (_CYGWIN_SIGNAL_STRING
) - 1) != 0)
921 if (strncmp (s
, "cYg", 3) != 0)
925 #ifdef __COPY_CONTEXT_SIZE
928 /* Got a cygwin signal marker. A cygwin signal is followed by the signal number
929 itself and then optionally followed by the thread id and address to saved context
930 within the DLL. If these are supplied, then the given thread is assumed to have
931 issued the signal and the context from the thread is assumed to be stored at the
932 given address in the inferior. Tell gdb to treat this like a real signal. */
934 int sig
= strtol (s
+ sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
935 int gotasig
= target_signal_from_host (sig
);
936 ourstatus
->value
.sig
= gotasig
;
941 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
942 retval
= strtoul (p
, &p
, 0);
944 retval
= main_thread_id
;
945 else if ((x
= (LPCVOID
) strtoul (p
, &p
, 0))
946 && ReadProcessMemory (current_process_handle
, x
,
947 &saved_context
, __COPY_CONTEXT_SIZE
, &n
)
948 && n
== __COPY_CONTEXT_SIZE
)
949 have_saved_context
= 1;
950 current_event
.dwThreadId
= retval
;
961 display_selector (HANDLE thread
, DWORD sel
)
964 if (GetThreadSelectorEntry (thread
, sel
, &info
))
967 printf_filtered ("0x%03lx: ", sel
);
968 if (!info
.HighWord
.Bits
.Pres
)
970 puts_filtered ("Segment not present\n");
973 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
974 (info
.HighWord
.Bits
.BaseMid
<< 16)
976 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
977 if (info
.HighWord
.Bits
.Granularity
)
978 limit
= (limit
<< 12) | 0xfff;
979 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
980 if (info
.HighWord
.Bits
.Default_Big
)
981 puts_filtered(" 32-bit ");
983 puts_filtered(" 16-bit ");
984 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
987 puts_filtered ("Data (Read-Only, Exp-up");
990 puts_filtered ("Data (Read/Write, Exp-up");
993 puts_filtered ("Unused segment (");
996 puts_filtered ("Data (Read/Write, Exp-down");
999 puts_filtered ("Code (Exec-Only, N.Conf");
1002 puts_filtered ("Code (Exec/Read, N.Conf");
1005 puts_filtered ("Code (Exec-Only, Conf");
1008 puts_filtered ("Code (Exec/Read, Conf");
1011 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
1013 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1014 puts_filtered(", N.Acc");
1015 puts_filtered (")\n");
1016 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1017 puts_filtered("System selector ");
1018 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
1019 if (info
.HighWord
.Bits
.Granularity
)
1020 puts_filtered ("Page granular.\n");
1022 puts_filtered ("Byte granular.\n");
1027 printf_filtered ("Invalid selector 0x%lx.\n",sel
);
1033 display_selectors (char * args
, int from_tty
)
1035 if (!current_thread
)
1037 puts_filtered ("Impossible to display selectors now.\n");
1043 puts_filtered ("Selector $cs\n");
1044 display_selector (current_thread
->h
,
1045 current_thread
->context
.SegCs
);
1046 puts_filtered ("Selector $ds\n");
1047 display_selector (current_thread
->h
,
1048 current_thread
->context
.SegDs
);
1049 puts_filtered ("Selector $es\n");
1050 display_selector (current_thread
->h
,
1051 current_thread
->context
.SegEs
);
1052 puts_filtered ("Selector $ss\n");
1053 display_selector (current_thread
->h
,
1054 current_thread
->context
.SegSs
);
1055 puts_filtered ("Selector $fs\n");
1056 display_selector (current_thread
->h
,
1057 current_thread
->context
.SegFs
);
1058 puts_filtered ("Selector $gs\n");
1059 display_selector (current_thread
->h
,
1060 current_thread
->context
.SegGs
);
1065 sel
= parse_and_eval_long (args
);
1066 printf_filtered ("Selector \"%s\"\n",args
);
1067 display_selector (current_thread
->h
, sel
);
1071 static struct cmd_list_element
*info_w32_cmdlist
= NULL
;
1074 info_w32_command (char *args
, int from_tty
)
1076 help_list (info_w32_cmdlist
, "info w32 ", class_info
, gdb_stdout
);
1080 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1081 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1082 host_address_to_string (\
1083 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1086 handle_exception (struct target_waitstatus
*ourstatus
)
1089 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1091 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1093 /* Record the context of the current thread */
1094 th
= thread_rec (current_event
.dwThreadId
, -1);
1098 case EXCEPTION_ACCESS_VIOLATION
:
1099 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1100 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1103 /* See if the access violation happened within the cygwin DLL itself. Cygwin uses
1104 a kind of exception handling to deal with passed-in invalid addresses. gdb
1105 should not treat these as real SEGVs since they will be silently handled by
1106 cygwin. A real SEGV will (theoretically) be caught by cygwin later in the process
1107 and will be sent as a cygwin-specific-signal. So, ignore SEGVs if they show up
1108 within the text segment of the DLL itself. */
1110 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
;
1111 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
&& addr
< cygwin_load_end
))
1112 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1113 && strncmp (fn
, "KERNEL32!IsBad", strlen ("KERNEL32!IsBad")) == 0))
1118 case STATUS_STACK_OVERFLOW
:
1119 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1120 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1122 case STATUS_FLOAT_DENORMAL_OPERAND
:
1123 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1124 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1126 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1127 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1128 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1130 case STATUS_FLOAT_INEXACT_RESULT
:
1131 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1132 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1134 case STATUS_FLOAT_INVALID_OPERATION
:
1135 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1136 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1138 case STATUS_FLOAT_OVERFLOW
:
1139 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1140 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1142 case STATUS_FLOAT_STACK_CHECK
:
1143 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1144 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1146 case STATUS_FLOAT_UNDERFLOW
:
1147 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1148 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1150 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1151 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1152 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1154 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1155 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1156 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1158 case STATUS_INTEGER_OVERFLOW
:
1159 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1160 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1162 case EXCEPTION_BREAKPOINT
:
1163 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1164 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1167 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1168 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1170 case DBG_CONTROL_BREAK
:
1171 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1172 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1174 case EXCEPTION_SINGLE_STEP
:
1175 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1176 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1178 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1179 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1180 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1182 case EXCEPTION_PRIV_INSTRUCTION
:
1183 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1184 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1186 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1187 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1188 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1191 /* Treat unhandled first chance exceptions specially. */
1192 if (current_event
.u
.Exception
.dwFirstChance
)
1194 printf_unfiltered ("gdb: unknown target exception 0x%08lx at %s\n",
1195 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1196 host_address_to_string (
1197 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1198 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1202 last_sig
= ourstatus
->value
.sig
;
1206 /* Resume all artificially suspended threads if we are continuing
1209 windows_continue (DWORD continue_status
, int id
)
1215 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%lx, %s);\n",
1216 current_event
.dwProcessId
, current_event
.dwThreadId
,
1217 continue_status
== DBG_CONTINUE
?
1218 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1220 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1221 if ((id
== -1 || id
== (int) th
->id
)
1224 if (debug_registers_changed
)
1226 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1227 th
->context
.Dr0
= dr
[0];
1228 th
->context
.Dr1
= dr
[1];
1229 th
->context
.Dr2
= dr
[2];
1230 th
->context
.Dr3
= dr
[3];
1231 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1232 th
->context
.Dr7
= dr
[7];
1234 if (th
->context
.ContextFlags
)
1236 CHECK (SetThreadContext (th
->h
, &th
->context
));
1237 th
->context
.ContextFlags
= 0;
1239 if (th
->suspended
> 0)
1240 (void) ResumeThread (th
->h
);
1244 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1245 current_event
.dwThreadId
,
1248 debug_registers_changed
= 0;
1252 /* Called in pathological case where Windows fails to send a
1253 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1255 fake_create_process (void)
1257 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1258 current_event
.dwProcessId
);
1259 if (current_process_handle
!= NULL
)
1260 open_process_used
= 1;
1263 error (_("OpenProcess call failed, GetLastError = %lud\n"),
1265 /* We can not debug anything in that case. */
1267 main_thread_id
= current_event
.dwThreadId
;
1268 current_thread
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1269 current_event
.dwThreadId
),
1270 current_event
.u
.CreateThread
.hThread
);
1271 return main_thread_id
;
1275 windows_resume (struct target_ops
*ops
,
1276 ptid_t ptid
, int step
, enum target_signal sig
)
1279 DWORD continue_status
= DBG_CONTINUE
;
1281 /* A specific PTID means `step only this thread id'. */
1282 int resume_all
= ptid_equal (ptid
, minus_one_ptid
);
1284 /* If we're continuing all threads, it's the current inferior that
1285 should be handled specially. */
1287 ptid
= inferior_ptid
;
1289 if (sig
!= TARGET_SIGNAL_0
)
1291 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1293 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1295 else if (sig
== last_sig
)
1296 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1299 /* This code does not seem to work, because
1300 the kernel does probably not consider changes in the ExceptionRecord
1301 structure when passing the exception to the inferior.
1302 Note that this seems possible in the exception handler itself. */
1305 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1306 if (xlate
[i
].us
== sig
)
1308 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
=
1310 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1313 if (continue_status
== DBG_CONTINUE
)
1315 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1319 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1323 last_sig
= TARGET_SIGNAL_0
;
1325 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1326 ptid_get_pid (ptid
), ptid_get_tid (ptid
), step
, sig
));
1328 /* Get context for currently selected thread */
1329 th
= thread_rec (ptid_get_tid (inferior_ptid
), FALSE
);
1334 /* Single step by setting t bit */
1335 struct regcache
*regcache
= get_current_regcache ();
1336 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1337 windows_fetch_inferior_registers (ops
, regcache
,
1338 gdbarch_ps_regnum (gdbarch
));
1339 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1342 if (th
->context
.ContextFlags
)
1344 if (debug_registers_changed
)
1346 th
->context
.Dr0
= dr
[0];
1347 th
->context
.Dr1
= dr
[1];
1348 th
->context
.Dr2
= dr
[2];
1349 th
->context
.Dr3
= dr
[3];
1350 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1351 th
->context
.Dr7
= dr
[7];
1353 CHECK (SetThreadContext (th
->h
, &th
->context
));
1354 th
->context
.ContextFlags
= 0;
1358 /* Allow continuing with the same signal that interrupted us.
1359 Otherwise complain. */
1362 windows_continue (continue_status
, -1);
1364 windows_continue (continue_status
, ptid_get_tid (ptid
));
1367 /* Ctrl-C handler used when the inferior is not run in the same console. The
1368 handler is in charge of interrupting the inferior using DebugBreakProcess.
1369 Note that this function is not available prior to Windows XP. In this case
1370 we emit a warning. */
1372 ctrl_c_handler (DWORD event_type
)
1374 const int attach_flag
= current_inferior ()->attach_flag
;
1376 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1377 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1380 /* If the inferior and the debugger share the same console, do nothing as
1381 the inferior has also received the Ctrl-C event. */
1382 if (!new_console
&& !attach_flag
)
1385 if (!DebugBreakProcess (current_process_handle
))
1387 Could not interrupt program. Press Ctrl-c in the program console."));
1389 /* Return true to tell that Ctrl-C has been handled. */
1393 /* Get the next event from the child. Return 1 if the event requires
1394 handling by WFI (or whatever). */
1396 get_windows_debug_event (struct target_ops
*ops
,
1397 int pid
, struct target_waitstatus
*ourstatus
)
1400 DWORD continue_status
, event_code
;
1402 static thread_info dummy_thread_info
;
1405 last_sig
= TARGET_SIGNAL_0
;
1407 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1411 continue_status
= DBG_CONTINUE
;
1413 event_code
= current_event
.dwDebugEventCode
;
1414 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1416 have_saved_context
= 0;
1420 case CREATE_THREAD_DEBUG_EVENT
:
1421 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1422 (unsigned) current_event
.dwProcessId
,
1423 (unsigned) current_event
.dwThreadId
,
1424 "CREATE_THREAD_DEBUG_EVENT"));
1425 if (saw_create
!= 1)
1427 struct inferior
*inf
;
1428 inf
= find_inferior_pid (current_event
.dwProcessId
);
1429 if (!saw_create
&& inf
->attach_flag
)
1431 /* Kludge around a Windows bug where first event is a create
1432 thread event. Caused when attached process does not have
1434 retval
= fake_create_process ();
1440 /* Record the existence of this thread */
1441 retval
= current_event
.dwThreadId
;
1442 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1443 current_event
.dwThreadId
),
1444 current_event
.u
.CreateThread
.hThread
);
1447 case EXIT_THREAD_DEBUG_EVENT
:
1448 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1449 (unsigned) current_event
.dwProcessId
,
1450 (unsigned) current_event
.dwThreadId
,
1451 "EXIT_THREAD_DEBUG_EVENT"));
1453 if (current_event
.dwThreadId
!= main_thread_id
)
1455 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1456 current_event
.dwThreadId
));
1457 th
= &dummy_thread_info
;
1461 case CREATE_PROCESS_DEBUG_EVENT
:
1462 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1463 (unsigned) current_event
.dwProcessId
,
1464 (unsigned) current_event
.dwThreadId
,
1465 "CREATE_PROCESS_DEBUG_EVENT"));
1466 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1467 if (++saw_create
!= 1)
1470 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1472 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1474 main_thread_id
= current_event
.dwThreadId
;
1475 /* Add the main thread */
1476 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1477 current_event
.dwThreadId
),
1478 current_event
.u
.CreateProcessInfo
.hThread
);
1479 retval
= current_event
.dwThreadId
;
1482 case EXIT_PROCESS_DEBUG_EVENT
:
1483 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1484 (unsigned) current_event
.dwProcessId
,
1485 (unsigned) current_event
.dwThreadId
,
1486 "EXIT_PROCESS_DEBUG_EVENT"));
1487 if (!windows_initialization_done
)
1489 target_terminal_ours ();
1490 target_mourn_inferior ();
1491 error (_("During startup program exited with code 0x%x."),
1492 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1494 else if (saw_create
== 1)
1496 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1497 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1498 retval
= main_thread_id
;
1502 case LOAD_DLL_DEBUG_EVENT
:
1503 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1504 (unsigned) current_event
.dwProcessId
,
1505 (unsigned) current_event
.dwThreadId
,
1506 "LOAD_DLL_DEBUG_EVENT"));
1507 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1508 if (saw_create
!= 1)
1510 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1511 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1512 ourstatus
->value
.integer
= 0;
1513 retval
= main_thread_id
;
1516 case UNLOAD_DLL_DEBUG_EVENT
:
1517 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1518 (unsigned) current_event
.dwProcessId
,
1519 (unsigned) current_event
.dwThreadId
,
1520 "UNLOAD_DLL_DEBUG_EVENT"));
1521 if (saw_create
!= 1)
1523 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1524 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1525 ourstatus
->value
.integer
= 0;
1526 retval
= main_thread_id
;
1529 case EXCEPTION_DEBUG_EVENT
:
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 "EXCEPTION_DEBUG_EVENT"));
1534 if (saw_create
!= 1)
1536 switch (handle_exception (ourstatus
))
1539 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1542 retval
= current_event
.dwThreadId
;
1546 continue_status
= -1;
1551 case OUTPUT_DEBUG_STRING_EVENT
: /* message from the kernel */
1552 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1553 (unsigned) current_event
.dwProcessId
,
1554 (unsigned) current_event
.dwThreadId
,
1555 "OUTPUT_DEBUG_STRING_EVENT"));
1556 if (saw_create
!= 1)
1558 retval
= handle_output_debug_string (ourstatus
);
1562 if (saw_create
!= 1)
1564 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1565 (DWORD
) current_event
.dwProcessId
,
1566 (DWORD
) current_event
.dwThreadId
);
1567 printf_unfiltered (" unknown event code %ld\n",
1568 current_event
.dwDebugEventCode
);
1572 if (!retval
|| saw_create
!= 1)
1574 if (continue_status
== -1)
1575 windows_resume (ops
, minus_one_ptid
, 0, 1);
1577 CHECK (windows_continue (continue_status
, -1));
1581 inferior_ptid
= ptid_build (current_event
.dwProcessId
, 0,
1583 current_thread
= th
?: thread_rec (current_event
.dwThreadId
, TRUE
);
1590 /* Wait for interesting events to occur in the target process. */
1592 windows_wait (struct target_ops
*ops
,
1593 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
1597 target_terminal_ours ();
1599 /* We loop when we get a non-standard exception rather than return
1600 with a SPURIOUS because resume can try and step or modify things,
1601 which needs a current_thread->h. But some of these exceptions mark
1602 the birth or death of threads, which mean that the current thread
1603 isn't necessarily what you think it is. */
1609 /* If the user presses Ctrl-c while the debugger is waiting
1610 for an event, he expects the debugger to interrupt his program
1611 and to get the prompt back. There are two possible situations:
1613 - The debugger and the program do not share the console, in
1614 which case the Ctrl-c event only reached the debugger.
1615 In that case, the ctrl_c handler will take care of interrupting
1616 the inferior. Note that this case is working starting with
1617 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1620 - The debugger and the program share the same console, in which
1621 case both debugger and inferior will receive the Ctrl-c event.
1622 In that case the ctrl_c handler will ignore the event, as the
1623 Ctrl-c event generated inside the inferior will trigger the
1624 expected debug event.
1626 FIXME: brobecker/2008-05-20: If the inferior receives the
1627 signal first and the delay until GDB receives that signal
1628 is sufficiently long, GDB can sometimes receive the SIGINT
1629 after we have unblocked the CTRL+C handler. This would
1630 lead to the debugger stopping prematurely while handling
1631 the new-thread event that comes with the handling of the SIGINT
1632 inside the inferior, and then stop again immediately when
1633 the user tries to resume the execution in the inferior.
1634 This is a classic race that we should try to fix one day. */
1635 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1636 retval
= get_windows_debug_event (ops
, pid
, ourstatus
);
1637 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1640 return ptid_build (current_event
.dwProcessId
, 0, retval
);
1645 if (deprecated_ui_loop_hook
!= NULL
)
1646 detach
= deprecated_ui_loop_hook (0);
1649 windows_kill_inferior (ops
);
1655 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1657 extern int stop_after_trap
;
1659 struct inferior
*inf
;
1660 struct thread_info
*tp
;
1662 last_sig
= TARGET_SIGNAL_0
;
1664 exception_count
= 0;
1665 open_process_used
= 0;
1666 debug_registers_changed
= 0;
1667 debug_registers_used
= 0;
1668 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1671 cygwin_load_start
= cygwin_load_end
= 0;
1673 current_event
.dwProcessId
= pid
;
1674 memset (¤t_event
, 0, sizeof (current_event
));
1676 disable_breakpoints_in_shlibs ();
1677 windows_clear_solib ();
1678 clear_proceed_status ();
1679 init_wait_for_inferior ();
1681 inf
= current_inferior ();
1682 inferior_appeared (inf
, pid
);
1683 inf
->attach_flag
= attaching
;
1685 /* Make the new process the current inferior, so terminal handling
1686 can rely on it. When attaching, we don't know about any thread
1687 id here, but that's OK --- nothing should be referencing the
1688 current thread until we report an event out of windows_wait. */
1689 inferior_ptid
= pid_to_ptid (pid
);
1691 terminal_init_inferior_with_pgrp (pid
);
1692 target_terminal_inferior ();
1694 windows_initialization_done
= 0;
1695 inf
->stop_soon
= STOP_QUIETLY
;
1698 stop_after_trap
= 1;
1699 wait_for_inferior (0);
1700 tp
= inferior_thread ();
1701 if (tp
->stop_signal
!= TARGET_SIGNAL_TRAP
)
1702 resume (0, tp
->stop_signal
);
1707 windows_initialization_done
= 1;
1708 inf
->stop_soon
= NO_STOP_QUIETLY
;
1709 stop_after_trap
= 0;
1713 /* Try to set or remove a user privilege to the current process. Return -1
1714 if that fails, the previous setting of that privilege otherwise.
1716 This code is copied from the Cygwin source code and rearranged to allow
1717 dynamically loading of the needed symbols from advapi32 which is only
1718 available on NT/2K/XP. */
1720 set_process_privilege (const char *privilege
, BOOL enable
)
1722 HANDLE token_hdl
= NULL
;
1724 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1728 if (!OpenProcessToken (GetCurrentProcess (),
1729 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1733 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
1736 new_priv
.PrivilegeCount
= 1;
1737 new_priv
.Privileges
[0].Luid
= restore_priv
;
1738 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1740 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1741 sizeof orig_priv
, &orig_priv
, &size
))
1744 /* Disabled, otherwise every `attach' in an unprivileged user session
1745 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1746 windows_attach(). */
1747 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1748 be enabled. GetLastError () returns an correct error code, though. */
1749 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1753 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1757 CloseHandle (token_hdl
);
1762 /* Attach to process PID, then initialize for debugging it. */
1764 windows_attach (struct target_ops
*ops
, char *args
, int from_tty
)
1769 pid
= parse_pid_to_attach (args
);
1771 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1773 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1774 printf_unfiltered ("This can cause attach to fail on Windows NT/2K/XP\n");
1777 windows_init_thread_list ();
1778 ok
= DebugActiveProcess (pid
);
1784 /* Try fall back to Cygwin pid */
1785 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1788 ok
= DebugActiveProcess (pid
);
1793 error (_("Can't attach to process."));
1795 DebugSetProcessKillOnExit (FALSE
);
1799 char *exec_file
= (char *) get_exec_file (0);
1802 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1803 target_pid_to_str (pid_to_ptid (pid
)));
1805 printf_unfiltered ("Attaching to %s\n",
1806 target_pid_to_str (pid_to_ptid (pid
)));
1808 gdb_flush (gdb_stdout
);
1811 do_initial_windows_stuff (ops
, pid
, 1);
1812 target_terminal_ours ();
1816 windows_detach (struct target_ops
*ops
, char *args
, int from_tty
)
1821 windows_resume (ops
, ptid
, 0, TARGET_SIGNAL_0
);
1823 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1825 error (_("Can't detach process %lu (error %lu)"),
1826 current_event
.dwProcessId
, GetLastError ());
1829 DebugSetProcessKillOnExit (FALSE
);
1831 if (detached
&& from_tty
)
1833 char *exec_file
= get_exec_file (0);
1836 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file
,
1837 current_event
.dwProcessId
);
1838 gdb_flush (gdb_stdout
);
1841 inferior_ptid
= null_ptid
;
1842 detach_inferior (current_event
.dwProcessId
);
1844 unpush_target (ops
);
1848 windows_pid_to_exec_file (int pid
)
1850 static char path
[__PMAX
];
1852 /* Try to find exe name as symlink target of /proc/<pid>/exe */
1854 char procexe
[sizeof ("/proc/4294967295/exe")];
1855 sprintf (procexe
, "/proc/%u/exe", pid
);
1856 nchars
= readlink (procexe
, path
, sizeof(path
));
1857 if (nchars
> 0 && nchars
< sizeof (path
))
1859 path
[nchars
] = '\0'; /* Got it */
1864 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
1865 of gdb, or we're trying to debug a non-Cygwin windows executable. */
1866 if (!get_module_name (0, path
))
1872 /* Print status information about what we're accessing. */
1875 windows_files_info (struct target_ops
*ignore
)
1877 struct inferior
*inf
= current_inferior ();
1879 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1880 inf
->attach_flag
? "attached" : "child",
1881 target_pid_to_str (inferior_ptid
));
1885 windows_open (char *arg
, int from_tty
)
1887 error (_("Use the \"run\" command to start a Unix child process."));
1890 /* Start an inferior windows child process and sets inferior_ptid to its pid.
1891 EXEC_FILE is the file to run.
1892 ALLARGS is a string containing the arguments to the program.
1893 ENV is the environment vector to pass. Errors reported with error(). */
1896 windows_create_inferior (struct target_ops
*ops
, char *exec_file
,
1897 char *allargs
, char **in_env
, int from_tty
)
1901 cygwin_buf_t real_path
[__PMAX
];
1902 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
1904 cygwin_buf_t
*toexec
;
1905 cygwin_buf_t
*cygallargs
;
1909 int ostdin
, ostdout
, ostderr
;
1911 char real_path
[__PMAX
];
1912 char shell
[__PMAX
]; /* Path to shell */
1917 PROCESS_INFORMATION pi
;
1920 const char *inferior_io_terminal
= get_inferior_io_terminal ();
1923 error (_("No executable specified, use `target exec'."));
1925 memset (&si
, 0, sizeof (si
));
1926 si
.cb
= sizeof (si
);
1929 flags
|= CREATE_NEW_PROCESS_GROUP
;
1932 flags
|= CREATE_NEW_CONSOLE
;
1937 flags
|= DEBUG_ONLY_THIS_PROCESS
;
1938 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
1939 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
1940 error (_("Error starting executable: %d"), errno
);
1943 len
= mbstowcs (NULL
, allargs
, 0) + 1;
1944 if (len
== (size_t) -1)
1945 error (_("Error starting executable: %d"), errno
);
1946 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
1947 mbstowcs (cygallargs
, allargs
, len
);
1952 sh
= getenv ("SHELL");
1955 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
1956 error (_("Error starting executable via shell: %d"), errno
);
1958 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
1959 + mbstowcs (NULL
, allargs
, 0) + 2;
1960 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
1961 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
1963 cygallargs
= (char *) alloca (sizeof (" -c 'exec '") + strlen (exec_file
)
1964 + strlen (allargs
) + 2);
1965 sprintf (cygallargs
, " -c 'exec %s %s'", exec_file
, allargs
);
1968 flags
|= DEBUG_PROCESS
;
1972 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
1973 * sizeof (wchar_t));
1974 wcscpy (args
, toexec
);
1975 wcscat (args
, L
" ");
1976 wcscat (args
, cygallargs
);
1978 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
1979 strcpy (args
, toexec
);
1981 strcat (args
, cygallargs
);
1984 /* Prepare the environment vars for CreateProcess. */
1985 cygwin_internal (CW_SYNC_WINENV
);
1987 if (!inferior_io_terminal
)
1988 tty
= ostdin
= ostdout
= ostderr
= -1;
1991 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
1994 print_sys_errmsg (inferior_io_terminal
, errno
);
1995 ostdin
= ostdout
= ostderr
= -1;
2008 windows_init_thread_list ();
2009 ret
= CreateProcess (0,
2010 args
, /* command line */
2011 NULL
, /* Security */
2013 TRUE
, /* inherit handles */
2014 flags
, /* start flags */
2015 NULL
, /* environment */
2016 NULL
, /* current directory */
2031 args
= alloca (strlen (toexec
) + strlen (allargs
) + 2);
2032 strcpy (args
, toexec
);
2034 strcat (args
, allargs
);
2036 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2038 if (!inferior_io_terminal
)
2039 tty
= INVALID_HANDLE_VALUE
;
2042 SECURITY_ATTRIBUTES sa
;
2043 sa
.nLength
= sizeof(sa
);
2044 sa
.lpSecurityDescriptor
= 0;
2045 sa
.bInheritHandle
= TRUE
;
2046 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2047 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2048 if (tty
== INVALID_HANDLE_VALUE
)
2049 warning (_("Warning: Failed to open TTY %s, error %#x."),
2050 inferior_io_terminal
, (unsigned) GetLastError ());
2054 si
.hStdOutput
= tty
;
2056 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2060 windows_init_thread_list ();
2061 ret
= CreateProcessA (0,
2062 args
, /* command line */
2063 NULL
, /* Security */
2065 TRUE
, /* inherit handles */
2066 flags
, /* start flags */
2067 NULL
, /* environment */
2068 NULL
, /* current directory */
2071 if (tty
!= INVALID_HANDLE_VALUE
)
2076 error (_("Error creating process %s, (error %d)."),
2077 exec_file
, (unsigned) GetLastError ());
2079 CloseHandle (pi
.hThread
);
2080 CloseHandle (pi
.hProcess
);
2082 if (useshell
&& shell
[0] != '\0')
2087 do_initial_windows_stuff (ops
, pi
.dwProcessId
, 0);
2089 /* windows_continue (DBG_CONTINUE, -1); */
2093 windows_mourn_inferior (struct target_ops
*ops
)
2095 (void) windows_continue (DBG_CONTINUE
, -1);
2096 i386_cleanup_dregs();
2097 if (open_process_used
)
2099 CHECK (CloseHandle (current_process_handle
));
2100 open_process_used
= 0;
2102 unpush_target (ops
);
2103 generic_mourn_inferior ();
2106 /* Send a SIGINT to the process group. This acts just like the user typed a
2107 ^C on the controlling terminal. */
2110 windows_stop (ptid_t ptid
)
2112 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2113 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
2114 registers_changed (); /* refresh register state */
2118 windows_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*our
, int len
,
2119 int write
, struct mem_attrib
*mem
,
2120 struct target_ops
*target
)
2125 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
2126 len
, (DWORD
) (uintptr_t) memaddr
));
2127 if (!WriteProcessMemory (current_process_handle
,
2128 (LPVOID
) (uintptr_t) memaddr
, our
,
2131 FlushInstructionCache (current_process_handle
,
2132 (LPCVOID
) (uintptr_t) memaddr
, len
);
2136 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
2137 len
, (DWORD
) (uintptr_t) memaddr
));
2138 if (!ReadProcessMemory (current_process_handle
,
2139 (LPCVOID
) (uintptr_t) memaddr
, our
,
2147 windows_kill_inferior (struct target_ops
*ops
)
2149 CHECK (TerminateProcess (current_process_handle
, 0));
2153 if (!windows_continue (DBG_CONTINUE
, -1))
2155 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
2157 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2161 target_mourn_inferior (); /* or just windows_mourn_inferior? */
2165 windows_prepare_to_store (struct regcache
*regcache
)
2167 /* Do nothing, since we can store individual regs */
2171 windows_can_run (void)
2177 windows_close (int x
)
2179 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2180 PIDGET (inferior_ptid
)));
2183 /* Convert pid to printable format. */
2185 windows_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
2187 static char buf
[80];
2189 if (ptid_get_tid (ptid
) != 0)
2191 snprintf (buf
, sizeof (buf
), "Thread %d.0x%lx",
2192 ptid_get_pid (ptid
), ptid_get_tid (ptid
));
2196 return normal_pid_to_str (ptid
);
2200 windows_xfer_shared_libraries (struct target_ops
*ops
,
2201 enum target_object object
, const char *annex
,
2202 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2203 ULONGEST offset
, LONGEST len
)
2205 struct obstack obstack
;
2213 obstack_init (&obstack
);
2214 obstack_grow_str (&obstack
, "<library-list>\n");
2215 for (so
= solib_start
.next
; so
; so
= so
->next
)
2216 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
) (uintptr_t) so
->lm_info
->load_addr
,
2217 target_gdbarch
, &obstack
);
2218 obstack_grow_str0 (&obstack
, "</library-list>\n");
2220 buf
= obstack_finish (&obstack
);
2221 len_avail
= strlen (buf
);
2222 if (offset
>= len_avail
)
2225 if (len
> len_avail
- offset
)
2226 len
= len_avail
- offset
;
2227 memcpy (readbuf
, buf
+ offset
, len
);
2229 obstack_free (&obstack
, NULL
);
2234 windows_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2235 const char *annex
, gdb_byte
*readbuf
,
2236 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
2240 case TARGET_OBJECT_MEMORY
:
2242 return (*ops
->deprecated_xfer_memory
) (offset
, readbuf
,
2243 len
, 0/*read*/, NULL
, ops
);
2245 return (*ops
->deprecated_xfer_memory
) (offset
, (gdb_byte
*) writebuf
,
2246 len
, 1/*write*/, NULL
, ops
);
2249 case TARGET_OBJECT_LIBRARIES
:
2250 return windows_xfer_shared_libraries (ops
, object
, annex
, readbuf
,
2251 writebuf
, offset
, len
);
2254 if (ops
->beneath
!= NULL
)
2255 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2256 readbuf
, writebuf
, offset
, len
);
2262 windows_get_ada_task_ptid (long lwp
, long thread
)
2264 return ptid_build (ptid_get_pid (inferior_ptid
), 0, lwp
);
2268 init_windows_ops (void)
2270 windows_ops
.to_shortname
= "child";
2271 windows_ops
.to_longname
= "Win32 child process";
2272 windows_ops
.to_doc
= "Win32 child process (started by the \"run\" command).";
2273 windows_ops
.to_open
= windows_open
;
2274 windows_ops
.to_close
= windows_close
;
2275 windows_ops
.to_attach
= windows_attach
;
2276 windows_ops
.to_attach_no_wait
= 1;
2277 windows_ops
.to_detach
= windows_detach
;
2278 windows_ops
.to_resume
= windows_resume
;
2279 windows_ops
.to_wait
= windows_wait
;
2280 windows_ops
.to_fetch_registers
= windows_fetch_inferior_registers
;
2281 windows_ops
.to_store_registers
= windows_store_inferior_registers
;
2282 windows_ops
.to_prepare_to_store
= windows_prepare_to_store
;
2283 windows_ops
.deprecated_xfer_memory
= windows_xfer_memory
;
2284 windows_ops
.to_xfer_partial
= windows_xfer_partial
;
2285 windows_ops
.to_files_info
= windows_files_info
;
2286 windows_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
2287 windows_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
2288 windows_ops
.to_terminal_init
= terminal_init_inferior
;
2289 windows_ops
.to_terminal_inferior
= terminal_inferior
;
2290 windows_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
2291 windows_ops
.to_terminal_ours
= terminal_ours
;
2292 windows_ops
.to_terminal_save_ours
= terminal_save_ours
;
2293 windows_ops
.to_terminal_info
= child_terminal_info
;
2294 windows_ops
.to_kill
= windows_kill_inferior
;
2295 windows_ops
.to_create_inferior
= windows_create_inferior
;
2296 windows_ops
.to_mourn_inferior
= windows_mourn_inferior
;
2297 windows_ops
.to_can_run
= windows_can_run
;
2298 windows_ops
.to_thread_alive
= windows_thread_alive
;
2299 windows_ops
.to_pid_to_str
= windows_pid_to_str
;
2300 windows_ops
.to_stop
= windows_stop
;
2301 windows_ops
.to_stratum
= process_stratum
;
2302 windows_ops
.to_has_all_memory
= default_child_has_all_memory
;
2303 windows_ops
.to_has_memory
= default_child_has_memory
;
2304 windows_ops
.to_has_stack
= default_child_has_stack
;
2305 windows_ops
.to_has_registers
= default_child_has_registers
;
2306 windows_ops
.to_has_execution
= default_child_has_execution
;
2307 windows_ops
.to_pid_to_exec_file
= windows_pid_to_exec_file
;
2308 windows_ops
.to_get_ada_task_ptid
= windows_get_ada_task_ptid
;
2310 i386_use_watchpoints (&windows_ops
);
2312 i386_dr_low
.set_control
= cygwin_set_dr7
;
2313 i386_dr_low
.set_addr
= cygwin_set_dr
;
2314 i386_dr_low
.reset_addr
= NULL
;
2315 i386_dr_low
.get_status
= cygwin_get_dr6
;
2317 /* i386_dr_low.debug_register_length field is set by
2318 calling i386_set_debug_register_length function
2319 in processor windows specific native file. */
2321 windows_ops
.to_magic
= OPS_MAGIC
;
2325 set_windows_aliases (char *argv0
)
2327 add_info_alias ("dll", "sharedlibrary", 1);
2331 _initialize_windows_nat (void)
2333 struct cmd_list_element
*c
;
2335 init_windows_ops ();
2338 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
2341 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
2342 _("Load dll library symbols from FILE."));
2343 set_cmd_completer (c
, filename_completer
);
2345 add_com_alias ("sharedlibrary", "dll-symbols", class_alias
, 1);
2347 add_com_alias ("add-shared-symbol-files", "dll-symbols", class_alias
, 1);
2349 add_com_alias ("assf", "dll-symbols", class_alias
, 1);
2352 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
2353 Set use of shell to start subprocess."), _("\
2354 Show use of shell to start subprocess."), NULL
,
2356 NULL
, /* FIXME: i18n: */
2357 &setlist
, &showlist
);
2359 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
, &cygwin_exceptions
, _("\
2360 Break when an exception is detected in the Cygwin DLL itself."), _("\
2361 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
2363 NULL
, /* FIXME: i18n: */
2364 &setlist
, &showlist
);
2367 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
2368 Set creation of new console when creating child process."), _("\
2369 Show creation of new console when creating child process."), NULL
,
2371 NULL
, /* FIXME: i18n: */
2372 &setlist
, &showlist
);
2374 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
2375 Set creation of new group when creating child process."), _("\
2376 Show creation of new group when creating child process."), NULL
,
2378 NULL
, /* FIXME: i18n: */
2379 &setlist
, &showlist
);
2381 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
2382 Set whether to display execution in child process."), _("\
2383 Show whether to display execution in child process."), NULL
,
2385 NULL
, /* FIXME: i18n: */
2386 &setlist
, &showlist
);
2388 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
2389 Set whether to display kernel events in child process."), _("\
2390 Show whether to display kernel events in child process."), NULL
,
2392 NULL
, /* FIXME: i18n: */
2393 &setlist
, &showlist
);
2395 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
2396 Set whether to display memory accesses in child process."), _("\
2397 Show whether to display memory accesses in child process."), NULL
,
2399 NULL
, /* FIXME: i18n: */
2400 &setlist
, &showlist
);
2402 add_setshow_boolean_cmd ("debugexceptions", class_support
,
2403 &debug_exceptions
, _("\
2404 Set whether to display kernel exceptions in child process."), _("\
2405 Show whether to display kernel exceptions in child process."), NULL
,
2407 NULL
, /* FIXME: i18n: */
2408 &setlist
, &showlist
);
2410 add_prefix_cmd ("w32", class_info
, info_w32_command
,
2411 _("Print information specific to Win32 debugging."),
2412 &info_w32_cmdlist
, "info w32 ", 0, &infolist
);
2414 add_cmd ("selector", class_info
, display_selectors
,
2415 _("Display selectors infos."),
2417 add_target (&windows_ops
);
2418 deprecated_init_ui_hook
= set_windows_aliases
;
2421 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2423 /* Pass the address ADDR to the inferior in the I'th debug register.
2424 Here we just store the address in dr array, the registers will be
2425 actually set up when windows_continue is called. */
2427 cygwin_set_dr (int i
, CORE_ADDR addr
)
2430 internal_error (__FILE__
, __LINE__
,
2431 _("Invalid register %d in cygwin_set_dr.\n"), i
);
2433 debug_registers_changed
= 1;
2434 debug_registers_used
= 1;
2437 /* Pass the value VAL to the inferior in the DR7 debug control
2438 register. Here we just store the address in D_REGS, the watchpoint
2439 will be actually set up in windows_wait. */
2441 cygwin_set_dr7 (unsigned long val
)
2443 dr
[7] = (CORE_ADDR
) val
;
2444 debug_registers_changed
= 1;
2445 debug_registers_used
= 1;
2448 /* Get the value of the DR6 debug status register from the inferior.
2449 Here we just return the value stored in dr[6]
2450 by the last call to thread_rec for current_event.dwThreadId id. */
2451 static unsigned long
2452 cygwin_get_dr6 (void)
2454 return (unsigned long) dr
[6];
2457 /* Determine if the thread referenced by "ptid" is alive
2458 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2459 it means that the thread has died. Otherwise it is assumed to be alive. */
2461 windows_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
2465 gdb_assert (ptid_get_tid (ptid
) != 0);
2466 tid
= ptid_get_tid (ptid
);
2468 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
?
2473 _initialize_check_for_gdb_ini (void)
2476 if (inhibit_gdbinit
)
2479 homedir
= getenv ("HOME");
2483 char *oldini
= (char *) alloca (strlen (homedir
) +
2484 sizeof ("/gdb.ini"));
2485 strcpy (oldini
, homedir
);
2486 p
= strchr (oldini
, '\0');
2487 if (p
> oldini
&& p
[-1] != '/')
2489 strcpy (p
, "gdb.ini");
2490 if (access (oldini
, 0) == 0)
2492 int len
= strlen (oldini
);
2493 char *newini
= alloca (len
+ 1);
2494 sprintf (newini
, "%.*s.gdbinit",
2495 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
2496 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
2501 /* Define dummy functions which always return error for the rare cases where
2502 these functions could not be found. */
2504 bad_DebugActiveProcessStop (DWORD w
)
2509 bad_DebugBreakProcess (HANDLE w
)
2514 bad_DebugSetProcessKillOnExit (BOOL w
)
2519 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
2526 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
2532 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
2539 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
2545 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
2550 /* Load any functions which may not be available in ancient versions
2553 _initialize_loadable (void)
2557 hm
= LoadLibrary ("kernel32.dll");
2560 DebugActiveProcessStop
= (void *)
2561 GetProcAddress (hm
, "DebugActiveProcessStop");
2562 DebugBreakProcess
= (void *)
2563 GetProcAddress (hm
, "DebugBreakProcess");
2564 DebugSetProcessKillOnExit
= (void *)
2565 GetProcAddress (hm
, "DebugSetProcessKillOnExit");
2568 /* Set variables to dummy versions of these processes if the function
2569 wasn't found in kernel32.dll. */
2570 if (!DebugBreakProcess
)
2571 DebugBreakProcess
= bad_DebugBreakProcess
;
2572 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
2574 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
2575 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
2578 /* Load optional functions used for retrieving filename information
2579 associated with the currently debugged process or its dlls. */
2580 hm
= LoadLibrary ("psapi.dll");
2583 EnumProcessModules
= (void *)
2584 GetProcAddress (hm
, "EnumProcessModules");
2585 GetModuleInformation
= (void *)
2586 GetProcAddress (hm
, "GetModuleInformation");
2587 GetModuleFileNameEx
= (void *)
2588 GetProcAddress (hm
, GetModuleFileNameEx_name
);
2591 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
2593 /* Set variables to dummy versions of these processes if the function
2594 wasn't found in psapi.dll. */
2595 EnumProcessModules
= bad_EnumProcessModules
;
2596 GetModuleInformation
= bad_GetModuleInformation
;
2597 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
2598 /* This will probably fail on Windows 9x/Me. Let the user know that we're
2599 missing some functionality. */
2600 warning(_("cannot automatically find executable file or library to read symbols.\nUse \"file\" or \"dll\" command to load executable/libraries directly."));
2603 hm
= LoadLibrary ("advapi32.dll");
2606 OpenProcessToken
= (void *) GetProcAddress (hm
, "OpenProcessToken");
2607 LookupPrivilegeValueA
= (void *)
2608 GetProcAddress (hm
, "LookupPrivilegeValueA");
2609 AdjustTokenPrivileges
= (void *)
2610 GetProcAddress (hm
, "AdjustTokenPrivileges");
2611 /* Only need to set one of these since if OpenProcessToken fails nothing
2613 if (!OpenProcessToken
|| !LookupPrivilegeValueA
|| !AdjustTokenPrivileges
)
2614 OpenProcessToken
= bad_OpenProcessToken
;