1 /* Target-vector operations for controlling windows child processes, for GDB.
3 Copyright (C) 1995-2020 Free Software Foundation, Inc.
5 Contributed by Cygnus Solutions, A Red Hat Company.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 /* Originally by Steve Chamberlain, sac@cygnus.com */
25 #include "frame.h" /* required by inferior.h */
31 #include "completer.h"
35 #include <sys/types.h>
42 #include <sys/cygwin.h>
43 #include <cygwin/version.h>
48 #include "filenames.h"
52 #include "gdb_obstack.h"
53 #include "gdbthread.h"
59 #include "xml-support.h"
62 #include "i386-tdep.h"
63 #include "i387-tdep.h"
65 #include "windows-tdep.h"
66 #include "windows-nat.h"
68 #include "complaints.h"
69 #include "inf-child.h"
70 #include "gdbsupport/gdb_tilde_expand.h"
71 #include "gdbsupport/pathstuff.h"
72 #include "gdbsupport/gdb_wait.h"
73 #include "nat/windows-nat.h"
75 #define STATUS_WX86_BREAKPOINT 0x4000001F
76 #define STATUS_WX86_SINGLE_STEP 0x4000001E
78 #define AdjustTokenPrivileges dyn_AdjustTokenPrivileges
79 #define DebugActiveProcessStop dyn_DebugActiveProcessStop
80 #define DebugBreakProcess dyn_DebugBreakProcess
81 #define DebugSetProcessKillOnExit dyn_DebugSetProcessKillOnExit
82 #define EnumProcessModules dyn_EnumProcessModules
83 #define EnumProcessModulesEx dyn_EnumProcessModulesEx
84 #define GetModuleInformation dyn_GetModuleInformation
85 #define LookupPrivilegeValueA dyn_LookupPrivilegeValueA
86 #define OpenProcessToken dyn_OpenProcessToken
87 #define GetConsoleFontSize dyn_GetConsoleFontSize
88 #define GetCurrentConsoleFont dyn_GetCurrentConsoleFont
89 #define Wow64SuspendThread dyn_Wow64SuspendThread
90 #define Wow64GetThreadContext dyn_Wow64GetThreadContext
91 #define Wow64SetThreadContext dyn_Wow64SetThreadContext
92 #define Wow64GetThreadSelectorEntry dyn_Wow64GetThreadSelectorEntry
94 typedef BOOL
WINAPI (AdjustTokenPrivileges_ftype
) (HANDLE
, BOOL
,
96 DWORD
, PTOKEN_PRIVILEGES
,
98 static AdjustTokenPrivileges_ftype
*AdjustTokenPrivileges
;
100 typedef BOOL
WINAPI (DebugActiveProcessStop_ftype
) (DWORD
);
101 static DebugActiveProcessStop_ftype
*DebugActiveProcessStop
;
103 typedef BOOL
WINAPI (DebugBreakProcess_ftype
) (HANDLE
);
104 static DebugBreakProcess_ftype
*DebugBreakProcess
;
106 typedef BOOL
WINAPI (DebugSetProcessKillOnExit_ftype
) (BOOL
);
107 static DebugSetProcessKillOnExit_ftype
*DebugSetProcessKillOnExit
;
109 typedef BOOL
WINAPI (EnumProcessModules_ftype
) (HANDLE
, HMODULE
*, DWORD
,
111 static EnumProcessModules_ftype
*EnumProcessModules
;
114 typedef BOOL
WINAPI (EnumProcessModulesEx_ftype
) (HANDLE
, HMODULE
*, DWORD
,
116 static EnumProcessModulesEx_ftype
*EnumProcessModulesEx
;
119 typedef BOOL
WINAPI (GetModuleInformation_ftype
) (HANDLE
, HMODULE
,
120 LPMODULEINFO
, DWORD
);
121 static GetModuleInformation_ftype
*GetModuleInformation
;
123 typedef BOOL
WINAPI (LookupPrivilegeValueA_ftype
) (LPCSTR
, LPCSTR
, PLUID
);
124 static LookupPrivilegeValueA_ftype
*LookupPrivilegeValueA
;
126 typedef BOOL
WINAPI (OpenProcessToken_ftype
) (HANDLE
, DWORD
, PHANDLE
);
127 static OpenProcessToken_ftype
*OpenProcessToken
;
129 typedef BOOL
WINAPI (GetCurrentConsoleFont_ftype
) (HANDLE
, BOOL
,
130 CONSOLE_FONT_INFO
*);
131 static GetCurrentConsoleFont_ftype
*GetCurrentConsoleFont
;
133 typedef COORD
WINAPI (GetConsoleFontSize_ftype
) (HANDLE
, DWORD
);
134 static GetConsoleFontSize_ftype
*GetConsoleFontSize
;
137 typedef DWORD
WINAPI (Wow64SuspendThread_ftype
) (HANDLE
);
138 static Wow64SuspendThread_ftype
*Wow64SuspendThread
;
140 typedef BOOL
WINAPI (Wow64GetThreadContext_ftype
) (HANDLE
, PWOW64_CONTEXT
);
141 static Wow64GetThreadContext_ftype
*Wow64GetThreadContext
;
143 typedef BOOL
WINAPI (Wow64SetThreadContext_ftype
) (HANDLE
,
144 const WOW64_CONTEXT
*);
145 static Wow64SetThreadContext_ftype
*Wow64SetThreadContext
;
147 typedef BOOL
WINAPI (Wow64GetThreadSelectorEntry_ftype
) (HANDLE
, DWORD
,
149 static Wow64GetThreadSelectorEntry_ftype
*Wow64GetThreadSelectorEntry
;
154 #undef GetModuleFileNameEx
157 # define __PMAX (MAX_PATH + 1)
158 typedef DWORD
WINAPI (GetModuleFileNameEx_ftype
) (HANDLE
, HMODULE
, LPSTR
, DWORD
);
159 static GetModuleFileNameEx_ftype
*GetModuleFileNameEx
;
160 # define STARTUPINFO STARTUPINFOA
161 # define CreateProcess CreateProcessA
162 # define GetModuleFileNameEx_name "GetModuleFileNameExA"
163 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
165 # define __PMAX PATH_MAX
166 /* The starting and ending address of the cygwin1.dll text segment. */
167 static CORE_ADDR cygwin_load_start
;
168 static CORE_ADDR cygwin_load_end
;
170 typedef wchar_t cygwin_buf_t
;
171 typedef DWORD
WINAPI (GetModuleFileNameEx_ftype
) (HANDLE
, HMODULE
,
173 static GetModuleFileNameEx_ftype
*GetModuleFileNameEx
;
174 # define STARTUPINFO STARTUPINFOW
175 # define CreateProcess CreateProcessW
176 # define GetModuleFileNameEx_name "GetModuleFileNameExW"
177 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExW
180 static int have_saved_context
; /* True if we've saved context from a
183 static CONTEXT saved_context
; /* Contains the saved context from a
187 /* If we're not using the old Cygwin header file set, define the
188 following which never should have been in the generic Win32 API
189 headers in the first place since they were our own invention... */
190 #ifndef _GNU_H_WINDOWS_H
193 FLAG_TRACE_BIT
= 0x100,
197 #ifndef CONTEXT_EXTENDED_REGISTERS
198 /* This macro is only defined on ia32. It only makes sense on this target,
199 so define it as zero if not already defined. */
200 #define CONTEXT_EXTENDED_REGISTERS 0
203 #define CONTEXT_DEBUGGER_DR CONTEXT_FULL | CONTEXT_FLOATING_POINT \
204 | CONTEXT_SEGMENTS | CONTEXT_DEBUG_REGISTERS \
205 | CONTEXT_EXTENDED_REGISTERS
207 static uintptr_t dr
[8];
208 static int debug_registers_changed
;
209 static int debug_registers_used
;
211 static int windows_initialization_done
;
212 #define DR6_CLEAR_VALUE 0xffff0ff0
214 /* The exception thrown by a program to tell the debugger the name of
215 a thread. The exception record contains an ID of a thread and a
216 name to give it. This exception has no documented name, but MSDN
217 dubs it "MS_VC_EXCEPTION" in one code example. */
218 #define MS_VC_EXCEPTION 0x406d1388
222 HANDLE_EXCEPTION_UNHANDLED
= 0,
223 HANDLE_EXCEPTION_HANDLED
,
224 HANDLE_EXCEPTION_IGNORED
225 } handle_exception_result
;
227 /* The string sent by cygwin when it processes a signal.
228 FIXME: This should be in a cygwin include file. */
229 #ifndef _CYGWIN_SIGNAL_STRING
230 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
233 #define CHECK(x) check (x, __FILE__,__LINE__)
234 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
235 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
236 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
237 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
239 static void cygwin_set_dr (int i
, CORE_ADDR addr
);
240 static void cygwin_set_dr7 (unsigned long val
);
241 static CORE_ADDR
cygwin_get_dr (int i
);
242 static unsigned long cygwin_get_dr6 (void);
243 static unsigned long cygwin_get_dr7 (void);
245 static enum gdb_signal last_sig
= GDB_SIGNAL_0
;
246 /* Set if a signal was received from the debugged process. */
248 static std::vector
<windows_thread_info
*> thread_list
;
250 /* The process and thread handles for the above context. */
252 static DEBUG_EVENT current_event
; /* The current debug event from
254 static HANDLE current_process_handle
; /* Currently executing process */
255 static windows_thread_info
*current_thread
; /* Info on currently selected thread */
256 static EXCEPTION_RECORD siginfo_er
; /* Contents of $_siginfo */
258 /* Counts of things. */
259 static int exception_count
= 0;
260 static int event_count
= 0;
261 static int saw_create
;
262 static int open_process_used
= 0;
264 static bool wow64_process
= false;
265 static bool ignore_first_breakpoint
= false;
269 static bool new_console
= false;
271 static bool cygwin_exceptions
= false;
273 static bool new_group
= true;
274 static bool debug_exec
= false; /* show execution */
275 static bool debug_events
= false; /* show events from kernel */
276 static bool debug_memory
= false; /* show target memory accesses */
277 static bool debug_exceptions
= false; /* show target exceptions */
278 static bool useshell
= false; /* use shell for subprocesses */
280 /* This vector maps GDB's idea of a register's number into an offset
281 in the windows exception context vector.
283 It also contains the bit mask needed to load the register in question.
285 The contents of this table can only be computed by the units
286 that provide CPU-specific support for Windows native debugging.
287 These units should set the table by calling
288 windows_set_context_register_offsets.
290 One day we could read a reg, we could inspect the context we
291 already have loaded, if it doesn't have the bit set that we need,
292 we read that set of registers in using GetThreadContext. If the
293 context already contains what we need, we just unpack it. Then to
294 write a register, first we have to ensure that the context contains
295 the other regs of the group, and then we copy the info in and set
298 static const int *mappings
;
300 /* The function to use in order to determine whether a register is
301 a segment register or not. */
302 static segment_register_p_ftype
*segment_register_p
;
304 /* See windows_nat_target::resume to understand why this is commented
307 /* This vector maps the target's idea of an exception (extracted
308 from the DEBUG_EVENT structure) to GDB's idea. */
310 struct xlate_exception
316 static const struct xlate_exception xlate
[] =
318 {EXCEPTION_ACCESS_VIOLATION
, GDB_SIGNAL_SEGV
},
319 {STATUS_STACK_OVERFLOW
, GDB_SIGNAL_SEGV
},
320 {EXCEPTION_BREAKPOINT
, GDB_SIGNAL_TRAP
},
321 {DBG_CONTROL_C
, GDB_SIGNAL_INT
},
322 {EXCEPTION_SINGLE_STEP
, GDB_SIGNAL_TRAP
},
323 {STATUS_FLOAT_DIVIDE_BY_ZERO
, GDB_SIGNAL_FPE
}
328 struct windows_nat_target final
: public x86_nat_target
<inf_child_target
>
330 void close () override
;
332 void attach (const char *, int) override
;
334 bool attach_no_wait () override
337 void detach (inferior
*, int) override
;
339 void resume (ptid_t
, int , enum gdb_signal
) override
;
341 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
343 void fetch_registers (struct regcache
*, int) override
;
344 void store_registers (struct regcache
*, int) override
;
346 enum target_xfer_status
xfer_partial (enum target_object object
,
349 const gdb_byte
*writebuf
,
350 ULONGEST offset
, ULONGEST len
,
351 ULONGEST
*xfered_len
) override
;
353 void files_info () override
;
355 void kill () override
;
357 void create_inferior (const char *, const std::string
&,
358 char **, int) override
;
360 void mourn_inferior () override
;
362 bool thread_alive (ptid_t ptid
) override
;
364 std::string
pid_to_str (ptid_t
) override
;
366 void interrupt () override
;
368 char *pid_to_exec_file (int pid
) override
;
370 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
372 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
374 const char *thread_name (struct thread_info
*) override
;
376 int get_windows_debug_event (int pid
, struct target_waitstatus
*ourstatus
);
379 static windows_nat_target the_windows_nat_target
;
381 /* Set the MAPPINGS static global to OFFSETS.
382 See the description of MAPPINGS for more details. */
385 windows_set_context_register_offsets (const int *offsets
)
390 /* Set the function that should be used by this module to determine
391 whether a given register is a segment register or not. */
394 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
396 segment_register_p
= fun
;
400 check (BOOL ok
, const char *file
, int line
)
403 printf_filtered ("error return %s:%d was %u\n", file
, line
,
404 (unsigned) GetLastError ());
407 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
408 then also retrieve the context for this thread. If GET_CONTEXT is
409 negative, then don't suspend the thread. */
410 static windows_thread_info
*
411 thread_rec (DWORD id
, int get_context
)
413 for (windows_thread_info
*th
: thread_list
)
416 if (!th
->suspended
&& get_context
)
418 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
420 else if (get_context
< 0)
422 th
->reload_context
= true;
430 /* Add a thread to the thread list.
432 PTID is the ptid of the thread to be added.
433 H is its Windows handle.
434 TLB is its thread local base.
435 MAIN_THREAD_P should be true if the thread to be added is
436 the main thread, false otherwise. */
438 static windows_thread_info
*
439 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
, bool main_thread_p
)
441 windows_thread_info
*th
;
444 gdb_assert (ptid
.lwp () != 0);
448 if ((th
= thread_rec (id
, FALSE
)))
451 CORE_ADDR base
= (CORE_ADDR
) (uintptr_t) tlb
;
453 /* For WOW64 processes, this is actually the pointer to the 64bit TIB,
454 and the 32bit TIB is exactly 2 pages after it. */
458 th
= new windows_thread_info (id
, h
, base
);
459 thread_list
.push_back (th
);
461 /* Add this new thread to the list of threads.
463 To be consistent with what's done on other platforms, we add
464 the main thread silently (in reality, this thread is really
465 more of a process to the user than a thread). */
467 add_thread_silent (&the_windows_nat_target
, ptid
);
469 add_thread (&the_windows_nat_target
, ptid
);
471 /* Set the debug registers for the new thread if they are used. */
472 if (debug_registers_used
)
477 /* Only change the value of the debug registers. */
478 th
->wow64_context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
479 CHECK (Wow64GetThreadContext (th
->h
, &th
->wow64_context
));
480 th
->wow64_context
.Dr0
= dr
[0];
481 th
->wow64_context
.Dr1
= dr
[1];
482 th
->wow64_context
.Dr2
= dr
[2];
483 th
->wow64_context
.Dr3
= dr
[3];
484 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
485 th
->wow64_context
.Dr7
= dr
[7];
486 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
487 th
->wow64_context
.ContextFlags
= 0;
492 /* Only change the value of the debug registers. */
493 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
494 CHECK (GetThreadContext (th
->h
, &th
->context
));
495 th
->context
.Dr0
= dr
[0];
496 th
->context
.Dr1
= dr
[1];
497 th
->context
.Dr2
= dr
[2];
498 th
->context
.Dr3
= dr
[3];
499 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
500 th
->context
.Dr7
= dr
[7];
501 CHECK (SetThreadContext (th
->h
, &th
->context
));
502 th
->context
.ContextFlags
= 0;
508 /* Clear out any old thread list and reinitialize it to a
511 windows_init_thread_list (void)
513 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
516 for (windows_thread_info
*here
: thread_list
)
519 thread_list
.clear ();
522 /* Delete a thread from the list of threads.
524 PTID is the ptid of the thread to be deleted.
525 EXIT_CODE is the thread's exit code.
526 MAIN_THREAD_P should be true if the thread to be deleted is
527 the main thread, false otherwise. */
530 windows_delete_thread (ptid_t ptid
, DWORD exit_code
, bool main_thread_p
)
534 gdb_assert (ptid
.lwp () != 0);
538 /* Emit a notification about the thread being deleted.
540 Note that no notification was printed when the main thread
541 was created, and thus, unless in verbose mode, we should be
542 symmetrical, and avoid that notification for the main thread
546 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
).c_str ());
547 else if (print_thread_events
&& !main_thread_p
)
548 printf_unfiltered (_("[%s exited with code %u]\n"),
549 target_pid_to_str (ptid
).c_str (),
550 (unsigned) exit_code
);
552 delete_thread (find_thread_ptid (&the_windows_nat_target
, ptid
));
554 auto iter
= std::find_if (thread_list
.begin (), thread_list
.end (),
555 [=] (windows_thread_info
*th
)
557 return th
->tid
== id
;
560 if (iter
!= thread_list
.end ())
563 thread_list
.erase (iter
);
567 /* Fetches register number R from the given windows_thread_info,
568 and supplies its value to the given regcache.
570 This function assumes that R is non-negative. A failed assertion
571 is raised if that is not true.
573 This function assumes that TH->RELOAD_CONTEXT is not set, meaning
574 that the windows_thread_info has an up-to-date context. A failed
575 assertion is raised if that assumption is violated. */
578 windows_fetch_one_register (struct regcache
*regcache
,
579 windows_thread_info
*th
, int r
)
582 gdb_assert (!th
->reload_context
);
584 char *context_ptr
= (char *) &th
->context
;
587 context_ptr
= (char *) &th
->wow64_context
;
590 char *context_offset
= context_ptr
+ mappings
[r
];
591 struct gdbarch
*gdbarch
= regcache
->arch ();
592 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
594 if (r
== I387_FISEG_REGNUM (tdep
))
596 long l
= *((long *) context_offset
) & 0xffff;
597 regcache
->raw_supply (r
, (char *) &l
);
599 else if (r
== I387_FOP_REGNUM (tdep
))
601 long l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
602 regcache
->raw_supply (r
, (char *) &l
);
604 else if (segment_register_p (r
))
606 /* GDB treats segment registers as 32bit registers, but they are
607 in fact only 16 bits long. Make sure we do not read extra
608 bits from our source buffer. */
609 long l
= *((long *) context_offset
) & 0xffff;
610 regcache
->raw_supply (r
, (char *) &l
);
613 regcache
->raw_supply (r
, context_offset
);
617 windows_nat_target::fetch_registers (struct regcache
*regcache
, int r
)
619 DWORD tid
= regcache
->ptid ().lwp ();
620 windows_thread_info
*th
= thread_rec (tid
, TRUE
);
622 /* Check if TH exists. Windows sometimes uses a non-existent
623 thread id in its events. */
627 if (th
->reload_context
)
630 if (have_saved_context
)
632 /* Lie about where the program actually is stopped since
633 cygwin has informed us that we should consider the signal
634 to have occurred at another location which is stored in
636 memcpy (&th
->context
, &saved_context
,
637 __COPY_CONTEXT_SIZE
);
638 have_saved_context
= 0;
645 th
->wow64_context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
646 CHECK (Wow64GetThreadContext (th
->h
, &th
->wow64_context
));
647 /* Copy dr values from that thread.
648 But only if there were not modified since last stop.
650 if (!debug_registers_changed
)
652 dr
[0] = th
->wow64_context
.Dr0
;
653 dr
[1] = th
->wow64_context
.Dr1
;
654 dr
[2] = th
->wow64_context
.Dr2
;
655 dr
[3] = th
->wow64_context
.Dr3
;
656 dr
[6] = th
->wow64_context
.Dr6
;
657 dr
[7] = th
->wow64_context
.Dr7
;
663 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
664 CHECK (GetThreadContext (th
->h
, &th
->context
));
665 /* Copy dr values from that thread.
666 But only if there were not modified since last stop.
668 if (!debug_registers_changed
)
670 dr
[0] = th
->context
.Dr0
;
671 dr
[1] = th
->context
.Dr1
;
672 dr
[2] = th
->context
.Dr2
;
673 dr
[3] = th
->context
.Dr3
;
674 dr
[6] = th
->context
.Dr6
;
675 dr
[7] = th
->context
.Dr7
;
678 th
->reload_context
= false;
682 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch()); r
++)
683 windows_fetch_one_register (regcache
, th
, r
);
685 windows_fetch_one_register (regcache
, th
, r
);
688 /* Collect the register number R from the given regcache, and store
689 its value into the corresponding area of the given thread's context.
691 This function assumes that R is non-negative. A failed assertion
692 assertion is raised if that is not true. */
695 windows_store_one_register (const struct regcache
*regcache
,
696 windows_thread_info
*th
, int r
)
700 char *context_ptr
= (char *) &th
->context
;
703 context_ptr
= (char *) &th
->wow64_context
;
706 regcache
->raw_collect (r
, context_ptr
+ mappings
[r
]);
709 /* Store a new register value into the context of the thread tied to
713 windows_nat_target::store_registers (struct regcache
*regcache
, int r
)
715 DWORD tid
= regcache
->ptid ().lwp ();
716 windows_thread_info
*th
= thread_rec (tid
, TRUE
);
718 /* Check if TH exists. Windows sometimes uses a non-existent
719 thread id in its events. */
724 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch ()); r
++)
725 windows_store_one_register (regcache
, th
, r
);
727 windows_store_one_register (regcache
, th
, r
);
730 /* Maintain a linked list of "so" information. */
731 struct lm_info_windows
: public lm_info_base
733 LPVOID load_addr
= 0;
734 CORE_ADDR text_offset
= 0;
737 static struct so_list solib_start
, *solib_end
;
739 static struct so_list
*
740 windows_make_so (const char *name
, LPVOID load_addr
)
747 WIN32_FIND_DATA w32_fd
;
748 HANDLE h
= FindFirstFile(name
, &w32_fd
);
750 if (h
== INVALID_HANDLE_VALUE
)
756 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
758 p
= strrchr (buf
, '\\');
761 SetCurrentDirectory (buf
);
762 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
763 SetCurrentDirectory (cwd
);
766 if (strcasecmp (buf
, "ntdll.dll") == 0)
768 GetSystemDirectory (buf
, sizeof (buf
));
769 strcat (buf
, "\\ntdll.dll");
772 cygwin_buf_t buf
[__PMAX
];
775 if (access (name
, F_OK
) != 0)
777 if (strcasecmp (name
, "ntdll.dll") == 0)
780 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
781 wcscat (buf
, L
"\\ntdll.dll");
785 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
786 strcat (buf
, "\\ntdll.dll");
791 so
= XCNEW (struct so_list
);
792 lm_info_windows
*li
= new lm_info_windows
;
794 li
->load_addr
= load_addr
;
795 strcpy (so
->so_original_name
, name
);
797 strcpy (so
->so_name
, buf
);
800 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
801 SO_NAME_MAX_PATH_SIZE
);
804 char *rname
= realpath (name
, NULL
);
805 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
807 strcpy (so
->so_name
, rname
);
811 error (_("dll path too long"));
813 /* Record cygwin1.dll .text start/end. */
814 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
815 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
817 asection
*text
= NULL
;
819 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386", -1));
824 if (bfd_check_format (abfd
.get (), bfd_object
))
825 text
= bfd_get_section_by_name (abfd
.get (), ".text");
830 /* The symbols in a dll are offset by 0x1000, which is the
831 offset from 0 of the first byte in an image - because of the
832 file header and the section alignment. */
833 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
835 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (text
);
843 get_image_name (HANDLE h
, void *address
, int unicode
)
846 static char buf
[__PMAX
];
848 static char buf
[(2 * __PMAX
) + 1];
850 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
856 /* Attempt to read the name of the dll that was detected.
857 This is documented to work only when actively debugging
858 a program. It will not work for attached processes. */
862 /* See if we could read the address of a string, and that the
863 address isn't null. */
864 if (!ReadProcessMemory (h
, address
, &address_ptr
,
865 sizeof (address_ptr
), &done
)
866 || done
!= sizeof (address_ptr
) || !address_ptr
)
869 /* Find the length of the string. */
870 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
871 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
875 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
878 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
879 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
882 wcstombs (buf
, unicode_address
, __PMAX
);
884 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
892 /* Handle a DLL load event, and return 1.
894 This function assumes that this event did not occur during inferior
895 initialization, where their event info may be incomplete (see
896 do_initial_windows_stuff and windows_add_all_dlls for more info
897 on how we handle DLL loading during that phase). */
902 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
905 /* Try getting the DLL name via the lpImageName field of the event.
906 Note that Microsoft documents this fields as strictly optional,
907 in the sense that it might be NULL. And the first DLL event in
908 particular is explicitly documented as "likely not pass[ed]"
909 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
910 dll_name
= get_image_name (current_process_handle
,
911 event
->lpImageName
, event
->fUnicode
);
915 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
916 solib_end
= solib_end
->next
;
918 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
920 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
921 host_address_to_string (li
->load_addr
)));
925 windows_free_so (struct so_list
*so
)
927 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
933 /* Handle a DLL unload event.
934 Return 1 if successful, or zero otherwise.
936 This function assumes that this event did not occur during inferior
937 initialization, where their event info may be incomplete (see
938 do_initial_windows_stuff and windows_add_all_dlls for more info
939 on how we handle DLL loading during that phase). */
944 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
947 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
949 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
951 if (li_next
->load_addr
== lpBaseOfDll
)
953 struct so_list
*sodel
= so
->next
;
955 so
->next
= sodel
->next
;
958 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
960 windows_free_so (sodel
);
965 /* We did not find any DLL that was previously loaded at this address,
966 so register a complaint. We do not report an error, because we have
967 observed that this may be happening under some circumstances. For
968 instance, running 32bit applications on x64 Windows causes us to receive
969 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
970 events are apparently caused by the WOW layer, the interface between
971 32bit and 64bit worlds). */
972 complaint (_("dll starting at %s not found."),
973 host_address_to_string (lpBaseOfDll
));
976 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
980 catch_errors (void (*func
) ())
986 catch (const gdb_exception
&ex
)
988 exception_print (gdb_stderr
, ex
);
992 /* Clear list of loaded DLLs. */
994 windows_clear_solib (void)
998 for (so
= solib_start
.next
; so
; so
= solib_start
.next
)
1000 solib_start
.next
= so
->next
;
1001 windows_free_so (so
);
1004 solib_end
= &solib_start
;
1008 signal_event_command (const char *args
, int from_tty
)
1010 uintptr_t event_id
= 0;
1011 char *endargs
= NULL
;
1014 error (_("signal-event requires an argument (integer event id)"));
1016 event_id
= strtoumax (args
, &endargs
, 10);
1018 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
1019 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
1020 error (_("Failed to convert `%s' to event id"), args
);
1022 SetEvent ((HANDLE
) event_id
);
1023 CloseHandle ((HANDLE
) event_id
);
1026 /* Handle DEBUG_STRING output from child process.
1027 Cygwin prepends its messages with a "cygwin:". Interpret this as
1028 a Cygwin signal. Otherwise just print the string as a warning. */
1030 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
1032 gdb::unique_xmalloc_ptr
<char> s
;
1035 if (!target_read_string
1036 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
1038 || !s
|| !*(s
.get ()))
1039 /* nothing to do */;
1040 else if (!startswith (s
.get (), _CYGWIN_SIGNAL_STRING
))
1043 if (!startswith (s
.get (), "cYg"))
1046 char *p
= strchr (s
.get (), '\0');
1048 if (p
> s
.get () && *--p
== '\n')
1050 warning (("%s"), s
.get ());
1056 /* Got a cygwin signal marker. A cygwin signal is followed by
1057 the signal number itself and then optionally followed by the
1058 thread id and address to saved context within the DLL. If
1059 these are supplied, then the given thread is assumed to have
1060 issued the signal and the context from the thread is assumed
1061 to be stored at the given address in the inferior. Tell gdb
1062 to treat this like a real signal. */
1064 int sig
= strtol (s
.get () + sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
1065 gdb_signal gotasig
= gdb_signal_from_host (sig
);
1067 ourstatus
->value
.sig
= gotasig
;
1073 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1074 retval
= strtoul (p
, &p
, 0);
1076 retval
= current_event
.dwThreadId
;
1077 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
1078 && ReadProcessMemory (current_process_handle
, x
,
1080 __COPY_CONTEXT_SIZE
, &n
)
1081 && n
== __COPY_CONTEXT_SIZE
)
1082 have_saved_context
= 1;
1091 display_selector (HANDLE thread
, DWORD sel
)
1097 ret
= Wow64GetThreadSelectorEntry (thread
, sel
, &info
);
1100 ret
= GetThreadSelectorEntry (thread
, sel
, &info
);
1104 printf_filtered ("0x%03x: ", (unsigned) sel
);
1105 if (!info
.HighWord
.Bits
.Pres
)
1107 puts_filtered ("Segment not present\n");
1110 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1111 (info
.HighWord
.Bits
.BaseMid
<< 16)
1113 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1114 if (info
.HighWord
.Bits
.Granularity
)
1115 limit
= (limit
<< 12) | 0xfff;
1116 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1117 if (info
.HighWord
.Bits
.Default_Big
)
1118 puts_filtered(" 32-bit ");
1120 puts_filtered(" 16-bit ");
1121 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1124 puts_filtered ("Data (Read-Only, Exp-up");
1127 puts_filtered ("Data (Read/Write, Exp-up");
1130 puts_filtered ("Unused segment (");
1133 puts_filtered ("Data (Read/Write, Exp-down");
1136 puts_filtered ("Code (Exec-Only, N.Conf");
1139 puts_filtered ("Code (Exec/Read, N.Conf");
1142 puts_filtered ("Code (Exec-Only, Conf");
1145 puts_filtered ("Code (Exec/Read, Conf");
1148 printf_filtered ("Unknown type 0x%lx",
1149 (unsigned long) info
.HighWord
.Bits
.Type
);
1151 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1152 puts_filtered(", N.Acc");
1153 puts_filtered (")\n");
1154 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1155 puts_filtered("System selector ");
1156 printf_filtered ("Priviledge level = %ld. ",
1157 (unsigned long) info
.HighWord
.Bits
.Dpl
);
1158 if (info
.HighWord
.Bits
.Granularity
)
1159 puts_filtered ("Page granular.\n");
1161 puts_filtered ("Byte granular.\n");
1166 DWORD err
= GetLastError ();
1167 if (err
== ERROR_NOT_SUPPORTED
)
1168 printf_filtered ("Function not supported\n");
1170 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1176 display_selectors (const char * args
, int from_tty
)
1178 if (!current_thread
)
1180 puts_filtered ("Impossible to display selectors now.\n");
1188 puts_filtered ("Selector $cs\n");
1189 display_selector (current_thread
->h
,
1190 current_thread
->wow64_context
.SegCs
);
1191 puts_filtered ("Selector $ds\n");
1192 display_selector (current_thread
->h
,
1193 current_thread
->wow64_context
.SegDs
);
1194 puts_filtered ("Selector $es\n");
1195 display_selector (current_thread
->h
,
1196 current_thread
->wow64_context
.SegEs
);
1197 puts_filtered ("Selector $ss\n");
1198 display_selector (current_thread
->h
,
1199 current_thread
->wow64_context
.SegSs
);
1200 puts_filtered ("Selector $fs\n");
1201 display_selector (current_thread
->h
,
1202 current_thread
->wow64_context
.SegFs
);
1203 puts_filtered ("Selector $gs\n");
1204 display_selector (current_thread
->h
,
1205 current_thread
->wow64_context
.SegGs
);
1210 puts_filtered ("Selector $cs\n");
1211 display_selector (current_thread
->h
,
1212 current_thread
->context
.SegCs
);
1213 puts_filtered ("Selector $ds\n");
1214 display_selector (current_thread
->h
,
1215 current_thread
->context
.SegDs
);
1216 puts_filtered ("Selector $es\n");
1217 display_selector (current_thread
->h
,
1218 current_thread
->context
.SegEs
);
1219 puts_filtered ("Selector $ss\n");
1220 display_selector (current_thread
->h
,
1221 current_thread
->context
.SegSs
);
1222 puts_filtered ("Selector $fs\n");
1223 display_selector (current_thread
->h
,
1224 current_thread
->context
.SegFs
);
1225 puts_filtered ("Selector $gs\n");
1226 display_selector (current_thread
->h
,
1227 current_thread
->context
.SegGs
);
1233 sel
= parse_and_eval_long (args
);
1234 printf_filtered ("Selector \"%s\"\n",args
);
1235 display_selector (current_thread
->h
, sel
);
1239 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1240 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1241 host_address_to_string (\
1242 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1244 static handle_exception_result
1245 handle_exception (struct target_waitstatus
*ourstatus
)
1247 EXCEPTION_RECORD
*rec
= ¤t_event
.u
.Exception
.ExceptionRecord
;
1248 DWORD code
= rec
->ExceptionCode
;
1249 handle_exception_result result
= HANDLE_EXCEPTION_HANDLED
;
1251 memcpy (&siginfo_er
, rec
, sizeof siginfo_er
);
1253 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1255 /* Record the context of the current thread. */
1256 thread_rec (current_event
.dwThreadId
, -1);
1260 case EXCEPTION_ACCESS_VIOLATION
:
1261 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1262 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1265 /* See if the access violation happened within the cygwin DLL
1266 itself. Cygwin uses a kind of exception handling to deal
1267 with passed-in invalid addresses. gdb should not treat
1268 these as real SEGVs since they will be silently handled by
1269 cygwin. A real SEGV will (theoretically) be caught by
1270 cygwin later in the process and will be sent as a
1271 cygwin-specific-signal. So, ignore SEGVs if they show up
1272 within the text segment of the DLL itself. */
1274 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1276 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1277 && addr
< cygwin_load_end
))
1278 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1279 && startswith (fn
, "KERNEL32!IsBad")))
1280 return HANDLE_EXCEPTION_UNHANDLED
;
1284 case STATUS_STACK_OVERFLOW
:
1285 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1286 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1288 case STATUS_FLOAT_DENORMAL_OPERAND
:
1289 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1290 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1292 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1293 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1294 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1296 case STATUS_FLOAT_INEXACT_RESULT
:
1297 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1298 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1300 case STATUS_FLOAT_INVALID_OPERATION
:
1301 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1302 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1304 case STATUS_FLOAT_OVERFLOW
:
1305 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1306 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1308 case STATUS_FLOAT_STACK_CHECK
:
1309 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1310 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1312 case STATUS_FLOAT_UNDERFLOW
:
1313 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1314 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1316 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1317 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1318 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1320 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1321 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1322 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1324 case STATUS_INTEGER_OVERFLOW
:
1325 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1326 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1328 case EXCEPTION_BREAKPOINT
:
1330 if (ignore_first_breakpoint
)
1332 /* For WOW64 processes, there are always 2 breakpoint exceptions
1333 on startup, first a BREAKPOINT for the 64bit ntdll.dll,
1334 then a WX86_BREAKPOINT for the 32bit ntdll.dll.
1335 Here we only care about the WX86_BREAKPOINT's. */
1336 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1337 ignore_first_breakpoint
= false;
1341 case STATUS_WX86_BREAKPOINT
:
1342 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1343 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1346 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1347 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1349 case DBG_CONTROL_BREAK
:
1350 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1351 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1353 case EXCEPTION_SINGLE_STEP
:
1354 case STATUS_WX86_SINGLE_STEP
:
1355 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1356 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1358 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1359 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1360 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1362 case EXCEPTION_PRIV_INSTRUCTION
:
1363 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1364 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1366 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1367 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1368 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1370 case MS_VC_EXCEPTION
:
1371 if (rec
->NumberParameters
>= 3
1372 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1374 DWORD named_thread_id
;
1375 windows_thread_info
*named_thread
;
1376 CORE_ADDR thread_name_target
;
1378 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1380 thread_name_target
= rec
->ExceptionInformation
[1];
1381 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1383 if (named_thread_id
== (DWORD
) -1)
1384 named_thread_id
= current_event
.dwThreadId
;
1386 named_thread
= thread_rec (named_thread_id
, 0);
1387 if (named_thread
!= NULL
)
1389 int thread_name_len
;
1390 gdb::unique_xmalloc_ptr
<char> thread_name
;
1392 thread_name_len
= target_read_string (thread_name_target
,
1393 &thread_name
, 1025, NULL
);
1394 if (thread_name_len
> 0)
1396 thread_name
.get ()[thread_name_len
- 1] = '\0';
1397 named_thread
->name
= std::move (thread_name
);
1400 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1401 result
= HANDLE_EXCEPTION_IGNORED
;
1404 /* treat improperly formed exception as unknown */
1407 /* Treat unhandled first chance exceptions specially. */
1408 if (current_event
.u
.Exception
.dwFirstChance
)
1409 return HANDLE_EXCEPTION_UNHANDLED
;
1410 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1411 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1412 host_address_to_string (
1413 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1414 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1418 last_sig
= ourstatus
->value
.sig
;
1422 /* Resume thread specified by ID, or all artificially suspended
1423 threads, if we are continuing execution. KILLED non-zero means we
1424 have killed the inferior, so we should ignore weird errors due to
1425 threads shutting down. */
1427 windows_continue (DWORD continue_status
, int id
, int killed
)
1431 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1432 (unsigned) current_event
.dwProcessId
,
1433 (unsigned) current_event
.dwThreadId
,
1434 continue_status
== DBG_CONTINUE
?
1435 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1437 for (windows_thread_info
*th
: thread_list
)
1438 if ((id
== -1 || id
== (int) th
->tid
)
1444 if (debug_registers_changed
)
1446 th
->wow64_context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1447 th
->wow64_context
.Dr0
= dr
[0];
1448 th
->wow64_context
.Dr1
= dr
[1];
1449 th
->wow64_context
.Dr2
= dr
[2];
1450 th
->wow64_context
.Dr3
= dr
[3];
1451 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1452 th
->wow64_context
.Dr7
= dr
[7];
1454 if (th
->wow64_context
.ContextFlags
)
1458 if (GetExitCodeThread (th
->h
, &ec
)
1459 && ec
== STILL_ACTIVE
)
1461 BOOL status
= Wow64SetThreadContext (th
->h
,
1462 &th
->wow64_context
);
1467 th
->wow64_context
.ContextFlags
= 0;
1473 if (debug_registers_changed
)
1475 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1476 th
->context
.Dr0
= dr
[0];
1477 th
->context
.Dr1
= dr
[1];
1478 th
->context
.Dr2
= dr
[2];
1479 th
->context
.Dr3
= dr
[3];
1480 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1481 th
->context
.Dr7
= dr
[7];
1483 if (th
->context
.ContextFlags
)
1487 if (GetExitCodeThread (th
->h
, &ec
)
1488 && ec
== STILL_ACTIVE
)
1490 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1495 th
->context
.ContextFlags
= 0;
1501 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1502 current_event
.dwThreadId
,
1506 error (_("Failed to resume program execution"
1507 " (ContinueDebugEvent failed, error %u)"),
1508 (unsigned int) GetLastError ());
1510 debug_registers_changed
= 0;
1514 /* Called in pathological case where Windows fails to send a
1515 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1517 fake_create_process (void)
1519 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1520 current_event
.dwProcessId
);
1521 if (current_process_handle
!= NULL
)
1522 open_process_used
= 1;
1525 error (_("OpenProcess call failed, GetLastError = %u"),
1526 (unsigned) GetLastError ());
1527 /* We can not debug anything in that case. */
1530 = windows_add_thread (ptid_t (current_event
.dwProcessId
,
1531 current_event
.dwThreadId
, 0),
1532 current_event
.u
.CreateThread
.hThread
,
1533 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1534 true /* main_thread_p */);
1535 return current_event
.dwThreadId
;
1539 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1541 windows_thread_info
*th
;
1542 DWORD continue_status
= DBG_CONTINUE
;
1544 /* A specific PTID means `step only this thread id'. */
1545 int resume_all
= ptid
== minus_one_ptid
;
1547 /* If we're continuing all threads, it's the current inferior that
1548 should be handled specially. */
1550 ptid
= inferior_ptid
;
1552 if (sig
!= GDB_SIGNAL_0
)
1554 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1556 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1558 else if (sig
== last_sig
)
1559 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1562 /* This code does not seem to work, because
1563 the kernel does probably not consider changes in the ExceptionRecord
1564 structure when passing the exception to the inferior.
1565 Note that this seems possible in the exception handler itself. */
1567 for (const xlate_exception
&x
: xlate
)
1570 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1572 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1575 if (continue_status
== DBG_CONTINUE
)
1577 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1581 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1585 last_sig
= GDB_SIGNAL_0
;
1587 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=0x%x, step=%d, sig=%d);\n",
1588 ptid
.pid (), (unsigned) ptid
.lwp (), step
, sig
));
1590 /* Get context for currently selected thread. */
1591 th
= thread_rec (inferior_ptid
.lwp (), FALSE
);
1599 /* Single step by setting t bit. */
1600 struct regcache
*regcache
= get_current_regcache ();
1601 struct gdbarch
*gdbarch
= regcache
->arch ();
1602 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1603 th
->wow64_context
.EFlags
|= FLAG_TRACE_BIT
;
1606 if (th
->wow64_context
.ContextFlags
)
1608 if (debug_registers_changed
)
1610 th
->wow64_context
.Dr0
= dr
[0];
1611 th
->wow64_context
.Dr1
= dr
[1];
1612 th
->wow64_context
.Dr2
= dr
[2];
1613 th
->wow64_context
.Dr3
= dr
[3];
1614 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1615 th
->wow64_context
.Dr7
= dr
[7];
1617 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
1618 th
->wow64_context
.ContextFlags
= 0;
1626 /* Single step by setting t bit. */
1627 struct regcache
*regcache
= get_current_regcache ();
1628 struct gdbarch
*gdbarch
= regcache
->arch ();
1629 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1630 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1633 if (th
->context
.ContextFlags
)
1635 if (debug_registers_changed
)
1637 th
->context
.Dr0
= dr
[0];
1638 th
->context
.Dr1
= dr
[1];
1639 th
->context
.Dr2
= dr
[2];
1640 th
->context
.Dr3
= dr
[3];
1641 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1642 th
->context
.Dr7
= dr
[7];
1644 CHECK (SetThreadContext (th
->h
, &th
->context
));
1645 th
->context
.ContextFlags
= 0;
1650 /* Allow continuing with the same signal that interrupted us.
1651 Otherwise complain. */
1654 windows_continue (continue_status
, -1, 0);
1656 windows_continue (continue_status
, ptid
.lwp (), 0);
1659 /* Ctrl-C handler used when the inferior is not run in the same console. The
1660 handler is in charge of interrupting the inferior using DebugBreakProcess.
1661 Note that this function is not available prior to Windows XP. In this case
1662 we emit a warning. */
1664 ctrl_c_handler (DWORD event_type
)
1666 const int attach_flag
= current_inferior ()->attach_flag
;
1668 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1669 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1672 /* If the inferior and the debugger share the same console, do nothing as
1673 the inferior has also received the Ctrl-C event. */
1674 if (!new_console
&& !attach_flag
)
1677 if (!DebugBreakProcess (current_process_handle
))
1678 warning (_("Could not interrupt program. "
1679 "Press Ctrl-c in the program console."));
1681 /* Return true to tell that Ctrl-C has been handled. */
1685 /* Get the next event from the child. Returns a non-zero thread id if the event
1686 requires handling by WFI (or whatever). */
1689 windows_nat_target::get_windows_debug_event (int pid
,
1690 struct target_waitstatus
*ourstatus
)
1693 DWORD continue_status
, event_code
;
1694 windows_thread_info
*th
;
1695 static windows_thread_info
dummy_thread_info (0, 0, 0);
1696 DWORD thread_id
= 0;
1698 last_sig
= GDB_SIGNAL_0
;
1700 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1704 continue_status
= DBG_CONTINUE
;
1706 event_code
= current_event
.dwDebugEventCode
;
1707 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1709 have_saved_context
= 0;
1713 case CREATE_THREAD_DEBUG_EVENT
:
1714 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1715 (unsigned) current_event
.dwProcessId
,
1716 (unsigned) current_event
.dwThreadId
,
1717 "CREATE_THREAD_DEBUG_EVENT"));
1718 if (saw_create
!= 1)
1720 inferior
*inf
= find_inferior_pid (this, current_event
.dwProcessId
);
1721 if (!saw_create
&& inf
->attach_flag
)
1723 /* Kludge around a Windows bug where first event is a create
1724 thread event. Caused when attached process does not have
1726 thread_id
= fake_create_process ();
1732 /* Record the existence of this thread. */
1733 thread_id
= current_event
.dwThreadId
;
1734 th
= windows_add_thread
1735 (ptid_t (current_event
.dwProcessId
, current_event
.dwThreadId
, 0),
1736 current_event
.u
.CreateThread
.hThread
,
1737 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1738 false /* main_thread_p */);
1742 case EXIT_THREAD_DEBUG_EVENT
:
1743 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1744 (unsigned) current_event
.dwProcessId
,
1745 (unsigned) current_event
.dwThreadId
,
1746 "EXIT_THREAD_DEBUG_EVENT"));
1747 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1748 current_event
.dwThreadId
, 0),
1749 current_event
.u
.ExitThread
.dwExitCode
,
1750 false /* main_thread_p */);
1751 th
= &dummy_thread_info
;
1754 case CREATE_PROCESS_DEBUG_EVENT
:
1755 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1756 (unsigned) current_event
.dwProcessId
,
1757 (unsigned) current_event
.dwThreadId
,
1758 "CREATE_PROCESS_DEBUG_EVENT"));
1759 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1760 if (++saw_create
!= 1)
1763 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1764 /* Add the main thread. */
1765 th
= windows_add_thread
1766 (ptid_t (current_event
.dwProcessId
,
1767 current_event
.dwThreadId
, 0),
1768 current_event
.u
.CreateProcessInfo
.hThread
,
1769 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
,
1770 true /* main_thread_p */);
1771 thread_id
= current_event
.dwThreadId
;
1774 case EXIT_PROCESS_DEBUG_EVENT
:
1775 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1776 (unsigned) current_event
.dwProcessId
,
1777 (unsigned) current_event
.dwThreadId
,
1778 "EXIT_PROCESS_DEBUG_EVENT"));
1779 if (!windows_initialization_done
)
1781 target_terminal::ours ();
1782 target_mourn_inferior (inferior_ptid
);
1783 error (_("During startup program exited with code 0x%x."),
1784 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1786 else if (saw_create
== 1)
1788 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1789 current_event
.dwThreadId
, 0),
1790 0, true /* main_thread_p */);
1791 DWORD exit_status
= current_event
.u
.ExitProcess
.dwExitCode
;
1792 /* If the exit status looks like a fatal exception, but we
1793 don't recognize the exception's code, make the original
1794 exit status value available, to avoid losing
1797 = WIFSIGNALED (exit_status
) ? WTERMSIG (exit_status
) : -1;
1798 if (exit_signal
== -1)
1800 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1801 ourstatus
->value
.integer
= exit_status
;
1805 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1806 ourstatus
->value
.sig
= gdb_signal_from_host (exit_signal
);
1808 thread_id
= current_event
.dwThreadId
;
1812 case LOAD_DLL_DEBUG_EVENT
:
1813 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1814 (unsigned) current_event
.dwProcessId
,
1815 (unsigned) current_event
.dwThreadId
,
1816 "LOAD_DLL_DEBUG_EVENT"));
1817 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1818 if (saw_create
!= 1 || ! windows_initialization_done
)
1820 catch_errors (handle_load_dll
);
1821 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1822 ourstatus
->value
.integer
= 0;
1823 thread_id
= current_event
.dwThreadId
;
1826 case UNLOAD_DLL_DEBUG_EVENT
:
1827 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1828 (unsigned) current_event
.dwProcessId
,
1829 (unsigned) current_event
.dwThreadId
,
1830 "UNLOAD_DLL_DEBUG_EVENT"));
1831 if (saw_create
!= 1 || ! windows_initialization_done
)
1833 catch_errors (handle_unload_dll
);
1834 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1835 ourstatus
->value
.integer
= 0;
1836 thread_id
= current_event
.dwThreadId
;
1839 case EXCEPTION_DEBUG_EVENT
:
1840 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1841 (unsigned) current_event
.dwProcessId
,
1842 (unsigned) current_event
.dwThreadId
,
1843 "EXCEPTION_DEBUG_EVENT"));
1844 if (saw_create
!= 1)
1846 switch (handle_exception (ourstatus
))
1848 case HANDLE_EXCEPTION_UNHANDLED
:
1850 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1852 case HANDLE_EXCEPTION_HANDLED
:
1853 thread_id
= current_event
.dwThreadId
;
1855 case HANDLE_EXCEPTION_IGNORED
:
1856 continue_status
= DBG_CONTINUE
;
1861 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1862 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1863 (unsigned) current_event
.dwProcessId
,
1864 (unsigned) current_event
.dwThreadId
,
1865 "OUTPUT_DEBUG_STRING_EVENT"));
1866 if (saw_create
!= 1)
1868 thread_id
= handle_output_debug_string (ourstatus
);
1872 if (saw_create
!= 1)
1874 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1875 (unsigned) current_event
.dwProcessId
,
1876 (unsigned) current_event
.dwThreadId
);
1877 printf_unfiltered (" unknown event code %u\n",
1878 (unsigned) current_event
.dwDebugEventCode
);
1882 if (!thread_id
|| saw_create
!= 1)
1884 CHECK (windows_continue (continue_status
, -1, 0));
1888 inferior_ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1889 current_thread
= th
;
1890 if (!current_thread
)
1891 current_thread
= thread_rec (thread_id
, TRUE
);
1898 /* Wait for interesting events to occur in the target process. */
1900 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1905 /* We loop when we get a non-standard exception rather than return
1906 with a SPURIOUS because resume can try and step or modify things,
1907 which needs a current_thread->h. But some of these exceptions mark
1908 the birth or death of threads, which mean that the current thread
1909 isn't necessarily what you think it is. */
1915 /* If the user presses Ctrl-c while the debugger is waiting
1916 for an event, he expects the debugger to interrupt his program
1917 and to get the prompt back. There are two possible situations:
1919 - The debugger and the program do not share the console, in
1920 which case the Ctrl-c event only reached the debugger.
1921 In that case, the ctrl_c handler will take care of interrupting
1922 the inferior. Note that this case is working starting with
1923 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1926 - The debugger and the program share the same console, in which
1927 case both debugger and inferior will receive the Ctrl-c event.
1928 In that case the ctrl_c handler will ignore the event, as the
1929 Ctrl-c event generated inside the inferior will trigger the
1930 expected debug event.
1932 FIXME: brobecker/2008-05-20: If the inferior receives the
1933 signal first and the delay until GDB receives that signal
1934 is sufficiently long, GDB can sometimes receive the SIGINT
1935 after we have unblocked the CTRL+C handler. This would
1936 lead to the debugger stopping prematurely while handling
1937 the new-thread event that comes with the handling of the SIGINT
1938 inside the inferior, and then stop again immediately when
1939 the user tries to resume the execution in the inferior.
1940 This is a classic race that we should try to fix one day. */
1941 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1942 retval
= get_windows_debug_event (pid
, ourstatus
);
1943 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1946 return ptid_t (current_event
.dwProcessId
, retval
, 0);
1951 if (deprecated_ui_loop_hook
!= NULL
)
1952 detach
= deprecated_ui_loop_hook (0);
1960 /* Iterate over all DLLs currently mapped by our inferior, and
1961 add them to our list of solibs. */
1964 windows_add_all_dlls (void)
1966 HMODULE dummy_hmodule
;
1974 if (EnumProcessModulesEx (current_process_handle
, &dummy_hmodule
,
1975 sizeof (HMODULE
), &cb_needed
,
1976 LIST_MODULES_32BIT
) == 0)
1982 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
1983 sizeof (HMODULE
), &cb_needed
) == 0)
1990 hmodules
= (HMODULE
*) alloca (cb_needed
);
1994 if (EnumProcessModulesEx (current_process_handle
, hmodules
,
1995 cb_needed
, &cb_needed
,
1996 LIST_MODULES_32BIT
) == 0)
2002 if (EnumProcessModules (current_process_handle
, hmodules
,
2003 cb_needed
, &cb_needed
) == 0)
2007 char system_dir
[__PMAX
];
2008 char syswow_dir
[__PMAX
];
2009 size_t system_dir_len
= 0;
2010 bool convert_syswow_dir
= false;
2015 /* This fails on 32bit Windows because it has no SysWOW64 directory,
2016 and in this case a path conversion isn't necessary. */
2017 UINT len
= GetSystemWow64DirectoryA (syswow_dir
, sizeof (syswow_dir
));
2020 /* Check that we have passed a large enough buffer. */
2021 gdb_assert (len
< sizeof (syswow_dir
));
2023 len
= GetSystemDirectoryA (system_dir
, sizeof (system_dir
));
2025 gdb_assert (len
!= 0);
2026 /* Check that we have passed a large enough buffer. */
2027 gdb_assert (len
< sizeof (system_dir
));
2029 strcat (system_dir
, "\\");
2030 strcat (syswow_dir
, "\\");
2031 system_dir_len
= strlen (system_dir
);
2033 convert_syswow_dir
= true;
2037 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
2041 wchar_t dll_name
[__PMAX
];
2042 char dll_name_mb
[__PMAX
];
2044 char dll_name
[__PMAX
];
2047 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
2048 &mi
, sizeof (mi
)) == 0)
2050 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
2051 dll_name
, sizeof (dll_name
)) == 0)
2054 wcstombs (dll_name_mb
, dll_name
, __PMAX
);
2059 /* Convert the DLL path of 32bit processes returned by
2060 GetModuleFileNameEx from the 64bit system directory to the
2061 32bit syswow64 directory if necessary. */
2062 std::string syswow_dll_path
;
2063 if (convert_syswow_dir
2064 && strncasecmp (name
, system_dir
, system_dir_len
) == 0
2065 && strchr (name
+ system_dir_len
, '\\') == nullptr)
2067 syswow_dll_path
= syswow_dir
;
2068 syswow_dll_path
+= name
+ system_dir_len
;
2069 name
= syswow_dll_path
.c_str();
2072 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
2073 solib_end
= solib_end
->next
;
2078 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
2081 struct inferior
*inf
;
2083 last_sig
= GDB_SIGNAL_0
;
2085 exception_count
= 0;
2086 open_process_used
= 0;
2087 debug_registers_changed
= 0;
2088 debug_registers_used
= 0;
2089 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
2092 cygwin_load_start
= cygwin_load_end
= 0;
2094 current_event
.dwProcessId
= pid
;
2095 memset (¤t_event
, 0, sizeof (current_event
));
2096 if (!target_is_pushed (ops
))
2098 disable_breakpoints_in_shlibs ();
2099 windows_clear_solib ();
2100 clear_proceed_status (0);
2101 init_wait_for_inferior ();
2104 ignore_first_breakpoint
= !attaching
&& wow64_process
;
2108 windows_set_context_register_offsets (amd64_mappings
);
2109 windows_set_segment_register_p (amd64_windows_segment_register_p
);
2114 windows_set_context_register_offsets (i386_mappings
);
2115 windows_set_segment_register_p (i386_windows_segment_register_p
);
2118 inf
= current_inferior ();
2119 inferior_appeared (inf
, pid
);
2120 inf
->attach_flag
= attaching
;
2122 /* Make the new process the current inferior, so terminal handling
2123 can rely on it. When attaching, we don't know about any thread
2124 id here, but that's OK --- nothing should be referencing the
2125 current thread until we report an event out of windows_wait. */
2126 inferior_ptid
= ptid_t (pid
);
2128 target_terminal::init ();
2129 target_terminal::inferior ();
2131 windows_initialization_done
= 0;
2135 struct target_waitstatus status
;
2137 ops
->wait (minus_one_ptid
, &status
, 0);
2139 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
2141 if (status
.kind
!= TARGET_WAITKIND_LOADED
2142 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
2145 ops
->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
2148 /* Now that the inferior has been started and all DLLs have been mapped,
2149 we can iterate over all DLLs and load them in.
2151 We avoid doing it any earlier because, on certain versions of Windows,
2152 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
2153 we have seen on Windows 8.1 that the ntdll.dll load event does not
2154 include the DLL name, preventing us from creating an associated SO.
2155 A possible explanation is that ntdll.dll might be mapped before
2156 the SO info gets created by the Windows system -- ntdll.dll is
2157 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
2158 do not seem to suffer from that problem.
2160 Rather than try to work around this sort of issue, it is much
2161 simpler to just ignore DLL load/unload events during the startup
2162 phase, and then process them all in one batch now. */
2163 windows_add_all_dlls ();
2165 windows_initialization_done
= 1;
2169 /* Try to set or remove a user privilege to the current process. Return -1
2170 if that fails, the previous setting of that privilege otherwise.
2172 This code is copied from the Cygwin source code and rearranged to allow
2173 dynamically loading of the needed symbols from advapi32 which is only
2174 available on NT/2K/XP. */
2176 set_process_privilege (const char *privilege
, BOOL enable
)
2178 HANDLE token_hdl
= NULL
;
2180 TOKEN_PRIVILEGES new_priv
, orig_priv
;
2184 if (!OpenProcessToken (GetCurrentProcess (),
2185 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
2189 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
2192 new_priv
.PrivilegeCount
= 1;
2193 new_priv
.Privileges
[0].Luid
= restore_priv
;
2194 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
2196 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
2197 sizeof orig_priv
, &orig_priv
, &size
))
2200 /* Disabled, otherwise every `attach' in an unprivileged user session
2201 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
2202 windows_attach(). */
2203 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
2204 be enabled. GetLastError () returns an correct error code, though. */
2205 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
2209 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
2213 CloseHandle (token_hdl
);
2218 /* Attach to process PID, then initialize for debugging it. */
2221 windows_nat_target::attach (const char *args
, int from_tty
)
2226 pid
= parse_pid_to_attach (args
);
2228 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
2230 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
2231 printf_unfiltered ("This can cause attach to "
2232 "fail on Windows NT/2K/XP\n");
2235 windows_init_thread_list ();
2236 ok
= DebugActiveProcess (pid
);
2242 /* Try fall back to Cygwin pid. */
2243 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
2246 ok
= DebugActiveProcess (pid
);
2251 error (_("Can't attach to process %u (error %u)"),
2252 (unsigned) pid
, (unsigned) GetLastError ());
2254 DebugSetProcessKillOnExit (FALSE
);
2258 const char *exec_file
= get_exec_file (0);
2261 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
2262 target_pid_to_str (ptid_t (pid
)).c_str ());
2264 printf_unfiltered ("Attaching to %s\n",
2265 target_pid_to_str (ptid_t (pid
)).c_str ());
2269 HANDLE h
= OpenProcess (PROCESS_QUERY_INFORMATION
, FALSE
, pid
);
2273 if (IsWow64Process (h
, &wow64
))
2274 wow64_process
= wow64
;
2279 do_initial_windows_stuff (this, pid
, 1);
2280 target_terminal::ours ();
2284 windows_nat_target::detach (inferior
*inf
, int from_tty
)
2288 ptid_t ptid
= minus_one_ptid
;
2289 resume (ptid
, 0, GDB_SIGNAL_0
);
2291 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
2293 error (_("Can't detach process %u (error %u)"),
2294 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
2297 DebugSetProcessKillOnExit (FALSE
);
2299 if (detached
&& from_tty
)
2301 const char *exec_file
= get_exec_file (0);
2304 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
2305 (unsigned) current_event
.dwProcessId
);
2308 x86_cleanup_dregs ();
2309 inferior_ptid
= null_ptid
;
2310 detach_inferior (inf
);
2312 maybe_unpush_target ();
2315 /* Try to determine the executable filename.
2317 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2319 Upon success, the filename is stored inside EXE_NAME_RET, and
2320 this function returns nonzero.
2322 Otherwise, this function returns zero and the contents of
2323 EXE_NAME_RET is undefined. */
2326 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2336 if (!EnumProcessModulesEx (current_process_handle
, &dh_buf
,
2337 sizeof (HMODULE
), &cbNeeded
,
2338 LIST_MODULES_32BIT
) || !cbNeeded
)
2344 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2345 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2349 /* We know the executable is always first in the list of modules,
2350 which we just fetched. So no need to fetch more. */
2354 /* Cygwin prefers that the path be in /x/y/z format, so extract
2355 the filename into a temporary buffer first, and then convert it
2356 to POSIX format into the destination buffer. */
2357 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2359 len
= GetModuleFileNameEx (current_process_handle
,
2360 dh_buf
, pathbuf
, exe_name_max_len
);
2362 error (_("Error getting executable filename: %u."),
2363 (unsigned) GetLastError ());
2364 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2365 exe_name_max_len
) < 0)
2366 error (_("Error converting executable filename to POSIX: %d."), errno
);
2369 len
= GetModuleFileNameEx (current_process_handle
,
2370 dh_buf
, exe_name_ret
, exe_name_max_len
);
2372 error (_("Error getting executable filename: %u."),
2373 (unsigned) GetLastError ());
2376 return 1; /* success */
2379 /* The pid_to_exec_file target_ops method for this platform. */
2382 windows_nat_target::pid_to_exec_file (int pid
)
2384 static char path
[__PMAX
];
2386 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2388 char procexe
[sizeof ("/proc/4294967295/exe")];
2390 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2391 nchars
= readlink (procexe
, path
, sizeof(path
));
2392 if (nchars
> 0 && nchars
< sizeof (path
))
2394 path
[nchars
] = '\0'; /* Got it */
2399 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2400 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2401 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2407 /* Print status information about what we're accessing. */
2410 windows_nat_target::files_info ()
2412 struct inferior
*inf
= current_inferior ();
2414 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2415 inf
->attach_flag
? "attached" : "child",
2416 target_pid_to_str (inferior_ptid
).c_str ());
2419 /* Modify CreateProcess parameters for use of a new separate console.
2421 *FLAGS: DWORD parameter for general process creation flags.
2422 *SI: STARTUPINFO structure, for which the console window size and
2423 console buffer size is filled in if GDB is running in a console.
2424 to create the new console.
2425 The size of the used font is not available on all versions of
2426 Windows OS. Furthermore, the current font might not be the default
2427 font, but this is still better than before.
2428 If the windows and buffer sizes are computed,
2429 SI->DWFLAGS is changed so that this information is used
2430 by CreateProcess function. */
2433 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2435 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2436 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2438 if (hconsole
!= INVALID_HANDLE_VALUE
)
2440 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2442 CONSOLE_FONT_INFO cfi
;
2444 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2445 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2446 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2447 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2448 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2450 si
->dwXSize
*= font_size
.X
;
2454 si
->dwYSize
*= font_size
.Y
;
2457 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2458 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2459 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2461 *flags
|= CREATE_NEW_CONSOLE
;
2465 /* Function called by qsort to sort environment strings. */
2468 envvar_cmp (const void *a
, const void *b
)
2470 const char **p
= (const char **) a
;
2471 const char **q
= (const char **) b
;
2472 return strcasecmp (*p
, *q
);
2478 clear_win32_environment (char **env
)
2482 wchar_t *copy
= NULL
, *equalpos
;
2484 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2486 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2487 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2488 mbstowcs (copy
, env
[i
], len
);
2489 equalpos
= wcschr (copy
, L
'=');
2492 SetEnvironmentVariableW (copy
, NULL
);
2500 /* Redirection of inferior I/O streams for native MS-Windows programs.
2501 Unlike on Unix, where this is handled by invoking the inferior via
2502 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2504 The official documentation of the cmd.exe redirection features is here:
2506 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2508 (That page talks about Windows XP, but there's no newer
2509 documentation, so we assume later versions of cmd.exe didn't change
2512 Caveat: the documentation on that page seems to include a few lies.
2513 For example, it describes strange constructs 1<&2 and 2<&1, which
2514 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2515 think the cmd.exe parser of the redirection symbols simply doesn't
2516 care about the < vs > distinction in these cases. Therefore, the
2517 supported features are explicitly documented below.
2519 The emulation below aims at supporting all the valid use cases
2520 supported by cmd.exe, which include:
2522 < FILE redirect standard input from FILE
2523 0< FILE redirect standard input from FILE
2524 <&N redirect standard input from file descriptor N
2525 0<&N redirect standard input from file descriptor N
2526 > FILE redirect standard output to FILE
2527 >> FILE append standard output to FILE
2528 1>> FILE append standard output to FILE
2529 >&N redirect standard output to file descriptor N
2530 1>&N redirect standard output to file descriptor N
2531 >>&N append standard output to file descriptor N
2532 1>>&N append standard output to file descriptor N
2533 2> FILE redirect standard error to FILE
2534 2>> FILE append standard error to FILE
2535 2>&N redirect standard error to file descriptor N
2536 2>>&N append standard error to file descriptor N
2538 Note that using N > 2 in the above construct is supported, but
2539 requires that the corresponding file descriptor be open by some
2540 means elsewhere or outside GDB. Also note that using ">&0" or
2541 "<&2" will generally fail, because the file descriptor redirected
2542 from is normally open in an incompatible mode (e.g., FD 0 is open
2543 for reading only). IOW, use of such tricks is not recommended;
2544 you are on your own.
2546 We do NOT support redirection of file descriptors above 2, as in
2547 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2548 that needs special handling in the startup code that MinGW
2549 doesn't have). Pipes are also not supported.
2551 As for invalid use cases, where the redirection contains some
2552 error, the emulation below will detect that and produce some
2553 error and/or failure. But the behavior in those cases is not
2554 bug-for-bug compatible with what cmd.exe does in those cases.
2555 That's because what cmd.exe does then is not well defined, and
2556 seems to be a side effect of the cmd.exe parsing of the command
2557 line more than anything else. For example, try redirecting to an
2558 invalid file name, as in "> foo:bar".
2560 There are also minor syntactic deviations from what cmd.exe does
2561 in some corner cases. For example, it doesn't support the likes
2562 of "> &foo" to mean redirect to file named literally "&foo"; we
2563 do support that here, because that, too, sounds like some issue
2564 with the cmd.exe parser. Another nicety is that we support
2565 redirection targets that use file names with forward slashes,
2566 something cmd.exe doesn't -- this comes in handy since GDB
2567 file-name completion can be used when typing the command line for
2570 /* Support routines for redirecting standard handles of the inferior. */
2572 /* Parse a single redirection spec, open/duplicate the specified
2573 file/fd, and assign the appropriate value to one of the 3 standard
2574 file descriptors. */
2576 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2578 int *fd
, ref_fd
= -2;
2580 const char *fname
= redir_string
+ 1;
2581 int rc
= *redir_string
;
2596 fd
= (rc
== '2') ? err
: out
;
2597 mode
= O_WRONLY
| O_CREAT
;
2610 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2612 /* A reference to a file descriptor. */
2614 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2615 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2617 /* Don't allow redirection when open modes are incompatible. */
2618 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2619 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2626 else if (ref_fd
== 1)
2628 else if (ref_fd
== 2)
2638 fname
++; /* skip the separator space */
2639 /* If the descriptor is already open, close it. This allows
2640 multiple specs of redirections for the same stream, which is
2641 somewhat nonsensical, but still valid and supported by cmd.exe.
2642 (But cmd.exe only opens a single file in this case, the one
2643 specified by the last redirection spec on the command line.) */
2648 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2652 else if (ref_fd
== -1)
2653 *fd
= -1; /* reset to default destination */
2656 *fd
= _dup (ref_fd
);
2660 /* _open just sets a flag for O_APPEND, which won't be passed to the
2661 inferior, so we need to actually move the file pointer. */
2662 if ((mode
& O_APPEND
) != 0)
2663 _lseek (*fd
, 0L, SEEK_END
);
2667 /* Canonicalize a single redirection spec and set up the corresponding
2668 file descriptor as specified. */
2670 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2672 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2674 const char *start
= s
;
2677 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2678 if ((*start
== '>' || *start
== '1' || *start
== '2')
2682 if (*s
== '>' && *start
!= '>')
2685 else if (*start
== '0' && *s
== '<')
2687 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2690 while (isspace (*s
)) /* skip whitespace before file name */
2692 *d
++ = ' '; /* separate file name with a single space */
2695 /* Copy the file name. */
2698 /* Remove quoting characters from the file name in buf[]. */
2699 if (*s
== '"') /* could support '..' quoting here */
2703 else if (*s
== quote
)
2711 else if (*s
== '\\')
2713 if (s
[1] == '"') /* could support '..' here */
2717 else if (isspace (*s
) && !quote
)
2721 if (d
- buf
>= sizeof (buf
) - 1)
2723 errno
= ENAMETOOLONG
;
2729 /* Windows doesn't allow redirection characters in file names, so we
2730 can bail out early if they use them, or if there's no target file
2731 name after the redirection symbol. */
2732 if (d
[-1] == '>' || d
[-1] == '<')
2737 if (redir_open (buf
, inp
, out
, err
) == 0)
2742 /* Parse the command line for redirection specs and prepare the file
2743 descriptors for the 3 standard streams accordingly. */
2745 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2746 int *inp
, int *out
, int *err
)
2748 const char *s
= cmd_orig
;
2751 bool retval
= false;
2753 while (isspace (*s
))
2758 if (*s
== '"') /* could also support '..' quoting here */
2762 else if (*s
== quote
)
2765 else if (*s
== '\\')
2767 if (s
[1] == '"') /* escaped quote char */
2772 /* Process a single redirection candidate. */
2773 if (*s
== '<' || *s
== '>'
2774 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2775 || (*s
== '0' && s
[1] == '<'))
2777 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2791 #endif /* !__CYGWIN__ */
2793 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2794 EXEC_FILE is the file to run.
2795 ALLARGS is a string containing the arguments to the program.
2796 ENV is the environment vector to pass. Errors reported with error(). */
2799 windows_nat_target::create_inferior (const char *exec_file
,
2800 const std::string
&origallargs
,
2801 char **in_env
, int from_tty
)
2805 cygwin_buf_t real_path
[__PMAX
];
2806 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2807 cygwin_buf_t infcwd
[__PMAX
];
2809 cygwin_buf_t
*toexec
;
2810 cygwin_buf_t
*cygallargs
;
2812 char **old_env
= NULL
;
2816 int ostdin
, ostdout
, ostderr
;
2817 #else /* !__CYGWIN__ */
2818 char shell
[__PMAX
]; /* Path to shell */
2820 char *args
, *allargs_copy
;
2821 size_t args_len
, allargs_len
;
2822 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2823 HANDLE tty
= INVALID_HANDLE_VALUE
;
2824 bool redirected
= false;
2831 #endif /* !__CYGWIN__ */
2832 const char *allargs
= origallargs
.c_str ();
2833 PROCESS_INFORMATION pi
;
2836 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2839 error (_("No executable specified, use `target exec'."));
2841 const char *inferior_cwd
= get_inferior_cwd ();
2842 std::string expanded_infcwd
;
2843 if (inferior_cwd
!= NULL
)
2845 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
2846 /* Mirror slashes on inferior's cwd. */
2847 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
2849 inferior_cwd
= expanded_infcwd
.c_str ();
2852 memset (&si
, 0, sizeof (si
));
2853 si
.cb
= sizeof (si
);
2856 flags
|= CREATE_NEW_PROCESS_GROUP
;
2859 windows_set_console_info (&si
, &flags
);
2864 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2865 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2866 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2867 error (_("Error starting executable: %d"), errno
);
2870 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2871 if (len
== (size_t) -1)
2872 error (_("Error starting executable: %d"), errno
);
2873 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2874 mbstowcs (cygallargs
, allargs
, len
);
2875 #else /* !__USEWIDE */
2876 cygallargs
= allargs
;
2882 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2883 error (_("Error starting executable via shell: %d"), errno
);
2885 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2886 + mbstowcs (NULL
, allargs
, 0) + 2;
2887 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2888 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2889 #else /* !__USEWIDE */
2890 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2891 + strlen (allargs
) + 2);
2892 cygallargs
= (char *) alloca (len
);
2893 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2894 #endif /* __USEWIDE */
2896 flags
|= DEBUG_PROCESS
;
2899 if (inferior_cwd
!= NULL
2900 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
2901 infcwd
, strlen (inferior_cwd
)) < 0)
2902 error (_("Error converting inferior cwd: %d"), errno
);
2905 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2906 * sizeof (wchar_t));
2907 wcscpy (args
, toexec
);
2908 wcscat (args
, L
" ");
2909 wcscat (args
, cygallargs
);
2910 #else /* !__USEWIDE */
2911 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2912 strcpy (args
, toexec
);
2914 strcat (args
, cygallargs
);
2915 #endif /* !__USEWIDE */
2917 #ifdef CW_CVT_ENV_TO_WINENV
2918 /* First try to create a direct Win32 copy of the POSIX environment. */
2919 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2920 if (w32_env
!= (PWCHAR
) -1)
2921 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2923 /* If that fails, fall back to old method tweaking GDB's environment. */
2924 #endif /* CW_CVT_ENV_TO_WINENV */
2926 /* Reset all Win32 environment variables to avoid leftover on next run. */
2927 clear_win32_environment (environ
);
2928 /* Prepare the environment vars for CreateProcess. */
2931 cygwin_internal (CW_SYNC_WINENV
);
2935 if (!inferior_io_terminal
)
2936 tty
= ostdin
= ostdout
= ostderr
= -1;
2939 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2942 print_sys_errmsg (inferior_io_terminal
, errno
);
2943 ostdin
= ostdout
= ostderr
= -1;
2956 windows_init_thread_list ();
2957 ret
= CreateProcess (0,
2958 args
, /* command line */
2959 NULL
, /* Security */
2961 TRUE
, /* inherit handles */
2962 flags
, /* start flags */
2963 w32_env
, /* environment */
2964 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
2969 /* Just free the Win32 environment, if it could be created. */
2973 /* Reset all environment variables to avoid leftover on next run. */
2974 clear_win32_environment (in_env
);
2975 /* Restore normal GDB environment variables. */
2977 cygwin_internal (CW_SYNC_WINENV
);
2990 #else /* !__CYGWIN__ */
2991 allargs_len
= strlen (allargs
);
2992 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
2993 if (strpbrk (allargs_copy
, "<>") != NULL
)
2998 redirect_inferior_handles (allargs
, allargs_copy
,
2999 &fd_inp
, &fd_out
, &fd_err
);
3001 warning (_("Error in redirection: %s."), safe_strerror (errno
));
3004 allargs_len
= strlen (allargs_copy
);
3006 /* If not all the standard streams are redirected by the command
3007 line, use inferior_io_terminal for those which aren't. */
3008 if (inferior_io_terminal
3009 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
3011 SECURITY_ATTRIBUTES sa
;
3012 sa
.nLength
= sizeof(sa
);
3013 sa
.lpSecurityDescriptor
= 0;
3014 sa
.bInheritHandle
= TRUE
;
3015 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
3016 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
3017 if (tty
== INVALID_HANDLE_VALUE
)
3018 warning (_("Warning: Failed to open TTY %s, error %#x."),
3019 inferior_io_terminal
, (unsigned) GetLastError ());
3021 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
3024 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
3025 else if (tty
!= INVALID_HANDLE_VALUE
)
3028 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
3030 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
3031 else if (tty
!= INVALID_HANDLE_VALUE
)
3032 si
.hStdOutput
= tty
;
3034 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
3036 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
3037 else if (tty
!= INVALID_HANDLE_VALUE
)
3040 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
3041 si
.dwFlags
|= STARTF_USESTDHANDLES
;
3045 /* Build the command line, a space-separated list of tokens where
3046 the first token is the name of the module to be executed.
3047 To avoid ambiguities introduced by spaces in the module name,
3049 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
3050 args
= (char *) alloca (args_len
);
3051 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
3053 flags
|= DEBUG_ONLY_THIS_PROCESS
;
3055 /* CreateProcess takes the environment list as a null terminated set of
3056 strings (i.e. two nulls terminate the list). */
3058 /* Get total size for env strings. */
3059 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
3060 envlen
+= strlen (in_env
[i
]) + 1;
3062 envsize
= sizeof (in_env
[0]) * (i
+ 1);
3063 env
= (char **) alloca (envsize
);
3064 memcpy (env
, in_env
, envsize
);
3065 /* Windows programs expect the environment block to be sorted. */
3066 qsort (env
, i
, sizeof (char *), envvar_cmp
);
3068 w32env
= (char *) alloca (envlen
+ 1);
3070 /* Copy env strings into new buffer. */
3071 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
3073 strcpy (temp
, env
[i
]);
3074 temp
+= strlen (temp
) + 1;
3077 /* Final nil string to terminate new env. */
3080 windows_init_thread_list ();
3081 ret
= CreateProcessA (0,
3082 args
, /* command line */
3083 NULL
, /* Security */
3085 TRUE
, /* inherit handles */
3086 flags
, /* start flags */
3087 w32env
, /* environment */
3088 inferior_cwd
, /* current directory */
3091 if (tty
!= INVALID_HANDLE_VALUE
)
3099 #endif /* !__CYGWIN__ */
3102 error (_("Error creating process %s, (error %u)."),
3103 exec_file
, (unsigned) GetLastError ());
3107 if (IsWow64Process (pi
.hProcess
, &wow64
))
3108 wow64_process
= wow64
;
3111 CloseHandle (pi
.hThread
);
3112 CloseHandle (pi
.hProcess
);
3114 if (useshell
&& shell
[0] != '\0')
3119 do_initial_windows_stuff (this, pi
.dwProcessId
, 0);
3121 /* windows_continue (DBG_CONTINUE, -1, 0); */
3125 windows_nat_target::mourn_inferior ()
3127 (void) windows_continue (DBG_CONTINUE
, -1, 0);
3128 x86_cleanup_dregs();
3129 if (open_process_used
)
3131 CHECK (CloseHandle (current_process_handle
));
3132 open_process_used
= 0;
3134 siginfo_er
.ExceptionCode
= 0;
3135 inf_child_target::mourn_inferior ();
3138 /* Send a SIGINT to the process group. This acts just like the user typed a
3139 ^C on the controlling terminal. */
3142 windows_nat_target::interrupt ()
3144 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
3145 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
3146 registers_changed (); /* refresh register state */
3149 /* Helper for windows_xfer_partial that handles memory transfers.
3150 Arguments are like target_xfer_partial. */
3152 static enum target_xfer_status
3153 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3154 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
3158 DWORD lasterror
= 0;
3160 if (writebuf
!= NULL
)
3162 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
3163 pulongest (len
), core_addr_to_string (memaddr
)));
3164 success
= WriteProcessMemory (current_process_handle
,
3165 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
3168 lasterror
= GetLastError ();
3169 FlushInstructionCache (current_process_handle
,
3170 (LPCVOID
) (uintptr_t) memaddr
, len
);
3174 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
3175 pulongest (len
), core_addr_to_string (memaddr
)));
3176 success
= ReadProcessMemory (current_process_handle
,
3177 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
3180 lasterror
= GetLastError ();
3182 *xfered_len
= (ULONGEST
) done
;
3183 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
3184 return TARGET_XFER_OK
;
3186 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
3190 windows_nat_target::kill ()
3192 CHECK (TerminateProcess (current_process_handle
, 0));
3196 if (!windows_continue (DBG_CONTINUE
, -1, 1))
3198 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
3200 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
3204 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
3208 windows_nat_target::close ()
3210 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
3211 inferior_ptid
.pid ()));
3214 /* Convert pid to printable format. */
3216 windows_nat_target::pid_to_str (ptid_t ptid
)
3218 if (ptid
.lwp () != 0)
3219 return string_printf ("Thread %d.0x%lx", ptid
.pid (), ptid
.lwp ());
3221 return normal_pid_to_str (ptid
);
3224 static enum target_xfer_status
3225 windows_xfer_shared_libraries (struct target_ops
*ops
,
3226 enum target_object object
, const char *annex
,
3227 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3228 ULONGEST offset
, ULONGEST len
,
3229 ULONGEST
*xfered_len
)
3231 struct obstack obstack
;
3237 return TARGET_XFER_E_IO
;
3239 obstack_init (&obstack
);
3240 obstack_grow_str (&obstack
, "<library-list>\n");
3241 for (so
= solib_start
.next
; so
; so
= so
->next
)
3243 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
3245 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
3246 (uintptr_t) li
->load_addr
,
3248 target_gdbarch (), &obstack
);
3250 obstack_grow_str0 (&obstack
, "</library-list>\n");
3252 buf
= (const char *) obstack_finish (&obstack
);
3253 len_avail
= strlen (buf
);
3254 if (offset
>= len_avail
)
3258 if (len
> len_avail
- offset
)
3259 len
= len_avail
- offset
;
3260 memcpy (readbuf
, buf
+ offset
, len
);
3263 obstack_free (&obstack
, NULL
);
3264 *xfered_len
= (ULONGEST
) len
;
3265 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
3268 /* Helper for windows_nat_target::xfer_partial that handles signal info. */
3270 static enum target_xfer_status
3271 windows_xfer_siginfo (gdb_byte
*readbuf
, ULONGEST offset
, ULONGEST len
,
3272 ULONGEST
*xfered_len
)
3274 char *buf
= (char *) &siginfo_er
;
3275 size_t bufsize
= sizeof (siginfo_er
);
3278 EXCEPTION_RECORD32 er32
;
3281 buf
= (char *) &er32
;
3282 bufsize
= sizeof (er32
);
3284 er32
.ExceptionCode
= siginfo_er
.ExceptionCode
;
3285 er32
.ExceptionFlags
= siginfo_er
.ExceptionFlags
;
3286 er32
.ExceptionRecord
= (uintptr_t) siginfo_er
.ExceptionRecord
;
3287 er32
.ExceptionAddress
= (uintptr_t) siginfo_er
.ExceptionAddress
;
3288 er32
.NumberParameters
= siginfo_er
.NumberParameters
;
3290 for (i
= 0; i
< EXCEPTION_MAXIMUM_PARAMETERS
; i
++)
3291 er32
.ExceptionInformation
[i
] = siginfo_er
.ExceptionInformation
[i
];
3295 if (siginfo_er
.ExceptionCode
== 0)
3296 return TARGET_XFER_E_IO
;
3298 if (readbuf
== nullptr)
3299 return TARGET_XFER_E_IO
;
3301 if (offset
> bufsize
)
3302 return TARGET_XFER_E_IO
;
3304 if (offset
+ len
> bufsize
)
3305 len
= bufsize
- offset
;
3307 memcpy (readbuf
, buf
+ offset
, len
);
3310 return TARGET_XFER_OK
;
3313 enum target_xfer_status
3314 windows_nat_target::xfer_partial (enum target_object object
,
3315 const char *annex
, gdb_byte
*readbuf
,
3316 const gdb_byte
*writebuf
, ULONGEST offset
,
3317 ULONGEST len
, ULONGEST
*xfered_len
)
3321 case TARGET_OBJECT_MEMORY
:
3322 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
3324 case TARGET_OBJECT_LIBRARIES
:
3325 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
3326 writebuf
, offset
, len
, xfered_len
);
3328 case TARGET_OBJECT_SIGNAL_INFO
:
3329 return windows_xfer_siginfo (readbuf
, offset
, len
, xfered_len
);
3332 if (beneath () == NULL
)
3334 /* This can happen when requesting the transfer of unsupported
3335 objects before a program has been started (and therefore
3336 with the current_target having no target beneath). */
3337 return TARGET_XFER_E_IO
;
3339 return beneath ()->xfer_partial (object
, annex
,
3340 readbuf
, writebuf
, offset
, len
,
3345 /* Provide thread local base, i.e. Thread Information Block address.
3346 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
3349 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
3351 windows_thread_info
*th
;
3353 th
= thread_rec (ptid
.lwp (), 0);
3358 *addr
= th
->thread_local_base
;
3364 windows_nat_target::get_ada_task_ptid (long lwp
, long thread
)
3366 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
3369 /* Implementation of the to_thread_name method. */
3372 windows_nat_target::thread_name (struct thread_info
*thr
)
3374 return thread_rec (thr
->ptid
.lwp (), 0)->name
.get ();
3378 void _initialize_windows_nat ();
3380 _initialize_windows_nat ()
3382 x86_dr_low
.set_control
= cygwin_set_dr7
;
3383 x86_dr_low
.set_addr
= cygwin_set_dr
;
3384 x86_dr_low
.get_addr
= cygwin_get_dr
;
3385 x86_dr_low
.get_status
= cygwin_get_dr6
;
3386 x86_dr_low
.get_control
= cygwin_get_dr7
;
3388 /* x86_dr_low.debug_register_length field is set by
3389 calling x86_set_debug_register_length function
3390 in processor windows specific native file. */
3392 add_inf_child_target (&the_windows_nat_target
);
3395 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3398 add_com ("signal-event", class_run
, signal_event_command
, _("\
3399 Signal a crashed process with event ID, to allow its debugging.\n\
3400 This command is needed in support of setting up GDB as JIT debugger on \
3401 MS-Windows. The command should be invoked from the GDB command line using \
3402 the '-ex' command-line option. The ID of the event that blocks the \
3403 crashed process will be supplied by the Windows JIT debugging mechanism."));
3406 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3407 Set use of shell to start subprocess."), _("\
3408 Show use of shell to start subprocess."), NULL
,
3410 NULL
, /* FIXME: i18n: */
3411 &setlist
, &showlist
);
3413 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3414 &cygwin_exceptions
, _("\
3415 Break when an exception is detected in the Cygwin DLL itself."), _("\
3416 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3418 NULL
, /* FIXME: i18n: */
3419 &setlist
, &showlist
);
3422 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3423 Set creation of new console when creating child process."), _("\
3424 Show creation of new console when creating child process."), NULL
,
3426 NULL
, /* FIXME: i18n: */
3427 &setlist
, &showlist
);
3429 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3430 Set creation of new group when creating child process."), _("\
3431 Show creation of new group when creating child process."), NULL
,
3433 NULL
, /* FIXME: i18n: */
3434 &setlist
, &showlist
);
3436 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3437 Set whether to display execution in child process."), _("\
3438 Show whether to display execution in child process."), NULL
,
3440 NULL
, /* FIXME: i18n: */
3441 &setlist
, &showlist
);
3443 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3444 Set whether to display kernel events in child process."), _("\
3445 Show whether to display kernel events in child process."), NULL
,
3447 NULL
, /* FIXME: i18n: */
3448 &setlist
, &showlist
);
3450 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3451 Set whether to display memory accesses in child process."), _("\
3452 Show whether to display memory accesses in child process."), NULL
,
3454 NULL
, /* FIXME: i18n: */
3455 &setlist
, &showlist
);
3457 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3458 &debug_exceptions
, _("\
3459 Set whether to display kernel exceptions in child process."), _("\
3460 Show whether to display kernel exceptions in child process."), NULL
,
3462 NULL
, /* FIXME: i18n: */
3463 &setlist
, &showlist
);
3465 init_w32_command_list ();
3467 add_cmd ("selector", class_info
, display_selectors
,
3468 _("Display selectors infos."),
3472 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3474 /* Pass the address ADDR to the inferior in the I'th debug register.
3475 Here we just store the address in dr array, the registers will be
3476 actually set up when windows_continue is called. */
3478 cygwin_set_dr (int i
, CORE_ADDR addr
)
3481 internal_error (__FILE__
, __LINE__
,
3482 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3484 debug_registers_changed
= 1;
3485 debug_registers_used
= 1;
3488 /* Pass the value VAL to the inferior in the DR7 debug control
3489 register. Here we just store the address in D_REGS, the watchpoint
3490 will be actually set up in windows_wait. */
3492 cygwin_set_dr7 (unsigned long val
)
3494 dr
[7] = (CORE_ADDR
) val
;
3495 debug_registers_changed
= 1;
3496 debug_registers_used
= 1;
3499 /* Get the value of debug register I from the inferior. */
3502 cygwin_get_dr (int i
)
3507 /* Get the value of the DR6 debug status register from the inferior.
3508 Here we just return the value stored in dr[6]
3509 by the last call to thread_rec for current_event.dwThreadId id. */
3510 static unsigned long
3511 cygwin_get_dr6 (void)
3513 return (unsigned long) dr
[6];
3516 /* Get the value of the DR7 debug status register from the inferior.
3517 Here we just return the value stored in dr[7] by the last call to
3518 thread_rec for current_event.dwThreadId id. */
3520 static unsigned long
3521 cygwin_get_dr7 (void)
3523 return (unsigned long) dr
[7];
3526 /* Determine if the thread referenced by "ptid" is alive
3527 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3528 it means that the thread has died. Otherwise it is assumed to be alive. */
3531 windows_nat_target::thread_alive (ptid_t ptid
)
3535 gdb_assert (ptid
.lwp () != 0);
3538 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) != WAIT_OBJECT_0
;
3541 void _initialize_check_for_gdb_ini ();
3543 _initialize_check_for_gdb_ini ()
3546 if (inhibit_gdbinit
)
3549 homedir
= getenv ("HOME");
3553 char *oldini
= (char *) alloca (strlen (homedir
) +
3554 sizeof ("gdb.ini") + 1);
3555 strcpy (oldini
, homedir
);
3556 p
= strchr (oldini
, '\0');
3557 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3559 strcpy (p
, "gdb.ini");
3560 if (access (oldini
, 0) == 0)
3562 int len
= strlen (oldini
);
3563 char *newini
= (char *) alloca (len
+ 2);
3565 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3566 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3567 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3572 /* Define dummy functions which always return error for the rare cases where
3573 these functions could not be found. */
3575 bad_DebugActiveProcessStop (DWORD w
)
3580 bad_DebugBreakProcess (HANDLE w
)
3585 bad_DebugSetProcessKillOnExit (BOOL w
)
3590 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3597 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3603 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3610 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3616 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3622 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3628 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3636 /* Load any functions which may not be available in ancient versions
3639 void _initialize_loadable ();
3641 _initialize_loadable ()
3645 #define GPA(m, func) \
3646 func = (func ## _ftype *) GetProcAddress (m, #func)
3648 hm
= LoadLibrary ("kernel32.dll");
3651 GPA (hm
, DebugActiveProcessStop
);
3652 GPA (hm
, DebugBreakProcess
);
3653 GPA (hm
, DebugSetProcessKillOnExit
);
3654 GPA (hm
, GetConsoleFontSize
);
3655 GPA (hm
, DebugActiveProcessStop
);
3656 GPA (hm
, GetCurrentConsoleFont
);
3658 GPA (hm
, Wow64SuspendThread
);
3659 GPA (hm
, Wow64GetThreadContext
);
3660 GPA (hm
, Wow64SetThreadContext
);
3661 GPA (hm
, Wow64GetThreadSelectorEntry
);
3665 /* Set variables to dummy versions of these processes if the function
3666 wasn't found in kernel32.dll. */
3667 if (!DebugBreakProcess
)
3668 DebugBreakProcess
= bad_DebugBreakProcess
;
3669 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3671 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3672 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3674 if (!GetConsoleFontSize
)
3675 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3676 if (!GetCurrentConsoleFont
)
3677 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3679 /* Load optional functions used for retrieving filename information
3680 associated with the currently debugged process or its dlls. */
3681 hm
= LoadLibrary ("psapi.dll");
3684 GPA (hm
, EnumProcessModules
);
3686 GPA (hm
, EnumProcessModulesEx
);
3688 GPA (hm
, GetModuleInformation
);
3689 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3690 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3693 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3695 /* Set variables to dummy versions of these processes if the function
3696 wasn't found in psapi.dll. */
3697 EnumProcessModules
= bad_EnumProcessModules
;
3698 GetModuleInformation
= bad_GetModuleInformation
;
3699 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3700 /* This will probably fail on Windows 9x/Me. Let the user know
3701 that we're missing some functionality. */
3703 cannot automatically find executable file or library to read symbols.\n\
3704 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3707 hm
= LoadLibrary ("advapi32.dll");
3710 GPA (hm
, OpenProcessToken
);
3711 GPA (hm
, LookupPrivilegeValueA
);
3712 GPA (hm
, AdjustTokenPrivileges
);
3713 /* Only need to set one of these since if OpenProcessToken fails nothing
3715 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3716 || !AdjustTokenPrivileges
)
3717 OpenProcessToken
= bad_OpenProcessToken
;