1 /* Target-vector operations for controlling windows child processes, for GDB.
3 Copyright (C) 1995-2015 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 */
31 #include "completer.h"
35 #include <sys/types.h>
42 #include <sys/cygwin.h>
43 #include <cygwin/version.h>
47 #include "filenames.h"
51 #include "gdb_obstack.h"
52 #include "gdbthread.h"
58 #include "xml-support.h"
60 #include "i386-tdep.h"
61 #include "i387-tdep.h"
63 #include "windows-tdep.h"
64 #include "windows-nat.h"
66 #include "complaints.h"
67 #include "inf-child.h"
69 #define AdjustTokenPrivileges dyn_AdjustTokenPrivileges
70 #define DebugActiveProcessStop dyn_DebugActiveProcessStop
71 #define DebugBreakProcess dyn_DebugBreakProcess
72 #define DebugSetProcessKillOnExit dyn_DebugSetProcessKillOnExit
73 #define EnumProcessModules dyn_EnumProcessModules
74 #define GetModuleInformation dyn_GetModuleInformation
75 #define LookupPrivilegeValueA dyn_LookupPrivilegeValueA
76 #define OpenProcessToken dyn_OpenProcessToken
77 #define GetConsoleFontSize dyn_GetConsoleFontSize
78 #define GetCurrentConsoleFont dyn_GetCurrentConsoleFont
80 static BOOL
WINAPI (*AdjustTokenPrivileges
)(HANDLE
, BOOL
, PTOKEN_PRIVILEGES
,
81 DWORD
, PTOKEN_PRIVILEGES
, PDWORD
);
82 static BOOL
WINAPI (*DebugActiveProcessStop
) (DWORD
);
83 static BOOL
WINAPI (*DebugBreakProcess
) (HANDLE
);
84 static BOOL
WINAPI (*DebugSetProcessKillOnExit
) (BOOL
);
85 static BOOL
WINAPI (*EnumProcessModules
) (HANDLE
, HMODULE
*, DWORD
,
87 static BOOL
WINAPI (*GetModuleInformation
) (HANDLE
, HMODULE
, LPMODULEINFO
,
89 static BOOL
WINAPI (*LookupPrivilegeValueA
)(LPCSTR
, LPCSTR
, PLUID
);
90 static BOOL
WINAPI (*OpenProcessToken
)(HANDLE
, DWORD
, PHANDLE
);
91 static BOOL
WINAPI (*GetCurrentConsoleFont
) (HANDLE
, BOOL
,
93 static COORD
WINAPI (*GetConsoleFontSize
) (HANDLE
, DWORD
);
97 #undef GetModuleFileNameEx
100 # define __PMAX (MAX_PATH + 1)
101 static DWORD
WINAPI (*GetModuleFileNameEx
) (HANDLE
, HMODULE
, LPSTR
, DWORD
);
102 # define STARTUPINFO STARTUPINFOA
103 # define CreateProcess CreateProcessA
104 # define GetModuleFileNameEx_name "GetModuleFileNameExA"
105 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
107 # define __PMAX PATH_MAX
108 /* The starting and ending address of the cygwin1.dll text segment. */
109 static CORE_ADDR cygwin_load_start
;
110 static CORE_ADDR cygwin_load_end
;
112 typedef wchar_t cygwin_buf_t
;
113 static DWORD
WINAPI (*GetModuleFileNameEx
) (HANDLE
, HMODULE
,
115 # define STARTUPINFO STARTUPINFOW
116 # define CreateProcess CreateProcessW
117 # define GetModuleFileNameEx_name "GetModuleFileNameExW"
118 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExW
121 static int have_saved_context
; /* True if we've saved context from a
123 static CONTEXT saved_context
; /* Containes the saved context from a
126 /* If we're not using the old Cygwin header file set, define the
127 following which never should have been in the generic Win32 API
128 headers in the first place since they were our own invention... */
129 #ifndef _GNU_H_WINDOWS_H
132 FLAG_TRACE_BIT
= 0x100,
136 #ifndef CONTEXT_EXTENDED_REGISTERS
137 /* This macro is only defined on ia32. It only makes sense on this target,
138 so define it as zero if not already defined. */
139 #define CONTEXT_EXTENDED_REGISTERS 0
142 #define CONTEXT_DEBUGGER_DR CONTEXT_FULL | CONTEXT_FLOATING_POINT \
143 | CONTEXT_SEGMENTS | CONTEXT_DEBUG_REGISTERS \
144 | CONTEXT_EXTENDED_REGISTERS
146 static uintptr_t dr
[8];
147 static int debug_registers_changed
;
148 static int debug_registers_used
;
150 static int windows_initialization_done
;
151 #define DR6_CLEAR_VALUE 0xffff0ff0
153 /* The string sent by cygwin when it processes a signal.
154 FIXME: This should be in a cygwin include file. */
155 #ifndef _CYGWIN_SIGNAL_STRING
156 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
159 #define CHECK(x) check (x, __FILE__,__LINE__)
160 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
161 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
162 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
163 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
165 static void windows_stop (struct target_ops
*self
, ptid_t
);
166 static int windows_thread_alive (struct target_ops
*, ptid_t
);
167 static void windows_kill_inferior (struct target_ops
*);
169 static void cygwin_set_dr (int i
, CORE_ADDR addr
);
170 static void cygwin_set_dr7 (unsigned long val
);
171 static CORE_ADDR
cygwin_get_dr (int i
);
172 static unsigned long cygwin_get_dr6 (void);
173 static unsigned long cygwin_get_dr7 (void);
175 static enum gdb_signal last_sig
= GDB_SIGNAL_0
;
176 /* Set if a signal was received from the debugged process. */
178 /* Thread information structure used to track information that is
179 not available in gdb's thread structure. */
180 typedef struct windows_thread_info_struct
182 struct windows_thread_info_struct
*next
;
185 CORE_ADDR thread_local_base
;
194 static windows_thread_info thread_head
;
196 /* The process and thread handles for the above context. */
198 static DEBUG_EVENT current_event
; /* The current debug event from
200 static HANDLE current_process_handle
; /* Currently executing process */
201 static windows_thread_info
*current_thread
; /* Info on currently selected thread */
202 static DWORD main_thread_id
; /* Thread ID of the main thread */
204 /* Counts of things. */
205 static int exception_count
= 0;
206 static int event_count
= 0;
207 static int saw_create
;
208 static int open_process_used
= 0;
211 static int new_console
= 0;
213 static int cygwin_exceptions
= 0;
215 static int new_group
= 1;
216 static int debug_exec
= 0; /* show execution */
217 static int debug_events
= 0; /* show events from kernel */
218 static int debug_memory
= 0; /* show target memory accesses */
219 static int debug_exceptions
= 0; /* show target exceptions */
220 static int useshell
= 0; /* use shell for subprocesses */
222 /* This vector maps GDB's idea of a register's number into an offset
223 in the windows exception context vector.
225 It also contains the bit mask needed to load the register in question.
227 The contents of this table can only be computed by the units
228 that provide CPU-specific support for Windows native debugging.
229 These units should set the table by calling
230 windows_set_context_register_offsets.
232 One day we could read a reg, we could inspect the context we
233 already have loaded, if it doesn't have the bit set that we need,
234 we read that set of registers in using GetThreadContext. If the
235 context already contains what we need, we just unpack it. Then to
236 write a register, first we have to ensure that the context contains
237 the other regs of the group, and then we copy the info in and set
240 static const int *mappings
;
242 /* The function to use in order to determine whether a register is
243 a segment register or not. */
244 static segment_register_p_ftype
*segment_register_p
;
246 /* This vector maps the target's idea of an exception (extracted
247 from the DEBUG_EVENT structure) to GDB's idea. */
249 struct xlate_exception
255 static const struct xlate_exception
258 {EXCEPTION_ACCESS_VIOLATION
, GDB_SIGNAL_SEGV
},
259 {STATUS_STACK_OVERFLOW
, GDB_SIGNAL_SEGV
},
260 {EXCEPTION_BREAKPOINT
, GDB_SIGNAL_TRAP
},
261 {DBG_CONTROL_C
, GDB_SIGNAL_INT
},
262 {EXCEPTION_SINGLE_STEP
, GDB_SIGNAL_TRAP
},
263 {STATUS_FLOAT_DIVIDE_BY_ZERO
, GDB_SIGNAL_FPE
},
266 /* Set the MAPPINGS static global to OFFSETS.
267 See the description of MAPPINGS for more details. */
270 windows_set_context_register_offsets (const int *offsets
)
275 /* See windows-nat.h. */
278 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
280 segment_register_p
= fun
;
284 check (BOOL ok
, const char *file
, int line
)
287 printf_filtered ("error return %s:%d was %u\n", file
, line
,
288 (unsigned) GetLastError ());
291 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
292 then also retrieve the context for this thread. If GET_CONTEXT is
293 negative, then don't suspend the thread. */
294 static windows_thread_info
*
295 thread_rec (DWORD id
, int get_context
)
297 windows_thread_info
*th
;
299 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
302 if (!th
->suspended
&& get_context
)
304 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
306 if (SuspendThread (th
->h
) == (DWORD
) -1)
308 DWORD err
= GetLastError ();
310 /* We get Access Denied (5) when trying to suspend
311 threads that Windows started on behalf of the
312 debuggee, usually when those threads are just
314 if (err
!= ERROR_ACCESS_DENIED
)
315 warning (_("SuspendThread (tid=0x%x) failed."
317 (unsigned) id
, (unsigned) err
);
323 else if (get_context
< 0)
325 th
->reload_context
= 1;
333 /* Add a thread to the thread list. */
334 static windows_thread_info
*
335 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
)
337 windows_thread_info
*th
;
340 gdb_assert (ptid_get_tid (ptid
) != 0);
342 id
= ptid_get_tid (ptid
);
344 if ((th
= thread_rec (id
, FALSE
)))
347 th
= XCNEW (windows_thread_info
);
350 th
->thread_local_base
= (CORE_ADDR
) (uintptr_t) tlb
;
351 th
->next
= thread_head
.next
;
352 thread_head
.next
= th
;
354 /* Set the debug registers for the new thread if they are used. */
355 if (debug_registers_used
)
357 /* Only change the value of the debug registers. */
358 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
359 CHECK (GetThreadContext (th
->h
, &th
->context
));
360 th
->context
.Dr0
= dr
[0];
361 th
->context
.Dr1
= dr
[1];
362 th
->context
.Dr2
= dr
[2];
363 th
->context
.Dr3
= dr
[3];
364 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
365 th
->context
.Dr7
= dr
[7];
366 CHECK (SetThreadContext (th
->h
, &th
->context
));
367 th
->context
.ContextFlags
= 0;
372 /* Clear out any old thread list and reintialize it to a
375 windows_init_thread_list (void)
377 windows_thread_info
*th
= &thread_head
;
379 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
381 while (th
->next
!= NULL
)
383 windows_thread_info
*here
= th
->next
;
384 th
->next
= here
->next
;
387 thread_head
.next
= NULL
;
390 /* Delete a thread from the list of threads. */
392 windows_delete_thread (ptid_t ptid
, DWORD exit_code
)
394 windows_thread_info
*th
;
397 gdb_assert (ptid_get_tid (ptid
) != 0);
399 id
= ptid_get_tid (ptid
);
402 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
));
403 else if (print_thread_events
&& id
!= main_thread_id
)
404 printf_unfiltered (_("[%s exited with code %u]\n"),
405 target_pid_to_str (ptid
), (unsigned) exit_code
);
406 delete_thread (ptid
);
408 for (th
= &thread_head
;
409 th
->next
!= NULL
&& th
->next
->id
!= id
;
413 if (th
->next
!= NULL
)
415 windows_thread_info
*here
= th
->next
;
416 th
->next
= here
->next
;
422 do_windows_fetch_inferior_registers (struct regcache
*regcache
, int r
)
424 char *context_offset
= ((char *) ¤t_thread
->context
) + mappings
[r
];
425 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
426 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
430 return; /* Windows sometimes uses a non-existent thread id in its
433 if (current_thread
->reload_context
)
435 #ifdef __COPY_CONTEXT_SIZE
436 if (have_saved_context
)
438 /* Lie about where the program actually is stopped since
439 cygwin has informed us that we should consider the signal
440 to have occurred at another location which is stored in
442 memcpy (¤t_thread
->context
, &saved_context
,
443 __COPY_CONTEXT_SIZE
);
444 have_saved_context
= 0;
449 windows_thread_info
*th
= current_thread
;
450 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
451 CHECK (GetThreadContext (th
->h
, &th
->context
));
452 /* Copy dr values from that thread.
453 But only if there were not modified since last stop.
455 if (!debug_registers_changed
)
457 dr
[0] = th
->context
.Dr0
;
458 dr
[1] = th
->context
.Dr1
;
459 dr
[2] = th
->context
.Dr2
;
460 dr
[3] = th
->context
.Dr3
;
461 dr
[6] = th
->context
.Dr6
;
462 dr
[7] = th
->context
.Dr7
;
465 current_thread
->reload_context
= 0;
468 if (r
== I387_FISEG_REGNUM (tdep
))
470 l
= *((long *) context_offset
) & 0xffff;
471 regcache_raw_supply (regcache
, r
, (char *) &l
);
473 else if (r
== I387_FOP_REGNUM (tdep
))
475 l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
476 regcache_raw_supply (regcache
, r
, (char *) &l
);
478 else if (segment_register_p (r
))
480 /* GDB treats segment registers as 32bit registers, but they are
481 in fact only 16 bits long. Make sure we do not read extra
482 bits from our source buffer. */
483 l
= *((long *) context_offset
) & 0xffff;
484 regcache_raw_supply (regcache
, r
, (char *) &l
);
487 regcache_raw_supply (regcache
, r
, context_offset
);
490 for (r
= 0; r
< gdbarch_num_regs (gdbarch
); r
++)
491 do_windows_fetch_inferior_registers (regcache
, r
);
496 windows_fetch_inferior_registers (struct target_ops
*ops
,
497 struct regcache
*regcache
, int r
)
499 current_thread
= thread_rec (ptid_get_tid (inferior_ptid
), TRUE
);
500 /* Check if current_thread exists. Windows sometimes uses a non-existent
501 thread id in its events. */
503 do_windows_fetch_inferior_registers (regcache
, r
);
507 do_windows_store_inferior_registers (const struct regcache
*regcache
, int r
)
510 /* Windows sometimes uses a non-existent thread id in its events. */;
512 regcache_raw_collect (regcache
, r
,
513 ((char *) ¤t_thread
->context
) + mappings
[r
]);
516 for (r
= 0; r
< gdbarch_num_regs (get_regcache_arch (regcache
)); r
++)
517 do_windows_store_inferior_registers (regcache
, r
);
521 /* Store a new register value into the current thread context. */
523 windows_store_inferior_registers (struct target_ops
*ops
,
524 struct regcache
*regcache
, int r
)
526 current_thread
= thread_rec (ptid_get_tid (inferior_ptid
), TRUE
);
527 /* Check if current_thread exists. Windows sometimes uses a non-existent
528 thread id in its events. */
530 do_windows_store_inferior_registers (regcache
, r
);
533 /* Encapsulate the information required in a call to
534 symbol_file_add_args. */
535 struct safe_symbol_file_add_args
539 struct section_addr_info
*addrs
;
542 struct ui_file
*err
, *out
;
546 /* Maintain a linked list of "so" information. */
552 static struct so_list solib_start
, *solib_end
;
554 static struct so_list
*
555 windows_make_so (const char *name
, LPVOID load_addr
)
562 WIN32_FIND_DATA w32_fd
;
563 HANDLE h
= FindFirstFile(name
, &w32_fd
);
565 if (h
== INVALID_HANDLE_VALUE
)
571 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
573 p
= strrchr (buf
, '\\');
576 SetCurrentDirectory (buf
);
577 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
578 SetCurrentDirectory (cwd
);
581 if (strcasecmp (buf
, "ntdll.dll") == 0)
583 GetSystemDirectory (buf
, sizeof (buf
));
584 strcat (buf
, "\\ntdll.dll");
587 cygwin_buf_t buf
[__PMAX
];
590 if (access (name
, F_OK
) != 0)
592 if (strcasecmp (name
, "ntdll.dll") == 0)
595 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
596 wcscat (buf
, L
"\\ntdll.dll");
600 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
601 strcat (buf
, "\\ntdll.dll");
606 so
= XCNEW (struct so_list
);
607 so
->lm_info
= (struct lm_info
*) xmalloc (sizeof (struct lm_info
));
608 so
->lm_info
->load_addr
= load_addr
;
609 strcpy (so
->so_original_name
, name
);
611 strcpy (so
->so_name
, buf
);
614 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
615 SO_NAME_MAX_PATH_SIZE
);
618 char *rname
= realpath (name
, NULL
);
619 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
621 strcpy (so
->so_name
, rname
);
625 error (_("dll path too long"));
627 /* Record cygwin1.dll .text start/end. */
628 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
629 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
632 asection
*text
= NULL
;
635 abfd
= gdb_bfd_open (so
->so_name
, "pei-i386", -1);
640 if (bfd_check_format (abfd
, bfd_object
))
641 text
= bfd_get_section_by_name (abfd
, ".text");
645 gdb_bfd_unref (abfd
);
649 /* The symbols in a dll are offset by 0x1000, which is the
650 offset from 0 of the first byte in an image - because of the
651 file header and the section alignment. */
652 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
654 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (abfd
, text
);
656 gdb_bfd_unref (abfd
);
664 get_image_name (HANDLE h
, void *address
, int unicode
)
667 static char buf
[__PMAX
];
669 static char buf
[(2 * __PMAX
) + 1];
671 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
677 /* Attempt to read the name of the dll that was detected.
678 This is documented to work only when actively debugging
679 a program. It will not work for attached processes. */
683 /* See if we could read the address of a string, and that the
684 address isn't null. */
685 if (!ReadProcessMemory (h
, address
, &address_ptr
,
686 sizeof (address_ptr
), &done
)
687 || done
!= sizeof (address_ptr
) || !address_ptr
)
690 /* Find the length of the string. */
691 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
692 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
696 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
699 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
700 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
703 wcstombs (buf
, unicode_address
, __PMAX
);
705 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
713 /* Handle a DLL load event, and return 1.
715 This function assumes that this event did not occur during inferior
716 initialization, where their event info may be incomplete (see
717 do_initial_windows_stuff and windows_add_all_dlls for more info
718 on how we handle DLL loading during that phase). */
721 handle_load_dll (void *dummy
)
723 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
726 /* Try getting the DLL name via the lpImageName field of the event.
727 Note that Microsoft documents this fields as strictly optional,
728 in the sense that it might be NULL. And the first DLL event in
729 particular is explicitly documented as "likely not pass[ed]"
730 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
731 dll_name
= get_image_name (current_process_handle
,
732 event
->lpImageName
, event
->fUnicode
);
736 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
737 solib_end
= solib_end
->next
;
739 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
740 host_address_to_string (solib_end
->lm_info
->load_addr
)));
746 windows_free_so (struct so_list
*so
)
753 /* Handle a DLL unload event.
754 Return 1 if successful, or zero otherwise.
756 This function assumes that this event did not occur during inferior
757 initialization, where their event info may be incomplete (see
758 do_initial_windows_stuff and windows_add_all_dlls for more info
759 on how we handle DLL loading during that phase). */
762 handle_unload_dll (void *dummy
)
764 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
767 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
768 if (so
->next
->lm_info
->load_addr
== lpBaseOfDll
)
770 struct so_list
*sodel
= so
->next
;
772 so
->next
= sodel
->next
;
775 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
777 windows_free_so (sodel
);
781 /* We did not find any DLL that was previously loaded at this address,
782 so register a complaint. We do not report an error, because we have
783 observed that this may be happening under some circumstances. For
784 instance, running 32bit applications on x64 Windows causes us to receive
785 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
786 events are apparently caused by the WOW layer, the interface between
787 32bit and 64bit worlds). */
788 complaint (&symfile_complaints
, _("dll starting at %s not found."),
789 host_address_to_string (lpBaseOfDll
));
794 /* Clear list of loaded DLLs. */
796 windows_clear_solib (void)
798 solib_start
.next
= NULL
;
799 solib_end
= &solib_start
;
802 /* Handle DEBUG_STRING output from child process.
803 Cygwin prepends its messages with a "cygwin:". Interpret this as
804 a Cygwin signal. Otherwise just print the string as a warning. */
806 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
811 if (!target_read_string
812 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
816 else if (!startswith (s
, _CYGWIN_SIGNAL_STRING
))
819 if (!startswith (s
, "cYg"))
822 char *p
= strchr (s
, '\0');
824 if (p
> s
&& *--p
== '\n')
829 #ifdef __COPY_CONTEXT_SIZE
832 /* Got a cygwin signal marker. A cygwin signal is followed by
833 the signal number itself and then optionally followed by the
834 thread id and address to saved context within the DLL. If
835 these are supplied, then the given thread is assumed to have
836 issued the signal and the context from the thread is assumed
837 to be stored at the given address in the inferior. Tell gdb
838 to treat this like a real signal. */
840 int sig
= strtol (s
+ sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
841 int gotasig
= gdb_signal_from_host (sig
);
843 ourstatus
->value
.sig
= gotasig
;
849 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
850 retval
= strtoul (p
, &p
, 0);
852 retval
= main_thread_id
;
853 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
854 && ReadProcessMemory (current_process_handle
, x
,
856 __COPY_CONTEXT_SIZE
, &n
)
857 && n
== __COPY_CONTEXT_SIZE
)
858 have_saved_context
= 1;
869 display_selector (HANDLE thread
, DWORD sel
)
872 if (GetThreadSelectorEntry (thread
, sel
, &info
))
875 printf_filtered ("0x%03x: ", (unsigned) sel
);
876 if (!info
.HighWord
.Bits
.Pres
)
878 puts_filtered ("Segment not present\n");
881 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
882 (info
.HighWord
.Bits
.BaseMid
<< 16)
884 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
885 if (info
.HighWord
.Bits
.Granularity
)
886 limit
= (limit
<< 12) | 0xfff;
887 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
888 if (info
.HighWord
.Bits
.Default_Big
)
889 puts_filtered(" 32-bit ");
891 puts_filtered(" 16-bit ");
892 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
895 puts_filtered ("Data (Read-Only, Exp-up");
898 puts_filtered ("Data (Read/Write, Exp-up");
901 puts_filtered ("Unused segment (");
904 puts_filtered ("Data (Read/Write, Exp-down");
907 puts_filtered ("Code (Exec-Only, N.Conf");
910 puts_filtered ("Code (Exec/Read, N.Conf");
913 puts_filtered ("Code (Exec-Only, Conf");
916 puts_filtered ("Code (Exec/Read, Conf");
919 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
921 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
922 puts_filtered(", N.Acc");
923 puts_filtered (")\n");
924 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
925 puts_filtered("System selector ");
926 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
927 if (info
.HighWord
.Bits
.Granularity
)
928 puts_filtered ("Page granular.\n");
930 puts_filtered ("Byte granular.\n");
935 DWORD err
= GetLastError ();
936 if (err
== ERROR_NOT_SUPPORTED
)
937 printf_filtered ("Function not supported\n");
939 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) 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 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
984 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
985 host_address_to_string (\
986 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
989 handle_exception (struct target_waitstatus
*ourstatus
)
991 windows_thread_info
*th
;
992 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
994 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
996 /* Record the context of the current thread. */
997 th
= thread_rec (current_event
.dwThreadId
, -1);
1001 case EXCEPTION_ACCESS_VIOLATION
:
1002 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1003 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1006 /* See if the access violation happened within the cygwin DLL
1007 itself. Cygwin uses a kind of exception handling to deal
1008 with passed-in invalid addresses. gdb should not treat
1009 these as real SEGVs since they will be silently handled by
1010 cygwin. A real SEGV will (theoretically) be caught by
1011 cygwin later in the process and will be sent as a
1012 cygwin-specific-signal. So, ignore SEGVs if they show up
1013 within the text segment of the DLL itself. */
1015 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t)
1016 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
;
1018 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1019 && addr
< cygwin_load_end
))
1020 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1021 && startswith (fn
, "KERNEL32!IsBad")))
1026 case STATUS_STACK_OVERFLOW
:
1027 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1028 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1030 case STATUS_FLOAT_DENORMAL_OPERAND
:
1031 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1032 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1034 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1035 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1036 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1038 case STATUS_FLOAT_INEXACT_RESULT
:
1039 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1040 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1042 case STATUS_FLOAT_INVALID_OPERATION
:
1043 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1044 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1046 case STATUS_FLOAT_OVERFLOW
:
1047 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1048 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1050 case STATUS_FLOAT_STACK_CHECK
:
1051 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1052 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1054 case STATUS_FLOAT_UNDERFLOW
:
1055 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1056 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1058 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1059 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1060 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1062 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1063 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1064 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1066 case STATUS_INTEGER_OVERFLOW
:
1067 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1068 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1070 case EXCEPTION_BREAKPOINT
:
1071 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1072 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1075 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1076 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1078 case DBG_CONTROL_BREAK
:
1079 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1080 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1082 case EXCEPTION_SINGLE_STEP
:
1083 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1084 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1086 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1087 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1088 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1090 case EXCEPTION_PRIV_INSTRUCTION
:
1091 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1092 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1094 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1095 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1096 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1099 /* Treat unhandled first chance exceptions specially. */
1100 if (current_event
.u
.Exception
.dwFirstChance
)
1102 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1103 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1104 host_address_to_string (
1105 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1106 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1110 last_sig
= ourstatus
->value
.sig
;
1114 /* Resume thread specified by ID, or all artificially suspended
1115 threads, if we are continuing execution. KILLED non-zero means we
1116 have killed the inferior, so we should ignore weird errors due to
1117 threads shutting down. */
1119 windows_continue (DWORD continue_status
, int id
, int killed
)
1122 windows_thread_info
*th
;
1125 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1126 (unsigned) current_event
.dwProcessId
,
1127 (unsigned) 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
)
1149 if (GetExitCodeThread (th
->h
, &ec
)
1150 && ec
== STILL_ACTIVE
)
1152 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1157 th
->context
.ContextFlags
= 0;
1159 if (th
->suspended
> 0)
1160 (void) ResumeThread (th
->h
);
1164 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1165 current_event
.dwThreadId
,
1169 error (_("Failed to resume program execution"
1170 " (ContinueDebugEvent failed, error %u)"),
1171 (unsigned int) GetLastError ());
1173 debug_registers_changed
= 0;
1177 /* Called in pathological case where Windows fails to send a
1178 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1180 fake_create_process (void)
1182 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1183 current_event
.dwProcessId
);
1184 if (current_process_handle
!= NULL
)
1185 open_process_used
= 1;
1188 error (_("OpenProcess call failed, GetLastError = %u"),
1189 (unsigned) GetLastError ());
1190 /* We can not debug anything in that case. */
1192 main_thread_id
= current_event
.dwThreadId
;
1193 current_thread
= windows_add_thread (
1194 ptid_build (current_event
.dwProcessId
, 0,
1195 current_event
.dwThreadId
),
1196 current_event
.u
.CreateThread
.hThread
,
1197 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1198 return main_thread_id
;
1202 windows_resume (struct target_ops
*ops
,
1203 ptid_t ptid
, int step
, enum gdb_signal sig
)
1205 windows_thread_info
*th
;
1206 DWORD continue_status
= DBG_CONTINUE
;
1208 /* A specific PTID means `step only this thread id'. */
1209 int resume_all
= ptid_equal (ptid
, minus_one_ptid
);
1211 /* If we're continuing all threads, it's the current inferior that
1212 should be handled specially. */
1214 ptid
= inferior_ptid
;
1216 if (sig
!= GDB_SIGNAL_0
)
1218 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1220 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1222 else if (sig
== last_sig
)
1223 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1226 /* This code does not seem to work, because
1227 the kernel does probably not consider changes in the ExceptionRecord
1228 structure when passing the exception to the inferior.
1229 Note that this seems possible in the exception handler itself. */
1232 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1233 if (xlate
[i
].us
== sig
)
1235 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1237 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1240 if (continue_status
== DBG_CONTINUE
)
1242 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1246 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1250 last_sig
= GDB_SIGNAL_0
;
1252 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1253 ptid_get_pid (ptid
), ptid_get_tid (ptid
), step
, sig
));
1255 /* Get context for currently selected thread. */
1256 th
= thread_rec (ptid_get_tid (inferior_ptid
), FALSE
);
1261 /* Single step by setting t bit. */
1262 struct regcache
*regcache
= get_current_regcache ();
1263 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1264 windows_fetch_inferior_registers (ops
, regcache
,
1265 gdbarch_ps_regnum (gdbarch
));
1266 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1269 if (th
->context
.ContextFlags
)
1271 if (debug_registers_changed
)
1273 th
->context
.Dr0
= dr
[0];
1274 th
->context
.Dr1
= dr
[1];
1275 th
->context
.Dr2
= dr
[2];
1276 th
->context
.Dr3
= dr
[3];
1277 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1278 th
->context
.Dr7
= dr
[7];
1280 CHECK (SetThreadContext (th
->h
, &th
->context
));
1281 th
->context
.ContextFlags
= 0;
1285 /* Allow continuing with the same signal that interrupted us.
1286 Otherwise complain. */
1289 windows_continue (continue_status
, -1, 0);
1291 windows_continue (continue_status
, ptid_get_tid (ptid
), 0);
1294 /* Ctrl-C handler used when the inferior is not run in the same console. The
1295 handler is in charge of interrupting the inferior using DebugBreakProcess.
1296 Note that this function is not available prior to Windows XP. In this case
1297 we emit a warning. */
1299 ctrl_c_handler (DWORD event_type
)
1301 const int attach_flag
= current_inferior ()->attach_flag
;
1303 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1304 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1307 /* If the inferior and the debugger share the same console, do nothing as
1308 the inferior has also received the Ctrl-C event. */
1309 if (!new_console
&& !attach_flag
)
1312 if (!DebugBreakProcess (current_process_handle
))
1313 warning (_("Could not interrupt program. "
1314 "Press Ctrl-c in the program console."));
1316 /* Return true to tell that Ctrl-C has been handled. */
1320 /* Get the next event from the child. Returns a non-zero thread id if the event
1321 requires handling by WFI (or whatever). */
1323 get_windows_debug_event (struct target_ops
*ops
,
1324 int pid
, struct target_waitstatus
*ourstatus
)
1327 DWORD continue_status
, event_code
;
1328 windows_thread_info
*th
;
1329 static windows_thread_info dummy_thread_info
;
1330 DWORD thread_id
= 0;
1332 last_sig
= GDB_SIGNAL_0
;
1334 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1338 continue_status
= DBG_CONTINUE
;
1340 event_code
= current_event
.dwDebugEventCode
;
1341 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1343 have_saved_context
= 0;
1347 case CREATE_THREAD_DEBUG_EVENT
:
1348 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1349 (unsigned) current_event
.dwProcessId
,
1350 (unsigned) current_event
.dwThreadId
,
1351 "CREATE_THREAD_DEBUG_EVENT"));
1352 if (saw_create
!= 1)
1354 struct inferior
*inf
;
1355 inf
= find_inferior_pid (current_event
.dwProcessId
);
1356 if (!saw_create
&& inf
->attach_flag
)
1358 /* Kludge around a Windows bug where first event is a create
1359 thread event. Caused when attached process does not have
1361 thread_id
= fake_create_process ();
1367 /* Record the existence of this thread. */
1368 thread_id
= current_event
.dwThreadId
;
1369 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1370 current_event
.dwThreadId
),
1371 current_event
.u
.CreateThread
.hThread
,
1372 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1376 case EXIT_THREAD_DEBUG_EVENT
:
1377 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1378 (unsigned) current_event
.dwProcessId
,
1379 (unsigned) current_event
.dwThreadId
,
1380 "EXIT_THREAD_DEBUG_EVENT"));
1382 if (current_event
.dwThreadId
!= main_thread_id
)
1384 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1385 current_event
.dwThreadId
),
1386 current_event
.u
.ExitThread
.dwExitCode
);
1387 th
= &dummy_thread_info
;
1391 case CREATE_PROCESS_DEBUG_EVENT
:
1392 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1393 (unsigned) current_event
.dwProcessId
,
1394 (unsigned) current_event
.dwThreadId
,
1395 "CREATE_PROCESS_DEBUG_EVENT"));
1396 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1397 if (++saw_create
!= 1)
1400 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1402 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1405 main_thread_id
= current_event
.dwThreadId
;
1406 /* Add the main thread. */
1407 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1408 current_event
.dwThreadId
),
1409 current_event
.u
.CreateProcessInfo
.hThread
,
1410 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
);
1411 thread_id
= current_event
.dwThreadId
;
1414 case EXIT_PROCESS_DEBUG_EVENT
:
1415 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1416 (unsigned) current_event
.dwProcessId
,
1417 (unsigned) current_event
.dwThreadId
,
1418 "EXIT_PROCESS_DEBUG_EVENT"));
1419 if (!windows_initialization_done
)
1421 target_terminal_ours ();
1422 target_mourn_inferior ();
1423 error (_("During startup program exited with code 0x%x."),
1424 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1426 else if (saw_create
== 1)
1428 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1429 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1430 thread_id
= main_thread_id
;
1434 case LOAD_DLL_DEBUG_EVENT
:
1435 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1436 (unsigned) current_event
.dwProcessId
,
1437 (unsigned) current_event
.dwThreadId
,
1438 "LOAD_DLL_DEBUG_EVENT"));
1439 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1440 if (saw_create
!= 1 || ! windows_initialization_done
)
1442 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1443 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1444 ourstatus
->value
.integer
= 0;
1445 thread_id
= main_thread_id
;
1448 case UNLOAD_DLL_DEBUG_EVENT
:
1449 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1450 (unsigned) current_event
.dwProcessId
,
1451 (unsigned) current_event
.dwThreadId
,
1452 "UNLOAD_DLL_DEBUG_EVENT"));
1453 if (saw_create
!= 1 || ! windows_initialization_done
)
1455 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1456 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1457 ourstatus
->value
.integer
= 0;
1458 thread_id
= main_thread_id
;
1461 case EXCEPTION_DEBUG_EVENT
:
1462 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1463 (unsigned) current_event
.dwProcessId
,
1464 (unsigned) current_event
.dwThreadId
,
1465 "EXCEPTION_DEBUG_EVENT"));
1466 if (saw_create
!= 1)
1468 switch (handle_exception (ourstatus
))
1471 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1474 thread_id
= current_event
.dwThreadId
;
1478 continue_status
= -1;
1483 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1484 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1485 (unsigned) current_event
.dwProcessId
,
1486 (unsigned) current_event
.dwThreadId
,
1487 "OUTPUT_DEBUG_STRING_EVENT"));
1488 if (saw_create
!= 1)
1490 thread_id
= handle_output_debug_string (ourstatus
);
1494 if (saw_create
!= 1)
1496 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1497 (unsigned) current_event
.dwProcessId
,
1498 (unsigned) current_event
.dwThreadId
);
1499 printf_unfiltered (" unknown event code %u\n",
1500 (unsigned) current_event
.dwDebugEventCode
);
1504 if (!thread_id
|| saw_create
!= 1)
1506 if (continue_status
== -1)
1507 windows_resume (ops
, minus_one_ptid
, 0, 1);
1509 CHECK (windows_continue (continue_status
, -1, 0));
1513 inferior_ptid
= ptid_build (current_event
.dwProcessId
, 0,
1515 current_thread
= th
;
1516 if (!current_thread
)
1517 current_thread
= thread_rec (thread_id
, TRUE
);
1524 /* Wait for interesting events to occur in the target process. */
1526 windows_wait (struct target_ops
*ops
,
1527 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
1531 target_terminal_ours ();
1533 /* We loop when we get a non-standard exception rather than return
1534 with a SPURIOUS because resume can try and step or modify things,
1535 which needs a current_thread->h. But some of these exceptions mark
1536 the birth or death of threads, which mean that the current thread
1537 isn't necessarily what you think it is. */
1543 /* If the user presses Ctrl-c while the debugger is waiting
1544 for an event, he expects the debugger to interrupt his program
1545 and to get the prompt back. There are two possible situations:
1547 - The debugger and the program do not share the console, in
1548 which case the Ctrl-c event only reached the debugger.
1549 In that case, the ctrl_c handler will take care of interrupting
1550 the inferior. Note that this case is working starting with
1551 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1554 - The debugger and the program share the same console, in which
1555 case both debugger and inferior will receive the Ctrl-c event.
1556 In that case the ctrl_c handler will ignore the event, as the
1557 Ctrl-c event generated inside the inferior will trigger the
1558 expected debug event.
1560 FIXME: brobecker/2008-05-20: If the inferior receives the
1561 signal first and the delay until GDB receives that signal
1562 is sufficiently long, GDB can sometimes receive the SIGINT
1563 after we have unblocked the CTRL+C handler. This would
1564 lead to the debugger stopping prematurely while handling
1565 the new-thread event that comes with the handling of the SIGINT
1566 inside the inferior, and then stop again immediately when
1567 the user tries to resume the execution in the inferior.
1568 This is a classic race that we should try to fix one day. */
1569 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1570 retval
= get_windows_debug_event (ops
, pid
, ourstatus
);
1571 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1574 return ptid_build (current_event
.dwProcessId
, 0, retval
);
1579 if (deprecated_ui_loop_hook
!= NULL
)
1580 detach
= deprecated_ui_loop_hook (0);
1583 windows_kill_inferior (ops
);
1588 /* Iterate over all DLLs currently mapped by our inferior, and
1589 add them to our list of solibs. */
1592 windows_add_all_dlls (void)
1595 HMODULE dummy_hmodule
;
1600 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
1601 sizeof (HMODULE
), &cb_needed
) == 0)
1607 hmodules
= (HMODULE
*) alloca (cb_needed
);
1608 if (EnumProcessModules (current_process_handle
, hmodules
,
1609 cb_needed
, &cb_needed
) == 0)
1612 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
1616 wchar_t dll_name
[__PMAX
];
1619 char dll_name
[__PMAX
];
1622 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
1623 &mi
, sizeof (mi
)) == 0)
1625 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
1626 dll_name
, sizeof (dll_name
)) == 0)
1629 wcstombs (name
, dll_name
, __PMAX
);
1634 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
1635 solib_end
= solib_end
->next
;
1640 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1642 extern int stop_after_trap
;
1644 struct inferior
*inf
;
1645 struct thread_info
*tp
;
1647 last_sig
= GDB_SIGNAL_0
;
1649 exception_count
= 0;
1650 open_process_used
= 0;
1651 debug_registers_changed
= 0;
1652 debug_registers_used
= 0;
1653 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1656 cygwin_load_start
= cygwin_load_end
= 0;
1658 current_event
.dwProcessId
= pid
;
1659 memset (¤t_event
, 0, sizeof (current_event
));
1660 if (!target_is_pushed (ops
))
1662 disable_breakpoints_in_shlibs ();
1663 windows_clear_solib ();
1664 clear_proceed_status (0);
1665 init_wait_for_inferior ();
1667 inf
= current_inferior ();
1668 inferior_appeared (inf
, pid
);
1669 inf
->attach_flag
= attaching
;
1671 /* Make the new process the current inferior, so terminal handling
1672 can rely on it. When attaching, we don't know about any thread
1673 id here, but that's OK --- nothing should be referencing the
1674 current thread until we report an event out of windows_wait. */
1675 inferior_ptid
= pid_to_ptid (pid
);
1677 target_terminal_init ();
1678 target_terminal_inferior ();
1680 windows_initialization_done
= 0;
1681 inf
->control
.stop_soon
= STOP_QUIETLY
;
1684 stop_after_trap
= 1;
1685 wait_for_inferior ();
1686 tp
= inferior_thread ();
1687 if (tp
->suspend
.stop_signal
!= GDB_SIGNAL_TRAP
)
1688 resume (tp
->suspend
.stop_signal
);
1693 /* Now that the inferior has been started and all DLLs have been mapped,
1694 we can iterate over all DLLs and load them in.
1696 We avoid doing it any earlier because, on certain versions of Windows,
1697 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
1698 we have seen on Windows 8.1 that the ntdll.dll load event does not
1699 include the DLL name, preventing us from creating an associated SO.
1700 A possible explanation is that ntdll.dll might be mapped before
1701 the SO info gets created by the Windows system -- ntdll.dll is
1702 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
1703 do not seem to suffer from that problem.
1705 Rather than try to work around this sort of issue, it is much
1706 simpler to just ignore DLL load/unload events during the startup
1707 phase, and then process them all in one batch now. */
1708 windows_add_all_dlls ();
1710 windows_initialization_done
= 1;
1711 inf
->control
.stop_soon
= NO_STOP_QUIETLY
;
1712 stop_after_trap
= 0;
1716 /* Try to set or remove a user privilege to the current process. Return -1
1717 if that fails, the previous setting of that privilege otherwise.
1719 This code is copied from the Cygwin source code and rearranged to allow
1720 dynamically loading of the needed symbols from advapi32 which is only
1721 available on NT/2K/XP. */
1723 set_process_privilege (const char *privilege
, BOOL enable
)
1725 HANDLE token_hdl
= NULL
;
1727 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1731 if (!OpenProcessToken (GetCurrentProcess (),
1732 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1736 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
1739 new_priv
.PrivilegeCount
= 1;
1740 new_priv
.Privileges
[0].Luid
= restore_priv
;
1741 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1743 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1744 sizeof orig_priv
, &orig_priv
, &size
))
1747 /* Disabled, otherwise every `attach' in an unprivileged user session
1748 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1749 windows_attach(). */
1750 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1751 be enabled. GetLastError () returns an correct error code, though. */
1752 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1756 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1760 CloseHandle (token_hdl
);
1765 /* Attach to process PID, then initialize for debugging it. */
1767 windows_attach (struct target_ops
*ops
, const char *args
, int from_tty
)
1772 pid
= parse_pid_to_attach (args
);
1774 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1776 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1777 printf_unfiltered ("This can cause attach to "
1778 "fail on Windows NT/2K/XP\n");
1781 windows_init_thread_list ();
1782 ok
= DebugActiveProcess (pid
);
1788 /* Try fall back to Cygwin pid. */
1789 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1792 ok
= DebugActiveProcess (pid
);
1797 error (_("Can't attach to process."));
1799 DebugSetProcessKillOnExit (FALSE
);
1803 char *exec_file
= (char *) get_exec_file (0);
1806 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1807 target_pid_to_str (pid_to_ptid (pid
)));
1809 printf_unfiltered ("Attaching to %s\n",
1810 target_pid_to_str (pid_to_ptid (pid
)));
1812 gdb_flush (gdb_stdout
);
1815 do_initial_windows_stuff (ops
, pid
, 1);
1816 target_terminal_ours ();
1820 windows_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
1825 windows_resume (ops
, ptid
, 0, GDB_SIGNAL_0
);
1827 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1829 error (_("Can't detach process %u (error %u)"),
1830 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
1833 DebugSetProcessKillOnExit (FALSE
);
1835 if (detached
&& from_tty
)
1837 char *exec_file
= get_exec_file (0);
1840 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
1841 (unsigned) current_event
.dwProcessId
);
1842 gdb_flush (gdb_stdout
);
1845 x86_cleanup_dregs ();
1846 inferior_ptid
= null_ptid
;
1847 detach_inferior (current_event
.dwProcessId
);
1849 inf_child_maybe_unpush_target (ops
);
1852 /* Try to determine the executable filename.
1854 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
1856 Upon success, the filename is stored inside EXE_NAME_RET, and
1857 this function returns nonzero.
1859 Otherwise, this function returns zero and the contents of
1860 EXE_NAME_RET is undefined. */
1863 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
1870 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
1871 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
1874 /* We know the executable is always first in the list of modules,
1875 which we just fetched. So no need to fetch more. */
1879 /* Cygwin prefers that the path be in /x/y/z format, so extract
1880 the filename into a temporary buffer first, and then convert it
1881 to POSIX format into the destination buffer. */
1882 cygwin_buf_t
*pathbuf
= alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
1884 len
= GetModuleFileNameEx (current_process_handle
,
1885 dh_buf
, pathbuf
, exe_name_max_len
);
1887 error (_("Error getting executable filename: %u."),
1888 (unsigned) GetLastError ());
1889 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
1890 exe_name_max_len
) < 0)
1891 error (_("Error converting executable filename to POSIX: %d."), errno
);
1894 len
= GetModuleFileNameEx (current_process_handle
,
1895 dh_buf
, exe_name_ret
, exe_name_max_len
);
1897 error (_("Error getting executable filename: %u."),
1898 (unsigned) GetLastError ());
1901 return 1; /* success */
1904 /* The pid_to_exec_file target_ops method for this platform. */
1907 windows_pid_to_exec_file (struct target_ops
*self
, int pid
)
1909 static char path
[__PMAX
];
1911 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
1913 char procexe
[sizeof ("/proc/4294967295/exe")];
1915 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
1916 nchars
= readlink (procexe
, path
, sizeof(path
));
1917 if (nchars
> 0 && nchars
< sizeof (path
))
1919 path
[nchars
] = '\0'; /* Got it */
1924 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
1925 of gdb, or we're trying to debug a non-Cygwin windows executable. */
1926 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
1932 /* Print status information about what we're accessing. */
1935 windows_files_info (struct target_ops
*ignore
)
1937 struct inferior
*inf
= current_inferior ();
1939 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1940 inf
->attach_flag
? "attached" : "child",
1941 target_pid_to_str (inferior_ptid
));
1944 /* Modify CreateProcess parameters for use of a new separate console.
1946 *FLAGS: DWORD parameter for general process creation flags.
1947 *SI: STARTUPINFO structure, for which the console window size and
1948 console buffer size is filled in if GDB is running in a console.
1949 to create the new console.
1950 The size of the used font is not available on all versions of
1951 Windows OS. Furthermore, the current font might not be the default
1952 font, but this is still better than before.
1953 If the windows and buffer sizes are computed,
1954 SI->DWFLAGS is changed so that this information is used
1955 by CreateProcess function. */
1958 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
1960 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
1961 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
1963 if (hconsole
!= INVALID_HANDLE_VALUE
)
1965 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
1967 CONSOLE_FONT_INFO cfi
;
1969 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
1970 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
1971 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
1972 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
1973 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
1975 si
->dwXSize
*= font_size
.X
;
1979 si
->dwYSize
*= font_size
.Y
;
1982 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
1983 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
1984 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
1986 *flags
|= CREATE_NEW_CONSOLE
;
1990 /* Function called by qsort to sort environment strings. */
1993 envvar_cmp (const void *a
, const void *b
)
1995 const char **p
= (const char **) a
;
1996 const char **q
= (const char **) b
;
1997 return strcasecmp (*p
, *q
);
2003 clear_win32_environment (char **env
)
2007 wchar_t *copy
= NULL
, *equalpos
;
2009 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2011 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2012 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2013 mbstowcs (copy
, env
[i
], len
);
2014 equalpos
= wcschr (copy
, L
'=');
2017 SetEnvironmentVariableW (copy
, NULL
);
2023 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2024 EXEC_FILE is the file to run.
2025 ALLARGS is a string containing the arguments to the program.
2026 ENV is the environment vector to pass. Errors reported with error(). */
2029 windows_create_inferior (struct target_ops
*ops
, char *exec_file
,
2030 char *allargs
, char **in_env
, int from_tty
)
2034 cygwin_buf_t real_path
[__PMAX
];
2035 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2037 cygwin_buf_t
*toexec
;
2038 cygwin_buf_t
*cygallargs
;
2040 char **old_env
= NULL
;
2044 int ostdin
, ostdout
, ostderr
;
2046 char real_path
[__PMAX
];
2047 char shell
[__PMAX
]; /* Path to shell */
2059 PROCESS_INFORMATION pi
;
2062 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2065 error (_("No executable specified, use `target exec'."));
2067 memset (&si
, 0, sizeof (si
));
2068 si
.cb
= sizeof (si
);
2071 flags
|= CREATE_NEW_PROCESS_GROUP
;
2074 windows_set_console_info (&si
, &flags
);
2079 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2080 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2081 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2082 error (_("Error starting executable: %d"), errno
);
2085 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2086 if (len
== (size_t) -1)
2087 error (_("Error starting executable: %d"), errno
);
2088 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2089 mbstowcs (cygallargs
, allargs
, len
);
2091 cygallargs
= allargs
;
2096 sh
= getenv ("SHELL");
2099 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2100 error (_("Error starting executable via shell: %d"), errno
);
2102 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2103 + mbstowcs (NULL
, allargs
, 0) + 2;
2104 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2105 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2107 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2108 + strlen (allargs
) + 2);
2109 cygallargs
= (char *) alloca (len
);
2110 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2113 flags
|= DEBUG_PROCESS
;
2117 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2118 * sizeof (wchar_t));
2119 wcscpy (args
, toexec
);
2120 wcscat (args
, L
" ");
2121 wcscat (args
, cygallargs
);
2123 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2124 strcpy (args
, toexec
);
2126 strcat (args
, cygallargs
);
2129 #ifdef CW_CVT_ENV_TO_WINENV
2130 /* First try to create a direct Win32 copy of the POSIX environment. */
2131 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2132 if (w32_env
!= (PWCHAR
) -1)
2133 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2135 /* If that fails, fall back to old method tweaking GDB's environment. */
2138 /* Reset all Win32 environment variables to avoid leftover on next run. */
2139 clear_win32_environment (environ
);
2140 /* Prepare the environment vars for CreateProcess. */
2143 cygwin_internal (CW_SYNC_WINENV
);
2147 if (!inferior_io_terminal
)
2148 tty
= ostdin
= ostdout
= ostderr
= -1;
2151 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2154 print_sys_errmsg (inferior_io_terminal
, errno
);
2155 ostdin
= ostdout
= ostderr
= -1;
2168 windows_init_thread_list ();
2169 ret
= CreateProcess (0,
2170 args
, /* command line */
2171 NULL
, /* Security */
2173 TRUE
, /* inherit handles */
2174 flags
, /* start flags */
2175 w32_env
, /* environment */
2176 NULL
, /* current directory */
2180 /* Just free the Win32 environment, if it could be created. */
2184 /* Reset all environment variables to avoid leftover on next run. */
2185 clear_win32_environment (in_env
);
2186 /* Restore normal GDB environment variables. */
2188 cygwin_internal (CW_SYNC_WINENV
);
2203 /* Build the command line, a space-separated list of tokens where
2204 the first token is the name of the module to be executed.
2205 To avoid ambiguities introduced by spaces in the module name,
2207 args_len
= strlen (toexec
) + 2 /* quotes */ + strlen (allargs
) + 2;
2208 args
= alloca (args_len
);
2209 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs
);
2211 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2213 if (!inferior_io_terminal
)
2214 tty
= INVALID_HANDLE_VALUE
;
2217 SECURITY_ATTRIBUTES sa
;
2218 sa
.nLength
= sizeof(sa
);
2219 sa
.lpSecurityDescriptor
= 0;
2220 sa
.bInheritHandle
= TRUE
;
2221 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2222 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2223 if (tty
== INVALID_HANDLE_VALUE
)
2224 warning (_("Warning: Failed to open TTY %s, error %#x."),
2225 inferior_io_terminal
, (unsigned) GetLastError ());
2229 si
.hStdOutput
= tty
;
2231 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2235 /* CreateProcess takes the environment list as a null terminated set of
2236 strings (i.e. two nulls terminate the list). */
2238 /* Get total size for env strings. */
2239 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2240 envlen
+= strlen (in_env
[i
]) + 1;
2242 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2243 env
= (char **) alloca (envsize
);
2244 memcpy (env
, in_env
, envsize
);
2245 /* Windows programs expect the environment block to be sorted. */
2246 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2248 w32env
= alloca (envlen
+ 1);
2250 /* Copy env strings into new buffer. */
2251 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2253 strcpy (temp
, env
[i
]);
2254 temp
+= strlen (temp
) + 1;
2257 /* Final nil string to terminate new env. */
2260 windows_init_thread_list ();
2261 ret
= CreateProcessA (0,
2262 args
, /* command line */
2263 NULL
, /* Security */
2265 TRUE
, /* inherit handles */
2266 flags
, /* start flags */
2267 w32env
, /* environment */
2268 NULL
, /* current directory */
2271 if (tty
!= INVALID_HANDLE_VALUE
)
2276 error (_("Error creating process %s, (error %u)."),
2277 exec_file
, (unsigned) GetLastError ());
2279 CloseHandle (pi
.hThread
);
2280 CloseHandle (pi
.hProcess
);
2282 if (useshell
&& shell
[0] != '\0')
2287 do_initial_windows_stuff (ops
, pi
.dwProcessId
, 0);
2289 /* windows_continue (DBG_CONTINUE, -1, 0); */
2293 windows_mourn_inferior (struct target_ops
*ops
)
2295 (void) windows_continue (DBG_CONTINUE
, -1, 0);
2296 x86_cleanup_dregs();
2297 if (open_process_used
)
2299 CHECK (CloseHandle (current_process_handle
));
2300 open_process_used
= 0;
2302 inf_child_mourn_inferior (ops
);
2305 /* Send a SIGINT to the process group. This acts just like the user typed a
2306 ^C on the controlling terminal. */
2309 windows_stop (struct target_ops
*self
, ptid_t ptid
)
2311 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2312 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
2313 registers_changed (); /* refresh register state */
2316 /* Helper for windows_xfer_partial that handles memory transfers.
2317 Arguments are like target_xfer_partial. */
2319 static enum target_xfer_status
2320 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2321 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2325 DWORD lasterror
= 0;
2327 if (writebuf
!= NULL
)
2329 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
2330 pulongest (len
), core_addr_to_string (memaddr
)));
2331 success
= WriteProcessMemory (current_process_handle
,
2332 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
2335 lasterror
= GetLastError ();
2336 FlushInstructionCache (current_process_handle
,
2337 (LPCVOID
) (uintptr_t) memaddr
, len
);
2341 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
2342 pulongest (len
), core_addr_to_string (memaddr
)));
2343 success
= ReadProcessMemory (current_process_handle
,
2344 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
2347 lasterror
= GetLastError ();
2349 *xfered_len
= (ULONGEST
) done
;
2350 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
2351 return TARGET_XFER_OK
;
2353 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
2357 windows_kill_inferior (struct target_ops
*ops
)
2359 CHECK (TerminateProcess (current_process_handle
, 0));
2363 if (!windows_continue (DBG_CONTINUE
, -1, 1))
2365 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
2367 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2371 target_mourn_inferior (); /* Or just windows_mourn_inferior? */
2375 windows_close (struct target_ops
*self
)
2377 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2378 ptid_get_pid (inferior_ptid
)));
2381 /* Convert pid to printable format. */
2383 windows_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
2385 static char buf
[80];
2387 if (ptid_get_tid (ptid
) != 0)
2389 snprintf (buf
, sizeof (buf
), "Thread %d.0x%lx",
2390 ptid_get_pid (ptid
), ptid_get_tid (ptid
));
2394 return normal_pid_to_str (ptid
);
2397 static enum target_xfer_status
2398 windows_xfer_shared_libraries (struct target_ops
*ops
,
2399 enum target_object object
, const char *annex
,
2400 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2401 ULONGEST offset
, ULONGEST len
,
2402 ULONGEST
*xfered_len
)
2404 struct obstack obstack
;
2410 return TARGET_XFER_E_IO
;
2412 obstack_init (&obstack
);
2413 obstack_grow_str (&obstack
, "<library-list>\n");
2414 for (so
= solib_start
.next
; so
; so
= so
->next
)
2415 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
2416 (uintptr_t) so
->lm_info
->load_addr
,
2417 target_gdbarch (), &obstack
);
2418 obstack_grow_str0 (&obstack
, "</library-list>\n");
2420 buf
= obstack_finish (&obstack
);
2421 len_avail
= strlen (buf
);
2422 if (offset
>= len_avail
)
2426 if (len
> len_avail
- offset
)
2427 len
= len_avail
- offset
;
2428 memcpy (readbuf
, buf
+ offset
, len
);
2431 obstack_free (&obstack
, NULL
);
2432 *xfered_len
= (ULONGEST
) len
;
2433 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
2436 static enum target_xfer_status
2437 windows_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2438 const char *annex
, gdb_byte
*readbuf
,
2439 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
2440 ULONGEST
*xfered_len
)
2444 case TARGET_OBJECT_MEMORY
:
2445 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
2447 case TARGET_OBJECT_LIBRARIES
:
2448 return windows_xfer_shared_libraries (ops
, object
, annex
, readbuf
,
2449 writebuf
, offset
, len
, xfered_len
);
2452 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2453 readbuf
, writebuf
, offset
, len
,
2458 /* Provide thread local base, i.e. Thread Information Block address.
2459 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
2462 windows_get_tib_address (struct target_ops
*self
,
2463 ptid_t ptid
, CORE_ADDR
*addr
)
2465 windows_thread_info
*th
;
2467 th
= thread_rec (ptid_get_tid (ptid
), 0);
2472 *addr
= th
->thread_local_base
;
2478 windows_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long thread
)
2480 return ptid_build (ptid_get_pid (inferior_ptid
), 0, lwp
);
2483 static struct target_ops
*
2484 windows_target (void)
2486 struct target_ops
*t
= inf_child_target ();
2488 t
->to_close
= windows_close
;
2489 t
->to_attach
= windows_attach
;
2490 t
->to_attach_no_wait
= 1;
2491 t
->to_detach
= windows_detach
;
2492 t
->to_resume
= windows_resume
;
2493 t
->to_wait
= windows_wait
;
2494 t
->to_fetch_registers
= windows_fetch_inferior_registers
;
2495 t
->to_store_registers
= windows_store_inferior_registers
;
2496 t
->to_xfer_partial
= windows_xfer_partial
;
2497 t
->to_files_info
= windows_files_info
;
2498 t
->to_kill
= windows_kill_inferior
;
2499 t
->to_create_inferior
= windows_create_inferior
;
2500 t
->to_mourn_inferior
= windows_mourn_inferior
;
2501 t
->to_thread_alive
= windows_thread_alive
;
2502 t
->to_pid_to_str
= windows_pid_to_str
;
2503 t
->to_stop
= windows_stop
;
2504 t
->to_pid_to_exec_file
= windows_pid_to_exec_file
;
2505 t
->to_get_ada_task_ptid
= windows_get_ada_task_ptid
;
2506 t
->to_get_tib_address
= windows_get_tib_address
;
2511 /* -Wmissing-prototypes */
2512 extern initialize_file_ftype _initialize_windows_nat
;
2515 _initialize_windows_nat (void)
2517 struct target_ops
*t
;
2519 t
= windows_target ();
2521 x86_use_watchpoints (t
);
2523 x86_dr_low
.set_control
= cygwin_set_dr7
;
2524 x86_dr_low
.set_addr
= cygwin_set_dr
;
2525 x86_dr_low
.get_addr
= cygwin_get_dr
;
2526 x86_dr_low
.get_status
= cygwin_get_dr6
;
2527 x86_dr_low
.get_control
= cygwin_get_dr7
;
2529 /* x86_dr_low.debug_register_length field is set by
2530 calling x86_set_debug_register_length function
2531 in processor windows specific native file. */
2536 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
2540 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
2541 Set use of shell to start subprocess."), _("\
2542 Show use of shell to start subprocess."), NULL
,
2544 NULL
, /* FIXME: i18n: */
2545 &setlist
, &showlist
);
2547 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
2548 &cygwin_exceptions
, _("\
2549 Break when an exception is detected in the Cygwin DLL itself."), _("\
2550 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
2552 NULL
, /* FIXME: i18n: */
2553 &setlist
, &showlist
);
2556 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
2557 Set creation of new console when creating child process."), _("\
2558 Show creation of new console when creating child process."), NULL
,
2560 NULL
, /* FIXME: i18n: */
2561 &setlist
, &showlist
);
2563 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
2564 Set creation of new group when creating child process."), _("\
2565 Show creation of new group when creating child process."), NULL
,
2567 NULL
, /* FIXME: i18n: */
2568 &setlist
, &showlist
);
2570 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
2571 Set whether to display execution in child process."), _("\
2572 Show whether to display execution in child process."), NULL
,
2574 NULL
, /* FIXME: i18n: */
2575 &setlist
, &showlist
);
2577 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
2578 Set whether to display kernel events in child process."), _("\
2579 Show whether to display kernel events in child process."), NULL
,
2581 NULL
, /* FIXME: i18n: */
2582 &setlist
, &showlist
);
2584 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
2585 Set whether to display memory accesses in child process."), _("\
2586 Show whether to display memory accesses in child process."), NULL
,
2588 NULL
, /* FIXME: i18n: */
2589 &setlist
, &showlist
);
2591 add_setshow_boolean_cmd ("debugexceptions", class_support
,
2592 &debug_exceptions
, _("\
2593 Set whether to display kernel exceptions in child process."), _("\
2594 Show whether to display kernel exceptions in child process."), NULL
,
2596 NULL
, /* FIXME: i18n: */
2597 &setlist
, &showlist
);
2599 init_w32_command_list ();
2601 add_cmd ("selector", class_info
, display_selectors
,
2602 _("Display selectors infos."),
2606 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2608 /* Pass the address ADDR to the inferior in the I'th debug register.
2609 Here we just store the address in dr array, the registers will be
2610 actually set up when windows_continue is called. */
2612 cygwin_set_dr (int i
, CORE_ADDR addr
)
2615 internal_error (__FILE__
, __LINE__
,
2616 _("Invalid register %d in cygwin_set_dr.\n"), i
);
2618 debug_registers_changed
= 1;
2619 debug_registers_used
= 1;
2622 /* Pass the value VAL to the inferior in the DR7 debug control
2623 register. Here we just store the address in D_REGS, the watchpoint
2624 will be actually set up in windows_wait. */
2626 cygwin_set_dr7 (unsigned long val
)
2628 dr
[7] = (CORE_ADDR
) val
;
2629 debug_registers_changed
= 1;
2630 debug_registers_used
= 1;
2633 /* Get the value of debug register I from the inferior. */
2636 cygwin_get_dr (int i
)
2641 /* Get the value of the DR6 debug status register from the inferior.
2642 Here we just return the value stored in dr[6]
2643 by the last call to thread_rec for current_event.dwThreadId id. */
2644 static unsigned long
2645 cygwin_get_dr6 (void)
2647 return (unsigned long) dr
[6];
2650 /* Get the value of the DR7 debug status register from the inferior.
2651 Here we just return the value stored in dr[7] by the last call to
2652 thread_rec for current_event.dwThreadId id. */
2654 static unsigned long
2655 cygwin_get_dr7 (void)
2657 return (unsigned long) dr
[7];
2660 /* Determine if the thread referenced by "ptid" is alive
2661 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2662 it means that the thread has died. Otherwise it is assumed to be alive. */
2664 windows_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
2668 gdb_assert (ptid_get_tid (ptid
) != 0);
2669 tid
= ptid_get_tid (ptid
);
2671 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
2675 /* -Wmissing-prototypes */
2676 extern initialize_file_ftype _initialize_check_for_gdb_ini
;
2679 _initialize_check_for_gdb_ini (void)
2682 if (inhibit_gdbinit
)
2685 homedir
= getenv ("HOME");
2689 char *oldini
= (char *) alloca (strlen (homedir
) +
2690 sizeof ("/gdb.ini"));
2691 strcpy (oldini
, homedir
);
2692 p
= strchr (oldini
, '\0');
2693 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
2695 strcpy (p
, "gdb.ini");
2696 if (access (oldini
, 0) == 0)
2698 int len
= strlen (oldini
);
2699 char *newini
= alloca (len
+ 1);
2701 xsnprintf (newini
, len
+ 1, "%.*s.gdbinit",
2702 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
2703 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
2708 /* Define dummy functions which always return error for the rare cases where
2709 these functions could not be found. */
2711 bad_DebugActiveProcessStop (DWORD w
)
2716 bad_DebugBreakProcess (HANDLE w
)
2721 bad_DebugSetProcessKillOnExit (BOOL w
)
2726 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
2733 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
2739 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
2746 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
2752 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
2758 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
2764 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
2772 /* -Wmissing-prototypes */
2773 extern initialize_file_ftype _initialize_loadable
;
2775 /* Load any functions which may not be available in ancient versions
2779 _initialize_loadable (void)
2783 hm
= LoadLibrary ("kernel32.dll");
2786 DebugActiveProcessStop
= (void *)
2787 GetProcAddress (hm
, "DebugActiveProcessStop");
2788 DebugBreakProcess
= (void *)
2789 GetProcAddress (hm
, "DebugBreakProcess");
2790 DebugSetProcessKillOnExit
= (void *)
2791 GetProcAddress (hm
, "DebugSetProcessKillOnExit");
2792 GetConsoleFontSize
= (void *)
2793 GetProcAddress (hm
, "GetConsoleFontSize");
2794 GetCurrentConsoleFont
= (void *)
2795 GetProcAddress (hm
, "GetCurrentConsoleFont");
2798 /* Set variables to dummy versions of these processes if the function
2799 wasn't found in kernel32.dll. */
2800 if (!DebugBreakProcess
)
2801 DebugBreakProcess
= bad_DebugBreakProcess
;
2802 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
2804 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
2805 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
2807 if (!GetConsoleFontSize
)
2808 GetConsoleFontSize
= bad_GetConsoleFontSize
;
2809 if (!GetCurrentConsoleFont
)
2810 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
2812 /* Load optional functions used for retrieving filename information
2813 associated with the currently debugged process or its dlls. */
2814 hm
= LoadLibrary ("psapi.dll");
2817 EnumProcessModules
= (void *)
2818 GetProcAddress (hm
, "EnumProcessModules");
2819 GetModuleInformation
= (void *)
2820 GetProcAddress (hm
, "GetModuleInformation");
2821 GetModuleFileNameEx
= (void *)
2822 GetProcAddress (hm
, GetModuleFileNameEx_name
);
2825 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
2827 /* Set variables to dummy versions of these processes if the function
2828 wasn't found in psapi.dll. */
2829 EnumProcessModules
= bad_EnumProcessModules
;
2830 GetModuleInformation
= bad_GetModuleInformation
;
2831 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
2832 /* This will probably fail on Windows 9x/Me. Let the user know
2833 that we're missing some functionality. */
2835 cannot automatically find executable file or library to read symbols.\n\
2836 Use \"file\" or \"dll\" command to load executable/libraries directly."));
2839 hm
= LoadLibrary ("advapi32.dll");
2842 OpenProcessToken
= (void *) GetProcAddress (hm
, "OpenProcessToken");
2843 LookupPrivilegeValueA
= (void *)
2844 GetProcAddress (hm
, "LookupPrivilegeValueA");
2845 AdjustTokenPrivileges
= (void *)
2846 GetProcAddress (hm
, "AdjustTokenPrivileges");
2847 /* Only need to set one of these since if OpenProcessToken fails nothing
2849 if (!OpenProcessToken
|| !LookupPrivilegeValueA
2850 || !AdjustTokenPrivileges
)
2851 OpenProcessToken
= bad_OpenProcessToken
;