1 /* Target-vector operations for controlling windows child processes, for GDB.
3 Copyright (C) 1995-2020 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>
48 #include "filenames.h"
52 #include "gdb_obstack.h"
53 #include "gdbthread.h"
59 #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"
70 #include "gdbsupport/gdb_tilde_expand.h"
71 #include "gdbsupport/pathstuff.h"
72 #include "gdbsupport/gdb_wait.h"
74 #define STATUS_WX86_BREAKPOINT 0x4000001F
75 #define STATUS_WX86_SINGLE_STEP 0x4000001E
77 #define AdjustTokenPrivileges dyn_AdjustTokenPrivileges
78 #define DebugActiveProcessStop dyn_DebugActiveProcessStop
79 #define DebugBreakProcess dyn_DebugBreakProcess
80 #define DebugSetProcessKillOnExit dyn_DebugSetProcessKillOnExit
81 #define EnumProcessModules dyn_EnumProcessModules
82 #define EnumProcessModulesEx dyn_EnumProcessModulesEx
83 #define GetModuleInformation dyn_GetModuleInformation
84 #define LookupPrivilegeValueA dyn_LookupPrivilegeValueA
85 #define OpenProcessToken dyn_OpenProcessToken
86 #define GetConsoleFontSize dyn_GetConsoleFontSize
87 #define GetCurrentConsoleFont dyn_GetCurrentConsoleFont
88 #define Wow64SuspendThread dyn_Wow64SuspendThread
89 #define Wow64GetThreadContext dyn_Wow64GetThreadContext
90 #define Wow64SetThreadContext dyn_Wow64SetThreadContext
91 #define Wow64GetThreadSelectorEntry dyn_Wow64GetThreadSelectorEntry
93 typedef BOOL
WINAPI (AdjustTokenPrivileges_ftype
) (HANDLE
, BOOL
,
95 DWORD
, PTOKEN_PRIVILEGES
,
97 static AdjustTokenPrivileges_ftype
*AdjustTokenPrivileges
;
99 typedef BOOL
WINAPI (DebugActiveProcessStop_ftype
) (DWORD
);
100 static DebugActiveProcessStop_ftype
*DebugActiveProcessStop
;
102 typedef BOOL
WINAPI (DebugBreakProcess_ftype
) (HANDLE
);
103 static DebugBreakProcess_ftype
*DebugBreakProcess
;
105 typedef BOOL
WINAPI (DebugSetProcessKillOnExit_ftype
) (BOOL
);
106 static DebugSetProcessKillOnExit_ftype
*DebugSetProcessKillOnExit
;
108 typedef BOOL
WINAPI (EnumProcessModules_ftype
) (HANDLE
, HMODULE
*, DWORD
,
110 static EnumProcessModules_ftype
*EnumProcessModules
;
113 typedef BOOL
WINAPI (EnumProcessModulesEx_ftype
) (HANDLE
, HMODULE
*, DWORD
,
115 static EnumProcessModulesEx_ftype
*EnumProcessModulesEx
;
118 typedef BOOL
WINAPI (GetModuleInformation_ftype
) (HANDLE
, HMODULE
,
119 LPMODULEINFO
, DWORD
);
120 static GetModuleInformation_ftype
*GetModuleInformation
;
122 typedef BOOL
WINAPI (LookupPrivilegeValueA_ftype
) (LPCSTR
, LPCSTR
, PLUID
);
123 static LookupPrivilegeValueA_ftype
*LookupPrivilegeValueA
;
125 typedef BOOL
WINAPI (OpenProcessToken_ftype
) (HANDLE
, DWORD
, PHANDLE
);
126 static OpenProcessToken_ftype
*OpenProcessToken
;
128 typedef BOOL
WINAPI (GetCurrentConsoleFont_ftype
) (HANDLE
, BOOL
,
129 CONSOLE_FONT_INFO
*);
130 static GetCurrentConsoleFont_ftype
*GetCurrentConsoleFont
;
132 typedef COORD
WINAPI (GetConsoleFontSize_ftype
) (HANDLE
, DWORD
);
133 static GetConsoleFontSize_ftype
*GetConsoleFontSize
;
136 typedef DWORD
WINAPI (Wow64SuspendThread_ftype
) (HANDLE
);
137 static Wow64SuspendThread_ftype
*Wow64SuspendThread
;
139 typedef BOOL
WINAPI (Wow64GetThreadContext_ftype
) (HANDLE
, PWOW64_CONTEXT
);
140 static Wow64GetThreadContext_ftype
*Wow64GetThreadContext
;
142 typedef BOOL
WINAPI (Wow64SetThreadContext_ftype
) (HANDLE
,
143 const WOW64_CONTEXT
*);
144 static Wow64SetThreadContext_ftype
*Wow64SetThreadContext
;
146 typedef BOOL
WINAPI (Wow64GetThreadSelectorEntry_ftype
) (HANDLE
, DWORD
,
148 static Wow64GetThreadSelectorEntry_ftype
*Wow64GetThreadSelectorEntry
;
153 #undef GetModuleFileNameEx
156 # define __PMAX (MAX_PATH + 1)
157 typedef DWORD
WINAPI (GetModuleFileNameEx_ftype
) (HANDLE
, HMODULE
, LPSTR
, DWORD
);
158 static GetModuleFileNameEx_ftype
*GetModuleFileNameEx
;
159 # define STARTUPINFO STARTUPINFOA
160 # define CreateProcess CreateProcessA
161 # define GetModuleFileNameEx_name "GetModuleFileNameExA"
162 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
164 # define __PMAX PATH_MAX
165 /* The starting and ending address of the cygwin1.dll text segment. */
166 static CORE_ADDR cygwin_load_start
;
167 static CORE_ADDR cygwin_load_end
;
169 typedef wchar_t cygwin_buf_t
;
170 typedef DWORD
WINAPI (GetModuleFileNameEx_ftype
) (HANDLE
, HMODULE
,
172 static GetModuleFileNameEx_ftype
*GetModuleFileNameEx
;
173 # define STARTUPINFO STARTUPINFOW
174 # define CreateProcess CreateProcessW
175 # define GetModuleFileNameEx_name "GetModuleFileNameExW"
176 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExW
179 static int have_saved_context
; /* True if we've saved context from a
182 static CONTEXT saved_context
; /* Contains the saved context from a
186 /* If we're not using the old Cygwin header file set, define the
187 following which never should have been in the generic Win32 API
188 headers in the first place since they were our own invention... */
189 #ifndef _GNU_H_WINDOWS_H
192 FLAG_TRACE_BIT
= 0x100,
196 #ifndef CONTEXT_EXTENDED_REGISTERS
197 /* This macro is only defined on ia32. It only makes sense on this target,
198 so define it as zero if not already defined. */
199 #define CONTEXT_EXTENDED_REGISTERS 0
202 #define CONTEXT_DEBUGGER_DR CONTEXT_FULL | CONTEXT_FLOATING_POINT \
203 | CONTEXT_SEGMENTS | CONTEXT_DEBUG_REGISTERS \
204 | CONTEXT_EXTENDED_REGISTERS
206 static uintptr_t dr
[8];
207 static int debug_registers_changed
;
208 static int debug_registers_used
;
210 static int windows_initialization_done
;
211 #define DR6_CLEAR_VALUE 0xffff0ff0
213 /* The exception thrown by a program to tell the debugger the name of
214 a thread. The exception record contains an ID of a thread and a
215 name to give it. This exception has no documented name, but MSDN
216 dubs it "MS_VC_EXCEPTION" in one code example. */
217 #define MS_VC_EXCEPTION 0x406d1388
221 HANDLE_EXCEPTION_UNHANDLED
= 0,
222 HANDLE_EXCEPTION_HANDLED
,
223 HANDLE_EXCEPTION_IGNORED
224 } handle_exception_result
;
226 /* The string sent by cygwin when it processes a signal.
227 FIXME: This should be in a cygwin include file. */
228 #ifndef _CYGWIN_SIGNAL_STRING
229 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
232 #define CHECK(x) check (x, __FILE__,__LINE__)
233 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
234 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
235 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
236 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
238 static void cygwin_set_dr (int i
, CORE_ADDR addr
);
239 static void cygwin_set_dr7 (unsigned long val
);
240 static CORE_ADDR
cygwin_get_dr (int i
);
241 static unsigned long cygwin_get_dr6 (void);
242 static unsigned long cygwin_get_dr7 (void);
244 static enum gdb_signal last_sig
= GDB_SIGNAL_0
;
245 /* Set if a signal was received from the debugged process. */
247 /* Thread information structure used to track information that is
248 not available in gdb's thread structure. */
249 struct windows_thread_info
253 CORE_ADDR thread_local_base
;
261 WOW64_CONTEXT wow64_context
;
266 static std::vector
<windows_thread_info
*> thread_list
;
268 /* The process and thread handles for the above context. */
270 static DEBUG_EVENT current_event
; /* The current debug event from
272 static HANDLE current_process_handle
; /* Currently executing process */
273 static windows_thread_info
*current_thread
; /* Info on currently selected thread */
274 static EXCEPTION_RECORD siginfo_er
; /* Contents of $_siginfo */
276 /* Counts of things. */
277 static int exception_count
= 0;
278 static int event_count
= 0;
279 static int saw_create
;
280 static int open_process_used
= 0;
282 static bool wow64_process
= false;
283 static bool ignore_first_breakpoint
= false;
287 static bool new_console
= false;
289 static bool cygwin_exceptions
= false;
291 static bool new_group
= true;
292 static bool debug_exec
= false; /* show execution */
293 static bool debug_events
= false; /* show events from kernel */
294 static bool debug_memory
= false; /* show target memory accesses */
295 static bool debug_exceptions
= false; /* show target exceptions */
296 static bool useshell
= false; /* use shell for subprocesses */
298 /* This vector maps GDB's idea of a register's number into an offset
299 in the windows exception context vector.
301 It also contains the bit mask needed to load the register in question.
303 The contents of this table can only be computed by the units
304 that provide CPU-specific support for Windows native debugging.
305 These units should set the table by calling
306 windows_set_context_register_offsets.
308 One day we could read a reg, we could inspect the context we
309 already have loaded, if it doesn't have the bit set that we need,
310 we read that set of registers in using GetThreadContext. If the
311 context already contains what we need, we just unpack it. Then to
312 write a register, first we have to ensure that the context contains
313 the other regs of the group, and then we copy the info in and set
316 static const int *mappings
;
318 /* The function to use in order to determine whether a register is
319 a segment register or not. */
320 static segment_register_p_ftype
*segment_register_p
;
322 /* See windows_nat_target::resume to understand why this is commented
325 /* This vector maps the target's idea of an exception (extracted
326 from the DEBUG_EVENT structure) to GDB's idea. */
328 struct xlate_exception
334 static const struct xlate_exception xlate
[] =
336 {EXCEPTION_ACCESS_VIOLATION
, GDB_SIGNAL_SEGV
},
337 {STATUS_STACK_OVERFLOW
, GDB_SIGNAL_SEGV
},
338 {EXCEPTION_BREAKPOINT
, GDB_SIGNAL_TRAP
},
339 {DBG_CONTROL_C
, GDB_SIGNAL_INT
},
340 {EXCEPTION_SINGLE_STEP
, GDB_SIGNAL_TRAP
},
341 {STATUS_FLOAT_DIVIDE_BY_ZERO
, GDB_SIGNAL_FPE
}
346 struct windows_nat_target final
: public x86_nat_target
<inf_child_target
>
348 void close () override
;
350 void attach (const char *, int) override
;
352 bool attach_no_wait () override
355 void detach (inferior
*, int) override
;
357 void resume (ptid_t
, int , enum gdb_signal
) override
;
359 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
361 void fetch_registers (struct regcache
*, int) override
;
362 void store_registers (struct regcache
*, int) override
;
364 enum target_xfer_status
xfer_partial (enum target_object object
,
367 const gdb_byte
*writebuf
,
368 ULONGEST offset
, ULONGEST len
,
369 ULONGEST
*xfered_len
) override
;
371 void files_info () override
;
373 void kill () override
;
375 void create_inferior (const char *, const std::string
&,
376 char **, int) override
;
378 void mourn_inferior () override
;
380 bool thread_alive (ptid_t ptid
) override
;
382 std::string
pid_to_str (ptid_t
) override
;
384 void interrupt () override
;
386 char *pid_to_exec_file (int pid
) override
;
388 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
390 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
392 const char *thread_name (struct thread_info
*) override
;
394 int get_windows_debug_event (int pid
, struct target_waitstatus
*ourstatus
);
397 static windows_nat_target the_windows_nat_target
;
399 /* Set the MAPPINGS static global to OFFSETS.
400 See the description of MAPPINGS for more details. */
403 windows_set_context_register_offsets (const int *offsets
)
408 /* Set the function that should be used by this module to determine
409 whether a given register is a segment register or not. */
412 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
414 segment_register_p
= fun
;
418 check (BOOL ok
, const char *file
, int line
)
421 printf_filtered ("error return %s:%d was %u\n", file
, line
,
422 (unsigned) GetLastError ());
425 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
426 then also retrieve the context for this thread. If GET_CONTEXT is
427 negative, then don't suspend the thread. */
428 static windows_thread_info
*
429 thread_rec (DWORD id
, int get_context
)
431 for (windows_thread_info
*th
: thread_list
)
434 if (!th
->suspended
&& get_context
)
436 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
438 if (SuspendThread (th
->h
) == (DWORD
) -1)
440 DWORD err
= GetLastError ();
442 /* We get Access Denied (5) when trying to suspend
443 threads that Windows started on behalf of the
444 debuggee, usually when those threads are just
446 We can get Invalid Handle (6) if the main thread
448 if (err
!= ERROR_INVALID_HANDLE
449 && err
!= ERROR_ACCESS_DENIED
)
450 warning (_("SuspendThread (tid=0x%x) failed."
452 (unsigned) id
, (unsigned) err
);
458 else if (get_context
< 0)
460 th
->reload_context
= 1;
468 /* Add a thread to the thread list.
470 PTID is the ptid of the thread to be added.
471 H is its Windows handle.
472 TLB is its thread local base.
473 MAIN_THREAD_P should be true if the thread to be added is
474 the main thread, false otherwise. */
476 static windows_thread_info
*
477 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
, bool main_thread_p
)
479 windows_thread_info
*th
;
482 gdb_assert (ptid
.tid () != 0);
486 if ((th
= thread_rec (id
, FALSE
)))
489 th
= XCNEW (windows_thread_info
);
492 th
->thread_local_base
= (CORE_ADDR
) (uintptr_t) tlb
;
494 /* For WOW64 processes, this is actually the pointer to the 64bit TIB,
495 and the 32bit TIB is exactly 2 pages after it. */
497 th
->thread_local_base
+= 0x2000;
499 thread_list
.push_back (th
);
501 /* Add this new thread to the list of threads.
503 To be consistent with what's done on other platforms, we add
504 the main thread silently (in reality, this thread is really
505 more of a process to the user than a thread). */
507 add_thread_silent (&the_windows_nat_target
, ptid
);
509 add_thread (&the_windows_nat_target
, ptid
);
511 /* Set the debug registers for the new thread if they are used. */
512 if (debug_registers_used
)
517 /* Only change the value of the debug registers. */
518 th
->wow64_context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
519 CHECK (Wow64GetThreadContext (th
->h
, &th
->wow64_context
));
520 th
->wow64_context
.Dr0
= dr
[0];
521 th
->wow64_context
.Dr1
= dr
[1];
522 th
->wow64_context
.Dr2
= dr
[2];
523 th
->wow64_context
.Dr3
= dr
[3];
524 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
525 th
->wow64_context
.Dr7
= dr
[7];
526 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
527 th
->wow64_context
.ContextFlags
= 0;
532 /* Only change the value of the debug registers. */
533 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
534 CHECK (GetThreadContext (th
->h
, &th
->context
));
535 th
->context
.Dr0
= dr
[0];
536 th
->context
.Dr1
= dr
[1];
537 th
->context
.Dr2
= dr
[2];
538 th
->context
.Dr3
= dr
[3];
539 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
540 th
->context
.Dr7
= dr
[7];
541 CHECK (SetThreadContext (th
->h
, &th
->context
));
542 th
->context
.ContextFlags
= 0;
548 /* Clear out any old thread list and reinitialize it to a
551 windows_init_thread_list (void)
553 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
556 for (windows_thread_info
*here
: thread_list
)
559 thread_list
.clear ();
562 /* Delete a thread from the list of threads.
564 PTID is the ptid of the thread to be deleted.
565 EXIT_CODE is the thread's exit code.
566 MAIN_THREAD_P should be true if the thread to be deleted is
567 the main thread, false otherwise. */
570 windows_delete_thread (ptid_t ptid
, DWORD exit_code
, bool main_thread_p
)
574 gdb_assert (ptid
.tid () != 0);
578 /* Emit a notification about the thread being deleted.
580 Note that no notification was printed when the main thread
581 was created, and thus, unless in verbose mode, we should be
582 symmetrical, and avoid that notification for the main thread
586 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
).c_str ());
587 else if (print_thread_events
&& !main_thread_p
)
588 printf_unfiltered (_("[%s exited with code %u]\n"),
589 target_pid_to_str (ptid
).c_str (),
590 (unsigned) exit_code
);
592 delete_thread (find_thread_ptid (&the_windows_nat_target
, ptid
));
594 auto iter
= std::find_if (thread_list
.begin (), thread_list
.end (),
595 [=] (windows_thread_info
*th
)
600 if (iter
!= thread_list
.end ())
602 xfree ((*iter
)->name
);
604 thread_list
.erase (iter
);
608 /* Fetches register number R from the given windows_thread_info,
609 and supplies its value to the given regcache.
611 This function assumes that R is non-negative. A failed assertion
612 is raised if that is not true.
614 This function assumes that TH->RELOAD_CONTEXT is not set, meaning
615 that the windows_thread_info has an up-to-date context. A failed
616 assertion is raised if that assumption is violated. */
619 windows_fetch_one_register (struct regcache
*regcache
,
620 windows_thread_info
*th
, int r
)
623 gdb_assert (!th
->reload_context
);
625 char *context_ptr
= (char *) &th
->context
;
628 context_ptr
= (char *) &th
->wow64_context
;
631 char *context_offset
= context_ptr
+ mappings
[r
];
632 struct gdbarch
*gdbarch
= regcache
->arch ();
633 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
635 if (r
== I387_FISEG_REGNUM (tdep
))
637 long l
= *((long *) context_offset
) & 0xffff;
638 regcache
->raw_supply (r
, (char *) &l
);
640 else if (r
== I387_FOP_REGNUM (tdep
))
642 long l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
643 regcache
->raw_supply (r
, (char *) &l
);
645 else if (segment_register_p (r
))
647 /* GDB treats segment registers as 32bit registers, but they are
648 in fact only 16 bits long. Make sure we do not read extra
649 bits from our source buffer. */
650 long l
= *((long *) context_offset
) & 0xffff;
651 regcache
->raw_supply (r
, (char *) &l
);
654 regcache
->raw_supply (r
, context_offset
);
658 windows_nat_target::fetch_registers (struct regcache
*regcache
, int r
)
660 DWORD tid
= regcache
->ptid ().tid ();
661 windows_thread_info
*th
= thread_rec (tid
, TRUE
);
663 /* Check if TH exists. Windows sometimes uses a non-existent
664 thread id in its events. */
668 if (th
->reload_context
)
671 if (have_saved_context
)
673 /* Lie about where the program actually is stopped since
674 cygwin has informed us that we should consider the signal
675 to have occurred at another location which is stored in
677 memcpy (&th
->context
, &saved_context
,
678 __COPY_CONTEXT_SIZE
);
679 have_saved_context
= 0;
686 th
->wow64_context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
687 CHECK (Wow64GetThreadContext (th
->h
, &th
->wow64_context
));
688 /* Copy dr values from that thread.
689 But only if there were not modified since last stop.
691 if (!debug_registers_changed
)
693 dr
[0] = th
->wow64_context
.Dr0
;
694 dr
[1] = th
->wow64_context
.Dr1
;
695 dr
[2] = th
->wow64_context
.Dr2
;
696 dr
[3] = th
->wow64_context
.Dr3
;
697 dr
[6] = th
->wow64_context
.Dr6
;
698 dr
[7] = th
->wow64_context
.Dr7
;
704 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
705 CHECK (GetThreadContext (th
->h
, &th
->context
));
706 /* Copy dr values from that thread.
707 But only if there were not modified since last stop.
709 if (!debug_registers_changed
)
711 dr
[0] = th
->context
.Dr0
;
712 dr
[1] = th
->context
.Dr1
;
713 dr
[2] = th
->context
.Dr2
;
714 dr
[3] = th
->context
.Dr3
;
715 dr
[6] = th
->context
.Dr6
;
716 dr
[7] = th
->context
.Dr7
;
719 th
->reload_context
= 0;
723 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch()); r
++)
724 windows_fetch_one_register (regcache
, th
, r
);
726 windows_fetch_one_register (regcache
, th
, r
);
729 /* Collect the register number R from the given regcache, and store
730 its value into the corresponding area of the given thread's context.
732 This function assumes that R is non-negative. A failed assertion
733 assertion is raised if that is not true. */
736 windows_store_one_register (const struct regcache
*regcache
,
737 windows_thread_info
*th
, int r
)
741 char *context_ptr
= (char *) &th
->context
;
744 context_ptr
= (char *) &th
->wow64_context
;
747 regcache
->raw_collect (r
, context_ptr
+ mappings
[r
]);
750 /* Store a new register value into the context of the thread tied to
754 windows_nat_target::store_registers (struct regcache
*regcache
, int r
)
756 DWORD tid
= regcache
->ptid ().tid ();
757 windows_thread_info
*th
= thread_rec (tid
, TRUE
);
759 /* Check if TH exists. Windows sometimes uses a non-existent
760 thread id in its events. */
765 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch ()); r
++)
766 windows_store_one_register (regcache
, th
, r
);
768 windows_store_one_register (regcache
, th
, r
);
771 /* Maintain a linked list of "so" information. */
772 struct lm_info_windows
: public lm_info_base
774 LPVOID load_addr
= 0;
775 CORE_ADDR text_offset
= 0;
778 static struct so_list solib_start
, *solib_end
;
780 static struct so_list
*
781 windows_make_so (const char *name
, LPVOID load_addr
)
788 WIN32_FIND_DATA w32_fd
;
789 HANDLE h
= FindFirstFile(name
, &w32_fd
);
791 if (h
== INVALID_HANDLE_VALUE
)
797 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
799 p
= strrchr (buf
, '\\');
802 SetCurrentDirectory (buf
);
803 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
804 SetCurrentDirectory (cwd
);
807 if (strcasecmp (buf
, "ntdll.dll") == 0)
809 GetSystemDirectory (buf
, sizeof (buf
));
810 strcat (buf
, "\\ntdll.dll");
813 cygwin_buf_t buf
[__PMAX
];
816 if (access (name
, F_OK
) != 0)
818 if (strcasecmp (name
, "ntdll.dll") == 0)
821 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
822 wcscat (buf
, L
"\\ntdll.dll");
826 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
827 strcat (buf
, "\\ntdll.dll");
832 so
= XCNEW (struct so_list
);
833 lm_info_windows
*li
= new lm_info_windows
;
835 li
->load_addr
= load_addr
;
836 strcpy (so
->so_original_name
, name
);
838 strcpy (so
->so_name
, buf
);
841 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
842 SO_NAME_MAX_PATH_SIZE
);
845 char *rname
= realpath (name
, NULL
);
846 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
848 strcpy (so
->so_name
, rname
);
852 error (_("dll path too long"));
854 /* Record cygwin1.dll .text start/end. */
855 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
856 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
858 asection
*text
= NULL
;
860 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386", -1));
865 if (bfd_check_format (abfd
.get (), bfd_object
))
866 text
= bfd_get_section_by_name (abfd
.get (), ".text");
871 /* The symbols in a dll are offset by 0x1000, which is the
872 offset from 0 of the first byte in an image - because of the
873 file header and the section alignment. */
874 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
876 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (text
);
884 get_image_name (HANDLE h
, void *address
, int unicode
)
887 static char buf
[__PMAX
];
889 static char buf
[(2 * __PMAX
) + 1];
891 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
897 /* Attempt to read the name of the dll that was detected.
898 This is documented to work only when actively debugging
899 a program. It will not work for attached processes. */
903 /* See if we could read the address of a string, and that the
904 address isn't null. */
905 if (!ReadProcessMemory (h
, address
, &address_ptr
,
906 sizeof (address_ptr
), &done
)
907 || done
!= sizeof (address_ptr
) || !address_ptr
)
910 /* Find the length of the string. */
911 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
912 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
916 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
919 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
920 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
923 wcstombs (buf
, unicode_address
, __PMAX
);
925 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
933 /* Handle a DLL load event, and return 1.
935 This function assumes that this event did not occur during inferior
936 initialization, where their event info may be incomplete (see
937 do_initial_windows_stuff and windows_add_all_dlls for more info
938 on how we handle DLL loading during that phase). */
943 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
946 /* Try getting the DLL name via the lpImageName field of the event.
947 Note that Microsoft documents this fields as strictly optional,
948 in the sense that it might be NULL. And the first DLL event in
949 particular is explicitly documented as "likely not pass[ed]"
950 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
951 dll_name
= get_image_name (current_process_handle
,
952 event
->lpImageName
, event
->fUnicode
);
956 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
957 solib_end
= solib_end
->next
;
959 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
961 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
962 host_address_to_string (li
->load_addr
)));
966 windows_free_so (struct so_list
*so
)
968 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
974 /* Handle a DLL unload event.
975 Return 1 if successful, or zero otherwise.
977 This function assumes that this event did not occur during inferior
978 initialization, where their event info may be incomplete (see
979 do_initial_windows_stuff and windows_add_all_dlls for more info
980 on how we handle DLL loading during that phase). */
985 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
988 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
990 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
992 if (li_next
->load_addr
== lpBaseOfDll
)
994 struct so_list
*sodel
= so
->next
;
996 so
->next
= sodel
->next
;
999 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
1001 windows_free_so (sodel
);
1006 /* We did not find any DLL that was previously loaded at this address,
1007 so register a complaint. We do not report an error, because we have
1008 observed that this may be happening under some circumstances. For
1009 instance, running 32bit applications on x64 Windows causes us to receive
1010 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
1011 events are apparently caused by the WOW layer, the interface between
1012 32bit and 64bit worlds). */
1013 complaint (_("dll starting at %s not found."),
1014 host_address_to_string (lpBaseOfDll
));
1017 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
1021 catch_errors (void (*func
) ())
1027 catch (const gdb_exception
&ex
)
1029 exception_print (gdb_stderr
, ex
);
1033 /* Clear list of loaded DLLs. */
1035 windows_clear_solib (void)
1039 for (so
= solib_start
.next
; so
; so
= solib_start
.next
)
1041 solib_start
.next
= so
->next
;
1042 windows_free_so (so
);
1045 solib_end
= &solib_start
;
1049 signal_event_command (const char *args
, int from_tty
)
1051 uintptr_t event_id
= 0;
1052 char *endargs
= NULL
;
1055 error (_("signal-event requires an argument (integer event id)"));
1057 event_id
= strtoumax (args
, &endargs
, 10);
1059 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
1060 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
1061 error (_("Failed to convert `%s' to event id"), args
);
1063 SetEvent ((HANDLE
) event_id
);
1064 CloseHandle ((HANDLE
) event_id
);
1067 /* Handle DEBUG_STRING output from child process.
1068 Cygwin prepends its messages with a "cygwin:". Interpret this as
1069 a Cygwin signal. Otherwise just print the string as a warning. */
1071 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
1073 gdb::unique_xmalloc_ptr
<char> s
;
1076 if (!target_read_string
1077 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
1079 || !s
|| !*(s
.get ()))
1080 /* nothing to do */;
1081 else if (!startswith (s
.get (), _CYGWIN_SIGNAL_STRING
))
1084 if (!startswith (s
.get (), "cYg"))
1087 char *p
= strchr (s
.get (), '\0');
1089 if (p
> s
.get () && *--p
== '\n')
1091 warning (("%s"), s
.get ());
1097 /* Got a cygwin signal marker. A cygwin signal is followed by
1098 the signal number itself and then optionally followed by the
1099 thread id and address to saved context within the DLL. If
1100 these are supplied, then the given thread is assumed to have
1101 issued the signal and the context from the thread is assumed
1102 to be stored at the given address in the inferior. Tell gdb
1103 to treat this like a real signal. */
1105 int sig
= strtol (s
.get () + sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
1106 gdb_signal gotasig
= gdb_signal_from_host (sig
);
1108 ourstatus
->value
.sig
= gotasig
;
1114 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1115 retval
= strtoul (p
, &p
, 0);
1117 retval
= current_event
.dwThreadId
;
1118 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
1119 && ReadProcessMemory (current_process_handle
, x
,
1121 __COPY_CONTEXT_SIZE
, &n
)
1122 && n
== __COPY_CONTEXT_SIZE
)
1123 have_saved_context
= 1;
1132 display_selector (HANDLE thread
, DWORD sel
)
1138 ret
= Wow64GetThreadSelectorEntry (thread
, sel
, &info
);
1141 ret
= GetThreadSelectorEntry (thread
, sel
, &info
);
1145 printf_filtered ("0x%03x: ", (unsigned) sel
);
1146 if (!info
.HighWord
.Bits
.Pres
)
1148 puts_filtered ("Segment not present\n");
1151 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1152 (info
.HighWord
.Bits
.BaseMid
<< 16)
1154 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1155 if (info
.HighWord
.Bits
.Granularity
)
1156 limit
= (limit
<< 12) | 0xfff;
1157 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1158 if (info
.HighWord
.Bits
.Default_Big
)
1159 puts_filtered(" 32-bit ");
1161 puts_filtered(" 16-bit ");
1162 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1165 puts_filtered ("Data (Read-Only, Exp-up");
1168 puts_filtered ("Data (Read/Write, Exp-up");
1171 puts_filtered ("Unused segment (");
1174 puts_filtered ("Data (Read/Write, Exp-down");
1177 puts_filtered ("Code (Exec-Only, N.Conf");
1180 puts_filtered ("Code (Exec/Read, N.Conf");
1183 puts_filtered ("Code (Exec-Only, Conf");
1186 puts_filtered ("Code (Exec/Read, Conf");
1189 printf_filtered ("Unknown type 0x%lx",
1190 (unsigned long) info
.HighWord
.Bits
.Type
);
1192 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1193 puts_filtered(", N.Acc");
1194 puts_filtered (")\n");
1195 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1196 puts_filtered("System selector ");
1197 printf_filtered ("Priviledge level = %ld. ",
1198 (unsigned long) info
.HighWord
.Bits
.Dpl
);
1199 if (info
.HighWord
.Bits
.Granularity
)
1200 puts_filtered ("Page granular.\n");
1202 puts_filtered ("Byte granular.\n");
1207 DWORD err
= GetLastError ();
1208 if (err
== ERROR_NOT_SUPPORTED
)
1209 printf_filtered ("Function not supported\n");
1211 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1217 display_selectors (const char * args
, int from_tty
)
1219 if (!current_thread
)
1221 puts_filtered ("Impossible to display selectors now.\n");
1229 puts_filtered ("Selector $cs\n");
1230 display_selector (current_thread
->h
,
1231 current_thread
->wow64_context
.SegCs
);
1232 puts_filtered ("Selector $ds\n");
1233 display_selector (current_thread
->h
,
1234 current_thread
->wow64_context
.SegDs
);
1235 puts_filtered ("Selector $es\n");
1236 display_selector (current_thread
->h
,
1237 current_thread
->wow64_context
.SegEs
);
1238 puts_filtered ("Selector $ss\n");
1239 display_selector (current_thread
->h
,
1240 current_thread
->wow64_context
.SegSs
);
1241 puts_filtered ("Selector $fs\n");
1242 display_selector (current_thread
->h
,
1243 current_thread
->wow64_context
.SegFs
);
1244 puts_filtered ("Selector $gs\n");
1245 display_selector (current_thread
->h
,
1246 current_thread
->wow64_context
.SegGs
);
1251 puts_filtered ("Selector $cs\n");
1252 display_selector (current_thread
->h
,
1253 current_thread
->context
.SegCs
);
1254 puts_filtered ("Selector $ds\n");
1255 display_selector (current_thread
->h
,
1256 current_thread
->context
.SegDs
);
1257 puts_filtered ("Selector $es\n");
1258 display_selector (current_thread
->h
,
1259 current_thread
->context
.SegEs
);
1260 puts_filtered ("Selector $ss\n");
1261 display_selector (current_thread
->h
,
1262 current_thread
->context
.SegSs
);
1263 puts_filtered ("Selector $fs\n");
1264 display_selector (current_thread
->h
,
1265 current_thread
->context
.SegFs
);
1266 puts_filtered ("Selector $gs\n");
1267 display_selector (current_thread
->h
,
1268 current_thread
->context
.SegGs
);
1274 sel
= parse_and_eval_long (args
);
1275 printf_filtered ("Selector \"%s\"\n",args
);
1276 display_selector (current_thread
->h
, sel
);
1280 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1281 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1282 host_address_to_string (\
1283 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1285 static handle_exception_result
1286 handle_exception (struct target_waitstatus
*ourstatus
)
1288 EXCEPTION_RECORD
*rec
= ¤t_event
.u
.Exception
.ExceptionRecord
;
1289 DWORD code
= rec
->ExceptionCode
;
1290 handle_exception_result result
= HANDLE_EXCEPTION_HANDLED
;
1292 memcpy (&siginfo_er
, rec
, sizeof siginfo_er
);
1294 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1296 /* Record the context of the current thread. */
1297 thread_rec (current_event
.dwThreadId
, -1);
1301 case EXCEPTION_ACCESS_VIOLATION
:
1302 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1303 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1306 /* See if the access violation happened within the cygwin DLL
1307 itself. Cygwin uses a kind of exception handling to deal
1308 with passed-in invalid addresses. gdb should not treat
1309 these as real SEGVs since they will be silently handled by
1310 cygwin. A real SEGV will (theoretically) be caught by
1311 cygwin later in the process and will be sent as a
1312 cygwin-specific-signal. So, ignore SEGVs if they show up
1313 within the text segment of the DLL itself. */
1315 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1317 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1318 && addr
< cygwin_load_end
))
1319 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1320 && startswith (fn
, "KERNEL32!IsBad")))
1321 return HANDLE_EXCEPTION_UNHANDLED
;
1325 case STATUS_STACK_OVERFLOW
:
1326 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1327 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1329 case STATUS_FLOAT_DENORMAL_OPERAND
:
1330 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1331 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1333 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1334 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1335 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1337 case STATUS_FLOAT_INEXACT_RESULT
:
1338 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1339 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1341 case STATUS_FLOAT_INVALID_OPERATION
:
1342 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1343 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1345 case STATUS_FLOAT_OVERFLOW
:
1346 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1347 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1349 case STATUS_FLOAT_STACK_CHECK
:
1350 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1351 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1353 case STATUS_FLOAT_UNDERFLOW
:
1354 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1355 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1357 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1358 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1359 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1361 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1362 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1363 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1365 case STATUS_INTEGER_OVERFLOW
:
1366 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1367 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1369 case EXCEPTION_BREAKPOINT
:
1371 if (ignore_first_breakpoint
)
1373 /* For WOW64 processes, there are always 2 breakpoint exceptions
1374 on startup, first a BREAKPOINT for the 64bit ntdll.dll,
1375 then a WX86_BREAKPOINT for the 32bit ntdll.dll.
1376 Here we only care about the WX86_BREAKPOINT's. */
1377 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1378 ignore_first_breakpoint
= false;
1382 case STATUS_WX86_BREAKPOINT
:
1383 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1384 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1387 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1388 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1390 case DBG_CONTROL_BREAK
:
1391 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1392 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1394 case EXCEPTION_SINGLE_STEP
:
1395 case STATUS_WX86_SINGLE_STEP
:
1396 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1397 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1399 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1400 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1401 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1403 case EXCEPTION_PRIV_INSTRUCTION
:
1404 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1405 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1407 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1408 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1409 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1411 case MS_VC_EXCEPTION
:
1412 if (rec
->NumberParameters
>= 3
1413 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1415 DWORD named_thread_id
;
1416 windows_thread_info
*named_thread
;
1417 CORE_ADDR thread_name_target
;
1419 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1421 thread_name_target
= rec
->ExceptionInformation
[1];
1422 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1424 if (named_thread_id
== (DWORD
) -1)
1425 named_thread_id
= current_event
.dwThreadId
;
1427 named_thread
= thread_rec (named_thread_id
, 0);
1428 if (named_thread
!= NULL
)
1430 int thread_name_len
;
1431 gdb::unique_xmalloc_ptr
<char> thread_name
;
1433 thread_name_len
= target_read_string (thread_name_target
,
1434 &thread_name
, 1025, NULL
);
1435 if (thread_name_len
> 0)
1437 thread_name
.get ()[thread_name_len
- 1] = '\0';
1438 xfree (named_thread
->name
);
1439 named_thread
->name
= thread_name
.release ();
1442 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1443 result
= HANDLE_EXCEPTION_IGNORED
;
1446 /* treat improperly formed exception as unknown */
1449 /* Treat unhandled first chance exceptions specially. */
1450 if (current_event
.u
.Exception
.dwFirstChance
)
1451 return HANDLE_EXCEPTION_UNHANDLED
;
1452 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1453 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1454 host_address_to_string (
1455 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1456 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1460 last_sig
= ourstatus
->value
.sig
;
1464 /* Resume thread specified by ID, or all artificially suspended
1465 threads, if we are continuing execution. KILLED non-zero means we
1466 have killed the inferior, so we should ignore weird errors due to
1467 threads shutting down. */
1469 windows_continue (DWORD continue_status
, int id
, int killed
)
1473 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1474 (unsigned) current_event
.dwProcessId
,
1475 (unsigned) current_event
.dwThreadId
,
1476 continue_status
== DBG_CONTINUE
?
1477 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1479 for (windows_thread_info
*th
: thread_list
)
1480 if ((id
== -1 || id
== (int) th
->id
)
1486 if (debug_registers_changed
)
1488 th
->wow64_context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1489 th
->wow64_context
.Dr0
= dr
[0];
1490 th
->wow64_context
.Dr1
= dr
[1];
1491 th
->wow64_context
.Dr2
= dr
[2];
1492 th
->wow64_context
.Dr3
= dr
[3];
1493 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1494 th
->wow64_context
.Dr7
= dr
[7];
1496 if (th
->wow64_context
.ContextFlags
)
1500 if (GetExitCodeThread (th
->h
, &ec
)
1501 && ec
== STILL_ACTIVE
)
1503 BOOL status
= Wow64SetThreadContext (th
->h
,
1504 &th
->wow64_context
);
1509 th
->wow64_context
.ContextFlags
= 0;
1515 if (debug_registers_changed
)
1517 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1518 th
->context
.Dr0
= dr
[0];
1519 th
->context
.Dr1
= dr
[1];
1520 th
->context
.Dr2
= dr
[2];
1521 th
->context
.Dr3
= dr
[3];
1522 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1523 th
->context
.Dr7
= dr
[7];
1525 if (th
->context
.ContextFlags
)
1529 if (GetExitCodeThread (th
->h
, &ec
)
1530 && ec
== STILL_ACTIVE
)
1532 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1537 th
->context
.ContextFlags
= 0;
1540 if (th
->suspended
> 0)
1541 (void) ResumeThread (th
->h
);
1545 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1546 current_event
.dwThreadId
,
1550 error (_("Failed to resume program execution"
1551 " (ContinueDebugEvent failed, error %u)"),
1552 (unsigned int) GetLastError ());
1554 debug_registers_changed
= 0;
1558 /* Called in pathological case where Windows fails to send a
1559 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1561 fake_create_process (void)
1563 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1564 current_event
.dwProcessId
);
1565 if (current_process_handle
!= NULL
)
1566 open_process_used
= 1;
1569 error (_("OpenProcess call failed, GetLastError = %u"),
1570 (unsigned) GetLastError ());
1571 /* We can not debug anything in that case. */
1574 = windows_add_thread (ptid_t (current_event
.dwProcessId
, 0,
1575 current_event
.dwThreadId
),
1576 current_event
.u
.CreateThread
.hThread
,
1577 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1578 true /* main_thread_p */);
1579 return current_event
.dwThreadId
;
1583 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1585 windows_thread_info
*th
;
1586 DWORD continue_status
= DBG_CONTINUE
;
1588 /* A specific PTID means `step only this thread id'. */
1589 int resume_all
= ptid
== minus_one_ptid
;
1591 /* If we're continuing all threads, it's the current inferior that
1592 should be handled specially. */
1594 ptid
= inferior_ptid
;
1596 if (sig
!= GDB_SIGNAL_0
)
1598 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1600 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1602 else if (sig
== last_sig
)
1603 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1606 /* This code does not seem to work, because
1607 the kernel does probably not consider changes in the ExceptionRecord
1608 structure when passing the exception to the inferior.
1609 Note that this seems possible in the exception handler itself. */
1611 for (const xlate_exception
&x
: xlate
)
1614 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1616 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1619 if (continue_status
== DBG_CONTINUE
)
1621 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1625 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1629 last_sig
= GDB_SIGNAL_0
;
1631 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=0x%x, step=%d, sig=%d);\n",
1632 ptid
.pid (), (unsigned) ptid
.tid (), step
, sig
));
1634 /* Get context for currently selected thread. */
1635 th
= thread_rec (inferior_ptid
.tid (), FALSE
);
1643 /* Single step by setting t bit. */
1644 struct regcache
*regcache
= get_current_regcache ();
1645 struct gdbarch
*gdbarch
= regcache
->arch ();
1646 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1647 th
->wow64_context
.EFlags
|= FLAG_TRACE_BIT
;
1650 if (th
->wow64_context
.ContextFlags
)
1652 if (debug_registers_changed
)
1654 th
->wow64_context
.Dr0
= dr
[0];
1655 th
->wow64_context
.Dr1
= dr
[1];
1656 th
->wow64_context
.Dr2
= dr
[2];
1657 th
->wow64_context
.Dr3
= dr
[3];
1658 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1659 th
->wow64_context
.Dr7
= dr
[7];
1661 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
1662 th
->wow64_context
.ContextFlags
= 0;
1670 /* Single step by setting t bit. */
1671 struct regcache
*regcache
= get_current_regcache ();
1672 struct gdbarch
*gdbarch
= regcache
->arch ();
1673 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1674 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1677 if (th
->context
.ContextFlags
)
1679 if (debug_registers_changed
)
1681 th
->context
.Dr0
= dr
[0];
1682 th
->context
.Dr1
= dr
[1];
1683 th
->context
.Dr2
= dr
[2];
1684 th
->context
.Dr3
= dr
[3];
1685 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1686 th
->context
.Dr7
= dr
[7];
1688 CHECK (SetThreadContext (th
->h
, &th
->context
));
1689 th
->context
.ContextFlags
= 0;
1694 /* Allow continuing with the same signal that interrupted us.
1695 Otherwise complain. */
1698 windows_continue (continue_status
, -1, 0);
1700 windows_continue (continue_status
, ptid
.tid (), 0);
1703 /* Ctrl-C handler used when the inferior is not run in the same console. The
1704 handler is in charge of interrupting the inferior using DebugBreakProcess.
1705 Note that this function is not available prior to Windows XP. In this case
1706 we emit a warning. */
1708 ctrl_c_handler (DWORD event_type
)
1710 const int attach_flag
= current_inferior ()->attach_flag
;
1712 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1713 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1716 /* If the inferior and the debugger share the same console, do nothing as
1717 the inferior has also received the Ctrl-C event. */
1718 if (!new_console
&& !attach_flag
)
1721 if (!DebugBreakProcess (current_process_handle
))
1722 warning (_("Could not interrupt program. "
1723 "Press Ctrl-c in the program console."));
1725 /* Return true to tell that Ctrl-C has been handled. */
1729 /* Get the next event from the child. Returns a non-zero thread id if the event
1730 requires handling by WFI (or whatever). */
1733 windows_nat_target::get_windows_debug_event (int pid
,
1734 struct target_waitstatus
*ourstatus
)
1737 DWORD continue_status
, event_code
;
1738 windows_thread_info
*th
;
1739 static windows_thread_info dummy_thread_info
;
1740 DWORD thread_id
= 0;
1742 last_sig
= GDB_SIGNAL_0
;
1744 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1748 continue_status
= DBG_CONTINUE
;
1750 event_code
= current_event
.dwDebugEventCode
;
1751 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1753 have_saved_context
= 0;
1757 case CREATE_THREAD_DEBUG_EVENT
:
1758 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1759 (unsigned) current_event
.dwProcessId
,
1760 (unsigned) current_event
.dwThreadId
,
1761 "CREATE_THREAD_DEBUG_EVENT"));
1762 if (saw_create
!= 1)
1764 inferior
*inf
= find_inferior_pid (this, current_event
.dwProcessId
);
1765 if (!saw_create
&& inf
->attach_flag
)
1767 /* Kludge around a Windows bug where first event is a create
1768 thread event. Caused when attached process does not have
1770 thread_id
= fake_create_process ();
1776 /* Record the existence of this thread. */
1777 thread_id
= current_event
.dwThreadId
;
1778 th
= windows_add_thread
1779 (ptid_t (current_event
.dwProcessId
, 0, current_event
.dwThreadId
),
1780 current_event
.u
.CreateThread
.hThread
,
1781 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1782 false /* main_thread_p */);
1786 case EXIT_THREAD_DEBUG_EVENT
:
1787 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1788 (unsigned) current_event
.dwProcessId
,
1789 (unsigned) current_event
.dwThreadId
,
1790 "EXIT_THREAD_DEBUG_EVENT"));
1791 windows_delete_thread (ptid_t (current_event
.dwProcessId
, 0,
1792 current_event
.dwThreadId
),
1793 current_event
.u
.ExitThread
.dwExitCode
,
1794 false /* main_thread_p */);
1795 th
= &dummy_thread_info
;
1798 case CREATE_PROCESS_DEBUG_EVENT
:
1799 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1800 (unsigned) current_event
.dwProcessId
,
1801 (unsigned) current_event
.dwThreadId
,
1802 "CREATE_PROCESS_DEBUG_EVENT"));
1803 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1804 if (++saw_create
!= 1)
1807 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1808 /* Add the main thread. */
1809 th
= windows_add_thread
1810 (ptid_t (current_event
.dwProcessId
, 0,
1811 current_event
.dwThreadId
),
1812 current_event
.u
.CreateProcessInfo
.hThread
,
1813 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
,
1814 true /* main_thread_p */);
1815 thread_id
= current_event
.dwThreadId
;
1818 case EXIT_PROCESS_DEBUG_EVENT
:
1819 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1820 (unsigned) current_event
.dwProcessId
,
1821 (unsigned) current_event
.dwThreadId
,
1822 "EXIT_PROCESS_DEBUG_EVENT"));
1823 if (!windows_initialization_done
)
1825 target_terminal::ours ();
1826 target_mourn_inferior (inferior_ptid
);
1827 error (_("During startup program exited with code 0x%x."),
1828 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1830 else if (saw_create
== 1)
1832 windows_delete_thread (ptid_t (current_event
.dwProcessId
, 0,
1833 current_event
.dwThreadId
),
1834 0, true /* main_thread_p */);
1835 DWORD exit_status
= current_event
.u
.ExitProcess
.dwExitCode
;
1836 /* If the exit status looks like a fatal exception, but we
1837 don't recognize the exception's code, make the original
1838 exit status value available, to avoid losing
1841 = WIFSIGNALED (exit_status
) ? WTERMSIG (exit_status
) : -1;
1842 if (exit_signal
== -1)
1844 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1845 ourstatus
->value
.integer
= exit_status
;
1849 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1850 ourstatus
->value
.sig
= gdb_signal_from_host (exit_signal
);
1852 thread_id
= current_event
.dwThreadId
;
1856 case LOAD_DLL_DEBUG_EVENT
:
1857 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1858 (unsigned) current_event
.dwProcessId
,
1859 (unsigned) current_event
.dwThreadId
,
1860 "LOAD_DLL_DEBUG_EVENT"));
1861 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1862 if (saw_create
!= 1 || ! windows_initialization_done
)
1864 catch_errors (handle_load_dll
);
1865 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1866 ourstatus
->value
.integer
= 0;
1867 thread_id
= current_event
.dwThreadId
;
1870 case UNLOAD_DLL_DEBUG_EVENT
:
1871 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1872 (unsigned) current_event
.dwProcessId
,
1873 (unsigned) current_event
.dwThreadId
,
1874 "UNLOAD_DLL_DEBUG_EVENT"));
1875 if (saw_create
!= 1 || ! windows_initialization_done
)
1877 catch_errors (handle_unload_dll
);
1878 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1879 ourstatus
->value
.integer
= 0;
1880 thread_id
= current_event
.dwThreadId
;
1883 case EXCEPTION_DEBUG_EVENT
:
1884 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1885 (unsigned) current_event
.dwProcessId
,
1886 (unsigned) current_event
.dwThreadId
,
1887 "EXCEPTION_DEBUG_EVENT"));
1888 if (saw_create
!= 1)
1890 switch (handle_exception (ourstatus
))
1892 case HANDLE_EXCEPTION_UNHANDLED
:
1894 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1896 case HANDLE_EXCEPTION_HANDLED
:
1897 thread_id
= current_event
.dwThreadId
;
1899 case HANDLE_EXCEPTION_IGNORED
:
1900 continue_status
= DBG_CONTINUE
;
1905 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1906 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1907 (unsigned) current_event
.dwProcessId
,
1908 (unsigned) current_event
.dwThreadId
,
1909 "OUTPUT_DEBUG_STRING_EVENT"));
1910 if (saw_create
!= 1)
1912 thread_id
= handle_output_debug_string (ourstatus
);
1916 if (saw_create
!= 1)
1918 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1919 (unsigned) current_event
.dwProcessId
,
1920 (unsigned) current_event
.dwThreadId
);
1921 printf_unfiltered (" unknown event code %u\n",
1922 (unsigned) current_event
.dwDebugEventCode
);
1926 if (!thread_id
|| saw_create
!= 1)
1928 CHECK (windows_continue (continue_status
, -1, 0));
1932 inferior_ptid
= ptid_t (current_event
.dwProcessId
, 0, thread_id
);
1933 current_thread
= th
;
1934 if (!current_thread
)
1935 current_thread
= thread_rec (thread_id
, TRUE
);
1942 /* Wait for interesting events to occur in the target process. */
1944 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1949 /* We loop when we get a non-standard exception rather than return
1950 with a SPURIOUS because resume can try and step or modify things,
1951 which needs a current_thread->h. But some of these exceptions mark
1952 the birth or death of threads, which mean that the current thread
1953 isn't necessarily what you think it is. */
1959 /* If the user presses Ctrl-c while the debugger is waiting
1960 for an event, he expects the debugger to interrupt his program
1961 and to get the prompt back. There are two possible situations:
1963 - The debugger and the program do not share the console, in
1964 which case the Ctrl-c event only reached the debugger.
1965 In that case, the ctrl_c handler will take care of interrupting
1966 the inferior. Note that this case is working starting with
1967 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1970 - The debugger and the program share the same console, in which
1971 case both debugger and inferior will receive the Ctrl-c event.
1972 In that case the ctrl_c handler will ignore the event, as the
1973 Ctrl-c event generated inside the inferior will trigger the
1974 expected debug event.
1976 FIXME: brobecker/2008-05-20: If the inferior receives the
1977 signal first and the delay until GDB receives that signal
1978 is sufficiently long, GDB can sometimes receive the SIGINT
1979 after we have unblocked the CTRL+C handler. This would
1980 lead to the debugger stopping prematurely while handling
1981 the new-thread event that comes with the handling of the SIGINT
1982 inside the inferior, and then stop again immediately when
1983 the user tries to resume the execution in the inferior.
1984 This is a classic race that we should try to fix one day. */
1985 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1986 retval
= get_windows_debug_event (pid
, ourstatus
);
1987 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1990 return ptid_t (current_event
.dwProcessId
, 0, retval
);
1995 if (deprecated_ui_loop_hook
!= NULL
)
1996 detach
= deprecated_ui_loop_hook (0);
2004 /* Iterate over all DLLs currently mapped by our inferior, and
2005 add them to our list of solibs. */
2008 windows_add_all_dlls (void)
2010 HMODULE dummy_hmodule
;
2018 if (EnumProcessModulesEx (current_process_handle
, &dummy_hmodule
,
2019 sizeof (HMODULE
), &cb_needed
,
2020 LIST_MODULES_32BIT
) == 0)
2026 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
2027 sizeof (HMODULE
), &cb_needed
) == 0)
2034 hmodules
= (HMODULE
*) alloca (cb_needed
);
2038 if (EnumProcessModulesEx (current_process_handle
, hmodules
,
2039 cb_needed
, &cb_needed
,
2040 LIST_MODULES_32BIT
) == 0)
2046 if (EnumProcessModules (current_process_handle
, hmodules
,
2047 cb_needed
, &cb_needed
) == 0)
2051 char system_dir
[__PMAX
];
2052 char syswow_dir
[__PMAX
];
2053 size_t system_dir_len
= 0;
2054 bool convert_syswow_dir
= false;
2059 /* This fails on 32bit Windows because it has no SysWOW64 directory,
2060 and in this case a path conversion isn't necessary. */
2061 UINT len
= GetSystemWow64DirectoryA (syswow_dir
, sizeof (syswow_dir
));
2064 /* Check that we have passed a large enough buffer. */
2065 gdb_assert (len
< sizeof (syswow_dir
));
2067 len
= GetSystemDirectoryA (system_dir
, sizeof (system_dir
));
2069 gdb_assert (len
!= 0);
2070 /* Check that we have passed a large enough buffer. */
2071 gdb_assert (len
< sizeof (system_dir
));
2073 strcat (system_dir
, "\\");
2074 strcat (syswow_dir
, "\\");
2075 system_dir_len
= strlen (system_dir
);
2077 convert_syswow_dir
= true;
2081 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
2085 wchar_t dll_name
[__PMAX
];
2086 char dll_name_mb
[__PMAX
];
2088 char dll_name
[__PMAX
];
2091 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
2092 &mi
, sizeof (mi
)) == 0)
2094 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
2095 dll_name
, sizeof (dll_name
)) == 0)
2098 wcstombs (dll_name_mb
, dll_name
, __PMAX
);
2103 /* Convert the DLL path of 32bit processes returned by
2104 GetModuleFileNameEx from the 64bit system directory to the
2105 32bit syswow64 directory if necessary. */
2106 std::string syswow_dll_path
;
2107 if (convert_syswow_dir
2108 && strncasecmp (name
, system_dir
, system_dir_len
) == 0
2109 && strchr (name
+ system_dir_len
, '\\') == nullptr)
2111 syswow_dll_path
= syswow_dir
;
2112 syswow_dll_path
+= name
+ system_dir_len
;
2113 name
= syswow_dll_path
.c_str();
2116 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
2117 solib_end
= solib_end
->next
;
2122 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
2125 struct inferior
*inf
;
2127 last_sig
= GDB_SIGNAL_0
;
2129 exception_count
= 0;
2130 open_process_used
= 0;
2131 debug_registers_changed
= 0;
2132 debug_registers_used
= 0;
2133 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
2136 cygwin_load_start
= cygwin_load_end
= 0;
2138 current_event
.dwProcessId
= pid
;
2139 memset (¤t_event
, 0, sizeof (current_event
));
2140 if (!target_is_pushed (ops
))
2142 disable_breakpoints_in_shlibs ();
2143 windows_clear_solib ();
2144 clear_proceed_status (0);
2145 init_wait_for_inferior ();
2148 ignore_first_breakpoint
= !attaching
&& wow64_process
;
2152 windows_set_context_register_offsets (amd64_mappings
);
2153 windows_set_segment_register_p (amd64_windows_segment_register_p
);
2158 windows_set_context_register_offsets (i386_mappings
);
2159 windows_set_segment_register_p (i386_windows_segment_register_p
);
2162 inf
= current_inferior ();
2163 inferior_appeared (inf
, pid
);
2164 inf
->attach_flag
= attaching
;
2166 /* Make the new process the current inferior, so terminal handling
2167 can rely on it. When attaching, we don't know about any thread
2168 id here, but that's OK --- nothing should be referencing the
2169 current thread until we report an event out of windows_wait. */
2170 inferior_ptid
= ptid_t (pid
);
2172 target_terminal::init ();
2173 target_terminal::inferior ();
2175 windows_initialization_done
= 0;
2179 struct target_waitstatus status
;
2181 ops
->wait (minus_one_ptid
, &status
, 0);
2183 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
2185 if (status
.kind
!= TARGET_WAITKIND_LOADED
2186 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
2189 ops
->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
2192 /* Now that the inferior has been started and all DLLs have been mapped,
2193 we can iterate over all DLLs and load them in.
2195 We avoid doing it any earlier because, on certain versions of Windows,
2196 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
2197 we have seen on Windows 8.1 that the ntdll.dll load event does not
2198 include the DLL name, preventing us from creating an associated SO.
2199 A possible explanation is that ntdll.dll might be mapped before
2200 the SO info gets created by the Windows system -- ntdll.dll is
2201 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
2202 do not seem to suffer from that problem.
2204 Rather than try to work around this sort of issue, it is much
2205 simpler to just ignore DLL load/unload events during the startup
2206 phase, and then process them all in one batch now. */
2207 windows_add_all_dlls ();
2209 windows_initialization_done
= 1;
2213 /* Try to set or remove a user privilege to the current process. Return -1
2214 if that fails, the previous setting of that privilege otherwise.
2216 This code is copied from the Cygwin source code and rearranged to allow
2217 dynamically loading of the needed symbols from advapi32 which is only
2218 available on NT/2K/XP. */
2220 set_process_privilege (const char *privilege
, BOOL enable
)
2222 HANDLE token_hdl
= NULL
;
2224 TOKEN_PRIVILEGES new_priv
, orig_priv
;
2228 if (!OpenProcessToken (GetCurrentProcess (),
2229 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
2233 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
2236 new_priv
.PrivilegeCount
= 1;
2237 new_priv
.Privileges
[0].Luid
= restore_priv
;
2238 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
2240 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
2241 sizeof orig_priv
, &orig_priv
, &size
))
2244 /* Disabled, otherwise every `attach' in an unprivileged user session
2245 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
2246 windows_attach(). */
2247 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
2248 be enabled. GetLastError () returns an correct error code, though. */
2249 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
2253 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
2257 CloseHandle (token_hdl
);
2262 /* Attach to process PID, then initialize for debugging it. */
2265 windows_nat_target::attach (const char *args
, int from_tty
)
2270 pid
= parse_pid_to_attach (args
);
2272 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
2274 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
2275 printf_unfiltered ("This can cause attach to "
2276 "fail on Windows NT/2K/XP\n");
2279 windows_init_thread_list ();
2280 ok
= DebugActiveProcess (pid
);
2286 /* Try fall back to Cygwin pid. */
2287 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
2290 ok
= DebugActiveProcess (pid
);
2295 error (_("Can't attach to process %u (error %u)"),
2296 (unsigned) pid
, (unsigned) GetLastError ());
2298 DebugSetProcessKillOnExit (FALSE
);
2302 const char *exec_file
= get_exec_file (0);
2305 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
2306 target_pid_to_str (ptid_t (pid
)).c_str ());
2308 printf_unfiltered ("Attaching to %s\n",
2309 target_pid_to_str (ptid_t (pid
)).c_str ());
2313 HANDLE h
= OpenProcess (PROCESS_QUERY_INFORMATION
, FALSE
, pid
);
2317 if (IsWow64Process (h
, &wow64
))
2318 wow64_process
= wow64
;
2323 do_initial_windows_stuff (this, pid
, 1);
2324 target_terminal::ours ();
2328 windows_nat_target::detach (inferior
*inf
, int from_tty
)
2332 ptid_t ptid
= minus_one_ptid
;
2333 resume (ptid
, 0, GDB_SIGNAL_0
);
2335 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
2337 error (_("Can't detach process %u (error %u)"),
2338 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
2341 DebugSetProcessKillOnExit (FALSE
);
2343 if (detached
&& from_tty
)
2345 const char *exec_file
= get_exec_file (0);
2348 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
2349 (unsigned) current_event
.dwProcessId
);
2352 x86_cleanup_dregs ();
2353 inferior_ptid
= null_ptid
;
2354 detach_inferior (inf
);
2356 maybe_unpush_target ();
2359 /* Try to determine the executable filename.
2361 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2363 Upon success, the filename is stored inside EXE_NAME_RET, and
2364 this function returns nonzero.
2366 Otherwise, this function returns zero and the contents of
2367 EXE_NAME_RET is undefined. */
2370 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2380 if (!EnumProcessModulesEx (current_process_handle
, &dh_buf
,
2381 sizeof (HMODULE
), &cbNeeded
,
2382 LIST_MODULES_32BIT
) || !cbNeeded
)
2388 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2389 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2393 /* We know the executable is always first in the list of modules,
2394 which we just fetched. So no need to fetch more. */
2398 /* Cygwin prefers that the path be in /x/y/z format, so extract
2399 the filename into a temporary buffer first, and then convert it
2400 to POSIX format into the destination buffer. */
2401 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2403 len
= GetModuleFileNameEx (current_process_handle
,
2404 dh_buf
, pathbuf
, exe_name_max_len
);
2406 error (_("Error getting executable filename: %u."),
2407 (unsigned) GetLastError ());
2408 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2409 exe_name_max_len
) < 0)
2410 error (_("Error converting executable filename to POSIX: %d."), errno
);
2413 len
= GetModuleFileNameEx (current_process_handle
,
2414 dh_buf
, exe_name_ret
, exe_name_max_len
);
2416 error (_("Error getting executable filename: %u."),
2417 (unsigned) GetLastError ());
2420 return 1; /* success */
2423 /* The pid_to_exec_file target_ops method for this platform. */
2426 windows_nat_target::pid_to_exec_file (int pid
)
2428 static char path
[__PMAX
];
2430 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2432 char procexe
[sizeof ("/proc/4294967295/exe")];
2434 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2435 nchars
= readlink (procexe
, path
, sizeof(path
));
2436 if (nchars
> 0 && nchars
< sizeof (path
))
2438 path
[nchars
] = '\0'; /* Got it */
2443 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2444 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2445 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2451 /* Print status information about what we're accessing. */
2454 windows_nat_target::files_info ()
2456 struct inferior
*inf
= current_inferior ();
2458 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2459 inf
->attach_flag
? "attached" : "child",
2460 target_pid_to_str (inferior_ptid
).c_str ());
2463 /* Modify CreateProcess parameters for use of a new separate console.
2465 *FLAGS: DWORD parameter for general process creation flags.
2466 *SI: STARTUPINFO structure, for which the console window size and
2467 console buffer size is filled in if GDB is running in a console.
2468 to create the new console.
2469 The size of the used font is not available on all versions of
2470 Windows OS. Furthermore, the current font might not be the default
2471 font, but this is still better than before.
2472 If the windows and buffer sizes are computed,
2473 SI->DWFLAGS is changed so that this information is used
2474 by CreateProcess function. */
2477 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2479 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2480 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2482 if (hconsole
!= INVALID_HANDLE_VALUE
)
2484 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2486 CONSOLE_FONT_INFO cfi
;
2488 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2489 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2490 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2491 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2492 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2494 si
->dwXSize
*= font_size
.X
;
2498 si
->dwYSize
*= font_size
.Y
;
2501 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2502 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2503 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2505 *flags
|= CREATE_NEW_CONSOLE
;
2509 /* Function called by qsort to sort environment strings. */
2512 envvar_cmp (const void *a
, const void *b
)
2514 const char **p
= (const char **) a
;
2515 const char **q
= (const char **) b
;
2516 return strcasecmp (*p
, *q
);
2522 clear_win32_environment (char **env
)
2526 wchar_t *copy
= NULL
, *equalpos
;
2528 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2530 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2531 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2532 mbstowcs (copy
, env
[i
], len
);
2533 equalpos
= wcschr (copy
, L
'=');
2536 SetEnvironmentVariableW (copy
, NULL
);
2544 /* Redirection of inferior I/O streams for native MS-Windows programs.
2545 Unlike on Unix, where this is handled by invoking the inferior via
2546 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2548 The official documentation of the cmd.exe redirection features is here:
2550 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2552 (That page talks about Windows XP, but there's no newer
2553 documentation, so we assume later versions of cmd.exe didn't change
2556 Caveat: the documentation on that page seems to include a few lies.
2557 For example, it describes strange constructs 1<&2 and 2<&1, which
2558 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2559 think the cmd.exe parser of the redirection symbols simply doesn't
2560 care about the < vs > distinction in these cases. Therefore, the
2561 supported features are explicitly documented below.
2563 The emulation below aims at supporting all the valid use cases
2564 supported by cmd.exe, which include:
2566 < FILE redirect standard input from FILE
2567 0< FILE redirect standard input from FILE
2568 <&N redirect standard input from file descriptor N
2569 0<&N redirect standard input from file descriptor N
2570 > FILE redirect standard output to FILE
2571 >> FILE append standard output to FILE
2572 1>> FILE append standard output to FILE
2573 >&N redirect standard output to file descriptor N
2574 1>&N redirect standard output to file descriptor N
2575 >>&N append standard output to file descriptor N
2576 1>>&N append standard output to file descriptor N
2577 2> FILE redirect standard error to FILE
2578 2>> FILE append standard error to FILE
2579 2>&N redirect standard error to file descriptor N
2580 2>>&N append standard error to file descriptor N
2582 Note that using N > 2 in the above construct is supported, but
2583 requires that the corresponding file descriptor be open by some
2584 means elsewhere or outside GDB. Also note that using ">&0" or
2585 "<&2" will generally fail, because the file descriptor redirected
2586 from is normally open in an incompatible mode (e.g., FD 0 is open
2587 for reading only). IOW, use of such tricks is not recommended;
2588 you are on your own.
2590 We do NOT support redirection of file descriptors above 2, as in
2591 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2592 that needs special handling in the startup code that MinGW
2593 doesn't have). Pipes are also not supported.
2595 As for invalid use cases, where the redirection contains some
2596 error, the emulation below will detect that and produce some
2597 error and/or failure. But the behavior in those cases is not
2598 bug-for-bug compatible with what cmd.exe does in those cases.
2599 That's because what cmd.exe does then is not well defined, and
2600 seems to be a side effect of the cmd.exe parsing of the command
2601 line more than anything else. For example, try redirecting to an
2602 invalid file name, as in "> foo:bar".
2604 There are also minor syntactic deviations from what cmd.exe does
2605 in some corner cases. For example, it doesn't support the likes
2606 of "> &foo" to mean redirect to file named literally "&foo"; we
2607 do support that here, because that, too, sounds like some issue
2608 with the cmd.exe parser. Another nicety is that we support
2609 redirection targets that use file names with forward slashes,
2610 something cmd.exe doesn't -- this comes in handy since GDB
2611 file-name completion can be used when typing the command line for
2614 /* Support routines for redirecting standard handles of the inferior. */
2616 /* Parse a single redirection spec, open/duplicate the specified
2617 file/fd, and assign the appropriate value to one of the 3 standard
2618 file descriptors. */
2620 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2622 int *fd
, ref_fd
= -2;
2624 const char *fname
= redir_string
+ 1;
2625 int rc
= *redir_string
;
2640 fd
= (rc
== '2') ? err
: out
;
2641 mode
= O_WRONLY
| O_CREAT
;
2654 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2656 /* A reference to a file descriptor. */
2658 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2659 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2661 /* Don't allow redirection when open modes are incompatible. */
2662 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2663 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2670 else if (ref_fd
== 1)
2672 else if (ref_fd
== 2)
2682 fname
++; /* skip the separator space */
2683 /* If the descriptor is already open, close it. This allows
2684 multiple specs of redirections for the same stream, which is
2685 somewhat nonsensical, but still valid and supported by cmd.exe.
2686 (But cmd.exe only opens a single file in this case, the one
2687 specified by the last redirection spec on the command line.) */
2692 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2696 else if (ref_fd
== -1)
2697 *fd
= -1; /* reset to default destination */
2700 *fd
= _dup (ref_fd
);
2704 /* _open just sets a flag for O_APPEND, which won't be passed to the
2705 inferior, so we need to actually move the file pointer. */
2706 if ((mode
& O_APPEND
) != 0)
2707 _lseek (*fd
, 0L, SEEK_END
);
2711 /* Canonicalize a single redirection spec and set up the corresponding
2712 file descriptor as specified. */
2714 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2716 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2718 const char *start
= s
;
2721 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2722 if ((*start
== '>' || *start
== '1' || *start
== '2')
2726 if (*s
== '>' && *start
!= '>')
2729 else if (*start
== '0' && *s
== '<')
2731 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2734 while (isspace (*s
)) /* skip whitespace before file name */
2736 *d
++ = ' '; /* separate file name with a single space */
2739 /* Copy the file name. */
2742 /* Remove quoting characters from the file name in buf[]. */
2743 if (*s
== '"') /* could support '..' quoting here */
2747 else if (*s
== quote
)
2755 else if (*s
== '\\')
2757 if (s
[1] == '"') /* could support '..' here */
2761 else if (isspace (*s
) && !quote
)
2765 if (d
- buf
>= sizeof (buf
) - 1)
2767 errno
= ENAMETOOLONG
;
2773 /* Windows doesn't allow redirection characters in file names, so we
2774 can bail out early if they use them, or if there's no target file
2775 name after the redirection symbol. */
2776 if (d
[-1] == '>' || d
[-1] == '<')
2781 if (redir_open (buf
, inp
, out
, err
) == 0)
2786 /* Parse the command line for redirection specs and prepare the file
2787 descriptors for the 3 standard streams accordingly. */
2789 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2790 int *inp
, int *out
, int *err
)
2792 const char *s
= cmd_orig
;
2795 bool retval
= false;
2797 while (isspace (*s
))
2802 if (*s
== '"') /* could also support '..' quoting here */
2806 else if (*s
== quote
)
2809 else if (*s
== '\\')
2811 if (s
[1] == '"') /* escaped quote char */
2816 /* Process a single redirection candidate. */
2817 if (*s
== '<' || *s
== '>'
2818 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2819 || (*s
== '0' && s
[1] == '<'))
2821 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2835 #endif /* !__CYGWIN__ */
2837 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2838 EXEC_FILE is the file to run.
2839 ALLARGS is a string containing the arguments to the program.
2840 ENV is the environment vector to pass. Errors reported with error(). */
2843 windows_nat_target::create_inferior (const char *exec_file
,
2844 const std::string
&origallargs
,
2845 char **in_env
, int from_tty
)
2849 cygwin_buf_t real_path
[__PMAX
];
2850 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2851 cygwin_buf_t infcwd
[__PMAX
];
2853 cygwin_buf_t
*toexec
;
2854 cygwin_buf_t
*cygallargs
;
2856 char **old_env
= NULL
;
2860 int ostdin
, ostdout
, ostderr
;
2861 #else /* !__CYGWIN__ */
2862 char shell
[__PMAX
]; /* Path to shell */
2864 char *args
, *allargs_copy
;
2865 size_t args_len
, allargs_len
;
2866 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2867 HANDLE tty
= INVALID_HANDLE_VALUE
;
2868 bool redirected
= false;
2875 #endif /* !__CYGWIN__ */
2876 const char *allargs
= origallargs
.c_str ();
2877 PROCESS_INFORMATION pi
;
2880 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2883 error (_("No executable specified, use `target exec'."));
2885 const char *inferior_cwd
= get_inferior_cwd ();
2886 std::string expanded_infcwd
;
2887 if (inferior_cwd
!= NULL
)
2889 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
2890 /* Mirror slashes on inferior's cwd. */
2891 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
2893 inferior_cwd
= expanded_infcwd
.c_str ();
2896 memset (&si
, 0, sizeof (si
));
2897 si
.cb
= sizeof (si
);
2900 flags
|= CREATE_NEW_PROCESS_GROUP
;
2903 windows_set_console_info (&si
, &flags
);
2908 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2909 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2910 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2911 error (_("Error starting executable: %d"), errno
);
2914 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2915 if (len
== (size_t) -1)
2916 error (_("Error starting executable: %d"), errno
);
2917 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2918 mbstowcs (cygallargs
, allargs
, len
);
2919 #else /* !__USEWIDE */
2920 cygallargs
= allargs
;
2926 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2927 error (_("Error starting executable via shell: %d"), errno
);
2929 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2930 + mbstowcs (NULL
, allargs
, 0) + 2;
2931 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2932 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2933 #else /* !__USEWIDE */
2934 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2935 + strlen (allargs
) + 2);
2936 cygallargs
= (char *) alloca (len
);
2937 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2938 #endif /* __USEWIDE */
2940 flags
|= DEBUG_PROCESS
;
2943 if (inferior_cwd
!= NULL
2944 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
2945 infcwd
, strlen (inferior_cwd
)) < 0)
2946 error (_("Error converting inferior cwd: %d"), errno
);
2949 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2950 * sizeof (wchar_t));
2951 wcscpy (args
, toexec
);
2952 wcscat (args
, L
" ");
2953 wcscat (args
, cygallargs
);
2954 #else /* !__USEWIDE */
2955 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2956 strcpy (args
, toexec
);
2958 strcat (args
, cygallargs
);
2959 #endif /* !__USEWIDE */
2961 #ifdef CW_CVT_ENV_TO_WINENV
2962 /* First try to create a direct Win32 copy of the POSIX environment. */
2963 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2964 if (w32_env
!= (PWCHAR
) -1)
2965 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2967 /* If that fails, fall back to old method tweaking GDB's environment. */
2968 #endif /* CW_CVT_ENV_TO_WINENV */
2970 /* Reset all Win32 environment variables to avoid leftover on next run. */
2971 clear_win32_environment (environ
);
2972 /* Prepare the environment vars for CreateProcess. */
2975 cygwin_internal (CW_SYNC_WINENV
);
2979 if (!inferior_io_terminal
)
2980 tty
= ostdin
= ostdout
= ostderr
= -1;
2983 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2986 print_sys_errmsg (inferior_io_terminal
, errno
);
2987 ostdin
= ostdout
= ostderr
= -1;
3000 windows_init_thread_list ();
3001 ret
= CreateProcess (0,
3002 args
, /* command line */
3003 NULL
, /* Security */
3005 TRUE
, /* inherit handles */
3006 flags
, /* start flags */
3007 w32_env
, /* environment */
3008 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
3013 /* Just free the Win32 environment, if it could be created. */
3017 /* Reset all environment variables to avoid leftover on next run. */
3018 clear_win32_environment (in_env
);
3019 /* Restore normal GDB environment variables. */
3021 cygwin_internal (CW_SYNC_WINENV
);
3034 #else /* !__CYGWIN__ */
3035 allargs_len
= strlen (allargs
);
3036 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
3037 if (strpbrk (allargs_copy
, "<>") != NULL
)
3042 redirect_inferior_handles (allargs
, allargs_copy
,
3043 &fd_inp
, &fd_out
, &fd_err
);
3045 warning (_("Error in redirection: %s."), safe_strerror (errno
));
3048 allargs_len
= strlen (allargs_copy
);
3050 /* If not all the standard streams are redirected by the command
3051 line, use inferior_io_terminal for those which aren't. */
3052 if (inferior_io_terminal
3053 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
3055 SECURITY_ATTRIBUTES sa
;
3056 sa
.nLength
= sizeof(sa
);
3057 sa
.lpSecurityDescriptor
= 0;
3058 sa
.bInheritHandle
= TRUE
;
3059 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
3060 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
3061 if (tty
== INVALID_HANDLE_VALUE
)
3062 warning (_("Warning: Failed to open TTY %s, error %#x."),
3063 inferior_io_terminal
, (unsigned) GetLastError ());
3065 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
3068 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
3069 else if (tty
!= INVALID_HANDLE_VALUE
)
3072 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
3074 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
3075 else if (tty
!= INVALID_HANDLE_VALUE
)
3076 si
.hStdOutput
= tty
;
3078 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
3080 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
3081 else if (tty
!= INVALID_HANDLE_VALUE
)
3084 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
3085 si
.dwFlags
|= STARTF_USESTDHANDLES
;
3089 /* Build the command line, a space-separated list of tokens where
3090 the first token is the name of the module to be executed.
3091 To avoid ambiguities introduced by spaces in the module name,
3093 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
3094 args
= (char *) alloca (args_len
);
3095 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
3097 flags
|= DEBUG_ONLY_THIS_PROCESS
;
3099 /* CreateProcess takes the environment list as a null terminated set of
3100 strings (i.e. two nulls terminate the list). */
3102 /* Get total size for env strings. */
3103 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
3104 envlen
+= strlen (in_env
[i
]) + 1;
3106 envsize
= sizeof (in_env
[0]) * (i
+ 1);
3107 env
= (char **) alloca (envsize
);
3108 memcpy (env
, in_env
, envsize
);
3109 /* Windows programs expect the environment block to be sorted. */
3110 qsort (env
, i
, sizeof (char *), envvar_cmp
);
3112 w32env
= (char *) alloca (envlen
+ 1);
3114 /* Copy env strings into new buffer. */
3115 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
3117 strcpy (temp
, env
[i
]);
3118 temp
+= strlen (temp
) + 1;
3121 /* Final nil string to terminate new env. */
3124 windows_init_thread_list ();
3125 ret
= CreateProcessA (0,
3126 args
, /* command line */
3127 NULL
, /* Security */
3129 TRUE
, /* inherit handles */
3130 flags
, /* start flags */
3131 w32env
, /* environment */
3132 inferior_cwd
, /* current directory */
3135 if (tty
!= INVALID_HANDLE_VALUE
)
3143 #endif /* !__CYGWIN__ */
3146 error (_("Error creating process %s, (error %u)."),
3147 exec_file
, (unsigned) GetLastError ());
3151 if (IsWow64Process (pi
.hProcess
, &wow64
))
3152 wow64_process
= wow64
;
3155 CloseHandle (pi
.hThread
);
3156 CloseHandle (pi
.hProcess
);
3158 if (useshell
&& shell
[0] != '\0')
3163 do_initial_windows_stuff (this, pi
.dwProcessId
, 0);
3165 /* windows_continue (DBG_CONTINUE, -1, 0); */
3169 windows_nat_target::mourn_inferior ()
3171 (void) windows_continue (DBG_CONTINUE
, -1, 0);
3172 x86_cleanup_dregs();
3173 if (open_process_used
)
3175 CHECK (CloseHandle (current_process_handle
));
3176 open_process_used
= 0;
3178 siginfo_er
.ExceptionCode
= 0;
3179 inf_child_target::mourn_inferior ();
3182 /* Send a SIGINT to the process group. This acts just like the user typed a
3183 ^C on the controlling terminal. */
3186 windows_nat_target::interrupt ()
3188 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
3189 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
3190 registers_changed (); /* refresh register state */
3193 /* Helper for windows_xfer_partial that handles memory transfers.
3194 Arguments are like target_xfer_partial. */
3196 static enum target_xfer_status
3197 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3198 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
3202 DWORD lasterror
= 0;
3204 if (writebuf
!= NULL
)
3206 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
3207 pulongest (len
), core_addr_to_string (memaddr
)));
3208 success
= WriteProcessMemory (current_process_handle
,
3209 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
3212 lasterror
= GetLastError ();
3213 FlushInstructionCache (current_process_handle
,
3214 (LPCVOID
) (uintptr_t) memaddr
, len
);
3218 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
3219 pulongest (len
), core_addr_to_string (memaddr
)));
3220 success
= ReadProcessMemory (current_process_handle
,
3221 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
3224 lasterror
= GetLastError ();
3226 *xfered_len
= (ULONGEST
) done
;
3227 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
3228 return TARGET_XFER_OK
;
3230 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
3234 windows_nat_target::kill ()
3236 CHECK (TerminateProcess (current_process_handle
, 0));
3240 if (!windows_continue (DBG_CONTINUE
, -1, 1))
3242 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
3244 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
3248 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
3252 windows_nat_target::close ()
3254 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
3255 inferior_ptid
.pid ()));
3258 /* Convert pid to printable format. */
3260 windows_nat_target::pid_to_str (ptid_t ptid
)
3262 if (ptid
.tid () != 0)
3263 return string_printf ("Thread %d.0x%lx", ptid
.pid (), ptid
.tid ());
3265 return normal_pid_to_str (ptid
);
3268 static enum target_xfer_status
3269 windows_xfer_shared_libraries (struct target_ops
*ops
,
3270 enum target_object object
, const char *annex
,
3271 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3272 ULONGEST offset
, ULONGEST len
,
3273 ULONGEST
*xfered_len
)
3275 struct obstack obstack
;
3281 return TARGET_XFER_E_IO
;
3283 obstack_init (&obstack
);
3284 obstack_grow_str (&obstack
, "<library-list>\n");
3285 for (so
= solib_start
.next
; so
; so
= so
->next
)
3287 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
3289 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
3290 (uintptr_t) li
->load_addr
,
3292 target_gdbarch (), &obstack
);
3294 obstack_grow_str0 (&obstack
, "</library-list>\n");
3296 buf
= (const char *) obstack_finish (&obstack
);
3297 len_avail
= strlen (buf
);
3298 if (offset
>= len_avail
)
3302 if (len
> len_avail
- offset
)
3303 len
= len_avail
- offset
;
3304 memcpy (readbuf
, buf
+ offset
, len
);
3307 obstack_free (&obstack
, NULL
);
3308 *xfered_len
= (ULONGEST
) len
;
3309 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
3312 /* Helper for windows_nat_target::xfer_partial that handles signal info. */
3314 static enum target_xfer_status
3315 windows_xfer_siginfo (gdb_byte
*readbuf
, ULONGEST offset
, ULONGEST len
,
3316 ULONGEST
*xfered_len
)
3318 char *buf
= (char *) &siginfo_er
;
3319 size_t bufsize
= sizeof (siginfo_er
);
3322 EXCEPTION_RECORD32 er32
;
3325 buf
= (char *) &er32
;
3326 bufsize
= sizeof (er32
);
3328 er32
.ExceptionCode
= siginfo_er
.ExceptionCode
;
3329 er32
.ExceptionFlags
= siginfo_er
.ExceptionFlags
;
3330 er32
.ExceptionRecord
= (uintptr_t) siginfo_er
.ExceptionRecord
;
3331 er32
.ExceptionAddress
= (uintptr_t) siginfo_er
.ExceptionAddress
;
3332 er32
.NumberParameters
= siginfo_er
.NumberParameters
;
3334 for (i
= 0; i
< EXCEPTION_MAXIMUM_PARAMETERS
; i
++)
3335 er32
.ExceptionInformation
[i
] = siginfo_er
.ExceptionInformation
[i
];
3339 if (siginfo_er
.ExceptionCode
== 0)
3340 return TARGET_XFER_E_IO
;
3342 if (readbuf
== nullptr)
3343 return TARGET_XFER_E_IO
;
3345 if (offset
> bufsize
)
3346 return TARGET_XFER_E_IO
;
3348 if (offset
+ len
> bufsize
)
3349 len
= bufsize
- offset
;
3351 memcpy (readbuf
, buf
+ offset
, len
);
3354 return TARGET_XFER_OK
;
3357 enum target_xfer_status
3358 windows_nat_target::xfer_partial (enum target_object object
,
3359 const char *annex
, gdb_byte
*readbuf
,
3360 const gdb_byte
*writebuf
, ULONGEST offset
,
3361 ULONGEST len
, ULONGEST
*xfered_len
)
3365 case TARGET_OBJECT_MEMORY
:
3366 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
3368 case TARGET_OBJECT_LIBRARIES
:
3369 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
3370 writebuf
, offset
, len
, xfered_len
);
3372 case TARGET_OBJECT_SIGNAL_INFO
:
3373 return windows_xfer_siginfo (readbuf
, offset
, len
, xfered_len
);
3376 if (beneath () == NULL
)
3378 /* This can happen when requesting the transfer of unsupported
3379 objects before a program has been started (and therefore
3380 with the current_target having no target beneath). */
3381 return TARGET_XFER_E_IO
;
3383 return beneath ()->xfer_partial (object
, annex
,
3384 readbuf
, writebuf
, offset
, len
,
3389 /* Provide thread local base, i.e. Thread Information Block address.
3390 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
3393 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
3395 windows_thread_info
*th
;
3397 th
= thread_rec (ptid
.tid (), 0);
3402 *addr
= th
->thread_local_base
;
3408 windows_nat_target::get_ada_task_ptid (long lwp
, long thread
)
3410 return ptid_t (inferior_ptid
.pid (), 0, lwp
);
3413 /* Implementation of the to_thread_name method. */
3416 windows_nat_target::thread_name (struct thread_info
*thr
)
3418 return thread_rec (thr
->ptid
.tid (), 0)->name
;
3422 void _initialize_windows_nat ();
3424 _initialize_windows_nat ()
3426 x86_dr_low
.set_control
= cygwin_set_dr7
;
3427 x86_dr_low
.set_addr
= cygwin_set_dr
;
3428 x86_dr_low
.get_addr
= cygwin_get_dr
;
3429 x86_dr_low
.get_status
= cygwin_get_dr6
;
3430 x86_dr_low
.get_control
= cygwin_get_dr7
;
3432 /* x86_dr_low.debug_register_length field is set by
3433 calling x86_set_debug_register_length function
3434 in processor windows specific native file. */
3436 add_inf_child_target (&the_windows_nat_target
);
3439 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3442 add_com ("signal-event", class_run
, signal_event_command
, _("\
3443 Signal a crashed process with event ID, to allow its debugging.\n\
3444 This command is needed in support of setting up GDB as JIT debugger on \
3445 MS-Windows. The command should be invoked from the GDB command line using \
3446 the '-ex' command-line option. The ID of the event that blocks the \
3447 crashed process will be supplied by the Windows JIT debugging mechanism."));
3450 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3451 Set use of shell to start subprocess."), _("\
3452 Show use of shell to start subprocess."), NULL
,
3454 NULL
, /* FIXME: i18n: */
3455 &setlist
, &showlist
);
3457 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3458 &cygwin_exceptions
, _("\
3459 Break when an exception is detected in the Cygwin DLL itself."), _("\
3460 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3462 NULL
, /* FIXME: i18n: */
3463 &setlist
, &showlist
);
3466 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3467 Set creation of new console when creating child process."), _("\
3468 Show creation of new console when creating child process."), NULL
,
3470 NULL
, /* FIXME: i18n: */
3471 &setlist
, &showlist
);
3473 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3474 Set creation of new group when creating child process."), _("\
3475 Show creation of new group when creating child process."), NULL
,
3477 NULL
, /* FIXME: i18n: */
3478 &setlist
, &showlist
);
3480 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3481 Set whether to display execution in child process."), _("\
3482 Show whether to display execution in child process."), NULL
,
3484 NULL
, /* FIXME: i18n: */
3485 &setlist
, &showlist
);
3487 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3488 Set whether to display kernel events in child process."), _("\
3489 Show whether to display kernel events in child process."), NULL
,
3491 NULL
, /* FIXME: i18n: */
3492 &setlist
, &showlist
);
3494 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3495 Set whether to display memory accesses in child process."), _("\
3496 Show whether to display memory accesses in child process."), NULL
,
3498 NULL
, /* FIXME: i18n: */
3499 &setlist
, &showlist
);
3501 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3502 &debug_exceptions
, _("\
3503 Set whether to display kernel exceptions in child process."), _("\
3504 Show whether to display kernel exceptions in child process."), NULL
,
3506 NULL
, /* FIXME: i18n: */
3507 &setlist
, &showlist
);
3509 init_w32_command_list ();
3511 add_cmd ("selector", class_info
, display_selectors
,
3512 _("Display selectors infos."),
3516 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3518 /* Pass the address ADDR to the inferior in the I'th debug register.
3519 Here we just store the address in dr array, the registers will be
3520 actually set up when windows_continue is called. */
3522 cygwin_set_dr (int i
, CORE_ADDR addr
)
3525 internal_error (__FILE__
, __LINE__
,
3526 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3528 debug_registers_changed
= 1;
3529 debug_registers_used
= 1;
3532 /* Pass the value VAL to the inferior in the DR7 debug control
3533 register. Here we just store the address in D_REGS, the watchpoint
3534 will be actually set up in windows_wait. */
3536 cygwin_set_dr7 (unsigned long val
)
3538 dr
[7] = (CORE_ADDR
) val
;
3539 debug_registers_changed
= 1;
3540 debug_registers_used
= 1;
3543 /* Get the value of debug register I from the inferior. */
3546 cygwin_get_dr (int i
)
3551 /* Get the value of the DR6 debug status register from the inferior.
3552 Here we just return the value stored in dr[6]
3553 by the last call to thread_rec for current_event.dwThreadId id. */
3554 static unsigned long
3555 cygwin_get_dr6 (void)
3557 return (unsigned long) dr
[6];
3560 /* Get the value of the DR7 debug status register from the inferior.
3561 Here we just return the value stored in dr[7] by the last call to
3562 thread_rec for current_event.dwThreadId id. */
3564 static unsigned long
3565 cygwin_get_dr7 (void)
3567 return (unsigned long) dr
[7];
3570 /* Determine if the thread referenced by "ptid" is alive
3571 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3572 it means that the thread has died. Otherwise it is assumed to be alive. */
3575 windows_nat_target::thread_alive (ptid_t ptid
)
3579 gdb_assert (ptid
.tid () != 0);
3582 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) != WAIT_OBJECT_0
;
3585 void _initialize_check_for_gdb_ini ();
3587 _initialize_check_for_gdb_ini ()
3590 if (inhibit_gdbinit
)
3593 homedir
= getenv ("HOME");
3597 char *oldini
= (char *) alloca (strlen (homedir
) +
3598 sizeof ("gdb.ini") + 1);
3599 strcpy (oldini
, homedir
);
3600 p
= strchr (oldini
, '\0');
3601 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3603 strcpy (p
, "gdb.ini");
3604 if (access (oldini
, 0) == 0)
3606 int len
= strlen (oldini
);
3607 char *newini
= (char *) alloca (len
+ 2);
3609 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3610 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3611 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3616 /* Define dummy functions which always return error for the rare cases where
3617 these functions could not be found. */
3619 bad_DebugActiveProcessStop (DWORD w
)
3624 bad_DebugBreakProcess (HANDLE w
)
3629 bad_DebugSetProcessKillOnExit (BOOL w
)
3634 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3641 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3647 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3654 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3660 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3666 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3672 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3680 /* Load any functions which may not be available in ancient versions
3683 void _initialize_loadable ();
3685 _initialize_loadable ()
3689 #define GPA(m, func) \
3690 func = (func ## _ftype *) GetProcAddress (m, #func)
3692 hm
= LoadLibrary ("kernel32.dll");
3695 GPA (hm
, DebugActiveProcessStop
);
3696 GPA (hm
, DebugBreakProcess
);
3697 GPA (hm
, DebugSetProcessKillOnExit
);
3698 GPA (hm
, GetConsoleFontSize
);
3699 GPA (hm
, DebugActiveProcessStop
);
3700 GPA (hm
, GetCurrentConsoleFont
);
3702 GPA (hm
, Wow64SuspendThread
);
3703 GPA (hm
, Wow64GetThreadContext
);
3704 GPA (hm
, Wow64SetThreadContext
);
3705 GPA (hm
, Wow64GetThreadSelectorEntry
);
3709 /* Set variables to dummy versions of these processes if the function
3710 wasn't found in kernel32.dll. */
3711 if (!DebugBreakProcess
)
3712 DebugBreakProcess
= bad_DebugBreakProcess
;
3713 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3715 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3716 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3718 if (!GetConsoleFontSize
)
3719 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3720 if (!GetCurrentConsoleFont
)
3721 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3723 /* Load optional functions used for retrieving filename information
3724 associated with the currently debugged process or its dlls. */
3725 hm
= LoadLibrary ("psapi.dll");
3728 GPA (hm
, EnumProcessModules
);
3730 GPA (hm
, EnumProcessModulesEx
);
3732 GPA (hm
, GetModuleInformation
);
3733 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3734 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3737 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3739 /* Set variables to dummy versions of these processes if the function
3740 wasn't found in psapi.dll. */
3741 EnumProcessModules
= bad_EnumProcessModules
;
3742 GetModuleInformation
= bad_GetModuleInformation
;
3743 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3744 /* This will probably fail on Windows 9x/Me. Let the user know
3745 that we're missing some functionality. */
3747 cannot automatically find executable file or library to read symbols.\n\
3748 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3751 hm
= LoadLibrary ("advapi32.dll");
3754 GPA (hm
, OpenProcessToken
);
3755 GPA (hm
, LookupPrivilegeValueA
);
3756 GPA (hm
, AdjustTokenPrivileges
);
3757 /* Only need to set one of these since if OpenProcessToken fails nothing
3759 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3760 || !AdjustTokenPrivileges
)
3761 OpenProcessToken
= bad_OpenProcessToken
;