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 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 #define AdjustTokenPrivileges dyn_AdjustTokenPrivileges
68 #define DebugActiveProcessStop dyn_DebugActiveProcessStop
69 #define DebugBreakProcess dyn_DebugBreakProcess
70 #define DebugSetProcessKillOnExit dyn_DebugSetProcessKillOnExit
71 #define EnumProcessModules dyn_EnumProcessModules
72 #define GetModuleFileNameExA dyn_GetModuleFileNameExA
73 #define GetModuleInformation dyn_GetModuleInformation
74 #define LookupPrivilegeValueA dyn_LookupPrivilegeValueA
75 #define OpenProcessToken dyn_OpenProcessToken
77 static BOOL
WINAPI (*AdjustTokenPrivileges
)(HANDLE
, BOOL
, PTOKEN_PRIVILEGES
,
78 DWORD
, PTOKEN_PRIVILEGES
, PDWORD
);
79 static BOOL
WINAPI (*DebugActiveProcessStop
) (DWORD
);
80 static BOOL
WINAPI (*DebugBreakProcess
) (HANDLE
);
81 static BOOL
WINAPI (*DebugSetProcessKillOnExit
) (BOOL
);
82 static BOOL
WINAPI (*EnumProcessModules
) (HANDLE
, HMODULE
*, DWORD
,
84 static DWORD
WINAPI (*GetModuleFileNameExA
) (HANDLE
, HMODULE
, LPSTR
,
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
;
94 /* The starting and ending address of the cygwin1.dll text segment. */
95 static CORE_ADDR cygwin_load_start
;
96 static CORE_ADDR cygwin_load_end
;
99 static int have_saved_context
; /* True if we've saved context from a cygwin signal. */
100 static CONTEXT saved_context
; /* Containes the saved context from a cygwin signal. */
102 /* If we're not using the old Cygwin header file set, define the
103 following which never should have been in the generic Win32 API
104 headers in the first place since they were our own invention... */
105 #ifndef _GNU_H_WINDOWS_H
108 FLAG_TRACE_BIT
= 0x100,
109 CONTEXT_DEBUGGER
= (CONTEXT_FULL
| CONTEXT_FLOATING_POINT
)
113 #ifndef CONTEXT_EXTENDED_REGISTERS
114 /* This macro is only defined on ia32. It only makes sense on this target,
115 so define it as zero if not already defined. */
116 #define CONTEXT_EXTENDED_REGISTERS 0
119 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \
120 | CONTEXT_EXTENDED_REGISTERS
122 static uintptr_t dr
[8];
123 static int debug_registers_changed
;
124 static int debug_registers_used
;
125 #define DR6_CLEAR_VALUE 0xffff0ff0
127 /* The string sent by cygwin when it processes a signal.
128 FIXME: This should be in a cygwin include file. */
129 #ifndef _CYGWIN_SIGNAL_STRING
130 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
133 #define CHECK(x) check (x, __FILE__,__LINE__)
134 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
135 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
136 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
137 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
139 static void windows_stop (ptid_t
);
140 static int windows_thread_alive (struct target_ops
*, ptid_t
);
141 static void windows_kill_inferior (struct target_ops
*);
143 static enum target_signal last_sig
= TARGET_SIGNAL_0
;
144 /* Set if a signal was received from the debugged process */
146 /* Thread information structure used to track information that is
147 not available in gdb's thread structure. */
148 typedef struct thread_info_struct
150 struct thread_info_struct
*next
;
161 static thread_info thread_head
;
163 /* The process and thread handles for the above context. */
165 static DEBUG_EVENT current_event
; /* The current debug event from
167 static HANDLE current_process_handle
; /* Currently executing process */
168 static thread_info
*current_thread
; /* Info on currently selected thread */
169 static DWORD main_thread_id
; /* Thread ID of the main thread */
171 /* Counts of things. */
172 static int exception_count
= 0;
173 static int event_count
= 0;
174 static int saw_create
;
175 static int open_process_used
= 0;
178 static int new_console
= 0;
180 static int cygwin_exceptions
= 0;
182 static int new_group
= 1;
183 static int debug_exec
= 0; /* show execution */
184 static int debug_events
= 0; /* show events from kernel */
185 static int debug_memory
= 0; /* show target memory accesses */
186 static int debug_exceptions
= 0; /* show target exceptions */
187 static int useshell
= 0; /* use shell for subprocesses */
189 /* This vector maps GDB's idea of a register's number into an offset
190 in the windows exception context vector.
192 It also contains the bit mask needed to load the register in question.
194 The contents of this table can only be computed by the units
195 that provide CPU-specific support for Windows native debugging.
196 These units should set the table by calling
197 windows_set_context_register_offsets.
199 One day we could read a reg, we could inspect the context we
200 already have loaded, if it doesn't have the bit set that we need,
201 we read that set of registers in using GetThreadContext. If the
202 context already contains what we need, we just unpack it. Then to
203 write a register, first we have to ensure that the context contains
204 the other regs of the group, and then we copy the info in and set
207 static const int *mappings
;
209 /* This vector maps the target's idea of an exception (extracted
210 from the DEBUG_EVENT structure) to GDB's idea. */
212 struct xlate_exception
215 enum target_signal us
;
218 static const struct xlate_exception
221 {EXCEPTION_ACCESS_VIOLATION
, TARGET_SIGNAL_SEGV
},
222 {STATUS_STACK_OVERFLOW
, TARGET_SIGNAL_SEGV
},
223 {EXCEPTION_BREAKPOINT
, TARGET_SIGNAL_TRAP
},
224 {DBG_CONTROL_C
, TARGET_SIGNAL_INT
},
225 {EXCEPTION_SINGLE_STEP
, TARGET_SIGNAL_TRAP
},
226 {STATUS_FLOAT_DIVIDE_BY_ZERO
, TARGET_SIGNAL_FPE
},
229 /* Set the MAPPINGS static global to OFFSETS.
230 See the description of MAPPINGS for more details. */
233 windows_set_context_register_offsets (const int *offsets
)
239 check (BOOL ok
, const char *file
, int line
)
242 printf_filtered ("error return %s:%d was %lu\n", file
, line
,
246 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
247 then also retrieve the context for this thread. If GET_CONTEXT is
248 negative, then don't suspend the thread. */
250 thread_rec (DWORD id
, int get_context
)
254 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
257 if (!th
->suspended
&& get_context
)
259 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
261 if (SuspendThread (th
->h
) == (DWORD
) -1)
263 DWORD err
= GetLastError ();
264 warning (_("SuspendThread failed. (winerr %d)"),
270 else if (get_context
< 0)
272 th
->reload_context
= 1;
280 /* Add a thread to the thread list. */
282 windows_add_thread (ptid_t ptid
, HANDLE h
)
287 gdb_assert (ptid_get_tid (ptid
) != 0);
289 id
= ptid_get_tid (ptid
);
291 if ((th
= thread_rec (id
, FALSE
)))
294 th
= XZALLOC (thread_info
);
297 th
->next
= thread_head
.next
;
298 thread_head
.next
= th
;
300 /* Set the debug registers for the new thread if they are used. */
301 if (debug_registers_used
)
303 /* Only change the value of the debug registers. */
304 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
305 CHECK (GetThreadContext (th
->h
, &th
->context
));
306 th
->context
.Dr0
= dr
[0];
307 th
->context
.Dr1
= dr
[1];
308 th
->context
.Dr2
= dr
[2];
309 th
->context
.Dr3
= dr
[3];
310 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
311 th
->context
.Dr7
= dr
[7];
312 CHECK (SetThreadContext (th
->h
, &th
->context
));
313 th
->context
.ContextFlags
= 0;
318 /* Clear out any old thread list and reintialize it to a
321 windows_init_thread_list (void)
323 thread_info
*th
= &thread_head
;
325 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
327 while (th
->next
!= NULL
)
329 thread_info
*here
= th
->next
;
330 th
->next
= here
->next
;
333 thread_head
.next
= NULL
;
336 /* Delete a thread from the list of threads */
338 windows_delete_thread (ptid_t ptid
)
343 gdb_assert (ptid_get_tid (ptid
) != 0);
345 id
= ptid_get_tid (ptid
);
348 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
));
349 delete_thread (ptid
);
351 for (th
= &thread_head
;
352 th
->next
!= NULL
&& th
->next
->id
!= id
;
356 if (th
->next
!= NULL
)
358 thread_info
*here
= th
->next
;
359 th
->next
= here
->next
;
365 do_windows_fetch_inferior_registers (struct regcache
*regcache
, int r
)
367 char *context_offset
= ((char *) ¤t_thread
->context
) + mappings
[r
];
368 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
369 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
373 return; /* Windows sometimes uses a non-existent thread id in its
376 if (current_thread
->reload_context
)
378 #ifdef __COPY_CONTEXT_SIZE
379 if (have_saved_context
)
381 /* Lie about where the program actually is stopped since cygwin has informed us that
382 we should consider the signal to have occurred at another location which is stored
383 in "saved_context. */
384 memcpy (¤t_thread
->context
, &saved_context
, __COPY_CONTEXT_SIZE
);
385 have_saved_context
= 0;
390 thread_info
*th
= current_thread
;
391 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
392 GetThreadContext (th
->h
, &th
->context
);
393 /* Copy dr values from that thread.
394 But only if there were not modified since last stop. PR gdb/2388 */
395 if (!debug_registers_changed
)
397 dr
[0] = th
->context
.Dr0
;
398 dr
[1] = th
->context
.Dr1
;
399 dr
[2] = th
->context
.Dr2
;
400 dr
[3] = th
->context
.Dr3
;
401 dr
[6] = th
->context
.Dr6
;
402 dr
[7] = th
->context
.Dr7
;
405 current_thread
->reload_context
= 0;
408 if (r
== I387_FISEG_REGNUM (tdep
))
410 l
= *((long *) context_offset
) & 0xffff;
411 regcache_raw_supply (regcache
, r
, (char *) &l
);
413 else if (r
== I387_FOP_REGNUM (tdep
))
415 l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
416 regcache_raw_supply (regcache
, r
, (char *) &l
);
419 regcache_raw_supply (regcache
, r
, context_offset
);
422 for (r
= 0; r
< gdbarch_num_regs (gdbarch
); r
++)
423 do_windows_fetch_inferior_registers (regcache
, r
);
428 windows_fetch_inferior_registers (struct target_ops
*ops
,
429 struct regcache
*regcache
, int r
)
431 current_thread
= thread_rec (ptid_get_tid (inferior_ptid
), TRUE
);
432 /* Check if current_thread exists. Windows sometimes uses a non-existent
433 thread id in its events */
435 do_windows_fetch_inferior_registers (regcache
, r
);
439 do_windows_store_inferior_registers (const struct regcache
*regcache
, int r
)
442 /* Windows sometimes uses a non-existent thread id in its events */;
444 regcache_raw_collect (regcache
, r
,
445 ((char *) ¤t_thread
->context
) + mappings
[r
]);
448 for (r
= 0; r
< gdbarch_num_regs (get_regcache_arch (regcache
)); r
++)
449 do_windows_store_inferior_registers (regcache
, r
);
453 /* Store a new register value into the current thread context */
455 windows_store_inferior_registers (struct target_ops
*ops
,
456 struct regcache
*regcache
, int r
)
458 current_thread
= thread_rec (ptid_get_tid (inferior_ptid
), TRUE
);
459 /* Check if current_thread exists. Windows sometimes uses a non-existent
460 thread id in its events */
462 do_windows_store_inferior_registers (regcache
, r
);
465 /* Get the name of a given module at at given base address. If base_address
466 is zero return the first loaded module (which is always the name of the
469 get_module_name (LPVOID base_address
, char *dll_name_ret
)
475 HMODULE
*DllHandle
= dh_buf
; /* Set to temporary storage for initial query */
478 char pathbuf
[PATH_MAX
+ 1]; /* Temporary storage prior to converting to
481 char *pathbuf
= dll_name_ret
; /* Just copy directly to passed-in arg */
485 /* Find size of buffer needed to handle list of modules loaded in inferior */
486 if (!EnumProcessModules (current_process_handle
, DllHandle
,
487 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
490 /* Allocate correct amount of space for module list */
491 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
495 /* Get the list of modules */
496 if (!EnumProcessModules (current_process_handle
, DllHandle
, cbNeeded
,
500 for (i
= 0; i
< (int) (cbNeeded
/ sizeof (HMODULE
)); i
++)
502 /* Get information on this module */
503 if (!GetModuleInformation (current_process_handle
, DllHandle
[i
],
505 error (_("Can't get module info"));
507 if (!base_address
|| mi
.lpBaseOfDll
== base_address
)
509 /* Try to find the name of the given module */
510 len
= GetModuleFileNameExA (current_process_handle
,
511 DllHandle
[i
], pathbuf
, MAX_PATH
);
513 error (_("Error getting dll name: %u."), (unsigned) GetLastError ());
515 /* Cygwin prefers that the path be in /x/y/z format */
516 cygwin_conv_to_full_posix_path (pathbuf
, dll_name_ret
);
518 return 1; /* success */
523 dll_name_ret
[0] = '\0';
524 return 0; /* failure */
527 /* Encapsulate the information required in a call to
528 symbol_file_add_args */
529 struct safe_symbol_file_add_args
533 struct section_addr_info
*addrs
;
536 struct ui_file
*err
, *out
;
540 /* Maintain a linked list of "so" information. */
546 static struct so_list solib_start
, *solib_end
;
548 /* Call symbol_file_add with stderr redirected. We don't care if there
551 safe_symbol_file_add_stub (void *argv
)
553 #define p ((struct safe_symbol_file_add_args *) argv)
554 p
->ret
= symbol_file_add (p
->name
, p
->from_tty
, p
->addrs
, p
->mainline
, p
->flags
);
559 /* Restore gdb's stderr after calling symbol_file_add */
561 safe_symbol_file_add_cleanup (void *p
)
563 #define sp ((struct safe_symbol_file_add_args *)p)
564 gdb_flush (gdb_stderr
);
565 gdb_flush (gdb_stdout
);
566 ui_file_delete (gdb_stderr
);
567 ui_file_delete (gdb_stdout
);
568 gdb_stderr
= sp
->err
;
569 gdb_stdout
= sp
->out
;
573 /* symbol_file_add wrapper that prevents errors from being displayed. */
574 static struct objfile
*
575 safe_symbol_file_add (char *name
, int from_tty
,
576 struct section_addr_info
*addrs
,
577 int mainline
, int flags
)
579 struct safe_symbol_file_add_args p
;
580 struct cleanup
*cleanup
;
582 cleanup
= make_cleanup (safe_symbol_file_add_cleanup
, &p
);
586 gdb_flush (gdb_stderr
);
587 gdb_flush (gdb_stdout
);
588 gdb_stderr
= ui_file_new ();
589 gdb_stdout
= ui_file_new ();
591 p
.from_tty
= from_tty
;
593 p
.mainline
= mainline
;
595 catch_errors (safe_symbol_file_add_stub
, &p
, "", RETURN_MASK_ERROR
);
597 do_cleanups (cleanup
);
601 static struct so_list
*
602 windows_make_so (const char *name
, LPVOID load_addr
)
605 char buf
[MAX_PATH
+ 1];
606 char cwd
[MAX_PATH
+ 1];
608 WIN32_FIND_DATA w32_fd
;
609 HANDLE h
= FindFirstFile(name
, &w32_fd
);
610 MEMORY_BASIC_INFORMATION m
;
612 if (h
== INVALID_HANDLE_VALUE
)
618 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
620 p
= strrchr (buf
, '\\');
623 SetCurrentDirectory (buf
);
624 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
625 SetCurrentDirectory (cwd
);
629 if (strcasecmp (buf
, "ntdll.dll") == 0)
631 GetSystemDirectory (buf
, sizeof (buf
));
632 strcat (buf
, "\\ntdll.dll");
634 so
= XZALLOC (struct so_list
);
635 so
->lm_info
= (struct lm_info
*) xmalloc (sizeof (struct lm_info
));
636 so
->lm_info
->load_addr
= load_addr
;
637 strcpy (so
->so_original_name
, name
);
639 strcpy (so
->so_name
, buf
);
641 cygwin_conv_to_posix_path (buf
, so
->so_name
);
642 /* Record cygwin1.dll .text start/end. */
643 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
644 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
647 asection
*text
= NULL
;
650 abfd
= bfd_openr (so
->so_name
, "pei-i386");
655 if (bfd_check_format (abfd
, bfd_object
))
656 text
= bfd_get_section_by_name (abfd
, ".text");
664 /* The symbols in a dll are offset by 0x1000, which is the the
665 offset from 0 of the first byte in an image - because of the
666 file header and the section alignment. */
667 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *) load_addr
+ 0x1000);
668 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (abfd
, text
);
678 get_image_name (HANDLE h
, void *address
, int unicode
)
680 static char buf
[(2 * MAX_PATH
) + 1];
681 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
687 /* Attempt to read the name of the dll that was detected.
688 This is documented to work only when actively debugging
689 a program. It will not work for attached processes. */
693 /* See if we could read the address of a string, and that the
694 address isn't null. */
695 if (!ReadProcessMemory (h
, address
, &address_ptr
, sizeof (address_ptr
), &done
)
696 || done
!= sizeof (address_ptr
) || !address_ptr
)
699 /* Find the length of the string */
700 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
701 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
705 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
708 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
709 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
712 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
718 /* Wait for child to do something. Return pid of child, or -1 in case
719 of error; store status through argument pointer OURSTATUS. */
721 handle_load_dll (void *dummy
)
723 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
724 char dll_buf
[MAX_PATH
+ 1];
725 char *dll_name
= NULL
;
727 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
729 if (!get_module_name (event
->lpBaseOfDll
, dll_buf
))
730 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
734 if (*dll_name
== '\0')
735 dll_name
= get_image_name (current_process_handle
,
736 event
->lpImageName
, event
->fUnicode
);
740 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
741 solib_end
= solib_end
->next
;
743 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %p.\n", solib_end
->so_name
,
744 solib_end
->lm_info
->load_addr
));
750 windows_free_so (struct so_list
*so
)
758 handle_unload_dll (void *dummy
)
760 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
763 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
764 if (so
->next
->lm_info
->load_addr
== lpBaseOfDll
)
766 struct so_list
*sodel
= so
->next
;
767 so
->next
= sodel
->next
;
770 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
772 windows_free_so (sodel
);
773 solib_add (NULL
, 0, NULL
, auto_solib_add
);
777 error (_("Error: dll starting at %p not found."), lpBaseOfDll
);
782 /* Clear list of loaded DLLs. */
784 windows_clear_solib (void)
786 solib_start
.next
= NULL
;
787 solib_end
= &solib_start
;
790 /* Load DLL symbol info. */
792 dll_symbol_command (char *args
, int from_tty
)
798 error (_("dll-symbols requires a file name"));
801 if (n
> 4 && strcasecmp (args
+ n
- 4, ".dll") != 0)
803 char *newargs
= (char *) alloca (n
+ 4 + 1);
804 strcpy (newargs
, args
);
805 strcat (newargs
, ".dll");
809 safe_symbol_file_add (args
, from_tty
, NULL
, 0, OBJF_SHARED
| OBJF_USERLOADED
);
812 /* Handle DEBUG_STRING output from child process.
813 Cygwin prepends its messages with a "cygwin:". Interpret this as
814 a Cygwin signal. Otherwise just print the string as a warning. */
816 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
821 if (!target_read_string
822 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
826 else if (strncmp (s
, _CYGWIN_SIGNAL_STRING
, sizeof (_CYGWIN_SIGNAL_STRING
) - 1) != 0)
829 if (strncmp (s
, "cYg", 3) != 0)
833 #ifdef __COPY_CONTEXT_SIZE
836 /* Got a cygwin signal marker. A cygwin signal is followed by the signal number
837 itself and then optionally followed by the thread id and address to saved context
838 within the DLL. If these are supplied, then the given thread is assumed to have
839 issued the signal and the context from the thread is assumed to be stored at the
840 given address in the inferior. Tell gdb to treat this like a real signal. */
842 int sig
= strtol (s
+ sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
843 int gotasig
= target_signal_from_host (sig
);
844 ourstatus
->value
.sig
= gotasig
;
849 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
850 retval
= strtoul (p
, &p
, 0);
852 retval
= main_thread_id
;
853 else if ((x
= (LPCVOID
) strtoul (p
, &p
, 0))
854 && ReadProcessMemory (current_process_handle
, x
,
855 &saved_context
, __COPY_CONTEXT_SIZE
, &n
)
856 && n
== __COPY_CONTEXT_SIZE
)
857 have_saved_context
= 1;
858 current_event
.dwThreadId
= retval
;
869 display_selector (HANDLE thread
, DWORD sel
)
872 if (GetThreadSelectorEntry (thread
, sel
, &info
))
875 printf_filtered ("0x%03lx: ", sel
);
876 if (!info
.HighWord
.Bits
.Pres
)
878 puts_filtered ("Segment not present\n");
881 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
882 (info
.HighWord
.Bits
.BaseMid
<< 16)
884 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
885 if (info
.HighWord
.Bits
.Granularity
)
886 limit
= (limit
<< 12) | 0xfff;
887 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
888 if (info
.HighWord
.Bits
.Default_Big
)
889 puts_filtered(" 32-bit ");
891 puts_filtered(" 16-bit ");
892 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
895 puts_filtered ("Data (Read-Only, Exp-up");
898 puts_filtered ("Data (Read/Write, Exp-up");
901 puts_filtered ("Unused segment (");
904 puts_filtered ("Data (Read/Write, Exp-down");
907 puts_filtered ("Code (Exec-Only, N.Conf");
910 puts_filtered ("Code (Exec/Read, N.Conf");
913 puts_filtered ("Code (Exec-Only, Conf");
916 puts_filtered ("Code (Exec/Read, Conf");
919 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
921 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
922 puts_filtered(", N.Acc");
923 puts_filtered (")\n");
924 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
925 puts_filtered("System selector ");
926 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
927 if (info
.HighWord
.Bits
.Granularity
)
928 puts_filtered ("Page granular.\n");
930 puts_filtered ("Byte granular.\n");
935 printf_filtered ("Invalid selector 0x%lx.\n",sel
);
941 display_selectors (char * args
, int from_tty
)
945 puts_filtered ("Impossible to display selectors now.\n");
951 puts_filtered ("Selector $cs\n");
952 display_selector (current_thread
->h
,
953 current_thread
->context
.SegCs
);
954 puts_filtered ("Selector $ds\n");
955 display_selector (current_thread
->h
,
956 current_thread
->context
.SegDs
);
957 puts_filtered ("Selector $es\n");
958 display_selector (current_thread
->h
,
959 current_thread
->context
.SegEs
);
960 puts_filtered ("Selector $ss\n");
961 display_selector (current_thread
->h
,
962 current_thread
->context
.SegSs
);
963 puts_filtered ("Selector $fs\n");
964 display_selector (current_thread
->h
,
965 current_thread
->context
.SegFs
);
966 puts_filtered ("Selector $gs\n");
967 display_selector (current_thread
->h
,
968 current_thread
->context
.SegGs
);
973 sel
= parse_and_eval_long (args
);
974 printf_filtered ("Selector \"%s\"\n",args
);
975 display_selector (current_thread
->h
, sel
);
979 static struct cmd_list_element
*info_w32_cmdlist
= NULL
;
982 info_w32_command (char *args
, int from_tty
)
984 help_list (info_w32_cmdlist
, "info w32 ", class_info
, gdb_stdout
);
988 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
989 printf_unfiltered ("gdb: Target exception %s at %p\n", x, \
990 current_event.u.Exception.ExceptionRecord.ExceptionAddress)
993 handle_exception (struct target_waitstatus
*ourstatus
)
996 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
998 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1000 /* Record the context of the current thread */
1001 th
= thread_rec (current_event
.dwThreadId
, -1);
1005 case EXCEPTION_ACCESS_VIOLATION
:
1006 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1007 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1010 /* See if the access violation happened within the cygwin DLL itself. Cygwin uses
1011 a kind of exception handling to deal with passed-in invalid addresses. gdb
1012 should not treat these as real SEGVs since they will be silently handled by
1013 cygwin. A real SEGV will (theoretically) be caught by cygwin later in the process
1014 and will be sent as a cygwin-specific-signal. So, ignore SEGVs if they show up
1015 within the text segment of the DLL itself. */
1017 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
;
1018 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
&& addr
< cygwin_load_end
))
1019 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1020 && strncmp (fn
, "KERNEL32!IsBad", strlen ("KERNEL32!IsBad")) == 0))
1025 case STATUS_STACK_OVERFLOW
:
1026 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1027 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1029 case STATUS_FLOAT_DENORMAL_OPERAND
:
1030 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1031 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1033 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1034 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1035 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1037 case STATUS_FLOAT_INEXACT_RESULT
:
1038 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1039 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1041 case STATUS_FLOAT_INVALID_OPERATION
:
1042 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1043 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1045 case STATUS_FLOAT_OVERFLOW
:
1046 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1047 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1049 case STATUS_FLOAT_STACK_CHECK
:
1050 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1051 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1053 case STATUS_FLOAT_UNDERFLOW
:
1054 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1055 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1057 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1058 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1059 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1061 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1062 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1063 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1065 case STATUS_INTEGER_OVERFLOW
:
1066 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1067 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1069 case EXCEPTION_BREAKPOINT
:
1070 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1071 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1074 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1075 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1077 case DBG_CONTROL_BREAK
:
1078 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1079 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1081 case EXCEPTION_SINGLE_STEP
:
1082 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1083 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1085 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1086 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1087 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1089 case EXCEPTION_PRIV_INSTRUCTION
:
1090 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1091 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1093 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1094 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1095 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1098 /* Treat unhandled first chance exceptions specially. */
1099 if (current_event
.u
.Exception
.dwFirstChance
)
1101 printf_unfiltered ("gdb: unknown target exception 0x%08lx at %p\n",
1102 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1103 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1104 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1108 last_sig
= ourstatus
->value
.sig
;
1112 /* Resume all artificially suspended threads if we are continuing
1115 windows_continue (DWORD continue_status
, int id
)
1121 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, %s);\n",
1122 current_event
.dwProcessId
, current_event
.dwThreadId
,
1123 continue_status
== DBG_CONTINUE
?
1124 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1126 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1127 if ((id
== -1 || id
== (int) th
->id
)
1130 if (debug_registers_changed
)
1132 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1133 th
->context
.Dr0
= dr
[0];
1134 th
->context
.Dr1
= dr
[1];
1135 th
->context
.Dr2
= dr
[2];
1136 th
->context
.Dr3
= dr
[3];
1137 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1138 th
->context
.Dr7
= dr
[7];
1140 if (th
->context
.ContextFlags
)
1142 CHECK (SetThreadContext (th
->h
, &th
->context
));
1143 th
->context
.ContextFlags
= 0;
1145 if (th
->suspended
> 0)
1146 (void) ResumeThread (th
->h
);
1150 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1151 current_event
.dwThreadId
,
1154 debug_registers_changed
= 0;
1158 /* Called in pathological case where Windows fails to send a
1159 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1161 fake_create_process (void)
1163 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1164 current_event
.dwProcessId
);
1165 if (current_process_handle
!= NULL
)
1166 open_process_used
= 1;
1169 error (_("OpenProcess call failed, GetLastError = %lud\n"),
1171 /* We can not debug anything in that case. */
1173 main_thread_id
= current_event
.dwThreadId
;
1174 current_thread
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1175 current_event
.dwThreadId
),
1176 current_event
.u
.CreateThread
.hThread
);
1177 return main_thread_id
;
1181 windows_resume (struct target_ops
*ops
,
1182 ptid_t ptid
, int step
, enum target_signal sig
)
1185 DWORD continue_status
= DBG_CONTINUE
;
1187 /* A specific PTID means `step only this thread id'. */
1188 int resume_all
= ptid_equal (ptid
, minus_one_ptid
);
1190 /* If we're continuing all threads, it's the current inferior that
1191 should be handled specially. */
1193 ptid
= inferior_ptid
;
1195 if (sig
!= TARGET_SIGNAL_0
)
1197 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1199 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1201 else if (sig
== last_sig
)
1202 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1205 /* This code does not seem to work, because
1206 the kernel does probably not consider changes in the ExceptionRecord
1207 structure when passing the exception to the inferior.
1208 Note that this seems possible in the exception handler itself. */
1211 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1212 if (xlate
[i
].us
== sig
)
1214 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
=
1216 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1219 if (continue_status
== DBG_CONTINUE
)
1221 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1225 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1229 last_sig
= TARGET_SIGNAL_0
;
1231 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1232 ptid_get_pid (ptid
), ptid_get_tid (ptid
), step
, sig
));
1234 /* Get context for currently selected thread */
1235 th
= thread_rec (ptid_get_tid (inferior_ptid
), FALSE
);
1240 /* Single step by setting t bit */
1241 windows_fetch_inferior_registers (ops
,
1242 get_current_regcache (),
1243 gdbarch_ps_regnum (current_gdbarch
));
1244 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1247 if (th
->context
.ContextFlags
)
1249 if (debug_registers_changed
)
1251 th
->context
.Dr0
= dr
[0];
1252 th
->context
.Dr1
= dr
[1];
1253 th
->context
.Dr2
= dr
[2];
1254 th
->context
.Dr3
= dr
[3];
1255 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1256 th
->context
.Dr7
= dr
[7];
1258 CHECK (SetThreadContext (th
->h
, &th
->context
));
1259 th
->context
.ContextFlags
= 0;
1263 /* Allow continuing with the same signal that interrupted us.
1264 Otherwise complain. */
1267 windows_continue (continue_status
, -1);
1269 windows_continue (continue_status
, ptid_get_tid (ptid
));
1272 /* Ctrl-C handler used when the inferior is not run in the same console. The
1273 handler is in charge of interrupting the inferior using DebugBreakProcess.
1274 Note that this function is not available prior to Windows XP. In this case
1275 we emit a warning. */
1277 ctrl_c_handler (DWORD event_type
)
1279 const int attach_flag
= current_inferior ()->attach_flag
;
1281 /* Only handle Ctrl-C event. Ignore others. */
1282 if (event_type
!= CTRL_C_EVENT
)
1285 /* If the inferior and the debugger share the same console, do nothing as
1286 the inferior has also received the Ctrl-C event. */
1287 if (!new_console
&& !attach_flag
)
1290 if (!DebugBreakProcess (current_process_handle
))
1292 Could not interrupt program. Press Ctrl-c in the program console."));
1294 /* Return true to tell that Ctrl-C has been handled. */
1298 /* Get the next event from the child. Return 1 if the event requires
1299 handling by WFI (or whatever). */
1301 get_windows_debug_event (struct target_ops
*ops
,
1302 int pid
, struct target_waitstatus
*ourstatus
)
1305 DWORD continue_status
, event_code
;
1307 static thread_info dummy_thread_info
;
1310 last_sig
= TARGET_SIGNAL_0
;
1312 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1316 continue_status
= DBG_CONTINUE
;
1318 event_code
= current_event
.dwDebugEventCode
;
1319 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1321 have_saved_context
= 0;
1325 case CREATE_THREAD_DEBUG_EVENT
:
1326 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1327 (unsigned) current_event
.dwProcessId
,
1328 (unsigned) current_event
.dwThreadId
,
1329 "CREATE_THREAD_DEBUG_EVENT"));
1330 if (saw_create
!= 1)
1332 struct inferior
*inf
;
1333 inf
= find_inferior_pid (current_event
.dwProcessId
);
1334 if (!saw_create
&& inf
->attach_flag
)
1336 /* Kludge around a Windows bug where first event is a create
1337 thread event. Caused when attached process does not have
1339 retval
= fake_create_process ();
1345 /* Record the existence of this thread */
1346 retval
= current_event
.dwThreadId
;
1347 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1348 current_event
.dwThreadId
),
1349 current_event
.u
.CreateThread
.hThread
);
1352 case EXIT_THREAD_DEBUG_EVENT
:
1353 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1354 (unsigned) current_event
.dwProcessId
,
1355 (unsigned) current_event
.dwThreadId
,
1356 "EXIT_THREAD_DEBUG_EVENT"));
1357 if (current_event
.dwThreadId
!= main_thread_id
)
1359 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1360 current_event
.dwThreadId
));
1361 th
= &dummy_thread_info
;
1365 case CREATE_PROCESS_DEBUG_EVENT
:
1366 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1367 (unsigned) current_event
.dwProcessId
,
1368 (unsigned) current_event
.dwThreadId
,
1369 "CREATE_PROCESS_DEBUG_EVENT"));
1370 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1371 if (++saw_create
!= 1)
1374 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1376 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1378 main_thread_id
= current_event
.dwThreadId
;
1379 /* Add the main thread */
1380 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1381 current_event
.dwThreadId
),
1382 current_event
.u
.CreateProcessInfo
.hThread
);
1383 retval
= current_event
.dwThreadId
;
1386 case EXIT_PROCESS_DEBUG_EVENT
:
1387 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1388 (unsigned) current_event
.dwProcessId
,
1389 (unsigned) current_event
.dwThreadId
,
1390 "EXIT_PROCESS_DEBUG_EVENT"));
1391 if (saw_create
!= 1)
1393 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1394 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1395 retval
= main_thread_id
;
1398 case LOAD_DLL_DEBUG_EVENT
:
1399 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1400 (unsigned) current_event
.dwProcessId
,
1401 (unsigned) current_event
.dwThreadId
,
1402 "LOAD_DLL_DEBUG_EVENT"));
1403 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1404 if (saw_create
!= 1)
1406 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1407 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1408 ourstatus
->value
.integer
= 0;
1409 retval
= main_thread_id
;
1412 case UNLOAD_DLL_DEBUG_EVENT
:
1413 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1414 (unsigned) current_event
.dwProcessId
,
1415 (unsigned) current_event
.dwThreadId
,
1416 "UNLOAD_DLL_DEBUG_EVENT"));
1417 if (saw_create
!= 1)
1419 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1420 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1421 ourstatus
->value
.integer
= 0;
1422 retval
= main_thread_id
;
1425 case EXCEPTION_DEBUG_EVENT
:
1426 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1427 (unsigned) current_event
.dwProcessId
,
1428 (unsigned) current_event
.dwThreadId
,
1429 "EXCEPTION_DEBUG_EVENT"));
1430 if (saw_create
!= 1)
1432 switch (handle_exception (ourstatus
))
1435 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1438 retval
= current_event
.dwThreadId
;
1442 continue_status
= -1;
1447 case OUTPUT_DEBUG_STRING_EVENT
: /* message from the kernel */
1448 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1449 (unsigned) current_event
.dwProcessId
,
1450 (unsigned) current_event
.dwThreadId
,
1451 "OUTPUT_DEBUG_STRING_EVENT"));
1452 if (saw_create
!= 1)
1454 retval
= handle_output_debug_string (ourstatus
);
1458 if (saw_create
!= 1)
1460 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1461 (DWORD
) current_event
.dwProcessId
,
1462 (DWORD
) current_event
.dwThreadId
);
1463 printf_unfiltered (" unknown event code %ld\n",
1464 current_event
.dwDebugEventCode
);
1468 if (!retval
|| saw_create
!= 1)
1470 if (continue_status
== -1)
1471 windows_resume (ops
, minus_one_ptid
, 0, 1);
1473 CHECK (windows_continue (continue_status
, -1));
1477 inferior_ptid
= ptid_build (current_event
.dwProcessId
, 0,
1479 current_thread
= th
?: thread_rec (current_event
.dwThreadId
, TRUE
);
1486 /* Wait for interesting events to occur in the target process. */
1488 windows_wait (struct target_ops
*ops
,
1489 ptid_t ptid
, struct target_waitstatus
*ourstatus
)
1493 target_terminal_ours ();
1495 /* We loop when we get a non-standard exception rather than return
1496 with a SPURIOUS because resume can try and step or modify things,
1497 which needs a current_thread->h. But some of these exceptions mark
1498 the birth or death of threads, which mean that the current thread
1499 isn't necessarily what you think it is. */
1505 /* If the user presses Ctrl-c while the debugger is waiting
1506 for an event, he expects the debugger to interrupt his program
1507 and to get the prompt back. There are two possible situations:
1509 - The debugger and the program do not share the console, in
1510 which case the Ctrl-c event only reached the debugger.
1511 In that case, the ctrl_c handler will take care of interrupting
1512 the inferior. Note that this case is working starting with
1513 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1516 - The debugger and the program share the same console, in which
1517 case both debugger and inferior will receive the Ctrl-c event.
1518 In that case the ctrl_c handler will ignore the event, as the
1519 Ctrl-c event generated inside the inferior will trigger the
1520 expected debug event.
1522 FIXME: brobecker/2008-05-20: If the inferior receives the
1523 signal first and the delay until GDB receives that signal
1524 is sufficiently long, GDB can sometimes receive the SIGINT
1525 after we have unblocked the CTRL+C handler. This would
1526 lead to the debugger stopping prematurely while handling
1527 the new-thread event that comes with the handling of the SIGINT
1528 inside the inferior, and then stop again immediately when
1529 the user tries to resume the execution in the inferior.
1530 This is a classic race that we should try to fix one day. */
1531 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1532 retval
= get_windows_debug_event (ops
, pid
, ourstatus
);
1533 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1536 return ptid_build (current_event
.dwProcessId
, 0, retval
);
1541 if (deprecated_ui_loop_hook
!= NULL
)
1542 detach
= deprecated_ui_loop_hook (0);
1545 windows_kill_inferior (ops
);
1551 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1553 extern int stop_after_trap
;
1555 struct inferior
*inf
;
1556 struct thread_info
*tp
;
1558 last_sig
= TARGET_SIGNAL_0
;
1560 exception_count
= 0;
1561 open_process_used
= 0;
1562 debug_registers_changed
= 0;
1563 debug_registers_used
= 0;
1564 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1567 cygwin_load_start
= cygwin_load_end
= 0;
1569 current_event
.dwProcessId
= pid
;
1570 memset (¤t_event
, 0, sizeof (current_event
));
1572 disable_breakpoints_in_shlibs ();
1573 windows_clear_solib ();
1574 clear_proceed_status ();
1575 init_wait_for_inferior ();
1577 inf
= add_inferior (pid
);
1578 inf
->attach_flag
= attaching
;
1580 /* Make the new process the current inferior, so terminal handling
1581 can rely on it. When attaching, we don't know about any thread
1582 id here, but that's OK --- nothing should be referencing the
1583 current thread until we report an event out of windows_wait. */
1584 inferior_ptid
= pid_to_ptid (pid
);
1586 terminal_init_inferior_with_pgrp (pid
);
1587 target_terminal_inferior ();
1589 inf
->stop_soon
= STOP_QUIETLY
;
1592 stop_after_trap
= 1;
1593 wait_for_inferior (0);
1594 tp
= inferior_thread ();
1595 if (tp
->stop_signal
!= TARGET_SIGNAL_TRAP
)
1596 resume (0, tp
->stop_signal
);
1601 inf
->stop_soon
= NO_STOP_QUIETLY
;
1602 stop_after_trap
= 0;
1606 /* Try to set or remove a user privilege to the current process. Return -1
1607 if that fails, the previous setting of that privilege otherwise.
1609 This code is copied from the Cygwin source code and rearranged to allow
1610 dynamically loading of the needed symbols from advapi32 which is only
1611 available on NT/2K/XP. */
1613 set_process_privilege (const char *privilege
, BOOL enable
)
1615 HANDLE token_hdl
= NULL
;
1617 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1621 if (!OpenProcessToken (GetCurrentProcess (),
1622 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1626 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
1629 new_priv
.PrivilegeCount
= 1;
1630 new_priv
.Privileges
[0].Luid
= restore_priv
;
1631 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1633 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1634 sizeof orig_priv
, &orig_priv
, &size
))
1637 /* Disabled, otherwise every `attach' in an unprivileged user session
1638 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1639 windows_attach(). */
1640 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1641 be enabled. GetLastError () returns an correct error code, though. */
1642 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1646 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1650 CloseHandle (token_hdl
);
1655 /* Attach to process PID, then initialize for debugging it. */
1657 windows_attach (struct target_ops
*ops
, char *args
, int from_tty
)
1663 error_no_arg (_("process-id to attach"));
1665 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1667 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1668 printf_unfiltered ("This can cause attach to fail on Windows NT/2K/XP\n");
1671 pid
= strtoul (args
, 0, 0); /* Windows pid */
1673 windows_init_thread_list ();
1674 ok
= DebugActiveProcess (pid
);
1680 /* Try fall back to Cygwin pid */
1681 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1684 ok
= DebugActiveProcess (pid
);
1689 error (_("Can't attach to process."));
1691 DebugSetProcessKillOnExit (FALSE
);
1695 char *exec_file
= (char *) get_exec_file (0);
1698 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1699 target_pid_to_str (pid_to_ptid (pid
)));
1701 printf_unfiltered ("Attaching to %s\n",
1702 target_pid_to_str (pid_to_ptid (pid
)));
1704 gdb_flush (gdb_stdout
);
1707 do_initial_windows_stuff (ops
, pid
, 1);
1708 target_terminal_ours ();
1712 windows_detach (struct target_ops
*ops
, char *args
, int from_tty
)
1717 windows_resume (ops
, ptid
, 0, TARGET_SIGNAL_0
);
1719 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1721 error (_("Can't detach process %lu (error %lu)"),
1722 current_event
.dwProcessId
, GetLastError ());
1725 DebugSetProcessKillOnExit (FALSE
);
1727 if (detached
&& from_tty
)
1729 char *exec_file
= get_exec_file (0);
1732 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file
,
1733 current_event
.dwProcessId
);
1734 gdb_flush (gdb_stdout
);
1737 inferior_ptid
= null_ptid
;
1738 detach_inferior (current_event
.dwProcessId
);
1740 unpush_target (ops
);
1744 windows_pid_to_exec_file (int pid
)
1746 static char path
[MAX_PATH
+ 1];
1749 /* Try to find exe name as symlink target of /proc/<pid>/exe */
1751 char procexe
[sizeof ("/proc/4294967295/exe")];
1752 sprintf (procexe
, "/proc/%u/exe", pid
);
1753 nchars
= readlink (procexe
, path
, sizeof(path
));
1754 if (nchars
> 0 && nchars
< sizeof (path
))
1756 path
[nchars
] = '\0'; /* Got it */
1761 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
1762 of gdb, or we're trying to debug a non-Cygwin windows executable. */
1763 if (!get_module_name (0, path
))
1769 /* Print status information about what we're accessing. */
1772 windows_files_info (struct target_ops
*ignore
)
1774 struct inferior
*inf
= current_inferior ();
1776 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1777 inf
->attach_flag
? "attached" : "child",
1778 target_pid_to_str (inferior_ptid
));
1782 windows_open (char *arg
, int from_tty
)
1784 error (_("Use the \"run\" command to start a Unix child process."));
1787 /* Start an inferior windows child process and sets inferior_ptid to its pid.
1788 EXEC_FILE is the file to run.
1789 ALLARGS is a string containing the arguments to the program.
1790 ENV is the environment vector to pass. Errors reported with error(). */
1793 windows_create_inferior (struct target_ops
*ops
, char *exec_file
,
1794 char *allargs
, char **in_env
, int from_tty
)
1797 PROCESS_INFORMATION pi
;
1801 char real_path
[MAXPATHLEN
];
1803 char shell
[MAX_PATH
+ 1]; /* Path to shell */
1807 int ostdin
, ostdout
, ostderr
;
1811 const char *inferior_io_terminal
= get_inferior_io_terminal ();
1814 error (_("No executable specified, use `target exec'."));
1816 memset (&si
, 0, sizeof (si
));
1817 si
.cb
= sizeof (si
);
1822 flags
= DEBUG_ONLY_THIS_PROCESS
;
1823 cygwin_conv_to_win32_path (exec_file
, real_path
);
1829 sh
= getenv ("SHELL");
1832 cygwin_conv_to_win32_path (sh
, shell
);
1833 newallargs
= alloca (sizeof (" -c 'exec '") + strlen (exec_file
)
1834 + strlen (allargs
) + 2);
1835 sprintf (newallargs
, " -c 'exec %s %s'", exec_file
, allargs
);
1836 allargs
= newallargs
;
1838 flags
= DEBUG_PROCESS
;
1842 flags
= DEBUG_ONLY_THIS_PROCESS
;
1846 flags
|= CREATE_NEW_PROCESS_GROUP
;
1849 flags
|= CREATE_NEW_CONSOLE
;
1851 args
= alloca (strlen (toexec
) + strlen (allargs
) + 2);
1852 strcpy (args
, toexec
);
1854 strcat (args
, allargs
);
1857 /* Prepare the environment vars for CreateProcess. */
1858 cygwin_internal (CW_SYNC_WINENV
);
1860 if (!inferior_io_terminal
)
1861 tty
= ostdin
= ostdout
= ostderr
= -1;
1864 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
1867 print_sys_errmsg (inferior_io_terminal
, errno
);
1868 ostdin
= ostdout
= ostderr
= -1;
1881 if (!inferior_io_terminal
)
1882 tty
= INVALID_HANDLE_VALUE
;
1885 SECURITY_ATTRIBUTES sa
;
1886 sa
.nLength
= sizeof(sa
);
1887 sa
.lpSecurityDescriptor
= 0;
1888 sa
.bInheritHandle
= TRUE
;
1889 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
1890 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
1891 if (tty
== INVALID_HANDLE_VALUE
)
1892 warning (_("Warning: Failed to open TTY %s, error %#x."),
1893 inferior_io_terminal
, (unsigned) GetLastError ());
1897 si
.hStdOutput
= tty
;
1899 si
.dwFlags
|= STARTF_USESTDHANDLES
;
1904 windows_init_thread_list ();
1905 ret
= CreateProcess (0,
1906 args
, /* command line */
1907 NULL
, /* Security */
1909 TRUE
, /* inherit handles */
1910 flags
, /* start flags */
1911 NULL
, /* environment */
1912 NULL
, /* current directory */
1928 if (tty
!= INVALID_HANDLE_VALUE
)
1933 error (_("Error creating process %s, (error %d)."),
1934 exec_file
, (unsigned) GetLastError ());
1936 CloseHandle (pi
.hThread
);
1937 CloseHandle (pi
.hProcess
);
1939 if (useshell
&& shell
[0] != '\0')
1944 do_initial_windows_stuff (ops
, pi
.dwProcessId
, 0);
1946 /* windows_continue (DBG_CONTINUE, -1); */
1950 windows_mourn_inferior (struct target_ops
*ops
)
1952 (void) windows_continue (DBG_CONTINUE
, -1);
1953 i386_cleanup_dregs();
1954 if (open_process_used
)
1956 CHECK (CloseHandle (current_process_handle
));
1957 open_process_used
= 0;
1959 unpush_target (ops
);
1960 generic_mourn_inferior ();
1963 /* Send a SIGINT to the process group. This acts just like the user typed a
1964 ^C on the controlling terminal. */
1967 windows_stop (ptid_t ptid
)
1969 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1970 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
1971 registers_changed (); /* refresh register state */
1975 windows_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*our
, int len
,
1976 int write
, struct mem_attrib
*mem
,
1977 struct target_ops
*target
)
1982 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1983 len
, (DWORD
) (uintptr_t) memaddr
));
1984 if (!WriteProcessMemory (current_process_handle
,
1985 (LPVOID
) (uintptr_t) memaddr
, our
,
1988 FlushInstructionCache (current_process_handle
,
1989 (LPCVOID
) (uintptr_t) memaddr
, len
);
1993 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
1994 len
, (DWORD
) (uintptr_t) memaddr
));
1995 if (!ReadProcessMemory (current_process_handle
,
1996 (LPCVOID
) (uintptr_t) memaddr
, our
,
2004 windows_kill_inferior (struct target_ops
*ops
)
2006 CHECK (TerminateProcess (current_process_handle
, 0));
2010 if (!windows_continue (DBG_CONTINUE
, -1))
2012 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
2014 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2018 target_mourn_inferior (); /* or just windows_mourn_inferior? */
2022 windows_prepare_to_store (struct regcache
*regcache
)
2024 /* Do nothing, since we can store individual regs */
2028 windows_can_run (void)
2034 windows_close (int x
)
2036 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2037 PIDGET (inferior_ptid
)));
2040 /* Convert pid to printable format. */
2042 windows_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
2044 static char buf
[80];
2046 if (ptid_get_tid (ptid
) != 0)
2048 snprintf (buf
, sizeof (buf
), "Thread %d.0x%lx",
2049 ptid_get_pid (ptid
), ptid_get_tid (ptid
));
2053 return normal_pid_to_str (ptid
);
2057 windows_xfer_shared_libraries (struct target_ops
*ops
,
2058 enum target_object object
, const char *annex
,
2059 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2060 ULONGEST offset
, LONGEST len
)
2062 struct obstack obstack
;
2070 obstack_init (&obstack
);
2071 obstack_grow_str (&obstack
, "<library-list>\n");
2072 for (so
= solib_start
.next
; so
; so
= so
->next
)
2073 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
) (uintptr_t) so
->lm_info
->load_addr
,
2075 obstack_grow_str0 (&obstack
, "</library-list>\n");
2077 buf
= obstack_finish (&obstack
);
2078 len_avail
= strlen (buf
);
2079 if (offset
>= len_avail
)
2082 if (len
> len_avail
- offset
)
2083 len
= len_avail
- offset
;
2084 memcpy (readbuf
, buf
+ offset
, len
);
2086 obstack_free (&obstack
, NULL
);
2091 windows_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2092 const char *annex
, gdb_byte
*readbuf
,
2093 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
2097 case TARGET_OBJECT_MEMORY
:
2099 return (*ops
->deprecated_xfer_memory
) (offset
, readbuf
,
2100 len
, 0/*read*/, NULL
, ops
);
2102 return (*ops
->deprecated_xfer_memory
) (offset
, (gdb_byte
*) writebuf
,
2103 len
, 1/*write*/, NULL
, ops
);
2106 case TARGET_OBJECT_LIBRARIES
:
2107 return windows_xfer_shared_libraries (ops
, object
, annex
, readbuf
,
2108 writebuf
, offset
, len
);
2111 if (ops
->beneath
!= NULL
)
2112 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2113 readbuf
, writebuf
, offset
, len
);
2119 init_windows_ops (void)
2121 windows_ops
.to_shortname
= "child";
2122 windows_ops
.to_longname
= "Win32 child process";
2123 windows_ops
.to_doc
= "Win32 child process (started by the \"run\" command).";
2124 windows_ops
.to_open
= windows_open
;
2125 windows_ops
.to_close
= windows_close
;
2126 windows_ops
.to_attach
= windows_attach
;
2127 windows_ops
.to_attach_no_wait
= 1;
2128 windows_ops
.to_detach
= windows_detach
;
2129 windows_ops
.to_resume
= windows_resume
;
2130 windows_ops
.to_wait
= windows_wait
;
2131 windows_ops
.to_fetch_registers
= windows_fetch_inferior_registers
;
2132 windows_ops
.to_store_registers
= windows_store_inferior_registers
;
2133 windows_ops
.to_prepare_to_store
= windows_prepare_to_store
;
2134 windows_ops
.deprecated_xfer_memory
= windows_xfer_memory
;
2135 windows_ops
.to_xfer_partial
= windows_xfer_partial
;
2136 windows_ops
.to_files_info
= windows_files_info
;
2137 windows_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
2138 windows_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
2139 windows_ops
.to_terminal_init
= terminal_init_inferior
;
2140 windows_ops
.to_terminal_inferior
= terminal_inferior
;
2141 windows_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
2142 windows_ops
.to_terminal_ours
= terminal_ours
;
2143 windows_ops
.to_terminal_save_ours
= terminal_save_ours
;
2144 windows_ops
.to_terminal_info
= child_terminal_info
;
2145 windows_ops
.to_kill
= windows_kill_inferior
;
2146 windows_ops
.to_create_inferior
= windows_create_inferior
;
2147 windows_ops
.to_mourn_inferior
= windows_mourn_inferior
;
2148 windows_ops
.to_can_run
= windows_can_run
;
2149 windows_ops
.to_thread_alive
= windows_thread_alive
;
2150 windows_ops
.to_pid_to_str
= windows_pid_to_str
;
2151 windows_ops
.to_stop
= windows_stop
;
2152 windows_ops
.to_stratum
= process_stratum
;
2153 windows_ops
.to_has_all_memory
= 1;
2154 windows_ops
.to_has_memory
= 1;
2155 windows_ops
.to_has_stack
= 1;
2156 windows_ops
.to_has_registers
= 1;
2157 windows_ops
.to_has_execution
= 1;
2158 windows_ops
.to_pid_to_exec_file
= windows_pid_to_exec_file
;
2159 i386_use_watchpoints (&windows_ops
);
2161 windows_ops
.to_magic
= OPS_MAGIC
;
2165 set_windows_aliases (char *argv0
)
2167 add_info_alias ("dll", "sharedlibrary", 1);
2171 _initialize_windows_nat (void)
2173 struct cmd_list_element
*c
;
2175 init_windows_ops ();
2177 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
2178 _("Load dll library symbols from FILE."));
2179 set_cmd_completer (c
, filename_completer
);
2181 add_com_alias ("sharedlibrary", "dll-symbols", class_alias
, 1);
2184 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
2185 Set use of shell to start subprocess."), _("\
2186 Show use of shell to start subprocess."), NULL
,
2188 NULL
, /* FIXME: i18n: */
2189 &setlist
, &showlist
);
2191 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
, &cygwin_exceptions
, _("\
2192 Break when an exception is detected in the Cygwin DLL itself."), _("\
2193 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
2195 NULL
, /* FIXME: i18n: */
2196 &setlist
, &showlist
);
2199 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
2200 Set creation of new console when creating child process."), _("\
2201 Show creation of new console when creating child process."), NULL
,
2203 NULL
, /* FIXME: i18n: */
2204 &setlist
, &showlist
);
2206 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
2207 Set creation of new group when creating child process."), _("\
2208 Show creation of new group when creating child process."), NULL
,
2210 NULL
, /* FIXME: i18n: */
2211 &setlist
, &showlist
);
2213 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
2214 Set whether to display execution in child process."), _("\
2215 Show whether to display execution in child process."), NULL
,
2217 NULL
, /* FIXME: i18n: */
2218 &setlist
, &showlist
);
2220 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
2221 Set whether to display kernel events in child process."), _("\
2222 Show whether to display kernel events in child process."), NULL
,
2224 NULL
, /* FIXME: i18n: */
2225 &setlist
, &showlist
);
2227 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
2228 Set whether to display memory accesses in child process."), _("\
2229 Show whether to display memory accesses in child process."), NULL
,
2231 NULL
, /* FIXME: i18n: */
2232 &setlist
, &showlist
);
2234 add_setshow_boolean_cmd ("debugexceptions", class_support
,
2235 &debug_exceptions
, _("\
2236 Set whether to display kernel exceptions in child process."), _("\
2237 Show whether to display kernel exceptions in child process."), NULL
,
2239 NULL
, /* FIXME: i18n: */
2240 &setlist
, &showlist
);
2242 add_prefix_cmd ("w32", class_info
, info_w32_command
,
2243 _("Print information specific to Win32 debugging."),
2244 &info_w32_cmdlist
, "info w32 ", 0, &infolist
);
2246 add_cmd ("selector", class_info
, display_selectors
,
2247 _("Display selectors infos."),
2249 add_target (&windows_ops
);
2250 deprecated_init_ui_hook
= set_windows_aliases
;
2253 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2255 /* Pass the address ADDR to the inferior in the I'th debug register.
2256 Here we just store the address in dr array, the registers will be
2257 actually set up when windows_continue is called. */
2259 cygwin_set_dr (int i
, CORE_ADDR addr
)
2262 internal_error (__FILE__
, __LINE__
,
2263 _("Invalid register %d in cygwin_set_dr.\n"), i
);
2265 debug_registers_changed
= 1;
2266 debug_registers_used
= 1;
2269 /* Pass the value VAL to the inferior in the DR7 debug control
2270 register. Here we just store the address in D_REGS, the watchpoint
2271 will be actually set up in windows_wait. */
2273 cygwin_set_dr7 (unsigned val
)
2276 debug_registers_changed
= 1;
2277 debug_registers_used
= 1;
2280 /* Get the value of the DR6 debug status register from the inferior.
2281 Here we just return the value stored in dr[6]
2282 by the last call to thread_rec for current_event.dwThreadId id. */
2284 cygwin_get_dr6 (void)
2289 /* Determine if the thread referenced by "ptid" is alive
2290 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2291 it means that the thread has died. Otherwise it is assumed to be alive. */
2293 windows_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
2297 gdb_assert (ptid_get_tid (ptid
) != 0);
2298 tid
= ptid_get_tid (ptid
);
2300 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
?
2305 _initialize_check_for_gdb_ini (void)
2308 if (inhibit_gdbinit
)
2311 homedir
= getenv ("HOME");
2315 char *oldini
= (char *) alloca (strlen (homedir
) +
2316 sizeof ("/gdb.ini"));
2317 strcpy (oldini
, homedir
);
2318 p
= strchr (oldini
, '\0');
2319 if (p
> oldini
&& p
[-1] != '/')
2321 strcpy (p
, "gdb.ini");
2322 if (access (oldini
, 0) == 0)
2324 int len
= strlen (oldini
);
2325 char *newini
= alloca (len
+ 1);
2326 sprintf (newini
, "%.*s.gdbinit",
2327 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
2328 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
2333 /* Define dummy functions which always return error for the rare cases where
2334 these functions could not be found. */
2336 bad_DebugActiveProcessStop (DWORD w
)
2341 bad_DebugBreakProcess (HANDLE w
)
2346 bad_DebugSetProcessKillOnExit (BOOL w
)
2351 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
2356 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
2361 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
2367 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
2372 /* Load any functions which may not be available in ancient versions
2375 _initialize_loadable (void)
2379 hm
= LoadLibrary ("kernel32.dll");
2382 dyn_DebugActiveProcessStop
= (void *)
2383 GetProcAddress (hm
, "DebugActiveProcessStop");
2384 dyn_DebugBreakProcess
= (void *)
2385 GetProcAddress (hm
, "DebugBreakProcess");
2386 dyn_DebugSetProcessKillOnExit
= (void *)
2387 GetProcAddress (hm
, "DebugSetProcessKillOnExit");
2390 /* Set variables to dummy versions of these processes if the function
2391 wasn't found in kernel32.dll. */
2392 if (!dyn_DebugBreakProcess
)
2393 dyn_DebugBreakProcess
= bad_DebugBreakProcess
;
2394 if (!dyn_DebugActiveProcessStop
|| !dyn_DebugSetProcessKillOnExit
)
2396 dyn_DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
2397 dyn_DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
2400 /* Load optional functions used for retrieving filename information
2401 associated with the currently debugged process or its dlls. */
2402 hm
= LoadLibrary ("psapi.dll");
2405 dyn_EnumProcessModules
= (void *)
2406 GetProcAddress (hm
, "EnumProcessModules");
2407 dyn_GetModuleInformation
= (void *)
2408 GetProcAddress (hm
, "GetModuleInformation");
2409 dyn_GetModuleFileNameExA
= (void *)
2410 GetProcAddress (hm
, "GetModuleFileNameExA");
2413 if (!dyn_EnumProcessModules
|| !dyn_GetModuleInformation
|| !dyn_GetModuleFileNameExA
)
2415 /* Set variables to dummy versions of these processes if the function
2416 wasn't found in psapi.dll. */
2417 dyn_EnumProcessModules
= bad_EnumProcessModules
;
2418 dyn_GetModuleInformation
= bad_GetModuleInformation
;
2419 dyn_GetModuleFileNameExA
= bad_GetModuleFileNameExA
;
2420 /* This will probably fail on Windows 9x/Me. Let the user know that we're
2421 missing some functionality. */
2422 warning(_("cannot automatically find executable file or library to read symbols.\nUse \"file\" or \"dll\" command to load executable/libraries directly."));
2425 hm
= LoadLibrary ("advapi32.dll");
2428 dyn_OpenProcessToken
= (void *)
2429 GetProcAddress (hm
, "OpenProcessToken");
2430 dyn_LookupPrivilegeValueA
= (void *)
2431 GetProcAddress (hm
, "LookupPrivilegeValueA");
2432 dyn_AdjustTokenPrivileges
= (void *)
2433 GetProcAddress (hm
, "AdjustTokenPrivileges");
2434 /* Only need to set one of these since if OpenProcessToken fails nothing
2436 if (!dyn_OpenProcessToken
|| !dyn_LookupPrivilegeValueA
|| !dyn_AdjustTokenPrivileges
)
2437 dyn_OpenProcessToken
= bad_OpenProcessToken
;