1 /* Target-vector operations for controlling windows child processes, for GDB.
3 Copyright (C) 1995-2014 Free Software Foundation, Inc.
5 Contributed by Cygnus Solutions, A Red Hat Company.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 /* Originally by Steve Chamberlain, sac@cygnus.com */
25 #include "frame.h" /* required by inferior.h */
28 #include "exceptions.h"
31 #include "completer.h"
35 #include <sys/types.h>
43 #include <sys/cygwin.h>
44 #include <cygwin/version.h>
48 #include "filenames.h"
52 #include "gdb_obstack.h"
54 #include "gdbthread.h"
60 #include "xml-support.h"
62 #include "i386-tdep.h"
63 #include "i387-tdep.h"
65 #include "windows-tdep.h"
66 #include "windows-nat.h"
68 #include "complaints.h"
69 #include "inf-child.h"
71 #define AdjustTokenPrivileges dyn_AdjustTokenPrivileges
72 #define DebugActiveProcessStop dyn_DebugActiveProcessStop
73 #define DebugBreakProcess dyn_DebugBreakProcess
74 #define DebugSetProcessKillOnExit dyn_DebugSetProcessKillOnExit
75 #define EnumProcessModules dyn_EnumProcessModules
76 #define GetModuleInformation dyn_GetModuleInformation
77 #define LookupPrivilegeValueA dyn_LookupPrivilegeValueA
78 #define OpenProcessToken dyn_OpenProcessToken
79 #define GetConsoleFontSize dyn_GetConsoleFontSize
80 #define GetCurrentConsoleFont dyn_GetCurrentConsoleFont
82 static BOOL
WINAPI (*AdjustTokenPrivileges
)(HANDLE
, BOOL
, PTOKEN_PRIVILEGES
,
83 DWORD
, PTOKEN_PRIVILEGES
, PDWORD
);
84 static BOOL
WINAPI (*DebugActiveProcessStop
) (DWORD
);
85 static BOOL
WINAPI (*DebugBreakProcess
) (HANDLE
);
86 static BOOL
WINAPI (*DebugSetProcessKillOnExit
) (BOOL
);
87 static BOOL
WINAPI (*EnumProcessModules
) (HANDLE
, HMODULE
*, DWORD
,
89 static BOOL
WINAPI (*GetModuleInformation
) (HANDLE
, HMODULE
, LPMODULEINFO
,
91 static BOOL
WINAPI (*LookupPrivilegeValueA
)(LPCSTR
, LPCSTR
, PLUID
);
92 static BOOL
WINAPI (*OpenProcessToken
)(HANDLE
, DWORD
, PHANDLE
);
93 static BOOL
WINAPI (*GetCurrentConsoleFont
) (HANDLE
, BOOL
,
95 static COORD
WINAPI (*GetConsoleFontSize
) (HANDLE
, DWORD
);
99 #undef GetModuleFileNameEx
102 # define __PMAX (MAX_PATH + 1)
103 static DWORD
WINAPI (*GetModuleFileNameEx
) (HANDLE
, HMODULE
, LPSTR
, DWORD
);
104 # define STARTUPINFO STARTUPINFOA
105 # define CreateProcess CreateProcessA
106 # define GetModuleFileNameEx_name "GetModuleFileNameExA"
107 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
109 # define __PMAX PATH_MAX
110 /* The starting and ending address of the cygwin1.dll text segment. */
111 static CORE_ADDR cygwin_load_start
;
112 static CORE_ADDR cygwin_load_end
;
114 typedef wchar_t cygwin_buf_t
;
115 static DWORD
WINAPI (*GetModuleFileNameEx
) (HANDLE
, HMODULE
,
117 # define STARTUPINFO STARTUPINFOW
118 # define CreateProcess CreateProcessW
119 # define GetModuleFileNameEx_name "GetModuleFileNameExW"
120 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExW
123 static int have_saved_context
; /* True if we've saved context from a
125 static CONTEXT saved_context
; /* Containes the saved context from a
128 /* If we're not using the old Cygwin header file set, define the
129 following which never should have been in the generic Win32 API
130 headers in the first place since they were our own invention... */
131 #ifndef _GNU_H_WINDOWS_H
134 FLAG_TRACE_BIT
= 0x100,
135 CONTEXT_DEBUGGER
= (CONTEXT_FULL
| CONTEXT_FLOATING_POINT
)
139 #ifndef CONTEXT_EXTENDED_REGISTERS
140 /* This macro is only defined on ia32. It only makes sense on this target,
141 so define it as zero if not already defined. */
142 #define CONTEXT_EXTENDED_REGISTERS 0
145 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \
146 | CONTEXT_EXTENDED_REGISTERS
148 static uintptr_t dr
[8];
149 static int debug_registers_changed
;
150 static int debug_registers_used
;
152 static int windows_initialization_done
;
153 #define DR6_CLEAR_VALUE 0xffff0ff0
155 /* The string sent by cygwin when it processes a signal.
156 FIXME: This should be in a cygwin include file. */
157 #ifndef _CYGWIN_SIGNAL_STRING
158 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
161 #define CHECK(x) check (x, __FILE__,__LINE__)
162 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
163 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
164 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
165 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
167 static void windows_stop (struct target_ops
*self
, ptid_t
);
168 static int windows_thread_alive (struct target_ops
*, ptid_t
);
169 static void windows_kill_inferior (struct target_ops
*);
171 static void cygwin_set_dr (int i
, CORE_ADDR addr
);
172 static void cygwin_set_dr7 (unsigned long val
);
173 static CORE_ADDR
cygwin_get_dr (int i
);
174 static unsigned long cygwin_get_dr6 (void);
175 static unsigned long cygwin_get_dr7 (void);
177 static enum gdb_signal last_sig
= GDB_SIGNAL_0
;
178 /* Set if a signal was received from the debugged process. */
180 /* Thread information structure used to track information that is
181 not available in gdb's thread structure. */
182 typedef struct thread_info_struct
184 struct thread_info_struct
*next
;
187 CORE_ADDR thread_local_base
;
196 static thread_info thread_head
;
198 /* The process and thread handles for the above context. */
200 static DEBUG_EVENT current_event
; /* The current debug event from
202 static HANDLE current_process_handle
; /* Currently executing process */
203 static thread_info
*current_thread
; /* Info on currently selected thread */
204 static DWORD main_thread_id
; /* Thread ID of the main thread */
206 /* Counts of things. */
207 static int exception_count
= 0;
208 static int event_count
= 0;
209 static int saw_create
;
210 static int open_process_used
= 0;
213 static int new_console
= 0;
215 static int cygwin_exceptions
= 0;
217 static int new_group
= 1;
218 static int debug_exec
= 0; /* show execution */
219 static int debug_events
= 0; /* show events from kernel */
220 static int debug_memory
= 0; /* show target memory accesses */
221 static int debug_exceptions
= 0; /* show target exceptions */
222 static int useshell
= 0; /* use shell for subprocesses */
224 /* This vector maps GDB's idea of a register's number into an offset
225 in the windows exception context vector.
227 It also contains the bit mask needed to load the register in question.
229 The contents of this table can only be computed by the units
230 that provide CPU-specific support for Windows native debugging.
231 These units should set the table by calling
232 windows_set_context_register_offsets.
234 One day we could read a reg, we could inspect the context we
235 already have loaded, if it doesn't have the bit set that we need,
236 we read that set of registers in using GetThreadContext. If the
237 context already contains what we need, we just unpack it. Then to
238 write a register, first we have to ensure that the context contains
239 the other regs of the group, and then we copy the info in and set
242 static const int *mappings
;
244 /* The function to use in order to determine whether a register is
245 a segment register or not. */
246 static segment_register_p_ftype
*segment_register_p
;
248 /* This vector maps the target's idea of an exception (extracted
249 from the DEBUG_EVENT structure) to GDB's idea. */
251 struct xlate_exception
257 static const struct xlate_exception
260 {EXCEPTION_ACCESS_VIOLATION
, GDB_SIGNAL_SEGV
},
261 {STATUS_STACK_OVERFLOW
, GDB_SIGNAL_SEGV
},
262 {EXCEPTION_BREAKPOINT
, GDB_SIGNAL_TRAP
},
263 {DBG_CONTROL_C
, GDB_SIGNAL_INT
},
264 {EXCEPTION_SINGLE_STEP
, GDB_SIGNAL_TRAP
},
265 {STATUS_FLOAT_DIVIDE_BY_ZERO
, GDB_SIGNAL_FPE
},
268 /* Set the MAPPINGS static global to OFFSETS.
269 See the description of MAPPINGS for more details. */
272 windows_set_context_register_offsets (const int *offsets
)
277 /* See windows-nat.h. */
280 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
282 segment_register_p
= fun
;
286 check (BOOL ok
, const char *file
, int line
)
289 printf_filtered ("error return %s:%d was %u\n", file
, line
,
290 (unsigned) GetLastError ());
293 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
294 then also retrieve the context for this thread. If GET_CONTEXT is
295 negative, then don't suspend the thread. */
297 thread_rec (DWORD id
, int get_context
)
301 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
304 if (!th
->suspended
&& get_context
)
306 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
308 if (SuspendThread (th
->h
) == (DWORD
) -1)
310 DWORD err
= GetLastError ();
312 warning (_("SuspendThread (tid=0x%x) failed."
314 (unsigned) id
, (unsigned) err
);
319 else if (get_context
< 0)
321 th
->reload_context
= 1;
329 /* Add a thread to the thread list. */
331 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
)
336 gdb_assert (ptid_get_tid (ptid
) != 0);
338 id
= ptid_get_tid (ptid
);
340 if ((th
= thread_rec (id
, FALSE
)))
343 th
= XCNEW (thread_info
);
346 th
->thread_local_base
= (CORE_ADDR
) (uintptr_t) tlb
;
347 th
->next
= thread_head
.next
;
348 thread_head
.next
= th
;
350 /* Set the debug registers for the new thread if they are used. */
351 if (debug_registers_used
)
353 /* Only change the value of the debug registers. */
354 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
355 CHECK (GetThreadContext (th
->h
, &th
->context
));
356 th
->context
.Dr0
= dr
[0];
357 th
->context
.Dr1
= dr
[1];
358 th
->context
.Dr2
= dr
[2];
359 th
->context
.Dr3
= dr
[3];
360 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
361 th
->context
.Dr7
= dr
[7];
362 CHECK (SetThreadContext (th
->h
, &th
->context
));
363 th
->context
.ContextFlags
= 0;
368 /* Clear out any old thread list and reintialize it to a
371 windows_init_thread_list (void)
373 thread_info
*th
= &thread_head
;
375 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
377 while (th
->next
!= NULL
)
379 thread_info
*here
= th
->next
;
380 th
->next
= here
->next
;
383 thread_head
.next
= NULL
;
386 /* Delete a thread from the list of threads. */
388 windows_delete_thread (ptid_t ptid
, DWORD exit_code
)
393 gdb_assert (ptid_get_tid (ptid
) != 0);
395 id
= ptid_get_tid (ptid
);
398 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
));
399 else if (print_thread_events
&& id
!= main_thread_id
)
400 printf_unfiltered (_("[%s exited with code %u]\n"),
401 target_pid_to_str (ptid
), (unsigned) exit_code
);
402 delete_thread (ptid
);
404 for (th
= &thread_head
;
405 th
->next
!= NULL
&& th
->next
->id
!= id
;
409 if (th
->next
!= NULL
)
411 thread_info
*here
= th
->next
;
412 th
->next
= here
->next
;
418 do_windows_fetch_inferior_registers (struct regcache
*regcache
, int r
)
420 char *context_offset
= ((char *) ¤t_thread
->context
) + mappings
[r
];
421 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
422 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
426 return; /* Windows sometimes uses a non-existent thread id in its
429 if (current_thread
->reload_context
)
431 #ifdef __COPY_CONTEXT_SIZE
432 if (have_saved_context
)
434 /* Lie about where the program actually is stopped since
435 cygwin has informed us that we should consider the signal
436 to have occurred at another location which is stored in
438 memcpy (¤t_thread
->context
, &saved_context
,
439 __COPY_CONTEXT_SIZE
);
440 have_saved_context
= 0;
445 thread_info
*th
= current_thread
;
446 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
447 GetThreadContext (th
->h
, &th
->context
);
448 /* Copy dr values from that thread.
449 But only if there were not modified since last stop.
451 if (!debug_registers_changed
)
453 dr
[0] = th
->context
.Dr0
;
454 dr
[1] = th
->context
.Dr1
;
455 dr
[2] = th
->context
.Dr2
;
456 dr
[3] = th
->context
.Dr3
;
457 dr
[6] = th
->context
.Dr6
;
458 dr
[7] = th
->context
.Dr7
;
461 current_thread
->reload_context
= 0;
464 if (r
== I387_FISEG_REGNUM (tdep
))
466 l
= *((long *) context_offset
) & 0xffff;
467 regcache_raw_supply (regcache
, r
, (char *) &l
);
469 else if (r
== I387_FOP_REGNUM (tdep
))
471 l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
472 regcache_raw_supply (regcache
, r
, (char *) &l
);
474 else if (segment_register_p (r
))
476 /* GDB treats segment registers as 32bit registers, but they are
477 in fact only 16 bits long. Make sure we do not read extra
478 bits from our source buffer. */
479 l
= *((long *) context_offset
) & 0xffff;
480 regcache_raw_supply (regcache
, r
, (char *) &l
);
483 regcache_raw_supply (regcache
, r
, context_offset
);
486 for (r
= 0; r
< gdbarch_num_regs (gdbarch
); r
++)
487 do_windows_fetch_inferior_registers (regcache
, r
);
492 windows_fetch_inferior_registers (struct target_ops
*ops
,
493 struct regcache
*regcache
, int r
)
495 current_thread
= thread_rec (ptid_get_tid (inferior_ptid
), TRUE
);
496 /* Check if current_thread exists. Windows sometimes uses a non-existent
497 thread id in its events. */
499 do_windows_fetch_inferior_registers (regcache
, r
);
503 do_windows_store_inferior_registers (const struct regcache
*regcache
, int r
)
506 /* Windows sometimes uses a non-existent thread id in its events. */;
508 regcache_raw_collect (regcache
, r
,
509 ((char *) ¤t_thread
->context
) + mappings
[r
]);
512 for (r
= 0; r
< gdbarch_num_regs (get_regcache_arch (regcache
)); r
++)
513 do_windows_store_inferior_registers (regcache
, r
);
517 /* Store a new register value into the current thread context. */
519 windows_store_inferior_registers (struct target_ops
*ops
,
520 struct regcache
*regcache
, int r
)
522 current_thread
= thread_rec (ptid_get_tid (inferior_ptid
), TRUE
);
523 /* Check if current_thread exists. Windows sometimes uses a non-existent
524 thread id in its events. */
526 do_windows_store_inferior_registers (regcache
, r
);
529 /* Encapsulate the information required in a call to
530 symbol_file_add_args. */
531 struct safe_symbol_file_add_args
535 struct section_addr_info
*addrs
;
538 struct ui_file
*err
, *out
;
542 /* Maintain a linked list of "so" information. */
548 static struct so_list solib_start
, *solib_end
;
550 /* Call symbol_file_add with stderr redirected. We don't care if there
553 safe_symbol_file_add_stub (void *argv
)
555 #define p ((struct safe_symbol_file_add_args *) argv)
556 const int add_flags
= ((p
->from_tty
? SYMFILE_VERBOSE
: 0)
557 | (p
->mainline
? SYMFILE_MAINLINE
: 0));
558 p
->ret
= symbol_file_add (p
->name
, add_flags
, p
->addrs
, p
->flags
);
563 /* Restore gdb's stderr after calling symbol_file_add. */
565 safe_symbol_file_add_cleanup (void *p
)
567 #define sp ((struct safe_symbol_file_add_args *)p)
568 gdb_flush (gdb_stderr
);
569 gdb_flush (gdb_stdout
);
570 ui_file_delete (gdb_stderr
);
571 ui_file_delete (gdb_stdout
);
572 gdb_stderr
= sp
->err
;
573 gdb_stdout
= sp
->out
;
577 /* symbol_file_add wrapper that prevents errors from being displayed. */
578 static struct objfile
*
579 safe_symbol_file_add (char *name
, int from_tty
,
580 struct section_addr_info
*addrs
,
581 int mainline
, int flags
)
583 struct safe_symbol_file_add_args p
;
584 struct cleanup
*cleanup
;
586 cleanup
= make_cleanup (safe_symbol_file_add_cleanup
, &p
);
590 gdb_flush (gdb_stderr
);
591 gdb_flush (gdb_stdout
);
592 gdb_stderr
= ui_file_new ();
593 gdb_stdout
= ui_file_new ();
595 p
.from_tty
= from_tty
;
597 p
.mainline
= mainline
;
599 catch_errors (safe_symbol_file_add_stub
, &p
, "", RETURN_MASK_ERROR
);
601 do_cleanups (cleanup
);
605 static struct so_list
*
606 windows_make_so (const char *name
, LPVOID load_addr
)
613 WIN32_FIND_DATA w32_fd
;
614 HANDLE h
= FindFirstFile(name
, &w32_fd
);
616 if (h
== INVALID_HANDLE_VALUE
)
622 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
624 p
= strrchr (buf
, '\\');
627 SetCurrentDirectory (buf
);
628 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
629 SetCurrentDirectory (cwd
);
632 if (strcasecmp (buf
, "ntdll.dll") == 0)
634 GetSystemDirectory (buf
, sizeof (buf
));
635 strcat (buf
, "\\ntdll.dll");
638 cygwin_buf_t buf
[__PMAX
];
641 if (access (name
, F_OK
) != 0)
643 if (strcasecmp (name
, "ntdll.dll") == 0)
646 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
647 wcscat (buf
, L
"\\ntdll.dll");
651 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
652 strcat (buf
, "\\ntdll.dll");
657 so
= XCNEW (struct so_list
);
658 so
->lm_info
= (struct lm_info
*) xmalloc (sizeof (struct lm_info
));
659 so
->lm_info
->load_addr
= load_addr
;
660 strcpy (so
->so_original_name
, name
);
662 strcpy (so
->so_name
, buf
);
665 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
666 SO_NAME_MAX_PATH_SIZE
);
669 char *rname
= realpath (name
, NULL
);
670 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
672 strcpy (so
->so_name
, rname
);
676 error (_("dll path too long"));
678 /* Record cygwin1.dll .text start/end. */
679 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
680 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
683 asection
*text
= NULL
;
686 abfd
= gdb_bfd_open (so
->so_name
, "pei-i386", -1);
691 if (bfd_check_format (abfd
, bfd_object
))
692 text
= bfd_get_section_by_name (abfd
, ".text");
696 gdb_bfd_unref (abfd
);
700 /* The symbols in a dll are offset by 0x1000, which is the
701 offset from 0 of the first byte in an image - because of the
702 file header and the section alignment. */
703 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
705 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (abfd
, text
);
707 gdb_bfd_unref (abfd
);
715 get_image_name (HANDLE h
, void *address
, int unicode
)
718 static char buf
[__PMAX
];
720 static char buf
[(2 * __PMAX
) + 1];
722 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
728 /* Attempt to read the name of the dll that was detected.
729 This is documented to work only when actively debugging
730 a program. It will not work for attached processes. */
734 /* See if we could read the address of a string, and that the
735 address isn't null. */
736 if (!ReadProcessMemory (h
, address
, &address_ptr
,
737 sizeof (address_ptr
), &done
)
738 || done
!= sizeof (address_ptr
) || !address_ptr
)
741 /* Find the length of the string. */
742 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
743 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
747 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
750 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
751 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
754 wcstombs (buf
, unicode_address
, __PMAX
);
756 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
764 /* Handle a DLL load event, and return 1.
766 This function assumes that this event did not occur during inferior
767 initialization, where their event info may be incomplete (see
768 do_initial_windows_stuff and windows_add_all_dlls for more info
769 on how we handle DLL loading during that phase). */
772 handle_load_dll (void *dummy
)
774 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
777 /* Try getting the DLL name via the lpImageName field of the event.
778 Note that Microsoft documents this fields as strictly optional,
779 in the sense that it might be NULL. And the first DLL event in
780 particular is explicitly documented as "likely not pass[ed]"
781 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
782 dll_name
= get_image_name (current_process_handle
,
783 event
->lpImageName
, event
->fUnicode
);
787 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
788 solib_end
= solib_end
->next
;
790 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
791 host_address_to_string (solib_end
->lm_info
->load_addr
)));
797 windows_free_so (struct so_list
*so
)
804 /* Handle a DLL unload event.
805 Return 1 if successful, or zero otherwise.
807 This function assumes that this event did not occur during inferior
808 initialization, where their event info may be incomplete (see
809 do_initial_windows_stuff and windows_add_all_dlls for more info
810 on how we handle DLL loading during that phase). */
813 handle_unload_dll (void *dummy
)
815 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
818 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
819 if (so
->next
->lm_info
->load_addr
== lpBaseOfDll
)
821 struct so_list
*sodel
= so
->next
;
823 so
->next
= sodel
->next
;
826 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
828 windows_free_so (sodel
);
832 /* We did not find any DLL that was previously loaded at this address,
833 so register a complaint. We do not report an error, because we have
834 observed that this may be happening under some circumstances. For
835 instance, running 32bit applications on x64 Windows causes us to receive
836 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
837 events are apparently caused by the WOW layer, the interface between
838 32bit and 64bit worlds). */
839 complaint (&symfile_complaints
, _("dll starting at %s not found."),
840 host_address_to_string (lpBaseOfDll
));
845 /* Clear list of loaded DLLs. */
847 windows_clear_solib (void)
849 solib_start
.next
= NULL
;
850 solib_end
= &solib_start
;
853 /* Load DLL symbol info. */
855 dll_symbol_command (char *args
, int from_tty
)
861 error (_("dll-symbols requires a file name"));
864 if (n
> 4 && strcasecmp (args
+ n
- 4, ".dll") != 0)
866 char *newargs
= (char *) alloca (n
+ 4 + 1);
867 strcpy (newargs
, args
);
868 strcat (newargs
, ".dll");
872 safe_symbol_file_add (args
, from_tty
, NULL
, 0, OBJF_SHARED
| OBJF_USERLOADED
);
875 /* Handle DEBUG_STRING output from child process.
876 Cygwin prepends its messages with a "cygwin:". Interpret this as
877 a Cygwin signal. Otherwise just print the string as a warning. */
879 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
884 if (!target_read_string
885 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
889 else if (strncmp (s
, _CYGWIN_SIGNAL_STRING
,
890 sizeof (_CYGWIN_SIGNAL_STRING
) - 1) != 0)
893 if (strncmp (s
, "cYg", 3) != 0)
897 #ifdef __COPY_CONTEXT_SIZE
900 /* Got a cygwin signal marker. A cygwin signal is followed by
901 the signal number itself and then optionally followed by the
902 thread id and address to saved context within the DLL. If
903 these are supplied, then the given thread is assumed to have
904 issued the signal and the context from the thread is assumed
905 to be stored at the given address in the inferior. Tell gdb
906 to treat this like a real signal. */
908 int sig
= strtol (s
+ sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
909 int gotasig
= gdb_signal_from_host (sig
);
911 ourstatus
->value
.sig
= gotasig
;
917 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
918 retval
= strtoul (p
, &p
, 0);
920 retval
= main_thread_id
;
921 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
922 && ReadProcessMemory (current_process_handle
, x
,
924 __COPY_CONTEXT_SIZE
, &n
)
925 && n
== __COPY_CONTEXT_SIZE
)
926 have_saved_context
= 1;
927 current_event
.dwThreadId
= retval
;
938 display_selector (HANDLE thread
, DWORD sel
)
941 if (GetThreadSelectorEntry (thread
, sel
, &info
))
944 printf_filtered ("0x%03x: ", (unsigned) sel
);
945 if (!info
.HighWord
.Bits
.Pres
)
947 puts_filtered ("Segment not present\n");
950 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
951 (info
.HighWord
.Bits
.BaseMid
<< 16)
953 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
954 if (info
.HighWord
.Bits
.Granularity
)
955 limit
= (limit
<< 12) | 0xfff;
956 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
957 if (info
.HighWord
.Bits
.Default_Big
)
958 puts_filtered(" 32-bit ");
960 puts_filtered(" 16-bit ");
961 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
964 puts_filtered ("Data (Read-Only, Exp-up");
967 puts_filtered ("Data (Read/Write, Exp-up");
970 puts_filtered ("Unused segment (");
973 puts_filtered ("Data (Read/Write, Exp-down");
976 puts_filtered ("Code (Exec-Only, N.Conf");
979 puts_filtered ("Code (Exec/Read, N.Conf");
982 puts_filtered ("Code (Exec-Only, Conf");
985 puts_filtered ("Code (Exec/Read, Conf");
988 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
990 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
991 puts_filtered(", N.Acc");
992 puts_filtered (")\n");
993 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
994 puts_filtered("System selector ");
995 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
996 if (info
.HighWord
.Bits
.Granularity
)
997 puts_filtered ("Page granular.\n");
999 puts_filtered ("Byte granular.\n");
1004 DWORD err
= GetLastError ();
1005 if (err
== ERROR_NOT_SUPPORTED
)
1006 printf_filtered ("Function not supported\n");
1008 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1014 display_selectors (char * args
, int from_tty
)
1016 if (!current_thread
)
1018 puts_filtered ("Impossible to display selectors now.\n");
1024 puts_filtered ("Selector $cs\n");
1025 display_selector (current_thread
->h
,
1026 current_thread
->context
.SegCs
);
1027 puts_filtered ("Selector $ds\n");
1028 display_selector (current_thread
->h
,
1029 current_thread
->context
.SegDs
);
1030 puts_filtered ("Selector $es\n");
1031 display_selector (current_thread
->h
,
1032 current_thread
->context
.SegEs
);
1033 puts_filtered ("Selector $ss\n");
1034 display_selector (current_thread
->h
,
1035 current_thread
->context
.SegSs
);
1036 puts_filtered ("Selector $fs\n");
1037 display_selector (current_thread
->h
,
1038 current_thread
->context
.SegFs
);
1039 puts_filtered ("Selector $gs\n");
1040 display_selector (current_thread
->h
,
1041 current_thread
->context
.SegGs
);
1046 sel
= parse_and_eval_long (args
);
1047 printf_filtered ("Selector \"%s\"\n",args
);
1048 display_selector (current_thread
->h
, sel
);
1052 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1053 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1054 host_address_to_string (\
1055 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1058 handle_exception (struct target_waitstatus
*ourstatus
)
1061 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1063 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1065 /* Record the context of the current thread. */
1066 th
= thread_rec (current_event
.dwThreadId
, -1);
1070 case EXCEPTION_ACCESS_VIOLATION
:
1071 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1072 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1075 /* See if the access violation happened within the cygwin DLL
1076 itself. Cygwin uses a kind of exception handling to deal
1077 with passed-in invalid addresses. gdb should not treat
1078 these as real SEGVs since they will be silently handled by
1079 cygwin. A real SEGV will (theoretically) be caught by
1080 cygwin later in the process and will be sent as a
1081 cygwin-specific-signal. So, ignore SEGVs if they show up
1082 within the text segment of the DLL itself. */
1084 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t)
1085 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
;
1087 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1088 && addr
< cygwin_load_end
))
1089 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1090 && strncmp (fn
, "KERNEL32!IsBad",
1091 strlen ("KERNEL32!IsBad")) == 0))
1096 case STATUS_STACK_OVERFLOW
:
1097 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1098 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1100 case STATUS_FLOAT_DENORMAL_OPERAND
:
1101 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1102 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1104 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1105 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1106 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1108 case STATUS_FLOAT_INEXACT_RESULT
:
1109 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1110 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1112 case STATUS_FLOAT_INVALID_OPERATION
:
1113 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1114 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1116 case STATUS_FLOAT_OVERFLOW
:
1117 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1118 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1120 case STATUS_FLOAT_STACK_CHECK
:
1121 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1122 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1124 case STATUS_FLOAT_UNDERFLOW
:
1125 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1126 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1128 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1129 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1130 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1132 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1133 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1134 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1136 case STATUS_INTEGER_OVERFLOW
:
1137 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1138 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1140 case EXCEPTION_BREAKPOINT
:
1141 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1142 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1145 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1146 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1148 case DBG_CONTROL_BREAK
:
1149 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1150 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1152 case EXCEPTION_SINGLE_STEP
:
1153 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1154 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1156 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1157 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1158 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1160 case EXCEPTION_PRIV_INSTRUCTION
:
1161 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1162 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1164 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1165 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1166 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1169 /* Treat unhandled first chance exceptions specially. */
1170 if (current_event
.u
.Exception
.dwFirstChance
)
1172 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1173 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1174 host_address_to_string (
1175 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1176 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1180 last_sig
= ourstatus
->value
.sig
;
1184 /* Resume all artificially suspended threads if we are continuing
1187 windows_continue (DWORD continue_status
, int id
)
1193 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1194 (unsigned) current_event
.dwProcessId
,
1195 (unsigned) current_event
.dwThreadId
,
1196 continue_status
== DBG_CONTINUE
?
1197 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1199 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1200 if ((id
== -1 || id
== (int) th
->id
)
1203 if (debug_registers_changed
)
1205 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1206 th
->context
.Dr0
= dr
[0];
1207 th
->context
.Dr1
= dr
[1];
1208 th
->context
.Dr2
= dr
[2];
1209 th
->context
.Dr3
= dr
[3];
1210 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1211 th
->context
.Dr7
= dr
[7];
1213 if (th
->context
.ContextFlags
)
1215 CHECK (SetThreadContext (th
->h
, &th
->context
));
1216 th
->context
.ContextFlags
= 0;
1218 if (th
->suspended
> 0)
1219 (void) ResumeThread (th
->h
);
1223 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1224 current_event
.dwThreadId
,
1227 debug_registers_changed
= 0;
1231 /* Called in pathological case where Windows fails to send a
1232 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1234 fake_create_process (void)
1236 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1237 current_event
.dwProcessId
);
1238 if (current_process_handle
!= NULL
)
1239 open_process_used
= 1;
1242 error (_("OpenProcess call failed, GetLastError = %u"),
1243 (unsigned) GetLastError ());
1244 /* We can not debug anything in that case. */
1246 main_thread_id
= current_event
.dwThreadId
;
1247 current_thread
= windows_add_thread (
1248 ptid_build (current_event
.dwProcessId
, 0,
1249 current_event
.dwThreadId
),
1250 current_event
.u
.CreateThread
.hThread
,
1251 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1252 return main_thread_id
;
1256 windows_resume (struct target_ops
*ops
,
1257 ptid_t ptid
, int step
, enum gdb_signal sig
)
1260 DWORD continue_status
= DBG_CONTINUE
;
1262 /* A specific PTID means `step only this thread id'. */
1263 int resume_all
= ptid_equal (ptid
, minus_one_ptid
);
1265 /* If we're continuing all threads, it's the current inferior that
1266 should be handled specially. */
1268 ptid
= inferior_ptid
;
1270 if (sig
!= GDB_SIGNAL_0
)
1272 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1274 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1276 else if (sig
== last_sig
)
1277 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1280 /* This code does not seem to work, because
1281 the kernel does probably not consider changes in the ExceptionRecord
1282 structure when passing the exception to the inferior.
1283 Note that this seems possible in the exception handler itself. */
1286 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1287 if (xlate
[i
].us
== sig
)
1289 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1291 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1294 if (continue_status
== DBG_CONTINUE
)
1296 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1300 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1304 last_sig
= GDB_SIGNAL_0
;
1306 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1307 ptid_get_pid (ptid
), ptid_get_tid (ptid
), step
, sig
));
1309 /* Get context for currently selected thread. */
1310 th
= thread_rec (ptid_get_tid (inferior_ptid
), FALSE
);
1315 /* Single step by setting t bit. */
1316 struct regcache
*regcache
= get_current_regcache ();
1317 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1318 windows_fetch_inferior_registers (ops
, regcache
,
1319 gdbarch_ps_regnum (gdbarch
));
1320 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1323 if (th
->context
.ContextFlags
)
1325 if (debug_registers_changed
)
1327 th
->context
.Dr0
= dr
[0];
1328 th
->context
.Dr1
= dr
[1];
1329 th
->context
.Dr2
= dr
[2];
1330 th
->context
.Dr3
= dr
[3];
1331 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1332 th
->context
.Dr7
= dr
[7];
1334 CHECK (SetThreadContext (th
->h
, &th
->context
));
1335 th
->context
.ContextFlags
= 0;
1339 /* Allow continuing with the same signal that interrupted us.
1340 Otherwise complain. */
1343 windows_continue (continue_status
, -1);
1345 windows_continue (continue_status
, ptid_get_tid (ptid
));
1348 /* Ctrl-C handler used when the inferior is not run in the same console. The
1349 handler is in charge of interrupting the inferior using DebugBreakProcess.
1350 Note that this function is not available prior to Windows XP. In this case
1351 we emit a warning. */
1353 ctrl_c_handler (DWORD event_type
)
1355 const int attach_flag
= current_inferior ()->attach_flag
;
1357 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1358 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1361 /* If the inferior and the debugger share the same console, do nothing as
1362 the inferior has also received the Ctrl-C event. */
1363 if (!new_console
&& !attach_flag
)
1366 if (!DebugBreakProcess (current_process_handle
))
1367 warning (_("Could not interrupt program. "
1368 "Press Ctrl-c in the program console."));
1370 /* Return true to tell that Ctrl-C has been handled. */
1374 /* Get the next event from the child. Return 1 if the event requires
1375 handling by WFI (or whatever). */
1377 get_windows_debug_event (struct target_ops
*ops
,
1378 int pid
, struct target_waitstatus
*ourstatus
)
1381 DWORD continue_status
, event_code
;
1383 static thread_info dummy_thread_info
;
1386 last_sig
= GDB_SIGNAL_0
;
1388 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1392 continue_status
= DBG_CONTINUE
;
1394 event_code
= current_event
.dwDebugEventCode
;
1395 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1397 have_saved_context
= 0;
1401 case CREATE_THREAD_DEBUG_EVENT
:
1402 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1403 (unsigned) current_event
.dwProcessId
,
1404 (unsigned) current_event
.dwThreadId
,
1405 "CREATE_THREAD_DEBUG_EVENT"));
1406 if (saw_create
!= 1)
1408 struct inferior
*inf
;
1409 inf
= find_inferior_pid (current_event
.dwProcessId
);
1410 if (!saw_create
&& inf
->attach_flag
)
1412 /* Kludge around a Windows bug where first event is a create
1413 thread event. Caused when attached process does not have
1415 retval
= fake_create_process ();
1421 /* Record the existence of this thread. */
1422 retval
= current_event
.dwThreadId
;
1423 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1424 current_event
.dwThreadId
),
1425 current_event
.u
.CreateThread
.hThread
,
1426 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1430 case EXIT_THREAD_DEBUG_EVENT
:
1431 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1432 (unsigned) current_event
.dwProcessId
,
1433 (unsigned) current_event
.dwThreadId
,
1434 "EXIT_THREAD_DEBUG_EVENT"));
1436 if (current_event
.dwThreadId
!= main_thread_id
)
1438 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1439 current_event
.dwThreadId
),
1440 current_event
.u
.ExitThread
.dwExitCode
);
1441 th
= &dummy_thread_info
;
1445 case CREATE_PROCESS_DEBUG_EVENT
:
1446 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1447 (unsigned) current_event
.dwProcessId
,
1448 (unsigned) current_event
.dwThreadId
,
1449 "CREATE_PROCESS_DEBUG_EVENT"));
1450 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1451 if (++saw_create
!= 1)
1454 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1456 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1459 main_thread_id
= current_event
.dwThreadId
;
1460 /* Add the main thread. */
1461 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1462 current_event
.dwThreadId
),
1463 current_event
.u
.CreateProcessInfo
.hThread
,
1464 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
);
1465 retval
= current_event
.dwThreadId
;
1468 case EXIT_PROCESS_DEBUG_EVENT
:
1469 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1470 (unsigned) current_event
.dwProcessId
,
1471 (unsigned) current_event
.dwThreadId
,
1472 "EXIT_PROCESS_DEBUG_EVENT"));
1473 if (!windows_initialization_done
)
1475 target_terminal_ours ();
1476 target_mourn_inferior ();
1477 error (_("During startup program exited with code 0x%x."),
1478 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1480 else if (saw_create
== 1)
1482 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1483 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1484 retval
= main_thread_id
;
1488 case LOAD_DLL_DEBUG_EVENT
:
1489 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1490 (unsigned) current_event
.dwProcessId
,
1491 (unsigned) current_event
.dwThreadId
,
1492 "LOAD_DLL_DEBUG_EVENT"));
1493 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1494 if (saw_create
!= 1 || ! windows_initialization_done
)
1496 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1497 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1498 ourstatus
->value
.integer
= 0;
1499 retval
= main_thread_id
;
1502 case UNLOAD_DLL_DEBUG_EVENT
:
1503 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1504 (unsigned) current_event
.dwProcessId
,
1505 (unsigned) current_event
.dwThreadId
,
1506 "UNLOAD_DLL_DEBUG_EVENT"));
1507 if (saw_create
!= 1 || ! windows_initialization_done
)
1509 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1510 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1511 ourstatus
->value
.integer
= 0;
1512 retval
= main_thread_id
;
1515 case EXCEPTION_DEBUG_EVENT
:
1516 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1517 (unsigned) current_event
.dwProcessId
,
1518 (unsigned) current_event
.dwThreadId
,
1519 "EXCEPTION_DEBUG_EVENT"));
1520 if (saw_create
!= 1)
1522 switch (handle_exception (ourstatus
))
1525 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1528 retval
= current_event
.dwThreadId
;
1532 continue_status
= -1;
1537 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1538 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1539 (unsigned) current_event
.dwProcessId
,
1540 (unsigned) current_event
.dwThreadId
,
1541 "OUTPUT_DEBUG_STRING_EVENT"));
1542 if (saw_create
!= 1)
1544 retval
= handle_output_debug_string (ourstatus
);
1548 if (saw_create
!= 1)
1550 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1551 (unsigned) current_event
.dwProcessId
,
1552 (unsigned) current_event
.dwThreadId
);
1553 printf_unfiltered (" unknown event code %u\n",
1554 (unsigned) current_event
.dwDebugEventCode
);
1558 if (!retval
|| saw_create
!= 1)
1560 if (continue_status
== -1)
1561 windows_resume (ops
, minus_one_ptid
, 0, 1);
1563 CHECK (windows_continue (continue_status
, -1));
1567 inferior_ptid
= ptid_build (current_event
.dwProcessId
, 0,
1569 current_thread
= th
?: thread_rec (current_event
.dwThreadId
, TRUE
);
1576 /* Wait for interesting events to occur in the target process. */
1578 windows_wait (struct target_ops
*ops
,
1579 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
1583 target_terminal_ours ();
1585 /* We loop when we get a non-standard exception rather than return
1586 with a SPURIOUS because resume can try and step or modify things,
1587 which needs a current_thread->h. But some of these exceptions mark
1588 the birth or death of threads, which mean that the current thread
1589 isn't necessarily what you think it is. */
1595 /* If the user presses Ctrl-c while the debugger is waiting
1596 for an event, he expects the debugger to interrupt his program
1597 and to get the prompt back. There are two possible situations:
1599 - The debugger and the program do not share the console, in
1600 which case the Ctrl-c event only reached the debugger.
1601 In that case, the ctrl_c handler will take care of interrupting
1602 the inferior. Note that this case is working starting with
1603 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1606 - The debugger and the program share the same console, in which
1607 case both debugger and inferior will receive the Ctrl-c event.
1608 In that case the ctrl_c handler will ignore the event, as the
1609 Ctrl-c event generated inside the inferior will trigger the
1610 expected debug event.
1612 FIXME: brobecker/2008-05-20: If the inferior receives the
1613 signal first and the delay until GDB receives that signal
1614 is sufficiently long, GDB can sometimes receive the SIGINT
1615 after we have unblocked the CTRL+C handler. This would
1616 lead to the debugger stopping prematurely while handling
1617 the new-thread event that comes with the handling of the SIGINT
1618 inside the inferior, and then stop again immediately when
1619 the user tries to resume the execution in the inferior.
1620 This is a classic race that we should try to fix one day. */
1621 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1622 retval
= get_windows_debug_event (ops
, pid
, ourstatus
);
1623 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1626 return ptid_build (current_event
.dwProcessId
, 0, retval
);
1631 if (deprecated_ui_loop_hook
!= NULL
)
1632 detach
= deprecated_ui_loop_hook (0);
1635 windows_kill_inferior (ops
);
1640 /* Iterate over all DLLs currently mapped by our inferior, and
1641 add them to our list of solibs. */
1644 windows_add_all_dlls (void)
1647 HMODULE dummy_hmodule
;
1652 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
1653 sizeof (HMODULE
), &cb_needed
) == 0)
1659 hmodules
= (HMODULE
*) alloca (cb_needed
);
1660 if (EnumProcessModules (current_process_handle
, hmodules
,
1661 cb_needed
, &cb_needed
) == 0)
1664 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
1668 wchar_t dll_name
[__PMAX
];
1671 char dll_name
[__PMAX
];
1674 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
1675 &mi
, sizeof (mi
)) == 0)
1677 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
1678 dll_name
, sizeof (dll_name
)) == 0)
1681 wcstombs (name
, dll_name
, __PMAX
);
1686 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
1687 solib_end
= solib_end
->next
;
1692 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1694 extern int stop_after_trap
;
1696 struct inferior
*inf
;
1697 struct thread_info
*tp
;
1699 last_sig
= GDB_SIGNAL_0
;
1701 exception_count
= 0;
1702 open_process_used
= 0;
1703 debug_registers_changed
= 0;
1704 debug_registers_used
= 0;
1705 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1708 cygwin_load_start
= cygwin_load_end
= 0;
1710 current_event
.dwProcessId
= pid
;
1711 memset (¤t_event
, 0, sizeof (current_event
));
1713 disable_breakpoints_in_shlibs ();
1714 windows_clear_solib ();
1715 clear_proceed_status ();
1716 init_wait_for_inferior ();
1718 inf
= current_inferior ();
1719 inferior_appeared (inf
, pid
);
1720 inf
->attach_flag
= attaching
;
1722 /* Make the new process the current inferior, so terminal handling
1723 can rely on it. When attaching, we don't know about any thread
1724 id here, but that's OK --- nothing should be referencing the
1725 current thread until we report an event out of windows_wait. */
1726 inferior_ptid
= pid_to_ptid (pid
);
1728 child_terminal_init_with_pgrp (pid
);
1729 target_terminal_inferior ();
1731 windows_initialization_done
= 0;
1732 inf
->control
.stop_soon
= STOP_QUIETLY
;
1735 stop_after_trap
= 1;
1736 wait_for_inferior ();
1737 tp
= inferior_thread ();
1738 if (tp
->suspend
.stop_signal
!= GDB_SIGNAL_TRAP
)
1739 resume (0, tp
->suspend
.stop_signal
);
1744 /* Now that the inferior has been started and all DLLs have been mapped,
1745 we can iterate over all DLLs and load them in.
1747 We avoid doing it any earlier because, on certain versions of Windows,
1748 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
1749 we have seen on Windows 8.1 that the ntdll.dll load event does not
1750 include the DLL name, preventing us from creating an associated SO.
1751 A possible explanation is that ntdll.dll might be mapped before
1752 the SO info gets created by the Windows system -- ntdll.dll is
1753 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
1754 do not seem to suffer from that problem.
1756 Rather than try to work around this sort of issue, it is much
1757 simpler to just ignore DLL load/unload events during the startup
1758 phase, and then process them all in one batch now. */
1759 windows_add_all_dlls ();
1761 windows_initialization_done
= 1;
1762 inf
->control
.stop_soon
= NO_STOP_QUIETLY
;
1763 stop_after_trap
= 0;
1767 /* Try to set or remove a user privilege to the current process. Return -1
1768 if that fails, the previous setting of that privilege otherwise.
1770 This code is copied from the Cygwin source code and rearranged to allow
1771 dynamically loading of the needed symbols from advapi32 which is only
1772 available on NT/2K/XP. */
1774 set_process_privilege (const char *privilege
, BOOL enable
)
1776 HANDLE token_hdl
= NULL
;
1778 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1782 if (!OpenProcessToken (GetCurrentProcess (),
1783 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1787 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
1790 new_priv
.PrivilegeCount
= 1;
1791 new_priv
.Privileges
[0].Luid
= restore_priv
;
1792 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1794 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1795 sizeof orig_priv
, &orig_priv
, &size
))
1798 /* Disabled, otherwise every `attach' in an unprivileged user session
1799 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1800 windows_attach(). */
1801 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1802 be enabled. GetLastError () returns an correct error code, though. */
1803 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1807 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1811 CloseHandle (token_hdl
);
1816 /* Attach to process PID, then initialize for debugging it. */
1818 windows_attach (struct target_ops
*ops
, char *args
, int from_tty
)
1823 pid
= parse_pid_to_attach (args
);
1825 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1827 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1828 printf_unfiltered ("This can cause attach to "
1829 "fail on Windows NT/2K/XP\n");
1832 windows_init_thread_list ();
1833 ok
= DebugActiveProcess (pid
);
1839 /* Try fall back to Cygwin pid. */
1840 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1843 ok
= DebugActiveProcess (pid
);
1848 error (_("Can't attach to process."));
1850 DebugSetProcessKillOnExit (FALSE
);
1854 char *exec_file
= (char *) get_exec_file (0);
1857 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1858 target_pid_to_str (pid_to_ptid (pid
)));
1860 printf_unfiltered ("Attaching to %s\n",
1861 target_pid_to_str (pid_to_ptid (pid
)));
1863 gdb_flush (gdb_stdout
);
1866 do_initial_windows_stuff (ops
, pid
, 1);
1867 target_terminal_ours ();
1871 windows_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
1876 windows_resume (ops
, ptid
, 0, GDB_SIGNAL_0
);
1878 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1880 error (_("Can't detach process %u (error %u)"),
1881 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
1884 DebugSetProcessKillOnExit (FALSE
);
1886 if (detached
&& from_tty
)
1888 char *exec_file
= get_exec_file (0);
1891 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
1892 (unsigned) current_event
.dwProcessId
);
1893 gdb_flush (gdb_stdout
);
1896 i386_cleanup_dregs ();
1897 inferior_ptid
= null_ptid
;
1898 detach_inferior (current_event
.dwProcessId
);
1900 unpush_target (ops
);
1903 /* Try to determine the executable filename.
1905 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
1907 Upon success, the filename is stored inside EXE_NAME_RET, and
1908 this function returns nonzero.
1910 Otherwise, this function returns zero and the contents of
1911 EXE_NAME_RET is undefined. */
1914 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
1921 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
1922 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
1925 /* We know the executable is always first in the list of modules,
1926 which we just fetched. So no need to fetch more. */
1930 /* Cygwin prefers that the path be in /x/y/z format, so extract
1931 the filename into a temporary buffer first, and then convert it
1932 to POSIX format into the destination buffer. */
1933 cygwin_buf_t
*pathbuf
= alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
1935 len
= GetModuleFileNameEx (current_process_handle
,
1936 dh_buf
, pathbuf
, exe_name_max_len
);
1938 error (_("Error getting executable filename: %u."),
1939 (unsigned) GetLastError ());
1940 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
1941 exe_name_max_len
) < 0)
1942 error (_("Error converting executable filename to POSIX: %d."), errno
);
1945 len
= GetModuleFileNameEx (current_process_handle
,
1946 dh_buf
, exe_name_ret
, exe_name_max_len
);
1948 error (_("Error getting executable filename: %u."),
1949 (unsigned) GetLastError ());
1952 return 1; /* success */
1955 /* The pid_to_exec_file target_ops method for this platform. */
1958 windows_pid_to_exec_file (struct target_ops
*self
, int pid
)
1960 static char path
[__PMAX
];
1962 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
1964 char procexe
[sizeof ("/proc/4294967295/exe")];
1966 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
1967 nchars
= readlink (procexe
, path
, sizeof(path
));
1968 if (nchars
> 0 && nchars
< sizeof (path
))
1970 path
[nchars
] = '\0'; /* Got it */
1975 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
1976 of gdb, or we're trying to debug a non-Cygwin windows executable. */
1977 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
1983 /* Print status information about what we're accessing. */
1986 windows_files_info (struct target_ops
*ignore
)
1988 struct inferior
*inf
= current_inferior ();
1990 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1991 inf
->attach_flag
? "attached" : "child",
1992 target_pid_to_str (inferior_ptid
));
1995 /* Modify CreateProcess parameters for use of a new separate console.
1997 *FLAGS: DWORD parameter for general process creation flags.
1998 *SI: STARTUPINFO structure, for which the console window size and
1999 console buffer size is filled in if GDB is running in a console.
2000 to create the new console.
2001 The size of the used font is not available on all versions of
2002 Windows OS. Furthermore, the current font might not be the default
2003 font, but this is still better than before.
2004 If the windows and buffer sizes are computed,
2005 SI->DWFLAGS is changed so that this information is used
2006 by CreateProcess function. */
2009 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2011 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2012 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2014 if (hconsole
!= INVALID_HANDLE_VALUE
)
2016 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2018 CONSOLE_FONT_INFO cfi
;
2020 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2021 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2022 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2023 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2024 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2026 si
->dwXSize
*= font_size
.X
;
2030 si
->dwYSize
*= font_size
.Y
;
2033 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2034 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2035 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2037 *flags
|= CREATE_NEW_CONSOLE
;
2041 /* Function called by qsort to sort environment strings. */
2044 envvar_cmp (const void *a
, const void *b
)
2046 const char **p
= (const char **) a
;
2047 const char **q
= (const char **) b
;
2048 return strcasecmp (*p
, *q
);
2054 clear_win32_environment (char **env
)
2058 wchar_t *copy
= NULL
, *equalpos
;
2060 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2062 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2063 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2064 mbstowcs (copy
, env
[i
], len
);
2065 equalpos
= wcschr (copy
, L
'=');
2068 SetEnvironmentVariableW (copy
, NULL
);
2074 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2075 EXEC_FILE is the file to run.
2076 ALLARGS is a string containing the arguments to the program.
2077 ENV is the environment vector to pass. Errors reported with error(). */
2080 windows_create_inferior (struct target_ops
*ops
, char *exec_file
,
2081 char *allargs
, char **in_env
, int from_tty
)
2085 cygwin_buf_t real_path
[__PMAX
];
2086 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2088 cygwin_buf_t
*toexec
;
2089 cygwin_buf_t
*cygallargs
;
2091 char **old_env
= NULL
;
2095 int ostdin
, ostdout
, ostderr
;
2097 char real_path
[__PMAX
];
2098 char shell
[__PMAX
]; /* Path to shell */
2110 PROCESS_INFORMATION pi
;
2113 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2116 error (_("No executable specified, use `target exec'."));
2118 memset (&si
, 0, sizeof (si
));
2119 si
.cb
= sizeof (si
);
2122 flags
|= CREATE_NEW_PROCESS_GROUP
;
2125 windows_set_console_info (&si
, &flags
);
2130 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2131 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2132 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2133 error (_("Error starting executable: %d"), errno
);
2136 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2137 if (len
== (size_t) -1)
2138 error (_("Error starting executable: %d"), errno
);
2139 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2140 mbstowcs (cygallargs
, allargs
, len
);
2142 cygallargs
= allargs
;
2147 sh
= getenv ("SHELL");
2150 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2151 error (_("Error starting executable via shell: %d"), errno
);
2153 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2154 + mbstowcs (NULL
, allargs
, 0) + 2;
2155 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2156 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2158 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2159 + strlen (allargs
) + 2);
2160 cygallargs
= (char *) alloca (len
);
2161 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2164 flags
|= DEBUG_PROCESS
;
2168 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2169 * sizeof (wchar_t));
2170 wcscpy (args
, toexec
);
2171 wcscat (args
, L
" ");
2172 wcscat (args
, cygallargs
);
2174 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2175 strcpy (args
, toexec
);
2177 strcat (args
, cygallargs
);
2180 #ifdef CW_CVT_ENV_TO_WINENV
2181 /* First try to create a direct Win32 copy of the POSIX environment. */
2182 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2183 if (w32_env
!= (PWCHAR
) -1)
2184 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2186 /* If that fails, fall back to old method tweaking GDB's environment. */
2189 /* Reset all Win32 environment variables to avoid leftover on next run. */
2190 clear_win32_environment (environ
);
2191 /* Prepare the environment vars for CreateProcess. */
2194 cygwin_internal (CW_SYNC_WINENV
);
2198 if (!inferior_io_terminal
)
2199 tty
= ostdin
= ostdout
= ostderr
= -1;
2202 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2205 print_sys_errmsg (inferior_io_terminal
, errno
);
2206 ostdin
= ostdout
= ostderr
= -1;
2219 windows_init_thread_list ();
2220 ret
= CreateProcess (0,
2221 args
, /* command line */
2222 NULL
, /* Security */
2224 TRUE
, /* inherit handles */
2225 flags
, /* start flags */
2226 w32_env
, /* environment */
2227 NULL
, /* current directory */
2231 /* Just free the Win32 environment, if it could be created. */
2235 /* Reset all environment variables to avoid leftover on next run. */
2236 clear_win32_environment (in_env
);
2237 /* Restore normal GDB environment variables. */
2239 cygwin_internal (CW_SYNC_WINENV
);
2254 /* Build the command line, a space-separated list of tokens where
2255 the first token is the name of the module to be executed.
2256 To avoid ambiguities introduced by spaces in the module name,
2258 args_len
= strlen (toexec
) + 2 /* quotes */ + strlen (allargs
) + 2;
2259 args
= alloca (args_len
);
2260 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs
);
2262 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2264 if (!inferior_io_terminal
)
2265 tty
= INVALID_HANDLE_VALUE
;
2268 SECURITY_ATTRIBUTES sa
;
2269 sa
.nLength
= sizeof(sa
);
2270 sa
.lpSecurityDescriptor
= 0;
2271 sa
.bInheritHandle
= TRUE
;
2272 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2273 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2274 if (tty
== INVALID_HANDLE_VALUE
)
2275 warning (_("Warning: Failed to open TTY %s, error %#x."),
2276 inferior_io_terminal
, (unsigned) GetLastError ());
2280 si
.hStdOutput
= tty
;
2282 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2286 /* CreateProcess takes the environment list as a null terminated set of
2287 strings (i.e. two nulls terminate the list). */
2289 /* Get total size for env strings. */
2290 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2291 envlen
+= strlen (in_env
[i
]) + 1;
2293 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2294 env
= (char **) alloca (envsize
);
2295 memcpy (env
, in_env
, envsize
);
2296 /* Windows programs expect the environment block to be sorted. */
2297 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2299 w32env
= alloca (envlen
+ 1);
2301 /* Copy env strings into new buffer. */
2302 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2304 strcpy (temp
, env
[i
]);
2305 temp
+= strlen (temp
) + 1;
2308 /* Final nil string to terminate new env. */
2311 windows_init_thread_list ();
2312 ret
= CreateProcessA (0,
2313 args
, /* command line */
2314 NULL
, /* Security */
2316 TRUE
, /* inherit handles */
2317 flags
, /* start flags */
2318 w32env
, /* environment */
2319 NULL
, /* current directory */
2322 if (tty
!= INVALID_HANDLE_VALUE
)
2327 error (_("Error creating process %s, (error %u)."),
2328 exec_file
, (unsigned) GetLastError ());
2330 CloseHandle (pi
.hThread
);
2331 CloseHandle (pi
.hProcess
);
2333 if (useshell
&& shell
[0] != '\0')
2338 do_initial_windows_stuff (ops
, pi
.dwProcessId
, 0);
2340 /* windows_continue (DBG_CONTINUE, -1); */
2344 windows_mourn_inferior (struct target_ops
*ops
)
2346 (void) windows_continue (DBG_CONTINUE
, -1);
2347 i386_cleanup_dregs();
2348 if (open_process_used
)
2350 CHECK (CloseHandle (current_process_handle
));
2351 open_process_used
= 0;
2353 unpush_target (ops
);
2354 generic_mourn_inferior ();
2357 /* Send a SIGINT to the process group. This acts just like the user typed a
2358 ^C on the controlling terminal. */
2361 windows_stop (struct target_ops
*self
, ptid_t ptid
)
2363 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2364 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
2365 registers_changed (); /* refresh register state */
2368 /* Helper for windows_xfer_partial that handles memory transfers.
2369 Arguments are like target_xfer_partial. */
2371 static enum target_xfer_status
2372 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2373 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2377 DWORD lasterror
= 0;
2379 if (writebuf
!= NULL
)
2381 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
2382 pulongest (len
), core_addr_to_string (memaddr
)));
2383 success
= WriteProcessMemory (current_process_handle
,
2384 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
2387 lasterror
= GetLastError ();
2388 FlushInstructionCache (current_process_handle
,
2389 (LPCVOID
) (uintptr_t) memaddr
, len
);
2393 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
2394 pulongest (len
), core_addr_to_string (memaddr
)));
2395 success
= ReadProcessMemory (current_process_handle
,
2396 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
2399 lasterror
= GetLastError ();
2401 *xfered_len
= (ULONGEST
) done
;
2402 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
2403 return TARGET_XFER_OK
;
2405 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
2409 windows_kill_inferior (struct target_ops
*ops
)
2411 CHECK (TerminateProcess (current_process_handle
, 0));
2415 if (!windows_continue (DBG_CONTINUE
, -1))
2417 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
2419 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2423 target_mourn_inferior (); /* Or just windows_mourn_inferior? */
2427 windows_close (struct target_ops
*self
)
2429 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2430 ptid_get_pid (inferior_ptid
)));
2433 /* Convert pid to printable format. */
2435 windows_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
2437 static char buf
[80];
2439 if (ptid_get_tid (ptid
) != 0)
2441 snprintf (buf
, sizeof (buf
), "Thread %d.0x%lx",
2442 ptid_get_pid (ptid
), ptid_get_tid (ptid
));
2446 return normal_pid_to_str (ptid
);
2449 static enum target_xfer_status
2450 windows_xfer_shared_libraries (struct target_ops
*ops
,
2451 enum target_object object
, const char *annex
,
2452 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2453 ULONGEST offset
, ULONGEST len
,
2454 ULONGEST
*xfered_len
)
2456 struct obstack obstack
;
2462 return TARGET_XFER_E_IO
;
2464 obstack_init (&obstack
);
2465 obstack_grow_str (&obstack
, "<library-list>\n");
2466 for (so
= solib_start
.next
; so
; so
= so
->next
)
2467 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
2468 (uintptr_t) so
->lm_info
->load_addr
,
2469 target_gdbarch (), &obstack
);
2470 obstack_grow_str0 (&obstack
, "</library-list>\n");
2472 buf
= obstack_finish (&obstack
);
2473 len_avail
= strlen (buf
);
2474 if (offset
>= len_avail
)
2478 if (len
> len_avail
- offset
)
2479 len
= len_avail
- offset
;
2480 memcpy (readbuf
, buf
+ offset
, len
);
2483 obstack_free (&obstack
, NULL
);
2484 *xfered_len
= (ULONGEST
) len
;
2485 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
2488 static enum target_xfer_status
2489 windows_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2490 const char *annex
, gdb_byte
*readbuf
,
2491 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
2492 ULONGEST
*xfered_len
)
2496 case TARGET_OBJECT_MEMORY
:
2497 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
2499 case TARGET_OBJECT_LIBRARIES
:
2500 return windows_xfer_shared_libraries (ops
, object
, annex
, readbuf
,
2501 writebuf
, offset
, len
, xfered_len
);
2504 if (ops
->beneath
!= NULL
)
2505 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2506 readbuf
, writebuf
, offset
, len
,
2508 return TARGET_XFER_E_IO
;
2512 /* Provide thread local base, i.e. Thread Information Block address.
2513 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
2516 windows_get_tib_address (struct target_ops
*self
,
2517 ptid_t ptid
, CORE_ADDR
*addr
)
2521 th
= thread_rec (ptid_get_tid (ptid
), 0);
2526 *addr
= th
->thread_local_base
;
2532 windows_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long thread
)
2534 return ptid_build (ptid_get_pid (inferior_ptid
), 0, lwp
);
2537 static struct target_ops
*
2538 windows_target (void)
2540 struct target_ops
*t
= inf_child_target ();
2542 t
->to_shortname
= "child";
2543 t
->to_longname
= "Win32 child process";
2544 t
->to_doc
= "Win32 child process (started by the \"run\" command).";
2545 t
->to_close
= windows_close
;
2546 t
->to_attach
= windows_attach
;
2547 t
->to_attach_no_wait
= 1;
2548 t
->to_detach
= windows_detach
;
2549 t
->to_resume
= windows_resume
;
2550 t
->to_wait
= windows_wait
;
2551 t
->to_fetch_registers
= windows_fetch_inferior_registers
;
2552 t
->to_store_registers
= windows_store_inferior_registers
;
2553 t
->to_xfer_partial
= windows_xfer_partial
;
2554 t
->to_files_info
= windows_files_info
;
2555 t
->to_kill
= windows_kill_inferior
;
2556 t
->to_create_inferior
= windows_create_inferior
;
2557 t
->to_mourn_inferior
= windows_mourn_inferior
;
2558 t
->to_thread_alive
= windows_thread_alive
;
2559 t
->to_pid_to_str
= windows_pid_to_str
;
2560 t
->to_stop
= windows_stop
;
2561 t
->to_pid_to_exec_file
= windows_pid_to_exec_file
;
2562 t
->to_get_ada_task_ptid
= windows_get_ada_task_ptid
;
2563 t
->to_get_tib_address
= windows_get_tib_address
;
2569 set_windows_aliases (char *argv0
)
2571 add_info_alias ("dll", "sharedlibrary", 1);
2574 /* -Wmissing-prototypes */
2575 extern initialize_file_ftype _initialize_windows_nat
;
2578 _initialize_windows_nat (void)
2580 struct cmd_list_element
*c
;
2581 struct target_ops
*t
;
2583 t
= windows_target ();
2585 i386_use_watchpoints (t
);
2587 i386_dr_low
.set_control
= cygwin_set_dr7
;
2588 i386_dr_low
.set_addr
= cygwin_set_dr
;
2589 i386_dr_low
.get_addr
= cygwin_get_dr
;
2590 i386_dr_low
.get_status
= cygwin_get_dr6
;
2591 i386_dr_low
.get_control
= cygwin_get_dr7
;
2593 /* i386_dr_low.debug_register_length field is set by
2594 calling i386_set_debug_register_length function
2595 in processor windows specific native file. */
2600 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
2603 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
2604 _("Load dll library symbols from FILE."));
2605 set_cmd_completer (c
, filename_completer
);
2606 deprecate_cmd (c
, "sharedlibrary");
2608 c
= add_com ("add-shared-symbol-files", class_files
, dll_symbol_command
,
2609 _("Load dll library symbols from FILE."));
2610 set_cmd_completer (c
, filename_completer
);
2611 deprecate_cmd (c
, "sharedlibrary");
2613 c
= add_com ("assf", class_files
, dll_symbol_command
,
2614 _("Load dll library symbols from FILE."));
2615 set_cmd_completer (c
, filename_completer
);
2616 deprecate_cmd (c
, "sharedlibrary");
2619 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
2620 Set use of shell to start subprocess."), _("\
2621 Show use of shell to start subprocess."), NULL
,
2623 NULL
, /* FIXME: i18n: */
2624 &setlist
, &showlist
);
2626 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
2627 &cygwin_exceptions
, _("\
2628 Break when an exception is detected in the Cygwin DLL itself."), _("\
2629 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
2631 NULL
, /* FIXME: i18n: */
2632 &setlist
, &showlist
);
2635 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
2636 Set creation of new console when creating child process."), _("\
2637 Show creation of new console when creating child process."), NULL
,
2639 NULL
, /* FIXME: i18n: */
2640 &setlist
, &showlist
);
2642 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
2643 Set creation of new group when creating child process."), _("\
2644 Show creation of new group when creating child process."), NULL
,
2646 NULL
, /* FIXME: i18n: */
2647 &setlist
, &showlist
);
2649 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
2650 Set whether to display execution in child process."), _("\
2651 Show whether to display execution in child process."), NULL
,
2653 NULL
, /* FIXME: i18n: */
2654 &setlist
, &showlist
);
2656 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
2657 Set whether to display kernel events in child process."), _("\
2658 Show whether to display kernel events in child process."), NULL
,
2660 NULL
, /* FIXME: i18n: */
2661 &setlist
, &showlist
);
2663 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
2664 Set whether to display memory accesses in child process."), _("\
2665 Show whether to display memory accesses in child process."), NULL
,
2667 NULL
, /* FIXME: i18n: */
2668 &setlist
, &showlist
);
2670 add_setshow_boolean_cmd ("debugexceptions", class_support
,
2671 &debug_exceptions
, _("\
2672 Set whether to display kernel exceptions in child process."), _("\
2673 Show whether to display kernel exceptions in child process."), NULL
,
2675 NULL
, /* FIXME: i18n: */
2676 &setlist
, &showlist
);
2678 init_w32_command_list ();
2680 add_cmd ("selector", class_info
, display_selectors
,
2681 _("Display selectors infos."),
2683 deprecated_init_ui_hook
= set_windows_aliases
;
2686 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2688 /* Pass the address ADDR to the inferior in the I'th debug register.
2689 Here we just store the address in dr array, the registers will be
2690 actually set up when windows_continue is called. */
2692 cygwin_set_dr (int i
, CORE_ADDR addr
)
2695 internal_error (__FILE__
, __LINE__
,
2696 _("Invalid register %d in cygwin_set_dr.\n"), i
);
2698 debug_registers_changed
= 1;
2699 debug_registers_used
= 1;
2702 /* Pass the value VAL to the inferior in the DR7 debug control
2703 register. Here we just store the address in D_REGS, the watchpoint
2704 will be actually set up in windows_wait. */
2706 cygwin_set_dr7 (unsigned long val
)
2708 dr
[7] = (CORE_ADDR
) val
;
2709 debug_registers_changed
= 1;
2710 debug_registers_used
= 1;
2713 /* Get the value of debug register I from the inferior. */
2716 cygwin_get_dr (int i
)
2721 /* Get the value of the DR6 debug status register from the inferior.
2722 Here we just return the value stored in dr[6]
2723 by the last call to thread_rec for current_event.dwThreadId id. */
2724 static unsigned long
2725 cygwin_get_dr6 (void)
2727 return (unsigned long) dr
[6];
2730 /* Get the value of the DR7 debug status register from the inferior.
2731 Here we just return the value stored in dr[7] by the last call to
2732 thread_rec for current_event.dwThreadId id. */
2734 static unsigned long
2735 cygwin_get_dr7 (void)
2737 return (unsigned long) dr
[7];
2740 /* Determine if the thread referenced by "ptid" is alive
2741 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2742 it means that the thread has died. Otherwise it is assumed to be alive. */
2744 windows_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
2748 gdb_assert (ptid_get_tid (ptid
) != 0);
2749 tid
= ptid_get_tid (ptid
);
2751 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
2755 /* -Wmissing-prototypes */
2756 extern initialize_file_ftype _initialize_check_for_gdb_ini
;
2759 _initialize_check_for_gdb_ini (void)
2762 if (inhibit_gdbinit
)
2765 homedir
= getenv ("HOME");
2769 char *oldini
= (char *) alloca (strlen (homedir
) +
2770 sizeof ("/gdb.ini"));
2771 strcpy (oldini
, homedir
);
2772 p
= strchr (oldini
, '\0');
2773 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
2775 strcpy (p
, "gdb.ini");
2776 if (access (oldini
, 0) == 0)
2778 int len
= strlen (oldini
);
2779 char *newini
= alloca (len
+ 1);
2781 xsnprintf (newini
, len
+ 1, "%.*s.gdbinit",
2782 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
2783 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
2788 /* Define dummy functions which always return error for the rare cases where
2789 these functions could not be found. */
2791 bad_DebugActiveProcessStop (DWORD w
)
2796 bad_DebugBreakProcess (HANDLE w
)
2801 bad_DebugSetProcessKillOnExit (BOOL w
)
2806 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
2813 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
2819 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
2826 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
2832 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
2838 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
2844 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
2852 /* -Wmissing-prototypes */
2853 extern initialize_file_ftype _initialize_loadable
;
2855 /* Load any functions which may not be available in ancient versions
2859 _initialize_loadable (void)
2863 hm
= LoadLibrary ("kernel32.dll");
2866 DebugActiveProcessStop
= (void *)
2867 GetProcAddress (hm
, "DebugActiveProcessStop");
2868 DebugBreakProcess
= (void *)
2869 GetProcAddress (hm
, "DebugBreakProcess");
2870 DebugSetProcessKillOnExit
= (void *)
2871 GetProcAddress (hm
, "DebugSetProcessKillOnExit");
2872 GetConsoleFontSize
= (void *)
2873 GetProcAddress (hm
, "GetConsoleFontSize");
2874 GetCurrentConsoleFont
= (void *)
2875 GetProcAddress (hm
, "GetCurrentConsoleFont");
2878 /* Set variables to dummy versions of these processes if the function
2879 wasn't found in kernel32.dll. */
2880 if (!DebugBreakProcess
)
2881 DebugBreakProcess
= bad_DebugBreakProcess
;
2882 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
2884 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
2885 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
2887 if (!GetConsoleFontSize
)
2888 GetConsoleFontSize
= bad_GetConsoleFontSize
;
2889 if (!GetCurrentConsoleFont
)
2890 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
2892 /* Load optional functions used for retrieving filename information
2893 associated with the currently debugged process or its dlls. */
2894 hm
= LoadLibrary ("psapi.dll");
2897 EnumProcessModules
= (void *)
2898 GetProcAddress (hm
, "EnumProcessModules");
2899 GetModuleInformation
= (void *)
2900 GetProcAddress (hm
, "GetModuleInformation");
2901 GetModuleFileNameEx
= (void *)
2902 GetProcAddress (hm
, GetModuleFileNameEx_name
);
2905 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
2907 /* Set variables to dummy versions of these processes if the function
2908 wasn't found in psapi.dll. */
2909 EnumProcessModules
= bad_EnumProcessModules
;
2910 GetModuleInformation
= bad_GetModuleInformation
;
2911 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
2912 /* This will probably fail on Windows 9x/Me. Let the user know
2913 that we're missing some functionality. */
2915 cannot automatically find executable file or library to read symbols.\n\
2916 Use \"file\" or \"dll\" command to load executable/libraries directly."));
2919 hm
= LoadLibrary ("advapi32.dll");
2922 OpenProcessToken
= (void *) GetProcAddress (hm
, "OpenProcessToken");
2923 LookupPrivilegeValueA
= (void *)
2924 GetProcAddress (hm
, "LookupPrivilegeValueA");
2925 AdjustTokenPrivileges
= (void *)
2926 GetProcAddress (hm
, "AdjustTokenPrivileges");
2927 /* Only need to set one of these since if OpenProcessToken fails nothing
2929 if (!OpenProcessToken
|| !LookupPrivilegeValueA
2930 || !AdjustTokenPrivileges
)
2931 OpenProcessToken
= bad_OpenProcessToken
;