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>
47 #include "filenames.h"
51 #include "gdb_obstack.h"
52 #include "gdbthread.h"
58 #include "xml-support.h"
61 #include "i386-tdep.h"
62 #include "i387-tdep.h"
64 #include "windows-tdep.h"
65 #include "windows-nat.h"
67 #include "complaints.h"
68 #include "inf-child.h"
69 #include "gdbsupport/gdb_tilde_expand.h"
70 #include "gdbsupport/pathstuff.h"
71 #include "gdbsupport/gdb_wait.h"
73 #define STATUS_WX86_BREAKPOINT 0x4000001F
74 #define STATUS_WX86_SINGLE_STEP 0x4000001E
76 #define AdjustTokenPrivileges dyn_AdjustTokenPrivileges
77 #define DebugActiveProcessStop dyn_DebugActiveProcessStop
78 #define DebugBreakProcess dyn_DebugBreakProcess
79 #define DebugSetProcessKillOnExit dyn_DebugSetProcessKillOnExit
80 #define EnumProcessModules dyn_EnumProcessModules
81 #define EnumProcessModulesEx dyn_EnumProcessModulesEx
82 #define GetModuleInformation dyn_GetModuleInformation
83 #define LookupPrivilegeValueA dyn_LookupPrivilegeValueA
84 #define OpenProcessToken dyn_OpenProcessToken
85 #define GetConsoleFontSize dyn_GetConsoleFontSize
86 #define GetCurrentConsoleFont dyn_GetCurrentConsoleFont
87 #define Wow64SuspendThread dyn_Wow64SuspendThread
88 #define Wow64GetThreadContext dyn_Wow64GetThreadContext
89 #define Wow64SetThreadContext dyn_Wow64SetThreadContext
90 #define Wow64GetThreadSelectorEntry dyn_Wow64GetThreadSelectorEntry
92 typedef BOOL
WINAPI (AdjustTokenPrivileges_ftype
) (HANDLE
, BOOL
,
94 DWORD
, PTOKEN_PRIVILEGES
,
96 static AdjustTokenPrivileges_ftype
*AdjustTokenPrivileges
;
98 typedef BOOL
WINAPI (DebugActiveProcessStop_ftype
) (DWORD
);
99 static DebugActiveProcessStop_ftype
*DebugActiveProcessStop
;
101 typedef BOOL
WINAPI (DebugBreakProcess_ftype
) (HANDLE
);
102 static DebugBreakProcess_ftype
*DebugBreakProcess
;
104 typedef BOOL
WINAPI (DebugSetProcessKillOnExit_ftype
) (BOOL
);
105 static DebugSetProcessKillOnExit_ftype
*DebugSetProcessKillOnExit
;
107 typedef BOOL
WINAPI (EnumProcessModules_ftype
) (HANDLE
, HMODULE
*, DWORD
,
109 static EnumProcessModules_ftype
*EnumProcessModules
;
112 typedef BOOL
WINAPI (EnumProcessModulesEx_ftype
) (HANDLE
, HMODULE
*, DWORD
,
114 static EnumProcessModulesEx_ftype
*EnumProcessModulesEx
;
117 typedef BOOL
WINAPI (GetModuleInformation_ftype
) (HANDLE
, HMODULE
,
118 LPMODULEINFO
, DWORD
);
119 static GetModuleInformation_ftype
*GetModuleInformation
;
121 typedef BOOL
WINAPI (LookupPrivilegeValueA_ftype
) (LPCSTR
, LPCSTR
, PLUID
);
122 static LookupPrivilegeValueA_ftype
*LookupPrivilegeValueA
;
124 typedef BOOL
WINAPI (OpenProcessToken_ftype
) (HANDLE
, DWORD
, PHANDLE
);
125 static OpenProcessToken_ftype
*OpenProcessToken
;
127 typedef BOOL
WINAPI (GetCurrentConsoleFont_ftype
) (HANDLE
, BOOL
,
128 CONSOLE_FONT_INFO
*);
129 static GetCurrentConsoleFont_ftype
*GetCurrentConsoleFont
;
131 typedef COORD
WINAPI (GetConsoleFontSize_ftype
) (HANDLE
, DWORD
);
132 static GetConsoleFontSize_ftype
*GetConsoleFontSize
;
135 typedef DWORD
WINAPI (Wow64SuspendThread_ftype
) (HANDLE
);
136 static Wow64SuspendThread_ftype
*Wow64SuspendThread
;
138 typedef BOOL
WINAPI (Wow64GetThreadContext_ftype
) (HANDLE
, PWOW64_CONTEXT
);
139 static Wow64GetThreadContext_ftype
*Wow64GetThreadContext
;
141 typedef BOOL
WINAPI (Wow64SetThreadContext_ftype
) (HANDLE
,
142 const WOW64_CONTEXT
*);
143 static Wow64SetThreadContext_ftype
*Wow64SetThreadContext
;
145 typedef BOOL
WINAPI (Wow64GetThreadSelectorEntry_ftype
) (HANDLE
, DWORD
,
147 static Wow64GetThreadSelectorEntry_ftype
*Wow64GetThreadSelectorEntry
;
152 #undef GetModuleFileNameEx
155 # define __PMAX (MAX_PATH + 1)
156 typedef DWORD
WINAPI (GetModuleFileNameEx_ftype
) (HANDLE
, HMODULE
, LPSTR
, DWORD
);
157 static GetModuleFileNameEx_ftype
*GetModuleFileNameEx
;
158 # define STARTUPINFO STARTUPINFOA
159 # define CreateProcess CreateProcessA
160 # define GetModuleFileNameEx_name "GetModuleFileNameExA"
161 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
163 # define __PMAX PATH_MAX
164 /* The starting and ending address of the cygwin1.dll text segment. */
165 static CORE_ADDR cygwin_load_start
;
166 static CORE_ADDR cygwin_load_end
;
168 typedef wchar_t cygwin_buf_t
;
169 typedef DWORD
WINAPI (GetModuleFileNameEx_ftype
) (HANDLE
, HMODULE
,
171 static GetModuleFileNameEx_ftype
*GetModuleFileNameEx
;
172 # define STARTUPINFO STARTUPINFOW
173 # define CreateProcess CreateProcessW
174 # define GetModuleFileNameEx_name "GetModuleFileNameExW"
175 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExW
178 static int have_saved_context
; /* True if we've saved context from a
181 static CONTEXT saved_context
; /* Contains the saved context from a
185 /* If we're not using the old Cygwin header file set, define the
186 following which never should have been in the generic Win32 API
187 headers in the first place since they were our own invention... */
188 #ifndef _GNU_H_WINDOWS_H
191 FLAG_TRACE_BIT
= 0x100,
195 #ifndef CONTEXT_EXTENDED_REGISTERS
196 /* This macro is only defined on ia32. It only makes sense on this target,
197 so define it as zero if not already defined. */
198 #define CONTEXT_EXTENDED_REGISTERS 0
201 #define CONTEXT_DEBUGGER_DR CONTEXT_FULL | CONTEXT_FLOATING_POINT \
202 | CONTEXT_SEGMENTS | CONTEXT_DEBUG_REGISTERS \
203 | CONTEXT_EXTENDED_REGISTERS
205 static uintptr_t dr
[8];
206 static int debug_registers_changed
;
207 static int debug_registers_used
;
209 static int windows_initialization_done
;
210 #define DR6_CLEAR_VALUE 0xffff0ff0
212 /* The exception thrown by a program to tell the debugger the name of
213 a thread. The exception record contains an ID of a thread and a
214 name to give it. This exception has no documented name, but MSDN
215 dubs it "MS_VC_EXCEPTION" in one code example. */
216 #define MS_VC_EXCEPTION 0x406d1388
220 HANDLE_EXCEPTION_UNHANDLED
= 0,
221 HANDLE_EXCEPTION_HANDLED
,
222 HANDLE_EXCEPTION_IGNORED
223 } handle_exception_result
;
225 /* The string sent by cygwin when it processes a signal.
226 FIXME: This should be in a cygwin include file. */
227 #ifndef _CYGWIN_SIGNAL_STRING
228 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
231 #define CHECK(x) check (x, __FILE__,__LINE__)
232 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
233 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
234 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
235 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
237 static void cygwin_set_dr (int i
, CORE_ADDR addr
);
238 static void cygwin_set_dr7 (unsigned long val
);
239 static CORE_ADDR
cygwin_get_dr (int i
);
240 static unsigned long cygwin_get_dr6 (void);
241 static unsigned long cygwin_get_dr7 (void);
243 static enum gdb_signal last_sig
= GDB_SIGNAL_0
;
244 /* Set if a signal was received from the debugged process. */
246 /* Thread information structure used to track information that is
247 not available in gdb's thread structure. */
248 typedef struct windows_thread_info_struct
250 struct windows_thread_info_struct
*next
;
253 CORE_ADDR thread_local_base
;
261 WOW64_CONTEXT wow64_context
;
267 static windows_thread_info thread_head
;
269 /* The process and thread handles for the above context. */
271 static DEBUG_EVENT current_event
; /* The current debug event from
273 static HANDLE current_process_handle
; /* Currently executing process */
274 static windows_thread_info
*current_thread
; /* Info on currently selected thread */
275 static EXCEPTION_RECORD siginfo_er
; /* Contents of $_siginfo */
277 /* Counts of things. */
278 static int exception_count
= 0;
279 static int event_count
= 0;
280 static int saw_create
;
281 static int open_process_used
= 0;
283 static bool wow64_process
= false;
284 static bool ignore_first_breakpoint
= false;
288 static bool new_console
= false;
290 static bool cygwin_exceptions
= false;
292 static bool new_group
= true;
293 static bool debug_exec
= false; /* show execution */
294 static bool debug_events
= false; /* show events from kernel */
295 static bool debug_memory
= false; /* show target memory accesses */
296 static bool debug_exceptions
= false; /* show target exceptions */
297 static bool useshell
= false; /* use shell for subprocesses */
299 /* This vector maps GDB's idea of a register's number into an offset
300 in the windows exception context vector.
302 It also contains the bit mask needed to load the register in question.
304 The contents of this table can only be computed by the units
305 that provide CPU-specific support for Windows native debugging.
306 These units should set the table by calling
307 windows_set_context_register_offsets.
309 One day we could read a reg, we could inspect the context we
310 already have loaded, if it doesn't have the bit set that we need,
311 we read that set of registers in using GetThreadContext. If the
312 context already contains what we need, we just unpack it. Then to
313 write a register, first we have to ensure that the context contains
314 the other regs of the group, and then we copy the info in and set
317 static const int *mappings
;
319 /* The function to use in order to determine whether a register is
320 a segment register or not. */
321 static segment_register_p_ftype
*segment_register_p
;
323 /* See windows_nat_target::resume to understand why this is commented
326 /* This vector maps the target's idea of an exception (extracted
327 from the DEBUG_EVENT structure) to GDB's idea. */
329 struct xlate_exception
335 static const struct xlate_exception xlate
[] =
337 {EXCEPTION_ACCESS_VIOLATION
, GDB_SIGNAL_SEGV
},
338 {STATUS_STACK_OVERFLOW
, GDB_SIGNAL_SEGV
},
339 {EXCEPTION_BREAKPOINT
, GDB_SIGNAL_TRAP
},
340 {DBG_CONTROL_C
, GDB_SIGNAL_INT
},
341 {EXCEPTION_SINGLE_STEP
, GDB_SIGNAL_TRAP
},
342 {STATUS_FLOAT_DIVIDE_BY_ZERO
, GDB_SIGNAL_FPE
}
347 struct windows_nat_target final
: public x86_nat_target
<inf_child_target
>
349 void close () override
;
351 void attach (const char *, int) override
;
353 bool attach_no_wait () override
356 void detach (inferior
*, int) override
;
358 void resume (ptid_t
, int , enum gdb_signal
) override
;
360 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
362 void fetch_registers (struct regcache
*, int) override
;
363 void store_registers (struct regcache
*, int) override
;
365 enum target_xfer_status
xfer_partial (enum target_object object
,
368 const gdb_byte
*writebuf
,
369 ULONGEST offset
, ULONGEST len
,
370 ULONGEST
*xfered_len
) override
;
372 void files_info () override
;
374 void kill () override
;
376 void create_inferior (const char *, const std::string
&,
377 char **, int) override
;
379 void mourn_inferior () override
;
381 bool thread_alive (ptid_t ptid
) override
;
383 std::string
pid_to_str (ptid_t
) override
;
385 void interrupt () override
;
387 char *pid_to_exec_file (int pid
) override
;
389 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
391 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
393 const char *thread_name (struct thread_info
*) override
;
395 int get_windows_debug_event (int pid
, struct target_waitstatus
*ourstatus
);
398 static windows_nat_target the_windows_nat_target
;
400 /* Set the MAPPINGS static global to OFFSETS.
401 See the description of MAPPINGS for more details. */
404 windows_set_context_register_offsets (const int *offsets
)
409 /* Set the function that should be used by this module to determine
410 whether a given register is a segment register or not. */
413 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
415 segment_register_p
= fun
;
419 check (BOOL ok
, const char *file
, int line
)
422 printf_filtered ("error return %s:%d was %u\n", file
, line
,
423 (unsigned) GetLastError ());
426 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
427 then also retrieve the context for this thread. If GET_CONTEXT is
428 negative, then don't suspend the thread. */
429 static windows_thread_info
*
430 thread_rec (DWORD id
, int get_context
)
432 windows_thread_info
*th
;
434 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
437 if (!th
->suspended
&& get_context
)
439 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
441 if (SuspendThread (th
->h
) == (DWORD
) -1)
443 DWORD err
= GetLastError ();
445 /* We get Access Denied (5) when trying to suspend
446 threads that Windows started on behalf of the
447 debuggee, usually when those threads are just
449 We can get Invalid Handle (6) if the main thread
451 if (err
!= ERROR_INVALID_HANDLE
452 && err
!= ERROR_ACCESS_DENIED
)
453 warning (_("SuspendThread (tid=0x%x) failed."
455 (unsigned) id
, (unsigned) err
);
461 else if (get_context
< 0)
463 th
->reload_context
= 1;
471 /* Add a thread to the thread list.
473 PTID is the ptid of the thread to be added.
474 H is its Windows handle.
475 TLB is its thread local base.
476 MAIN_THREAD_P should be true if the thread to be added is
477 the main thread, false otherwise. */
479 static windows_thread_info
*
480 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
, bool main_thread_p
)
482 windows_thread_info
*th
;
485 gdb_assert (ptid
.tid () != 0);
489 if ((th
= thread_rec (id
, FALSE
)))
492 th
= XCNEW (windows_thread_info
);
495 th
->thread_local_base
= (CORE_ADDR
) (uintptr_t) tlb
;
497 /* For WOW64 processes, this is actually the pointer to the 64bit TIB,
498 and the 32bit TIB is exactly 2 pages after it. */
500 th
->thread_local_base
+= 0x2000;
502 th
->next
= thread_head
.next
;
503 thread_head
.next
= th
;
505 /* Add this new thread to the list of threads.
507 To be consistent with what's done on other platforms, we add
508 the main thread silently (in reality, this thread is really
509 more of a process to the user than a thread). */
511 add_thread_silent (&the_windows_nat_target
, ptid
);
513 add_thread (&the_windows_nat_target
, ptid
);
515 /* Set the debug registers for the new thread if they are used. */
516 if (debug_registers_used
)
521 /* Only change the value of the debug registers. */
522 th
->wow64_context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
523 CHECK (Wow64GetThreadContext (th
->h
, &th
->wow64_context
));
524 th
->wow64_context
.Dr0
= dr
[0];
525 th
->wow64_context
.Dr1
= dr
[1];
526 th
->wow64_context
.Dr2
= dr
[2];
527 th
->wow64_context
.Dr3
= dr
[3];
528 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
529 th
->wow64_context
.Dr7
= dr
[7];
530 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
531 th
->wow64_context
.ContextFlags
= 0;
536 /* Only change the value of the debug registers. */
537 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
538 CHECK (GetThreadContext (th
->h
, &th
->context
));
539 th
->context
.Dr0
= dr
[0];
540 th
->context
.Dr1
= dr
[1];
541 th
->context
.Dr2
= dr
[2];
542 th
->context
.Dr3
= dr
[3];
543 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
544 th
->context
.Dr7
= dr
[7];
545 CHECK (SetThreadContext (th
->h
, &th
->context
));
546 th
->context
.ContextFlags
= 0;
552 /* Clear out any old thread list and reinitialize it to a
555 windows_init_thread_list (void)
557 windows_thread_info
*th
= &thread_head
;
559 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
561 while (th
->next
!= NULL
)
563 windows_thread_info
*here
= th
->next
;
564 th
->next
= here
->next
;
567 thread_head
.next
= NULL
;
570 /* Delete a thread from the list of threads.
572 PTID is the ptid of the thread to be deleted.
573 EXIT_CODE is the thread's exit code.
574 MAIN_THREAD_P should be true if the thread to be deleted is
575 the main thread, false otherwise. */
578 windows_delete_thread (ptid_t ptid
, DWORD exit_code
, bool main_thread_p
)
580 windows_thread_info
*th
;
583 gdb_assert (ptid
.tid () != 0);
587 /* Emit a notification about the thread being deleted.
589 Note that no notification was printed when the main thread
590 was created, and thus, unless in verbose mode, we should be
591 symmetrical, and avoid that notification for the main thread
595 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
).c_str ());
596 else if (print_thread_events
&& !main_thread_p
)
597 printf_unfiltered (_("[%s exited with code %u]\n"),
598 target_pid_to_str (ptid
).c_str (),
599 (unsigned) exit_code
);
601 delete_thread (find_thread_ptid (&the_windows_nat_target
, ptid
));
603 for (th
= &thread_head
;
604 th
->next
!= NULL
&& th
->next
->id
!= id
;
608 if (th
->next
!= NULL
)
610 windows_thread_info
*here
= th
->next
;
611 th
->next
= here
->next
;
617 /* Fetches register number R from the given windows_thread_info,
618 and supplies its value to the given regcache.
620 This function assumes that R is non-negative. A failed assertion
621 is raised if that is not true.
623 This function assumes that TH->RELOAD_CONTEXT is not set, meaning
624 that the windows_thread_info has an up-to-date context. A failed
625 assertion is raised if that assumption is violated. */
628 windows_fetch_one_register (struct regcache
*regcache
,
629 windows_thread_info
*th
, int r
)
632 gdb_assert (!th
->reload_context
);
634 char *context_ptr
= (char *) &th
->context
;
637 context_ptr
= (char *) &th
->wow64_context
;
640 char *context_offset
= context_ptr
+ mappings
[r
];
641 struct gdbarch
*gdbarch
= regcache
->arch ();
642 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
644 if (r
== I387_FISEG_REGNUM (tdep
))
646 long l
= *((long *) context_offset
) & 0xffff;
647 regcache
->raw_supply (r
, (char *) &l
);
649 else if (r
== I387_FOP_REGNUM (tdep
))
651 long l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
652 regcache
->raw_supply (r
, (char *) &l
);
654 else if (segment_register_p (r
))
656 /* GDB treats segment registers as 32bit registers, but they are
657 in fact only 16 bits long. Make sure we do not read extra
658 bits from our source buffer. */
659 long l
= *((long *) context_offset
) & 0xffff;
660 regcache
->raw_supply (r
, (char *) &l
);
663 regcache
->raw_supply (r
, context_offset
);
667 windows_nat_target::fetch_registers (struct regcache
*regcache
, int r
)
669 DWORD tid
= regcache
->ptid ().tid ();
670 windows_thread_info
*th
= thread_rec (tid
, TRUE
);
672 /* Check if TH exists. Windows sometimes uses a non-existent
673 thread id in its events. */
677 if (th
->reload_context
)
680 if (have_saved_context
)
682 /* Lie about where the program actually is stopped since
683 cygwin has informed us that we should consider the signal
684 to have occurred at another location which is stored in
686 memcpy (&th
->context
, &saved_context
,
687 __COPY_CONTEXT_SIZE
);
688 have_saved_context
= 0;
695 th
->wow64_context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
696 CHECK (Wow64GetThreadContext (th
->h
, &th
->wow64_context
));
697 /* Copy dr values from that thread.
698 But only if there were not modified since last stop.
700 if (!debug_registers_changed
)
702 dr
[0] = th
->wow64_context
.Dr0
;
703 dr
[1] = th
->wow64_context
.Dr1
;
704 dr
[2] = th
->wow64_context
.Dr2
;
705 dr
[3] = th
->wow64_context
.Dr3
;
706 dr
[6] = th
->wow64_context
.Dr6
;
707 dr
[7] = th
->wow64_context
.Dr7
;
713 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
714 CHECK (GetThreadContext (th
->h
, &th
->context
));
715 /* Copy dr values from that thread.
716 But only if there were not modified since last stop.
718 if (!debug_registers_changed
)
720 dr
[0] = th
->context
.Dr0
;
721 dr
[1] = th
->context
.Dr1
;
722 dr
[2] = th
->context
.Dr2
;
723 dr
[3] = th
->context
.Dr3
;
724 dr
[6] = th
->context
.Dr6
;
725 dr
[7] = th
->context
.Dr7
;
728 th
->reload_context
= 0;
732 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch()); r
++)
733 windows_fetch_one_register (regcache
, th
, r
);
735 windows_fetch_one_register (regcache
, th
, r
);
738 /* Collect the register number R from the given regcache, and store
739 its value into the corresponding area of the given thread's context.
741 This function assumes that R is non-negative. A failed assertion
742 assertion is raised if that is not true. */
745 windows_store_one_register (const struct regcache
*regcache
,
746 windows_thread_info
*th
, int r
)
750 char *context_ptr
= (char *) &th
->context
;
753 context_ptr
= (char *) &th
->wow64_context
;
756 regcache
->raw_collect (r
, context_ptr
+ mappings
[r
]);
759 /* Store a new register value into the context of the thread tied to
763 windows_nat_target::store_registers (struct regcache
*regcache
, int r
)
765 DWORD tid
= regcache
->ptid ().tid ();
766 windows_thread_info
*th
= thread_rec (tid
, TRUE
);
768 /* Check if TH exists. Windows sometimes uses a non-existent
769 thread id in its events. */
774 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch ()); r
++)
775 windows_store_one_register (regcache
, th
, r
);
777 windows_store_one_register (regcache
, th
, r
);
780 /* Maintain a linked list of "so" information. */
781 struct lm_info_windows
: public lm_info_base
783 LPVOID load_addr
= 0;
784 CORE_ADDR text_offset
= 0;
787 static struct so_list solib_start
, *solib_end
;
789 static struct so_list
*
790 windows_make_so (const char *name
, LPVOID load_addr
)
797 WIN32_FIND_DATA w32_fd
;
798 HANDLE h
= FindFirstFile(name
, &w32_fd
);
800 if (h
== INVALID_HANDLE_VALUE
)
806 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
808 p
= strrchr (buf
, '\\');
811 SetCurrentDirectory (buf
);
812 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
813 SetCurrentDirectory (cwd
);
816 if (strcasecmp (buf
, "ntdll.dll") == 0)
818 GetSystemDirectory (buf
, sizeof (buf
));
819 strcat (buf
, "\\ntdll.dll");
822 cygwin_buf_t buf
[__PMAX
];
825 if (access (name
, F_OK
) != 0)
827 if (strcasecmp (name
, "ntdll.dll") == 0)
830 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
831 wcscat (buf
, L
"\\ntdll.dll");
835 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
836 strcat (buf
, "\\ntdll.dll");
841 so
= XCNEW (struct so_list
);
842 lm_info_windows
*li
= new lm_info_windows
;
844 li
->load_addr
= load_addr
;
845 strcpy (so
->so_original_name
, name
);
847 strcpy (so
->so_name
, buf
);
850 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
851 SO_NAME_MAX_PATH_SIZE
);
854 char *rname
= realpath (name
, NULL
);
855 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
857 strcpy (so
->so_name
, rname
);
861 error (_("dll path too long"));
863 /* Record cygwin1.dll .text start/end. */
864 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
865 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
867 asection
*text
= NULL
;
869 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386", -1));
874 if (bfd_check_format (abfd
.get (), bfd_object
))
875 text
= bfd_get_section_by_name (abfd
.get (), ".text");
880 /* The symbols in a dll are offset by 0x1000, which is the
881 offset from 0 of the first byte in an image - because of the
882 file header and the section alignment. */
883 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
885 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (text
);
893 get_image_name (HANDLE h
, void *address
, int unicode
)
896 static char buf
[__PMAX
];
898 static char buf
[(2 * __PMAX
) + 1];
900 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
906 /* Attempt to read the name of the dll that was detected.
907 This is documented to work only when actively debugging
908 a program. It will not work for attached processes. */
912 /* See if we could read the address of a string, and that the
913 address isn't null. */
914 if (!ReadProcessMemory (h
, address
, &address_ptr
,
915 sizeof (address_ptr
), &done
)
916 || done
!= sizeof (address_ptr
) || !address_ptr
)
919 /* Find the length of the string. */
920 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
921 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
925 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
928 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
929 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
932 wcstombs (buf
, unicode_address
, __PMAX
);
934 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
942 /* Handle a DLL load event, and return 1.
944 This function assumes that this event did not occur during inferior
945 initialization, where their event info may be incomplete (see
946 do_initial_windows_stuff and windows_add_all_dlls for more info
947 on how we handle DLL loading during that phase). */
952 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
955 /* Try getting the DLL name via the lpImageName field of the event.
956 Note that Microsoft documents this fields as strictly optional,
957 in the sense that it might be NULL. And the first DLL event in
958 particular is explicitly documented as "likely not pass[ed]"
959 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
960 dll_name
= get_image_name (current_process_handle
,
961 event
->lpImageName
, event
->fUnicode
);
965 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
966 solib_end
= solib_end
->next
;
968 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
970 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
971 host_address_to_string (li
->load_addr
)));
975 windows_free_so (struct so_list
*so
)
977 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
983 /* Handle a DLL unload event.
984 Return 1 if successful, or zero otherwise.
986 This function assumes that this event did not occur during inferior
987 initialization, where their event info may be incomplete (see
988 do_initial_windows_stuff and windows_add_all_dlls for more info
989 on how we handle DLL loading during that phase). */
994 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
997 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
999 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
1001 if (li_next
->load_addr
== lpBaseOfDll
)
1003 struct so_list
*sodel
= so
->next
;
1005 so
->next
= sodel
->next
;
1008 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
1010 windows_free_so (sodel
);
1015 /* We did not find any DLL that was previously loaded at this address,
1016 so register a complaint. We do not report an error, because we have
1017 observed that this may be happening under some circumstances. For
1018 instance, running 32bit applications on x64 Windows causes us to receive
1019 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
1020 events are apparently caused by the WOW layer, the interface between
1021 32bit and 64bit worlds). */
1022 complaint (_("dll starting at %s not found."),
1023 host_address_to_string (lpBaseOfDll
));
1026 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
1030 catch_errors (void (*func
) ())
1036 catch (const gdb_exception
&ex
)
1038 exception_print (gdb_stderr
, ex
);
1042 /* Clear list of loaded DLLs. */
1044 windows_clear_solib (void)
1048 for (so
= solib_start
.next
; so
; so
= solib_start
.next
)
1050 solib_start
.next
= so
->next
;
1051 windows_free_so (so
);
1054 solib_end
= &solib_start
;
1058 signal_event_command (const char *args
, int from_tty
)
1060 uintptr_t event_id
= 0;
1061 char *endargs
= NULL
;
1064 error (_("signal-event requires an argument (integer event id)"));
1066 event_id
= strtoumax (args
, &endargs
, 10);
1068 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
1069 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
1070 error (_("Failed to convert `%s' to event id"), args
);
1072 SetEvent ((HANDLE
) event_id
);
1073 CloseHandle ((HANDLE
) event_id
);
1076 /* Handle DEBUG_STRING output from child process.
1077 Cygwin prepends its messages with a "cygwin:". Interpret this as
1078 a Cygwin signal. Otherwise just print the string as a warning. */
1080 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
1082 gdb::unique_xmalloc_ptr
<char> s
;
1085 if (!target_read_string
1086 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
1088 || !s
|| !*(s
.get ()))
1089 /* nothing to do */;
1090 else if (!startswith (s
.get (), _CYGWIN_SIGNAL_STRING
))
1093 if (!startswith (s
.get (), "cYg"))
1096 char *p
= strchr (s
.get (), '\0');
1098 if (p
> s
.get () && *--p
== '\n')
1100 warning (("%s"), s
.get ());
1106 /* Got a cygwin signal marker. A cygwin signal is followed by
1107 the signal number itself and then optionally followed by the
1108 thread id and address to saved context within the DLL. If
1109 these are supplied, then the given thread is assumed to have
1110 issued the signal and the context from the thread is assumed
1111 to be stored at the given address in the inferior. Tell gdb
1112 to treat this like a real signal. */
1114 int sig
= strtol (s
.get () + sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
1115 gdb_signal gotasig
= gdb_signal_from_host (sig
);
1117 ourstatus
->value
.sig
= gotasig
;
1123 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1124 retval
= strtoul (p
, &p
, 0);
1126 retval
= current_event
.dwThreadId
;
1127 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
1128 && ReadProcessMemory (current_process_handle
, x
,
1130 __COPY_CONTEXT_SIZE
, &n
)
1131 && n
== __COPY_CONTEXT_SIZE
)
1132 have_saved_context
= 1;
1141 display_selector (HANDLE thread
, DWORD sel
)
1147 ret
= Wow64GetThreadSelectorEntry (thread
, sel
, &info
);
1150 ret
= GetThreadSelectorEntry (thread
, sel
, &info
);
1154 printf_filtered ("0x%03x: ", (unsigned) sel
);
1155 if (!info
.HighWord
.Bits
.Pres
)
1157 puts_filtered ("Segment not present\n");
1160 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1161 (info
.HighWord
.Bits
.BaseMid
<< 16)
1163 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1164 if (info
.HighWord
.Bits
.Granularity
)
1165 limit
= (limit
<< 12) | 0xfff;
1166 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1167 if (info
.HighWord
.Bits
.Default_Big
)
1168 puts_filtered(" 32-bit ");
1170 puts_filtered(" 16-bit ");
1171 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1174 puts_filtered ("Data (Read-Only, Exp-up");
1177 puts_filtered ("Data (Read/Write, Exp-up");
1180 puts_filtered ("Unused segment (");
1183 puts_filtered ("Data (Read/Write, Exp-down");
1186 puts_filtered ("Code (Exec-Only, N.Conf");
1189 puts_filtered ("Code (Exec/Read, N.Conf");
1192 puts_filtered ("Code (Exec-Only, Conf");
1195 puts_filtered ("Code (Exec/Read, Conf");
1198 printf_filtered ("Unknown type 0x%lx",
1199 (unsigned long) info
.HighWord
.Bits
.Type
);
1201 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1202 puts_filtered(", N.Acc");
1203 puts_filtered (")\n");
1204 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1205 puts_filtered("System selector ");
1206 printf_filtered ("Priviledge level = %ld. ",
1207 (unsigned long) info
.HighWord
.Bits
.Dpl
);
1208 if (info
.HighWord
.Bits
.Granularity
)
1209 puts_filtered ("Page granular.\n");
1211 puts_filtered ("Byte granular.\n");
1216 DWORD err
= GetLastError ();
1217 if (err
== ERROR_NOT_SUPPORTED
)
1218 printf_filtered ("Function not supported\n");
1220 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1226 display_selectors (const char * args
, int from_tty
)
1228 if (!current_thread
)
1230 puts_filtered ("Impossible to display selectors now.\n");
1238 puts_filtered ("Selector $cs\n");
1239 display_selector (current_thread
->h
,
1240 current_thread
->wow64_context
.SegCs
);
1241 puts_filtered ("Selector $ds\n");
1242 display_selector (current_thread
->h
,
1243 current_thread
->wow64_context
.SegDs
);
1244 puts_filtered ("Selector $es\n");
1245 display_selector (current_thread
->h
,
1246 current_thread
->wow64_context
.SegEs
);
1247 puts_filtered ("Selector $ss\n");
1248 display_selector (current_thread
->h
,
1249 current_thread
->wow64_context
.SegSs
);
1250 puts_filtered ("Selector $fs\n");
1251 display_selector (current_thread
->h
,
1252 current_thread
->wow64_context
.SegFs
);
1253 puts_filtered ("Selector $gs\n");
1254 display_selector (current_thread
->h
,
1255 current_thread
->wow64_context
.SegGs
);
1260 puts_filtered ("Selector $cs\n");
1261 display_selector (current_thread
->h
,
1262 current_thread
->context
.SegCs
);
1263 puts_filtered ("Selector $ds\n");
1264 display_selector (current_thread
->h
,
1265 current_thread
->context
.SegDs
);
1266 puts_filtered ("Selector $es\n");
1267 display_selector (current_thread
->h
,
1268 current_thread
->context
.SegEs
);
1269 puts_filtered ("Selector $ss\n");
1270 display_selector (current_thread
->h
,
1271 current_thread
->context
.SegSs
);
1272 puts_filtered ("Selector $fs\n");
1273 display_selector (current_thread
->h
,
1274 current_thread
->context
.SegFs
);
1275 puts_filtered ("Selector $gs\n");
1276 display_selector (current_thread
->h
,
1277 current_thread
->context
.SegGs
);
1283 sel
= parse_and_eval_long (args
);
1284 printf_filtered ("Selector \"%s\"\n",args
);
1285 display_selector (current_thread
->h
, sel
);
1289 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1290 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1291 host_address_to_string (\
1292 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1294 static handle_exception_result
1295 handle_exception (struct target_waitstatus
*ourstatus
)
1297 EXCEPTION_RECORD
*rec
= ¤t_event
.u
.Exception
.ExceptionRecord
;
1298 DWORD code
= rec
->ExceptionCode
;
1299 handle_exception_result result
= HANDLE_EXCEPTION_HANDLED
;
1301 memcpy (&siginfo_er
, rec
, sizeof siginfo_er
);
1303 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1305 /* Record the context of the current thread. */
1306 thread_rec (current_event
.dwThreadId
, -1);
1310 case EXCEPTION_ACCESS_VIOLATION
:
1311 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1312 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1315 /* See if the access violation happened within the cygwin DLL
1316 itself. Cygwin uses a kind of exception handling to deal
1317 with passed-in invalid addresses. gdb should not treat
1318 these as real SEGVs since they will be silently handled by
1319 cygwin. A real SEGV will (theoretically) be caught by
1320 cygwin later in the process and will be sent as a
1321 cygwin-specific-signal. So, ignore SEGVs if they show up
1322 within the text segment of the DLL itself. */
1324 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1326 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1327 && addr
< cygwin_load_end
))
1328 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1329 && startswith (fn
, "KERNEL32!IsBad")))
1330 return HANDLE_EXCEPTION_UNHANDLED
;
1334 case STATUS_STACK_OVERFLOW
:
1335 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1336 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1338 case STATUS_FLOAT_DENORMAL_OPERAND
:
1339 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1340 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1342 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1343 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1344 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1346 case STATUS_FLOAT_INEXACT_RESULT
:
1347 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1348 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1350 case STATUS_FLOAT_INVALID_OPERATION
:
1351 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1352 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1354 case STATUS_FLOAT_OVERFLOW
:
1355 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1356 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1358 case STATUS_FLOAT_STACK_CHECK
:
1359 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1360 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1362 case STATUS_FLOAT_UNDERFLOW
:
1363 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1364 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1366 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1367 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1368 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1370 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1371 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1372 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1374 case STATUS_INTEGER_OVERFLOW
:
1375 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1376 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1378 case EXCEPTION_BREAKPOINT
:
1380 if (ignore_first_breakpoint
)
1382 /* For WOW64 processes, there are always 2 breakpoint exceptions
1383 on startup, first a BREAKPOINT for the 64bit ntdll.dll,
1384 then a WX86_BREAKPOINT for the 32bit ntdll.dll.
1385 Here we only care about the WX86_BREAKPOINT's. */
1386 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1387 ignore_first_breakpoint
= false;
1391 case STATUS_WX86_BREAKPOINT
:
1392 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1393 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1396 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1397 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1399 case DBG_CONTROL_BREAK
:
1400 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1401 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1403 case EXCEPTION_SINGLE_STEP
:
1404 case STATUS_WX86_SINGLE_STEP
:
1405 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1406 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1408 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1409 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1410 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1412 case EXCEPTION_PRIV_INSTRUCTION
:
1413 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1414 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1416 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1417 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1418 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1420 case MS_VC_EXCEPTION
:
1421 if (rec
->NumberParameters
>= 3
1422 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1424 DWORD named_thread_id
;
1425 windows_thread_info
*named_thread
;
1426 CORE_ADDR thread_name_target
;
1428 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1430 thread_name_target
= rec
->ExceptionInformation
[1];
1431 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1433 if (named_thread_id
== (DWORD
) -1)
1434 named_thread_id
= current_event
.dwThreadId
;
1436 named_thread
= thread_rec (named_thread_id
, 0);
1437 if (named_thread
!= NULL
)
1439 int thread_name_len
;
1440 gdb::unique_xmalloc_ptr
<char> thread_name
;
1442 thread_name_len
= target_read_string (thread_name_target
,
1443 &thread_name
, 1025, NULL
);
1444 if (thread_name_len
> 0)
1446 thread_name
.get ()[thread_name_len
- 1] = '\0';
1447 xfree (named_thread
->name
);
1448 named_thread
->name
= thread_name
.release ();
1451 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1452 result
= HANDLE_EXCEPTION_IGNORED
;
1455 /* treat improperly formed exception as unknown */
1458 /* Treat unhandled first chance exceptions specially. */
1459 if (current_event
.u
.Exception
.dwFirstChance
)
1460 return HANDLE_EXCEPTION_UNHANDLED
;
1461 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1462 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1463 host_address_to_string (
1464 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1465 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1469 last_sig
= ourstatus
->value
.sig
;
1473 /* Resume thread specified by ID, or all artificially suspended
1474 threads, if we are continuing execution. KILLED non-zero means we
1475 have killed the inferior, so we should ignore weird errors due to
1476 threads shutting down. */
1478 windows_continue (DWORD continue_status
, int id
, int killed
)
1480 windows_thread_info
*th
;
1483 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1484 (unsigned) current_event
.dwProcessId
,
1485 (unsigned) current_event
.dwThreadId
,
1486 continue_status
== DBG_CONTINUE
?
1487 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1489 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1490 if ((id
== -1 || id
== (int) th
->id
)
1496 if (debug_registers_changed
)
1498 th
->wow64_context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1499 th
->wow64_context
.Dr0
= dr
[0];
1500 th
->wow64_context
.Dr1
= dr
[1];
1501 th
->wow64_context
.Dr2
= dr
[2];
1502 th
->wow64_context
.Dr3
= dr
[3];
1503 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1504 th
->wow64_context
.Dr7
= dr
[7];
1506 if (th
->wow64_context
.ContextFlags
)
1510 if (GetExitCodeThread (th
->h
, &ec
)
1511 && ec
== STILL_ACTIVE
)
1513 BOOL status
= Wow64SetThreadContext (th
->h
,
1514 &th
->wow64_context
);
1519 th
->wow64_context
.ContextFlags
= 0;
1525 if (debug_registers_changed
)
1527 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1528 th
->context
.Dr0
= dr
[0];
1529 th
->context
.Dr1
= dr
[1];
1530 th
->context
.Dr2
= dr
[2];
1531 th
->context
.Dr3
= dr
[3];
1532 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1533 th
->context
.Dr7
= dr
[7];
1535 if (th
->context
.ContextFlags
)
1539 if (GetExitCodeThread (th
->h
, &ec
)
1540 && ec
== STILL_ACTIVE
)
1542 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1547 th
->context
.ContextFlags
= 0;
1550 if (th
->suspended
> 0)
1551 (void) ResumeThread (th
->h
);
1555 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1556 current_event
.dwThreadId
,
1560 error (_("Failed to resume program execution"
1561 " (ContinueDebugEvent failed, error %u)"),
1562 (unsigned int) GetLastError ());
1564 debug_registers_changed
= 0;
1568 /* Called in pathological case where Windows fails to send a
1569 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1571 fake_create_process (void)
1573 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1574 current_event
.dwProcessId
);
1575 if (current_process_handle
!= NULL
)
1576 open_process_used
= 1;
1579 error (_("OpenProcess call failed, GetLastError = %u"),
1580 (unsigned) GetLastError ());
1581 /* We can not debug anything in that case. */
1584 = windows_add_thread (ptid_t (current_event
.dwProcessId
, 0,
1585 current_event
.dwThreadId
),
1586 current_event
.u
.CreateThread
.hThread
,
1587 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1588 true /* main_thread_p */);
1589 return current_event
.dwThreadId
;
1593 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1595 windows_thread_info
*th
;
1596 DWORD continue_status
= DBG_CONTINUE
;
1598 /* A specific PTID means `step only this thread id'. */
1599 int resume_all
= ptid
== minus_one_ptid
;
1601 /* If we're continuing all threads, it's the current inferior that
1602 should be handled specially. */
1604 ptid
= inferior_ptid
;
1606 if (sig
!= GDB_SIGNAL_0
)
1608 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1610 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1612 else if (sig
== last_sig
)
1613 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1616 /* This code does not seem to work, because
1617 the kernel does probably not consider changes in the ExceptionRecord
1618 structure when passing the exception to the inferior.
1619 Note that this seems possible in the exception handler itself. */
1621 for (const xlate_exception
&x
: xlate
)
1624 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1626 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1629 if (continue_status
== DBG_CONTINUE
)
1631 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1635 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1639 last_sig
= GDB_SIGNAL_0
;
1641 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=0x%x, step=%d, sig=%d);\n",
1642 ptid
.pid (), (unsigned) ptid
.tid (), step
, sig
));
1644 /* Get context for currently selected thread. */
1645 th
= thread_rec (inferior_ptid
.tid (), FALSE
);
1653 /* Single step by setting t bit. */
1654 struct regcache
*regcache
= get_current_regcache ();
1655 struct gdbarch
*gdbarch
= regcache
->arch ();
1656 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1657 th
->wow64_context
.EFlags
|= FLAG_TRACE_BIT
;
1660 if (th
->wow64_context
.ContextFlags
)
1662 if (debug_registers_changed
)
1664 th
->wow64_context
.Dr0
= dr
[0];
1665 th
->wow64_context
.Dr1
= dr
[1];
1666 th
->wow64_context
.Dr2
= dr
[2];
1667 th
->wow64_context
.Dr3
= dr
[3];
1668 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1669 th
->wow64_context
.Dr7
= dr
[7];
1671 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
1672 th
->wow64_context
.ContextFlags
= 0;
1680 /* Single step by setting t bit. */
1681 struct regcache
*regcache
= get_current_regcache ();
1682 struct gdbarch
*gdbarch
= regcache
->arch ();
1683 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1684 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1687 if (th
->context
.ContextFlags
)
1689 if (debug_registers_changed
)
1691 th
->context
.Dr0
= dr
[0];
1692 th
->context
.Dr1
= dr
[1];
1693 th
->context
.Dr2
= dr
[2];
1694 th
->context
.Dr3
= dr
[3];
1695 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1696 th
->context
.Dr7
= dr
[7];
1698 CHECK (SetThreadContext (th
->h
, &th
->context
));
1699 th
->context
.ContextFlags
= 0;
1704 /* Allow continuing with the same signal that interrupted us.
1705 Otherwise complain. */
1708 windows_continue (continue_status
, -1, 0);
1710 windows_continue (continue_status
, ptid
.tid (), 0);
1713 /* Ctrl-C handler used when the inferior is not run in the same console. The
1714 handler is in charge of interrupting the inferior using DebugBreakProcess.
1715 Note that this function is not available prior to Windows XP. In this case
1716 we emit a warning. */
1718 ctrl_c_handler (DWORD event_type
)
1720 const int attach_flag
= current_inferior ()->attach_flag
;
1722 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1723 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1726 /* If the inferior and the debugger share the same console, do nothing as
1727 the inferior has also received the Ctrl-C event. */
1728 if (!new_console
&& !attach_flag
)
1731 if (!DebugBreakProcess (current_process_handle
))
1732 warning (_("Could not interrupt program. "
1733 "Press Ctrl-c in the program console."));
1735 /* Return true to tell that Ctrl-C has been handled. */
1739 /* Get the next event from the child. Returns a non-zero thread id if the event
1740 requires handling by WFI (or whatever). */
1743 windows_nat_target::get_windows_debug_event (int pid
,
1744 struct target_waitstatus
*ourstatus
)
1747 DWORD continue_status
, event_code
;
1748 windows_thread_info
*th
;
1749 static windows_thread_info dummy_thread_info
;
1750 DWORD thread_id
= 0;
1752 last_sig
= GDB_SIGNAL_0
;
1754 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1758 continue_status
= DBG_CONTINUE
;
1760 event_code
= current_event
.dwDebugEventCode
;
1761 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1763 have_saved_context
= 0;
1767 case CREATE_THREAD_DEBUG_EVENT
:
1768 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1769 (unsigned) current_event
.dwProcessId
,
1770 (unsigned) current_event
.dwThreadId
,
1771 "CREATE_THREAD_DEBUG_EVENT"));
1772 if (saw_create
!= 1)
1774 inferior
*inf
= find_inferior_pid (this, current_event
.dwProcessId
);
1775 if (!saw_create
&& inf
->attach_flag
)
1777 /* Kludge around a Windows bug where first event is a create
1778 thread event. Caused when attached process does not have
1780 thread_id
= fake_create_process ();
1786 /* Record the existence of this thread. */
1787 thread_id
= current_event
.dwThreadId
;
1788 th
= windows_add_thread
1789 (ptid_t (current_event
.dwProcessId
, 0, current_event
.dwThreadId
),
1790 current_event
.u
.CreateThread
.hThread
,
1791 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1792 false /* main_thread_p */);
1796 case EXIT_THREAD_DEBUG_EVENT
:
1797 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1798 (unsigned) current_event
.dwProcessId
,
1799 (unsigned) current_event
.dwThreadId
,
1800 "EXIT_THREAD_DEBUG_EVENT"));
1801 windows_delete_thread (ptid_t (current_event
.dwProcessId
, 0,
1802 current_event
.dwThreadId
),
1803 current_event
.u
.ExitThread
.dwExitCode
,
1804 false /* main_thread_p */);
1805 th
= &dummy_thread_info
;
1808 case CREATE_PROCESS_DEBUG_EVENT
:
1809 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1810 (unsigned) current_event
.dwProcessId
,
1811 (unsigned) current_event
.dwThreadId
,
1812 "CREATE_PROCESS_DEBUG_EVENT"));
1813 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1814 if (++saw_create
!= 1)
1817 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1818 /* Add the main thread. */
1819 th
= windows_add_thread
1820 (ptid_t (current_event
.dwProcessId
, 0,
1821 current_event
.dwThreadId
),
1822 current_event
.u
.CreateProcessInfo
.hThread
,
1823 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
,
1824 true /* main_thread_p */);
1825 thread_id
= current_event
.dwThreadId
;
1828 case EXIT_PROCESS_DEBUG_EVENT
:
1829 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1830 (unsigned) current_event
.dwProcessId
,
1831 (unsigned) current_event
.dwThreadId
,
1832 "EXIT_PROCESS_DEBUG_EVENT"));
1833 if (!windows_initialization_done
)
1835 target_terminal::ours ();
1836 target_mourn_inferior (inferior_ptid
);
1837 error (_("During startup program exited with code 0x%x."),
1838 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1840 else if (saw_create
== 1)
1842 windows_delete_thread (ptid_t (current_event
.dwProcessId
, 0,
1843 current_event
.dwThreadId
),
1844 0, true /* main_thread_p */);
1845 DWORD exit_status
= current_event
.u
.ExitProcess
.dwExitCode
;
1846 /* If the exit status looks like a fatal exception, but we
1847 don't recognize the exception's code, make the original
1848 exit status value available, to avoid losing
1851 = WIFSIGNALED (exit_status
) ? WTERMSIG (exit_status
) : -1;
1852 if (exit_signal
== -1)
1854 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1855 ourstatus
->value
.integer
= exit_status
;
1859 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1860 ourstatus
->value
.sig
= gdb_signal_from_host (exit_signal
);
1862 thread_id
= current_event
.dwThreadId
;
1866 case LOAD_DLL_DEBUG_EVENT
:
1867 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1868 (unsigned) current_event
.dwProcessId
,
1869 (unsigned) current_event
.dwThreadId
,
1870 "LOAD_DLL_DEBUG_EVENT"));
1871 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1872 if (saw_create
!= 1 || ! windows_initialization_done
)
1874 catch_errors (handle_load_dll
);
1875 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1876 ourstatus
->value
.integer
= 0;
1877 thread_id
= current_event
.dwThreadId
;
1880 case UNLOAD_DLL_DEBUG_EVENT
:
1881 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1882 (unsigned) current_event
.dwProcessId
,
1883 (unsigned) current_event
.dwThreadId
,
1884 "UNLOAD_DLL_DEBUG_EVENT"));
1885 if (saw_create
!= 1 || ! windows_initialization_done
)
1887 catch_errors (handle_unload_dll
);
1888 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1889 ourstatus
->value
.integer
= 0;
1890 thread_id
= current_event
.dwThreadId
;
1893 case EXCEPTION_DEBUG_EVENT
:
1894 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1895 (unsigned) current_event
.dwProcessId
,
1896 (unsigned) current_event
.dwThreadId
,
1897 "EXCEPTION_DEBUG_EVENT"));
1898 if (saw_create
!= 1)
1900 switch (handle_exception (ourstatus
))
1902 case HANDLE_EXCEPTION_UNHANDLED
:
1904 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1906 case HANDLE_EXCEPTION_HANDLED
:
1907 thread_id
= current_event
.dwThreadId
;
1909 case HANDLE_EXCEPTION_IGNORED
:
1910 continue_status
= DBG_CONTINUE
;
1915 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1916 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1917 (unsigned) current_event
.dwProcessId
,
1918 (unsigned) current_event
.dwThreadId
,
1919 "OUTPUT_DEBUG_STRING_EVENT"));
1920 if (saw_create
!= 1)
1922 thread_id
= handle_output_debug_string (ourstatus
);
1926 if (saw_create
!= 1)
1928 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1929 (unsigned) current_event
.dwProcessId
,
1930 (unsigned) current_event
.dwThreadId
);
1931 printf_unfiltered (" unknown event code %u\n",
1932 (unsigned) current_event
.dwDebugEventCode
);
1936 if (!thread_id
|| saw_create
!= 1)
1938 CHECK (windows_continue (continue_status
, -1, 0));
1942 inferior_ptid
= ptid_t (current_event
.dwProcessId
, 0, thread_id
);
1943 current_thread
= th
;
1944 if (!current_thread
)
1945 current_thread
= thread_rec (thread_id
, TRUE
);
1952 /* Wait for interesting events to occur in the target process. */
1954 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1959 /* We loop when we get a non-standard exception rather than return
1960 with a SPURIOUS because resume can try and step or modify things,
1961 which needs a current_thread->h. But some of these exceptions mark
1962 the birth or death of threads, which mean that the current thread
1963 isn't necessarily what you think it is. */
1969 /* If the user presses Ctrl-c while the debugger is waiting
1970 for an event, he expects the debugger to interrupt his program
1971 and to get the prompt back. There are two possible situations:
1973 - The debugger and the program do not share the console, in
1974 which case the Ctrl-c event only reached the debugger.
1975 In that case, the ctrl_c handler will take care of interrupting
1976 the inferior. Note that this case is working starting with
1977 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1980 - The debugger and the program share the same console, in which
1981 case both debugger and inferior will receive the Ctrl-c event.
1982 In that case the ctrl_c handler will ignore the event, as the
1983 Ctrl-c event generated inside the inferior will trigger the
1984 expected debug event.
1986 FIXME: brobecker/2008-05-20: If the inferior receives the
1987 signal first and the delay until GDB receives that signal
1988 is sufficiently long, GDB can sometimes receive the SIGINT
1989 after we have unblocked the CTRL+C handler. This would
1990 lead to the debugger stopping prematurely while handling
1991 the new-thread event that comes with the handling of the SIGINT
1992 inside the inferior, and then stop again immediately when
1993 the user tries to resume the execution in the inferior.
1994 This is a classic race that we should try to fix one day. */
1995 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1996 retval
= get_windows_debug_event (pid
, ourstatus
);
1997 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
2000 return ptid_t (current_event
.dwProcessId
, 0, retval
);
2005 if (deprecated_ui_loop_hook
!= NULL
)
2006 detach
= deprecated_ui_loop_hook (0);
2014 /* Iterate over all DLLs currently mapped by our inferior, and
2015 add them to our list of solibs. */
2018 windows_add_all_dlls (void)
2020 HMODULE dummy_hmodule
;
2028 if (EnumProcessModulesEx (current_process_handle
, &dummy_hmodule
,
2029 sizeof (HMODULE
), &cb_needed
,
2030 LIST_MODULES_32BIT
) == 0)
2036 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
2037 sizeof (HMODULE
), &cb_needed
) == 0)
2044 hmodules
= (HMODULE
*) alloca (cb_needed
);
2048 if (EnumProcessModulesEx (current_process_handle
, hmodules
,
2049 cb_needed
, &cb_needed
,
2050 LIST_MODULES_32BIT
) == 0)
2056 if (EnumProcessModules (current_process_handle
, hmodules
,
2057 cb_needed
, &cb_needed
) == 0)
2061 char system_dir
[__PMAX
];
2062 char syswow_dir
[__PMAX
];
2063 size_t system_dir_len
= 0;
2064 bool convert_syswow_dir
= false;
2069 /* This fails on 32bit Windows because it has no SysWOW64 directory,
2070 and in this case a path conversion isn't necessary. */
2071 UINT len
= GetSystemWow64DirectoryA (syswow_dir
, sizeof (syswow_dir
));
2074 /* Check that we have passed a large enough buffer. */
2075 gdb_assert (len
< sizeof (syswow_dir
));
2077 len
= GetSystemDirectoryA (system_dir
, sizeof (system_dir
));
2079 gdb_assert (len
!= 0);
2080 /* Check that we have passed a large enough buffer. */
2081 gdb_assert (len
< sizeof (system_dir
));
2083 strcat (system_dir
, "\\");
2084 strcat (syswow_dir
, "\\");
2085 system_dir_len
= strlen (system_dir
);
2087 convert_syswow_dir
= true;
2091 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
2095 wchar_t dll_name
[__PMAX
];
2096 char dll_name_mb
[__PMAX
];
2098 char dll_name
[__PMAX
];
2101 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
2102 &mi
, sizeof (mi
)) == 0)
2104 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
2105 dll_name
, sizeof (dll_name
)) == 0)
2108 wcstombs (dll_name_mb
, dll_name
, __PMAX
);
2113 /* Convert the DLL path of 32bit processes returned by
2114 GetModuleFileNameEx from the 64bit system directory to the
2115 32bit syswow64 directory if necessary. */
2116 std::string syswow_dll_path
;
2117 if (convert_syswow_dir
2118 && strncasecmp (name
, system_dir
, system_dir_len
) == 0
2119 && strchr (name
+ system_dir_len
, '\\') == nullptr)
2121 syswow_dll_path
= syswow_dir
;
2122 syswow_dll_path
+= name
+ system_dir_len
;
2123 name
= syswow_dll_path
.c_str();
2126 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
2127 solib_end
= solib_end
->next
;
2132 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
2135 struct inferior
*inf
;
2137 last_sig
= GDB_SIGNAL_0
;
2139 exception_count
= 0;
2140 open_process_used
= 0;
2141 debug_registers_changed
= 0;
2142 debug_registers_used
= 0;
2143 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
2146 cygwin_load_start
= cygwin_load_end
= 0;
2148 current_event
.dwProcessId
= pid
;
2149 memset (¤t_event
, 0, sizeof (current_event
));
2150 if (!target_is_pushed (ops
))
2152 disable_breakpoints_in_shlibs ();
2153 windows_clear_solib ();
2154 clear_proceed_status (0);
2155 init_wait_for_inferior ();
2158 ignore_first_breakpoint
= !attaching
&& wow64_process
;
2162 windows_set_context_register_offsets (amd64_mappings
);
2163 windows_set_segment_register_p (amd64_windows_segment_register_p
);
2168 windows_set_context_register_offsets (i386_mappings
);
2169 windows_set_segment_register_p (i386_windows_segment_register_p
);
2172 inf
= current_inferior ();
2173 inferior_appeared (inf
, pid
);
2174 inf
->attach_flag
= attaching
;
2176 /* Make the new process the current inferior, so terminal handling
2177 can rely on it. When attaching, we don't know about any thread
2178 id here, but that's OK --- nothing should be referencing the
2179 current thread until we report an event out of windows_wait. */
2180 inferior_ptid
= ptid_t (pid
);
2182 target_terminal::init ();
2183 target_terminal::inferior ();
2185 windows_initialization_done
= 0;
2189 struct target_waitstatus status
;
2191 ops
->wait (minus_one_ptid
, &status
, 0);
2193 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
2195 if (status
.kind
!= TARGET_WAITKIND_LOADED
2196 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
2199 ops
->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
2202 /* Now that the inferior has been started and all DLLs have been mapped,
2203 we can iterate over all DLLs and load them in.
2205 We avoid doing it any earlier because, on certain versions of Windows,
2206 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
2207 we have seen on Windows 8.1 that the ntdll.dll load event does not
2208 include the DLL name, preventing us from creating an associated SO.
2209 A possible explanation is that ntdll.dll might be mapped before
2210 the SO info gets created by the Windows system -- ntdll.dll is
2211 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
2212 do not seem to suffer from that problem.
2214 Rather than try to work around this sort of issue, it is much
2215 simpler to just ignore DLL load/unload events during the startup
2216 phase, and then process them all in one batch now. */
2217 windows_add_all_dlls ();
2219 windows_initialization_done
= 1;
2223 /* Try to set or remove a user privilege to the current process. Return -1
2224 if that fails, the previous setting of that privilege otherwise.
2226 This code is copied from the Cygwin source code and rearranged to allow
2227 dynamically loading of the needed symbols from advapi32 which is only
2228 available on NT/2K/XP. */
2230 set_process_privilege (const char *privilege
, BOOL enable
)
2232 HANDLE token_hdl
= NULL
;
2234 TOKEN_PRIVILEGES new_priv
, orig_priv
;
2238 if (!OpenProcessToken (GetCurrentProcess (),
2239 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
2243 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
2246 new_priv
.PrivilegeCount
= 1;
2247 new_priv
.Privileges
[0].Luid
= restore_priv
;
2248 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
2250 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
2251 sizeof orig_priv
, &orig_priv
, &size
))
2254 /* Disabled, otherwise every `attach' in an unprivileged user session
2255 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
2256 windows_attach(). */
2257 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
2258 be enabled. GetLastError () returns an correct error code, though. */
2259 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
2263 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
2267 CloseHandle (token_hdl
);
2272 /* Attach to process PID, then initialize for debugging it. */
2275 windows_nat_target::attach (const char *args
, int from_tty
)
2280 pid
= parse_pid_to_attach (args
);
2282 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
2284 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
2285 printf_unfiltered ("This can cause attach to "
2286 "fail on Windows NT/2K/XP\n");
2289 windows_init_thread_list ();
2290 ok
= DebugActiveProcess (pid
);
2296 /* Try fall back to Cygwin pid. */
2297 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
2300 ok
= DebugActiveProcess (pid
);
2305 error (_("Can't attach to process %u (error %u)"),
2306 (unsigned) pid
, (unsigned) GetLastError ());
2308 DebugSetProcessKillOnExit (FALSE
);
2312 const char *exec_file
= get_exec_file (0);
2315 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
2316 target_pid_to_str (ptid_t (pid
)).c_str ());
2318 printf_unfiltered ("Attaching to %s\n",
2319 target_pid_to_str (ptid_t (pid
)).c_str ());
2323 HANDLE h
= OpenProcess (PROCESS_QUERY_INFORMATION
, FALSE
, pid
);
2327 if (IsWow64Process (h
, &wow64
))
2328 wow64_process
= wow64
;
2333 do_initial_windows_stuff (this, pid
, 1);
2334 target_terminal::ours ();
2338 windows_nat_target::detach (inferior
*inf
, int from_tty
)
2342 ptid_t ptid
= minus_one_ptid
;
2343 resume (ptid
, 0, GDB_SIGNAL_0
);
2345 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
2347 error (_("Can't detach process %u (error %u)"),
2348 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
2351 DebugSetProcessKillOnExit (FALSE
);
2353 if (detached
&& from_tty
)
2355 const char *exec_file
= get_exec_file (0);
2358 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
2359 (unsigned) current_event
.dwProcessId
);
2362 x86_cleanup_dregs ();
2363 inferior_ptid
= null_ptid
;
2364 detach_inferior (inf
);
2366 maybe_unpush_target ();
2369 /* Try to determine the executable filename.
2371 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2373 Upon success, the filename is stored inside EXE_NAME_RET, and
2374 this function returns nonzero.
2376 Otherwise, this function returns zero and the contents of
2377 EXE_NAME_RET is undefined. */
2380 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2390 if (!EnumProcessModulesEx (current_process_handle
, &dh_buf
,
2391 sizeof (HMODULE
), &cbNeeded
,
2392 LIST_MODULES_32BIT
) || !cbNeeded
)
2398 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2399 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2403 /* We know the executable is always first in the list of modules,
2404 which we just fetched. So no need to fetch more. */
2408 /* Cygwin prefers that the path be in /x/y/z format, so extract
2409 the filename into a temporary buffer first, and then convert it
2410 to POSIX format into the destination buffer. */
2411 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2413 len
= GetModuleFileNameEx (current_process_handle
,
2414 dh_buf
, pathbuf
, exe_name_max_len
);
2416 error (_("Error getting executable filename: %u."),
2417 (unsigned) GetLastError ());
2418 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2419 exe_name_max_len
) < 0)
2420 error (_("Error converting executable filename to POSIX: %d."), errno
);
2423 len
= GetModuleFileNameEx (current_process_handle
,
2424 dh_buf
, exe_name_ret
, exe_name_max_len
);
2426 error (_("Error getting executable filename: %u."),
2427 (unsigned) GetLastError ());
2430 return 1; /* success */
2433 /* The pid_to_exec_file target_ops method for this platform. */
2436 windows_nat_target::pid_to_exec_file (int pid
)
2438 static char path
[__PMAX
];
2440 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2442 char procexe
[sizeof ("/proc/4294967295/exe")];
2444 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2445 nchars
= readlink (procexe
, path
, sizeof(path
));
2446 if (nchars
> 0 && nchars
< sizeof (path
))
2448 path
[nchars
] = '\0'; /* Got it */
2453 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2454 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2455 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2461 /* Print status information about what we're accessing. */
2464 windows_nat_target::files_info ()
2466 struct inferior
*inf
= current_inferior ();
2468 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2469 inf
->attach_flag
? "attached" : "child",
2470 target_pid_to_str (inferior_ptid
).c_str ());
2473 /* Modify CreateProcess parameters for use of a new separate console.
2475 *FLAGS: DWORD parameter for general process creation flags.
2476 *SI: STARTUPINFO structure, for which the console window size and
2477 console buffer size is filled in if GDB is running in a console.
2478 to create the new console.
2479 The size of the used font is not available on all versions of
2480 Windows OS. Furthermore, the current font might not be the default
2481 font, but this is still better than before.
2482 If the windows and buffer sizes are computed,
2483 SI->DWFLAGS is changed so that this information is used
2484 by CreateProcess function. */
2487 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2489 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2490 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2492 if (hconsole
!= INVALID_HANDLE_VALUE
)
2494 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2496 CONSOLE_FONT_INFO cfi
;
2498 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2499 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2500 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2501 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2502 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2504 si
->dwXSize
*= font_size
.X
;
2508 si
->dwYSize
*= font_size
.Y
;
2511 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2512 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2513 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2515 *flags
|= CREATE_NEW_CONSOLE
;
2519 /* Function called by qsort to sort environment strings. */
2522 envvar_cmp (const void *a
, const void *b
)
2524 const char **p
= (const char **) a
;
2525 const char **q
= (const char **) b
;
2526 return strcasecmp (*p
, *q
);
2532 clear_win32_environment (char **env
)
2536 wchar_t *copy
= NULL
, *equalpos
;
2538 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2540 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2541 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2542 mbstowcs (copy
, env
[i
], len
);
2543 equalpos
= wcschr (copy
, L
'=');
2546 SetEnvironmentVariableW (copy
, NULL
);
2554 /* Redirection of inferior I/O streams for native MS-Windows programs.
2555 Unlike on Unix, where this is handled by invoking the inferior via
2556 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2558 The official documentation of the cmd.exe redirection features is here:
2560 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2562 (That page talks about Windows XP, but there's no newer
2563 documentation, so we assume later versions of cmd.exe didn't change
2566 Caveat: the documentation on that page seems to include a few lies.
2567 For example, it describes strange constructs 1<&2 and 2<&1, which
2568 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2569 think the cmd.exe parser of the redirection symbols simply doesn't
2570 care about the < vs > distinction in these cases. Therefore, the
2571 supported features are explicitly documented below.
2573 The emulation below aims at supporting all the valid use cases
2574 supported by cmd.exe, which include:
2576 < FILE redirect standard input from FILE
2577 0< FILE redirect standard input from FILE
2578 <&N redirect standard input from file descriptor N
2579 0<&N redirect standard input from file descriptor N
2580 > FILE redirect standard output to FILE
2581 >> FILE append standard output to FILE
2582 1>> FILE append standard output to FILE
2583 >&N redirect standard output to file descriptor N
2584 1>&N redirect standard output to file descriptor N
2585 >>&N append standard output to file descriptor N
2586 1>>&N append standard output to file descriptor N
2587 2> FILE redirect standard error to FILE
2588 2>> FILE append standard error to FILE
2589 2>&N redirect standard error to file descriptor N
2590 2>>&N append standard error to file descriptor N
2592 Note that using N > 2 in the above construct is supported, but
2593 requires that the corresponding file descriptor be open by some
2594 means elsewhere or outside GDB. Also note that using ">&0" or
2595 "<&2" will generally fail, because the file descriptor redirected
2596 from is normally open in an incompatible mode (e.g., FD 0 is open
2597 for reading only). IOW, use of such tricks is not recommended;
2598 you are on your own.
2600 We do NOT support redirection of file descriptors above 2, as in
2601 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2602 that needs special handling in the startup code that MinGW
2603 doesn't have). Pipes are also not supported.
2605 As for invalid use cases, where the redirection contains some
2606 error, the emulation below will detect that and produce some
2607 error and/or failure. But the behavior in those cases is not
2608 bug-for-bug compatible with what cmd.exe does in those cases.
2609 That's because what cmd.exe does then is not well defined, and
2610 seems to be a side effect of the cmd.exe parsing of the command
2611 line more than anything else. For example, try redirecting to an
2612 invalid file name, as in "> foo:bar".
2614 There are also minor syntactic deviations from what cmd.exe does
2615 in some corner cases. For example, it doesn't support the likes
2616 of "> &foo" to mean redirect to file named literally "&foo"; we
2617 do support that here, because that, too, sounds like some issue
2618 with the cmd.exe parser. Another nicety is that we support
2619 redirection targets that use file names with forward slashes,
2620 something cmd.exe doesn't -- this comes in handy since GDB
2621 file-name completion can be used when typing the command line for
2624 /* Support routines for redirecting standard handles of the inferior. */
2626 /* Parse a single redirection spec, open/duplicate the specified
2627 file/fd, and assign the appropriate value to one of the 3 standard
2628 file descriptors. */
2630 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2632 int *fd
, ref_fd
= -2;
2634 const char *fname
= redir_string
+ 1;
2635 int rc
= *redir_string
;
2650 fd
= (rc
== '2') ? err
: out
;
2651 mode
= O_WRONLY
| O_CREAT
;
2664 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2666 /* A reference to a file descriptor. */
2668 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2669 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2671 /* Don't allow redirection when open modes are incompatible. */
2672 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2673 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2680 else if (ref_fd
== 1)
2682 else if (ref_fd
== 2)
2692 fname
++; /* skip the separator space */
2693 /* If the descriptor is already open, close it. This allows
2694 multiple specs of redirections for the same stream, which is
2695 somewhat nonsensical, but still valid and supported by cmd.exe.
2696 (But cmd.exe only opens a single file in this case, the one
2697 specified by the last redirection spec on the command line.) */
2702 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2706 else if (ref_fd
== -1)
2707 *fd
= -1; /* reset to default destination */
2710 *fd
= _dup (ref_fd
);
2714 /* _open just sets a flag for O_APPEND, which won't be passed to the
2715 inferior, so we need to actually move the file pointer. */
2716 if ((mode
& O_APPEND
) != 0)
2717 _lseek (*fd
, 0L, SEEK_END
);
2721 /* Canonicalize a single redirection spec and set up the corresponding
2722 file descriptor as specified. */
2724 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2726 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2728 const char *start
= s
;
2731 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2732 if ((*start
== '>' || *start
== '1' || *start
== '2')
2736 if (*s
== '>' && *start
!= '>')
2739 else if (*start
== '0' && *s
== '<')
2741 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2744 while (isspace (*s
)) /* skip whitespace before file name */
2746 *d
++ = ' '; /* separate file name with a single space */
2749 /* Copy the file name. */
2752 /* Remove quoting characters from the file name in buf[]. */
2753 if (*s
== '"') /* could support '..' quoting here */
2757 else if (*s
== quote
)
2765 else if (*s
== '\\')
2767 if (s
[1] == '"') /* could support '..' here */
2771 else if (isspace (*s
) && !quote
)
2775 if (d
- buf
>= sizeof (buf
) - 1)
2777 errno
= ENAMETOOLONG
;
2783 /* Windows doesn't allow redirection characters in file names, so we
2784 can bail out early if they use them, or if there's no target file
2785 name after the redirection symbol. */
2786 if (d
[-1] == '>' || d
[-1] == '<')
2791 if (redir_open (buf
, inp
, out
, err
) == 0)
2796 /* Parse the command line for redirection specs and prepare the file
2797 descriptors for the 3 standard streams accordingly. */
2799 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2800 int *inp
, int *out
, int *err
)
2802 const char *s
= cmd_orig
;
2805 bool retval
= false;
2807 while (isspace (*s
))
2812 if (*s
== '"') /* could also support '..' quoting here */
2816 else if (*s
== quote
)
2819 else if (*s
== '\\')
2821 if (s
[1] == '"') /* escaped quote char */
2826 /* Process a single redirection candidate. */
2827 if (*s
== '<' || *s
== '>'
2828 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2829 || (*s
== '0' && s
[1] == '<'))
2831 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2845 #endif /* !__CYGWIN__ */
2847 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2848 EXEC_FILE is the file to run.
2849 ALLARGS is a string containing the arguments to the program.
2850 ENV is the environment vector to pass. Errors reported with error(). */
2853 windows_nat_target::create_inferior (const char *exec_file
,
2854 const std::string
&origallargs
,
2855 char **in_env
, int from_tty
)
2859 cygwin_buf_t real_path
[__PMAX
];
2860 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2861 cygwin_buf_t infcwd
[__PMAX
];
2863 cygwin_buf_t
*toexec
;
2864 cygwin_buf_t
*cygallargs
;
2866 char **old_env
= NULL
;
2870 int ostdin
, ostdout
, ostderr
;
2871 #else /* !__CYGWIN__ */
2872 char shell
[__PMAX
]; /* Path to shell */
2874 char *args
, *allargs_copy
;
2875 size_t args_len
, allargs_len
;
2876 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2877 HANDLE tty
= INVALID_HANDLE_VALUE
;
2878 bool redirected
= false;
2885 #endif /* !__CYGWIN__ */
2886 const char *allargs
= origallargs
.c_str ();
2887 PROCESS_INFORMATION pi
;
2890 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2893 error (_("No executable specified, use `target exec'."));
2895 const char *inferior_cwd
= get_inferior_cwd ();
2896 std::string expanded_infcwd
;
2897 if (inferior_cwd
!= NULL
)
2899 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
2900 /* Mirror slashes on inferior's cwd. */
2901 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
2903 inferior_cwd
= expanded_infcwd
.c_str ();
2906 memset (&si
, 0, sizeof (si
));
2907 si
.cb
= sizeof (si
);
2910 flags
|= CREATE_NEW_PROCESS_GROUP
;
2913 windows_set_console_info (&si
, &flags
);
2918 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2919 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2920 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2921 error (_("Error starting executable: %d"), errno
);
2924 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2925 if (len
== (size_t) -1)
2926 error (_("Error starting executable: %d"), errno
);
2927 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2928 mbstowcs (cygallargs
, allargs
, len
);
2929 #else /* !__USEWIDE */
2930 cygallargs
= allargs
;
2936 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2937 error (_("Error starting executable via shell: %d"), errno
);
2939 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2940 + mbstowcs (NULL
, allargs
, 0) + 2;
2941 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2942 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2943 #else /* !__USEWIDE */
2944 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2945 + strlen (allargs
) + 2);
2946 cygallargs
= (char *) alloca (len
);
2947 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2948 #endif /* __USEWIDE */
2950 flags
|= DEBUG_PROCESS
;
2953 if (inferior_cwd
!= NULL
2954 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
2955 infcwd
, strlen (inferior_cwd
)) < 0)
2956 error (_("Error converting inferior cwd: %d"), errno
);
2959 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2960 * sizeof (wchar_t));
2961 wcscpy (args
, toexec
);
2962 wcscat (args
, L
" ");
2963 wcscat (args
, cygallargs
);
2964 #else /* !__USEWIDE */
2965 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2966 strcpy (args
, toexec
);
2968 strcat (args
, cygallargs
);
2969 #endif /* !__USEWIDE */
2971 #ifdef CW_CVT_ENV_TO_WINENV
2972 /* First try to create a direct Win32 copy of the POSIX environment. */
2973 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2974 if (w32_env
!= (PWCHAR
) -1)
2975 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2977 /* If that fails, fall back to old method tweaking GDB's environment. */
2978 #endif /* CW_CVT_ENV_TO_WINENV */
2980 /* Reset all Win32 environment variables to avoid leftover on next run. */
2981 clear_win32_environment (environ
);
2982 /* Prepare the environment vars for CreateProcess. */
2985 cygwin_internal (CW_SYNC_WINENV
);
2989 if (!inferior_io_terminal
)
2990 tty
= ostdin
= ostdout
= ostderr
= -1;
2993 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2996 print_sys_errmsg (inferior_io_terminal
, errno
);
2997 ostdin
= ostdout
= ostderr
= -1;
3010 windows_init_thread_list ();
3011 ret
= CreateProcess (0,
3012 args
, /* command line */
3013 NULL
, /* Security */
3015 TRUE
, /* inherit handles */
3016 flags
, /* start flags */
3017 w32_env
, /* environment */
3018 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
3023 /* Just free the Win32 environment, if it could be created. */
3027 /* Reset all environment variables to avoid leftover on next run. */
3028 clear_win32_environment (in_env
);
3029 /* Restore normal GDB environment variables. */
3031 cygwin_internal (CW_SYNC_WINENV
);
3044 #else /* !__CYGWIN__ */
3045 allargs_len
= strlen (allargs
);
3046 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
3047 if (strpbrk (allargs_copy
, "<>") != NULL
)
3052 redirect_inferior_handles (allargs
, allargs_copy
,
3053 &fd_inp
, &fd_out
, &fd_err
);
3055 warning (_("Error in redirection: %s."), safe_strerror (errno
));
3058 allargs_len
= strlen (allargs_copy
);
3060 /* If not all the standard streams are redirected by the command
3061 line, use inferior_io_terminal for those which aren't. */
3062 if (inferior_io_terminal
3063 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
3065 SECURITY_ATTRIBUTES sa
;
3066 sa
.nLength
= sizeof(sa
);
3067 sa
.lpSecurityDescriptor
= 0;
3068 sa
.bInheritHandle
= TRUE
;
3069 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
3070 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
3071 if (tty
== INVALID_HANDLE_VALUE
)
3072 warning (_("Warning: Failed to open TTY %s, error %#x."),
3073 inferior_io_terminal
, (unsigned) GetLastError ());
3075 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
3078 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
3079 else if (tty
!= INVALID_HANDLE_VALUE
)
3082 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
3084 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
3085 else if (tty
!= INVALID_HANDLE_VALUE
)
3086 si
.hStdOutput
= tty
;
3088 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
3090 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
3091 else if (tty
!= INVALID_HANDLE_VALUE
)
3094 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
3095 si
.dwFlags
|= STARTF_USESTDHANDLES
;
3099 /* Build the command line, a space-separated list of tokens where
3100 the first token is the name of the module to be executed.
3101 To avoid ambiguities introduced by spaces in the module name,
3103 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
3104 args
= (char *) alloca (args_len
);
3105 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
3107 flags
|= DEBUG_ONLY_THIS_PROCESS
;
3109 /* CreateProcess takes the environment list as a null terminated set of
3110 strings (i.e. two nulls terminate the list). */
3112 /* Get total size for env strings. */
3113 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
3114 envlen
+= strlen (in_env
[i
]) + 1;
3116 envsize
= sizeof (in_env
[0]) * (i
+ 1);
3117 env
= (char **) alloca (envsize
);
3118 memcpy (env
, in_env
, envsize
);
3119 /* Windows programs expect the environment block to be sorted. */
3120 qsort (env
, i
, sizeof (char *), envvar_cmp
);
3122 w32env
= (char *) alloca (envlen
+ 1);
3124 /* Copy env strings into new buffer. */
3125 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
3127 strcpy (temp
, env
[i
]);
3128 temp
+= strlen (temp
) + 1;
3131 /* Final nil string to terminate new env. */
3134 windows_init_thread_list ();
3135 ret
= CreateProcessA (0,
3136 args
, /* command line */
3137 NULL
, /* Security */
3139 TRUE
, /* inherit handles */
3140 flags
, /* start flags */
3141 w32env
, /* environment */
3142 inferior_cwd
, /* current directory */
3145 if (tty
!= INVALID_HANDLE_VALUE
)
3153 #endif /* !__CYGWIN__ */
3156 error (_("Error creating process %s, (error %u)."),
3157 exec_file
, (unsigned) GetLastError ());
3161 if (IsWow64Process (pi
.hProcess
, &wow64
))
3162 wow64_process
= wow64
;
3165 CloseHandle (pi
.hThread
);
3166 CloseHandle (pi
.hProcess
);
3168 if (useshell
&& shell
[0] != '\0')
3173 do_initial_windows_stuff (this, pi
.dwProcessId
, 0);
3175 /* windows_continue (DBG_CONTINUE, -1, 0); */
3179 windows_nat_target::mourn_inferior ()
3181 (void) windows_continue (DBG_CONTINUE
, -1, 0);
3182 x86_cleanup_dregs();
3183 if (open_process_used
)
3185 CHECK (CloseHandle (current_process_handle
));
3186 open_process_used
= 0;
3188 siginfo_er
.ExceptionCode
= 0;
3189 inf_child_target::mourn_inferior ();
3192 /* Send a SIGINT to the process group. This acts just like the user typed a
3193 ^C on the controlling terminal. */
3196 windows_nat_target::interrupt ()
3198 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
3199 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
3200 registers_changed (); /* refresh register state */
3203 /* Helper for windows_xfer_partial that handles memory transfers.
3204 Arguments are like target_xfer_partial. */
3206 static enum target_xfer_status
3207 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3208 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
3212 DWORD lasterror
= 0;
3214 if (writebuf
!= NULL
)
3216 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
3217 pulongest (len
), core_addr_to_string (memaddr
)));
3218 success
= WriteProcessMemory (current_process_handle
,
3219 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
3222 lasterror
= GetLastError ();
3223 FlushInstructionCache (current_process_handle
,
3224 (LPCVOID
) (uintptr_t) memaddr
, len
);
3228 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
3229 pulongest (len
), core_addr_to_string (memaddr
)));
3230 success
= ReadProcessMemory (current_process_handle
,
3231 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
3234 lasterror
= GetLastError ();
3236 *xfered_len
= (ULONGEST
) done
;
3237 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
3238 return TARGET_XFER_OK
;
3240 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
3244 windows_nat_target::kill ()
3246 CHECK (TerminateProcess (current_process_handle
, 0));
3250 if (!windows_continue (DBG_CONTINUE
, -1, 1))
3252 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
3254 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
3258 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
3262 windows_nat_target::close ()
3264 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
3265 inferior_ptid
.pid ()));
3268 /* Convert pid to printable format. */
3270 windows_nat_target::pid_to_str (ptid_t ptid
)
3272 if (ptid
.tid () != 0)
3273 return string_printf ("Thread %d.0x%lx", ptid
.pid (), ptid
.tid ());
3275 return normal_pid_to_str (ptid
);
3278 static enum target_xfer_status
3279 windows_xfer_shared_libraries (struct target_ops
*ops
,
3280 enum target_object object
, const char *annex
,
3281 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3282 ULONGEST offset
, ULONGEST len
,
3283 ULONGEST
*xfered_len
)
3285 struct obstack obstack
;
3291 return TARGET_XFER_E_IO
;
3293 obstack_init (&obstack
);
3294 obstack_grow_str (&obstack
, "<library-list>\n");
3295 for (so
= solib_start
.next
; so
; so
= so
->next
)
3297 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
3299 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
3300 (uintptr_t) li
->load_addr
,
3302 target_gdbarch (), &obstack
);
3304 obstack_grow_str0 (&obstack
, "</library-list>\n");
3306 buf
= (const char *) obstack_finish (&obstack
);
3307 len_avail
= strlen (buf
);
3308 if (offset
>= len_avail
)
3312 if (len
> len_avail
- offset
)
3313 len
= len_avail
- offset
;
3314 memcpy (readbuf
, buf
+ offset
, len
);
3317 obstack_free (&obstack
, NULL
);
3318 *xfered_len
= (ULONGEST
) len
;
3319 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
3322 /* Helper for windows_nat_target::xfer_partial that handles signal info. */
3324 static enum target_xfer_status
3325 windows_xfer_siginfo (gdb_byte
*readbuf
, ULONGEST offset
, ULONGEST len
,
3326 ULONGEST
*xfered_len
)
3328 char *buf
= (char *) &siginfo_er
;
3329 size_t bufsize
= sizeof (siginfo_er
);
3332 EXCEPTION_RECORD32 er32
;
3335 buf
= (char *) &er32
;
3336 bufsize
= sizeof (er32
);
3338 er32
.ExceptionCode
= siginfo_er
.ExceptionCode
;
3339 er32
.ExceptionFlags
= siginfo_er
.ExceptionFlags
;
3340 er32
.ExceptionRecord
= (uintptr_t) siginfo_er
.ExceptionRecord
;
3341 er32
.ExceptionAddress
= (uintptr_t) siginfo_er
.ExceptionAddress
;
3342 er32
.NumberParameters
= siginfo_er
.NumberParameters
;
3344 for (i
= 0; i
< EXCEPTION_MAXIMUM_PARAMETERS
; i
++)
3345 er32
.ExceptionInformation
[i
] = siginfo_er
.ExceptionInformation
[i
];
3349 if (siginfo_er
.ExceptionCode
== 0)
3350 return TARGET_XFER_E_IO
;
3352 if (readbuf
== nullptr)
3353 return TARGET_XFER_E_IO
;
3355 if (offset
> bufsize
)
3356 return TARGET_XFER_E_IO
;
3358 if (offset
+ len
> bufsize
)
3359 len
= bufsize
- offset
;
3361 memcpy (readbuf
, buf
+ offset
, len
);
3364 return TARGET_XFER_OK
;
3367 enum target_xfer_status
3368 windows_nat_target::xfer_partial (enum target_object object
,
3369 const char *annex
, gdb_byte
*readbuf
,
3370 const gdb_byte
*writebuf
, ULONGEST offset
,
3371 ULONGEST len
, ULONGEST
*xfered_len
)
3375 case TARGET_OBJECT_MEMORY
:
3376 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
3378 case TARGET_OBJECT_LIBRARIES
:
3379 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
3380 writebuf
, offset
, len
, xfered_len
);
3382 case TARGET_OBJECT_SIGNAL_INFO
:
3383 return windows_xfer_siginfo (readbuf
, offset
, len
, xfered_len
);
3386 if (beneath () == NULL
)
3388 /* This can happen when requesting the transfer of unsupported
3389 objects before a program has been started (and therefore
3390 with the current_target having no target beneath). */
3391 return TARGET_XFER_E_IO
;
3393 return beneath ()->xfer_partial (object
, annex
,
3394 readbuf
, writebuf
, offset
, len
,
3399 /* Provide thread local base, i.e. Thread Information Block address.
3400 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
3403 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
3405 windows_thread_info
*th
;
3407 th
= thread_rec (ptid
.tid (), 0);
3412 *addr
= th
->thread_local_base
;
3418 windows_nat_target::get_ada_task_ptid (long lwp
, long thread
)
3420 return ptid_t (inferior_ptid
.pid (), 0, lwp
);
3423 /* Implementation of the to_thread_name method. */
3426 windows_nat_target::thread_name (struct thread_info
*thr
)
3428 return thread_rec (thr
->ptid
.tid (), 0)->name
;
3432 void _initialize_windows_nat ();
3434 _initialize_windows_nat ()
3436 x86_dr_low
.set_control
= cygwin_set_dr7
;
3437 x86_dr_low
.set_addr
= cygwin_set_dr
;
3438 x86_dr_low
.get_addr
= cygwin_get_dr
;
3439 x86_dr_low
.get_status
= cygwin_get_dr6
;
3440 x86_dr_low
.get_control
= cygwin_get_dr7
;
3442 /* x86_dr_low.debug_register_length field is set by
3443 calling x86_set_debug_register_length function
3444 in processor windows specific native file. */
3446 add_inf_child_target (&the_windows_nat_target
);
3449 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3452 add_com ("signal-event", class_run
, signal_event_command
, _("\
3453 Signal a crashed process with event ID, to allow its debugging.\n\
3454 This command is needed in support of setting up GDB as JIT debugger on \
3455 MS-Windows. The command should be invoked from the GDB command line using \
3456 the '-ex' command-line option. The ID of the event that blocks the \
3457 crashed process will be supplied by the Windows JIT debugging mechanism."));
3460 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3461 Set use of shell to start subprocess."), _("\
3462 Show use of shell to start subprocess."), NULL
,
3464 NULL
, /* FIXME: i18n: */
3465 &setlist
, &showlist
);
3467 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3468 &cygwin_exceptions
, _("\
3469 Break when an exception is detected in the Cygwin DLL itself."), _("\
3470 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3472 NULL
, /* FIXME: i18n: */
3473 &setlist
, &showlist
);
3476 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3477 Set creation of new console when creating child process."), _("\
3478 Show creation of new console when creating child process."), NULL
,
3480 NULL
, /* FIXME: i18n: */
3481 &setlist
, &showlist
);
3483 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3484 Set creation of new group when creating child process."), _("\
3485 Show creation of new group when creating child process."), NULL
,
3487 NULL
, /* FIXME: i18n: */
3488 &setlist
, &showlist
);
3490 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3491 Set whether to display execution in child process."), _("\
3492 Show whether to display execution in child process."), NULL
,
3494 NULL
, /* FIXME: i18n: */
3495 &setlist
, &showlist
);
3497 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3498 Set whether to display kernel events in child process."), _("\
3499 Show whether to display kernel events in child process."), NULL
,
3501 NULL
, /* FIXME: i18n: */
3502 &setlist
, &showlist
);
3504 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3505 Set whether to display memory accesses in child process."), _("\
3506 Show whether to display memory accesses in child process."), NULL
,
3508 NULL
, /* FIXME: i18n: */
3509 &setlist
, &showlist
);
3511 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3512 &debug_exceptions
, _("\
3513 Set whether to display kernel exceptions in child process."), _("\
3514 Show whether to display kernel exceptions in child process."), NULL
,
3516 NULL
, /* FIXME: i18n: */
3517 &setlist
, &showlist
);
3519 init_w32_command_list ();
3521 add_cmd ("selector", class_info
, display_selectors
,
3522 _("Display selectors infos."),
3526 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3528 /* Pass the address ADDR to the inferior in the I'th debug register.
3529 Here we just store the address in dr array, the registers will be
3530 actually set up when windows_continue is called. */
3532 cygwin_set_dr (int i
, CORE_ADDR addr
)
3535 internal_error (__FILE__
, __LINE__
,
3536 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3538 debug_registers_changed
= 1;
3539 debug_registers_used
= 1;
3542 /* Pass the value VAL to the inferior in the DR7 debug control
3543 register. Here we just store the address in D_REGS, the watchpoint
3544 will be actually set up in windows_wait. */
3546 cygwin_set_dr7 (unsigned long val
)
3548 dr
[7] = (CORE_ADDR
) val
;
3549 debug_registers_changed
= 1;
3550 debug_registers_used
= 1;
3553 /* Get the value of debug register I from the inferior. */
3556 cygwin_get_dr (int i
)
3561 /* Get the value of the DR6 debug status register from the inferior.
3562 Here we just return the value stored in dr[6]
3563 by the last call to thread_rec for current_event.dwThreadId id. */
3564 static unsigned long
3565 cygwin_get_dr6 (void)
3567 return (unsigned long) dr
[6];
3570 /* Get the value of the DR7 debug status register from the inferior.
3571 Here we just return the value stored in dr[7] by the last call to
3572 thread_rec for current_event.dwThreadId id. */
3574 static unsigned long
3575 cygwin_get_dr7 (void)
3577 return (unsigned long) dr
[7];
3580 /* Determine if the thread referenced by "ptid" is alive
3581 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3582 it means that the thread has died. Otherwise it is assumed to be alive. */
3585 windows_nat_target::thread_alive (ptid_t ptid
)
3589 gdb_assert (ptid
.tid () != 0);
3592 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) != WAIT_OBJECT_0
;
3595 void _initialize_check_for_gdb_ini ();
3597 _initialize_check_for_gdb_ini ()
3600 if (inhibit_gdbinit
)
3603 homedir
= getenv ("HOME");
3607 char *oldini
= (char *) alloca (strlen (homedir
) +
3608 sizeof ("gdb.ini") + 1);
3609 strcpy (oldini
, homedir
);
3610 p
= strchr (oldini
, '\0');
3611 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3613 strcpy (p
, "gdb.ini");
3614 if (access (oldini
, 0) == 0)
3616 int len
= strlen (oldini
);
3617 char *newini
= (char *) alloca (len
+ 2);
3619 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3620 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3621 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3626 /* Define dummy functions which always return error for the rare cases where
3627 these functions could not be found. */
3629 bad_DebugActiveProcessStop (DWORD w
)
3634 bad_DebugBreakProcess (HANDLE w
)
3639 bad_DebugSetProcessKillOnExit (BOOL w
)
3644 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3651 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3657 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3664 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3670 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3676 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3682 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3690 /* Load any functions which may not be available in ancient versions
3693 void _initialize_loadable ();
3695 _initialize_loadable ()
3699 #define GPA(m, func) \
3700 func = (func ## _ftype *) GetProcAddress (m, #func)
3702 hm
= LoadLibrary ("kernel32.dll");
3705 GPA (hm
, DebugActiveProcessStop
);
3706 GPA (hm
, DebugBreakProcess
);
3707 GPA (hm
, DebugSetProcessKillOnExit
);
3708 GPA (hm
, GetConsoleFontSize
);
3709 GPA (hm
, DebugActiveProcessStop
);
3710 GPA (hm
, GetCurrentConsoleFont
);
3712 GPA (hm
, Wow64SuspendThread
);
3713 GPA (hm
, Wow64GetThreadContext
);
3714 GPA (hm
, Wow64SetThreadContext
);
3715 GPA (hm
, Wow64GetThreadSelectorEntry
);
3719 /* Set variables to dummy versions of these processes if the function
3720 wasn't found in kernel32.dll. */
3721 if (!DebugBreakProcess
)
3722 DebugBreakProcess
= bad_DebugBreakProcess
;
3723 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3725 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3726 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3728 if (!GetConsoleFontSize
)
3729 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3730 if (!GetCurrentConsoleFont
)
3731 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3733 /* Load optional functions used for retrieving filename information
3734 associated with the currently debugged process or its dlls. */
3735 hm
= LoadLibrary ("psapi.dll");
3738 GPA (hm
, EnumProcessModules
);
3740 GPA (hm
, EnumProcessModulesEx
);
3742 GPA (hm
, GetModuleInformation
);
3743 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3744 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3747 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3749 /* Set variables to dummy versions of these processes if the function
3750 wasn't found in psapi.dll. */
3751 EnumProcessModules
= bad_EnumProcessModules
;
3752 GetModuleInformation
= bad_GetModuleInformation
;
3753 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3754 /* This will probably fail on Windows 9x/Me. Let the user know
3755 that we're missing some functionality. */
3757 cannot automatically find executable file or library to read symbols.\n\
3758 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3761 hm
= LoadLibrary ("advapi32.dll");
3764 GPA (hm
, OpenProcessToken
);
3765 GPA (hm
, LookupPrivilegeValueA
);
3766 GPA (hm
, AdjustTokenPrivileges
);
3767 /* Only need to set one of these since if OpenProcessToken fails nothing
3769 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3770 || !AdjustTokenPrivileges
)
3771 OpenProcessToken
= bad_OpenProcessToken
;