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>
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 "windows-tdep.h"
64 #include "windows-nat.h"
66 static struct target_ops windows_ops
;
69 /* The starting and ending address of the cygwin1.dll text segment. */
70 static CORE_ADDR cygwin_load_start
;
71 static CORE_ADDR cygwin_load_end
;
74 static int have_saved_context
; /* True if we've saved context from a cygwin signal. */
75 static CONTEXT saved_context
; /* Containes the saved context from a cygwin signal. */
77 /* If we're not using the old Cygwin header file set, define the
78 following which never should have been in the generic Win32 API
79 headers in the first place since they were our own invention... */
80 #ifndef _GNU_H_WINDOWS_H
83 FLAG_TRACE_BIT
= 0x100,
84 CONTEXT_DEBUGGER
= (CONTEXT_FULL
| CONTEXT_FLOATING_POINT
)
89 #ifndef CONTEXT_EXTENDED_REGISTERS
90 /* This macro is only defined on ia32. It only makes sense on this target,
91 so define it as zero if not already defined. */
92 #define CONTEXT_EXTENDED_REGISTERS 0
95 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \
96 | CONTEXT_EXTENDED_REGISTERS
98 static unsigned dr
[8];
99 static int debug_registers_changed
;
100 static int debug_registers_used
;
101 #define DR6_CLEAR_VALUE 0xffff0ff0
103 /* The string sent by cygwin when it processes a signal.
104 FIXME: This should be in a cygwin include file. */
105 #ifndef _CYGWIN_SIGNAL_STRING
106 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
109 #define CHECK(x) check (x, __FILE__,__LINE__)
110 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
111 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
112 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
113 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
115 static void windows_stop (ptid_t
);
116 static int windows_thread_alive (ptid_t
);
117 static void windows_kill_inferior (void);
119 static enum target_signal last_sig
= TARGET_SIGNAL_0
;
120 /* Set if a signal was received from the debugged process */
122 /* Thread information structure used to track information that is
123 not available in gdb's thread structure. */
124 typedef struct thread_info_struct
126 struct thread_info_struct
*next
;
137 static thread_info thread_head
;
139 /* The process and thread handles for the above context. */
141 static DEBUG_EVENT current_event
; /* The current debug event from
143 static HANDLE current_process_handle
; /* Currently executing process */
144 static thread_info
*current_thread
; /* Info on currently selected thread */
145 static DWORD main_thread_id
; /* Thread ID of the main thread */
147 /* Counts of things. */
148 static int exception_count
= 0;
149 static int event_count
= 0;
150 static int saw_create
;
151 static int open_process_used
= 0;
154 static int new_console
= 0;
156 static int cygwin_exceptions
= 0;
158 static int new_group
= 1;
159 static int debug_exec
= 0; /* show execution */
160 static int debug_events
= 0; /* show events from kernel */
161 static int debug_memory
= 0; /* show target memory accesses */
162 static int debug_exceptions
= 0; /* show target exceptions */
163 static int useshell
= 0; /* use shell for subprocesses */
165 /* This vector maps GDB's idea of a register's number into an offset
166 in the windows exception context vector.
168 It also contains the bit mask needed to load the register in question.
170 The contents of this table can only be computed by the units
171 that provide CPU-specific support for Windows native debugging.
172 These units should set the table by calling
173 windows_set_context_register_offsets.
175 One day we could read a reg, we could inspect the context we
176 already have loaded, if it doesn't have the bit set that we need,
177 we read that set of registers in using GetThreadContext. If the
178 context already contains what we need, we just unpack it. Then to
179 write a register, first we have to ensure that the context contains
180 the other regs of the group, and then we copy the info in and set
183 static const int *mappings
;
185 /* This vector maps the target's idea of an exception (extracted
186 from the DEBUG_EVENT structure) to GDB's idea. */
188 struct xlate_exception
191 enum target_signal us
;
194 static const struct xlate_exception
197 {EXCEPTION_ACCESS_VIOLATION
, TARGET_SIGNAL_SEGV
},
198 {STATUS_STACK_OVERFLOW
, TARGET_SIGNAL_SEGV
},
199 {EXCEPTION_BREAKPOINT
, TARGET_SIGNAL_TRAP
},
200 {DBG_CONTROL_C
, TARGET_SIGNAL_INT
},
201 {EXCEPTION_SINGLE_STEP
, TARGET_SIGNAL_TRAP
},
202 {STATUS_FLOAT_DIVIDE_BY_ZERO
, TARGET_SIGNAL_FPE
},
205 /* Set the MAPPINGS static global to OFFSETS.
206 See the description of MAPPINGS for more details. */
209 windows_set_context_register_offsets (const int *offsets
)
215 check (BOOL ok
, const char *file
, int line
)
218 printf_filtered ("error return %s:%d was %lu\n", file
, line
,
222 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
223 then also retrieve the context for this thread. If GET_CONTEXT is
224 negative, then don't suspend the thread. */
226 thread_rec (DWORD id
, int get_context
)
230 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
233 if (!th
->suspended
&& get_context
)
235 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
237 if (SuspendThread (th
->h
) == (DWORD
) -1)
239 DWORD err
= GetLastError ();
240 warning (_("SuspendThread failed. (winerr %d)"),
246 else if (get_context
< 0)
248 th
->reload_context
= 1;
256 /* Add a thread to the thread list. */
258 windows_add_thread (ptid_t ptid
, HANDLE h
)
263 gdb_assert (ptid_get_tid (ptid
) != 0);
265 id
= ptid_get_tid (ptid
);
267 if ((th
= thread_rec (id
, FALSE
)))
270 th
= XZALLOC (thread_info
);
273 th
->next
= thread_head
.next
;
274 thread_head
.next
= th
;
276 /* Set the debug registers for the new thread if they are used. */
277 if (debug_registers_used
)
279 /* Only change the value of the debug registers. */
280 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
281 CHECK (GetThreadContext (th
->h
, &th
->context
));
282 th
->context
.Dr0
= dr
[0];
283 th
->context
.Dr1
= dr
[1];
284 th
->context
.Dr2
= dr
[2];
285 th
->context
.Dr3
= dr
[3];
286 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
287 th
->context
.Dr7
= dr
[7];
288 CHECK (SetThreadContext (th
->h
, &th
->context
));
289 th
->context
.ContextFlags
= 0;
294 /* Clear out any old thread list and reintialize it to a
297 windows_init_thread_list (void)
299 thread_info
*th
= &thread_head
;
301 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
303 while (th
->next
!= NULL
)
305 thread_info
*here
= th
->next
;
306 th
->next
= here
->next
;
309 thread_head
.next
= NULL
;
312 /* Delete a thread from the list of threads */
314 windows_delete_thread (ptid_t ptid
)
319 gdb_assert (ptid_get_tid (ptid
) != 0);
321 id
= ptid_get_tid (ptid
);
324 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
));
325 delete_thread (ptid
);
327 for (th
= &thread_head
;
328 th
->next
!= NULL
&& th
->next
->id
!= id
;
332 if (th
->next
!= NULL
)
334 thread_info
*here
= th
->next
;
335 th
->next
= here
->next
;
341 do_windows_fetch_inferior_registers (struct regcache
*regcache
, int r
)
343 char *context_offset
= ((char *) ¤t_thread
->context
) + mappings
[r
];
344 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
345 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
349 return; /* Windows sometimes uses a non-existent thread id in its
352 if (current_thread
->reload_context
)
354 #ifdef __COPY_CONTEXT_SIZE
355 if (have_saved_context
)
357 /* Lie about where the program actually is stopped since cygwin has informed us that
358 we should consider the signal to have occurred at another location which is stored
359 in "saved_context. */
360 memcpy (¤t_thread
->context
, &saved_context
, __COPY_CONTEXT_SIZE
);
361 have_saved_context
= 0;
366 thread_info
*th
= current_thread
;
367 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
368 GetThreadContext (th
->h
, &th
->context
);
369 /* Copy dr values from that thread.
370 But only if there were not modified since last stop. PR gdb/2388 */
371 if (!debug_registers_changed
)
373 dr
[0] = th
->context
.Dr0
;
374 dr
[1] = th
->context
.Dr1
;
375 dr
[2] = th
->context
.Dr2
;
376 dr
[3] = th
->context
.Dr3
;
377 dr
[6] = th
->context
.Dr6
;
378 dr
[7] = th
->context
.Dr7
;
381 current_thread
->reload_context
= 0;
384 if (r
== I387_FISEG_REGNUM (tdep
))
386 l
= *((long *) context_offset
) & 0xffff;
387 regcache_raw_supply (regcache
, r
, (char *) &l
);
389 else if (r
== I387_FOP_REGNUM (tdep
))
391 l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
392 regcache_raw_supply (regcache
, r
, (char *) &l
);
395 regcache_raw_supply (regcache
, r
, context_offset
);
398 for (r
= 0; r
< gdbarch_num_regs (gdbarch
); r
++)
399 do_windows_fetch_inferior_registers (regcache
, r
);
404 windows_fetch_inferior_registers (struct target_ops
*ops
,
405 struct regcache
*regcache
, int r
)
407 current_thread
= thread_rec (ptid_get_tid (inferior_ptid
), TRUE
);
408 /* Check if current_thread exists. Windows sometimes uses a non-existent
409 thread id in its events */
411 do_windows_fetch_inferior_registers (regcache
, r
);
415 do_windows_store_inferior_registers (const struct regcache
*regcache
, int r
)
418 /* Windows sometimes uses a non-existent thread id in its events */;
420 regcache_raw_collect (regcache
, r
,
421 ((char *) ¤t_thread
->context
) + mappings
[r
]);
424 for (r
= 0; r
< gdbarch_num_regs (get_regcache_arch (regcache
)); r
++)
425 do_windows_store_inferior_registers (regcache
, r
);
429 /* Store a new register value into the current thread context */
431 windows_store_inferior_registers (struct target_ops
*ops
,
432 struct regcache
*regcache
, int r
)
434 current_thread
= thread_rec (ptid_get_tid (inferior_ptid
), TRUE
);
435 /* Check if current_thread exists. Windows sometimes uses a non-existent
436 thread id in its events */
438 do_windows_store_inferior_registers (regcache
, r
);
441 static int psapi_loaded
= 0;
442 static BOOL
WINAPI (*psapi_EnumProcessModules
) (HANDLE
, HMODULE
*, DWORD
,
444 static BOOL
WINAPI (*psapi_GetModuleInformation
) (HANDLE
, HMODULE
, LPMODULEINFO
,
446 static DWORD
WINAPI (*psapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
, LPSTR
,
449 /* Get the name of a given module at at given base address. If base_address
450 is zero return the first loaded module (which is always the name of the
453 get_module_name (LPVOID base_address
, char *dll_name_ret
)
459 HMODULE
*DllHandle
= dh_buf
; /* Set to temporary storage for initial query */
462 char pathbuf
[PATH_MAX
+ 1]; /* Temporary storage prior to converting to
465 char *pathbuf
= dll_name_ret
; /* Just copy directly to passed-in arg */
468 /* If psapi_loaded < 0 either psapi.dll is not available or it does not contain
469 the needed functions. */
470 if (psapi_loaded
<= 0)
474 /* Find size of buffer needed to handle list of modules loaded in inferior */
475 if (!psapi_EnumProcessModules (current_process_handle
, DllHandle
,
476 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
479 /* Allocate correct amount of space for module list */
480 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
484 /* Get the list of modules */
485 if (!psapi_EnumProcessModules (current_process_handle
, DllHandle
, cbNeeded
,
489 for (i
= 0; i
< (int) (cbNeeded
/ sizeof (HMODULE
)); i
++)
491 /* Get information on this module */
492 if (!psapi_GetModuleInformation (current_process_handle
, DllHandle
[i
],
494 error (_("Can't get module info"));
496 if (!base_address
|| mi
.lpBaseOfDll
== base_address
)
498 /* Try to find the name of the given module */
499 len
= psapi_GetModuleFileNameExA (current_process_handle
,
500 DllHandle
[i
], pathbuf
, MAX_PATH
);
502 error (_("Error getting dll name: %u."), (unsigned) GetLastError ());
504 /* Cygwin prefers that the path be in /x/y/z format */
505 cygwin_conv_to_full_posix_path (pathbuf
, dll_name_ret
);
507 return 1; /* success */
512 dll_name_ret
[0] = '\0';
513 return 0; /* failure */
516 /* Encapsulate the information required in a call to
517 symbol_file_add_args */
518 struct safe_symbol_file_add_args
522 struct section_addr_info
*addrs
;
525 struct ui_file
*err
, *out
;
529 /* Maintain a linked list of "so" information. */
535 static struct so_list solib_start
, *solib_end
;
537 /* Call symbol_file_add with stderr redirected. We don't care if there
540 safe_symbol_file_add_stub (void *argv
)
542 #define p ((struct safe_symbol_file_add_args *) argv)
543 p
->ret
= symbol_file_add (p
->name
, p
->from_tty
, p
->addrs
, p
->mainline
, p
->flags
);
548 /* Restore gdb's stderr after calling symbol_file_add */
550 safe_symbol_file_add_cleanup (void *p
)
552 #define sp ((struct safe_symbol_file_add_args *)p)
553 gdb_flush (gdb_stderr
);
554 gdb_flush (gdb_stdout
);
555 ui_file_delete (gdb_stderr
);
556 ui_file_delete (gdb_stdout
);
557 gdb_stderr
= sp
->err
;
558 gdb_stdout
= sp
->out
;
562 /* symbol_file_add wrapper that prevents errors from being displayed. */
563 static struct objfile
*
564 safe_symbol_file_add (char *name
, int from_tty
,
565 struct section_addr_info
*addrs
,
566 int mainline
, int flags
)
568 struct safe_symbol_file_add_args p
;
569 struct cleanup
*cleanup
;
571 cleanup
= make_cleanup (safe_symbol_file_add_cleanup
, &p
);
575 gdb_flush (gdb_stderr
);
576 gdb_flush (gdb_stdout
);
577 gdb_stderr
= ui_file_new ();
578 gdb_stdout
= ui_file_new ();
580 p
.from_tty
= from_tty
;
582 p
.mainline
= mainline
;
584 catch_errors (safe_symbol_file_add_stub
, &p
, "", RETURN_MASK_ERROR
);
586 do_cleanups (cleanup
);
590 static struct so_list
*
591 windows_make_so (const char *name
, LPVOID load_addr
)
594 char buf
[MAX_PATH
+ 1];
595 char cwd
[MAX_PATH
+ 1];
597 WIN32_FIND_DATA w32_fd
;
598 HANDLE h
= FindFirstFile(name
, &w32_fd
);
599 MEMORY_BASIC_INFORMATION m
;
601 if (h
== INVALID_HANDLE_VALUE
)
607 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
609 p
= strrchr (buf
, '\\');
612 SetCurrentDirectory (buf
);
613 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
614 SetCurrentDirectory (cwd
);
618 if (strcasecmp (buf
, "ntdll.dll") == 0)
620 GetSystemDirectory (buf
, sizeof (buf
));
621 strcat (buf
, "\\ntdll.dll");
623 so
= XZALLOC (struct so_list
);
624 so
->lm_info
= (struct lm_info
*) xmalloc (sizeof (struct lm_info
));
625 so
->lm_info
->load_addr
= load_addr
;
626 strcpy (so
->so_original_name
, name
);
628 strcpy (so
->so_name
, buf
);
630 cygwin_conv_to_posix_path (buf
, so
->so_name
);
631 /* Record cygwin1.dll .text start/end. */
632 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
633 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
636 asection
*text
= NULL
;
639 abfd
= bfd_openr (so
->so_name
, "pei-i386");
644 if (bfd_check_format (abfd
, bfd_object
))
645 text
= bfd_get_section_by_name (abfd
, ".text");
653 /* The symbols in a dll are offset by 0x1000, which is the the
654 offset from 0 of the first byte in an image - because of the
655 file header and the section alignment. */
656 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *) load_addr
+ 0x1000);
657 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (abfd
, text
);
667 get_image_name (HANDLE h
, void *address
, int unicode
)
669 static char buf
[(2 * MAX_PATH
) + 1];
670 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
676 /* Attempt to read the name of the dll that was detected.
677 This is documented to work only when actively debugging
678 a program. It will not work for attached processes. */
682 /* See if we could read the address of a string, and that the
683 address isn't null. */
684 if (!ReadProcessMemory (h
, address
, &address_ptr
, sizeof (address_ptr
), &done
)
685 || done
!= sizeof (address_ptr
) || !address_ptr
)
688 /* Find the length of the string */
689 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
690 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
694 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
697 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
698 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
701 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
707 /* Wait for child to do something. Return pid of child, or -1 in case
708 of error; store status through argument pointer OURSTATUS. */
710 handle_load_dll (void *dummy
)
712 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
713 char dll_buf
[MAX_PATH
+ 1];
714 char *dll_name
= NULL
;
716 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
718 if (!get_module_name (event
->lpBaseOfDll
, dll_buf
))
719 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
723 if (*dll_name
== '\0')
724 dll_name
= get_image_name (current_process_handle
,
725 event
->lpImageName
, event
->fUnicode
);
729 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
730 solib_end
= solib_end
->next
;
732 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %p.\n", solib_end
->so_name
,
733 solib_end
->lm_info
->load_addr
));
739 windows_free_so (struct so_list
*so
)
747 handle_unload_dll (void *dummy
)
749 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
752 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
753 if (so
->next
->lm_info
->load_addr
== lpBaseOfDll
)
755 struct so_list
*sodel
= so
->next
;
756 so
->next
= sodel
->next
;
759 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
761 windows_free_so (sodel
);
762 solib_add (NULL
, 0, NULL
, auto_solib_add
);
766 error (_("Error: dll starting at %p not found."), lpBaseOfDll
);
771 /* Clear list of loaded DLLs. */
773 windows_clear_solib (void)
775 solib_start
.next
= NULL
;
776 solib_end
= &solib_start
;
779 /* Load DLL symbol info. */
781 dll_symbol_command (char *args
, int from_tty
)
787 error (_("dll-symbols requires a file name"));
790 if (n
> 4 && strcasecmp (args
+ n
- 4, ".dll") != 0)
792 char *newargs
= (char *) alloca (n
+ 4 + 1);
793 strcpy (newargs
, args
);
794 strcat (newargs
, ".dll");
798 safe_symbol_file_add (args
, from_tty
, NULL
, 0, OBJF_SHARED
| OBJF_USERLOADED
);
801 /* Handle DEBUG_STRING output from child process.
802 Cygwin prepends its messages with a "cygwin:". Interpret this as
803 a Cygwin signal. Otherwise just print the string as a warning. */
805 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
810 if (!target_read_string
811 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
815 else if (strncmp (s
, _CYGWIN_SIGNAL_STRING
, sizeof (_CYGWIN_SIGNAL_STRING
) - 1) != 0)
818 if (strncmp (s
, "cYg", 3) != 0)
822 #ifdef __COPY_CONTEXT_SIZE
825 /* Got a cygwin signal marker. A cygwin signal is followed by the signal number
826 itself and then optionally followed by the thread id and address to saved context
827 within the DLL. If these are supplied, then the given thread is assumed to have
828 issued the signal and the context from the thread is assumed to be stored at the
829 given address in the inferior. Tell gdb to treat this like a real signal. */
831 int sig
= strtol (s
+ sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
832 int gotasig
= target_signal_from_host (sig
);
833 ourstatus
->value
.sig
= gotasig
;
838 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
839 retval
= strtoul (p
, &p
, 0);
841 retval
= main_thread_id
;
842 else if ((x
= (LPCVOID
) strtoul (p
, &p
, 0))
843 && ReadProcessMemory (current_process_handle
, x
,
844 &saved_context
, __COPY_CONTEXT_SIZE
, &n
)
845 && n
== __COPY_CONTEXT_SIZE
)
846 have_saved_context
= 1;
847 current_event
.dwThreadId
= retval
;
858 display_selector (HANDLE thread
, DWORD sel
)
861 if (GetThreadSelectorEntry (thread
, sel
, &info
))
864 printf_filtered ("0x%03lx: ", sel
);
865 if (!info
.HighWord
.Bits
.Pres
)
867 puts_filtered ("Segment not present\n");
870 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
871 (info
.HighWord
.Bits
.BaseMid
<< 16)
873 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
874 if (info
.HighWord
.Bits
.Granularity
)
875 limit
= (limit
<< 12) | 0xfff;
876 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
877 if (info
.HighWord
.Bits
.Default_Big
)
878 puts_filtered(" 32-bit ");
880 puts_filtered(" 16-bit ");
881 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
884 puts_filtered ("Data (Read-Only, Exp-up");
887 puts_filtered ("Data (Read/Write, Exp-up");
890 puts_filtered ("Unused segment (");
893 puts_filtered ("Data (Read/Write, Exp-down");
896 puts_filtered ("Code (Exec-Only, N.Conf");
899 puts_filtered ("Code (Exec/Read, N.Conf");
902 puts_filtered ("Code (Exec-Only, Conf");
905 puts_filtered ("Code (Exec/Read, Conf");
908 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
910 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
911 puts_filtered(", N.Acc");
912 puts_filtered (")\n");
913 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
914 puts_filtered("System selector ");
915 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
916 if (info
.HighWord
.Bits
.Granularity
)
917 puts_filtered ("Page granular.\n");
919 puts_filtered ("Byte granular.\n");
924 printf_filtered ("Invalid selector 0x%lx.\n",sel
);
930 display_selectors (char * args
, int from_tty
)
934 puts_filtered ("Impossible to display selectors now.\n");
940 puts_filtered ("Selector $cs\n");
941 display_selector (current_thread
->h
,
942 current_thread
->context
.SegCs
);
943 puts_filtered ("Selector $ds\n");
944 display_selector (current_thread
->h
,
945 current_thread
->context
.SegDs
);
946 puts_filtered ("Selector $es\n");
947 display_selector (current_thread
->h
,
948 current_thread
->context
.SegEs
);
949 puts_filtered ("Selector $ss\n");
950 display_selector (current_thread
->h
,
951 current_thread
->context
.SegSs
);
952 puts_filtered ("Selector $fs\n");
953 display_selector (current_thread
->h
,
954 current_thread
->context
.SegFs
);
955 puts_filtered ("Selector $gs\n");
956 display_selector (current_thread
->h
,
957 current_thread
->context
.SegGs
);
962 sel
= parse_and_eval_long (args
);
963 printf_filtered ("Selector \"%s\"\n",args
);
964 display_selector (current_thread
->h
, sel
);
968 static struct cmd_list_element
*info_w32_cmdlist
= NULL
;
971 info_w32_command (char *args
, int from_tty
)
973 help_list (info_w32_cmdlist
, "info w32 ", class_info
, gdb_stdout
);
977 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
978 printf_unfiltered ("gdb: Target exception %s at %p\n", x, \
979 current_event.u.Exception.ExceptionRecord.ExceptionAddress)
982 handle_exception (struct target_waitstatus
*ourstatus
)
985 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
987 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
989 /* Record the context of the current thread */
990 th
= thread_rec (current_event
.dwThreadId
, -1);
994 case EXCEPTION_ACCESS_VIOLATION
:
995 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
996 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
999 /* See if the access violation happened within the cygwin DLL itself. Cygwin uses
1000 a kind of exception handling to deal with passed-in invalid addresses. gdb
1001 should not treat these as real SEGVs since they will be silently handled by
1002 cygwin. A real SEGV will (theoretically) be caught by cygwin later in the process
1003 and will be sent as a cygwin-specific-signal. So, ignore SEGVs if they show up
1004 within the text segment of the DLL itself. */
1006 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
;
1007 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
&& addr
< cygwin_load_end
))
1008 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1009 && strncmp (fn
, "KERNEL32!IsBad", strlen ("KERNEL32!IsBad")) == 0))
1014 case STATUS_STACK_OVERFLOW
:
1015 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1016 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1018 case STATUS_FLOAT_DENORMAL_OPERAND
:
1019 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1020 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1022 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1023 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1024 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1026 case STATUS_FLOAT_INEXACT_RESULT
:
1027 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1028 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1030 case STATUS_FLOAT_INVALID_OPERATION
:
1031 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1032 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1034 case STATUS_FLOAT_OVERFLOW
:
1035 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1036 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1038 case STATUS_FLOAT_STACK_CHECK
:
1039 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1040 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1042 case STATUS_FLOAT_UNDERFLOW
:
1043 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1044 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1046 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1047 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1048 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1050 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1051 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1052 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1054 case STATUS_INTEGER_OVERFLOW
:
1055 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1056 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1058 case EXCEPTION_BREAKPOINT
:
1059 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1060 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1063 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1064 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1066 case DBG_CONTROL_BREAK
:
1067 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1068 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1070 case EXCEPTION_SINGLE_STEP
:
1071 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1072 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1074 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1075 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1076 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1078 case EXCEPTION_PRIV_INSTRUCTION
:
1079 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1080 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1082 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1083 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1084 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1087 /* Treat unhandled first chance exceptions specially. */
1088 if (current_event
.u
.Exception
.dwFirstChance
)
1090 printf_unfiltered ("gdb: unknown target exception 0x%08lx at %p\n",
1091 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1092 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1093 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1097 last_sig
= ourstatus
->value
.sig
;
1101 /* Resume all artificially suspended threads if we are continuing
1104 windows_continue (DWORD continue_status
, int id
)
1110 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, %s);\n",
1111 current_event
.dwProcessId
, current_event
.dwThreadId
,
1112 continue_status
== DBG_CONTINUE
?
1113 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1115 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1116 if ((id
== -1 || id
== (int) th
->id
)
1119 if (debug_registers_changed
)
1121 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1122 th
->context
.Dr0
= dr
[0];
1123 th
->context
.Dr1
= dr
[1];
1124 th
->context
.Dr2
= dr
[2];
1125 th
->context
.Dr3
= dr
[3];
1126 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1127 th
->context
.Dr7
= dr
[7];
1129 if (th
->context
.ContextFlags
)
1131 CHECK (SetThreadContext (th
->h
, &th
->context
));
1132 th
->context
.ContextFlags
= 0;
1134 if (th
->suspended
> 0)
1135 (void) ResumeThread (th
->h
);
1139 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1140 current_event
.dwThreadId
,
1143 debug_registers_changed
= 0;
1147 /* Called in pathological case where Windows fails to send a
1148 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1150 fake_create_process (void)
1152 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1153 current_event
.dwProcessId
);
1154 if (current_process_handle
!= NULL
)
1155 open_process_used
= 1;
1158 error (_("OpenProcess call failed, GetLastError = %lud\n"),
1160 /* We can not debug anything in that case. */
1162 main_thread_id
= current_event
.dwThreadId
;
1163 current_thread
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1164 current_event
.dwThreadId
),
1165 current_event
.u
.CreateThread
.hThread
);
1166 return main_thread_id
;
1170 windows_resume (struct target_ops
*ops
,
1171 ptid_t ptid
, int step
, enum target_signal sig
)
1174 DWORD continue_status
= DBG_CONTINUE
;
1176 /* A specific PTID means `step only this thread id'. */
1177 int resume_all
= ptid_equal (ptid
, minus_one_ptid
);
1179 /* If we're continuing all threads, it's the current inferior that
1180 should be handled specially. */
1182 ptid
= inferior_ptid
;
1184 if (sig
!= TARGET_SIGNAL_0
)
1186 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1188 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1190 else if (sig
== last_sig
)
1191 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1194 /* This code does not seem to work, because
1195 the kernel does probably not consider changes in the ExceptionRecord
1196 structure when passing the exception to the inferior.
1197 Note that this seems possible in the exception handler itself. */
1200 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1201 if (xlate
[i
].us
== sig
)
1203 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
=
1205 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1208 if (continue_status
== DBG_CONTINUE
)
1210 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1214 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1218 last_sig
= TARGET_SIGNAL_0
;
1220 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1221 ptid_get_pid (ptid
), ptid_get_tid (ptid
), step
, sig
));
1223 /* Get context for currently selected thread */
1224 th
= thread_rec (ptid_get_tid (inferior_ptid
), FALSE
);
1229 /* Single step by setting t bit */
1230 windows_fetch_inferior_registers (ops
,
1231 get_current_regcache (),
1232 gdbarch_ps_regnum (current_gdbarch
));
1233 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1236 if (th
->context
.ContextFlags
)
1238 if (debug_registers_changed
)
1240 th
->context
.Dr0
= dr
[0];
1241 th
->context
.Dr1
= dr
[1];
1242 th
->context
.Dr2
= dr
[2];
1243 th
->context
.Dr3
= dr
[3];
1244 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1245 th
->context
.Dr7
= dr
[7];
1247 CHECK (SetThreadContext (th
->h
, &th
->context
));
1248 th
->context
.ContextFlags
= 0;
1252 /* Allow continuing with the same signal that interrupted us.
1253 Otherwise complain. */
1256 windows_continue (continue_status
, -1);
1258 windows_continue (continue_status
, ptid_get_tid (ptid
));
1261 /* Get the next event from the child. Return 1 if the event requires
1262 handling by WFI (or whatever).
1265 get_windows_debug_event (struct target_ops
*ops
,
1266 int pid
, struct target_waitstatus
*ourstatus
)
1269 DWORD continue_status
, event_code
;
1271 static thread_info dummy_thread_info
;
1274 last_sig
= TARGET_SIGNAL_0
;
1276 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1280 continue_status
= DBG_CONTINUE
;
1282 event_code
= current_event
.dwDebugEventCode
;
1283 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1285 have_saved_context
= 0;
1289 case CREATE_THREAD_DEBUG_EVENT
:
1290 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1291 (unsigned) current_event
.dwProcessId
,
1292 (unsigned) current_event
.dwThreadId
,
1293 "CREATE_THREAD_DEBUG_EVENT"));
1294 if (saw_create
!= 1)
1296 struct inferior
*inf
;
1297 inf
= find_inferior_pid (current_event
.dwProcessId
);
1298 if (!saw_create
&& inf
->attach_flag
)
1300 /* Kludge around a Windows bug where first event is a create
1301 thread event. Caused when attached process does not have
1303 retval
= fake_create_process ();
1309 /* Record the existence of this thread */
1310 retval
= current_event
.dwThreadId
;
1311 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1312 current_event
.dwThreadId
),
1313 current_event
.u
.CreateThread
.hThread
);
1316 case EXIT_THREAD_DEBUG_EVENT
:
1317 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1318 (unsigned) current_event
.dwProcessId
,
1319 (unsigned) current_event
.dwThreadId
,
1320 "EXIT_THREAD_DEBUG_EVENT"));
1321 if (current_event
.dwThreadId
!= main_thread_id
)
1323 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1324 current_event
.dwThreadId
));
1325 th
= &dummy_thread_info
;
1329 case CREATE_PROCESS_DEBUG_EVENT
:
1330 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1331 (unsigned) current_event
.dwProcessId
,
1332 (unsigned) current_event
.dwThreadId
,
1333 "CREATE_PROCESS_DEBUG_EVENT"));
1334 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1335 if (++saw_create
!= 1)
1338 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1340 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1342 main_thread_id
= current_event
.dwThreadId
;
1343 /* Add the main thread */
1344 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1345 current_event
.dwThreadId
),
1346 current_event
.u
.CreateProcessInfo
.hThread
);
1347 retval
= current_event
.dwThreadId
;
1350 case EXIT_PROCESS_DEBUG_EVENT
:
1351 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1352 (unsigned) current_event
.dwProcessId
,
1353 (unsigned) current_event
.dwThreadId
,
1354 "EXIT_PROCESS_DEBUG_EVENT"));
1355 if (saw_create
!= 1)
1357 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1358 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1359 retval
= main_thread_id
;
1362 case LOAD_DLL_DEBUG_EVENT
:
1363 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1364 (unsigned) current_event
.dwProcessId
,
1365 (unsigned) current_event
.dwThreadId
,
1366 "LOAD_DLL_DEBUG_EVENT"));
1367 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1368 if (saw_create
!= 1)
1370 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1371 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1372 ourstatus
->value
.integer
= 0;
1373 retval
= main_thread_id
;
1376 case UNLOAD_DLL_DEBUG_EVENT
:
1377 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1378 (unsigned) current_event
.dwProcessId
,
1379 (unsigned) current_event
.dwThreadId
,
1380 "UNLOAD_DLL_DEBUG_EVENT"));
1381 if (saw_create
!= 1)
1383 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1384 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1385 ourstatus
->value
.integer
= 0;
1386 retval
= main_thread_id
;
1389 case EXCEPTION_DEBUG_EVENT
:
1390 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1391 (unsigned) current_event
.dwProcessId
,
1392 (unsigned) current_event
.dwThreadId
,
1393 "EXCEPTION_DEBUG_EVENT"));
1394 if (saw_create
!= 1)
1396 switch (handle_exception (ourstatus
))
1399 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1402 retval
= current_event
.dwThreadId
;
1406 continue_status
= -1;
1411 case OUTPUT_DEBUG_STRING_EVENT
: /* message from the kernel */
1412 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1413 (unsigned) current_event
.dwProcessId
,
1414 (unsigned) current_event
.dwThreadId
,
1415 "OUTPUT_DEBUG_STRING_EVENT"));
1416 if (saw_create
!= 1)
1418 retval
= handle_output_debug_string (ourstatus
);
1422 if (saw_create
!= 1)
1424 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1425 (DWORD
) current_event
.dwProcessId
,
1426 (DWORD
) current_event
.dwThreadId
);
1427 printf_unfiltered (" unknown event code %ld\n",
1428 current_event
.dwDebugEventCode
);
1432 if (!retval
|| saw_create
!= 1)
1434 if (continue_status
== -1)
1435 windows_resume (minus_one_ptid
, 0, 1);
1437 CHECK (windows_continue (continue_status
, -1));
1441 inferior_ptid
= ptid_build (current_event
.dwProcessId
, 0,
1443 current_thread
= th
?: thread_rec (current_event
.dwThreadId
, TRUE
);
1450 /* Wait for interesting events to occur in the target process. */
1452 windows_wait (struct target_ops
*ops
,
1453 ptid_t ptid
, struct target_waitstatus
*ourstatus
)
1457 target_terminal_ours ();
1459 /* We loop when we get a non-standard exception rather than return
1460 with a SPURIOUS because resume can try and step or modify things,
1461 which needs a current_thread->h. But some of these exceptions mark
1462 the birth or death of threads, which mean that the current thread
1463 isn't necessarily what you think it is. */
1469 /* Ignore CTRL+C signals while waiting for a debug event.
1470 FIXME: brobecker/2008-05-20: When the user presses CTRL+C while
1471 the inferior is running, both the inferior and GDB receive the
1472 associated signal. If the inferior receives the signal first
1473 and the delay until GDB receives that signal is sufficiently long,
1474 GDB can sometimes receive the SIGINT after we have unblocked
1475 the CTRL+C handler. This would lead to the debugger to stop
1476 prematurely while handling the new-thread event that comes
1477 with the handling of the SIGINT inside the inferior, and then
1478 stop again immediately when the user tries to resume the execution
1479 in the inferior. This is a classic race, and it would be nice
1480 to find a better solution to that problem. But in the meantime,
1481 the current approach already greatly mitigate this issue. */
1482 SetConsoleCtrlHandler (NULL
, TRUE
);
1483 retval
= get_windows_debug_event (ops
, pid
, ourstatus
);
1484 SetConsoleCtrlHandler (NULL
, FALSE
);
1487 return ptid_build (current_event
.dwProcessId
, 0, retval
);
1492 if (deprecated_ui_loop_hook
!= NULL
)
1493 detach
= deprecated_ui_loop_hook (0);
1496 windows_kill_inferior ();
1502 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1504 extern int stop_after_trap
;
1506 struct inferior
*inf
;
1507 struct thread_info
*tp
;
1509 last_sig
= TARGET_SIGNAL_0
;
1511 exception_count
= 0;
1512 open_process_used
= 0;
1513 debug_registers_changed
= 0;
1514 debug_registers_used
= 0;
1515 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1518 cygwin_load_start
= cygwin_load_end
= 0;
1520 current_event
.dwProcessId
= pid
;
1521 memset (¤t_event
, 0, sizeof (current_event
));
1523 disable_breakpoints_in_shlibs ();
1524 windows_clear_solib ();
1525 clear_proceed_status ();
1526 init_wait_for_inferior ();
1528 inf
= add_inferior (pid
);
1529 inf
->attach_flag
= attaching
;
1531 /* Make the new process the current inferior, so terminal handling
1532 can rely on it. When attaching, we don't know about any thread
1533 id here, but that's OK --- nothing should be referencing the
1534 current thread until we report an event out of windows_wait. */
1535 inferior_ptid
= pid_to_ptid (pid
);
1537 terminal_init_inferior_with_pgrp (pid
);
1538 target_terminal_inferior ();
1540 inf
->stop_soon
= STOP_QUIETLY
;
1543 stop_after_trap
= 1;
1544 wait_for_inferior (0);
1545 tp
= inferior_thread ();
1546 if (tp
->stop_signal
!= TARGET_SIGNAL_TRAP
)
1547 resume (0, tp
->stop_signal
);
1552 inf
->stop_soon
= NO_STOP_QUIETLY
;
1553 stop_after_trap
= 0;
1557 /* Since Windows XP, detaching from a process is supported by Windows.
1558 The following code tries loading the appropriate functions dynamically.
1559 If loading these functions succeeds use them to actually detach from
1560 the inferior process, otherwise behave as usual, pretending that
1561 detach has worked. */
1562 static BOOL
WINAPI (*kernel32_DebugSetProcessKillOnExit
)(BOOL
);
1563 static BOOL
WINAPI (*kernel32_DebugActiveProcessStop
)(DWORD
);
1566 has_detach_ability (void)
1568 static HMODULE kernel32
= NULL
;
1571 kernel32
= LoadLibrary ("kernel32.dll");
1574 if (!kernel32_DebugSetProcessKillOnExit
)
1575 kernel32_DebugSetProcessKillOnExit
=
1576 (void *) GetProcAddress (kernel32
, "DebugSetProcessKillOnExit");
1577 if (!kernel32_DebugActiveProcessStop
)
1578 kernel32_DebugActiveProcessStop
=
1579 (void *) GetProcAddress (kernel32
, "DebugActiveProcessStop");
1580 if (kernel32_DebugSetProcessKillOnExit
1581 && kernel32_DebugActiveProcessStop
)
1587 /* Try to set or remove a user privilege to the current process. Return -1
1588 if that fails, the previous setting of that privilege otherwise.
1590 This code is copied from the Cygwin source code and rearranged to allow
1591 dynamically loading of the needed symbols from advapi32 which is only
1592 available on NT/2K/XP. */
1594 set_process_privilege (const char *privilege
, BOOL enable
)
1596 static HMODULE advapi32
= NULL
;
1597 static BOOL
WINAPI (*OpenProcessToken
)(HANDLE
, DWORD
, PHANDLE
);
1598 static BOOL
WINAPI (*LookupPrivilegeValue
)(LPCSTR
, LPCSTR
, PLUID
);
1599 static BOOL
WINAPI (*AdjustTokenPrivileges
)(HANDLE
, BOOL
, PTOKEN_PRIVILEGES
,
1600 DWORD
, PTOKEN_PRIVILEGES
, PDWORD
);
1602 HANDLE token_hdl
= NULL
;
1604 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1608 if (GetVersion () >= 0x80000000) /* No security availbale on 9x/Me */
1613 if (!(advapi32
= LoadLibrary ("advapi32.dll")))
1615 if (!OpenProcessToken
)
1617 (void *) GetProcAddress (advapi32
, "OpenProcessToken");
1618 if (!LookupPrivilegeValue
)
1619 LookupPrivilegeValue
=
1620 (void *) GetProcAddress (advapi32
, "LookupPrivilegeValueA");
1621 if (!AdjustTokenPrivileges
)
1622 AdjustTokenPrivileges
=
1623 (void *) GetProcAddress (advapi32
, "AdjustTokenPrivileges");
1624 if (!OpenProcessToken
|| !LookupPrivilegeValue
|| !AdjustTokenPrivileges
)
1631 if (!OpenProcessToken (GetCurrentProcess (),
1632 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1636 if (!LookupPrivilegeValue (NULL
, privilege
, &restore_priv
))
1639 new_priv
.PrivilegeCount
= 1;
1640 new_priv
.Privileges
[0].Luid
= restore_priv
;
1641 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1643 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1644 sizeof orig_priv
, &orig_priv
, &size
))
1647 /* Disabled, otherwise every `attach' in an unprivileged user session
1648 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1649 windows_attach(). */
1650 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1651 be enabled. GetLastError () returns an correct error code, though. */
1652 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1656 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1660 CloseHandle (token_hdl
);
1665 /* Attach to process PID, then initialize for debugging it. */
1667 windows_attach (struct target_ops
*ops
, char *args
, int from_tty
)
1673 error_no_arg (_("process-id to attach"));
1675 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1677 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1678 printf_unfiltered ("This can cause attach to fail on Windows NT/2K/XP\n");
1681 pid
= strtoul (args
, 0, 0); /* Windows pid */
1683 windows_init_thread_list ();
1684 ok
= DebugActiveProcess (pid
);
1690 /* Try fall back to Cygwin pid */
1691 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1694 ok
= DebugActiveProcess (pid
);
1699 error (_("Can't attach to process."));
1701 if (has_detach_ability ())
1702 kernel32_DebugSetProcessKillOnExit (FALSE
);
1706 char *exec_file
= (char *) get_exec_file (0);
1709 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1710 target_pid_to_str (pid_to_ptid (pid
)));
1712 printf_unfiltered ("Attaching to %s\n",
1713 target_pid_to_str (pid_to_ptid (pid
)));
1715 gdb_flush (gdb_stdout
);
1718 do_initial_windows_stuff (ops
, pid
, 1);
1719 target_terminal_ours ();
1723 windows_detach (struct target_ops
*ops
, char *args
, int from_tty
)
1727 if (has_detach_ability ())
1730 windows_resume (ops
, ptid
, 0, TARGET_SIGNAL_0
);
1732 if (!kernel32_DebugActiveProcessStop (current_event
.dwProcessId
))
1734 error (_("Can't detach process %lu (error %lu)"),
1735 current_event
.dwProcessId
, GetLastError ());
1738 kernel32_DebugSetProcessKillOnExit (FALSE
);
1740 if (detached
&& from_tty
)
1742 char *exec_file
= get_exec_file (0);
1745 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file
,
1746 current_event
.dwProcessId
);
1747 gdb_flush (gdb_stdout
);
1750 inferior_ptid
= null_ptid
;
1751 detach_inferior (current_event
.dwProcessId
);
1753 unpush_target (ops
);
1757 windows_pid_to_exec_file (int pid
)
1759 static char path
[MAX_PATH
+ 1];
1762 /* Try to find exe name as symlink target of /proc/<pid>/exe */
1764 char procexe
[sizeof ("/proc/4294967295/exe")];
1765 sprintf (procexe
, "/proc/%u/exe", pid
);
1766 nchars
= readlink (procexe
, path
, sizeof(path
));
1767 if (nchars
> 0 && nchars
< sizeof (path
))
1769 path
[nchars
] = '\0'; /* Got it */
1774 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
1775 of gdb, or we're trying to debug a non-Cygwin windows executable. */
1776 if (!get_module_name (0, path
))
1782 /* Print status information about what we're accessing. */
1785 windows_files_info (struct target_ops
*ignore
)
1787 struct inferior
*inf
= current_inferior ();
1789 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1790 inf
->attach_flag
? "attached" : "child",
1791 target_pid_to_str (inferior_ptid
));
1795 windows_open (char *arg
, int from_tty
)
1797 error (_("Use the \"run\" command to start a Unix child process."));
1800 /* Start an inferior windows child process and sets inferior_ptid to its pid.
1801 EXEC_FILE is the file to run.
1802 ALLARGS is a string containing the arguments to the program.
1803 ENV is the environment vector to pass. Errors reported with error(). */
1806 windows_create_inferior (struct target_ops
*ops
, char *exec_file
,
1807 char *allargs
, char **in_env
, int from_tty
)
1810 PROCESS_INFORMATION pi
;
1814 char real_path
[MAXPATHLEN
];
1816 char shell
[MAX_PATH
+ 1]; /* Path to shell */
1819 int ostdin
, ostdout
, ostderr
;
1820 const char *inferior_io_terminal
= get_inferior_io_terminal ();
1823 error (_("No executable specified, use `target exec'."));
1825 memset (&si
, 0, sizeof (si
));
1826 si
.cb
= sizeof (si
);
1831 flags
= DEBUG_ONLY_THIS_PROCESS
;
1832 cygwin_conv_to_win32_path (exec_file
, real_path
);
1838 sh
= getenv ("SHELL");
1841 cygwin_conv_to_win32_path (sh
, shell
);
1842 newallargs
= alloca (sizeof (" -c 'exec '") + strlen (exec_file
)
1843 + strlen (allargs
) + 2);
1844 sprintf (newallargs
, " -c 'exec %s %s'", exec_file
, allargs
);
1845 allargs
= newallargs
;
1847 flags
= DEBUG_PROCESS
;
1851 flags
= DEBUG_ONLY_THIS_PROCESS
;
1855 flags
|= CREATE_NEW_PROCESS_GROUP
;
1858 flags
|= CREATE_NEW_CONSOLE
;
1860 args
= alloca (strlen (toexec
) + strlen (allargs
) + 2);
1861 strcpy (args
, toexec
);
1863 strcat (args
, allargs
);
1866 /* Prepare the environment vars for CreateProcess. */
1867 cygwin_internal (CW_SYNC_WINENV
);
1869 if (!inferior_io_terminal
)
1870 tty
= ostdin
= ostdout
= ostderr
= -1;
1873 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
1876 print_sys_errmsg (inferior_io_terminal
, errno
);
1877 ostdin
= ostdout
= ostderr
= -1;
1891 windows_init_thread_list ();
1892 ret
= CreateProcess (0,
1893 args
, /* command line */
1894 NULL
, /* Security */
1896 TRUE
, /* inherit handles */
1897 flags
, /* start flags */
1898 NULL
, /* environment */
1899 NULL
, /* current directory */
1917 error (_("Error creating process %s, (error %d)."),
1918 exec_file
, (unsigned) GetLastError ());
1920 CloseHandle (pi
.hThread
);
1921 CloseHandle (pi
.hProcess
);
1923 if (useshell
&& shell
[0] != '\0')
1928 do_initial_windows_stuff (ops
, pi
.dwProcessId
, 0);
1930 /* windows_continue (DBG_CONTINUE, -1); */
1934 windows_mourn_inferior (struct target_ops
*ops
)
1936 (void) windows_continue (DBG_CONTINUE
, -1);
1937 i386_cleanup_dregs();
1938 if (open_process_used
)
1940 CHECK (CloseHandle (current_process_handle
));
1941 open_process_used
= 0;
1943 unpush_target (ops
);
1944 generic_mourn_inferior ();
1947 /* Send a SIGINT to the process group. This acts just like the user typed a
1948 ^C on the controlling terminal. */
1951 windows_stop (ptid_t ptid
)
1953 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1954 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
1955 registers_changed (); /* refresh register state */
1959 windows_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*our
, int len
,
1960 int write
, struct mem_attrib
*mem
,
1961 struct target_ops
*target
)
1966 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1967 len
, (DWORD
) (uintptr_t) memaddr
));
1968 if (!WriteProcessMemory (current_process_handle
,
1969 (LPVOID
) (uintptr_t) memaddr
, our
,
1972 FlushInstructionCache (current_process_handle
,
1973 (LPCVOID
) (uintptr_t) memaddr
, len
);
1977 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
1978 len
, (DWORD
) (uintptr_t) memaddr
));
1979 if (!ReadProcessMemory (current_process_handle
,
1980 (LPCVOID
) (uintptr_t) memaddr
, our
,
1988 windows_kill_inferior (void)
1990 CHECK (TerminateProcess (current_process_handle
, 0));
1994 if (!windows_continue (DBG_CONTINUE
, -1))
1996 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
1998 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2002 target_mourn_inferior (); /* or just windows_mourn_inferior? */
2006 windows_prepare_to_store (struct regcache
*regcache
)
2008 /* Do nothing, since we can store individual regs */
2012 windows_can_run (void)
2018 windows_close (int x
)
2020 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2021 PIDGET (inferior_ptid
)));
2024 /* Convert pid to printable format. */
2026 windows_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
2028 static char buf
[80];
2030 if (ptid_get_tid (ptid
) != 0)
2032 snprintf (buf
, sizeof (buf
), "Thread %d.0x%lx",
2033 ptid_get_pid (ptid
), ptid_get_tid (ptid
));
2037 return normal_pid_to_str (ptid
);
2041 windows_xfer_shared_libraries (struct target_ops
*ops
,
2042 enum target_object object
, const char *annex
,
2043 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2044 ULONGEST offset
, LONGEST len
)
2046 struct obstack obstack
;
2054 obstack_init (&obstack
);
2055 obstack_grow_str (&obstack
, "<library-list>\n");
2056 for (so
= solib_start
.next
; so
; so
= so
->next
)
2057 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
) (uintptr_t) so
->lm_info
->load_addr
,
2059 obstack_grow_str0 (&obstack
, "</library-list>\n");
2061 buf
= obstack_finish (&obstack
);
2062 len_avail
= strlen (buf
);
2063 if (offset
>= len_avail
)
2066 if (len
> len_avail
- offset
)
2067 len
= len_avail
- offset
;
2068 memcpy (readbuf
, buf
+ offset
, len
);
2070 obstack_free (&obstack
, NULL
);
2075 windows_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2076 const char *annex
, gdb_byte
*readbuf
,
2077 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
2081 case TARGET_OBJECT_MEMORY
:
2083 return (*ops
->deprecated_xfer_memory
) (offset
, readbuf
,
2084 len
, 0/*read*/, NULL
, ops
);
2086 return (*ops
->deprecated_xfer_memory
) (offset
, (gdb_byte
*) writebuf
,
2087 len
, 1/*write*/, NULL
, ops
);
2090 case TARGET_OBJECT_LIBRARIES
:
2091 return windows_xfer_shared_libraries (ops
, object
, annex
, readbuf
,
2092 writebuf
, offset
, len
);
2095 if (ops
->beneath
!= NULL
)
2096 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2097 readbuf
, writebuf
, offset
, len
);
2103 init_windows_ops (void)
2105 windows_ops
.to_shortname
= "child";
2106 windows_ops
.to_longname
= "Win32 child process";
2107 windows_ops
.to_doc
= "Win32 child process (started by the \"run\" command).";
2108 windows_ops
.to_open
= windows_open
;
2109 windows_ops
.to_close
= windows_close
;
2110 windows_ops
.to_attach
= windows_attach
;
2111 windows_ops
.to_attach_no_wait
= 1;
2112 windows_ops
.to_detach
= windows_detach
;
2113 windows_ops
.to_resume
= windows_resume
;
2114 windows_ops
.to_wait
= windows_wait
;
2115 windows_ops
.to_fetch_registers
= windows_fetch_inferior_registers
;
2116 windows_ops
.to_store_registers
= windows_store_inferior_registers
;
2117 windows_ops
.to_prepare_to_store
= windows_prepare_to_store
;
2118 windows_ops
.deprecated_xfer_memory
= windows_xfer_memory
;
2119 windows_ops
.to_xfer_partial
= windows_xfer_partial
;
2120 windows_ops
.to_files_info
= windows_files_info
;
2121 windows_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
2122 windows_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
2123 windows_ops
.to_terminal_init
= terminal_init_inferior
;
2124 windows_ops
.to_terminal_inferior
= terminal_inferior
;
2125 windows_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
2126 windows_ops
.to_terminal_ours
= terminal_ours
;
2127 windows_ops
.to_terminal_save_ours
= terminal_save_ours
;
2128 windows_ops
.to_terminal_info
= child_terminal_info
;
2129 windows_ops
.to_kill
= windows_kill_inferior
;
2130 windows_ops
.to_create_inferior
= windows_create_inferior
;
2131 windows_ops
.to_mourn_inferior
= windows_mourn_inferior
;
2132 windows_ops
.to_can_run
= windows_can_run
;
2133 windows_ops
.to_thread_alive
= windows_thread_alive
;
2134 windows_ops
.to_pid_to_str
= windows_pid_to_str
;
2135 windows_ops
.to_stop
= windows_stop
;
2136 windows_ops
.to_stratum
= process_stratum
;
2137 windows_ops
.to_has_all_memory
= 1;
2138 windows_ops
.to_has_memory
= 1;
2139 windows_ops
.to_has_stack
= 1;
2140 windows_ops
.to_has_registers
= 1;
2141 windows_ops
.to_has_execution
= 1;
2142 windows_ops
.to_pid_to_exec_file
= windows_pid_to_exec_file
;
2143 i386_use_watchpoints (&windows_ops
);
2145 windows_ops
.to_magic
= OPS_MAGIC
;
2149 set_windows_aliases (char *argv0
)
2151 add_info_alias ("dll", "sharedlibrary", 1);
2155 _initialize_windows_nat (void)
2157 struct cmd_list_element
*c
;
2159 init_windows_ops ();
2161 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
2162 _("Load dll library symbols from FILE."));
2163 set_cmd_completer (c
, filename_completer
);
2165 add_com_alias ("sharedlibrary", "dll-symbols", class_alias
, 1);
2168 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
2169 Set use of shell to start subprocess."), _("\
2170 Show use of shell to start subprocess."), NULL
,
2172 NULL
, /* FIXME: i18n: */
2173 &setlist
, &showlist
);
2175 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
, &cygwin_exceptions
, _("\
2176 Break when an exception is detected in the Cygwin DLL itself."), _("\
2177 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
2179 NULL
, /* FIXME: i18n: */
2180 &setlist
, &showlist
);
2183 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
2184 Set creation of new console when creating child process."), _("\
2185 Show creation of new console when creating child process."), NULL
,
2187 NULL
, /* FIXME: i18n: */
2188 &setlist
, &showlist
);
2190 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
2191 Set creation of new group when creating child process."), _("\
2192 Show creation of new group when creating child process."), NULL
,
2194 NULL
, /* FIXME: i18n: */
2195 &setlist
, &showlist
);
2197 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
2198 Set whether to display execution in child process."), _("\
2199 Show whether to display execution in child process."), NULL
,
2201 NULL
, /* FIXME: i18n: */
2202 &setlist
, &showlist
);
2204 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
2205 Set whether to display kernel events in child process."), _("\
2206 Show whether to display kernel events in child process."), NULL
,
2208 NULL
, /* FIXME: i18n: */
2209 &setlist
, &showlist
);
2211 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
2212 Set whether to display memory accesses in child process."), _("\
2213 Show whether to display memory accesses in child process."), NULL
,
2215 NULL
, /* FIXME: i18n: */
2216 &setlist
, &showlist
);
2218 add_setshow_boolean_cmd ("debugexceptions", class_support
,
2219 &debug_exceptions
, _("\
2220 Set whether to display kernel exceptions in child process."), _("\
2221 Show whether to display kernel exceptions in child process."), NULL
,
2223 NULL
, /* FIXME: i18n: */
2224 &setlist
, &showlist
);
2226 add_prefix_cmd ("w32", class_info
, info_w32_command
,
2227 _("Print information specific to Win32 debugging."),
2228 &info_w32_cmdlist
, "info w32 ", 0, &infolist
);
2230 add_cmd ("selector", class_info
, display_selectors
,
2231 _("Display selectors infos."),
2233 add_target (&windows_ops
);
2234 deprecated_init_ui_hook
= set_windows_aliases
;
2237 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2239 /* Pass the address ADDR to the inferior in the I'th debug register.
2240 Here we just store the address in dr array, the registers will be
2241 actually set up when windows_continue is called. */
2243 cygwin_set_dr (int i
, CORE_ADDR addr
)
2246 internal_error (__FILE__
, __LINE__
,
2247 _("Invalid register %d in cygwin_set_dr.\n"), i
);
2248 dr
[i
] = (unsigned) addr
;
2249 debug_registers_changed
= 1;
2250 debug_registers_used
= 1;
2253 /* Pass the value VAL to the inferior in the DR7 debug control
2254 register. Here we just store the address in D_REGS, the watchpoint
2255 will be actually set up in windows_wait. */
2257 cygwin_set_dr7 (unsigned val
)
2260 debug_registers_changed
= 1;
2261 debug_registers_used
= 1;
2264 /* Get the value of the DR6 debug status register from the inferior.
2265 Here we just return the value stored in dr[6]
2266 by the last call to thread_rec for current_event.dwThreadId id. */
2268 cygwin_get_dr6 (void)
2273 /* Determine if the thread referenced by "ptid" is alive
2274 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2275 it means that the thread has died. Otherwise it is assumed to be alive. */
2277 windows_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
2281 gdb_assert (ptid_get_tid (ptid
) != 0);
2282 tid
= ptid_get_tid (ptid
);
2284 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
?
2289 _initialize_check_for_gdb_ini (void)
2292 if (inhibit_gdbinit
)
2295 homedir
= getenv ("HOME");
2299 char *oldini
= (char *) alloca (strlen (homedir
) +
2300 sizeof ("/gdb.ini"));
2301 strcpy (oldini
, homedir
);
2302 p
= strchr (oldini
, '\0');
2303 if (p
> oldini
&& p
[-1] != '/')
2305 strcpy (p
, "gdb.ini");
2306 if (access (oldini
, 0) == 0)
2308 int len
= strlen (oldini
);
2309 char *newini
= alloca (len
+ 1);
2310 sprintf (newini
, "%.*s.gdbinit",
2311 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
2312 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
2318 _initialize_psapi (void)
2320 /* Load optional functions used for retrieving filename information
2321 associated with the currently debugged process or its dlls. */
2324 HMODULE psapi_module_handle
;
2328 psapi_module_handle
= LoadLibrary ("psapi.dll");
2329 if (psapi_module_handle
)
2331 psapi_EnumProcessModules
= (void *) GetProcAddress (psapi_module_handle
, "EnumProcessModules");
2332 psapi_GetModuleInformation
= (void *) GetProcAddress (psapi_module_handle
, "GetModuleInformation");
2333 psapi_GetModuleFileNameExA
= (void *) GetProcAddress (psapi_module_handle
, "GetModuleFileNameExA");
2335 if (psapi_EnumProcessModules
!= NULL
2336 && psapi_GetModuleInformation
!= NULL
2337 && psapi_GetModuleFileNameExA
!= NULL
)
2342 /* This will probably fail on Windows 9x/Me. Let the user know that we're
2343 missing some functionality. */
2344 if (psapi_loaded
< 0)
2345 warning(_("cannot automatically find executable file or library to read symbols. Use \"file\" or \"dll\" command to load executable/libraries directly."));