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 "gdb_stdint.h"
52 #include "gdbthread.h"
54 #include <sys/param.h>
59 #include "xml-support.h"
61 #include "i386-tdep.h"
62 #include "i387-tdep.h"
64 #include "i386-cygwin-tdep.h"
66 static struct target_ops win32_ops
;
69 /* The starting and ending address of the cygwin1.dll text segment. */
70 static bfd_vma cygwin_load_start
;
71 static bfd_vma 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 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \
90 | CONTEXT_EXTENDED_REGISTERS
92 static unsigned dr
[8];
93 static int debug_registers_changed
;
94 static int debug_registers_used
;
95 #define DR6_CLEAR_VALUE 0xffff0ff0
97 /* The string sent by cygwin when it processes a signal.
98 FIXME: This should be in a cygwin include file. */
99 #ifndef _CYGWIN_SIGNAL_STRING
100 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
103 #define CHECK(x) check (x, __FILE__,__LINE__)
104 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
105 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
106 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
107 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
109 static void win32_stop (void);
110 static int win32_win32_thread_alive (ptid_t
);
111 static void win32_kill_inferior (void);
113 static enum target_signal last_sig
= TARGET_SIGNAL_0
;
114 /* Set if a signal was received from the debugged process */
116 /* Thread information structure used to track information that is
117 not available in gdb's thread structure. */
118 typedef struct thread_info_struct
120 struct thread_info_struct
*next
;
131 static thread_info thread_head
;
133 /* The process and thread handles for the above context. */
135 static DEBUG_EVENT current_event
; /* The current debug event from
137 static HANDLE current_process_handle
; /* Currently executing process */
138 static thread_info
*current_thread
; /* Info on currently selected thread */
139 static DWORD main_thread_id
; /* Thread ID of the main thread */
141 /* Counts of things. */
142 static int exception_count
= 0;
143 static int event_count
= 0;
144 static int saw_create
;
145 static int open_process_used
= 0;
148 static int new_console
= 0;
150 static int cygwin_exceptions
= 0;
152 static int new_group
= 1;
153 static int debug_exec
= 0; /* show execution */
154 static int debug_events
= 0; /* show events from kernel */
155 static int debug_memory
= 0; /* show target memory accesses */
156 static int debug_exceptions
= 0; /* show target exceptions */
157 static int useshell
= 0; /* use shell for subprocesses */
159 /* This vector maps GDB's idea of a register's number into an address
160 in the win32 exception context vector.
162 It also contains the bit mask needed to load the register in question.
164 One day we could read a reg, we could inspect the context we
165 already have loaded, if it doesn't have the bit set that we need,
166 we read that set of registers in using GetThreadContext. If the
167 context already contains what we need, we just unpack it. Then to
168 write a register, first we have to ensure that the context contains
169 the other regs of the group, and then we copy the info in and set
172 #define context_offset(x) ((int)&(((CONTEXT *)NULL)->x))
173 static const int mappings
[] =
175 context_offset (Eax
),
176 context_offset (Ecx
),
177 context_offset (Edx
),
178 context_offset (Ebx
),
179 context_offset (Esp
),
180 context_offset (Ebp
),
181 context_offset (Esi
),
182 context_offset (Edi
),
183 context_offset (Eip
),
184 context_offset (EFlags
),
185 context_offset (SegCs
),
186 context_offset (SegSs
),
187 context_offset (SegDs
),
188 context_offset (SegEs
),
189 context_offset (SegFs
),
190 context_offset (SegGs
),
191 context_offset (FloatSave
.RegisterArea
[0 * 10]),
192 context_offset (FloatSave
.RegisterArea
[1 * 10]),
193 context_offset (FloatSave
.RegisterArea
[2 * 10]),
194 context_offset (FloatSave
.RegisterArea
[3 * 10]),
195 context_offset (FloatSave
.RegisterArea
[4 * 10]),
196 context_offset (FloatSave
.RegisterArea
[5 * 10]),
197 context_offset (FloatSave
.RegisterArea
[6 * 10]),
198 context_offset (FloatSave
.RegisterArea
[7 * 10]),
199 context_offset (FloatSave
.ControlWord
),
200 context_offset (FloatSave
.StatusWord
),
201 context_offset (FloatSave
.TagWord
),
202 context_offset (FloatSave
.ErrorSelector
),
203 context_offset (FloatSave
.ErrorOffset
),
204 context_offset (FloatSave
.DataSelector
),
205 context_offset (FloatSave
.DataOffset
),
206 context_offset (FloatSave
.ErrorSelector
)
208 context_offset (ExtendedRegisters
[10*16]),
209 context_offset (ExtendedRegisters
[11*16]),
210 context_offset (ExtendedRegisters
[12*16]),
211 context_offset (ExtendedRegisters
[13*16]),
212 context_offset (ExtendedRegisters
[14*16]),
213 context_offset (ExtendedRegisters
[15*16]),
214 context_offset (ExtendedRegisters
[16*16]),
215 context_offset (ExtendedRegisters
[17*16]),
217 context_offset (ExtendedRegisters
[24])
220 #undef context_offset
222 /* This vector maps the target's idea of an exception (extracted
223 from the DEBUG_EVENT structure) to GDB's idea. */
225 struct xlate_exception
228 enum target_signal us
;
231 static const struct xlate_exception
234 {EXCEPTION_ACCESS_VIOLATION
, TARGET_SIGNAL_SEGV
},
235 {STATUS_STACK_OVERFLOW
, TARGET_SIGNAL_SEGV
},
236 {EXCEPTION_BREAKPOINT
, TARGET_SIGNAL_TRAP
},
237 {DBG_CONTROL_C
, TARGET_SIGNAL_INT
},
238 {EXCEPTION_SINGLE_STEP
, TARGET_SIGNAL_TRAP
},
239 {STATUS_FLOAT_DIVIDE_BY_ZERO
, TARGET_SIGNAL_FPE
},
243 check (BOOL ok
, const char *file
, int line
)
246 printf_filtered ("error return %s:%d was %lu\n", file
, line
,
250 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
251 then also retrieve the context for this thread. If GET_CONTEXT is
252 negative, then don't suspend the thread. */
254 thread_rec (DWORD id
, int get_context
)
258 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
261 if (!th
->suspended
&& get_context
)
263 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
265 if (SuspendThread (th
->h
) == (DWORD
) -1)
267 DWORD err
= GetLastError ();
268 warning (_("SuspendThread failed. (winerr %d)"),
274 else if (get_context
< 0)
276 th
->reload_context
= 1;
284 /* Add a thread to the thread list */
286 win32_add_thread (DWORD id
, HANDLE h
)
290 if ((th
= thread_rec (id
, FALSE
)))
293 th
= XZALLOC (thread_info
);
296 th
->next
= thread_head
.next
;
297 thread_head
.next
= th
;
298 add_thread (pid_to_ptid (id
));
299 /* Set the debug registers for the new thread in they are used. */
300 if (debug_registers_used
)
302 /* Only change the value of the debug registers. */
303 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
304 CHECK (GetThreadContext (th
->h
, &th
->context
));
305 th
->context
.Dr0
= dr
[0];
306 th
->context
.Dr1
= dr
[1];
307 th
->context
.Dr2
= dr
[2];
308 th
->context
.Dr3
= dr
[3];
309 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
310 th
->context
.Dr7
= dr
[7];
311 CHECK (SetThreadContext (th
->h
, &th
->context
));
312 th
->context
.ContextFlags
= 0;
317 /* Clear out any old thread list and reintialize it to a
320 win32_init_thread_list (void)
322 thread_info
*th
= &thread_head
;
324 DEBUG_EVENTS (("gdb: win32_init_thread_list\n"));
326 while (th
->next
!= NULL
)
328 thread_info
*here
= th
->next
;
329 th
->next
= here
->next
;
332 thread_head
.next
= NULL
;
335 /* Delete a thread from the list of threads */
337 win32_delete_thread (DWORD id
)
342 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (pid_to_ptid (id
)));
343 delete_thread (pid_to_ptid (id
));
345 for (th
= &thread_head
;
346 th
->next
!= NULL
&& th
->next
->id
!= id
;
350 if (th
->next
!= NULL
)
352 thread_info
*here
= th
->next
;
353 th
->next
= here
->next
;
359 do_win32_fetch_inferior_registers (struct regcache
*regcache
, int r
)
361 char *context_offset
= ((char *) ¤t_thread
->context
) + mappings
[r
];
362 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
363 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
367 return; /* Windows sometimes uses a non-existent thread id in its
370 if (current_thread
->reload_context
)
372 #ifdef __COPY_CONTEXT_SIZE
373 if (have_saved_context
)
375 /* Lie about where the program actually is stopped since cygwin has informed us that
376 we should consider the signal to have occurred at another location which is stored
377 in "saved_context. */
378 memcpy (¤t_thread
->context
, &saved_context
, __COPY_CONTEXT_SIZE
);
379 have_saved_context
= 0;
384 thread_info
*th
= current_thread
;
385 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
386 GetThreadContext (th
->h
, &th
->context
);
387 /* Copy dr values from that thread.
388 But only if there were not modified since last stop. PR gdb/2388 */
389 if (!debug_registers_changed
)
391 dr
[0] = th
->context
.Dr0
;
392 dr
[1] = th
->context
.Dr1
;
393 dr
[2] = th
->context
.Dr2
;
394 dr
[3] = th
->context
.Dr3
;
395 dr
[6] = th
->context
.Dr6
;
396 dr
[7] = th
->context
.Dr7
;
399 current_thread
->reload_context
= 0;
402 if (r
== I387_FISEG_REGNUM (tdep
))
404 l
= *((long *) context_offset
) & 0xffff;
405 regcache_raw_supply (regcache
, r
, (char *) &l
);
407 else if (r
== I387_FOP_REGNUM (tdep
))
409 l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
410 regcache_raw_supply (regcache
, r
, (char *) &l
);
413 regcache_raw_supply (regcache
, r
, context_offset
);
416 for (r
= 0; r
< gdbarch_num_regs (gdbarch
); r
++)
417 do_win32_fetch_inferior_registers (regcache
, r
);
422 win32_fetch_inferior_registers (struct regcache
*regcache
, int r
)
424 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
425 /* Check if current_thread exists. Windows sometimes uses a non-existent
426 thread id in its events */
428 do_win32_fetch_inferior_registers (regcache
, r
);
432 do_win32_store_inferior_registers (const struct regcache
*regcache
, int r
)
435 /* Windows sometimes uses a non-existent thread id in its events */;
437 regcache_raw_collect (regcache
, r
,
438 ((char *) ¤t_thread
->context
) + mappings
[r
]);
441 for (r
= 0; r
< gdbarch_num_regs (get_regcache_arch (regcache
)); r
++)
442 do_win32_store_inferior_registers (regcache
, r
);
446 /* Store a new register value into the current thread context */
448 win32_store_inferior_registers (struct regcache
*regcache
, int r
)
450 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
451 /* Check if current_thread exists. Windows sometimes uses a non-existent
452 thread id in its events */
454 do_win32_store_inferior_registers (regcache
, r
);
457 static int psapi_loaded
= 0;
458 static BOOL
WINAPI (*psapi_EnumProcessModules
) (HANDLE
, HMODULE
*, DWORD
,
460 static BOOL
WINAPI (*psapi_GetModuleInformation
) (HANDLE
, HMODULE
, LPMODULEINFO
,
462 static DWORD
WINAPI (*psapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
, LPSTR
,
465 /* Get the name of a given module at at given base address. If base_address
466 is zero return the first loaded module (which is always the name of the
469 get_module_name (DWORD base_address
, char *dll_name_ret
)
475 HMODULE
*DllHandle
= dh_buf
; /* Set to temporary storage for initial query */
478 char pathbuf
[PATH_MAX
+ 1]; /* Temporary storage prior to converting to
481 char *pathbuf
= dll_name_ret
; /* Just copy directly to passed-in arg */
484 /* If psapi_loaded < 0 either psapi.dll is not available or it does not contain
485 the needed functions. */
486 if (psapi_loaded
<= 0)
490 /* Find size of buffer needed to handle list of modules loaded in inferior */
491 if (!psapi_EnumProcessModules (current_process_handle
, DllHandle
,
492 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
495 /* Allocate correct amount of space for module list */
496 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
500 /* Get the list of modules */
501 if (!psapi_EnumProcessModules (current_process_handle
, DllHandle
, cbNeeded
,
505 for (i
= 0; i
< (int) (cbNeeded
/ sizeof (HMODULE
)); i
++)
507 /* Get information on this module */
508 if (!psapi_GetModuleInformation (current_process_handle
, DllHandle
[i
],
510 error (_("Can't get module info"));
512 if (!base_address
|| (DWORD
) (mi
.lpBaseOfDll
) == base_address
)
514 /* Try to find the name of the given module */
515 len
= psapi_GetModuleFileNameExA (current_process_handle
,
516 DllHandle
[i
], pathbuf
, MAX_PATH
);
518 error (_("Error getting dll name: %u."), (unsigned) GetLastError ());
520 /* Cygwin prefers that the path be in /x/y/z format */
521 cygwin_conv_to_full_posix_path (pathbuf
, dll_name_ret
);
523 return 1; /* success */
528 dll_name_ret
[0] = '\0';
529 return 0; /* failure */
532 /* Encapsulate the information required in a call to
533 symbol_file_add_args */
534 struct safe_symbol_file_add_args
538 struct section_addr_info
*addrs
;
541 struct ui_file
*err
, *out
;
545 /* Maintain a linked list of "so" information. */
551 static struct so_list solib_start
, *solib_end
;
553 /* Call symbol_file_add with stderr redirected. We don't care if there
556 safe_symbol_file_add_stub (void *argv
)
558 #define p ((struct safe_symbol_file_add_args *) argv)
559 p
->ret
= symbol_file_add (p
->name
, p
->from_tty
, p
->addrs
, p
->mainline
, p
->flags
);
564 /* Restore gdb's stderr after calling symbol_file_add */
566 safe_symbol_file_add_cleanup (void *p
)
568 #define sp ((struct safe_symbol_file_add_args *)p)
569 gdb_flush (gdb_stderr
);
570 gdb_flush (gdb_stdout
);
571 ui_file_delete (gdb_stderr
);
572 ui_file_delete (gdb_stdout
);
573 gdb_stderr
= sp
->err
;
574 gdb_stdout
= sp
->out
;
578 /* symbol_file_add wrapper that prevents errors from being displayed. */
579 static struct objfile
*
580 safe_symbol_file_add (char *name
, int from_tty
,
581 struct section_addr_info
*addrs
,
582 int mainline
, int flags
)
584 struct safe_symbol_file_add_args p
;
585 struct cleanup
*cleanup
;
587 cleanup
= make_cleanup (safe_symbol_file_add_cleanup
, &p
);
591 gdb_flush (gdb_stderr
);
592 gdb_flush (gdb_stdout
);
593 gdb_stderr
= ui_file_new ();
594 gdb_stdout
= ui_file_new ();
596 p
.from_tty
= from_tty
;
598 p
.mainline
= mainline
;
600 catch_errors (safe_symbol_file_add_stub
, &p
, "", RETURN_MASK_ERROR
);
602 do_cleanups (cleanup
);
606 static struct so_list
*
607 win32_make_so (const char *name
, DWORD load_addr
)
610 char buf
[MAX_PATH
+ 1];
611 char cwd
[MAX_PATH
+ 1];
613 WIN32_FIND_DATA w32_fd
;
614 HANDLE h
= FindFirstFile(name
, &w32_fd
);
615 MEMORY_BASIC_INFORMATION m
;
617 if (h
== INVALID_HANDLE_VALUE
)
623 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
625 p
= strrchr (buf
, '\\');
628 SetCurrentDirectory (buf
);
629 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
630 SetCurrentDirectory (cwd
);
634 if (strcasecmp (buf
, "ntdll.dll") == 0)
636 GetSystemDirectory (buf
, sizeof (buf
));
637 strcat (buf
, "\\ntdll.dll");
639 so
= XZALLOC (struct so_list
);
640 so
->lm_info
= (struct lm_info
*) xmalloc (sizeof (struct lm_info
));
641 so
->lm_info
->load_addr
= load_addr
;
642 strcpy (so
->so_original_name
, name
);
644 strcpy (so
->so_name
, buf
);
646 cygwin_conv_to_posix_path (buf
, so
->so_name
);
647 /* Record cygwin1.dll .text start/end. */
648 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
649 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
652 asection
*text
= NULL
;
655 abfd
= bfd_openr (so
->so_name
, "pei-i386");
660 if (bfd_check_format (abfd
, bfd_object
))
661 text
= bfd_get_section_by_name (abfd
, ".text");
669 /* The symbols in a dll are offset by 0x1000, which is the the
670 offset from 0 of the first byte in an image - because of the
671 file header and the section alignment. */
672 cygwin_load_start
= load_addr
+ 0x1000;
673 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (abfd
, text
);
683 get_image_name (HANDLE h
, void *address
, int unicode
)
685 static char buf
[(2 * MAX_PATH
) + 1];
686 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
692 /* Attempt to read the name of the dll that was detected.
693 This is documented to work only when actively debugging
694 a program. It will not work for attached processes. */
698 /* See if we could read the address of a string, and that the
699 address isn't null. */
700 if (!ReadProcessMemory (h
, address
, &address_ptr
, sizeof (address_ptr
), &done
)
701 || done
!= sizeof (address_ptr
) || !address_ptr
)
704 /* Find the length of the string */
705 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
706 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
710 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
713 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
714 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
717 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
723 /* Wait for child to do something. Return pid of child, or -1 in case
724 of error; store status through argument pointer OURSTATUS. */
726 handle_load_dll (void *dummy
)
728 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
729 char dll_buf
[MAX_PATH
+ 1];
730 char *dll_name
= NULL
;
732 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
734 if (!get_module_name ((DWORD
) event
->lpBaseOfDll
, dll_buf
))
735 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
739 if (*dll_name
== '\0')
740 dll_name
= get_image_name (current_process_handle
,
741 event
->lpImageName
, event
->fUnicode
);
745 solib_end
->next
= win32_make_so (dll_name
, (DWORD
) event
->lpBaseOfDll
);
746 solib_end
= solib_end
->next
;
748 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at 0x%lx.\n", solib_end
->so_name
,
749 (DWORD
) solib_end
->lm_info
->load_addr
));
755 win32_free_so (struct so_list
*so
)
763 handle_unload_dll (void *dummy
)
765 DWORD lpBaseOfDll
= (DWORD
) current_event
.u
.UnloadDll
.lpBaseOfDll
;
768 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
769 if (so
->next
->lm_info
->load_addr
== lpBaseOfDll
)
771 struct so_list
*sodel
= so
->next
;
772 so
->next
= sodel
->next
;
775 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
777 win32_free_so (sodel
);
778 solib_add (NULL
, 0, NULL
, auto_solib_add
);
782 error (_("Error: dll starting at 0x%lx not found."), (DWORD
) lpBaseOfDll
);
787 /* Clear list of loaded DLLs. */
789 win32_clear_solib (void)
791 solib_start
.next
= NULL
;
792 solib_end
= &solib_start
;
795 /* Load DLL symbol info. */
797 dll_symbol_command (char *args
, int from_tty
)
803 error (_("dll-symbols requires a file name"));
806 if (n
> 4 && strcasecmp (args
+ n
- 4, ".dll") != 0)
808 char *newargs
= (char *) alloca (n
+ 4 + 1);
809 strcpy (newargs
, args
);
810 strcat (newargs
, ".dll");
814 safe_symbol_file_add (args
, from_tty
, NULL
, 0, OBJF_SHARED
| OBJF_USERLOADED
);
817 /* Handle DEBUG_STRING output from child process.
818 Cygwin prepends its messages with a "cygwin:". Interpret this as
819 a Cygwin signal. Otherwise just print the string as a warning. */
821 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
826 if (!target_read_string
827 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
831 else if (strncmp (s
, _CYGWIN_SIGNAL_STRING
, sizeof (_CYGWIN_SIGNAL_STRING
) - 1) != 0)
834 if (strncmp (s
, "cYg", 3) != 0)
838 #ifdef __COPY_CONTEXT_SIZE
841 /* Got a cygwin signal marker. A cygwin signal is followed by the signal number
842 itself and then optionally followed by the thread id and address to saved context
843 within the DLL. If these are supplied, then the given thread is assumed to have
844 issued the signal and the context from the thread is assumed to be stored at the
845 given address in the inferior. Tell gdb to treat this like a real signal. */
847 int sig
= strtol (s
+ sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
848 int gotasig
= target_signal_from_host (sig
);
849 ourstatus
->value
.sig
= gotasig
;
854 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
855 retval
= strtoul (p
, &p
, 0);
857 retval
= main_thread_id
;
858 else if ((x
= (LPCVOID
) strtoul (p
, &p
, 0))
859 && ReadProcessMemory (current_process_handle
, x
,
860 &saved_context
, __COPY_CONTEXT_SIZE
, &n
)
861 && n
== __COPY_CONTEXT_SIZE
)
862 have_saved_context
= 1;
863 current_event
.dwThreadId
= retval
;
874 display_selector (HANDLE thread
, DWORD sel
)
877 if (GetThreadSelectorEntry (thread
, sel
, &info
))
880 printf_filtered ("0x%03lx: ", sel
);
881 if (!info
.HighWord
.Bits
.Pres
)
883 puts_filtered ("Segment not present\n");
886 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
887 (info
.HighWord
.Bits
.BaseMid
<< 16)
889 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
890 if (info
.HighWord
.Bits
.Granularity
)
891 limit
= (limit
<< 12) | 0xfff;
892 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
893 if (info
.HighWord
.Bits
.Default_Big
)
894 puts_filtered(" 32-bit ");
896 puts_filtered(" 16-bit ");
897 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
900 puts_filtered ("Data (Read-Only, Exp-up");
903 puts_filtered ("Data (Read/Write, Exp-up");
906 puts_filtered ("Unused segment (");
909 puts_filtered ("Data (Read/Write, Exp-down");
912 puts_filtered ("Code (Exec-Only, N.Conf");
915 puts_filtered ("Code (Exec/Read, N.Conf");
918 puts_filtered ("Code (Exec-Only, Conf");
921 puts_filtered ("Code (Exec/Read, Conf");
924 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
926 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
927 puts_filtered(", N.Acc");
928 puts_filtered (")\n");
929 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
930 puts_filtered("System selector ");
931 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
932 if (info
.HighWord
.Bits
.Granularity
)
933 puts_filtered ("Page granular.\n");
935 puts_filtered ("Byte granular.\n");
940 printf_filtered ("Invalid selector 0x%lx.\n",sel
);
946 display_selectors (char * args
, int from_tty
)
950 puts_filtered ("Impossible to display selectors now.\n");
956 puts_filtered ("Selector $cs\n");
957 display_selector (current_thread
->h
,
958 current_thread
->context
.SegCs
);
959 puts_filtered ("Selector $ds\n");
960 display_selector (current_thread
->h
,
961 current_thread
->context
.SegDs
);
962 puts_filtered ("Selector $es\n");
963 display_selector (current_thread
->h
,
964 current_thread
->context
.SegEs
);
965 puts_filtered ("Selector $ss\n");
966 display_selector (current_thread
->h
,
967 current_thread
->context
.SegSs
);
968 puts_filtered ("Selector $fs\n");
969 display_selector (current_thread
->h
,
970 current_thread
->context
.SegFs
);
971 puts_filtered ("Selector $gs\n");
972 display_selector (current_thread
->h
,
973 current_thread
->context
.SegGs
);
978 sel
= parse_and_eval_long (args
);
979 printf_filtered ("Selector \"%s\"\n",args
);
980 display_selector (current_thread
->h
, sel
);
984 static struct cmd_list_element
*info_w32_cmdlist
= NULL
;
987 info_w32_command (char *args
, int from_tty
)
989 help_list (info_w32_cmdlist
, "info w32 ", class_info
, gdb_stdout
);
993 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
994 printf_unfiltered ("gdb: Target exception %s at 0x%08lx\n", x, \
995 (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress)
998 handle_exception (struct target_waitstatus
*ourstatus
)
1001 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1003 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1005 /* Record the context of the current thread */
1006 th
= thread_rec (current_event
.dwThreadId
, -1);
1010 case EXCEPTION_ACCESS_VIOLATION
:
1011 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1012 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1015 /* See if the access violation happened within the cygwin DLL itself. Cygwin uses
1016 a kind of exception handling to deal with passed-in invalid addresses. gdb
1017 should not treat these as real SEGVs since they will be silently handled by
1018 cygwin. A real SEGV will (theoretically) be caught by cygwin later in the process
1019 and will be sent as a cygwin-specific-signal. So, ignore SEGVs if they show up
1020 within the text segment of the DLL itself. */
1022 bfd_vma addr
= (bfd_vma
) (uintptr_t) current_event
.u
.Exception
.
1023 ExceptionRecord
.ExceptionAddress
;
1024 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
&& addr
< cygwin_load_end
))
1025 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1026 && strncmp (fn
, "KERNEL32!IsBad", strlen ("KERNEL32!IsBad")) == 0))
1031 case STATUS_STACK_OVERFLOW
:
1032 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1033 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1035 case STATUS_FLOAT_DENORMAL_OPERAND
:
1036 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1037 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1039 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1040 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1041 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1043 case STATUS_FLOAT_INEXACT_RESULT
:
1044 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1045 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1047 case STATUS_FLOAT_INVALID_OPERATION
:
1048 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1049 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1051 case STATUS_FLOAT_OVERFLOW
:
1052 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1053 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1055 case STATUS_FLOAT_STACK_CHECK
:
1056 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1057 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1059 case STATUS_FLOAT_UNDERFLOW
:
1060 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1061 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1063 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1064 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1065 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1067 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1068 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1069 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1071 case STATUS_INTEGER_OVERFLOW
:
1072 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1073 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1075 case EXCEPTION_BREAKPOINT
:
1076 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1077 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1080 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1081 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1083 case DBG_CONTROL_BREAK
:
1084 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1085 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1087 case EXCEPTION_SINGLE_STEP
:
1088 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1089 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1091 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1092 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1093 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1095 case EXCEPTION_PRIV_INSTRUCTION
:
1096 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1097 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1099 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1100 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1101 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1104 /* Treat unhandled first chance exceptions specially. */
1105 if (current_event
.u
.Exception
.dwFirstChance
)
1107 printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",
1108 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1109 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1110 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1114 last_sig
= ourstatus
->value
.sig
;
1118 /* Resume all artificially suspended threads if we are continuing
1121 win32_continue (DWORD continue_status
, int id
)
1127 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, %s);\n",
1128 current_event
.dwProcessId
, current_event
.dwThreadId
,
1129 continue_status
== DBG_CONTINUE
?
1130 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1132 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1133 if ((id
== -1 || id
== (int) th
->id
)
1136 if (debug_registers_changed
)
1138 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1139 th
->context
.Dr0
= dr
[0];
1140 th
->context
.Dr1
= dr
[1];
1141 th
->context
.Dr2
= dr
[2];
1142 th
->context
.Dr3
= dr
[3];
1143 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1144 th
->context
.Dr7
= dr
[7];
1146 if (th
->context
.ContextFlags
)
1148 CHECK (SetThreadContext (th
->h
, &th
->context
));
1149 th
->context
.ContextFlags
= 0;
1151 if (th
->suspended
> 0)
1152 (void) ResumeThread (th
->h
);
1156 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1157 current_event
.dwThreadId
,
1160 debug_registers_changed
= 0;
1164 /* Called in pathological case where Windows fails to send a
1165 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1167 fake_create_process (void)
1169 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1170 current_event
.dwProcessId
);
1171 if (current_process_handle
!= NULL
)
1172 open_process_used
= 1;
1175 error (_("OpenProcess call failed, GetLastError = %lud\n"),
1177 /* We can not debug anything in that case. */
1179 main_thread_id
= current_event
.dwThreadId
;
1180 current_thread
= win32_add_thread (main_thread_id
,
1181 current_event
.u
.CreateThread
.hThread
);
1182 return main_thread_id
;
1186 win32_resume (ptid_t ptid
, int step
, enum target_signal sig
)
1189 DWORD continue_status
= DBG_CONTINUE
;
1191 int pid
= PIDGET (ptid
);
1193 if (sig
!= TARGET_SIGNAL_0
)
1195 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1197 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1199 else if (sig
== last_sig
)
1200 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1203 /* This code does not seem to work, because
1204 the kernel does probably not consider changes in the ExceptionRecord
1205 structure when passing the exception to the inferior.
1206 Note that this seems possible in the exception handler itself. */
1209 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1210 if (xlate
[i
].us
== sig
)
1212 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
=
1214 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1217 if (continue_status
== DBG_CONTINUE
)
1219 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1223 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1227 last_sig
= TARGET_SIGNAL_0
;
1229 DEBUG_EXEC (("gdb: win32_resume (pid=%d, step=%d, sig=%d);\n",
1232 /* Get context for currently selected thread */
1233 th
= thread_rec (PIDGET (inferior_ptid
), FALSE
);
1238 /* Single step by setting t bit */
1239 win32_fetch_inferior_registers (get_current_regcache (),
1240 gdbarch_ps_regnum (current_gdbarch
));
1241 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1244 if (th
->context
.ContextFlags
)
1246 if (debug_registers_changed
)
1248 th
->context
.Dr0
= dr
[0];
1249 th
->context
.Dr1
= dr
[1];
1250 th
->context
.Dr2
= dr
[2];
1251 th
->context
.Dr3
= dr
[3];
1252 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1253 th
->context
.Dr7
= dr
[7];
1255 CHECK (SetThreadContext (th
->h
, &th
->context
));
1256 th
->context
.ContextFlags
= 0;
1260 /* Allow continuing with the same signal that interrupted us.
1261 Otherwise complain. */
1263 win32_continue (continue_status
, pid
);
1266 /* Get the next event from the child. Return 1 if the event requires
1267 handling by WFI (or whatever).
1270 get_win32_debug_event (int pid
, struct target_waitstatus
*ourstatus
)
1273 DWORD continue_status
, event_code
;
1275 static thread_info dummy_thread_info
;
1279 last_sig
= TARGET_SIGNAL_0
;
1281 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1285 continue_status
= DBG_CONTINUE
;
1287 event_code
= current_event
.dwDebugEventCode
;
1288 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1290 have_saved_context
= 0;
1294 case CREATE_THREAD_DEBUG_EVENT
:
1295 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1296 (unsigned) current_event
.dwProcessId
,
1297 (unsigned) current_event
.dwThreadId
,
1298 "CREATE_THREAD_DEBUG_EVENT"));
1299 if (saw_create
!= 1)
1301 if (!saw_create
&& attach_flag
)
1303 /* Kludge around a Windows bug where first event is a create
1304 thread event. Caused when attached process does not have
1306 retval
= ourstatus
->value
.related_pid
= fake_create_process ();
1312 /* Record the existence of this thread */
1313 th
= win32_add_thread (current_event
.dwThreadId
,
1314 current_event
.u
.CreateThread
.hThread
);
1315 retval
= current_event
.dwThreadId
;
1318 case EXIT_THREAD_DEBUG_EVENT
:
1319 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1320 (unsigned) current_event
.dwProcessId
,
1321 (unsigned) current_event
.dwThreadId
,
1322 "EXIT_THREAD_DEBUG_EVENT"));
1323 if (current_event
.dwThreadId
!= main_thread_id
)
1325 win32_delete_thread (current_event
.dwThreadId
);
1326 th
= &dummy_thread_info
;
1330 case CREATE_PROCESS_DEBUG_EVENT
:
1331 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1332 (unsigned) current_event
.dwProcessId
,
1333 (unsigned) current_event
.dwThreadId
,
1334 "CREATE_PROCESS_DEBUG_EVENT"));
1335 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1336 if (++saw_create
!= 1)
1339 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1341 win32_delete_thread (main_thread_id
);
1342 main_thread_id
= current_event
.dwThreadId
;
1343 /* Add the main thread */
1344 th
= win32_add_thread (main_thread_id
,
1345 current_event
.u
.CreateProcessInfo
.hThread
);
1346 retval
= ourstatus
->value
.related_pid
= current_event
.dwThreadId
;
1349 case EXIT_PROCESS_DEBUG_EVENT
:
1350 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1351 (unsigned) current_event
.dwProcessId
,
1352 (unsigned) current_event
.dwThreadId
,
1353 "EXIT_PROCESS_DEBUG_EVENT"));
1354 if (saw_create
!= 1)
1356 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1357 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1358 retval
= main_thread_id
;
1361 case LOAD_DLL_DEBUG_EVENT
:
1362 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1363 (unsigned) current_event
.dwProcessId
,
1364 (unsigned) current_event
.dwThreadId
,
1365 "LOAD_DLL_DEBUG_EVENT"));
1366 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1367 if (saw_create
!= 1)
1369 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1370 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1371 ourstatus
->value
.integer
= 0;
1372 retval
= main_thread_id
;
1375 case UNLOAD_DLL_DEBUG_EVENT
:
1376 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1377 (unsigned) current_event
.dwProcessId
,
1378 (unsigned) current_event
.dwThreadId
,
1379 "UNLOAD_DLL_DEBUG_EVENT"));
1380 if (saw_create
!= 1)
1382 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1383 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1384 ourstatus
->value
.integer
= 0;
1385 retval
= main_thread_id
;
1388 case EXCEPTION_DEBUG_EVENT
:
1389 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1390 (unsigned) current_event
.dwProcessId
,
1391 (unsigned) current_event
.dwThreadId
,
1392 "EXCEPTION_DEBUG_EVENT"));
1393 if (saw_create
!= 1)
1395 switch (handle_exception (ourstatus
))
1398 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1401 retval
= current_event
.dwThreadId
;
1405 continue_status
= -1;
1410 case OUTPUT_DEBUG_STRING_EVENT
: /* message from the kernel */
1411 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1412 (unsigned) current_event
.dwProcessId
,
1413 (unsigned) current_event
.dwThreadId
,
1414 "OUTPUT_DEBUG_STRING_EVENT"));
1415 if (saw_create
!= 1)
1417 retval
= handle_output_debug_string (ourstatus
);
1421 if (saw_create
!= 1)
1423 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1424 (DWORD
) current_event
.dwProcessId
,
1425 (DWORD
) current_event
.dwThreadId
);
1426 printf_unfiltered (" unknown event code %ld\n",
1427 current_event
.dwDebugEventCode
);
1431 if (!retval
|| saw_create
!= 1)
1433 if (continue_status
== -1)
1434 win32_resume (ptid
, 0, 1);
1436 CHECK (win32_continue (continue_status
, -1));
1440 inferior_ptid
= pid_to_ptid (retval
);
1441 current_thread
= th
?: thread_rec (current_event
.dwThreadId
, TRUE
);
1448 /* Wait for interesting events to occur in the target process. */
1450 win32_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
1452 int pid
= PIDGET (ptid
);
1454 target_terminal_ours ();
1456 /* We loop when we get a non-standard exception rather than return
1457 with a SPURIOUS because resume can try and step or modify things,
1458 which needs a current_thread->h. But some of these exceptions mark
1459 the birth or death of threads, which mean that the current thread
1460 isn't necessarily what you think it is. */
1466 /* Ignore CTRL+C signals while waiting for a debug event.
1467 FIXME: brobecker/2008-05-20: When the user presses CTRL+C while
1468 the inferior is running, both the inferior and GDB receive the
1469 associated signal. If the inferior receives the signal first
1470 and the delay until GDB receives that signal is sufficiently long,
1471 GDB can sometimes receive the SIGINT after we have unblocked
1472 the CTRL+C handler. This would lead to the debugger to stop
1473 prematurely while handling the new-thread event that comes
1474 with the handling of the SIGINT inside the inferior, and then
1475 stop again immediately when the user tries to resume the execution
1476 in the inferior. This is a classic race, and it would be nice
1477 to find a better solution to that problem. But in the meantime,
1478 the current approach already greatly mitigate this issue. */
1479 SetConsoleCtrlHandler (NULL
, TRUE
);
1480 retval
= get_win32_debug_event (pid
, ourstatus
);
1481 SetConsoleCtrlHandler (NULL
, FALSE
);
1484 return pid_to_ptid (retval
);
1489 if (deprecated_ui_loop_hook
!= NULL
)
1490 detach
= deprecated_ui_loop_hook (0);
1493 win32_kill_inferior ();
1499 do_initial_win32_stuff (DWORD pid
)
1501 extern int stop_after_trap
;
1504 last_sig
= TARGET_SIGNAL_0
;
1506 exception_count
= 0;
1507 open_process_used
= 0;
1508 debug_registers_changed
= 0;
1509 debug_registers_used
= 0;
1510 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1513 cygwin_load_start
= cygwin_load_end
= 0;
1515 current_event
.dwProcessId
= pid
;
1516 memset (¤t_event
, 0, sizeof (current_event
));
1517 push_target (&win32_ops
);
1518 disable_breakpoints_in_shlibs ();
1519 win32_clear_solib ();
1520 clear_proceed_status ();
1521 init_wait_for_inferior ();
1523 terminal_init_inferior_with_pgrp (pid
);
1524 target_terminal_inferior ();
1526 stop_soon
= STOP_QUIETLY
;
1529 stop_after_trap
= 1;
1530 wait_for_inferior (0);
1531 if (stop_signal
!= TARGET_SIGNAL_TRAP
)
1532 resume (0, stop_signal
);
1537 stop_soon
= NO_STOP_QUIETLY
;
1538 stop_after_trap
= 0;
1542 /* Since Windows XP, detaching from a process is supported by Windows.
1543 The following code tries loading the appropriate functions dynamically.
1544 If loading these functions succeeds use them to actually detach from
1545 the inferior process, otherwise behave as usual, pretending that
1546 detach has worked. */
1547 static BOOL
WINAPI (*DebugSetProcessKillOnExit
)(BOOL
);
1548 static BOOL
WINAPI (*DebugActiveProcessStop
)(DWORD
);
1551 has_detach_ability (void)
1553 static HMODULE kernel32
= NULL
;
1556 kernel32
= LoadLibrary ("kernel32.dll");
1559 if (!DebugSetProcessKillOnExit
)
1560 DebugSetProcessKillOnExit
= GetProcAddress (kernel32
,
1561 "DebugSetProcessKillOnExit");
1562 if (!DebugActiveProcessStop
)
1563 DebugActiveProcessStop
= GetProcAddress (kernel32
,
1564 "DebugActiveProcessStop");
1565 if (DebugSetProcessKillOnExit
&& DebugActiveProcessStop
)
1571 /* Try to set or remove a user privilege to the current process. Return -1
1572 if that fails, the previous setting of that privilege otherwise.
1574 This code is copied from the Cygwin source code and rearranged to allow
1575 dynamically loading of the needed symbols from advapi32 which is only
1576 available on NT/2K/XP. */
1578 set_process_privilege (const char *privilege
, BOOL enable
)
1580 static HMODULE advapi32
= NULL
;
1581 static BOOL
WINAPI (*OpenProcessToken
)(HANDLE
, DWORD
, PHANDLE
);
1582 static BOOL
WINAPI (*LookupPrivilegeValue
)(LPCSTR
, LPCSTR
, PLUID
);
1583 static BOOL
WINAPI (*AdjustTokenPrivileges
)(HANDLE
, BOOL
, PTOKEN_PRIVILEGES
,
1584 DWORD
, PTOKEN_PRIVILEGES
, PDWORD
);
1586 HANDLE token_hdl
= NULL
;
1588 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1592 if (GetVersion () >= 0x80000000) /* No security availbale on 9x/Me */
1597 if (!(advapi32
= LoadLibrary ("advapi32.dll")))
1599 if (!OpenProcessToken
)
1600 OpenProcessToken
= GetProcAddress (advapi32
, "OpenProcessToken");
1601 if (!LookupPrivilegeValue
)
1602 LookupPrivilegeValue
= GetProcAddress (advapi32
,
1603 "LookupPrivilegeValueA");
1604 if (!AdjustTokenPrivileges
)
1605 AdjustTokenPrivileges
= GetProcAddress (advapi32
,
1606 "AdjustTokenPrivileges");
1607 if (!OpenProcessToken
|| !LookupPrivilegeValue
|| !AdjustTokenPrivileges
)
1614 if (!OpenProcessToken (GetCurrentProcess (),
1615 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1619 if (!LookupPrivilegeValue (NULL
, privilege
, &restore_priv
))
1622 new_priv
.PrivilegeCount
= 1;
1623 new_priv
.Privileges
[0].Luid
= restore_priv
;
1624 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1626 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1627 sizeof orig_priv
, &orig_priv
, &size
))
1630 /* Disabled, otherwise every `attach' in an unprivileged user session
1631 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1633 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1634 be enabled. GetLastError () returns an correct error code, though. */
1635 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1639 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1643 CloseHandle (token_hdl
);
1648 /* Attach to process PID, then initialize for debugging it. */
1650 win32_attach (char *args
, int from_tty
)
1656 error_no_arg (_("process-id to attach"));
1658 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1660 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1661 printf_unfiltered ("This can cause attach to fail on Windows NT/2K/XP\n");
1664 pid
= strtoul (args
, 0, 0); /* Windows pid */
1666 win32_init_thread_list ();
1667 ok
= DebugActiveProcess (pid
);
1673 /* Try fall back to Cygwin pid */
1674 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1677 ok
= DebugActiveProcess (pid
);
1682 error (_("Can't attach to process."));
1684 if (has_detach_ability ())
1685 DebugSetProcessKillOnExit (FALSE
);
1691 char *exec_file
= (char *) get_exec_file (0);
1694 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1695 target_pid_to_str (pid_to_ptid (pid
)));
1697 printf_unfiltered ("Attaching to %s\n",
1698 target_pid_to_str (pid_to_ptid (pid
)));
1700 gdb_flush (gdb_stdout
);
1703 do_initial_win32_stuff (pid
);
1704 target_terminal_ours ();
1708 win32_detach (char *args
, int from_tty
)
1712 if (has_detach_ability ())
1715 win32_resume (ptid
, 0, TARGET_SIGNAL_0
);
1717 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1719 error (_("Can't detach process %lu (error %lu)"),
1720 current_event
.dwProcessId
, GetLastError ());
1723 DebugSetProcessKillOnExit (FALSE
);
1725 if (detached
&& from_tty
)
1727 char *exec_file
= get_exec_file (0);
1730 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file
,
1731 current_event
.dwProcessId
);
1732 gdb_flush (gdb_stdout
);
1734 inferior_ptid
= null_ptid
;
1735 unpush_target (&win32_ops
);
1739 win32_pid_to_exec_file (int pid
)
1741 static char path
[MAX_PATH
+ 1];
1744 /* Try to find exe name as symlink target of /proc/<pid>/exe */
1746 char procexe
[sizeof ("/proc/4294967295/exe")];
1747 sprintf (procexe
, "/proc/%lu/exe", current_event
.dwProcessId
);
1748 nchars
= readlink (procexe
, path
, sizeof(path
));
1749 if (nchars
> 0 && nchars
< sizeof (path
))
1751 path
[nchars
] = '\0'; /* Got it */
1756 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
1757 of gdb, or we're trying to debug a non-Cygwin windows executable. */
1758 if (!get_module_name (0, path
))
1764 /* Print status information about what we're accessing. */
1767 win32_files_info (struct target_ops
*ignore
)
1769 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1770 attach_flag
? "attached" : "child", target_pid_to_str (inferior_ptid
));
1774 win32_open (char *arg
, int from_tty
)
1776 error (_("Use the \"run\" command to start a Unix child process."));
1779 /* Start an inferior win32 child process and sets inferior_ptid to its pid.
1780 EXEC_FILE is the file to run.
1781 ALLARGS is a string containing the arguments to the program.
1782 ENV is the environment vector to pass. Errors reported with error(). */
1785 win32_create_inferior (char *exec_file
, char *allargs
, char **in_env
,
1789 PROCESS_INFORMATION pi
;
1793 char real_path
[MAXPATHLEN
];
1795 char shell
[MAX_PATH
+ 1]; /* Path to shell */
1798 int ostdin
, ostdout
, ostderr
;
1799 const char *inferior_io_terminal
= get_inferior_io_terminal ();
1802 error (_("No executable specified, use `target exec'."));
1804 memset (&si
, 0, sizeof (si
));
1805 si
.cb
= sizeof (si
);
1810 flags
= DEBUG_ONLY_THIS_PROCESS
;
1811 cygwin_conv_to_win32_path (exec_file
, real_path
);
1817 sh
= getenv ("SHELL");
1820 cygwin_conv_to_win32_path (sh
, shell
);
1821 newallargs
= alloca (sizeof (" -c 'exec '") + strlen (exec_file
)
1822 + strlen (allargs
) + 2);
1823 sprintf (newallargs
, " -c 'exec %s %s'", exec_file
, allargs
);
1824 allargs
= newallargs
;
1826 flags
= DEBUG_PROCESS
;
1830 flags
= DEBUG_ONLY_THIS_PROCESS
;
1834 flags
|= CREATE_NEW_PROCESS_GROUP
;
1837 flags
|= CREATE_NEW_CONSOLE
;
1841 args
= alloca (strlen (toexec
) + strlen (allargs
) + 2);
1842 strcpy (args
, toexec
);
1844 strcat (args
, allargs
);
1847 /* Prepare the environment vars for CreateProcess. */
1848 cygwin_internal (CW_SYNC_WINENV
);
1850 if (!inferior_io_terminal
)
1851 tty
= ostdin
= ostdout
= ostderr
= -1;
1854 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
1857 print_sys_errmsg (inferior_io_terminal
, errno
);
1858 ostdin
= ostdout
= ostderr
= -1;
1872 win32_init_thread_list ();
1873 ret
= CreateProcess (0,
1874 args
, /* command line */
1875 NULL
, /* Security */
1877 TRUE
, /* inherit handles */
1878 flags
, /* start flags */
1879 NULL
, /* environment */
1880 NULL
, /* current directory */
1898 error (_("Error creating process %s, (error %d)."),
1899 exec_file
, (unsigned) GetLastError ());
1901 CloseHandle (pi
.hThread
);
1902 CloseHandle (pi
.hProcess
);
1904 if (useshell
&& shell
[0] != '\0')
1909 do_initial_win32_stuff (pi
.dwProcessId
);
1911 /* win32_continue (DBG_CONTINUE, -1); */
1915 win32_mourn_inferior (void)
1917 (void) win32_continue (DBG_CONTINUE
, -1);
1918 i386_cleanup_dregs();
1919 if (open_process_used
)
1921 CHECK (CloseHandle (current_process_handle
));
1922 open_process_used
= 0;
1924 unpush_target (&win32_ops
);
1925 generic_mourn_inferior ();
1928 /* Send a SIGINT to the process group. This acts just like the user typed a
1929 ^C on the controlling terminal. */
1934 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1935 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
1936 registers_changed (); /* refresh register state */
1940 win32_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*our
, int len
,
1941 int write
, struct mem_attrib
*mem
,
1942 struct target_ops
*target
)
1947 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1948 len
, (DWORD
) (uintptr_t) memaddr
));
1949 if (!WriteProcessMemory (current_process_handle
,
1950 (LPVOID
) (uintptr_t) memaddr
, our
,
1953 FlushInstructionCache (current_process_handle
,
1954 (LPCVOID
) (uintptr_t) memaddr
, len
);
1958 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
1959 len
, (DWORD
) (uintptr_t) memaddr
));
1960 if (!ReadProcessMemory (current_process_handle
,
1961 (LPCVOID
) (uintptr_t) memaddr
, our
,
1969 win32_kill_inferior (void)
1971 CHECK (TerminateProcess (current_process_handle
, 0));
1975 if (!win32_continue (DBG_CONTINUE
, -1))
1977 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
1979 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
1983 target_mourn_inferior (); /* or just win32_mourn_inferior? */
1987 win32_prepare_to_store (struct regcache
*regcache
)
1989 /* Do nothing, since we can store individual regs */
1993 win32_can_run (void)
2001 DEBUG_EVENTS (("gdb: win32_close, inferior_ptid=%d\n",
2002 PIDGET (inferior_ptid
)));
2005 /* Convert pid to printable format. */
2007 win32_pid_to_str (ptid_t ptid
)
2009 static char buf
[80];
2010 int pid
= PIDGET (ptid
);
2012 if ((DWORD
) pid
== current_event
.dwProcessId
)
2013 sprintf (buf
, "process %d", pid
);
2015 sprintf (buf
, "Thread %ld.0x%x", current_event
.dwProcessId
, pid
);
2020 win32_xfer_shared_libraries (struct target_ops
*ops
,
2021 enum target_object object
, const char *annex
,
2022 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2023 ULONGEST offset
, LONGEST len
)
2025 struct obstack obstack
;
2033 obstack_init (&obstack
);
2034 obstack_grow_str (&obstack
, "<library-list>\n");
2035 for (so
= solib_start
.next
; so
; so
= so
->next
)
2036 win32_xfer_shared_library (so
->so_name
, so
->lm_info
->load_addr
, &obstack
);
2037 obstack_grow_str0 (&obstack
, "</library-list>\n");
2039 buf
= obstack_finish (&obstack
);
2040 len_avail
= strlen (buf
);
2041 if (offset
>= len_avail
)
2044 if (len
> len_avail
- offset
)
2045 len
= len_avail
- offset
;
2046 memcpy (readbuf
, buf
+ offset
, len
);
2048 obstack_free (&obstack
, NULL
);
2053 win32_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2054 const char *annex
, gdb_byte
*readbuf
,
2055 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
2059 case TARGET_OBJECT_MEMORY
:
2061 return (*ops
->deprecated_xfer_memory
) (offset
, readbuf
,
2062 len
, 0/*read*/, NULL
, ops
);
2064 return (*ops
->deprecated_xfer_memory
) (offset
, (gdb_byte
*) writebuf
,
2065 len
, 1/*write*/, NULL
, ops
);
2068 case TARGET_OBJECT_LIBRARIES
:
2069 return win32_xfer_shared_libraries (ops
, object
, annex
, readbuf
,
2070 writebuf
, offset
, len
);
2073 if (ops
->beneath
!= NULL
)
2074 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2075 readbuf
, writebuf
, offset
, len
);
2081 init_win32_ops (void)
2083 win32_ops
.to_shortname
= "child";
2084 win32_ops
.to_longname
= "Win32 child process";
2085 win32_ops
.to_doc
= "Win32 child process (started by the \"run\" command).";
2086 win32_ops
.to_open
= win32_open
;
2087 win32_ops
.to_close
= win32_close
;
2088 win32_ops
.to_attach
= win32_attach
;
2089 win32_ops
.to_detach
= win32_detach
;
2090 win32_ops
.to_resume
= win32_resume
;
2091 win32_ops
.to_wait
= win32_wait
;
2092 win32_ops
.to_fetch_registers
= win32_fetch_inferior_registers
;
2093 win32_ops
.to_store_registers
= win32_store_inferior_registers
;
2094 win32_ops
.to_prepare_to_store
= win32_prepare_to_store
;
2095 win32_ops
.deprecated_xfer_memory
= win32_xfer_memory
;
2096 win32_ops
.to_xfer_partial
= win32_xfer_partial
;
2097 win32_ops
.to_files_info
= win32_files_info
;
2098 win32_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
2099 win32_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
2100 win32_ops
.to_terminal_init
= terminal_init_inferior
;
2101 win32_ops
.to_terminal_inferior
= terminal_inferior
;
2102 win32_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
2103 win32_ops
.to_terminal_ours
= terminal_ours
;
2104 win32_ops
.to_terminal_save_ours
= terminal_save_ours
;
2105 win32_ops
.to_terminal_info
= child_terminal_info
;
2106 win32_ops
.to_kill
= win32_kill_inferior
;
2107 win32_ops
.to_create_inferior
= win32_create_inferior
;
2108 win32_ops
.to_mourn_inferior
= win32_mourn_inferior
;
2109 win32_ops
.to_can_run
= win32_can_run
;
2110 win32_ops
.to_thread_alive
= win32_win32_thread_alive
;
2111 win32_ops
.to_pid_to_str
= win32_pid_to_str
;
2112 win32_ops
.to_stop
= win32_stop
;
2113 win32_ops
.to_stratum
= process_stratum
;
2114 win32_ops
.to_has_all_memory
= 1;
2115 win32_ops
.to_has_memory
= 1;
2116 win32_ops
.to_has_stack
= 1;
2117 win32_ops
.to_has_registers
= 1;
2118 win32_ops
.to_has_execution
= 1;
2119 win32_ops
.to_magic
= OPS_MAGIC
;
2120 win32_ops
.to_pid_to_exec_file
= win32_pid_to_exec_file
;
2124 set_win32_aliases (char *argv0
)
2126 add_info_alias ("dll", "sharedlibrary", 1);
2130 _initialize_win32_nat (void)
2132 struct cmd_list_element
*c
;
2136 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
2137 _("Load dll library symbols from FILE."));
2138 set_cmd_completer (c
, filename_completer
);
2140 add_com_alias ("sharedlibrary", "dll-symbols", class_alias
, 1);
2143 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
2144 Set use of shell to start subprocess."), _("\
2145 Show use of shell to start subprocess."), NULL
,
2147 NULL
, /* FIXME: i18n: */
2148 &setlist
, &showlist
);
2150 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
, &cygwin_exceptions
, _("\
2151 Break when an exception is detected in the Cygwin DLL itself."), _("\
2152 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
2154 NULL
, /* FIXME: i18n: */
2155 &setlist
, &showlist
);
2158 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
2159 Set creation of new console when creating child process."), _("\
2160 Show creation of new console when creating child process."), NULL
,
2162 NULL
, /* FIXME: i18n: */
2163 &setlist
, &showlist
);
2165 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
2166 Set creation of new group when creating child process."), _("\
2167 Show creation of new group when creating child process."), NULL
,
2169 NULL
, /* FIXME: i18n: */
2170 &setlist
, &showlist
);
2172 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
2173 Set whether to display execution in child process."), _("\
2174 Show whether to display execution in child process."), NULL
,
2176 NULL
, /* FIXME: i18n: */
2177 &setlist
, &showlist
);
2179 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
2180 Set whether to display kernel events in child process."), _("\
2181 Show whether to display kernel events in child process."), NULL
,
2183 NULL
, /* FIXME: i18n: */
2184 &setlist
, &showlist
);
2186 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
2187 Set whether to display memory accesses in child process."), _("\
2188 Show whether to display memory accesses in child process."), NULL
,
2190 NULL
, /* FIXME: i18n: */
2191 &setlist
, &showlist
);
2193 add_setshow_boolean_cmd ("debugexceptions", class_support
,
2194 &debug_exceptions
, _("\
2195 Set whether to display kernel exceptions in child process."), _("\
2196 Show whether to display kernel exceptions in child process."), NULL
,
2198 NULL
, /* FIXME: i18n: */
2199 &setlist
, &showlist
);
2201 add_prefix_cmd ("w32", class_info
, info_w32_command
,
2202 _("Print information specific to Win32 debugging."),
2203 &info_w32_cmdlist
, "info w32 ", 0, &infolist
);
2205 add_cmd ("selector", class_info
, display_selectors
,
2206 _("Display selectors infos."),
2208 add_target (&win32_ops
);
2209 deprecated_init_ui_hook
= set_win32_aliases
;
2212 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2214 /* Pass the address ADDR to the inferior in the I'th debug register.
2215 Here we just store the address in dr array, the registers will be
2216 actually set up when win32_continue is called. */
2218 cygwin_set_dr (int i
, CORE_ADDR addr
)
2221 internal_error (__FILE__
, __LINE__
,
2222 _("Invalid register %d in cygwin_set_dr.\n"), i
);
2223 dr
[i
] = (unsigned) addr
;
2224 debug_registers_changed
= 1;
2225 debug_registers_used
= 1;
2228 /* Pass the value VAL to the inferior in the DR7 debug control
2229 register. Here we just store the address in D_REGS, the watchpoint
2230 will be actually set up in win32_wait. */
2232 cygwin_set_dr7 (unsigned val
)
2235 debug_registers_changed
= 1;
2236 debug_registers_used
= 1;
2239 /* Get the value of the DR6 debug status register from the inferior.
2240 Here we just return the value stored in dr[6]
2241 by the last call to thread_rec for current_event.dwThreadId id. */
2243 cygwin_get_dr6 (void)
2248 /* Determine if the thread referenced by "pid" is alive
2249 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2250 it means that the pid has died. Otherwise it is assumed to be alive. */
2252 win32_win32_thread_alive (ptid_t ptid
)
2254 int pid
= PIDGET (ptid
);
2256 return WaitForSingleObject (thread_rec (pid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
?
2261 _initialize_check_for_gdb_ini (void)
2264 if (inhibit_gdbinit
)
2267 homedir
= getenv ("HOME");
2271 char *oldini
= (char *) alloca (strlen (homedir
) +
2272 sizeof ("/gdb.ini"));
2273 strcpy (oldini
, homedir
);
2274 p
= strchr (oldini
, '\0');
2275 if (p
> oldini
&& p
[-1] != '/')
2277 strcpy (p
, "gdb.ini");
2278 if (access (oldini
, 0) == 0)
2280 int len
= strlen (oldini
);
2281 char *newini
= alloca (len
+ 1);
2282 sprintf (newini
, "%.*s.gdbinit",
2283 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
2284 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
2290 _initialize_psapi (void)
2292 /* Load optional functions used for retrieving filename information
2293 associated with the currently debugged process or its dlls. */
2296 HMODULE psapi_module_handle
;
2300 psapi_module_handle
= LoadLibrary ("psapi.dll");
2301 if (psapi_module_handle
)
2303 psapi_EnumProcessModules
= (void *) GetProcAddress (psapi_module_handle
, "EnumProcessModules");
2304 psapi_GetModuleInformation
= (void *) GetProcAddress (psapi_module_handle
, "GetModuleInformation");
2305 psapi_GetModuleFileNameExA
= (void *) GetProcAddress (psapi_module_handle
, "GetModuleFileNameExA");
2307 if (psapi_EnumProcessModules
!= NULL
2308 && psapi_GetModuleInformation
!= NULL
2309 && psapi_GetModuleFileNameExA
!= NULL
)
2314 /* This will probably fail on Windows 9x/Me. Let the user know that we're
2315 missing some functionality. */
2316 if (psapi_loaded
< 0)
2317 warning(_("cannot automatically find executable file or library to read symbols. Use \"file\" or \"dll\" command to load executable/libraries directly."));