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 struct so_list
*so
= &solib_start
;
561 p
->ret
= symbol_file_add (p
->name
, p
->from_tty
, p
->addrs
, p
->mainline
, p
->flags
);
566 /* Restore gdb's stderr after calling symbol_file_add */
568 safe_symbol_file_add_cleanup (void *p
)
570 #define sp ((struct safe_symbol_file_add_args *)p)
571 gdb_flush (gdb_stderr
);
572 gdb_flush (gdb_stdout
);
573 ui_file_delete (gdb_stderr
);
574 ui_file_delete (gdb_stdout
);
575 gdb_stderr
= sp
->err
;
576 gdb_stdout
= sp
->out
;
580 /* symbol_file_add wrapper that prevents errors from being displayed. */
581 static struct objfile
*
582 safe_symbol_file_add (char *name
, int from_tty
,
583 struct section_addr_info
*addrs
,
584 int mainline
, int flags
)
586 struct safe_symbol_file_add_args p
;
587 struct cleanup
*cleanup
;
589 cleanup
= make_cleanup (safe_symbol_file_add_cleanup
, &p
);
593 gdb_flush (gdb_stderr
);
594 gdb_flush (gdb_stdout
);
595 gdb_stderr
= ui_file_new ();
596 gdb_stdout
= ui_file_new ();
598 p
.from_tty
= from_tty
;
600 p
.mainline
= mainline
;
602 catch_errors (safe_symbol_file_add_stub
, &p
, "", RETURN_MASK_ERROR
);
604 do_cleanups (cleanup
);
608 static struct so_list
*
609 win32_make_so (const char *name
, DWORD load_addr
)
612 char buf
[MAX_PATH
+ 1];
613 char cwd
[MAX_PATH
+ 1];
615 WIN32_FIND_DATA w32_fd
;
616 HANDLE h
= FindFirstFile(name
, &w32_fd
);
617 MEMORY_BASIC_INFORMATION m
;
619 if (h
== INVALID_HANDLE_VALUE
)
625 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
627 p
= strrchr (buf
, '\\');
630 SetCurrentDirectory (buf
);
631 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
632 SetCurrentDirectory (cwd
);
636 if (strcasecmp (buf
, "ntdll.dll") == 0)
638 GetSystemDirectory (buf
, sizeof (buf
));
639 strcat (buf
, "\\ntdll.dll");
641 so
= XZALLOC (struct so_list
);
642 so
->lm_info
= (struct lm_info
*) xmalloc (sizeof (struct lm_info
));
643 so
->lm_info
->load_addr
= load_addr
;
644 strcpy (so
->so_original_name
, name
);
646 strcpy (so
->so_name
, buf
);
648 cygwin_conv_to_posix_path (buf
, so
->so_name
);
649 /* Record cygwin1.dll .text start/end. */
650 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
651 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
654 asection
*text
= NULL
;
657 abfd
= bfd_openr (so
->so_name
, "pei-i386");
662 if (bfd_check_format (abfd
, bfd_object
))
663 text
= bfd_get_section_by_name (abfd
, ".text");
671 /* The symbols in a dll are offset by 0x1000, which is the the
672 offset from 0 of the first byte in an image - because of the
673 file header and the section alignment. */
674 cygwin_load_start
= load_addr
+ 0x1000;
675 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (abfd
, text
);
685 get_image_name (HANDLE h
, void *address
, int unicode
)
687 static char buf
[(2 * MAX_PATH
) + 1];
688 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
694 /* Attempt to read the name of the dll that was detected.
695 This is documented to work only when actively debugging
696 a program. It will not work for attached processes. */
700 /* See if we could read the address of a string, and that the
701 address isn't null. */
702 if (!ReadProcessMemory (h
, address
, &address_ptr
, sizeof (address_ptr
), &done
)
703 || done
!= sizeof (address_ptr
) || !address_ptr
)
706 /* Find the length of the string */
707 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
708 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
712 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
715 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
716 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
719 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
725 /* Wait for child to do something. Return pid of child, or -1 in case
726 of error; store status through argument pointer OURSTATUS. */
728 handle_load_dll (void *dummy
)
730 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
731 char dll_buf
[MAX_PATH
+ 1];
732 char *dll_name
= NULL
;
734 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
736 if (!get_module_name ((DWORD
) event
->lpBaseOfDll
, dll_buf
))
737 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
741 if (*dll_name
== '\0')
742 dll_name
= get_image_name (current_process_handle
,
743 event
->lpImageName
, event
->fUnicode
);
747 solib_end
->next
= win32_make_so (dll_name
, (DWORD
) event
->lpBaseOfDll
);
748 solib_end
= solib_end
->next
;
754 win32_free_so (struct so_list
*so
)
762 handle_unload_dll (void *dummy
)
764 DWORD lpBaseOfDll
= (DWORD
) current_event
.u
.UnloadDll
.lpBaseOfDll
;
767 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
768 if (so
->next
->lm_info
->load_addr
== lpBaseOfDll
)
770 struct so_list
*sodel
= so
->next
;
771 so
->next
= sodel
->next
;
774 win32_free_so (sodel
);
775 solib_add (NULL
, 0, NULL
, auto_solib_add
);
779 error (_("Error: dll starting at 0x%lx not found."), (DWORD
) lpBaseOfDll
);
784 /* Clear list of loaded DLLs. */
786 win32_clear_solib (void)
788 solib_start
.next
= NULL
;
789 solib_end
= &solib_start
;
792 /* Load DLL symbol info. */
794 dll_symbol_command (char *args
, int from_tty
)
800 error (_("dll-symbols requires a file name"));
803 if (n
> 4 && strcasecmp (args
+ n
- 4, ".dll") != 0)
805 char *newargs
= (char *) alloca (n
+ 4 + 1);
806 strcpy (newargs
, args
);
807 strcat (newargs
, ".dll");
811 safe_symbol_file_add (args
, from_tty
, NULL
, 0, OBJF_SHARED
| OBJF_USERLOADED
);
814 /* Handle DEBUG_STRING output from child process.
815 Cygwin prepends its messages with a "cygwin:". Interpret this as
816 a Cygwin signal. Otherwise just print the string as a warning. */
818 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
823 if (!target_read_string
824 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
828 else if (strncmp (s
, _CYGWIN_SIGNAL_STRING
, sizeof (_CYGWIN_SIGNAL_STRING
) - 1) != 0)
831 if (strncmp (s
, "cYg", 3) != 0)
835 #ifdef __COPY_CONTEXT_SIZE
838 /* Got a cygwin signal marker. A cygwin signal is followed by the signal number
839 itself and then optionally followed by the thread id and address to saved context
840 within the DLL. If these are supplied, then the given thread is assumed to have
841 issued the signal and the context from the thread is assumed to be stored at the
842 given address in the inferior. Tell gdb to treat this like a real signal. */
844 int sig
= strtol (s
+ sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
845 int gotasig
= target_signal_from_host (sig
);
846 ourstatus
->value
.sig
= gotasig
;
851 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
852 retval
= strtoul (p
, &p
, 0);
854 retval
= main_thread_id
;
855 else if ((x
= (LPCVOID
) strtoul (p
, &p
, 0))
856 && ReadProcessMemory (current_process_handle
, x
,
857 &saved_context
, __COPY_CONTEXT_SIZE
, &n
)
858 && n
== __COPY_CONTEXT_SIZE
)
859 have_saved_context
= 1;
860 current_event
.dwThreadId
= retval
;
871 display_selector (HANDLE thread
, DWORD sel
)
874 if (GetThreadSelectorEntry (thread
, sel
, &info
))
877 printf_filtered ("0x%03lx: ", sel
);
878 if (!info
.HighWord
.Bits
.Pres
)
880 puts_filtered ("Segment not present\n");
883 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
884 (info
.HighWord
.Bits
.BaseMid
<< 16)
886 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
887 if (info
.HighWord
.Bits
.Granularity
)
888 limit
= (limit
<< 12) | 0xfff;
889 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
890 if (info
.HighWord
.Bits
.Default_Big
)
891 puts_filtered(" 32-bit ");
893 puts_filtered(" 16-bit ");
894 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
897 puts_filtered ("Data (Read-Only, Exp-up");
900 puts_filtered ("Data (Read/Write, Exp-up");
903 puts_filtered ("Unused segment (");
906 puts_filtered ("Data (Read/Write, Exp-down");
909 puts_filtered ("Code (Exec-Only, N.Conf");
912 puts_filtered ("Code (Exec/Read, N.Conf");
915 puts_filtered ("Code (Exec-Only, Conf");
918 puts_filtered ("Code (Exec/Read, Conf");
921 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
923 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
924 puts_filtered(", N.Acc");
925 puts_filtered (")\n");
926 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
927 puts_filtered("System selector ");
928 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
929 if (info
.HighWord
.Bits
.Granularity
)
930 puts_filtered ("Page granular.\n");
932 puts_filtered ("Byte granular.\n");
937 printf_filtered ("Invalid selector 0x%lx.\n",sel
);
943 display_selectors (char * args
, int from_tty
)
947 puts_filtered ("Impossible to display selectors now.\n");
953 puts_filtered ("Selector $cs\n");
954 display_selector (current_thread
->h
,
955 current_thread
->context
.SegCs
);
956 puts_filtered ("Selector $ds\n");
957 display_selector (current_thread
->h
,
958 current_thread
->context
.SegDs
);
959 puts_filtered ("Selector $es\n");
960 display_selector (current_thread
->h
,
961 current_thread
->context
.SegEs
);
962 puts_filtered ("Selector $ss\n");
963 display_selector (current_thread
->h
,
964 current_thread
->context
.SegSs
);
965 puts_filtered ("Selector $fs\n");
966 display_selector (current_thread
->h
,
967 current_thread
->context
.SegFs
);
968 puts_filtered ("Selector $gs\n");
969 display_selector (current_thread
->h
,
970 current_thread
->context
.SegGs
);
975 sel
= parse_and_eval_long (args
);
976 printf_filtered ("Selector \"%s\"\n",args
);
977 display_selector (current_thread
->h
, sel
);
981 static struct cmd_list_element
*info_w32_cmdlist
= NULL
;
984 info_w32_command (char *args
, int from_tty
)
986 help_list (info_w32_cmdlist
, "info w32 ", class_info
, gdb_stdout
);
990 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
991 printf_unfiltered ("gdb: Target exception %s at 0x%08lx\n", x, \
992 (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress)
995 handle_exception (struct target_waitstatus
*ourstatus
)
998 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1000 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1002 /* Record the context of the current thread */
1003 th
= thread_rec (current_event
.dwThreadId
, -1);
1007 case EXCEPTION_ACCESS_VIOLATION
:
1008 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1009 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1012 /* See if the access violation happened within the cygwin DLL itself. Cygwin uses
1013 a kind of exception handling to deal with passed-in invalid addresses. gdb
1014 should not treat these as real SEGVs since they will be silently handled by
1015 cygwin. A real SEGV will (theoretically) be caught by cygwin later in the process
1016 and will be sent as a cygwin-specific-signal. So, ignore SEGVs if they show up
1017 within the text segment of the DLL itself. */
1019 bfd_vma addr
= (bfd_vma
) (uintptr_t) current_event
.u
.Exception
.
1020 ExceptionRecord
.ExceptionAddress
;
1021 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
&& addr
< cygwin_load_end
))
1022 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1023 && strncmp (fn
, "KERNEL32!IsBad", strlen ("KERNEL32!IsBad")) == 0))
1028 case STATUS_STACK_OVERFLOW
:
1029 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1030 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1032 case STATUS_FLOAT_DENORMAL_OPERAND
:
1033 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1034 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1036 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1037 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1038 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1040 case STATUS_FLOAT_INEXACT_RESULT
:
1041 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1042 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1044 case STATUS_FLOAT_INVALID_OPERATION
:
1045 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1046 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1048 case STATUS_FLOAT_OVERFLOW
:
1049 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1050 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1052 case STATUS_FLOAT_STACK_CHECK
:
1053 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1054 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1056 case STATUS_FLOAT_UNDERFLOW
:
1057 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1058 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1060 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1061 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1062 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1064 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1065 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1066 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1068 case STATUS_INTEGER_OVERFLOW
:
1069 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1070 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1072 case EXCEPTION_BREAKPOINT
:
1073 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1074 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1077 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1078 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1080 case DBG_CONTROL_BREAK
:
1081 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1082 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1084 case EXCEPTION_SINGLE_STEP
:
1085 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1086 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1088 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1089 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1090 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1092 case EXCEPTION_PRIV_INSTRUCTION
:
1093 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1094 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1096 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1097 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1098 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1101 /* Treat unhandled first chance exceptions specially. */
1102 if (current_event
.u
.Exception
.dwFirstChance
)
1104 printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",
1105 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1106 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1107 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1111 last_sig
= ourstatus
->value
.sig
;
1115 /* Resume all artificially suspended threads if we are continuing
1118 win32_continue (DWORD continue_status
, int id
)
1124 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, %s);\n",
1125 current_event
.dwProcessId
, current_event
.dwThreadId
,
1126 continue_status
== DBG_CONTINUE
?
1127 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1129 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1130 if ((id
== -1 || id
== (int) th
->id
)
1133 if (debug_registers_changed
)
1135 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1136 th
->context
.Dr0
= dr
[0];
1137 th
->context
.Dr1
= dr
[1];
1138 th
->context
.Dr2
= dr
[2];
1139 th
->context
.Dr3
= dr
[3];
1140 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1141 th
->context
.Dr7
= dr
[7];
1143 if (th
->context
.ContextFlags
)
1145 CHECK (SetThreadContext (th
->h
, &th
->context
));
1146 th
->context
.ContextFlags
= 0;
1148 if (th
->suspended
> 0)
1149 (void) ResumeThread (th
->h
);
1153 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1154 current_event
.dwThreadId
,
1157 debug_registers_changed
= 0;
1161 /* Called in pathological case where Windows fails to send a
1162 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1164 fake_create_process (void)
1166 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1167 current_event
.dwProcessId
);
1168 if (current_process_handle
!= NULL
)
1169 open_process_used
= 1;
1172 error (_("OpenProcess call failed, GetLastError = %lud\n"),
1174 /* We can not debug anything in that case. */
1176 main_thread_id
= current_event
.dwThreadId
;
1177 current_thread
= win32_add_thread (main_thread_id
,
1178 current_event
.u
.CreateThread
.hThread
);
1179 return main_thread_id
;
1183 win32_resume (ptid_t ptid
, int step
, enum target_signal sig
)
1186 DWORD continue_status
= DBG_CONTINUE
;
1188 int pid
= PIDGET (ptid
);
1190 if (sig
!= TARGET_SIGNAL_0
)
1192 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1194 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1196 else if (sig
== last_sig
)
1197 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1200 /* This code does not seem to work, because
1201 the kernel does probably not consider changes in the ExceptionRecord
1202 structure when passing the exception to the inferior.
1203 Note that this seems possible in the exception handler itself. */
1206 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1207 if (xlate
[i
].us
== sig
)
1209 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
=
1211 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1214 if (continue_status
== DBG_CONTINUE
)
1216 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1220 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1224 last_sig
= TARGET_SIGNAL_0
;
1226 DEBUG_EXEC (("gdb: win32_resume (pid=%d, step=%d, sig=%d);\n",
1229 /* Get context for currently selected thread */
1230 th
= thread_rec (PIDGET (inferior_ptid
), FALSE
);
1235 /* Single step by setting t bit */
1236 win32_fetch_inferior_registers (get_current_regcache (),
1237 gdbarch_ps_regnum (current_gdbarch
));
1238 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1241 if (th
->context
.ContextFlags
)
1243 if (debug_registers_changed
)
1245 th
->context
.Dr0
= dr
[0];
1246 th
->context
.Dr1
= dr
[1];
1247 th
->context
.Dr2
= dr
[2];
1248 th
->context
.Dr3
= dr
[3];
1249 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1250 th
->context
.Dr7
= dr
[7];
1252 CHECK (SetThreadContext (th
->h
, &th
->context
));
1253 th
->context
.ContextFlags
= 0;
1257 /* Allow continuing with the same signal that interrupted us.
1258 Otherwise complain. */
1260 win32_continue (continue_status
, pid
);
1263 /* Get the next event from the child. Return 1 if the event requires
1264 handling by WFI (or whatever).
1267 get_win32_debug_event (int pid
, struct target_waitstatus
*ourstatus
)
1270 DWORD continue_status
, event_code
;
1272 static thread_info dummy_thread_info
;
1276 last_sig
= TARGET_SIGNAL_0
;
1278 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1282 continue_status
= DBG_CONTINUE
;
1284 event_code
= current_event
.dwDebugEventCode
;
1285 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1287 have_saved_context
= 0;
1291 case CREATE_THREAD_DEBUG_EVENT
:
1292 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1293 (unsigned) current_event
.dwProcessId
,
1294 (unsigned) current_event
.dwThreadId
,
1295 "CREATE_THREAD_DEBUG_EVENT"));
1296 if (saw_create
!= 1)
1298 if (!saw_create
&& 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
= ourstatus
->value
.related_pid
= fake_create_process ();
1309 /* Record the existence of this thread */
1310 th
= win32_add_thread (current_event
.dwThreadId
,
1311 current_event
.u
.CreateThread
.hThread
);
1312 retval
= current_event
.dwThreadId
;
1315 case EXIT_THREAD_DEBUG_EVENT
:
1316 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1317 (unsigned) current_event
.dwProcessId
,
1318 (unsigned) current_event
.dwThreadId
,
1319 "EXIT_THREAD_DEBUG_EVENT"));
1320 if (current_event
.dwThreadId
!= main_thread_id
)
1322 win32_delete_thread (current_event
.dwThreadId
);
1323 th
= &dummy_thread_info
;
1327 case CREATE_PROCESS_DEBUG_EVENT
:
1328 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1329 (unsigned) current_event
.dwProcessId
,
1330 (unsigned) current_event
.dwThreadId
,
1331 "CREATE_PROCESS_DEBUG_EVENT"));
1332 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1333 if (++saw_create
!= 1)
1336 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1338 win32_delete_thread (main_thread_id
);
1339 main_thread_id
= current_event
.dwThreadId
;
1340 /* Add the main thread */
1341 th
= win32_add_thread (main_thread_id
,
1342 current_event
.u
.CreateProcessInfo
.hThread
);
1343 retval
= ourstatus
->value
.related_pid
= current_event
.dwThreadId
;
1346 case EXIT_PROCESS_DEBUG_EVENT
:
1347 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1348 (unsigned) current_event
.dwProcessId
,
1349 (unsigned) current_event
.dwThreadId
,
1350 "EXIT_PROCESS_DEBUG_EVENT"));
1351 if (saw_create
!= 1)
1353 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1354 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1355 retval
= main_thread_id
;
1358 case LOAD_DLL_DEBUG_EVENT
:
1359 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1360 (unsigned) current_event
.dwProcessId
,
1361 (unsigned) current_event
.dwThreadId
,
1362 "LOAD_DLL_DEBUG_EVENT"));
1363 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1364 if (saw_create
!= 1)
1366 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1367 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1368 ourstatus
->value
.integer
= 0;
1369 retval
= main_thread_id
;
1372 case UNLOAD_DLL_DEBUG_EVENT
:
1373 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1374 (unsigned) current_event
.dwProcessId
,
1375 (unsigned) current_event
.dwThreadId
,
1376 "UNLOAD_DLL_DEBUG_EVENT"));
1377 if (saw_create
!= 1)
1379 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1380 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1381 ourstatus
->value
.integer
= 0;
1382 retval
= main_thread_id
;
1385 case EXCEPTION_DEBUG_EVENT
:
1386 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1387 (unsigned) current_event
.dwProcessId
,
1388 (unsigned) current_event
.dwThreadId
,
1389 "EXCEPTION_DEBUG_EVENT"));
1390 if (saw_create
!= 1)
1392 switch (handle_exception (ourstatus
))
1395 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1398 retval
= current_event
.dwThreadId
;
1402 continue_status
= -1;
1407 case OUTPUT_DEBUG_STRING_EVENT
: /* message from the kernel */
1408 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1409 (unsigned) current_event
.dwProcessId
,
1410 (unsigned) current_event
.dwThreadId
,
1411 "OUTPUT_DEBUG_STRING_EVENT"));
1412 if (saw_create
!= 1)
1414 retval
= handle_output_debug_string (ourstatus
);
1418 if (saw_create
!= 1)
1420 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1421 (DWORD
) current_event
.dwProcessId
,
1422 (DWORD
) current_event
.dwThreadId
);
1423 printf_unfiltered (" unknown event code %ld\n",
1424 current_event
.dwDebugEventCode
);
1428 if (!retval
|| saw_create
!= 1)
1430 if (continue_status
== -1)
1431 win32_resume (ptid
, 0, 1);
1433 CHECK (win32_continue (continue_status
, -1));
1437 inferior_ptid
= pid_to_ptid (retval
);
1438 current_thread
= th
?: thread_rec (current_event
.dwThreadId
, TRUE
);
1445 /* Wait for interesting events to occur in the target process. */
1447 win32_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
1449 int pid
= PIDGET (ptid
);
1451 target_terminal_ours ();
1453 /* We loop when we get a non-standard exception rather than return
1454 with a SPURIOUS because resume can try and step or modify things,
1455 which needs a current_thread->h. But some of these exceptions mark
1456 the birth or death of threads, which mean that the current thread
1457 isn't necessarily what you think it is. */
1463 /* Ignore CTRL+C signals while waiting for a debug event.
1464 FIXME: brobecker/2008-05-20: When the user presses CTRL+C while
1465 the inferior is running, both the inferior and GDB receive the
1466 associated signal. If the inferior receives the signal first
1467 and the delay until GDB receives that signal is sufficiently long,
1468 GDB can sometimes receive the SIGINT after we have unblocked
1469 the CTRL+C handler. This would lead to the debugger to stop
1470 prematurely while handling the new-thread event that comes
1471 with the handling of the SIGINT inside the inferior, and then
1472 stop again immediately when the user tries to resume the execution
1473 in the inferior. This is a classic race, and it would be nice
1474 to find a better solution to that problem. But in the meantime,
1475 the current approach already greatly mitigate this issue. */
1476 SetConsoleCtrlHandler (NULL
, TRUE
);
1477 retval
= get_win32_debug_event (pid
, ourstatus
);
1478 SetConsoleCtrlHandler (NULL
, FALSE
);
1481 return pid_to_ptid (retval
);
1486 if (deprecated_ui_loop_hook
!= NULL
)
1487 detach
= deprecated_ui_loop_hook (0);
1490 win32_kill_inferior ();
1496 do_initial_win32_stuff (DWORD pid
)
1498 extern int stop_after_trap
;
1501 last_sig
= TARGET_SIGNAL_0
;
1503 exception_count
= 0;
1504 open_process_used
= 0;
1505 debug_registers_changed
= 0;
1506 debug_registers_used
= 0;
1507 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1510 cygwin_load_start
= cygwin_load_end
= 0;
1512 current_event
.dwProcessId
= pid
;
1513 memset (¤t_event
, 0, sizeof (current_event
));
1514 push_target (&win32_ops
);
1515 disable_breakpoints_in_shlibs ();
1516 win32_clear_solib ();
1517 clear_proceed_status ();
1518 init_wait_for_inferior ();
1520 terminal_init_inferior_with_pgrp (pid
);
1521 target_terminal_inferior ();
1525 stop_after_trap
= 1;
1526 wait_for_inferior (0);
1527 if (stop_signal
!= TARGET_SIGNAL_TRAP
)
1528 resume (0, stop_signal
);
1532 stop_after_trap
= 0;
1536 /* Since Windows XP, detaching from a process is supported by Windows.
1537 The following code tries loading the appropriate functions dynamically.
1538 If loading these functions succeeds use them to actually detach from
1539 the inferior process, otherwise behave as usual, pretending that
1540 detach has worked. */
1541 static BOOL
WINAPI (*DebugSetProcessKillOnExit
)(BOOL
);
1542 static BOOL
WINAPI (*DebugActiveProcessStop
)(DWORD
);
1545 has_detach_ability (void)
1547 static HMODULE kernel32
= NULL
;
1550 kernel32
= LoadLibrary ("kernel32.dll");
1553 if (!DebugSetProcessKillOnExit
)
1554 DebugSetProcessKillOnExit
= GetProcAddress (kernel32
,
1555 "DebugSetProcessKillOnExit");
1556 if (!DebugActiveProcessStop
)
1557 DebugActiveProcessStop
= GetProcAddress (kernel32
,
1558 "DebugActiveProcessStop");
1559 if (DebugSetProcessKillOnExit
&& DebugActiveProcessStop
)
1565 /* Try to set or remove a user privilege to the current process. Return -1
1566 if that fails, the previous setting of that privilege otherwise.
1568 This code is copied from the Cygwin source code and rearranged to allow
1569 dynamically loading of the needed symbols from advapi32 which is only
1570 available on NT/2K/XP. */
1572 set_process_privilege (const char *privilege
, BOOL enable
)
1574 static HMODULE advapi32
= NULL
;
1575 static BOOL
WINAPI (*OpenProcessToken
)(HANDLE
, DWORD
, PHANDLE
);
1576 static BOOL
WINAPI (*LookupPrivilegeValue
)(LPCSTR
, LPCSTR
, PLUID
);
1577 static BOOL
WINAPI (*AdjustTokenPrivileges
)(HANDLE
, BOOL
, PTOKEN_PRIVILEGES
,
1578 DWORD
, PTOKEN_PRIVILEGES
, PDWORD
);
1580 HANDLE token_hdl
= NULL
;
1582 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1586 if (GetVersion () >= 0x80000000) /* No security availbale on 9x/Me */
1591 if (!(advapi32
= LoadLibrary ("advapi32.dll")))
1593 if (!OpenProcessToken
)
1594 OpenProcessToken
= GetProcAddress (advapi32
, "OpenProcessToken");
1595 if (!LookupPrivilegeValue
)
1596 LookupPrivilegeValue
= GetProcAddress (advapi32
,
1597 "LookupPrivilegeValueA");
1598 if (!AdjustTokenPrivileges
)
1599 AdjustTokenPrivileges
= GetProcAddress (advapi32
,
1600 "AdjustTokenPrivileges");
1601 if (!OpenProcessToken
|| !LookupPrivilegeValue
|| !AdjustTokenPrivileges
)
1608 if (!OpenProcessToken (GetCurrentProcess (),
1609 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1613 if (!LookupPrivilegeValue (NULL
, privilege
, &restore_priv
))
1616 new_priv
.PrivilegeCount
= 1;
1617 new_priv
.Privileges
[0].Luid
= restore_priv
;
1618 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1620 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1621 sizeof orig_priv
, &orig_priv
, &size
))
1624 /* Disabled, otherwise every `attach' in an unprivileged user session
1625 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1627 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1628 be enabled. GetLastError () returns an correct error code, though. */
1629 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1633 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1637 CloseHandle (token_hdl
);
1642 /* Attach to process PID, then initialize for debugging it. */
1644 win32_attach (char *args
, int from_tty
)
1650 error_no_arg (_("process-id to attach"));
1652 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1654 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1655 printf_unfiltered ("This can cause attach to fail on Windows NT/2K/XP\n");
1658 pid
= strtoul (args
, 0, 0); /* Windows pid */
1660 win32_init_thread_list ();
1661 ok
= DebugActiveProcess (pid
);
1667 /* Try fall back to Cygwin pid */
1668 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1671 ok
= DebugActiveProcess (pid
);
1676 error (_("Can't attach to process."));
1678 if (has_detach_ability ())
1679 DebugSetProcessKillOnExit (FALSE
);
1685 char *exec_file
= (char *) get_exec_file (0);
1688 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1689 target_pid_to_str (pid_to_ptid (pid
)));
1691 printf_unfiltered ("Attaching to %s\n",
1692 target_pid_to_str (pid_to_ptid (pid
)));
1694 gdb_flush (gdb_stdout
);
1697 do_initial_win32_stuff (pid
);
1698 target_terminal_ours ();
1702 win32_detach (char *args
, int from_tty
)
1706 if (has_detach_ability ())
1709 win32_resume (ptid
, 0, TARGET_SIGNAL_0
);
1711 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1713 error (_("Can't detach process %lu (error %lu)"),
1714 current_event
.dwProcessId
, GetLastError ());
1717 DebugSetProcessKillOnExit (FALSE
);
1719 if (detached
&& from_tty
)
1721 char *exec_file
= get_exec_file (0);
1724 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file
,
1725 current_event
.dwProcessId
);
1726 gdb_flush (gdb_stdout
);
1728 inferior_ptid
= null_ptid
;
1729 unpush_target (&win32_ops
);
1733 win32_pid_to_exec_file (int pid
)
1735 static char path
[MAX_PATH
+ 1];
1738 /* Try to find exe name as symlink target of /proc/<pid>/exe */
1740 char procexe
[sizeof ("/proc/4294967295/exe")];
1741 sprintf (procexe
, "/proc/%lu/exe", current_event
.dwProcessId
);
1742 nchars
= readlink (procexe
, path
, sizeof(path
));
1743 if (nchars
> 0 && nchars
< sizeof (path
))
1745 path
[nchars
] = '\0'; /* Got it */
1750 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
1751 of gdb, or we're trying to debug a non-Cygwin windows executable. */
1752 if (!get_module_name (0, path
))
1758 /* Print status information about what we're accessing. */
1761 win32_files_info (struct target_ops
*ignore
)
1763 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1764 attach_flag
? "attached" : "child", target_pid_to_str (inferior_ptid
));
1768 win32_open (char *arg
, int from_tty
)
1770 error (_("Use the \"run\" command to start a Unix child process."));
1773 /* Start an inferior win32 child process and sets inferior_ptid to its pid.
1774 EXEC_FILE is the file to run.
1775 ALLARGS is a string containing the arguments to the program.
1776 ENV is the environment vector to pass. Errors reported with error(). */
1779 win32_create_inferior (char *exec_file
, char *allargs
, char **in_env
,
1783 PROCESS_INFORMATION pi
;
1787 char real_path
[MAXPATHLEN
];
1789 char shell
[MAX_PATH
+ 1]; /* Path to shell */
1792 int ostdin
, ostdout
, ostderr
;
1793 const char *inferior_io_terminal
= get_inferior_io_terminal ();
1796 error (_("No executable specified, use `target exec'."));
1798 memset (&si
, 0, sizeof (si
));
1799 si
.cb
= sizeof (si
);
1804 flags
= DEBUG_ONLY_THIS_PROCESS
;
1805 cygwin_conv_to_win32_path (exec_file
, real_path
);
1811 sh
= getenv ("SHELL");
1814 cygwin_conv_to_win32_path (sh
, shell
);
1815 newallargs
= alloca (sizeof (" -c 'exec '") + strlen (exec_file
)
1816 + strlen (allargs
) + 2);
1817 sprintf (newallargs
, " -c 'exec %s %s'", exec_file
, allargs
);
1818 allargs
= newallargs
;
1820 flags
= DEBUG_PROCESS
;
1824 flags
= DEBUG_ONLY_THIS_PROCESS
;
1828 flags
|= CREATE_NEW_PROCESS_GROUP
;
1831 flags
|= CREATE_NEW_CONSOLE
;
1835 args
= alloca (strlen (toexec
) + strlen (allargs
) + 2);
1836 strcpy (args
, toexec
);
1838 strcat (args
, allargs
);
1841 /* Prepare the environment vars for CreateProcess. */
1842 cygwin_internal (CW_SYNC_WINENV
);
1844 if (!inferior_io_terminal
)
1845 tty
= ostdin
= ostdout
= ostderr
= -1;
1848 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
1851 print_sys_errmsg (inferior_io_terminal
, errno
);
1852 ostdin
= ostdout
= ostderr
= -1;
1866 win32_init_thread_list ();
1867 ret
= CreateProcess (0,
1868 args
, /* command line */
1869 NULL
, /* Security */
1871 TRUE
, /* inherit handles */
1872 flags
, /* start flags */
1873 NULL
, /* environment */
1874 NULL
, /* current directory */
1892 error (_("Error creating process %s, (error %d)."),
1893 exec_file
, (unsigned) GetLastError ());
1895 CloseHandle (pi
.hThread
);
1896 CloseHandle (pi
.hProcess
);
1898 if (useshell
&& shell
[0] != '\0')
1903 do_initial_win32_stuff (pi
.dwProcessId
);
1905 /* win32_continue (DBG_CONTINUE, -1); */
1909 win32_mourn_inferior (void)
1911 (void) win32_continue (DBG_CONTINUE
, -1);
1912 i386_cleanup_dregs();
1913 if (open_process_used
)
1915 CHECK (CloseHandle (current_process_handle
));
1916 open_process_used
= 0;
1918 unpush_target (&win32_ops
);
1919 generic_mourn_inferior ();
1922 /* Send a SIGINT to the process group. This acts just like the user typed a
1923 ^C on the controlling terminal. */
1928 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1929 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
1930 registers_changed (); /* refresh register state */
1934 win32_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*our
, int len
,
1935 int write
, struct mem_attrib
*mem
,
1936 struct target_ops
*target
)
1941 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1942 len
, (DWORD
) (uintptr_t) memaddr
));
1943 if (!WriteProcessMemory (current_process_handle
,
1944 (LPVOID
) (uintptr_t) memaddr
, our
,
1947 FlushInstructionCache (current_process_handle
,
1948 (LPCVOID
) (uintptr_t) memaddr
, len
);
1952 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
1953 len
, (DWORD
) (uintptr_t) memaddr
));
1954 if (!ReadProcessMemory (current_process_handle
,
1955 (LPCVOID
) (uintptr_t) memaddr
, our
,
1963 win32_kill_inferior (void)
1965 CHECK (TerminateProcess (current_process_handle
, 0));
1969 if (!win32_continue (DBG_CONTINUE
, -1))
1971 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
1973 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
1977 target_mourn_inferior (); /* or just win32_mourn_inferior? */
1981 win32_prepare_to_store (struct regcache
*regcache
)
1983 /* Do nothing, since we can store individual regs */
1987 win32_can_run (void)
1995 DEBUG_EVENTS (("gdb: win32_close, inferior_ptid=%d\n",
1996 PIDGET (inferior_ptid
)));
1999 /* Convert pid to printable format. */
2001 win32_pid_to_str (ptid_t ptid
)
2003 static char buf
[80];
2004 int pid
= PIDGET (ptid
);
2006 if ((DWORD
) pid
== current_event
.dwProcessId
)
2007 sprintf (buf
, "process %d", pid
);
2009 sprintf (buf
, "thread %ld.0x%x", current_event
.dwProcessId
, pid
);
2014 win32_xfer_shared_libraries (struct target_ops
*ops
,
2015 enum target_object object
, const char *annex
,
2016 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2017 ULONGEST offset
, LONGEST len
)
2019 struct obstack obstack
;
2027 obstack_init (&obstack
);
2028 obstack_grow_str (&obstack
, "<library-list>\n");
2029 for (so
= solib_start
.next
; so
; so
= so
->next
)
2030 win32_xfer_shared_library (so
->so_name
, so
->lm_info
->load_addr
, &obstack
);
2031 obstack_grow_str0 (&obstack
, "</library-list>\n");
2033 buf
= obstack_finish (&obstack
);
2034 len_avail
= strlen (buf
);
2035 if (offset
>= len_avail
)
2038 if (len
> len_avail
- offset
)
2039 len
= len_avail
- offset
;
2040 memcpy (readbuf
, buf
+ offset
, len
);
2042 obstack_free (&obstack
, NULL
);
2047 win32_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2048 const char *annex
, gdb_byte
*readbuf
,
2049 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
2053 case TARGET_OBJECT_MEMORY
:
2055 return (*ops
->deprecated_xfer_memory
) (offset
, readbuf
,
2056 len
, 0/*read*/, NULL
, ops
);
2058 return (*ops
->deprecated_xfer_memory
) (offset
, (gdb_byte
*) writebuf
,
2059 len
, 1/*write*/, NULL
, ops
);
2062 case TARGET_OBJECT_LIBRARIES
:
2063 return win32_xfer_shared_libraries (ops
, object
, annex
, readbuf
,
2064 writebuf
, offset
, len
);
2067 if (ops
->beneath
!= NULL
)
2068 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2069 readbuf
, writebuf
, offset
, len
);
2075 init_win32_ops (void)
2077 win32_ops
.to_shortname
= "child";
2078 win32_ops
.to_longname
= "Win32 child process";
2079 win32_ops
.to_doc
= "Win32 child process (started by the \"run\" command).";
2080 win32_ops
.to_open
= win32_open
;
2081 win32_ops
.to_close
= win32_close
;
2082 win32_ops
.to_attach
= win32_attach
;
2083 win32_ops
.to_detach
= win32_detach
;
2084 win32_ops
.to_resume
= win32_resume
;
2085 win32_ops
.to_wait
= win32_wait
;
2086 win32_ops
.to_fetch_registers
= win32_fetch_inferior_registers
;
2087 win32_ops
.to_store_registers
= win32_store_inferior_registers
;
2088 win32_ops
.to_prepare_to_store
= win32_prepare_to_store
;
2089 win32_ops
.deprecated_xfer_memory
= win32_xfer_memory
;
2090 win32_ops
.to_xfer_partial
= win32_xfer_partial
;
2091 win32_ops
.to_files_info
= win32_files_info
;
2092 win32_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
2093 win32_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
2094 win32_ops
.to_terminal_init
= terminal_init_inferior
;
2095 win32_ops
.to_terminal_inferior
= terminal_inferior
;
2096 win32_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
2097 win32_ops
.to_terminal_ours
= terminal_ours
;
2098 win32_ops
.to_terminal_save_ours
= terminal_save_ours
;
2099 win32_ops
.to_terminal_info
= child_terminal_info
;
2100 win32_ops
.to_kill
= win32_kill_inferior
;
2101 win32_ops
.to_create_inferior
= win32_create_inferior
;
2102 win32_ops
.to_mourn_inferior
= win32_mourn_inferior
;
2103 win32_ops
.to_can_run
= win32_can_run
;
2104 win32_ops
.to_thread_alive
= win32_win32_thread_alive
;
2105 win32_ops
.to_pid_to_str
= win32_pid_to_str
;
2106 win32_ops
.to_stop
= win32_stop
;
2107 win32_ops
.to_stratum
= process_stratum
;
2108 win32_ops
.to_has_all_memory
= 1;
2109 win32_ops
.to_has_memory
= 1;
2110 win32_ops
.to_has_stack
= 1;
2111 win32_ops
.to_has_registers
= 1;
2112 win32_ops
.to_has_execution
= 1;
2113 win32_ops
.to_magic
= OPS_MAGIC
;
2114 win32_ops
.to_pid_to_exec_file
= win32_pid_to_exec_file
;
2118 set_win32_aliases (char *argv0
)
2120 add_info_alias ("dll", "sharedlibrary", 1);
2124 _initialize_win32_nat (void)
2126 struct cmd_list_element
*c
;
2130 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
2131 _("Load dll library symbols from FILE."));
2132 set_cmd_completer (c
, filename_completer
);
2134 add_com_alias ("sharedlibrary", "dll-symbols", class_alias
, 1);
2137 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
2138 Set use of shell to start subprocess."), _("\
2139 Show use of shell to start subprocess."), NULL
,
2141 NULL
, /* FIXME: i18n: */
2142 &setlist
, &showlist
);
2144 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
, &cygwin_exceptions
, _("\
2145 Break when an exception is detected in the Cygwin DLL itself."), _("\
2146 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
2148 NULL
, /* FIXME: i18n: */
2149 &setlist
, &showlist
);
2152 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
2153 Set creation of new console when creating child process."), _("\
2154 Show creation of new console when creating child process."), NULL
,
2156 NULL
, /* FIXME: i18n: */
2157 &setlist
, &showlist
);
2159 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
2160 Set creation of new group when creating child process."), _("\
2161 Show creation of new group when creating child process."), NULL
,
2163 NULL
, /* FIXME: i18n: */
2164 &setlist
, &showlist
);
2166 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
2167 Set whether to display execution in child process."), _("\
2168 Show whether to display execution in child process."), NULL
,
2170 NULL
, /* FIXME: i18n: */
2171 &setlist
, &showlist
);
2173 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
2174 Set whether to display kernel events in child process."), _("\
2175 Show whether to display kernel events in child process."), NULL
,
2177 NULL
, /* FIXME: i18n: */
2178 &setlist
, &showlist
);
2180 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
2181 Set whether to display memory accesses in child process."), _("\
2182 Show whether to display memory accesses in child process."), NULL
,
2184 NULL
, /* FIXME: i18n: */
2185 &setlist
, &showlist
);
2187 add_setshow_boolean_cmd ("debugexceptions", class_support
,
2188 &debug_exceptions
, _("\
2189 Set whether to display kernel exceptions in child process."), _("\
2190 Show whether to display kernel exceptions in child process."), NULL
,
2192 NULL
, /* FIXME: i18n: */
2193 &setlist
, &showlist
);
2195 add_prefix_cmd ("w32", class_info
, info_w32_command
,
2196 _("Print information specific to Win32 debugging."),
2197 &info_w32_cmdlist
, "info w32 ", 0, &infolist
);
2199 add_cmd ("selector", class_info
, display_selectors
,
2200 _("Display selectors infos."),
2202 add_target (&win32_ops
);
2203 deprecated_init_ui_hook
= set_win32_aliases
;
2206 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2208 /* Pass the address ADDR to the inferior in the I'th debug register.
2209 Here we just store the address in dr array, the registers will be
2210 actually set up when win32_continue is called. */
2212 cygwin_set_dr (int i
, CORE_ADDR addr
)
2215 internal_error (__FILE__
, __LINE__
,
2216 _("Invalid register %d in cygwin_set_dr.\n"), i
);
2217 dr
[i
] = (unsigned) addr
;
2218 debug_registers_changed
= 1;
2219 debug_registers_used
= 1;
2222 /* Pass the value VAL to the inferior in the DR7 debug control
2223 register. Here we just store the address in D_REGS, the watchpoint
2224 will be actually set up in win32_wait. */
2226 cygwin_set_dr7 (unsigned val
)
2229 debug_registers_changed
= 1;
2230 debug_registers_used
= 1;
2233 /* Get the value of the DR6 debug status register from the inferior.
2234 Here we just return the value stored in dr[6]
2235 by the last call to thread_rec for current_event.dwThreadId id. */
2237 cygwin_get_dr6 (void)
2242 /* Determine if the thread referenced by "pid" is alive
2243 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2244 it means that the pid has died. Otherwise it is assumed to be alive. */
2246 win32_win32_thread_alive (ptid_t ptid
)
2248 int pid
= PIDGET (ptid
);
2250 return WaitForSingleObject (thread_rec (pid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
?
2255 _initialize_check_for_gdb_ini (void)
2258 if (inhibit_gdbinit
)
2261 homedir
= getenv ("HOME");
2265 char *oldini
= (char *) alloca (strlen (homedir
) +
2266 sizeof ("/gdb.ini"));
2267 strcpy (oldini
, homedir
);
2268 p
= strchr (oldini
, '\0');
2269 if (p
> oldini
&& p
[-1] != '/')
2271 strcpy (p
, "gdb.ini");
2272 if (access (oldini
, 0) == 0)
2274 int len
= strlen (oldini
);
2275 char *newini
= alloca (len
+ 1);
2276 sprintf (newini
, "%.*s.gdbinit",
2277 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
2278 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
2284 _initialize_psapi (void)
2286 /* Load optional functions used for retrieving filename information
2287 associated with the currently debugged process or its dlls. */
2290 HMODULE psapi_module_handle
;
2294 psapi_module_handle
= LoadLibrary ("psapi.dll");
2295 if (psapi_module_handle
)
2297 psapi_EnumProcessModules
= (void *) GetProcAddress (psapi_module_handle
, "EnumProcessModules");
2298 psapi_GetModuleInformation
= (void *) GetProcAddress (psapi_module_handle
, "GetModuleInformation");
2299 psapi_GetModuleFileNameExA
= (void *) GetProcAddress (psapi_module_handle
, "GetModuleFileNameExA");
2301 if (psapi_EnumProcessModules
!= NULL
2302 && psapi_GetModuleInformation
!= NULL
2303 && psapi_GetModuleFileNameExA
!= NULL
)
2308 /* This will probably fail on Windows 9x/Me. Let the user know that we're
2309 missing some functionality. */
2310 if (psapi_loaded
< 0)
2311 warning(_("cannot automatically find executable file or library to read symbols. Use \"file\" or \"dll\" command to load executable/libraries directly."));