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
];
365 return; /* Windows sometimes uses a non-existent thread id in its
368 if (current_thread
->reload_context
)
370 #ifdef __COPY_CONTEXT_SIZE
371 if (have_saved_context
)
373 /* Lie about where the program actually is stopped since cygwin has informed us that
374 we should consider the signal to have occurred at another location which is stored
375 in "saved_context. */
376 memcpy (¤t_thread
->context
, &saved_context
, __COPY_CONTEXT_SIZE
);
377 have_saved_context
= 0;
382 thread_info
*th
= current_thread
;
383 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
384 GetThreadContext (th
->h
, &th
->context
);
385 /* Copy dr values from that thread.
386 But only if there were not modified since last stop. PR gdb/2388 */
387 if (!debug_registers_changed
)
389 dr
[0] = th
->context
.Dr0
;
390 dr
[1] = th
->context
.Dr1
;
391 dr
[2] = th
->context
.Dr2
;
392 dr
[3] = th
->context
.Dr3
;
393 dr
[6] = th
->context
.Dr6
;
394 dr
[7] = th
->context
.Dr7
;
397 current_thread
->reload_context
= 0;
400 #define I387_ST0_REGNUM I386_ST0_REGNUM
402 if (r
== I387_FISEG_REGNUM
)
404 l
= *((long *) context_offset
) & 0xffff;
405 regcache_raw_supply (regcache
, r
, (char *) &l
);
407 else if (r
== I387_FOP_REGNUM
)
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 (get_regcache_arch (regcache
)); r
++)
417 do_win32_fetch_inferior_registers (regcache
, r
);
420 #undef I387_ST0_REGNUM
424 win32_fetch_inferior_registers (struct regcache
*regcache
, int r
)
426 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
427 /* Check if current_thread exists. Windows sometimes uses a non-existent
428 thread id in its events */
430 do_win32_fetch_inferior_registers (regcache
, r
);
434 do_win32_store_inferior_registers (const struct regcache
*regcache
, int r
)
437 /* Windows sometimes uses a non-existent thread id in its events */;
439 regcache_raw_collect (regcache
, r
,
440 ((char *) ¤t_thread
->context
) + mappings
[r
]);
443 for (r
= 0; r
< gdbarch_num_regs (get_regcache_arch (regcache
)); r
++)
444 do_win32_store_inferior_registers (regcache
, r
);
448 /* Store a new register value into the current thread context */
450 win32_store_inferior_registers (struct regcache
*regcache
, int r
)
452 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
453 /* Check if current_thread exists. Windows sometimes uses a non-existent
454 thread id in its events */
456 do_win32_store_inferior_registers (regcache
, r
);
459 static int psapi_loaded
= 0;
460 static BOOL
WINAPI (*psapi_EnumProcessModules
) (HANDLE
, HMODULE
*, DWORD
,
462 static BOOL
WINAPI (*psapi_GetModuleInformation
) (HANDLE
, HMODULE
, LPMODULEINFO
,
464 static DWORD
WINAPI (*psapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
, LPSTR
,
467 /* Get the name of a given module at at given base address. If base_address
468 is zero return the first loaded module (which is always the name of the
471 get_module_name (DWORD base_address
, char *dll_name_ret
)
477 HMODULE
*DllHandle
= dh_buf
; /* Set to temporary storage for initial query */
480 char pathbuf
[PATH_MAX
+ 1]; /* Temporary storage prior to converting to
483 char *pathbuf
= dll_name_ret
; /* Just copy directly to passed-in arg */
486 /* If psapi_loaded < 0 either psapi.dll is not available or it does not contain
487 the needed functions. */
488 if (psapi_loaded
<= 0)
492 /* Find size of buffer needed to handle list of modules loaded in inferior */
493 if (!psapi_EnumProcessModules (current_process_handle
, DllHandle
,
494 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
497 /* Allocate correct amount of space for module list */
498 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
502 /* Get the list of modules */
503 if (!psapi_EnumProcessModules (current_process_handle
, DllHandle
, cbNeeded
,
507 for (i
= 0; i
< (int) (cbNeeded
/ sizeof (HMODULE
)); i
++)
509 /* Get information on this module */
510 if (!psapi_GetModuleInformation (current_process_handle
, DllHandle
[i
],
512 error (_("Can't get module info"));
514 if (!base_address
|| (DWORD
) (mi
.lpBaseOfDll
) == base_address
)
516 /* Try to find the name of the given module */
517 len
= psapi_GetModuleFileNameExA (current_process_handle
,
518 DllHandle
[i
], pathbuf
, MAX_PATH
);
520 error (_("Error getting dll name: %u."), (unsigned) GetLastError ());
522 /* Cygwin prefers that the path be in /x/y/z format */
523 cygwin_conv_to_full_posix_path (pathbuf
, dll_name_ret
);
525 return 1; /* success */
530 dll_name_ret
[0] = '\0';
531 return 0; /* failure */
534 /* Encapsulate the information required in a call to
535 symbol_file_add_args */
536 struct safe_symbol_file_add_args
540 struct section_addr_info
*addrs
;
543 struct ui_file
*err
, *out
;
547 /* Maintain a linked list of "so" information. */
553 static struct so_list solib_start
, *solib_end
;
555 /* Call symbol_file_add with stderr redirected. We don't care if there
558 safe_symbol_file_add_stub (void *argv
)
560 #define p ((struct safe_symbol_file_add_args *) argv)
561 struct so_list
*so
= &solib_start
;
563 p
->ret
= symbol_file_add (p
->name
, p
->from_tty
, p
->addrs
, p
->mainline
, p
->flags
);
568 /* Restore gdb's stderr after calling symbol_file_add */
570 safe_symbol_file_add_cleanup (void *p
)
572 #define sp ((struct safe_symbol_file_add_args *)p)
573 gdb_flush (gdb_stderr
);
574 gdb_flush (gdb_stdout
);
575 ui_file_delete (gdb_stderr
);
576 ui_file_delete (gdb_stdout
);
577 gdb_stderr
= sp
->err
;
578 gdb_stdout
= sp
->out
;
582 /* symbol_file_add wrapper that prevents errors from being displayed. */
583 static struct objfile
*
584 safe_symbol_file_add (char *name
, int from_tty
,
585 struct section_addr_info
*addrs
,
586 int mainline
, int flags
)
588 struct safe_symbol_file_add_args p
;
589 struct cleanup
*cleanup
;
591 cleanup
= make_cleanup (safe_symbol_file_add_cleanup
, &p
);
595 gdb_flush (gdb_stderr
);
596 gdb_flush (gdb_stdout
);
597 gdb_stderr
= ui_file_new ();
598 gdb_stdout
= ui_file_new ();
600 p
.from_tty
= from_tty
;
602 p
.mainline
= mainline
;
604 catch_errors (safe_symbol_file_add_stub
, &p
, "", RETURN_MASK_ERROR
);
606 do_cleanups (cleanup
);
610 static struct so_list
*
611 win32_make_so (const char *name
, DWORD load_addr
)
614 char buf
[MAX_PATH
+ 1];
615 char cwd
[MAX_PATH
+ 1];
617 WIN32_FIND_DATA w32_fd
;
618 HANDLE h
= FindFirstFile(name
, &w32_fd
);
619 MEMORY_BASIC_INFORMATION m
;
621 if (h
== INVALID_HANDLE_VALUE
)
627 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
629 p
= strrchr (buf
, '\\');
632 SetCurrentDirectory (buf
);
633 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
634 SetCurrentDirectory (cwd
);
638 if (strcasecmp (buf
, "ntdll.dll") == 0)
640 GetSystemDirectory (buf
, sizeof (buf
));
641 strcat (buf
, "\\ntdll.dll");
643 so
= XZALLOC (struct so_list
);
644 so
->lm_info
= (struct lm_info
*) xmalloc (sizeof (struct lm_info
));
645 so
->lm_info
->load_addr
= load_addr
;
646 strcpy (so
->so_original_name
, name
);
648 strcpy (so
->so_name
, buf
);
650 cygwin_conv_to_posix_path (buf
, so
->so_name
);
651 /* Record cygwin1.dll .text start/end. */
652 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
653 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
656 asection
*text
= NULL
;
659 abfd
= bfd_openr (so
->so_name
, "pei-i386");
664 if (bfd_check_format (abfd
, bfd_object
))
665 text
= bfd_get_section_by_name (abfd
, ".text");
673 /* The symbols in a dll are offset by 0x1000, which is the the
674 offset from 0 of the first byte in an image - because of the
675 file header and the section alignment. */
676 cygwin_load_start
= load_addr
+ 0x1000;
677 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (abfd
, text
);
687 get_image_name (HANDLE h
, void *address
, int unicode
)
689 static char buf
[(2 * MAX_PATH
) + 1];
690 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
696 /* Attempt to read the name of the dll that was detected.
697 This is documented to work only when actively debugging
698 a program. It will not work for attached processes. */
702 /* See if we could read the address of a string, and that the
703 address isn't null. */
704 if (!ReadProcessMemory (h
, address
, &address_ptr
, sizeof (address_ptr
), &done
)
705 || done
!= sizeof (address_ptr
) || !address_ptr
)
708 /* Find the length of the string */
709 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
710 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
714 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
717 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
718 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
721 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
727 /* Wait for child to do something. Return pid of child, or -1 in case
728 of error; store status through argument pointer OURSTATUS. */
730 handle_load_dll (void *dummy
)
732 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
733 char dll_buf
[MAX_PATH
+ 1];
734 char *dll_name
= NULL
;
736 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
738 if (!get_module_name ((DWORD
) event
->lpBaseOfDll
, dll_buf
))
739 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
743 if (*dll_name
== '\0')
744 dll_name
= get_image_name (current_process_handle
,
745 event
->lpImageName
, event
->fUnicode
);
749 solib_end
->next
= win32_make_so (dll_name
, (DWORD
) event
->lpBaseOfDll
);
750 solib_end
= solib_end
->next
;
756 win32_free_so (struct so_list
*so
)
764 handle_unload_dll (void *dummy
)
766 DWORD lpBaseOfDll
= (DWORD
) current_event
.u
.UnloadDll
.lpBaseOfDll
;
769 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
770 if (so
->next
->lm_info
->load_addr
== lpBaseOfDll
)
772 struct so_list
*sodel
= so
->next
;
773 so
->next
= sodel
->next
;
776 win32_free_so (sodel
);
777 solib_add (NULL
, 0, NULL
, auto_solib_add
);
781 error (_("Error: dll starting at 0x%lx not found."), (DWORD
) lpBaseOfDll
);
786 /* Clear list of loaded DLLs. */
788 win32_clear_solib (void)
790 solib_start
.next
= NULL
;
791 solib_end
= &solib_start
;
794 /* Load DLL symbol info. */
796 dll_symbol_command (char *args
, int from_tty
)
802 error (_("dll-symbols requires a file name"));
805 if (n
> 4 && strcasecmp (args
+ n
- 4, ".dll") != 0)
807 char *newargs
= (char *) alloca (n
+ 4 + 1);
808 strcpy (newargs
, args
);
809 strcat (newargs
, ".dll");
813 safe_symbol_file_add (args
, from_tty
, NULL
, 0, OBJF_SHARED
| OBJF_USERLOADED
);
816 /* Handle DEBUG_STRING output from child process.
817 Cygwin prepends its messages with a "cygwin:". Interpret this as
818 a Cygwin signal. Otherwise just print the string as a warning. */
820 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
825 if (!target_read_string
826 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
830 else if (strncmp (s
, _CYGWIN_SIGNAL_STRING
, sizeof (_CYGWIN_SIGNAL_STRING
) - 1) != 0)
833 if (strncmp (s
, "cYg", 3) != 0)
837 #ifdef __COPY_CONTEXT_SIZE
840 /* Got a cygwin signal marker. A cygwin signal is followed by the signal number
841 itself and then optionally followed by the thread id and address to saved context
842 within the DLL. If these are supplied, then the given thread is assumed to have
843 issued the signal and the context from the thread is assumed to be stored at the
844 given address in the inferior. Tell gdb to treat this like a real signal. */
846 int sig
= strtol (s
+ sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
847 int gotasig
= target_signal_from_host (sig
);
848 ourstatus
->value
.sig
= gotasig
;
853 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
854 retval
= strtoul (p
, &p
, 0);
856 retval
= main_thread_id
;
857 else if ((x
= (LPCVOID
) strtoul (p
, &p
, 0))
858 && ReadProcessMemory (current_process_handle
, x
,
859 &saved_context
, __COPY_CONTEXT_SIZE
, &n
)
860 && n
== __COPY_CONTEXT_SIZE
)
861 have_saved_context
= 1;
862 current_event
.dwThreadId
= retval
;
873 display_selector (HANDLE thread
, DWORD sel
)
876 if (GetThreadSelectorEntry (thread
, sel
, &info
))
879 printf_filtered ("0x%03lx: ", sel
);
880 if (!info
.HighWord
.Bits
.Pres
)
882 puts_filtered ("Segment not present\n");
885 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
886 (info
.HighWord
.Bits
.BaseMid
<< 16)
888 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
889 if (info
.HighWord
.Bits
.Granularity
)
890 limit
= (limit
<< 12) | 0xfff;
891 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
892 if (info
.HighWord
.Bits
.Default_Big
)
893 puts_filtered(" 32-bit ");
895 puts_filtered(" 16-bit ");
896 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
899 puts_filtered ("Data (Read-Only, Exp-up");
902 puts_filtered ("Data (Read/Write, Exp-up");
905 puts_filtered ("Unused segment (");
908 puts_filtered ("Data (Read/Write, Exp-down");
911 puts_filtered ("Code (Exec-Only, N.Conf");
914 puts_filtered ("Code (Exec/Read, N.Conf");
917 puts_filtered ("Code (Exec-Only, Conf");
920 puts_filtered ("Code (Exec/Read, Conf");
923 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
925 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
926 puts_filtered(", N.Acc");
927 puts_filtered (")\n");
928 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
929 puts_filtered("System selector ");
930 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
931 if (info
.HighWord
.Bits
.Granularity
)
932 puts_filtered ("Page granular.\n");
934 puts_filtered ("Byte granular.\n");
939 printf_filtered ("Invalid selector 0x%lx.\n",sel
);
945 display_selectors (char * args
, int from_tty
)
949 puts_filtered ("Impossible to display selectors now.\n");
955 puts_filtered ("Selector $cs\n");
956 display_selector (current_thread
->h
,
957 current_thread
->context
.SegCs
);
958 puts_filtered ("Selector $ds\n");
959 display_selector (current_thread
->h
,
960 current_thread
->context
.SegDs
);
961 puts_filtered ("Selector $es\n");
962 display_selector (current_thread
->h
,
963 current_thread
->context
.SegEs
);
964 puts_filtered ("Selector $ss\n");
965 display_selector (current_thread
->h
,
966 current_thread
->context
.SegSs
);
967 puts_filtered ("Selector $fs\n");
968 display_selector (current_thread
->h
,
969 current_thread
->context
.SegFs
);
970 puts_filtered ("Selector $gs\n");
971 display_selector (current_thread
->h
,
972 current_thread
->context
.SegGs
);
977 sel
= parse_and_eval_long (args
);
978 printf_filtered ("Selector \"%s\"\n",args
);
979 display_selector (current_thread
->h
, sel
);
983 static struct cmd_list_element
*info_w32_cmdlist
= NULL
;
986 info_w32_command (char *args
, int from_tty
)
988 help_list (info_w32_cmdlist
, "info w32 ", class_info
, gdb_stdout
);
992 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
993 printf_unfiltered ("gdb: Target exception %s at 0x%08lx\n", x, \
994 (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress)
997 handle_exception (struct target_waitstatus
*ourstatus
)
1000 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1002 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1004 /* Record the context of the current thread */
1005 th
= thread_rec (current_event
.dwThreadId
, -1);
1009 case EXCEPTION_ACCESS_VIOLATION
:
1010 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1011 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1014 /* See if the access violation happened within the cygwin DLL itself. Cygwin uses
1015 a kind of exception handling to deal with passed-in invalid addresses. gdb
1016 should not treat these as real SEGVs since they will be silently handled by
1017 cygwin. A real SEGV will (theoretically) be caught by cygwin later in the process
1018 and will be sent as a cygwin-specific-signal. So, ignore SEGVs if they show up
1019 within the text segment of the DLL itself. */
1021 bfd_vma addr
= (bfd_vma
) (uintptr_t) current_event
.u
.Exception
.
1022 ExceptionRecord
.ExceptionAddress
;
1023 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
&& addr
< cygwin_load_end
))
1024 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1025 && strncmp (fn
, "KERNEL32!IsBad", strlen ("KERNEL32!IsBad")) == 0))
1030 case STATUS_STACK_OVERFLOW
:
1031 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1032 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1034 case STATUS_FLOAT_DENORMAL_OPERAND
:
1035 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1036 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1038 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1039 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1040 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1042 case STATUS_FLOAT_INEXACT_RESULT
:
1043 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1044 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1046 case STATUS_FLOAT_INVALID_OPERATION
:
1047 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1048 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1050 case STATUS_FLOAT_OVERFLOW
:
1051 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1052 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1054 case STATUS_FLOAT_STACK_CHECK
:
1055 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1056 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1058 case STATUS_FLOAT_UNDERFLOW
:
1059 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1060 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1062 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1063 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1064 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1066 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1067 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1068 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1070 case STATUS_INTEGER_OVERFLOW
:
1071 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1072 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1074 case EXCEPTION_BREAKPOINT
:
1075 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1076 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1079 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1080 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1082 case DBG_CONTROL_BREAK
:
1083 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1084 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1086 case EXCEPTION_SINGLE_STEP
:
1087 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1088 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1090 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1091 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1092 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1094 case EXCEPTION_PRIV_INSTRUCTION
:
1095 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1096 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1098 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1099 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1100 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1103 /* Treat unhandled first chance exceptions specially. */
1104 if (current_event
.u
.Exception
.dwFirstChance
)
1106 printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",
1107 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1108 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1109 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1113 last_sig
= ourstatus
->value
.sig
;
1117 /* Resume all artificially suspended threads if we are continuing
1120 win32_continue (DWORD continue_status
, int id
)
1126 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, %s);\n",
1127 current_event
.dwProcessId
, current_event
.dwThreadId
,
1128 continue_status
== DBG_CONTINUE
?
1129 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1131 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1132 if ((id
== -1 || id
== (int) th
->id
)
1135 if (debug_registers_changed
)
1137 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1138 th
->context
.Dr0
= dr
[0];
1139 th
->context
.Dr1
= dr
[1];
1140 th
->context
.Dr2
= dr
[2];
1141 th
->context
.Dr3
= dr
[3];
1142 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1143 th
->context
.Dr7
= dr
[7];
1145 if (th
->context
.ContextFlags
)
1147 CHECK (SetThreadContext (th
->h
, &th
->context
));
1148 th
->context
.ContextFlags
= 0;
1150 if (th
->suspended
> 0)
1151 (void) ResumeThread (th
->h
);
1155 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1156 current_event
.dwThreadId
,
1159 debug_registers_changed
= 0;
1163 /* Called in pathological case where Windows fails to send a
1164 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1166 fake_create_process (void)
1168 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1169 current_event
.dwProcessId
);
1170 if (current_process_handle
!= NULL
)
1171 open_process_used
= 1;
1174 error (_("OpenProcess call failed, GetLastError = %lud\n"),
1176 /* We can not debug anything in that case. */
1178 main_thread_id
= current_event
.dwThreadId
;
1179 current_thread
= win32_add_thread (main_thread_id
,
1180 current_event
.u
.CreateThread
.hThread
);
1181 return main_thread_id
;
1185 win32_resume (ptid_t ptid
, int step
, enum target_signal sig
)
1188 DWORD continue_status
= DBG_CONTINUE
;
1190 int pid
= PIDGET (ptid
);
1192 if (sig
!= TARGET_SIGNAL_0
)
1194 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1196 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1198 else if (sig
== last_sig
)
1199 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1202 /* This code does not seem to work, because
1203 the kernel does probably not consider changes in the ExceptionRecord
1204 structure when passing the exception to the inferior.
1205 Note that this seems possible in the exception handler itself. */
1208 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1209 if (xlate
[i
].us
== sig
)
1211 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
=
1213 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1216 if (continue_status
== DBG_CONTINUE
)
1218 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1222 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1226 last_sig
= TARGET_SIGNAL_0
;
1228 DEBUG_EXEC (("gdb: win32_resume (pid=%d, step=%d, sig=%d);\n",
1231 /* Get context for currently selected thread */
1232 th
= thread_rec (PIDGET (inferior_ptid
), FALSE
);
1237 /* Single step by setting t bit */
1238 win32_fetch_inferior_registers (get_current_regcache (),
1239 gdbarch_ps_regnum (current_gdbarch
));
1240 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1243 if (th
->context
.ContextFlags
)
1245 if (debug_registers_changed
)
1247 th
->context
.Dr0
= dr
[0];
1248 th
->context
.Dr1
= dr
[1];
1249 th
->context
.Dr2
= dr
[2];
1250 th
->context
.Dr3
= dr
[3];
1251 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1252 th
->context
.Dr7
= dr
[7];
1254 CHECK (SetThreadContext (th
->h
, &th
->context
));
1255 th
->context
.ContextFlags
= 0;
1259 /* Allow continuing with the same signal that interrupted us.
1260 Otherwise complain. */
1262 win32_continue (continue_status
, pid
);
1265 /* Get the next event from the child. Return 1 if the event requires
1266 handling by WFI (or whatever).
1269 get_win32_debug_event (int pid
, struct target_waitstatus
*ourstatus
)
1272 DWORD continue_status
, event_code
;
1274 static thread_info dummy_thread_info
;
1278 last_sig
= TARGET_SIGNAL_0
;
1280 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1284 continue_status
= DBG_CONTINUE
;
1286 event_code
= current_event
.dwDebugEventCode
;
1287 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1289 have_saved_context
= 0;
1293 case CREATE_THREAD_DEBUG_EVENT
:
1294 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1295 (unsigned) current_event
.dwProcessId
,
1296 (unsigned) current_event
.dwThreadId
,
1297 "CREATE_THREAD_DEBUG_EVENT"));
1298 if (saw_create
!= 1)
1300 if (!saw_create
&& attach_flag
)
1302 /* Kludge around a Windows bug where first event is a create
1303 thread event. Caused when attached process does not have
1305 retval
= ourstatus
->value
.related_pid
= fake_create_process ();
1311 /* Record the existence of this thread */
1312 th
= win32_add_thread (current_event
.dwThreadId
,
1313 current_event
.u
.CreateThread
.hThread
);
1315 printf_unfiltered ("[New %s]\n",
1317 pid_to_ptid (current_event
.dwThreadId
)));
1318 retval
= current_event
.dwThreadId
;
1321 case EXIT_THREAD_DEBUG_EVENT
:
1322 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1323 (unsigned) current_event
.dwProcessId
,
1324 (unsigned) current_event
.dwThreadId
,
1325 "EXIT_THREAD_DEBUG_EVENT"));
1326 if (current_event
.dwThreadId
!= main_thread_id
)
1328 win32_delete_thread (current_event
.dwThreadId
);
1329 th
= &dummy_thread_info
;
1333 case CREATE_PROCESS_DEBUG_EVENT
:
1334 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1335 (unsigned) current_event
.dwProcessId
,
1336 (unsigned) current_event
.dwThreadId
,
1337 "CREATE_PROCESS_DEBUG_EVENT"));
1338 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1339 if (++saw_create
!= 1)
1342 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1344 win32_delete_thread (main_thread_id
);
1345 main_thread_id
= current_event
.dwThreadId
;
1346 /* Add the main thread */
1347 th
= win32_add_thread (main_thread_id
,
1348 current_event
.u
.CreateProcessInfo
.hThread
);
1349 retval
= ourstatus
->value
.related_pid
= current_event
.dwThreadId
;
1352 case EXIT_PROCESS_DEBUG_EVENT
:
1353 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1354 (unsigned) current_event
.dwProcessId
,
1355 (unsigned) current_event
.dwThreadId
,
1356 "EXIT_PROCESS_DEBUG_EVENT"));
1357 if (saw_create
!= 1)
1359 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1360 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1361 retval
= main_thread_id
;
1364 case LOAD_DLL_DEBUG_EVENT
:
1365 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1366 (unsigned) current_event
.dwProcessId
,
1367 (unsigned) current_event
.dwThreadId
,
1368 "LOAD_DLL_DEBUG_EVENT"));
1369 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1370 if (saw_create
!= 1)
1372 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1373 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1374 ourstatus
->value
.integer
= 0;
1375 retval
= main_thread_id
;
1378 case UNLOAD_DLL_DEBUG_EVENT
:
1379 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1380 (unsigned) current_event
.dwProcessId
,
1381 (unsigned) current_event
.dwThreadId
,
1382 "UNLOAD_DLL_DEBUG_EVENT"));
1383 if (saw_create
!= 1)
1385 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1386 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1387 ourstatus
->value
.integer
= 0;
1388 retval
= main_thread_id
;
1391 case EXCEPTION_DEBUG_EVENT
:
1392 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1393 (unsigned) current_event
.dwProcessId
,
1394 (unsigned) current_event
.dwThreadId
,
1395 "EXCEPTION_DEBUG_EVENT"));
1396 if (saw_create
!= 1)
1398 switch (handle_exception (ourstatus
))
1401 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1404 retval
= current_event
.dwThreadId
;
1408 continue_status
= -1;
1413 case OUTPUT_DEBUG_STRING_EVENT
: /* message from the kernel */
1414 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1415 (unsigned) current_event
.dwProcessId
,
1416 (unsigned) current_event
.dwThreadId
,
1417 "OUTPUT_DEBUG_STRING_EVENT"));
1418 if (saw_create
!= 1)
1420 retval
= handle_output_debug_string (ourstatus
);
1424 if (saw_create
!= 1)
1426 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1427 (DWORD
) current_event
.dwProcessId
,
1428 (DWORD
) current_event
.dwThreadId
);
1429 printf_unfiltered (" unknown event code %ld\n",
1430 current_event
.dwDebugEventCode
);
1434 if (!retval
|| saw_create
!= 1)
1436 if (continue_status
== -1)
1437 win32_resume (ptid
, 0, 1);
1439 CHECK (win32_continue (continue_status
, -1));
1443 inferior_ptid
= pid_to_ptid (retval
);
1444 current_thread
= th
?: thread_rec (current_event
.dwThreadId
, TRUE
);
1451 /* Wait for interesting events to occur in the target process. */
1453 win32_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
1455 int pid
= PIDGET (ptid
);
1457 target_terminal_ours ();
1459 /* We loop when we get a non-standard exception rather than return
1460 with a SPURIOUS because resume can try and step or modify things,
1461 which needs a current_thread->h. But some of these exceptions mark
1462 the birth or death of threads, which mean that the current thread
1463 isn't necessarily what you think it is. */
1467 int retval
= get_win32_debug_event (pid
, ourstatus
);
1469 return pid_to_ptid (retval
);
1474 if (deprecated_ui_loop_hook
!= NULL
)
1475 detach
= deprecated_ui_loop_hook (0);
1478 win32_kill_inferior ();
1484 do_initial_win32_stuff (DWORD pid
)
1486 extern int stop_after_trap
;
1489 last_sig
= TARGET_SIGNAL_0
;
1491 exception_count
= 0;
1492 open_process_used
= 0;
1493 debug_registers_changed
= 0;
1494 debug_registers_used
= 0;
1495 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1498 cygwin_load_start
= cygwin_load_end
= 0;
1500 current_event
.dwProcessId
= pid
;
1501 memset (¤t_event
, 0, sizeof (current_event
));
1502 push_target (&win32_ops
);
1503 disable_breakpoints_in_shlibs ();
1504 win32_clear_solib ();
1505 clear_proceed_status ();
1506 init_wait_for_inferior ();
1508 terminal_init_inferior_with_pgrp (pid
);
1509 target_terminal_inferior ();
1513 stop_after_trap
= 1;
1514 wait_for_inferior ();
1515 if (stop_signal
!= TARGET_SIGNAL_TRAP
)
1516 resume (0, stop_signal
);
1520 stop_after_trap
= 0;
1524 /* Since Windows XP, detaching from a process is supported by Windows.
1525 The following code tries loading the appropriate functions dynamically.
1526 If loading these functions succeeds use them to actually detach from
1527 the inferior process, otherwise behave as usual, pretending that
1528 detach has worked. */
1529 static BOOL
WINAPI (*DebugSetProcessKillOnExit
)(BOOL
);
1530 static BOOL
WINAPI (*DebugActiveProcessStop
)(DWORD
);
1533 has_detach_ability (void)
1535 static HMODULE kernel32
= NULL
;
1538 kernel32
= LoadLibrary ("kernel32.dll");
1541 if (!DebugSetProcessKillOnExit
)
1542 DebugSetProcessKillOnExit
= GetProcAddress (kernel32
,
1543 "DebugSetProcessKillOnExit");
1544 if (!DebugActiveProcessStop
)
1545 DebugActiveProcessStop
= GetProcAddress (kernel32
,
1546 "DebugActiveProcessStop");
1547 if (DebugSetProcessKillOnExit
&& DebugActiveProcessStop
)
1553 /* Try to set or remove a user privilege to the current process. Return -1
1554 if that fails, the previous setting of that privilege otherwise.
1556 This code is copied from the Cygwin source code and rearranged to allow
1557 dynamically loading of the needed symbols from advapi32 which is only
1558 available on NT/2K/XP. */
1560 set_process_privilege (const char *privilege
, BOOL enable
)
1562 static HMODULE advapi32
= NULL
;
1563 static BOOL
WINAPI (*OpenProcessToken
)(HANDLE
, DWORD
, PHANDLE
);
1564 static BOOL
WINAPI (*LookupPrivilegeValue
)(LPCSTR
, LPCSTR
, PLUID
);
1565 static BOOL
WINAPI (*AdjustTokenPrivileges
)(HANDLE
, BOOL
, PTOKEN_PRIVILEGES
,
1566 DWORD
, PTOKEN_PRIVILEGES
, PDWORD
);
1568 HANDLE token_hdl
= NULL
;
1570 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1574 if (GetVersion () >= 0x80000000) /* No security availbale on 9x/Me */
1579 if (!(advapi32
= LoadLibrary ("advapi32.dll")))
1581 if (!OpenProcessToken
)
1582 OpenProcessToken
= GetProcAddress (advapi32
, "OpenProcessToken");
1583 if (!LookupPrivilegeValue
)
1584 LookupPrivilegeValue
= GetProcAddress (advapi32
,
1585 "LookupPrivilegeValueA");
1586 if (!AdjustTokenPrivileges
)
1587 AdjustTokenPrivileges
= GetProcAddress (advapi32
,
1588 "AdjustTokenPrivileges");
1589 if (!OpenProcessToken
|| !LookupPrivilegeValue
|| !AdjustTokenPrivileges
)
1596 if (!OpenProcessToken (GetCurrentProcess (),
1597 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1601 if (!LookupPrivilegeValue (NULL
, privilege
, &restore_priv
))
1604 new_priv
.PrivilegeCount
= 1;
1605 new_priv
.Privileges
[0].Luid
= restore_priv
;
1606 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1608 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1609 sizeof orig_priv
, &orig_priv
, &size
))
1612 /* Disabled, otherwise every `attach' in an unprivileged user session
1613 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1615 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1616 be enabled. GetLastError () returns an correct error code, though. */
1617 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1621 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1625 CloseHandle (token_hdl
);
1630 /* Attach to process PID, then initialize for debugging it. */
1632 win32_attach (char *args
, int from_tty
)
1638 error_no_arg (_("process-id to attach"));
1640 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1642 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1643 printf_unfiltered ("This can cause attach to fail on Windows NT/2K/XP\n");
1646 pid
= strtoul (args
, 0, 0); /* Windows pid */
1648 win32_init_thread_list ();
1649 ok
= DebugActiveProcess (pid
);
1655 /* Try fall back to Cygwin pid */
1656 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1659 ok
= DebugActiveProcess (pid
);
1664 error (_("Can't attach to process."));
1666 if (has_detach_ability ())
1667 DebugSetProcessKillOnExit (FALSE
);
1673 char *exec_file
= (char *) get_exec_file (0);
1676 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1677 target_pid_to_str (pid_to_ptid (pid
)));
1679 printf_unfiltered ("Attaching to %s\n",
1680 target_pid_to_str (pid_to_ptid (pid
)));
1682 gdb_flush (gdb_stdout
);
1685 do_initial_win32_stuff (pid
);
1686 target_terminal_ours ();
1690 win32_detach (char *args
, int from_tty
)
1694 if (has_detach_ability ())
1697 win32_resume (ptid
, 0, TARGET_SIGNAL_0
);
1699 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1701 error (_("Can't detach process %lu (error %lu)"),
1702 current_event
.dwProcessId
, GetLastError ());
1705 DebugSetProcessKillOnExit (FALSE
);
1707 if (detached
&& from_tty
)
1709 char *exec_file
= get_exec_file (0);
1712 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file
,
1713 current_event
.dwProcessId
);
1714 gdb_flush (gdb_stdout
);
1716 inferior_ptid
= null_ptid
;
1717 unpush_target (&win32_ops
);
1721 win32_pid_to_exec_file (int pid
)
1723 static char path
[MAX_PATH
+ 1];
1726 /* Try to find exe name as symlink target of /proc/<pid>/exe */
1728 char procexe
[sizeof ("/proc/4294967295/exe")];
1729 sprintf (procexe
, "/proc/%lu/exe", current_event
.dwProcessId
);
1730 nchars
= readlink (procexe
, path
, sizeof(path
));
1731 if (nchars
> 0 && nchars
< sizeof (path
))
1733 path
[nchars
] = '\0'; /* Got it */
1738 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
1739 of gdb, or we're trying to debug a non-Cygwin windows executable. */
1740 if (!get_module_name (0, path
))
1746 /* Print status information about what we're accessing. */
1749 win32_files_info (struct target_ops
*ignore
)
1751 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1752 attach_flag
? "attached" : "child", target_pid_to_str (inferior_ptid
));
1756 win32_open (char *arg
, int from_tty
)
1758 error (_("Use the \"run\" command to start a Unix child process."));
1761 /* Start an inferior win32 child process and sets inferior_ptid to its pid.
1762 EXEC_FILE is the file to run.
1763 ALLARGS is a string containing the arguments to the program.
1764 ENV is the environment vector to pass. Errors reported with error(). */
1767 win32_create_inferior (char *exec_file
, char *allargs
, char **in_env
,
1771 PROCESS_INFORMATION pi
;
1775 char real_path
[MAXPATHLEN
];
1777 char shell
[MAX_PATH
+ 1]; /* Path to shell */
1780 int ostdin
, ostdout
, ostderr
;
1781 const char *inferior_io_terminal
= get_inferior_io_terminal ();
1784 error (_("No executable specified, use `target exec'."));
1786 memset (&si
, 0, sizeof (si
));
1787 si
.cb
= sizeof (si
);
1792 flags
= DEBUG_ONLY_THIS_PROCESS
;
1793 cygwin_conv_to_win32_path (exec_file
, real_path
);
1799 sh
= getenv ("SHELL");
1802 cygwin_conv_to_win32_path (sh
, shell
);
1803 newallargs
= alloca (sizeof (" -c 'exec '") + strlen (exec_file
)
1804 + strlen (allargs
) + 2);
1805 sprintf (newallargs
, " -c 'exec %s %s'", exec_file
, allargs
);
1806 allargs
= newallargs
;
1808 flags
= DEBUG_PROCESS
;
1812 flags
= DEBUG_ONLY_THIS_PROCESS
;
1816 flags
|= CREATE_NEW_PROCESS_GROUP
;
1819 flags
|= CREATE_NEW_CONSOLE
;
1823 args
= alloca (strlen (toexec
) + strlen (allargs
) + 2);
1824 strcpy (args
, toexec
);
1826 strcat (args
, allargs
);
1829 /* Prepare the environment vars for CreateProcess. */
1830 cygwin_internal (CW_SYNC_WINENV
);
1832 if (!inferior_io_terminal
)
1833 tty
= ostdin
= ostdout
= ostderr
= -1;
1836 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
1839 print_sys_errmsg (inferior_io_terminal
, errno
);
1840 ostdin
= ostdout
= ostderr
= -1;
1854 win32_init_thread_list ();
1855 ret
= CreateProcess (0,
1856 args
, /* command line */
1857 NULL
, /* Security */
1859 TRUE
, /* inherit handles */
1860 flags
, /* start flags */
1861 NULL
, /* environment */
1862 NULL
, /* current directory */
1880 error (_("Error creating process %s, (error %d)."),
1881 exec_file
, (unsigned) GetLastError ());
1883 CloseHandle (pi
.hThread
);
1884 CloseHandle (pi
.hProcess
);
1886 if (useshell
&& shell
[0] != '\0')
1891 do_initial_win32_stuff (pi
.dwProcessId
);
1893 /* win32_continue (DBG_CONTINUE, -1); */
1897 win32_mourn_inferior (void)
1899 (void) win32_continue (DBG_CONTINUE
, -1);
1900 i386_cleanup_dregs();
1901 if (open_process_used
)
1903 CHECK (CloseHandle (current_process_handle
));
1904 open_process_used
= 0;
1906 unpush_target (&win32_ops
);
1907 generic_mourn_inferior ();
1910 /* Send a SIGINT to the process group. This acts just like the user typed a
1911 ^C on the controlling terminal. */
1916 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1917 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
1918 registers_changed (); /* refresh register state */
1922 win32_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*our
, int len
,
1923 int write
, struct mem_attrib
*mem
,
1924 struct target_ops
*target
)
1929 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1930 len
, (DWORD
) (uintptr_t) memaddr
));
1931 if (!WriteProcessMemory (current_process_handle
,
1932 (LPVOID
) (uintptr_t) memaddr
, our
,
1935 FlushInstructionCache (current_process_handle
,
1936 (LPCVOID
) (uintptr_t) memaddr
, len
);
1940 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
1941 len
, (DWORD
) (uintptr_t) memaddr
));
1942 if (!ReadProcessMemory (current_process_handle
,
1943 (LPCVOID
) (uintptr_t) memaddr
, our
,
1951 win32_kill_inferior (void)
1953 CHECK (TerminateProcess (current_process_handle
, 0));
1957 if (!win32_continue (DBG_CONTINUE
, -1))
1959 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
1961 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
1965 target_mourn_inferior (); /* or just win32_mourn_inferior? */
1969 win32_prepare_to_store (struct regcache
*regcache
)
1971 /* Do nothing, since we can store individual regs */
1975 win32_can_run (void)
1983 DEBUG_EVENTS (("gdb: win32_close, inferior_ptid=%d\n",
1984 PIDGET (inferior_ptid
)));
1987 /* Convert pid to printable format. */
1989 win32_pid_to_str (ptid_t ptid
)
1991 static char buf
[80];
1992 int pid
= PIDGET (ptid
);
1994 if ((DWORD
) pid
== current_event
.dwProcessId
)
1995 sprintf (buf
, "process %d", pid
);
1997 sprintf (buf
, "thread %ld.0x%x", current_event
.dwProcessId
, pid
);
2002 win32_xfer_shared_libraries (struct target_ops
*ops
,
2003 enum target_object object
, const char *annex
,
2004 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2005 ULONGEST offset
, LONGEST len
)
2007 struct obstack obstack
;
2015 obstack_init (&obstack
);
2016 obstack_grow_str (&obstack
, "<library-list>\n");
2017 for (so
= solib_start
.next
; so
; so
= so
->next
)
2018 win32_xfer_shared_library (so
->so_name
, so
->lm_info
->load_addr
, &obstack
);
2019 obstack_grow_str0 (&obstack
, "</library-list>\n");
2021 buf
= obstack_finish (&obstack
);
2022 len_avail
= strlen (buf
);
2023 if (offset
>= len_avail
)
2026 if (len
> len_avail
- offset
)
2027 len
= len_avail
- offset
;
2028 memcpy (readbuf
, buf
+ offset
, len
);
2030 obstack_free (&obstack
, NULL
);
2035 win32_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2036 const char *annex
, gdb_byte
*readbuf
,
2037 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
2041 case TARGET_OBJECT_MEMORY
:
2043 return (*ops
->deprecated_xfer_memory
) (offset
, readbuf
,
2044 len
, 0/*write*/, NULL
, ops
);
2046 return (*ops
->deprecated_xfer_memory
) (offset
, (gdb_byte
*) writebuf
,
2047 len
, 1/*write*/, NULL
, ops
);
2050 case TARGET_OBJECT_LIBRARIES
:
2051 return win32_xfer_shared_libraries (ops
, object
, annex
, readbuf
,
2052 writebuf
, offset
, len
);
2055 if (ops
->beneath
!= NULL
)
2056 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2057 readbuf
, writebuf
, offset
, len
);
2063 init_win32_ops (void)
2065 win32_ops
.to_shortname
= "child";
2066 win32_ops
.to_longname
= "Win32 child process";
2067 win32_ops
.to_doc
= "Win32 child process (started by the \"run\" command).";
2068 win32_ops
.to_open
= win32_open
;
2069 win32_ops
.to_close
= win32_close
;
2070 win32_ops
.to_attach
= win32_attach
;
2071 win32_ops
.to_detach
= win32_detach
;
2072 win32_ops
.to_resume
= win32_resume
;
2073 win32_ops
.to_wait
= win32_wait
;
2074 win32_ops
.to_fetch_registers
= win32_fetch_inferior_registers
;
2075 win32_ops
.to_store_registers
= win32_store_inferior_registers
;
2076 win32_ops
.to_prepare_to_store
= win32_prepare_to_store
;
2077 win32_ops
.deprecated_xfer_memory
= win32_xfer_memory
;
2078 win32_ops
.to_xfer_partial
= win32_xfer_partial
;
2079 win32_ops
.to_files_info
= win32_files_info
;
2080 win32_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
2081 win32_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
2082 win32_ops
.to_terminal_init
= terminal_init_inferior
;
2083 win32_ops
.to_terminal_inferior
= terminal_inferior
;
2084 win32_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
2085 win32_ops
.to_terminal_ours
= terminal_ours
;
2086 win32_ops
.to_terminal_save_ours
= terminal_save_ours
;
2087 win32_ops
.to_terminal_info
= child_terminal_info
;
2088 win32_ops
.to_kill
= win32_kill_inferior
;
2089 win32_ops
.to_create_inferior
= win32_create_inferior
;
2090 win32_ops
.to_mourn_inferior
= win32_mourn_inferior
;
2091 win32_ops
.to_can_run
= win32_can_run
;
2092 win32_ops
.to_thread_alive
= win32_win32_thread_alive
;
2093 win32_ops
.to_pid_to_str
= win32_pid_to_str
;
2094 win32_ops
.to_stop
= win32_stop
;
2095 win32_ops
.to_stratum
= process_stratum
;
2096 win32_ops
.to_has_all_memory
= 1;
2097 win32_ops
.to_has_memory
= 1;
2098 win32_ops
.to_has_stack
= 1;
2099 win32_ops
.to_has_registers
= 1;
2100 win32_ops
.to_has_execution
= 1;
2101 win32_ops
.to_magic
= OPS_MAGIC
;
2102 win32_ops
.to_pid_to_exec_file
= win32_pid_to_exec_file
;
2106 set_win32_aliases (char *argv0
)
2108 add_info_alias ("dll", "sharedlibrary", 1);
2112 _initialize_win32_nat (void)
2114 struct cmd_list_element
*c
;
2118 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
2119 _("Load dll library symbols from FILE."));
2120 set_cmd_completer (c
, filename_completer
);
2122 add_com_alias ("sharedlibrary", "dll-symbols", class_alias
, 1);
2125 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
2126 Set use of shell to start subprocess."), _("\
2127 Show use of shell to start subprocess."), NULL
,
2129 NULL
, /* FIXME: i18n: */
2130 &setlist
, &showlist
);
2132 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
, &cygwin_exceptions
, _("\
2133 Break when an exception is detected in the Cygwin DLL itself."), _("\
2134 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
2136 NULL
, /* FIXME: i18n: */
2137 &setlist
, &showlist
);
2140 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
2141 Set creation of new console when creating child process."), _("\
2142 Show creation of new console when creating child process."), NULL
,
2144 NULL
, /* FIXME: i18n: */
2145 &setlist
, &showlist
);
2147 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
2148 Set creation of new group when creating child process."), _("\
2149 Show creation of new group when creating child process."), NULL
,
2151 NULL
, /* FIXME: i18n: */
2152 &setlist
, &showlist
);
2154 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
2155 Set whether to display execution in child process."), _("\
2156 Show whether to display execution in child process."), NULL
,
2158 NULL
, /* FIXME: i18n: */
2159 &setlist
, &showlist
);
2161 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
2162 Set whether to display kernel events in child process."), _("\
2163 Show whether to display kernel events in child process."), NULL
,
2165 NULL
, /* FIXME: i18n: */
2166 &setlist
, &showlist
);
2168 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
2169 Set whether to display memory accesses in child process."), _("\
2170 Show whether to display memory accesses in child process."), NULL
,
2172 NULL
, /* FIXME: i18n: */
2173 &setlist
, &showlist
);
2175 add_setshow_boolean_cmd ("debugexceptions", class_support
,
2176 &debug_exceptions
, _("\
2177 Set whether to display kernel exceptions in child process."), _("\
2178 Show whether to display kernel exceptions in child process."), NULL
,
2180 NULL
, /* FIXME: i18n: */
2181 &setlist
, &showlist
);
2183 add_prefix_cmd ("w32", class_info
, info_w32_command
,
2184 _("Print information specific to Win32 debugging."),
2185 &info_w32_cmdlist
, "info w32 ", 0, &infolist
);
2187 add_cmd ("selector", class_info
, display_selectors
,
2188 _("Display selectors infos."),
2190 add_target (&win32_ops
);
2191 deprecated_init_ui_hook
= set_win32_aliases
;
2194 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2196 /* Pass the address ADDR to the inferior in the I'th debug register.
2197 Here we just store the address in dr array, the registers will be
2198 actually set up when win32_continue is called. */
2200 cygwin_set_dr (int i
, CORE_ADDR addr
)
2203 internal_error (__FILE__
, __LINE__
,
2204 _("Invalid register %d in cygwin_set_dr.\n"), i
);
2205 dr
[i
] = (unsigned) addr
;
2206 debug_registers_changed
= 1;
2207 debug_registers_used
= 1;
2210 /* Pass the value VAL to the inferior in the DR7 debug control
2211 register. Here we just store the address in D_REGS, the watchpoint
2212 will be actually set up in win32_wait. */
2214 cygwin_set_dr7 (unsigned val
)
2217 debug_registers_changed
= 1;
2218 debug_registers_used
= 1;
2221 /* Get the value of the DR6 debug status register from the inferior.
2222 Here we just return the value stored in dr[6]
2223 by the last call to thread_rec for current_event.dwThreadId id. */
2225 cygwin_get_dr6 (void)
2230 /* Determine if the thread referenced by "pid" is alive
2231 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2232 it means that the pid has died. Otherwise it is assumed to be alive. */
2234 win32_win32_thread_alive (ptid_t ptid
)
2236 int pid
= PIDGET (ptid
);
2238 return WaitForSingleObject (thread_rec (pid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
?
2243 _initialize_check_for_gdb_ini (void)
2246 if (inhibit_gdbinit
)
2249 homedir
= getenv ("HOME");
2253 char *oldini
= (char *) alloca (strlen (homedir
) +
2254 sizeof ("/gdb.ini"));
2255 strcpy (oldini
, homedir
);
2256 p
= strchr (oldini
, '\0');
2257 if (p
> oldini
&& p
[-1] != '/')
2259 strcpy (p
, "gdb.ini");
2260 if (access (oldini
, 0) == 0)
2262 int len
= strlen (oldini
);
2263 char *newini
= alloca (len
+ 1);
2264 sprintf (newini
, "%.*s.gdbinit",
2265 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
2266 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
2272 _initialize_psapi (void)
2274 /* Load optional functions used for retrieving filename information
2275 associated with the currently debugged process or its dlls. */
2278 HMODULE psapi_module_handle
;
2282 psapi_module_handle
= LoadLibrary ("psapi.dll");
2283 if (psapi_module_handle
)
2285 psapi_EnumProcessModules
= (void *) GetProcAddress (psapi_module_handle
, "EnumProcessModules");
2286 psapi_GetModuleInformation
= (void *) GetProcAddress (psapi_module_handle
, "GetModuleInformation");
2287 psapi_GetModuleFileNameExA
= (void *) GetProcAddress (psapi_module_handle
, "GetModuleFileNameExA");
2289 if (psapi_EnumProcessModules
!= NULL
2290 && psapi_GetModuleInformation
!= NULL
2291 && psapi_GetModuleFileNameExA
!= NULL
)
2296 /* This will probably fail on Windows 9x/Me. Let the user know that we're
2297 missing some functionality. */
2298 if (psapi_loaded
< 0)
2299 warning(_("cannot automatically find executable file or library to read symbols. Use \"file\" or \"dll\" command to load executable/libraries directly."));