1 /* Target-vector operations for controlling win32 child processes, for GDB.
3 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
4 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
6 Contributed by Cygnus Solutions, A Red Hat Company.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 /* Originally by Steve Chamberlain, sac@cygnus.com */
26 #include "frame.h" /* required by inferior.h */
29 #include "exceptions.h"
32 #include "completer.h"
36 #include <sys/types.h>
42 #include <sys/cygwin.h>
49 #include "gdb_obstack.h"
50 #include "gdb_string.h"
51 #include "gdbthread.h"
53 #include <sys/param.h>
58 #include "xml-support.h"
60 #include "i386-tdep.h"
61 #include "i387-tdep.h"
63 #include "i386-cygwin-tdep.h"
65 static struct target_ops win32_ops
;
68 /* The starting and ending address of the cygwin1.dll text segment. */
69 static bfd_vma cygwin_load_start
;
70 static bfd_vma cygwin_load_end
;
73 static int have_saved_context
; /* True if we've saved context from a cygwin signal. */
74 static CONTEXT saved_context
; /* Containes the saved context from a cygwin signal. */
76 /* If we're not using the old Cygwin header file set, define the
77 following which never should have been in the generic Win32 API
78 headers in the first place since they were our own invention... */
79 #ifndef _GNU_H_WINDOWS_H
82 FLAG_TRACE_BIT
= 0x100,
83 CONTEXT_DEBUGGER
= (CONTEXT_FULL
| CONTEXT_FLOATING_POINT
)
88 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \
89 | CONTEXT_EXTENDED_REGISTERS
91 static unsigned dr
[8];
92 static int debug_registers_changed
;
93 static int debug_registers_used
;
94 #define DR6_CLEAR_VALUE 0xffff0ff0
96 /* The string sent by cygwin when it processes a signal.
97 FIXME: This should be in a cygwin include file. */
98 #ifndef _CYGWIN_SIGNAL_STRING
99 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
102 #define CHECK(x) check (x, __FILE__,__LINE__)
103 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
104 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
105 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
106 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
108 static void win32_stop (ptid_t
);
109 static int win32_win32_thread_alive (ptid_t
);
110 static void win32_kill_inferior (void);
112 static enum target_signal last_sig
= TARGET_SIGNAL_0
;
113 /* Set if a signal was received from the debugged process */
115 /* Thread information structure used to track information that is
116 not available in gdb's thread structure. */
117 typedef struct thread_info_struct
119 struct thread_info_struct
*next
;
130 static thread_info thread_head
;
132 /* The process and thread handles for the above context. */
134 static DEBUG_EVENT current_event
; /* The current debug event from
136 static HANDLE current_process_handle
; /* Currently executing process */
137 static thread_info
*current_thread
; /* Info on currently selected thread */
138 static DWORD main_thread_id
; /* Thread ID of the main thread */
140 /* Counts of things. */
141 static int exception_count
= 0;
142 static int event_count
= 0;
143 static int saw_create
;
144 static int open_process_used
= 0;
147 static int new_console
= 0;
149 static int cygwin_exceptions
= 0;
151 static int new_group
= 1;
152 static int debug_exec
= 0; /* show execution */
153 static int debug_events
= 0; /* show events from kernel */
154 static int debug_memory
= 0; /* show target memory accesses */
155 static int debug_exceptions
= 0; /* show target exceptions */
156 static int useshell
= 0; /* use shell for subprocesses */
158 /* This vector maps GDB's idea of a register's number into an address
159 in the win32 exception context vector.
161 It also contains the bit mask needed to load the register in question.
163 One day we could read a reg, we could inspect the context we
164 already have loaded, if it doesn't have the bit set that we need,
165 we read that set of registers in using GetThreadContext. If the
166 context already contains what we need, we just unpack it. Then to
167 write a register, first we have to ensure that the context contains
168 the other regs of the group, and then we copy the info in and set
171 #define context_offset(x) ((int)&(((CONTEXT *)NULL)->x))
172 static const int mappings
[] =
174 context_offset (Eax
),
175 context_offset (Ecx
),
176 context_offset (Edx
),
177 context_offset (Ebx
),
178 context_offset (Esp
),
179 context_offset (Ebp
),
180 context_offset (Esi
),
181 context_offset (Edi
),
182 context_offset (Eip
),
183 context_offset (EFlags
),
184 context_offset (SegCs
),
185 context_offset (SegSs
),
186 context_offset (SegDs
),
187 context_offset (SegEs
),
188 context_offset (SegFs
),
189 context_offset (SegGs
),
190 context_offset (FloatSave
.RegisterArea
[0 * 10]),
191 context_offset (FloatSave
.RegisterArea
[1 * 10]),
192 context_offset (FloatSave
.RegisterArea
[2 * 10]),
193 context_offset (FloatSave
.RegisterArea
[3 * 10]),
194 context_offset (FloatSave
.RegisterArea
[4 * 10]),
195 context_offset (FloatSave
.RegisterArea
[5 * 10]),
196 context_offset (FloatSave
.RegisterArea
[6 * 10]),
197 context_offset (FloatSave
.RegisterArea
[7 * 10]),
198 context_offset (FloatSave
.ControlWord
),
199 context_offset (FloatSave
.StatusWord
),
200 context_offset (FloatSave
.TagWord
),
201 context_offset (FloatSave
.ErrorSelector
),
202 context_offset (FloatSave
.ErrorOffset
),
203 context_offset (FloatSave
.DataSelector
),
204 context_offset (FloatSave
.DataOffset
),
205 context_offset (FloatSave
.ErrorSelector
)
207 context_offset (ExtendedRegisters
[10*16]),
208 context_offset (ExtendedRegisters
[11*16]),
209 context_offset (ExtendedRegisters
[12*16]),
210 context_offset (ExtendedRegisters
[13*16]),
211 context_offset (ExtendedRegisters
[14*16]),
212 context_offset (ExtendedRegisters
[15*16]),
213 context_offset (ExtendedRegisters
[16*16]),
214 context_offset (ExtendedRegisters
[17*16]),
216 context_offset (ExtendedRegisters
[24])
219 #undef context_offset
221 /* This vector maps the target's idea of an exception (extracted
222 from the DEBUG_EVENT structure) to GDB's idea. */
224 struct xlate_exception
227 enum target_signal us
;
230 static const struct xlate_exception
233 {EXCEPTION_ACCESS_VIOLATION
, TARGET_SIGNAL_SEGV
},
234 {STATUS_STACK_OVERFLOW
, TARGET_SIGNAL_SEGV
},
235 {EXCEPTION_BREAKPOINT
, TARGET_SIGNAL_TRAP
},
236 {DBG_CONTROL_C
, TARGET_SIGNAL_INT
},
237 {EXCEPTION_SINGLE_STEP
, TARGET_SIGNAL_TRAP
},
238 {STATUS_FLOAT_DIVIDE_BY_ZERO
, TARGET_SIGNAL_FPE
},
242 check (BOOL ok
, const char *file
, int line
)
245 printf_filtered ("error return %s:%d was %lu\n", file
, line
,
249 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
250 then also retrieve the context for this thread. If GET_CONTEXT is
251 negative, then don't suspend the thread. */
253 thread_rec (DWORD id
, int get_context
)
257 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
260 if (!th
->suspended
&& get_context
)
262 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
264 if (SuspendThread (th
->h
) == (DWORD
) -1)
266 DWORD err
= GetLastError ();
267 warning (_("SuspendThread failed. (winerr %d)"),
273 else if (get_context
< 0)
275 th
->reload_context
= 1;
283 /* Add a thread to the thread list. */
285 win32_add_thread (ptid_t ptid
, HANDLE h
)
290 gdb_assert (ptid_get_tid (ptid
) != 0);
292 id
= ptid_get_tid (ptid
);
294 if ((th
= thread_rec (id
, FALSE
)))
297 th
= XZALLOC (thread_info
);
300 th
->next
= thread_head
.next
;
301 thread_head
.next
= th
;
303 /* Set the debug registers for the new thread if they are used. */
304 if (debug_registers_used
)
306 /* Only change the value of the debug registers. */
307 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
308 CHECK (GetThreadContext (th
->h
, &th
->context
));
309 th
->context
.Dr0
= dr
[0];
310 th
->context
.Dr1
= dr
[1];
311 th
->context
.Dr2
= dr
[2];
312 th
->context
.Dr3
= dr
[3];
313 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
314 th
->context
.Dr7
= dr
[7];
315 CHECK (SetThreadContext (th
->h
, &th
->context
));
316 th
->context
.ContextFlags
= 0;
321 /* Clear out any old thread list and reintialize it to a
324 win32_init_thread_list (void)
326 thread_info
*th
= &thread_head
;
328 DEBUG_EVENTS (("gdb: win32_init_thread_list\n"));
330 while (th
->next
!= NULL
)
332 thread_info
*here
= th
->next
;
333 th
->next
= here
->next
;
336 thread_head
.next
= NULL
;
339 /* Delete a thread from the list of threads */
341 win32_delete_thread (ptid_t ptid
)
346 gdb_assert (ptid_get_tid (ptid
) != 0);
348 id
= ptid_get_tid (ptid
);
351 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
));
352 delete_thread (ptid
);
354 for (th
= &thread_head
;
355 th
->next
!= NULL
&& th
->next
->id
!= id
;
359 if (th
->next
!= NULL
)
361 thread_info
*here
= th
->next
;
362 th
->next
= here
->next
;
368 do_win32_fetch_inferior_registers (struct regcache
*regcache
, int r
)
370 char *context_offset
= ((char *) ¤t_thread
->context
) + mappings
[r
];
371 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
372 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
376 return; /* Windows sometimes uses a non-existent thread id in its
379 if (current_thread
->reload_context
)
381 #ifdef __COPY_CONTEXT_SIZE
382 if (have_saved_context
)
384 /* Lie about where the program actually is stopped since cygwin has informed us that
385 we should consider the signal to have occurred at another location which is stored
386 in "saved_context. */
387 memcpy (¤t_thread
->context
, &saved_context
, __COPY_CONTEXT_SIZE
);
388 have_saved_context
= 0;
393 thread_info
*th
= current_thread
;
394 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
395 GetThreadContext (th
->h
, &th
->context
);
396 /* Copy dr values from that thread.
397 But only if there were not modified since last stop. PR gdb/2388 */
398 if (!debug_registers_changed
)
400 dr
[0] = th
->context
.Dr0
;
401 dr
[1] = th
->context
.Dr1
;
402 dr
[2] = th
->context
.Dr2
;
403 dr
[3] = th
->context
.Dr3
;
404 dr
[6] = th
->context
.Dr6
;
405 dr
[7] = th
->context
.Dr7
;
408 current_thread
->reload_context
= 0;
411 if (r
== I387_FISEG_REGNUM (tdep
))
413 l
= *((long *) context_offset
) & 0xffff;
414 regcache_raw_supply (regcache
, r
, (char *) &l
);
416 else if (r
== I387_FOP_REGNUM (tdep
))
418 l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
419 regcache_raw_supply (regcache
, r
, (char *) &l
);
422 regcache_raw_supply (regcache
, r
, context_offset
);
425 for (r
= 0; r
< gdbarch_num_regs (gdbarch
); r
++)
426 do_win32_fetch_inferior_registers (regcache
, r
);
431 win32_fetch_inferior_registers (struct regcache
*regcache
, int r
)
433 current_thread
= thread_rec (ptid_get_tid (inferior_ptid
), TRUE
);
434 /* Check if current_thread exists. Windows sometimes uses a non-existent
435 thread id in its events */
437 do_win32_fetch_inferior_registers (regcache
, r
);
441 do_win32_store_inferior_registers (const struct regcache
*regcache
, int r
)
444 /* Windows sometimes uses a non-existent thread id in its events */;
446 regcache_raw_collect (regcache
, r
,
447 ((char *) ¤t_thread
->context
) + mappings
[r
]);
450 for (r
= 0; r
< gdbarch_num_regs (get_regcache_arch (regcache
)); r
++)
451 do_win32_store_inferior_registers (regcache
, r
);
455 /* Store a new register value into the current thread context */
457 win32_store_inferior_registers (struct regcache
*regcache
, int r
)
459 current_thread
= thread_rec (ptid_get_tid (inferior_ptid
), TRUE
);
460 /* Check if current_thread exists. Windows sometimes uses a non-existent
461 thread id in its events */
463 do_win32_store_inferior_registers (regcache
, r
);
466 static int psapi_loaded
= 0;
467 static BOOL
WINAPI (*psapi_EnumProcessModules
) (HANDLE
, HMODULE
*, DWORD
,
469 static BOOL
WINAPI (*psapi_GetModuleInformation
) (HANDLE
, HMODULE
, LPMODULEINFO
,
471 static DWORD
WINAPI (*psapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
, LPSTR
,
474 /* Get the name of a given module at at given base address. If base_address
475 is zero return the first loaded module (which is always the name of the
478 get_module_name (DWORD base_address
, char *dll_name_ret
)
484 HMODULE
*DllHandle
= dh_buf
; /* Set to temporary storage for initial query */
487 char pathbuf
[PATH_MAX
+ 1]; /* Temporary storage prior to converting to
490 char *pathbuf
= dll_name_ret
; /* Just copy directly to passed-in arg */
493 /* If psapi_loaded < 0 either psapi.dll is not available or it does not contain
494 the needed functions. */
495 if (psapi_loaded
<= 0)
499 /* Find size of buffer needed to handle list of modules loaded in inferior */
500 if (!psapi_EnumProcessModules (current_process_handle
, DllHandle
,
501 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
504 /* Allocate correct amount of space for module list */
505 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
509 /* Get the list of modules */
510 if (!psapi_EnumProcessModules (current_process_handle
, DllHandle
, cbNeeded
,
514 for (i
= 0; i
< (int) (cbNeeded
/ sizeof (HMODULE
)); i
++)
516 /* Get information on this module */
517 if (!psapi_GetModuleInformation (current_process_handle
, DllHandle
[i
],
519 error (_("Can't get module info"));
521 if (!base_address
|| (DWORD
) (mi
.lpBaseOfDll
) == base_address
)
523 /* Try to find the name of the given module */
524 len
= psapi_GetModuleFileNameExA (current_process_handle
,
525 DllHandle
[i
], pathbuf
, MAX_PATH
);
527 error (_("Error getting dll name: %u."), (unsigned) GetLastError ());
529 /* Cygwin prefers that the path be in /x/y/z format */
530 cygwin_conv_to_full_posix_path (pathbuf
, dll_name_ret
);
532 return 1; /* success */
537 dll_name_ret
[0] = '\0';
538 return 0; /* failure */
541 /* Encapsulate the information required in a call to
542 symbol_file_add_args */
543 struct safe_symbol_file_add_args
547 struct section_addr_info
*addrs
;
550 struct ui_file
*err
, *out
;
554 /* Maintain a linked list of "so" information. */
560 static struct so_list solib_start
, *solib_end
;
562 /* Call symbol_file_add with stderr redirected. We don't care if there
565 safe_symbol_file_add_stub (void *argv
)
567 #define p ((struct safe_symbol_file_add_args *) argv)
568 p
->ret
= symbol_file_add (p
->name
, p
->from_tty
, p
->addrs
, p
->mainline
, p
->flags
);
573 /* Restore gdb's stderr after calling symbol_file_add */
575 safe_symbol_file_add_cleanup (void *p
)
577 #define sp ((struct safe_symbol_file_add_args *)p)
578 gdb_flush (gdb_stderr
);
579 gdb_flush (gdb_stdout
);
580 ui_file_delete (gdb_stderr
);
581 ui_file_delete (gdb_stdout
);
582 gdb_stderr
= sp
->err
;
583 gdb_stdout
= sp
->out
;
587 /* symbol_file_add wrapper that prevents errors from being displayed. */
588 static struct objfile
*
589 safe_symbol_file_add (char *name
, int from_tty
,
590 struct section_addr_info
*addrs
,
591 int mainline
, int flags
)
593 struct safe_symbol_file_add_args p
;
594 struct cleanup
*cleanup
;
596 cleanup
= make_cleanup (safe_symbol_file_add_cleanup
, &p
);
600 gdb_flush (gdb_stderr
);
601 gdb_flush (gdb_stdout
);
602 gdb_stderr
= ui_file_new ();
603 gdb_stdout
= ui_file_new ();
605 p
.from_tty
= from_tty
;
607 p
.mainline
= mainline
;
609 catch_errors (safe_symbol_file_add_stub
, &p
, "", RETURN_MASK_ERROR
);
611 do_cleanups (cleanup
);
615 static struct so_list
*
616 win32_make_so (const char *name
, DWORD load_addr
)
619 char buf
[MAX_PATH
+ 1];
620 char cwd
[MAX_PATH
+ 1];
622 WIN32_FIND_DATA w32_fd
;
623 HANDLE h
= FindFirstFile(name
, &w32_fd
);
624 MEMORY_BASIC_INFORMATION m
;
626 if (h
== INVALID_HANDLE_VALUE
)
632 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
634 p
= strrchr (buf
, '\\');
637 SetCurrentDirectory (buf
);
638 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
639 SetCurrentDirectory (cwd
);
643 if (strcasecmp (buf
, "ntdll.dll") == 0)
645 GetSystemDirectory (buf
, sizeof (buf
));
646 strcat (buf
, "\\ntdll.dll");
648 so
= XZALLOC (struct so_list
);
649 so
->lm_info
= (struct lm_info
*) xmalloc (sizeof (struct lm_info
));
650 so
->lm_info
->load_addr
= load_addr
;
651 strcpy (so
->so_original_name
, name
);
653 strcpy (so
->so_name
, buf
);
655 cygwin_conv_to_posix_path (buf
, so
->so_name
);
656 /* Record cygwin1.dll .text start/end. */
657 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
658 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
661 asection
*text
= NULL
;
664 abfd
= bfd_openr (so
->so_name
, "pei-i386");
669 if (bfd_check_format (abfd
, bfd_object
))
670 text
= bfd_get_section_by_name (abfd
, ".text");
678 /* The symbols in a dll are offset by 0x1000, which is the the
679 offset from 0 of the first byte in an image - because of the
680 file header and the section alignment. */
681 cygwin_load_start
= load_addr
+ 0x1000;
682 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (abfd
, text
);
692 get_image_name (HANDLE h
, void *address
, int unicode
)
694 static char buf
[(2 * MAX_PATH
) + 1];
695 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
701 /* Attempt to read the name of the dll that was detected.
702 This is documented to work only when actively debugging
703 a program. It will not work for attached processes. */
707 /* See if we could read the address of a string, and that the
708 address isn't null. */
709 if (!ReadProcessMemory (h
, address
, &address_ptr
, sizeof (address_ptr
), &done
)
710 || done
!= sizeof (address_ptr
) || !address_ptr
)
713 /* Find the length of the string */
714 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
715 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
719 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
722 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
723 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
726 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
732 /* Wait for child to do something. Return pid of child, or -1 in case
733 of error; store status through argument pointer OURSTATUS. */
735 handle_load_dll (void *dummy
)
737 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
738 char dll_buf
[MAX_PATH
+ 1];
739 char *dll_name
= NULL
;
741 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
743 if (!get_module_name ((DWORD
) event
->lpBaseOfDll
, dll_buf
))
744 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
748 if (*dll_name
== '\0')
749 dll_name
= get_image_name (current_process_handle
,
750 event
->lpImageName
, event
->fUnicode
);
754 solib_end
->next
= win32_make_so (dll_name
, (DWORD
) event
->lpBaseOfDll
);
755 solib_end
= solib_end
->next
;
757 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at 0x%lx.\n", solib_end
->so_name
,
758 (DWORD
) solib_end
->lm_info
->load_addr
));
764 win32_free_so (struct so_list
*so
)
772 handle_unload_dll (void *dummy
)
774 DWORD lpBaseOfDll
= (DWORD
) current_event
.u
.UnloadDll
.lpBaseOfDll
;
777 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
778 if (so
->next
->lm_info
->load_addr
== lpBaseOfDll
)
780 struct so_list
*sodel
= so
->next
;
781 so
->next
= sodel
->next
;
784 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
786 win32_free_so (sodel
);
787 solib_add (NULL
, 0, NULL
, auto_solib_add
);
791 error (_("Error: dll starting at 0x%lx not found."), (DWORD
) lpBaseOfDll
);
796 /* Clear list of loaded DLLs. */
798 win32_clear_solib (void)
800 solib_start
.next
= NULL
;
801 solib_end
= &solib_start
;
804 /* Load DLL symbol info. */
806 dll_symbol_command (char *args
, int from_tty
)
812 error (_("dll-symbols requires a file name"));
815 if (n
> 4 && strcasecmp (args
+ n
- 4, ".dll") != 0)
817 char *newargs
= (char *) alloca (n
+ 4 + 1);
818 strcpy (newargs
, args
);
819 strcat (newargs
, ".dll");
823 safe_symbol_file_add (args
, from_tty
, NULL
, 0, OBJF_SHARED
| OBJF_USERLOADED
);
826 /* Handle DEBUG_STRING output from child process.
827 Cygwin prepends its messages with a "cygwin:". Interpret this as
828 a Cygwin signal. Otherwise just print the string as a warning. */
830 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
835 if (!target_read_string
836 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
840 else if (strncmp (s
, _CYGWIN_SIGNAL_STRING
, sizeof (_CYGWIN_SIGNAL_STRING
) - 1) != 0)
843 if (strncmp (s
, "cYg", 3) != 0)
847 #ifdef __COPY_CONTEXT_SIZE
850 /* Got a cygwin signal marker. A cygwin signal is followed by the signal number
851 itself and then optionally followed by the thread id and address to saved context
852 within the DLL. If these are supplied, then the given thread is assumed to have
853 issued the signal and the context from the thread is assumed to be stored at the
854 given address in the inferior. Tell gdb to treat this like a real signal. */
856 int sig
= strtol (s
+ sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
857 int gotasig
= target_signal_from_host (sig
);
858 ourstatus
->value
.sig
= gotasig
;
863 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
864 retval
= strtoul (p
, &p
, 0);
866 retval
= main_thread_id
;
867 else if ((x
= (LPCVOID
) strtoul (p
, &p
, 0))
868 && ReadProcessMemory (current_process_handle
, x
,
869 &saved_context
, __COPY_CONTEXT_SIZE
, &n
)
870 && n
== __COPY_CONTEXT_SIZE
)
871 have_saved_context
= 1;
872 current_event
.dwThreadId
= retval
;
883 display_selector (HANDLE thread
, DWORD sel
)
886 if (GetThreadSelectorEntry (thread
, sel
, &info
))
889 printf_filtered ("0x%03lx: ", sel
);
890 if (!info
.HighWord
.Bits
.Pres
)
892 puts_filtered ("Segment not present\n");
895 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
896 (info
.HighWord
.Bits
.BaseMid
<< 16)
898 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
899 if (info
.HighWord
.Bits
.Granularity
)
900 limit
= (limit
<< 12) | 0xfff;
901 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
902 if (info
.HighWord
.Bits
.Default_Big
)
903 puts_filtered(" 32-bit ");
905 puts_filtered(" 16-bit ");
906 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
909 puts_filtered ("Data (Read-Only, Exp-up");
912 puts_filtered ("Data (Read/Write, Exp-up");
915 puts_filtered ("Unused segment (");
918 puts_filtered ("Data (Read/Write, Exp-down");
921 puts_filtered ("Code (Exec-Only, N.Conf");
924 puts_filtered ("Code (Exec/Read, N.Conf");
927 puts_filtered ("Code (Exec-Only, Conf");
930 puts_filtered ("Code (Exec/Read, Conf");
933 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
935 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
936 puts_filtered(", N.Acc");
937 puts_filtered (")\n");
938 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
939 puts_filtered("System selector ");
940 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
941 if (info
.HighWord
.Bits
.Granularity
)
942 puts_filtered ("Page granular.\n");
944 puts_filtered ("Byte granular.\n");
949 printf_filtered ("Invalid selector 0x%lx.\n",sel
);
955 display_selectors (char * args
, int from_tty
)
959 puts_filtered ("Impossible to display selectors now.\n");
965 puts_filtered ("Selector $cs\n");
966 display_selector (current_thread
->h
,
967 current_thread
->context
.SegCs
);
968 puts_filtered ("Selector $ds\n");
969 display_selector (current_thread
->h
,
970 current_thread
->context
.SegDs
);
971 puts_filtered ("Selector $es\n");
972 display_selector (current_thread
->h
,
973 current_thread
->context
.SegEs
);
974 puts_filtered ("Selector $ss\n");
975 display_selector (current_thread
->h
,
976 current_thread
->context
.SegSs
);
977 puts_filtered ("Selector $fs\n");
978 display_selector (current_thread
->h
,
979 current_thread
->context
.SegFs
);
980 puts_filtered ("Selector $gs\n");
981 display_selector (current_thread
->h
,
982 current_thread
->context
.SegGs
);
987 sel
= parse_and_eval_long (args
);
988 printf_filtered ("Selector \"%s\"\n",args
);
989 display_selector (current_thread
->h
, sel
);
993 static struct cmd_list_element
*info_w32_cmdlist
= NULL
;
996 info_w32_command (char *args
, int from_tty
)
998 help_list (info_w32_cmdlist
, "info w32 ", class_info
, gdb_stdout
);
1002 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1003 printf_unfiltered ("gdb: Target exception %s at 0x%08lx\n", x, \
1004 (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress)
1007 handle_exception (struct target_waitstatus
*ourstatus
)
1010 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1012 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1014 /* Record the context of the current thread */
1015 th
= thread_rec (current_event
.dwThreadId
, -1);
1019 case EXCEPTION_ACCESS_VIOLATION
:
1020 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1021 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1024 /* See if the access violation happened within the cygwin DLL itself. Cygwin uses
1025 a kind of exception handling to deal with passed-in invalid addresses. gdb
1026 should not treat these as real SEGVs since they will be silently handled by
1027 cygwin. A real SEGV will (theoretically) be caught by cygwin later in the process
1028 and will be sent as a cygwin-specific-signal. So, ignore SEGVs if they show up
1029 within the text segment of the DLL itself. */
1031 bfd_vma addr
= (bfd_vma
) (uintptr_t) current_event
.u
.Exception
.
1032 ExceptionRecord
.ExceptionAddress
;
1033 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
&& addr
< cygwin_load_end
))
1034 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1035 && strncmp (fn
, "KERNEL32!IsBad", strlen ("KERNEL32!IsBad")) == 0))
1040 case STATUS_STACK_OVERFLOW
:
1041 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1042 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1044 case STATUS_FLOAT_DENORMAL_OPERAND
:
1045 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1046 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1048 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1049 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1050 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1052 case STATUS_FLOAT_INEXACT_RESULT
:
1053 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1054 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1056 case STATUS_FLOAT_INVALID_OPERATION
:
1057 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1058 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1060 case STATUS_FLOAT_OVERFLOW
:
1061 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1062 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1064 case STATUS_FLOAT_STACK_CHECK
:
1065 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1066 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1068 case STATUS_FLOAT_UNDERFLOW
:
1069 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1070 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1072 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1073 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1074 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1076 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1077 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1078 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1080 case STATUS_INTEGER_OVERFLOW
:
1081 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1082 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1084 case EXCEPTION_BREAKPOINT
:
1085 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1086 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1089 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1090 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1092 case DBG_CONTROL_BREAK
:
1093 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1094 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1096 case EXCEPTION_SINGLE_STEP
:
1097 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1098 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1100 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1101 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1102 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1104 case EXCEPTION_PRIV_INSTRUCTION
:
1105 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1106 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1108 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1109 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1110 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1113 /* Treat unhandled first chance exceptions specially. */
1114 if (current_event
.u
.Exception
.dwFirstChance
)
1116 printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",
1117 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1118 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1119 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1123 last_sig
= ourstatus
->value
.sig
;
1127 /* Resume all artificially suspended threads if we are continuing
1130 win32_continue (DWORD continue_status
, int id
)
1136 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, %s);\n",
1137 current_event
.dwProcessId
, current_event
.dwThreadId
,
1138 continue_status
== DBG_CONTINUE
?
1139 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1141 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1142 if ((id
== -1 || id
== (int) th
->id
)
1145 if (debug_registers_changed
)
1147 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1148 th
->context
.Dr0
= dr
[0];
1149 th
->context
.Dr1
= dr
[1];
1150 th
->context
.Dr2
= dr
[2];
1151 th
->context
.Dr3
= dr
[3];
1152 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1153 th
->context
.Dr7
= dr
[7];
1155 if (th
->context
.ContextFlags
)
1157 CHECK (SetThreadContext (th
->h
, &th
->context
));
1158 th
->context
.ContextFlags
= 0;
1160 if (th
->suspended
> 0)
1161 (void) ResumeThread (th
->h
);
1165 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1166 current_event
.dwThreadId
,
1169 debug_registers_changed
= 0;
1173 /* Called in pathological case where Windows fails to send a
1174 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1176 fake_create_process (void)
1178 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1179 current_event
.dwProcessId
);
1180 if (current_process_handle
!= NULL
)
1181 open_process_used
= 1;
1184 error (_("OpenProcess call failed, GetLastError = %lud\n"),
1186 /* We can not debug anything in that case. */
1188 main_thread_id
= current_event
.dwThreadId
;
1189 current_thread
= win32_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1190 current_event
.dwThreadId
),
1191 current_event
.u
.CreateThread
.hThread
);
1192 return main_thread_id
;
1196 win32_resume (ptid_t ptid
, int step
, enum target_signal sig
)
1199 DWORD continue_status
= DBG_CONTINUE
;
1201 /* A specific PTID means `step only this thread id'. */
1202 int resume_all
= ptid_equal (ptid
, minus_one_ptid
);
1204 /* If we're continuing all threads, it's the current inferior that
1205 should be handled specially. */
1207 ptid
= inferior_ptid
;
1209 if (sig
!= TARGET_SIGNAL_0
)
1211 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1213 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1215 else if (sig
== last_sig
)
1216 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1219 /* This code does not seem to work, because
1220 the kernel does probably not consider changes in the ExceptionRecord
1221 structure when passing the exception to the inferior.
1222 Note that this seems possible in the exception handler itself. */
1225 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1226 if (xlate
[i
].us
== sig
)
1228 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
=
1230 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1233 if (continue_status
== DBG_CONTINUE
)
1235 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1239 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1243 last_sig
= TARGET_SIGNAL_0
;
1245 DEBUG_EXEC (("gdb: win32_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1246 ptid_get_pid (ptid
), ptid_get_tid (ptid
), step
, sig
));
1248 /* Get context for currently selected thread */
1249 th
= thread_rec (ptid_get_tid (inferior_ptid
), FALSE
);
1254 /* Single step by setting t bit */
1255 win32_fetch_inferior_registers (get_current_regcache (),
1256 gdbarch_ps_regnum (current_gdbarch
));
1257 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1260 if (th
->context
.ContextFlags
)
1262 if (debug_registers_changed
)
1264 th
->context
.Dr0
= dr
[0];
1265 th
->context
.Dr1
= dr
[1];
1266 th
->context
.Dr2
= dr
[2];
1267 th
->context
.Dr3
= dr
[3];
1268 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1269 th
->context
.Dr7
= dr
[7];
1271 CHECK (SetThreadContext (th
->h
, &th
->context
));
1272 th
->context
.ContextFlags
= 0;
1276 /* Allow continuing with the same signal that interrupted us.
1277 Otherwise complain. */
1280 win32_continue (continue_status
, -1);
1282 win32_continue (continue_status
, ptid_get_tid (ptid
));
1285 /* Get the next event from the child. Return 1 if the event requires
1286 handling by WFI (or whatever).
1289 get_win32_debug_event (int pid
, struct target_waitstatus
*ourstatus
)
1292 DWORD continue_status
, event_code
;
1294 static thread_info dummy_thread_info
;
1297 last_sig
= TARGET_SIGNAL_0
;
1299 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1303 continue_status
= DBG_CONTINUE
;
1305 event_code
= current_event
.dwDebugEventCode
;
1306 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1308 have_saved_context
= 0;
1312 case CREATE_THREAD_DEBUG_EVENT
:
1313 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1314 (unsigned) current_event
.dwProcessId
,
1315 (unsigned) current_event
.dwThreadId
,
1316 "CREATE_THREAD_DEBUG_EVENT"));
1317 if (saw_create
!= 1)
1319 struct inferior
*inf
;
1320 inf
= find_inferior_pid (current_event
.dwProcessId
);
1321 if (!saw_create
&& inf
->attach_flag
)
1323 /* Kludge around a Windows bug where first event is a create
1324 thread event. Caused when attached process does not have
1326 retval
= fake_create_process ();
1332 /* Record the existence of this thread */
1333 retval
= current_event
.dwThreadId
;
1334 th
= win32_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1335 current_event
.dwThreadId
),
1336 current_event
.u
.CreateThread
.hThread
);
1339 case EXIT_THREAD_DEBUG_EVENT
:
1340 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1341 (unsigned) current_event
.dwProcessId
,
1342 (unsigned) current_event
.dwThreadId
,
1343 "EXIT_THREAD_DEBUG_EVENT"));
1344 if (current_event
.dwThreadId
!= main_thread_id
)
1346 win32_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1347 current_event
.dwThreadId
));
1348 th
= &dummy_thread_info
;
1352 case CREATE_PROCESS_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 "CREATE_PROCESS_DEBUG_EVENT"));
1357 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1358 if (++saw_create
!= 1)
1361 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1363 win32_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1365 main_thread_id
= current_event
.dwThreadId
;
1366 /* Add the main thread */
1367 th
= win32_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1368 current_event
.dwThreadId
),
1369 current_event
.u
.CreateProcessInfo
.hThread
);
1370 retval
= current_event
.dwThreadId
;
1373 case EXIT_PROCESS_DEBUG_EVENT
:
1374 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1375 (unsigned) current_event
.dwProcessId
,
1376 (unsigned) current_event
.dwThreadId
,
1377 "EXIT_PROCESS_DEBUG_EVENT"));
1378 if (saw_create
!= 1)
1380 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1381 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1382 retval
= main_thread_id
;
1385 case LOAD_DLL_DEBUG_EVENT
:
1386 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1387 (unsigned) current_event
.dwProcessId
,
1388 (unsigned) current_event
.dwThreadId
,
1389 "LOAD_DLL_DEBUG_EVENT"));
1390 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1391 if (saw_create
!= 1)
1393 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1394 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1395 ourstatus
->value
.integer
= 0;
1396 retval
= main_thread_id
;
1399 case UNLOAD_DLL_DEBUG_EVENT
:
1400 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1401 (unsigned) current_event
.dwProcessId
,
1402 (unsigned) current_event
.dwThreadId
,
1403 "UNLOAD_DLL_DEBUG_EVENT"));
1404 if (saw_create
!= 1)
1406 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1407 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1408 ourstatus
->value
.integer
= 0;
1409 retval
= main_thread_id
;
1412 case EXCEPTION_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 "EXCEPTION_DEBUG_EVENT"));
1417 if (saw_create
!= 1)
1419 switch (handle_exception (ourstatus
))
1422 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1425 retval
= current_event
.dwThreadId
;
1429 continue_status
= -1;
1434 case OUTPUT_DEBUG_STRING_EVENT
: /* message from the kernel */
1435 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1436 (unsigned) current_event
.dwProcessId
,
1437 (unsigned) current_event
.dwThreadId
,
1438 "OUTPUT_DEBUG_STRING_EVENT"));
1439 if (saw_create
!= 1)
1441 retval
= handle_output_debug_string (ourstatus
);
1445 if (saw_create
!= 1)
1447 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1448 (DWORD
) current_event
.dwProcessId
,
1449 (DWORD
) current_event
.dwThreadId
);
1450 printf_unfiltered (" unknown event code %ld\n",
1451 current_event
.dwDebugEventCode
);
1455 if (!retval
|| saw_create
!= 1)
1457 if (continue_status
== -1)
1458 win32_resume (minus_one_ptid
, 0, 1);
1460 CHECK (win32_continue (continue_status
, -1));
1464 inferior_ptid
= ptid_build (current_event
.dwProcessId
, 0,
1466 current_thread
= th
?: thread_rec (current_event
.dwThreadId
, TRUE
);
1473 /* Wait for interesting events to occur in the target process. */
1475 win32_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
1479 target_terminal_ours ();
1481 /* We loop when we get a non-standard exception rather than return
1482 with a SPURIOUS because resume can try and step or modify things,
1483 which needs a current_thread->h. But some of these exceptions mark
1484 the birth or death of threads, which mean that the current thread
1485 isn't necessarily what you think it is. */
1491 /* Ignore CTRL+C signals while waiting for a debug event.
1492 FIXME: brobecker/2008-05-20: When the user presses CTRL+C while
1493 the inferior is running, both the inferior and GDB receive the
1494 associated signal. If the inferior receives the signal first
1495 and the delay until GDB receives that signal is sufficiently long,
1496 GDB can sometimes receive the SIGINT after we have unblocked
1497 the CTRL+C handler. This would lead to the debugger to stop
1498 prematurely while handling the new-thread event that comes
1499 with the handling of the SIGINT inside the inferior, and then
1500 stop again immediately when the user tries to resume the execution
1501 in the inferior. This is a classic race, and it would be nice
1502 to find a better solution to that problem. But in the meantime,
1503 the current approach already greatly mitigate this issue. */
1504 SetConsoleCtrlHandler (NULL
, TRUE
);
1505 retval
= get_win32_debug_event (pid
, ourstatus
);
1506 SetConsoleCtrlHandler (NULL
, FALSE
);
1509 return ptid_build (current_event
.dwProcessId
, 0, retval
);
1514 if (deprecated_ui_loop_hook
!= NULL
)
1515 detach
= deprecated_ui_loop_hook (0);
1518 win32_kill_inferior ();
1524 do_initial_win32_stuff (DWORD pid
, int attaching
)
1526 extern int stop_after_trap
;
1528 struct inferior
*inf
;
1529 struct thread_info
*tp
;
1531 last_sig
= TARGET_SIGNAL_0
;
1533 exception_count
= 0;
1534 open_process_used
= 0;
1535 debug_registers_changed
= 0;
1536 debug_registers_used
= 0;
1537 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1540 cygwin_load_start
= cygwin_load_end
= 0;
1542 current_event
.dwProcessId
= pid
;
1543 memset (¤t_event
, 0, sizeof (current_event
));
1544 push_target (&win32_ops
);
1545 disable_breakpoints_in_shlibs ();
1546 win32_clear_solib ();
1547 clear_proceed_status ();
1548 init_wait_for_inferior ();
1550 inf
= add_inferior (pid
);
1551 inf
->attach_flag
= attaching
;
1553 terminal_init_inferior_with_pgrp (pid
);
1554 target_terminal_inferior ();
1556 inf
->stop_soon
= STOP_QUIETLY
;
1559 stop_after_trap
= 1;
1560 wait_for_inferior (0);
1561 tp
= inferior_thread ();
1562 if (tp
->stop_signal
!= TARGET_SIGNAL_TRAP
)
1563 resume (0, tp
->stop_signal
);
1568 inf
->stop_soon
= NO_STOP_QUIETLY
;
1569 stop_after_trap
= 0;
1573 /* Since Windows XP, detaching from a process is supported by Windows.
1574 The following code tries loading the appropriate functions dynamically.
1575 If loading these functions succeeds use them to actually detach from
1576 the inferior process, otherwise behave as usual, pretending that
1577 detach has worked. */
1578 static BOOL
WINAPI (*DebugSetProcessKillOnExit
)(BOOL
);
1579 static BOOL
WINAPI (*DebugActiveProcessStop
)(DWORD
);
1582 has_detach_ability (void)
1584 static HMODULE kernel32
= NULL
;
1587 kernel32
= LoadLibrary ("kernel32.dll");
1590 if (!DebugSetProcessKillOnExit
)
1591 DebugSetProcessKillOnExit
= GetProcAddress (kernel32
,
1592 "DebugSetProcessKillOnExit");
1593 if (!DebugActiveProcessStop
)
1594 DebugActiveProcessStop
= GetProcAddress (kernel32
,
1595 "DebugActiveProcessStop");
1596 if (DebugSetProcessKillOnExit
&& DebugActiveProcessStop
)
1602 /* Try to set or remove a user privilege to the current process. Return -1
1603 if that fails, the previous setting of that privilege otherwise.
1605 This code is copied from the Cygwin source code and rearranged to allow
1606 dynamically loading of the needed symbols from advapi32 which is only
1607 available on NT/2K/XP. */
1609 set_process_privilege (const char *privilege
, BOOL enable
)
1611 static HMODULE advapi32
= NULL
;
1612 static BOOL
WINAPI (*OpenProcessToken
)(HANDLE
, DWORD
, PHANDLE
);
1613 static BOOL
WINAPI (*LookupPrivilegeValue
)(LPCSTR
, LPCSTR
, PLUID
);
1614 static BOOL
WINAPI (*AdjustTokenPrivileges
)(HANDLE
, BOOL
, PTOKEN_PRIVILEGES
,
1615 DWORD
, PTOKEN_PRIVILEGES
, PDWORD
);
1617 HANDLE token_hdl
= NULL
;
1619 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1623 if (GetVersion () >= 0x80000000) /* No security availbale on 9x/Me */
1628 if (!(advapi32
= LoadLibrary ("advapi32.dll")))
1630 if (!OpenProcessToken
)
1631 OpenProcessToken
= GetProcAddress (advapi32
, "OpenProcessToken");
1632 if (!LookupPrivilegeValue
)
1633 LookupPrivilegeValue
= GetProcAddress (advapi32
,
1634 "LookupPrivilegeValueA");
1635 if (!AdjustTokenPrivileges
)
1636 AdjustTokenPrivileges
= GetProcAddress (advapi32
,
1637 "AdjustTokenPrivileges");
1638 if (!OpenProcessToken
|| !LookupPrivilegeValue
|| !AdjustTokenPrivileges
)
1645 if (!OpenProcessToken (GetCurrentProcess (),
1646 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1650 if (!LookupPrivilegeValue (NULL
, privilege
, &restore_priv
))
1653 new_priv
.PrivilegeCount
= 1;
1654 new_priv
.Privileges
[0].Luid
= restore_priv
;
1655 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1657 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1658 sizeof orig_priv
, &orig_priv
, &size
))
1661 /* Disabled, otherwise every `attach' in an unprivileged user session
1662 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1664 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1665 be enabled. GetLastError () returns an correct error code, though. */
1666 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1670 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1674 CloseHandle (token_hdl
);
1679 /* Attach to process PID, then initialize for debugging it. */
1681 win32_attach (char *args
, int from_tty
)
1687 error_no_arg (_("process-id to attach"));
1689 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1691 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1692 printf_unfiltered ("This can cause attach to fail on Windows NT/2K/XP\n");
1695 pid
= strtoul (args
, 0, 0); /* Windows pid */
1697 win32_init_thread_list ();
1698 ok
= DebugActiveProcess (pid
);
1704 /* Try fall back to Cygwin pid */
1705 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1708 ok
= DebugActiveProcess (pid
);
1713 error (_("Can't attach to process."));
1715 if (has_detach_ability ())
1716 DebugSetProcessKillOnExit (FALSE
);
1720 char *exec_file
= (char *) get_exec_file (0);
1723 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1724 target_pid_to_str (pid_to_ptid (pid
)));
1726 printf_unfiltered ("Attaching to %s\n",
1727 target_pid_to_str (pid_to_ptid (pid
)));
1729 gdb_flush (gdb_stdout
);
1732 do_initial_win32_stuff (pid
, 1);
1733 target_terminal_ours ();
1737 win32_detach (char *args
, int from_tty
)
1741 if (has_detach_ability ())
1744 win32_resume (ptid
, 0, TARGET_SIGNAL_0
);
1746 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1748 error (_("Can't detach process %lu (error %lu)"),
1749 current_event
.dwProcessId
, GetLastError ());
1752 DebugSetProcessKillOnExit (FALSE
);
1754 if (detached
&& from_tty
)
1756 char *exec_file
= get_exec_file (0);
1759 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file
,
1760 current_event
.dwProcessId
);
1761 gdb_flush (gdb_stdout
);
1764 inferior_ptid
= null_ptid
;
1765 detach_inferior (current_event
.dwProcessId
);
1767 unpush_target (&win32_ops
);
1771 win32_pid_to_exec_file (int pid
)
1773 static char path
[MAX_PATH
+ 1];
1776 /* Try to find exe name as symlink target of /proc/<pid>/exe */
1778 char procexe
[sizeof ("/proc/4294967295/exe")];
1779 sprintf (procexe
, "/proc/%u/exe", pid
);
1780 nchars
= readlink (procexe
, path
, sizeof(path
));
1781 if (nchars
> 0 && nchars
< sizeof (path
))
1783 path
[nchars
] = '\0'; /* Got it */
1788 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
1789 of gdb, or we're trying to debug a non-Cygwin windows executable. */
1790 if (!get_module_name (0, path
))
1796 /* Print status information about what we're accessing. */
1799 win32_files_info (struct target_ops
*ignore
)
1801 struct inferior
*inf
= current_inferior ();
1803 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1804 inf
->attach_flag
? "attached" : "child",
1805 target_pid_to_str (inferior_ptid
));
1809 win32_open (char *arg
, int from_tty
)
1811 error (_("Use the \"run\" command to start a Unix child process."));
1814 /* Start an inferior win32 child process and sets inferior_ptid to its pid.
1815 EXEC_FILE is the file to run.
1816 ALLARGS is a string containing the arguments to the program.
1817 ENV is the environment vector to pass. Errors reported with error(). */
1820 win32_create_inferior (char *exec_file
, char *allargs
, char **in_env
,
1824 PROCESS_INFORMATION pi
;
1828 char real_path
[MAXPATHLEN
];
1830 char shell
[MAX_PATH
+ 1]; /* Path to shell */
1833 int ostdin
, ostdout
, ostderr
;
1834 const char *inferior_io_terminal
= get_inferior_io_terminal ();
1837 error (_("No executable specified, use `target exec'."));
1839 memset (&si
, 0, sizeof (si
));
1840 si
.cb
= sizeof (si
);
1845 flags
= DEBUG_ONLY_THIS_PROCESS
;
1846 cygwin_conv_to_win32_path (exec_file
, real_path
);
1852 sh
= getenv ("SHELL");
1855 cygwin_conv_to_win32_path (sh
, shell
);
1856 newallargs
= alloca (sizeof (" -c 'exec '") + strlen (exec_file
)
1857 + strlen (allargs
) + 2);
1858 sprintf (newallargs
, " -c 'exec %s %s'", exec_file
, allargs
);
1859 allargs
= newallargs
;
1861 flags
= DEBUG_PROCESS
;
1865 flags
= DEBUG_ONLY_THIS_PROCESS
;
1869 flags
|= CREATE_NEW_PROCESS_GROUP
;
1872 flags
|= CREATE_NEW_CONSOLE
;
1874 args
= alloca (strlen (toexec
) + strlen (allargs
) + 2);
1875 strcpy (args
, toexec
);
1877 strcat (args
, allargs
);
1880 /* Prepare the environment vars for CreateProcess. */
1881 cygwin_internal (CW_SYNC_WINENV
);
1883 if (!inferior_io_terminal
)
1884 tty
= ostdin
= ostdout
= ostderr
= -1;
1887 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
1890 print_sys_errmsg (inferior_io_terminal
, errno
);
1891 ostdin
= ostdout
= ostderr
= -1;
1905 win32_init_thread_list ();
1906 ret
= CreateProcess (0,
1907 args
, /* command line */
1908 NULL
, /* Security */
1910 TRUE
, /* inherit handles */
1911 flags
, /* start flags */
1912 NULL
, /* environment */
1913 NULL
, /* current directory */
1931 error (_("Error creating process %s, (error %d)."),
1932 exec_file
, (unsigned) GetLastError ());
1934 CloseHandle (pi
.hThread
);
1935 CloseHandle (pi
.hProcess
);
1937 if (useshell
&& shell
[0] != '\0')
1942 do_initial_win32_stuff (pi
.dwProcessId
, 0);
1944 /* win32_continue (DBG_CONTINUE, -1); */
1948 win32_mourn_inferior (void)
1950 (void) win32_continue (DBG_CONTINUE
, -1);
1951 i386_cleanup_dregs();
1952 if (open_process_used
)
1954 CHECK (CloseHandle (current_process_handle
));
1955 open_process_used
= 0;
1957 unpush_target (&win32_ops
);
1958 generic_mourn_inferior ();
1961 /* Send a SIGINT to the process group. This acts just like the user typed a
1962 ^C on the controlling terminal. */
1965 win32_stop (ptid_t ptid
)
1967 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1968 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
1969 registers_changed (); /* refresh register state */
1973 win32_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*our
, int len
,
1974 int write
, struct mem_attrib
*mem
,
1975 struct target_ops
*target
)
1980 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1981 len
, (DWORD
) (uintptr_t) memaddr
));
1982 if (!WriteProcessMemory (current_process_handle
,
1983 (LPVOID
) (uintptr_t) memaddr
, our
,
1986 FlushInstructionCache (current_process_handle
,
1987 (LPCVOID
) (uintptr_t) memaddr
, len
);
1991 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
1992 len
, (DWORD
) (uintptr_t) memaddr
));
1993 if (!ReadProcessMemory (current_process_handle
,
1994 (LPCVOID
) (uintptr_t) memaddr
, our
,
2002 win32_kill_inferior (void)
2004 CHECK (TerminateProcess (current_process_handle
, 0));
2008 if (!win32_continue (DBG_CONTINUE
, -1))
2010 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
2012 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2016 target_mourn_inferior (); /* or just win32_mourn_inferior? */
2020 win32_prepare_to_store (struct regcache
*regcache
)
2022 /* Do nothing, since we can store individual regs */
2026 win32_can_run (void)
2034 DEBUG_EVENTS (("gdb: win32_close, inferior_ptid=%d\n",
2035 PIDGET (inferior_ptid
)));
2038 /* Convert pid to printable format. */
2040 win32_pid_to_str (ptid_t ptid
)
2042 static char buf
[80];
2044 if (ptid_get_tid (ptid
) != 0)
2046 snprintf (buf
, sizeof (buf
), "Thread %d.0x%lx",
2047 ptid_get_pid (ptid
), ptid_get_tid (ptid
));
2051 return normal_pid_to_str (ptid
);
2055 win32_xfer_shared_libraries (struct target_ops
*ops
,
2056 enum target_object object
, const char *annex
,
2057 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2058 ULONGEST offset
, LONGEST len
)
2060 struct obstack obstack
;
2068 obstack_init (&obstack
);
2069 obstack_grow_str (&obstack
, "<library-list>\n");
2070 for (so
= solib_start
.next
; so
; so
= so
->next
)
2071 win32_xfer_shared_library (so
->so_name
, so
->lm_info
->load_addr
, &obstack
);
2072 obstack_grow_str0 (&obstack
, "</library-list>\n");
2074 buf
= obstack_finish (&obstack
);
2075 len_avail
= strlen (buf
);
2076 if (offset
>= len_avail
)
2079 if (len
> len_avail
- offset
)
2080 len
= len_avail
- offset
;
2081 memcpy (readbuf
, buf
+ offset
, len
);
2083 obstack_free (&obstack
, NULL
);
2088 win32_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2089 const char *annex
, gdb_byte
*readbuf
,
2090 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
2094 case TARGET_OBJECT_MEMORY
:
2096 return (*ops
->deprecated_xfer_memory
) (offset
, readbuf
,
2097 len
, 0/*read*/, NULL
, ops
);
2099 return (*ops
->deprecated_xfer_memory
) (offset
, (gdb_byte
*) writebuf
,
2100 len
, 1/*write*/, NULL
, ops
);
2103 case TARGET_OBJECT_LIBRARIES
:
2104 return win32_xfer_shared_libraries (ops
, object
, annex
, readbuf
,
2105 writebuf
, offset
, len
);
2108 if (ops
->beneath
!= NULL
)
2109 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2110 readbuf
, writebuf
, offset
, len
);
2116 init_win32_ops (void)
2118 win32_ops
.to_shortname
= "child";
2119 win32_ops
.to_longname
= "Win32 child process";
2120 win32_ops
.to_doc
= "Win32 child process (started by the \"run\" command).";
2121 win32_ops
.to_open
= win32_open
;
2122 win32_ops
.to_close
= win32_close
;
2123 win32_ops
.to_attach
= win32_attach
;
2124 win32_ops
.to_attach_no_wait
= 1;
2125 win32_ops
.to_detach
= win32_detach
;
2126 win32_ops
.to_resume
= win32_resume
;
2127 win32_ops
.to_wait
= win32_wait
;
2128 win32_ops
.to_fetch_registers
= win32_fetch_inferior_registers
;
2129 win32_ops
.to_store_registers
= win32_store_inferior_registers
;
2130 win32_ops
.to_prepare_to_store
= win32_prepare_to_store
;
2131 win32_ops
.deprecated_xfer_memory
= win32_xfer_memory
;
2132 win32_ops
.to_xfer_partial
= win32_xfer_partial
;
2133 win32_ops
.to_files_info
= win32_files_info
;
2134 win32_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
2135 win32_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
2136 win32_ops
.to_terminal_init
= terminal_init_inferior
;
2137 win32_ops
.to_terminal_inferior
= terminal_inferior
;
2138 win32_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
2139 win32_ops
.to_terminal_ours
= terminal_ours
;
2140 win32_ops
.to_terminal_save_ours
= terminal_save_ours
;
2141 win32_ops
.to_terminal_info
= child_terminal_info
;
2142 win32_ops
.to_kill
= win32_kill_inferior
;
2143 win32_ops
.to_create_inferior
= win32_create_inferior
;
2144 win32_ops
.to_mourn_inferior
= win32_mourn_inferior
;
2145 win32_ops
.to_can_run
= win32_can_run
;
2146 win32_ops
.to_thread_alive
= win32_win32_thread_alive
;
2147 win32_ops
.to_pid_to_str
= win32_pid_to_str
;
2148 win32_ops
.to_stop
= win32_stop
;
2149 win32_ops
.to_stratum
= process_stratum
;
2150 win32_ops
.to_has_all_memory
= 1;
2151 win32_ops
.to_has_memory
= 1;
2152 win32_ops
.to_has_stack
= 1;
2153 win32_ops
.to_has_registers
= 1;
2154 win32_ops
.to_has_execution
= 1;
2155 win32_ops
.to_pid_to_exec_file
= win32_pid_to_exec_file
;
2156 win32_ops
.to_magic
= OPS_MAGIC
;
2160 set_win32_aliases (char *argv0
)
2162 add_info_alias ("dll", "sharedlibrary", 1);
2166 _initialize_win32_nat (void)
2168 struct cmd_list_element
*c
;
2172 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
2173 _("Load dll library symbols from FILE."));
2174 set_cmd_completer (c
, filename_completer
);
2176 add_com_alias ("sharedlibrary", "dll-symbols", class_alias
, 1);
2179 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
2180 Set use of shell to start subprocess."), _("\
2181 Show use of shell to start subprocess."), NULL
,
2183 NULL
, /* FIXME: i18n: */
2184 &setlist
, &showlist
);
2186 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
, &cygwin_exceptions
, _("\
2187 Break when an exception is detected in the Cygwin DLL itself."), _("\
2188 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
2190 NULL
, /* FIXME: i18n: */
2191 &setlist
, &showlist
);
2194 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
2195 Set creation of new console when creating child process."), _("\
2196 Show creation of new console when creating child process."), NULL
,
2198 NULL
, /* FIXME: i18n: */
2199 &setlist
, &showlist
);
2201 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
2202 Set creation of new group when creating child process."), _("\
2203 Show creation of new group when creating child process."), NULL
,
2205 NULL
, /* FIXME: i18n: */
2206 &setlist
, &showlist
);
2208 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
2209 Set whether to display execution in child process."), _("\
2210 Show whether to display execution in child process."), NULL
,
2212 NULL
, /* FIXME: i18n: */
2213 &setlist
, &showlist
);
2215 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
2216 Set whether to display kernel events in child process."), _("\
2217 Show whether to display kernel events in child process."), NULL
,
2219 NULL
, /* FIXME: i18n: */
2220 &setlist
, &showlist
);
2222 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
2223 Set whether to display memory accesses in child process."), _("\
2224 Show whether to display memory accesses in child process."), NULL
,
2226 NULL
, /* FIXME: i18n: */
2227 &setlist
, &showlist
);
2229 add_setshow_boolean_cmd ("debugexceptions", class_support
,
2230 &debug_exceptions
, _("\
2231 Set whether to display kernel exceptions in child process."), _("\
2232 Show whether to display kernel exceptions in child process."), NULL
,
2234 NULL
, /* FIXME: i18n: */
2235 &setlist
, &showlist
);
2237 add_prefix_cmd ("w32", class_info
, info_w32_command
,
2238 _("Print information specific to Win32 debugging."),
2239 &info_w32_cmdlist
, "info w32 ", 0, &infolist
);
2241 add_cmd ("selector", class_info
, display_selectors
,
2242 _("Display selectors infos."),
2244 add_target (&win32_ops
);
2245 deprecated_init_ui_hook
= set_win32_aliases
;
2248 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2250 /* Pass the address ADDR to the inferior in the I'th debug register.
2251 Here we just store the address in dr array, the registers will be
2252 actually set up when win32_continue is called. */
2254 cygwin_set_dr (int i
, CORE_ADDR addr
)
2257 internal_error (__FILE__
, __LINE__
,
2258 _("Invalid register %d in cygwin_set_dr.\n"), i
);
2259 dr
[i
] = (unsigned) addr
;
2260 debug_registers_changed
= 1;
2261 debug_registers_used
= 1;
2264 /* Pass the value VAL to the inferior in the DR7 debug control
2265 register. Here we just store the address in D_REGS, the watchpoint
2266 will be actually set up in win32_wait. */
2268 cygwin_set_dr7 (unsigned val
)
2271 debug_registers_changed
= 1;
2272 debug_registers_used
= 1;
2275 /* Get the value of the DR6 debug status register from the inferior.
2276 Here we just return the value stored in dr[6]
2277 by the last call to thread_rec for current_event.dwThreadId id. */
2279 cygwin_get_dr6 (void)
2284 /* Determine if the thread referenced by "ptid" is alive
2285 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2286 it means that the thread has died. Otherwise it is assumed to be alive. */
2288 win32_win32_thread_alive (ptid_t ptid
)
2292 gdb_assert (ptid_get_tid (ptid
) != 0);
2293 tid
= ptid_get_tid (ptid
);
2295 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
?
2300 _initialize_check_for_gdb_ini (void)
2303 if (inhibit_gdbinit
)
2306 homedir
= getenv ("HOME");
2310 char *oldini
= (char *) alloca (strlen (homedir
) +
2311 sizeof ("/gdb.ini"));
2312 strcpy (oldini
, homedir
);
2313 p
= strchr (oldini
, '\0');
2314 if (p
> oldini
&& p
[-1] != '/')
2316 strcpy (p
, "gdb.ini");
2317 if (access (oldini
, 0) == 0)
2319 int len
= strlen (oldini
);
2320 char *newini
= alloca (len
+ 1);
2321 sprintf (newini
, "%.*s.gdbinit",
2322 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
2323 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
2329 _initialize_psapi (void)
2331 /* Load optional functions used for retrieving filename information
2332 associated with the currently debugged process or its dlls. */
2335 HMODULE psapi_module_handle
;
2339 psapi_module_handle
= LoadLibrary ("psapi.dll");
2340 if (psapi_module_handle
)
2342 psapi_EnumProcessModules
= (void *) GetProcAddress (psapi_module_handle
, "EnumProcessModules");
2343 psapi_GetModuleInformation
= (void *) GetProcAddress (psapi_module_handle
, "GetModuleInformation");
2344 psapi_GetModuleFileNameExA
= (void *) GetProcAddress (psapi_module_handle
, "GetModuleFileNameExA");
2346 if (psapi_EnumProcessModules
!= NULL
2347 && psapi_GetModuleInformation
!= NULL
2348 && psapi_GetModuleFileNameExA
!= NULL
)
2353 /* This will probably fail on Windows 9x/Me. Let the user know that we're
2354 missing some functionality. */
2355 if (psapi_loaded
< 0)
2356 warning(_("cannot automatically find executable file or library to read symbols. Use \"file\" or \"dll\" command to load executable/libraries directly."));