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"
74 #include "gdbsupport/symbol.h"
76 using namespace windows_nat
;
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 string sent by cygwin when it processes a signal.
215 FIXME: This should be in a cygwin include file. */
216 #ifndef _CYGWIN_SIGNAL_STRING
217 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
220 #define CHECK(x) check (x, __FILE__,__LINE__)
221 #define DEBUG_EXEC(x) if (debug_exec) debug_printf x
222 #define DEBUG_EVENTS(x) if (debug_events) debug_printf x
223 #define DEBUG_MEM(x) if (debug_memory) debug_printf x
224 #define DEBUG_EXCEPT(x) if (debug_exceptions) debug_printf x
226 static void cygwin_set_dr (int i
, CORE_ADDR addr
);
227 static void cygwin_set_dr7 (unsigned long val
);
228 static CORE_ADDR
cygwin_get_dr (int i
);
229 static unsigned long cygwin_get_dr6 (void);
230 static unsigned long cygwin_get_dr7 (void);
232 static std::vector
<windows_thread_info
*> thread_list
;
234 /* Counts of things. */
235 static int saw_create
;
236 static int open_process_used
= 0;
238 static void *wow64_dbgbreak
;
242 static bool new_console
= false;
244 static bool cygwin_exceptions
= false;
246 static bool new_group
= true;
247 static bool debug_exec
= false; /* show execution */
248 static bool debug_events
= false; /* show events from kernel */
249 static bool debug_memory
= false; /* show target memory accesses */
250 static bool debug_exceptions
= false; /* show target exceptions */
251 static bool useshell
= false; /* use shell for subprocesses */
253 /* This vector maps GDB's idea of a register's number into an offset
254 in the windows exception context vector.
256 It also contains the bit mask needed to load the register in question.
258 The contents of this table can only be computed by the units
259 that provide CPU-specific support for Windows native debugging.
260 These units should set the table by calling
261 windows_set_context_register_offsets.
263 One day we could read a reg, we could inspect the context we
264 already have loaded, if it doesn't have the bit set that we need,
265 we read that set of registers in using GetThreadContext. If the
266 context already contains what we need, we just unpack it. Then to
267 write a register, first we have to ensure that the context contains
268 the other regs of the group, and then we copy the info in and set
271 static const int *mappings
;
273 /* The function to use in order to determine whether a register is
274 a segment register or not. */
275 static segment_register_p_ftype
*segment_register_p
;
277 /* See windows_nat_target::resume to understand why this is commented
280 /* This vector maps the target's idea of an exception (extracted
281 from the DEBUG_EVENT structure) to GDB's idea. */
283 struct xlate_exception
289 static const struct xlate_exception xlate
[] =
291 {EXCEPTION_ACCESS_VIOLATION
, GDB_SIGNAL_SEGV
},
292 {STATUS_STACK_OVERFLOW
, GDB_SIGNAL_SEGV
},
293 {EXCEPTION_BREAKPOINT
, GDB_SIGNAL_TRAP
},
294 {DBG_CONTROL_C
, GDB_SIGNAL_INT
},
295 {EXCEPTION_SINGLE_STEP
, GDB_SIGNAL_TRAP
},
296 {STATUS_FLOAT_DIVIDE_BY_ZERO
, GDB_SIGNAL_FPE
}
301 struct windows_nat_target final
: public x86_nat_target
<inf_child_target
>
303 void close () override
;
305 void attach (const char *, int) override
;
307 bool attach_no_wait () override
310 void detach (inferior
*, int) override
;
312 void resume (ptid_t
, int , enum gdb_signal
) override
;
314 ptid_t
wait (ptid_t
, struct target_waitstatus
*, target_wait_flags
) override
;
316 void fetch_registers (struct regcache
*, int) override
;
317 void store_registers (struct regcache
*, int) override
;
319 bool stopped_by_sw_breakpoint () override
321 windows_thread_info
*th
322 = thread_rec (inferior_ptid
, DONT_INVALIDATE_CONTEXT
);
323 return th
->stopped_at_software_breakpoint
;
326 bool supports_stopped_by_sw_breakpoint () override
331 enum target_xfer_status
xfer_partial (enum target_object object
,
334 const gdb_byte
*writebuf
,
335 ULONGEST offset
, ULONGEST len
,
336 ULONGEST
*xfered_len
) override
;
338 void files_info () override
;
340 void kill () override
;
342 void create_inferior (const char *, const std::string
&,
343 char **, int) override
;
345 void mourn_inferior () override
;
347 bool thread_alive (ptid_t ptid
) override
;
349 std::string
pid_to_str (ptid_t
) override
;
351 void interrupt () override
;
353 char *pid_to_exec_file (int pid
) override
;
355 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
357 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
359 const char *thread_name (struct thread_info
*) override
;
361 int get_windows_debug_event (int pid
, struct target_waitstatus
*ourstatus
);
363 void do_initial_windows_stuff (DWORD pid
, bool attaching
);
366 static windows_nat_target the_windows_nat_target
;
368 /* Set the MAPPINGS static global to OFFSETS.
369 See the description of MAPPINGS for more details. */
372 windows_set_context_register_offsets (const int *offsets
)
377 /* Set the function that should be used by this module to determine
378 whether a given register is a segment register or not. */
381 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
383 segment_register_p
= fun
;
387 check (BOOL ok
, const char *file
, int line
)
390 printf_filtered ("error return %s:%d was %u\n", file
, line
,
391 (unsigned) GetLastError ());
394 /* See nat/windows-nat.h. */
396 windows_thread_info
*
397 windows_nat::thread_rec (ptid_t ptid
, thread_disposition_type disposition
)
399 for (windows_thread_info
*th
: thread_list
)
400 if (th
->tid
== ptid
.lwp ())
406 case DONT_INVALIDATE_CONTEXT
:
409 case INVALIDATE_CONTEXT
:
410 if (ptid
.lwp () != current_event
.dwThreadId
)
412 th
->reload_context
= true;
415 th
->reload_context
= true;
426 /* Add a thread to the thread list.
428 PTID is the ptid of the thread to be added.
429 H is its Windows handle.
430 TLB is its thread local base.
431 MAIN_THREAD_P should be true if the thread to be added is
432 the main thread, false otherwise. */
434 static windows_thread_info
*
435 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
, bool main_thread_p
)
437 windows_thread_info
*th
;
439 gdb_assert (ptid
.lwp () != 0);
441 if ((th
= thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
)))
444 CORE_ADDR base
= (CORE_ADDR
) (uintptr_t) tlb
;
446 /* For WOW64 processes, this is actually the pointer to the 64bit TIB,
447 and the 32bit TIB is exactly 2 pages after it. */
451 th
= new windows_thread_info (ptid
.lwp (), h
, base
);
452 thread_list
.push_back (th
);
454 /* Add this new thread to the list of threads.
456 To be consistent with what's done on other platforms, we add
457 the main thread silently (in reality, this thread is really
458 more of a process to the user than a thread). */
460 add_thread_silent (&the_windows_nat_target
, ptid
);
462 add_thread (&the_windows_nat_target
, ptid
);
464 /* Set the debug registers for the new thread if they are used. */
465 if (debug_registers_used
)
470 /* Only change the value of the debug registers. */
471 th
->wow64_context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
472 CHECK (Wow64GetThreadContext (th
->h
, &th
->wow64_context
));
473 th
->wow64_context
.Dr0
= dr
[0];
474 th
->wow64_context
.Dr1
= dr
[1];
475 th
->wow64_context
.Dr2
= dr
[2];
476 th
->wow64_context
.Dr3
= dr
[3];
477 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
478 th
->wow64_context
.Dr7
= dr
[7];
479 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
480 th
->wow64_context
.ContextFlags
= 0;
485 /* Only change the value of the debug registers. */
486 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
487 CHECK (GetThreadContext (th
->h
, &th
->context
));
488 th
->context
.Dr0
= dr
[0];
489 th
->context
.Dr1
= dr
[1];
490 th
->context
.Dr2
= dr
[2];
491 th
->context
.Dr3
= dr
[3];
492 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
493 th
->context
.Dr7
= dr
[7];
494 CHECK (SetThreadContext (th
->h
, &th
->context
));
495 th
->context
.ContextFlags
= 0;
501 /* Clear out any old thread list and reinitialize it to a
504 windows_init_thread_list (void)
506 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
509 for (windows_thread_info
*here
: thread_list
)
512 thread_list
.clear ();
515 /* Delete a thread from the list of threads.
517 PTID is the ptid of the thread to be deleted.
518 EXIT_CODE is the thread's exit code.
519 MAIN_THREAD_P should be true if the thread to be deleted is
520 the main thread, false otherwise. */
523 windows_delete_thread (ptid_t ptid
, DWORD exit_code
, bool main_thread_p
)
527 gdb_assert (ptid
.lwp () != 0);
531 /* Emit a notification about the thread being deleted.
533 Note that no notification was printed when the main thread
534 was created, and thus, unless in verbose mode, we should be
535 symmetrical, and avoid that notification for the main thread
539 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
).c_str ());
540 else if (print_thread_events
&& !main_thread_p
)
541 printf_unfiltered (_("[%s exited with code %u]\n"),
542 target_pid_to_str (ptid
).c_str (),
543 (unsigned) exit_code
);
545 delete_thread (find_thread_ptid (&the_windows_nat_target
, ptid
));
547 auto iter
= std::find_if (thread_list
.begin (), thread_list
.end (),
548 [=] (windows_thread_info
*th
)
550 return th
->tid
== id
;
553 if (iter
!= thread_list
.end ())
556 thread_list
.erase (iter
);
560 /* Fetches register number R from the given windows_thread_info,
561 and supplies its value to the given regcache.
563 This function assumes that R is non-negative. A failed assertion
564 is raised if that is not true.
566 This function assumes that TH->RELOAD_CONTEXT is not set, meaning
567 that the windows_thread_info has an up-to-date context. A failed
568 assertion is raised if that assumption is violated. */
571 windows_fetch_one_register (struct regcache
*regcache
,
572 windows_thread_info
*th
, int r
)
575 gdb_assert (!th
->reload_context
);
577 char *context_ptr
= (char *) &th
->context
;
580 context_ptr
= (char *) &th
->wow64_context
;
583 char *context_offset
= context_ptr
+ mappings
[r
];
584 struct gdbarch
*gdbarch
= regcache
->arch ();
585 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
587 gdb_assert (!gdbarch_read_pc_p (gdbarch
));
588 gdb_assert (gdbarch_pc_regnum (gdbarch
) >= 0);
589 gdb_assert (!gdbarch_write_pc_p (gdbarch
));
591 if (r
== I387_FISEG_REGNUM (tdep
))
593 long l
= *((long *) context_offset
) & 0xffff;
594 regcache
->raw_supply (r
, (char *) &l
);
596 else if (r
== I387_FOP_REGNUM (tdep
))
598 long l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
599 regcache
->raw_supply (r
, (char *) &l
);
601 else if (segment_register_p (r
))
603 /* GDB treats segment registers as 32bit registers, but they are
604 in fact only 16 bits long. Make sure we do not read extra
605 bits from our source buffer. */
606 long l
= *((long *) context_offset
) & 0xffff;
607 regcache
->raw_supply (r
, (char *) &l
);
611 if (th
->stopped_at_software_breakpoint
613 && r
== gdbarch_pc_regnum (gdbarch
))
615 int size
= register_size (gdbarch
, r
);
619 memcpy (&value
, context_offset
, size
);
620 value
-= gdbarch_decr_pc_after_break (gdbarch
);
621 memcpy (context_offset
, &value
, size
);
625 gdb_assert (size
== 8);
627 memcpy (&value
, context_offset
, size
);
628 value
-= gdbarch_decr_pc_after_break (gdbarch
);
629 memcpy (context_offset
, &value
, size
);
631 /* Make sure we only rewrite the PC a single time. */
632 th
->pc_adjusted
= true;
634 regcache
->raw_supply (r
, context_offset
);
639 windows_nat_target::fetch_registers (struct regcache
*regcache
, int r
)
641 windows_thread_info
*th
= thread_rec (regcache
->ptid (), INVALIDATE_CONTEXT
);
643 /* Check if TH exists. Windows sometimes uses a non-existent
644 thread id in its events. */
648 if (th
->reload_context
)
651 if (have_saved_context
)
653 /* Lie about where the program actually is stopped since
654 cygwin has informed us that we should consider the signal
655 to have occurred at another location which is stored in
657 memcpy (&th
->context
, &saved_context
,
658 __COPY_CONTEXT_SIZE
);
659 have_saved_context
= 0;
666 th
->wow64_context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
667 CHECK (Wow64GetThreadContext (th
->h
, &th
->wow64_context
));
668 /* Copy dr values from that thread.
669 But only if there were not modified since last stop.
671 if (!debug_registers_changed
)
673 dr
[0] = th
->wow64_context
.Dr0
;
674 dr
[1] = th
->wow64_context
.Dr1
;
675 dr
[2] = th
->wow64_context
.Dr2
;
676 dr
[3] = th
->wow64_context
.Dr3
;
677 dr
[6] = th
->wow64_context
.Dr6
;
678 dr
[7] = th
->wow64_context
.Dr7
;
684 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
685 CHECK (GetThreadContext (th
->h
, &th
->context
));
686 /* Copy dr values from that thread.
687 But only if there were not modified since last stop.
689 if (!debug_registers_changed
)
691 dr
[0] = th
->context
.Dr0
;
692 dr
[1] = th
->context
.Dr1
;
693 dr
[2] = th
->context
.Dr2
;
694 dr
[3] = th
->context
.Dr3
;
695 dr
[6] = th
->context
.Dr6
;
696 dr
[7] = th
->context
.Dr7
;
699 th
->reload_context
= false;
703 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch()); r
++)
704 windows_fetch_one_register (regcache
, th
, r
);
706 windows_fetch_one_register (regcache
, th
, r
);
709 /* Collect the register number R from the given regcache, and store
710 its value into the corresponding area of the given thread's context.
712 This function assumes that R is non-negative. A failed assertion
713 assertion is raised if that is not true. */
716 windows_store_one_register (const struct regcache
*regcache
,
717 windows_thread_info
*th
, int r
)
721 char *context_ptr
= (char *) &th
->context
;
724 context_ptr
= (char *) &th
->wow64_context
;
727 regcache
->raw_collect (r
, context_ptr
+ mappings
[r
]);
730 /* Store a new register value into the context of the thread tied to
734 windows_nat_target::store_registers (struct regcache
*regcache
, int r
)
736 windows_thread_info
*th
= thread_rec (regcache
->ptid (), INVALIDATE_CONTEXT
);
738 /* Check if TH exists. Windows sometimes uses a non-existent
739 thread id in its events. */
744 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch ()); r
++)
745 windows_store_one_register (regcache
, th
, r
);
747 windows_store_one_register (regcache
, th
, r
);
750 /* Maintain a linked list of "so" information. */
751 struct lm_info_windows
: public lm_info_base
753 LPVOID load_addr
= 0;
754 CORE_ADDR text_offset
= 0;
757 static struct so_list solib_start
, *solib_end
;
759 static struct so_list
*
760 windows_make_so (const char *name
, LPVOID load_addr
)
767 WIN32_FIND_DATA w32_fd
;
768 HANDLE h
= FindFirstFile(name
, &w32_fd
);
770 if (h
== INVALID_HANDLE_VALUE
)
776 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
778 p
= strrchr (buf
, '\\');
781 SetCurrentDirectory (buf
);
782 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
783 SetCurrentDirectory (cwd
);
786 if (strcasecmp (buf
, "ntdll.dll") == 0)
788 GetSystemDirectory (buf
, sizeof (buf
));
789 strcat (buf
, "\\ntdll.dll");
792 cygwin_buf_t buf
[__PMAX
];
795 if (access (name
, F_OK
) != 0)
797 if (strcasecmp (name
, "ntdll.dll") == 0)
800 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
801 wcscat (buf
, L
"\\ntdll.dll");
805 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
806 strcat (buf
, "\\ntdll.dll");
811 so
= XCNEW (struct so_list
);
812 lm_info_windows
*li
= new lm_info_windows
;
814 li
->load_addr
= load_addr
;
815 strcpy (so
->so_original_name
, name
);
817 strcpy (so
->so_name
, buf
);
820 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
821 SO_NAME_MAX_PATH_SIZE
);
824 char *rname
= realpath (name
, NULL
);
825 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
827 strcpy (so
->so_name
, rname
);
832 warning (_("dll path for \"%s\" too long or inaccessible"), name
);
833 strcpy (so
->so_name
, so
->so_original_name
);
836 /* Record cygwin1.dll .text start/end. */
837 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
838 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
840 asection
*text
= NULL
;
842 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386"));
847 if (bfd_check_format (abfd
.get (), bfd_object
))
848 text
= bfd_get_section_by_name (abfd
.get (), ".text");
853 /* The symbols in a dll are offset by 0x1000, which is the
854 offset from 0 of the first byte in an image - because of the
855 file header and the section alignment. */
856 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
858 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (text
);
865 /* See nat/windows-nat.h. */
868 windows_nat::handle_load_dll ()
870 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
871 const char *dll_name
;
873 /* Try getting the DLL name via the lpImageName field of the event.
874 Note that Microsoft documents this fields as strictly optional,
875 in the sense that it might be NULL. And the first DLL event in
876 particular is explicitly documented as "likely not pass[ed]"
877 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
878 dll_name
= get_image_name (current_process_handle
,
879 event
->lpImageName
, event
->fUnicode
);
883 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
884 solib_end
= solib_end
->next
;
886 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
888 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
889 host_address_to_string (li
->load_addr
)));
893 windows_free_so (struct so_list
*so
)
895 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
901 /* See nat/windows-nat.h. */
904 windows_nat::handle_unload_dll ()
906 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
909 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
911 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
913 if (li_next
->load_addr
== lpBaseOfDll
)
915 struct so_list
*sodel
= so
->next
;
917 so
->next
= sodel
->next
;
920 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
922 windows_free_so (sodel
);
927 /* We did not find any DLL that was previously loaded at this address,
928 so register a complaint. We do not report an error, because we have
929 observed that this may be happening under some circumstances. For
930 instance, running 32bit applications on x64 Windows causes us to receive
931 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
932 events are apparently caused by the WOW layer, the interface between
933 32bit and 64bit worlds). */
934 complaint (_("dll starting at %s not found."),
935 host_address_to_string (lpBaseOfDll
));
938 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
942 catch_errors (void (*func
) ())
948 catch (const gdb_exception
&ex
)
950 exception_print (gdb_stderr
, ex
);
954 /* Clear list of loaded DLLs. */
956 windows_clear_solib (void)
960 for (so
= solib_start
.next
; so
; so
= solib_start
.next
)
962 solib_start
.next
= so
->next
;
963 windows_free_so (so
);
966 solib_end
= &solib_start
;
970 signal_event_command (const char *args
, int from_tty
)
972 uintptr_t event_id
= 0;
973 char *endargs
= NULL
;
976 error (_("signal-event requires an argument (integer event id)"));
978 event_id
= strtoumax (args
, &endargs
, 10);
980 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
981 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
982 error (_("Failed to convert `%s' to event id"), args
);
984 SetEvent ((HANDLE
) event_id
);
985 CloseHandle ((HANDLE
) event_id
);
988 /* See nat/windows-nat.h. */
991 windows_nat::handle_output_debug_string (struct target_waitstatus
*ourstatus
)
995 gdb::unique_xmalloc_ptr
<char> s
996 = (target_read_string
997 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
999 if (s
== nullptr || !*(s
.get ()))
1000 /* nothing to do */;
1001 else if (!startswith (s
.get (), _CYGWIN_SIGNAL_STRING
))
1004 if (!startswith (s
.get (), "cYg"))
1007 char *p
= strchr (s
.get (), '\0');
1009 if (p
> s
.get () && *--p
== '\n')
1011 warning (("%s"), s
.get ());
1017 /* Got a cygwin signal marker. A cygwin signal is followed by
1018 the signal number itself and then optionally followed by the
1019 thread id and address to saved context within the DLL. If
1020 these are supplied, then the given thread is assumed to have
1021 issued the signal and the context from the thread is assumed
1022 to be stored at the given address in the inferior. Tell gdb
1023 to treat this like a real signal. */
1025 int sig
= strtol (s
.get () + sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
1026 gdb_signal gotasig
= gdb_signal_from_host (sig
);
1028 ourstatus
->value
.sig
= gotasig
;
1034 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1035 retval
= strtoul (p
, &p
, 0);
1037 retval
= current_event
.dwThreadId
;
1038 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
1039 && ReadProcessMemory (current_process_handle
, x
,
1041 __COPY_CONTEXT_SIZE
, &n
)
1042 && n
== __COPY_CONTEXT_SIZE
)
1043 have_saved_context
= 1;
1052 display_selector (HANDLE thread
, DWORD sel
)
1058 ret
= Wow64GetThreadSelectorEntry (thread
, sel
, &info
);
1061 ret
= GetThreadSelectorEntry (thread
, sel
, &info
);
1065 printf_filtered ("0x%03x: ", (unsigned) sel
);
1066 if (!info
.HighWord
.Bits
.Pres
)
1068 puts_filtered ("Segment not present\n");
1071 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1072 (info
.HighWord
.Bits
.BaseMid
<< 16)
1074 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1075 if (info
.HighWord
.Bits
.Granularity
)
1076 limit
= (limit
<< 12) | 0xfff;
1077 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1078 if (info
.HighWord
.Bits
.Default_Big
)
1079 puts_filtered(" 32-bit ");
1081 puts_filtered(" 16-bit ");
1082 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1085 puts_filtered ("Data (Read-Only, Exp-up");
1088 puts_filtered ("Data (Read/Write, Exp-up");
1091 puts_filtered ("Unused segment (");
1094 puts_filtered ("Data (Read/Write, Exp-down");
1097 puts_filtered ("Code (Exec-Only, N.Conf");
1100 puts_filtered ("Code (Exec/Read, N.Conf");
1103 puts_filtered ("Code (Exec-Only, Conf");
1106 puts_filtered ("Code (Exec/Read, Conf");
1109 printf_filtered ("Unknown type 0x%lx",
1110 (unsigned long) info
.HighWord
.Bits
.Type
);
1112 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1113 puts_filtered(", N.Acc");
1114 puts_filtered (")\n");
1115 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1116 puts_filtered("System selector ");
1117 printf_filtered ("Priviledge level = %ld. ",
1118 (unsigned long) info
.HighWord
.Bits
.Dpl
);
1119 if (info
.HighWord
.Bits
.Granularity
)
1120 puts_filtered ("Page granular.\n");
1122 puts_filtered ("Byte granular.\n");
1127 DWORD err
= GetLastError ();
1128 if (err
== ERROR_NOT_SUPPORTED
)
1129 printf_filtered ("Function not supported\n");
1131 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1137 display_selectors (const char * args
, int from_tty
)
1139 if (inferior_ptid
== null_ptid
)
1141 puts_filtered ("Impossible to display selectors now.\n");
1145 windows_thread_info
*current_windows_thread
1146 = thread_rec (inferior_ptid
, DONT_INVALIDATE_CONTEXT
);
1153 puts_filtered ("Selector $cs\n");
1154 display_selector (current_windows_thread
->h
,
1155 current_windows_thread
->wow64_context
.SegCs
);
1156 puts_filtered ("Selector $ds\n");
1157 display_selector (current_windows_thread
->h
,
1158 current_windows_thread
->wow64_context
.SegDs
);
1159 puts_filtered ("Selector $es\n");
1160 display_selector (current_windows_thread
->h
,
1161 current_windows_thread
->wow64_context
.SegEs
);
1162 puts_filtered ("Selector $ss\n");
1163 display_selector (current_windows_thread
->h
,
1164 current_windows_thread
->wow64_context
.SegSs
);
1165 puts_filtered ("Selector $fs\n");
1166 display_selector (current_windows_thread
->h
,
1167 current_windows_thread
->wow64_context
.SegFs
);
1168 puts_filtered ("Selector $gs\n");
1169 display_selector (current_windows_thread
->h
,
1170 current_windows_thread
->wow64_context
.SegGs
);
1175 puts_filtered ("Selector $cs\n");
1176 display_selector (current_windows_thread
->h
,
1177 current_windows_thread
->context
.SegCs
);
1178 puts_filtered ("Selector $ds\n");
1179 display_selector (current_windows_thread
->h
,
1180 current_windows_thread
->context
.SegDs
);
1181 puts_filtered ("Selector $es\n");
1182 display_selector (current_windows_thread
->h
,
1183 current_windows_thread
->context
.SegEs
);
1184 puts_filtered ("Selector $ss\n");
1185 display_selector (current_windows_thread
->h
,
1186 current_windows_thread
->context
.SegSs
);
1187 puts_filtered ("Selector $fs\n");
1188 display_selector (current_windows_thread
->h
,
1189 current_windows_thread
->context
.SegFs
);
1190 puts_filtered ("Selector $gs\n");
1191 display_selector (current_windows_thread
->h
,
1192 current_windows_thread
->context
.SegGs
);
1198 sel
= parse_and_eval_long (args
);
1199 printf_filtered ("Selector \"%s\"\n",args
);
1200 display_selector (current_windows_thread
->h
, sel
);
1204 /* See nat/windows-nat.h. */
1207 windows_nat::handle_ms_vc_exception (const EXCEPTION_RECORD
*rec
)
1209 if (rec
->NumberParameters
>= 3
1210 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1212 DWORD named_thread_id
;
1213 windows_thread_info
*named_thread
;
1214 CORE_ADDR thread_name_target
;
1216 thread_name_target
= rec
->ExceptionInformation
[1];
1217 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1219 if (named_thread_id
== (DWORD
) -1)
1220 named_thread_id
= current_event
.dwThreadId
;
1222 named_thread
= thread_rec (ptid_t (current_event
.dwProcessId
,
1223 named_thread_id
, 0),
1224 DONT_INVALIDATE_CONTEXT
);
1225 if (named_thread
!= NULL
)
1227 int thread_name_len
;
1228 gdb::unique_xmalloc_ptr
<char> thread_name
1229 = target_read_string (thread_name_target
, 1025, &thread_name_len
);
1230 if (thread_name_len
> 0)
1232 thread_name
.get ()[thread_name_len
- 1] = '\0';
1233 named_thread
->name
= std::move (thread_name
);
1243 /* See nat/windows-nat.h. */
1246 windows_nat::handle_access_violation (const EXCEPTION_RECORD
*rec
)
1249 /* See if the access violation happened within the cygwin DLL
1250 itself. Cygwin uses a kind of exception handling to deal with
1251 passed-in invalid addresses. gdb should not treat these as real
1252 SEGVs since they will be silently handled by cygwin. A real SEGV
1253 will (theoretically) be caught by cygwin later in the process and
1254 will be sent as a cygwin-specific-signal. So, ignore SEGVs if
1255 they show up within the text segment of the DLL itself. */
1257 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1259 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1260 && addr
< cygwin_load_end
))
1261 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1262 && startswith (fn
, "KERNEL32!IsBad")))
1268 /* Resume thread specified by ID, or all artificially suspended
1269 threads, if we are continuing execution. KILLED non-zero means we
1270 have killed the inferior, so we should ignore weird errors due to
1271 threads shutting down. */
1273 windows_continue (DWORD continue_status
, int id
, int killed
)
1277 desired_stop_thread_id
= id
;
1279 if (matching_pending_stop (debug_events
))
1282 for (windows_thread_info
*th
: thread_list
)
1283 if (id
== -1 || id
== (int) th
->tid
)
1290 if (debug_registers_changed
)
1292 th
->wow64_context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1293 th
->wow64_context
.Dr0
= dr
[0];
1294 th
->wow64_context
.Dr1
= dr
[1];
1295 th
->wow64_context
.Dr2
= dr
[2];
1296 th
->wow64_context
.Dr3
= dr
[3];
1297 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1298 th
->wow64_context
.Dr7
= dr
[7];
1300 if (th
->wow64_context
.ContextFlags
)
1304 if (GetExitCodeThread (th
->h
, &ec
)
1305 && ec
== STILL_ACTIVE
)
1307 BOOL status
= Wow64SetThreadContext (th
->h
,
1308 &th
->wow64_context
);
1313 th
->wow64_context
.ContextFlags
= 0;
1319 if (debug_registers_changed
)
1321 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1322 th
->context
.Dr0
= dr
[0];
1323 th
->context
.Dr1
= dr
[1];
1324 th
->context
.Dr2
= dr
[2];
1325 th
->context
.Dr3
= dr
[3];
1326 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1327 th
->context
.Dr7
= dr
[7];
1329 if (th
->context
.ContextFlags
)
1333 if (GetExitCodeThread (th
->h
, &ec
)
1334 && ec
== STILL_ACTIVE
)
1336 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1341 th
->context
.ContextFlags
= 0;
1348 /* When single-stepping a specific thread, other threads must
1353 res
= continue_last_debug_event (continue_status
, debug_events
);
1356 error (_("Failed to resume program execution"
1357 " (ContinueDebugEvent failed, error %u)"),
1358 (unsigned int) GetLastError ());
1360 debug_registers_changed
= 0;
1364 /* Called in pathological case where Windows fails to send a
1365 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1367 fake_create_process (void)
1369 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1370 current_event
.dwProcessId
);
1371 if (current_process_handle
!= NULL
)
1372 open_process_used
= 1;
1375 error (_("OpenProcess call failed, GetLastError = %u"),
1376 (unsigned) GetLastError ());
1377 /* We can not debug anything in that case. */
1379 windows_add_thread (ptid_t (current_event
.dwProcessId
, 0,
1380 current_event
.dwThreadId
),
1381 current_event
.u
.CreateThread
.hThread
,
1382 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1383 true /* main_thread_p */);
1384 return current_event
.dwThreadId
;
1388 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1390 windows_thread_info
*th
;
1391 DWORD continue_status
= DBG_CONTINUE
;
1393 /* A specific PTID means `step only this thread id'. */
1394 int resume_all
= ptid
== minus_one_ptid
;
1396 /* If we're continuing all threads, it's the current inferior that
1397 should be handled specially. */
1399 ptid
= inferior_ptid
;
1401 if (sig
!= GDB_SIGNAL_0
)
1403 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1405 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1407 else if (sig
== last_sig
)
1408 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1411 /* This code does not seem to work, because
1412 the kernel does probably not consider changes in the ExceptionRecord
1413 structure when passing the exception to the inferior.
1414 Note that this seems possible in the exception handler itself. */
1416 for (const xlate_exception
&x
: xlate
)
1419 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1421 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1424 if (continue_status
== DBG_CONTINUE
)
1426 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1430 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1434 last_sig
= GDB_SIGNAL_0
;
1436 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=0x%x, step=%d, sig=%d);\n",
1437 ptid
.pid (), (unsigned) ptid
.lwp (), step
, sig
));
1439 /* Get context for currently selected thread. */
1440 th
= thread_rec (inferior_ptid
, DONT_INVALIDATE_CONTEXT
);
1448 /* Single step by setting t bit. */
1449 struct regcache
*regcache
= get_current_regcache ();
1450 struct gdbarch
*gdbarch
= regcache
->arch ();
1451 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1452 th
->wow64_context
.EFlags
|= FLAG_TRACE_BIT
;
1455 if (th
->wow64_context
.ContextFlags
)
1457 if (debug_registers_changed
)
1459 th
->wow64_context
.Dr0
= dr
[0];
1460 th
->wow64_context
.Dr1
= dr
[1];
1461 th
->wow64_context
.Dr2
= dr
[2];
1462 th
->wow64_context
.Dr3
= dr
[3];
1463 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1464 th
->wow64_context
.Dr7
= dr
[7];
1466 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
1467 th
->wow64_context
.ContextFlags
= 0;
1475 /* Single step by setting t bit. */
1476 struct regcache
*regcache
= get_current_regcache ();
1477 struct gdbarch
*gdbarch
= regcache
->arch ();
1478 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1479 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1482 if (th
->context
.ContextFlags
)
1484 if (debug_registers_changed
)
1486 th
->context
.Dr0
= dr
[0];
1487 th
->context
.Dr1
= dr
[1];
1488 th
->context
.Dr2
= dr
[2];
1489 th
->context
.Dr3
= dr
[3];
1490 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1491 th
->context
.Dr7
= dr
[7];
1493 CHECK (SetThreadContext (th
->h
, &th
->context
));
1494 th
->context
.ContextFlags
= 0;
1499 /* Allow continuing with the same signal that interrupted us.
1500 Otherwise complain. */
1503 windows_continue (continue_status
, -1, 0);
1505 windows_continue (continue_status
, ptid
.lwp (), 0);
1508 /* Ctrl-C handler used when the inferior is not run in the same console. The
1509 handler is in charge of interrupting the inferior using DebugBreakProcess.
1510 Note that this function is not available prior to Windows XP. In this case
1511 we emit a warning. */
1513 ctrl_c_handler (DWORD event_type
)
1515 const int attach_flag
= current_inferior ()->attach_flag
;
1517 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1518 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1521 /* If the inferior and the debugger share the same console, do nothing as
1522 the inferior has also received the Ctrl-C event. */
1523 if (!new_console
&& !attach_flag
)
1529 /* Call DbgUiRemoteBreakin of the 32bit ntdll.dll in the target process.
1530 DebugBreakProcess would call the one of the 64bit ntdll.dll, which
1531 can't be correctly handled by gdb. */
1532 if (wow64_dbgbreak
== nullptr)
1535 if (!find_minimal_symbol_address ("ntdll!DbgUiRemoteBreakin",
1537 wow64_dbgbreak
= (void *) addr
;
1540 if (wow64_dbgbreak
!= nullptr)
1542 HANDLE thread
= CreateRemoteThread (current_process_handle
, NULL
,
1543 0, (LPTHREAD_START_ROUTINE
)
1544 wow64_dbgbreak
, NULL
, 0, NULL
);
1546 CloseHandle (thread
);
1552 if (!DebugBreakProcess (current_process_handle
))
1553 warning (_("Could not interrupt program. "
1554 "Press Ctrl-c in the program console."));
1557 /* Return true to tell that Ctrl-C has been handled. */
1561 /* Get the next event from the child. Returns a non-zero thread id if the event
1562 requires handling by WFI (or whatever). */
1565 windows_nat_target::get_windows_debug_event (int pid
,
1566 struct target_waitstatus
*ourstatus
)
1569 DWORD continue_status
, event_code
;
1570 DWORD thread_id
= 0;
1572 /* If there is a relevant pending stop, report it now. See the
1573 comment by the definition of "pending_stops" for details on why
1575 gdb::optional
<pending_stop
> stop
= fetch_pending_stop (debug_events
);
1576 if (stop
.has_value ())
1578 thread_id
= stop
->thread_id
;
1579 *ourstatus
= stop
->status
;
1581 ptid_t
ptid (current_event
.dwProcessId
, thread_id
);
1582 windows_thread_info
*th
= thread_rec (ptid
, INVALIDATE_CONTEXT
);
1583 th
->reload_context
= 1;
1588 last_sig
= GDB_SIGNAL_0
;
1590 if (!(debug_event
= wait_for_debug_event (¤t_event
, 1000)))
1593 continue_status
= DBG_CONTINUE
;
1595 event_code
= current_event
.dwDebugEventCode
;
1596 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1597 have_saved_context
= 0;
1601 case CREATE_THREAD_DEBUG_EVENT
:
1602 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1603 (unsigned) current_event
.dwProcessId
,
1604 (unsigned) current_event
.dwThreadId
,
1605 "CREATE_THREAD_DEBUG_EVENT"));
1606 if (saw_create
!= 1)
1608 inferior
*inf
= find_inferior_pid (this, current_event
.dwProcessId
);
1609 if (!saw_create
&& inf
->attach_flag
)
1611 /* Kludge around a Windows bug where first event is a create
1612 thread event. Caused when attached process does not have
1614 thread_id
= fake_create_process ();
1620 /* Record the existence of this thread. */
1621 thread_id
= current_event
.dwThreadId
;
1623 (ptid_t (current_event
.dwProcessId
, current_event
.dwThreadId
, 0),
1624 current_event
.u
.CreateThread
.hThread
,
1625 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1626 false /* main_thread_p */);
1630 case EXIT_THREAD_DEBUG_EVENT
:
1631 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1632 (unsigned) current_event
.dwProcessId
,
1633 (unsigned) current_event
.dwThreadId
,
1634 "EXIT_THREAD_DEBUG_EVENT"));
1635 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1636 current_event
.dwThreadId
, 0),
1637 current_event
.u
.ExitThread
.dwExitCode
,
1638 false /* main_thread_p */);
1641 case CREATE_PROCESS_DEBUG_EVENT
:
1642 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1643 (unsigned) current_event
.dwProcessId
,
1644 (unsigned) current_event
.dwThreadId
,
1645 "CREATE_PROCESS_DEBUG_EVENT"));
1646 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1647 if (++saw_create
!= 1)
1650 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1651 /* Add the main thread. */
1653 (ptid_t (current_event
.dwProcessId
,
1654 current_event
.dwThreadId
, 0),
1655 current_event
.u
.CreateProcessInfo
.hThread
,
1656 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
,
1657 true /* main_thread_p */);
1658 thread_id
= current_event
.dwThreadId
;
1661 case EXIT_PROCESS_DEBUG_EVENT
:
1662 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1663 (unsigned) current_event
.dwProcessId
,
1664 (unsigned) current_event
.dwThreadId
,
1665 "EXIT_PROCESS_DEBUG_EVENT"));
1666 if (!windows_initialization_done
)
1668 target_terminal::ours ();
1669 target_mourn_inferior (inferior_ptid
);
1670 error (_("During startup program exited with code 0x%x."),
1671 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1673 else if (saw_create
== 1)
1675 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1676 current_event
.dwThreadId
, 0),
1677 0, true /* main_thread_p */);
1678 DWORD exit_status
= current_event
.u
.ExitProcess
.dwExitCode
;
1679 /* If the exit status looks like a fatal exception, but we
1680 don't recognize the exception's code, make the original
1681 exit status value available, to avoid losing
1684 = WIFSIGNALED (exit_status
) ? WTERMSIG (exit_status
) : -1;
1685 if (exit_signal
== -1)
1687 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1688 ourstatus
->value
.integer
= exit_status
;
1692 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1693 ourstatus
->value
.sig
= gdb_signal_from_host (exit_signal
);
1695 thread_id
= current_event
.dwThreadId
;
1699 case LOAD_DLL_DEBUG_EVENT
:
1700 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1701 (unsigned) current_event
.dwProcessId
,
1702 (unsigned) current_event
.dwThreadId
,
1703 "LOAD_DLL_DEBUG_EVENT"));
1704 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1705 if (saw_create
!= 1 || ! windows_initialization_done
)
1707 catch_errors (handle_load_dll
);
1708 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1709 ourstatus
->value
.integer
= 0;
1710 thread_id
= current_event
.dwThreadId
;
1713 case UNLOAD_DLL_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 "UNLOAD_DLL_DEBUG_EVENT"));
1718 if (saw_create
!= 1 || ! windows_initialization_done
)
1720 catch_errors (handle_unload_dll
);
1721 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1722 ourstatus
->value
.integer
= 0;
1723 thread_id
= current_event
.dwThreadId
;
1726 case EXCEPTION_DEBUG_EVENT
:
1727 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1728 (unsigned) current_event
.dwProcessId
,
1729 (unsigned) current_event
.dwThreadId
,
1730 "EXCEPTION_DEBUG_EVENT"));
1731 if (saw_create
!= 1)
1733 switch (handle_exception (ourstatus
, debug_exceptions
))
1735 case HANDLE_EXCEPTION_UNHANDLED
:
1737 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1739 case HANDLE_EXCEPTION_HANDLED
:
1740 thread_id
= current_event
.dwThreadId
;
1742 case HANDLE_EXCEPTION_IGNORED
:
1743 continue_status
= DBG_CONTINUE
;
1748 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1749 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1750 (unsigned) current_event
.dwProcessId
,
1751 (unsigned) current_event
.dwThreadId
,
1752 "OUTPUT_DEBUG_STRING_EVENT"));
1753 if (saw_create
!= 1)
1755 thread_id
= handle_output_debug_string (ourstatus
);
1759 if (saw_create
!= 1)
1761 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1762 (unsigned) current_event
.dwProcessId
,
1763 (unsigned) current_event
.dwThreadId
);
1764 printf_unfiltered (" unknown event code %u\n",
1765 (unsigned) current_event
.dwDebugEventCode
);
1769 if (!thread_id
|| saw_create
!= 1)
1771 CHECK (windows_continue (continue_status
, desired_stop_thread_id
, 0));
1773 else if (desired_stop_thread_id
!= -1 && desired_stop_thread_id
!= thread_id
)
1775 /* Pending stop. See the comment by the definition of
1776 "pending_stops" for details on why this is needed. */
1777 DEBUG_EVENTS (("get_windows_debug_event - "
1778 "unexpected stop in 0x%x (expecting 0x%x)\n",
1779 thread_id
, desired_stop_thread_id
));
1781 if (current_event
.dwDebugEventCode
== EXCEPTION_DEBUG_EVENT
1782 && ((current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1783 == EXCEPTION_BREAKPOINT
)
1784 || (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1785 == STATUS_WX86_BREAKPOINT
))
1786 && windows_initialization_done
)
1788 ptid_t ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1789 windows_thread_info
*th
= thread_rec (ptid
, INVALIDATE_CONTEXT
);
1790 th
->stopped_at_software_breakpoint
= true;
1791 th
->pc_adjusted
= false;
1793 pending_stops
.push_back ({thread_id
, *ourstatus
, current_event
});
1795 CHECK (windows_continue (continue_status
, desired_stop_thread_id
, 0));
1802 /* Wait for interesting events to occur in the target process. */
1804 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1805 target_wait_flags options
)
1809 /* We loop when we get a non-standard exception rather than return
1810 with a SPURIOUS because resume can try and step or modify things,
1811 which needs a current_thread->h. But some of these exceptions mark
1812 the birth or death of threads, which mean that the current thread
1813 isn't necessarily what you think it is. */
1819 /* If the user presses Ctrl-c while the debugger is waiting
1820 for an event, he expects the debugger to interrupt his program
1821 and to get the prompt back. There are two possible situations:
1823 - The debugger and the program do not share the console, in
1824 which case the Ctrl-c event only reached the debugger.
1825 In that case, the ctrl_c handler will take care of interrupting
1826 the inferior. Note that this case is working starting with
1827 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1830 - The debugger and the program share the same console, in which
1831 case both debugger and inferior will receive the Ctrl-c event.
1832 In that case the ctrl_c handler will ignore the event, as the
1833 Ctrl-c event generated inside the inferior will trigger the
1834 expected debug event.
1836 FIXME: brobecker/2008-05-20: If the inferior receives the
1837 signal first and the delay until GDB receives that signal
1838 is sufficiently long, GDB can sometimes receive the SIGINT
1839 after we have unblocked the CTRL+C handler. This would
1840 lead to the debugger stopping prematurely while handling
1841 the new-thread event that comes with the handling of the SIGINT
1842 inside the inferior, and then stop again immediately when
1843 the user tries to resume the execution in the inferior.
1844 This is a classic race that we should try to fix one day. */
1845 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1846 retval
= get_windows_debug_event (pid
, ourstatus
);
1847 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1851 ptid_t result
= ptid_t (current_event
.dwProcessId
, retval
, 0);
1853 if (ourstatus
->kind
!= TARGET_WAITKIND_EXITED
1854 && ourstatus
->kind
!= TARGET_WAITKIND_SIGNALLED
)
1856 windows_thread_info
*th
= thread_rec (result
, INVALIDATE_CONTEXT
);
1860 th
->stopped_at_software_breakpoint
= false;
1861 if (current_event
.dwDebugEventCode
== EXCEPTION_DEBUG_EVENT
1862 && ((current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1863 == EXCEPTION_BREAKPOINT
)
1864 || (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1865 == STATUS_WX86_BREAKPOINT
))
1866 && windows_initialization_done
)
1868 th
->stopped_at_software_breakpoint
= true;
1869 th
->pc_adjusted
= false;
1880 if (deprecated_ui_loop_hook
!= NULL
)
1881 detach
= deprecated_ui_loop_hook (0);
1889 /* Iterate over all DLLs currently mapped by our inferior, and
1890 add them to our list of solibs. */
1893 windows_add_all_dlls (void)
1895 HMODULE dummy_hmodule
;
1903 if (EnumProcessModulesEx (current_process_handle
, &dummy_hmodule
,
1904 sizeof (HMODULE
), &cb_needed
,
1905 LIST_MODULES_32BIT
) == 0)
1911 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
1912 sizeof (HMODULE
), &cb_needed
) == 0)
1919 hmodules
= (HMODULE
*) alloca (cb_needed
);
1923 if (EnumProcessModulesEx (current_process_handle
, hmodules
,
1924 cb_needed
, &cb_needed
,
1925 LIST_MODULES_32BIT
) == 0)
1931 if (EnumProcessModules (current_process_handle
, hmodules
,
1932 cb_needed
, &cb_needed
) == 0)
1936 char system_dir
[__PMAX
];
1937 char syswow_dir
[__PMAX
];
1938 size_t system_dir_len
= 0;
1939 bool convert_syswow_dir
= false;
1944 /* This fails on 32bit Windows because it has no SysWOW64 directory,
1945 and in this case a path conversion isn't necessary. */
1946 UINT len
= GetSystemWow64DirectoryA (syswow_dir
, sizeof (syswow_dir
));
1949 /* Check that we have passed a large enough buffer. */
1950 gdb_assert (len
< sizeof (syswow_dir
));
1952 len
= GetSystemDirectoryA (system_dir
, sizeof (system_dir
));
1954 gdb_assert (len
!= 0);
1955 /* Check that we have passed a large enough buffer. */
1956 gdb_assert (len
< sizeof (system_dir
));
1958 strcat (system_dir
, "\\");
1959 strcat (syswow_dir
, "\\");
1960 system_dir_len
= strlen (system_dir
);
1962 convert_syswow_dir
= true;
1966 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
1970 wchar_t dll_name
[__PMAX
];
1971 char dll_name_mb
[__PMAX
];
1973 char dll_name
[__PMAX
];
1976 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
1977 &mi
, sizeof (mi
)) == 0)
1979 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
1980 dll_name
, sizeof (dll_name
)) == 0)
1983 wcstombs (dll_name_mb
, dll_name
, __PMAX
);
1988 /* Convert the DLL path of 32bit processes returned by
1989 GetModuleFileNameEx from the 64bit system directory to the
1990 32bit syswow64 directory if necessary. */
1991 std::string syswow_dll_path
;
1992 if (convert_syswow_dir
1993 && strncasecmp (name
, system_dir
, system_dir_len
) == 0
1994 && strchr (name
+ system_dir_len
, '\\') == nullptr)
1996 syswow_dll_path
= syswow_dir
;
1997 syswow_dll_path
+= name
+ system_dir_len
;
1998 name
= syswow_dll_path
.c_str();
2001 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
2002 solib_end
= solib_end
->next
;
2007 windows_nat_target::do_initial_windows_stuff (DWORD pid
, bool attaching
)
2010 struct inferior
*inf
;
2012 last_sig
= GDB_SIGNAL_0
;
2013 open_process_used
= 0;
2014 debug_registers_changed
= 0;
2015 debug_registers_used
= 0;
2016 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
2019 cygwin_load_start
= cygwin_load_end
= 0;
2021 current_event
.dwProcessId
= pid
;
2022 memset (¤t_event
, 0, sizeof (current_event
));
2023 if (!target_is_pushed (this))
2025 disable_breakpoints_in_shlibs ();
2026 windows_clear_solib ();
2027 clear_proceed_status (0);
2028 init_wait_for_inferior ();
2031 ignore_first_breakpoint
= !attaching
&& wow64_process
;
2035 windows_set_context_register_offsets (amd64_mappings
);
2036 windows_set_segment_register_p (amd64_windows_segment_register_p
);
2041 windows_set_context_register_offsets (i386_mappings
);
2042 windows_set_segment_register_p (i386_windows_segment_register_p
);
2045 inf
= current_inferior ();
2046 inferior_appeared (inf
, pid
);
2047 inf
->attach_flag
= attaching
;
2049 target_terminal::init ();
2050 target_terminal::inferior ();
2052 windows_initialization_done
= 0;
2058 struct target_waitstatus status
;
2060 last_ptid
= this->wait (minus_one_ptid
, &status
, 0);
2062 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
2064 if (status
.kind
!= TARGET_WAITKIND_LOADED
2065 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
2068 this->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
2071 switch_to_thread (find_thread_ptid (this, last_ptid
));
2073 /* Now that the inferior has been started and all DLLs have been mapped,
2074 we can iterate over all DLLs and load them in.
2076 We avoid doing it any earlier because, on certain versions of Windows,
2077 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
2078 we have seen on Windows 8.1 that the ntdll.dll load event does not
2079 include the DLL name, preventing us from creating an associated SO.
2080 A possible explanation is that ntdll.dll might be mapped before
2081 the SO info gets created by the Windows system -- ntdll.dll is
2082 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
2083 do not seem to suffer from that problem.
2085 Rather than try to work around this sort of issue, it is much
2086 simpler to just ignore DLL load/unload events during the startup
2087 phase, and then process them all in one batch now. */
2088 windows_add_all_dlls ();
2090 windows_initialization_done
= 1;
2094 /* Try to set or remove a user privilege to the current process. Return -1
2095 if that fails, the previous setting of that privilege otherwise.
2097 This code is copied from the Cygwin source code and rearranged to allow
2098 dynamically loading of the needed symbols from advapi32 which is only
2099 available on NT/2K/XP. */
2101 set_process_privilege (const char *privilege
, BOOL enable
)
2103 HANDLE token_hdl
= NULL
;
2105 TOKEN_PRIVILEGES new_priv
, orig_priv
;
2109 if (!OpenProcessToken (GetCurrentProcess (),
2110 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
2114 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
2117 new_priv
.PrivilegeCount
= 1;
2118 new_priv
.Privileges
[0].Luid
= restore_priv
;
2119 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
2121 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
2122 sizeof orig_priv
, &orig_priv
, &size
))
2125 /* Disabled, otherwise every `attach' in an unprivileged user session
2126 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
2127 windows_attach(). */
2128 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
2129 be enabled. GetLastError () returns an correct error code, though. */
2130 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
2134 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
2138 CloseHandle (token_hdl
);
2143 /* Attach to process PID, then initialize for debugging it. */
2146 windows_nat_target::attach (const char *args
, int from_tty
)
2151 pid
= parse_pid_to_attach (args
);
2153 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
2155 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
2156 printf_unfiltered ("This can cause attach to "
2157 "fail on Windows NT/2K/XP\n");
2160 windows_init_thread_list ();
2161 ok
= DebugActiveProcess (pid
);
2167 /* Try fall back to Cygwin pid. */
2168 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
2171 ok
= DebugActiveProcess (pid
);
2176 error (_("Can't attach to process %u (error %u)"),
2177 (unsigned) pid
, (unsigned) GetLastError ());
2179 DebugSetProcessKillOnExit (FALSE
);
2183 const char *exec_file
= get_exec_file (0);
2186 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
2187 target_pid_to_str (ptid_t (pid
)).c_str ());
2189 printf_unfiltered ("Attaching to %s\n",
2190 target_pid_to_str (ptid_t (pid
)).c_str ());
2194 HANDLE h
= OpenProcess (PROCESS_QUERY_INFORMATION
, FALSE
, pid
);
2198 if (IsWow64Process (h
, &wow64
))
2199 wow64_process
= wow64
;
2204 do_initial_windows_stuff (pid
, 1);
2205 target_terminal::ours ();
2209 windows_nat_target::detach (inferior
*inf
, int from_tty
)
2213 ptid_t ptid
= minus_one_ptid
;
2214 resume (ptid
, 0, GDB_SIGNAL_0
);
2216 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
2218 error (_("Can't detach process %u (error %u)"),
2219 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
2222 DebugSetProcessKillOnExit (FALSE
);
2224 if (detached
&& from_tty
)
2226 const char *exec_file
= get_exec_file (0);
2229 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
2230 (unsigned) current_event
.dwProcessId
);
2233 x86_cleanup_dregs ();
2234 switch_to_no_thread ();
2235 detach_inferior (inf
);
2237 maybe_unpush_target ();
2240 /* Try to determine the executable filename.
2242 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2244 Upon success, the filename is stored inside EXE_NAME_RET, and
2245 this function returns nonzero.
2247 Otherwise, this function returns zero and the contents of
2248 EXE_NAME_RET is undefined. */
2251 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2261 if (!EnumProcessModulesEx (current_process_handle
, &dh_buf
,
2262 sizeof (HMODULE
), &cbNeeded
,
2263 LIST_MODULES_32BIT
) || !cbNeeded
)
2269 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2270 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2274 /* We know the executable is always first in the list of modules,
2275 which we just fetched. So no need to fetch more. */
2279 /* Cygwin prefers that the path be in /x/y/z format, so extract
2280 the filename into a temporary buffer first, and then convert it
2281 to POSIX format into the destination buffer. */
2282 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2284 len
= GetModuleFileNameEx (current_process_handle
,
2285 dh_buf
, pathbuf
, exe_name_max_len
);
2287 error (_("Error getting executable filename: %u."),
2288 (unsigned) GetLastError ());
2289 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2290 exe_name_max_len
) < 0)
2291 error (_("Error converting executable filename to POSIX: %d."), errno
);
2294 len
= GetModuleFileNameEx (current_process_handle
,
2295 dh_buf
, exe_name_ret
, exe_name_max_len
);
2297 error (_("Error getting executable filename: %u."),
2298 (unsigned) GetLastError ());
2301 return 1; /* success */
2304 /* The pid_to_exec_file target_ops method for this platform. */
2307 windows_nat_target::pid_to_exec_file (int pid
)
2309 static char path
[__PMAX
];
2311 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2313 char procexe
[sizeof ("/proc/4294967295/exe")];
2315 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2316 nchars
= readlink (procexe
, path
, sizeof(path
));
2317 if (nchars
> 0 && nchars
< sizeof (path
))
2319 path
[nchars
] = '\0'; /* Got it */
2324 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2325 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2326 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2332 /* Print status information about what we're accessing. */
2335 windows_nat_target::files_info ()
2337 struct inferior
*inf
= current_inferior ();
2339 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2340 inf
->attach_flag
? "attached" : "child",
2341 target_pid_to_str (inferior_ptid
).c_str ());
2344 /* Modify CreateProcess parameters for use of a new separate console.
2346 *FLAGS: DWORD parameter for general process creation flags.
2347 *SI: STARTUPINFO structure, for which the console window size and
2348 console buffer size is filled in if GDB is running in a console.
2349 to create the new console.
2350 The size of the used font is not available on all versions of
2351 Windows OS. Furthermore, the current font might not be the default
2352 font, but this is still better than before.
2353 If the windows and buffer sizes are computed,
2354 SI->DWFLAGS is changed so that this information is used
2355 by CreateProcess function. */
2358 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2360 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2361 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2363 if (hconsole
!= INVALID_HANDLE_VALUE
)
2365 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2367 CONSOLE_FONT_INFO cfi
;
2369 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2370 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2371 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2372 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2373 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2375 si
->dwXSize
*= font_size
.X
;
2379 si
->dwYSize
*= font_size
.Y
;
2382 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2383 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2384 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2386 *flags
|= CREATE_NEW_CONSOLE
;
2390 /* Function called by qsort to sort environment strings. */
2393 envvar_cmp (const void *a
, const void *b
)
2395 const char **p
= (const char **) a
;
2396 const char **q
= (const char **) b
;
2397 return strcasecmp (*p
, *q
);
2403 clear_win32_environment (char **env
)
2407 wchar_t *copy
= NULL
, *equalpos
;
2409 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2411 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2412 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2413 mbstowcs (copy
, env
[i
], len
);
2414 equalpos
= wcschr (copy
, L
'=');
2417 SetEnvironmentVariableW (copy
, NULL
);
2425 /* Redirection of inferior I/O streams for native MS-Windows programs.
2426 Unlike on Unix, where this is handled by invoking the inferior via
2427 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2429 The official documentation of the cmd.exe redirection features is here:
2431 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2433 (That page talks about Windows XP, but there's no newer
2434 documentation, so we assume later versions of cmd.exe didn't change
2437 Caveat: the documentation on that page seems to include a few lies.
2438 For example, it describes strange constructs 1<&2 and 2<&1, which
2439 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2440 think the cmd.exe parser of the redirection symbols simply doesn't
2441 care about the < vs > distinction in these cases. Therefore, the
2442 supported features are explicitly documented below.
2444 The emulation below aims at supporting all the valid use cases
2445 supported by cmd.exe, which include:
2447 < FILE redirect standard input from FILE
2448 0< FILE redirect standard input from FILE
2449 <&N redirect standard input from file descriptor N
2450 0<&N redirect standard input from file descriptor N
2451 > FILE redirect standard output to FILE
2452 >> FILE append standard output to FILE
2453 1>> FILE append standard output to FILE
2454 >&N redirect standard output to file descriptor N
2455 1>&N redirect standard output to file descriptor N
2456 >>&N append standard output to file descriptor N
2457 1>>&N append standard output to file descriptor N
2458 2> FILE redirect standard error to FILE
2459 2>> FILE append standard error to FILE
2460 2>&N redirect standard error to file descriptor N
2461 2>>&N append standard error to file descriptor N
2463 Note that using N > 2 in the above construct is supported, but
2464 requires that the corresponding file descriptor be open by some
2465 means elsewhere or outside GDB. Also note that using ">&0" or
2466 "<&2" will generally fail, because the file descriptor redirected
2467 from is normally open in an incompatible mode (e.g., FD 0 is open
2468 for reading only). IOW, use of such tricks is not recommended;
2469 you are on your own.
2471 We do NOT support redirection of file descriptors above 2, as in
2472 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2473 that needs special handling in the startup code that MinGW
2474 doesn't have). Pipes are also not supported.
2476 As for invalid use cases, where the redirection contains some
2477 error, the emulation below will detect that and produce some
2478 error and/or failure. But the behavior in those cases is not
2479 bug-for-bug compatible with what cmd.exe does in those cases.
2480 That's because what cmd.exe does then is not well defined, and
2481 seems to be a side effect of the cmd.exe parsing of the command
2482 line more than anything else. For example, try redirecting to an
2483 invalid file name, as in "> foo:bar".
2485 There are also minor syntactic deviations from what cmd.exe does
2486 in some corner cases. For example, it doesn't support the likes
2487 of "> &foo" to mean redirect to file named literally "&foo"; we
2488 do support that here, because that, too, sounds like some issue
2489 with the cmd.exe parser. Another nicety is that we support
2490 redirection targets that use file names with forward slashes,
2491 something cmd.exe doesn't -- this comes in handy since GDB
2492 file-name completion can be used when typing the command line for
2495 /* Support routines for redirecting standard handles of the inferior. */
2497 /* Parse a single redirection spec, open/duplicate the specified
2498 file/fd, and assign the appropriate value to one of the 3 standard
2499 file descriptors. */
2501 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2503 int *fd
, ref_fd
= -2;
2505 const char *fname
= redir_string
+ 1;
2506 int rc
= *redir_string
;
2521 fd
= (rc
== '2') ? err
: out
;
2522 mode
= O_WRONLY
| O_CREAT
;
2535 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2537 /* A reference to a file descriptor. */
2539 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2540 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2542 /* Don't allow redirection when open modes are incompatible. */
2543 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2544 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2551 else if (ref_fd
== 1)
2553 else if (ref_fd
== 2)
2563 fname
++; /* skip the separator space */
2564 /* If the descriptor is already open, close it. This allows
2565 multiple specs of redirections for the same stream, which is
2566 somewhat nonsensical, but still valid and supported by cmd.exe.
2567 (But cmd.exe only opens a single file in this case, the one
2568 specified by the last redirection spec on the command line.) */
2573 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2577 else if (ref_fd
== -1)
2578 *fd
= -1; /* reset to default destination */
2581 *fd
= _dup (ref_fd
);
2585 /* _open just sets a flag for O_APPEND, which won't be passed to the
2586 inferior, so we need to actually move the file pointer. */
2587 if ((mode
& O_APPEND
) != 0)
2588 _lseek (*fd
, 0L, SEEK_END
);
2592 /* Canonicalize a single redirection spec and set up the corresponding
2593 file descriptor as specified. */
2595 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2597 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2599 const char *start
= s
;
2602 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2603 if ((*start
== '>' || *start
== '1' || *start
== '2')
2607 if (*s
== '>' && *start
!= '>')
2610 else if (*start
== '0' && *s
== '<')
2612 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2615 while (isspace (*s
)) /* skip whitespace before file name */
2617 *d
++ = ' '; /* separate file name with a single space */
2620 /* Copy the file name. */
2623 /* Remove quoting characters from the file name in buf[]. */
2624 if (*s
== '"') /* could support '..' quoting here */
2628 else if (*s
== quote
)
2636 else if (*s
== '\\')
2638 if (s
[1] == '"') /* could support '..' here */
2642 else if (isspace (*s
) && !quote
)
2646 if (d
- buf
>= sizeof (buf
) - 1)
2648 errno
= ENAMETOOLONG
;
2654 /* Windows doesn't allow redirection characters in file names, so we
2655 can bail out early if they use them, or if there's no target file
2656 name after the redirection symbol. */
2657 if (d
[-1] == '>' || d
[-1] == '<')
2662 if (redir_open (buf
, inp
, out
, err
) == 0)
2667 /* Parse the command line for redirection specs and prepare the file
2668 descriptors for the 3 standard streams accordingly. */
2670 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2671 int *inp
, int *out
, int *err
)
2673 const char *s
= cmd_orig
;
2676 bool retval
= false;
2678 while (isspace (*s
))
2683 if (*s
== '"') /* could also support '..' quoting here */
2687 else if (*s
== quote
)
2690 else if (*s
== '\\')
2692 if (s
[1] == '"') /* escaped quote char */
2697 /* Process a single redirection candidate. */
2698 if (*s
== '<' || *s
== '>'
2699 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2700 || (*s
== '0' && s
[1] == '<'))
2702 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2716 #endif /* !__CYGWIN__ */
2718 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2719 EXEC_FILE is the file to run.
2720 ALLARGS is a string containing the arguments to the program.
2721 ENV is the environment vector to pass. Errors reported with error(). */
2724 windows_nat_target::create_inferior (const char *exec_file
,
2725 const std::string
&origallargs
,
2726 char **in_env
, int from_tty
)
2730 cygwin_buf_t real_path
[__PMAX
];
2731 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2732 cygwin_buf_t infcwd
[__PMAX
];
2734 cygwin_buf_t
*toexec
;
2735 cygwin_buf_t
*cygallargs
;
2737 char **old_env
= NULL
;
2741 int ostdin
, ostdout
, ostderr
;
2742 #else /* !__CYGWIN__ */
2743 char shell
[__PMAX
]; /* Path to shell */
2745 char *args
, *allargs_copy
;
2746 size_t args_len
, allargs_len
;
2747 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2748 HANDLE tty
= INVALID_HANDLE_VALUE
;
2749 bool redirected
= false;
2756 #endif /* !__CYGWIN__ */
2757 const char *allargs
= origallargs
.c_str ();
2758 PROCESS_INFORMATION pi
;
2761 const char *inferior_tty
= current_inferior ()->tty ();
2764 error (_("No executable specified, use `target exec'."));
2766 const char *inferior_cwd
= get_inferior_cwd ();
2767 std::string expanded_infcwd
;
2768 if (inferior_cwd
!= NULL
)
2770 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
2771 /* Mirror slashes on inferior's cwd. */
2772 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
2774 inferior_cwd
= expanded_infcwd
.c_str ();
2777 memset (&si
, 0, sizeof (si
));
2778 si
.cb
= sizeof (si
);
2781 flags
|= CREATE_NEW_PROCESS_GROUP
;
2784 windows_set_console_info (&si
, &flags
);
2789 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2790 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2791 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2792 error (_("Error starting executable: %d"), errno
);
2795 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2796 if (len
== (size_t) -1)
2797 error (_("Error starting executable: %d"), errno
);
2798 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2799 mbstowcs (cygallargs
, allargs
, len
);
2800 #else /* !__USEWIDE */
2801 cygallargs
= allargs
;
2807 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2808 error (_("Error starting executable via shell: %d"), errno
);
2810 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2811 + mbstowcs (NULL
, allargs
, 0) + 2;
2812 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2813 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2814 #else /* !__USEWIDE */
2815 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2816 + strlen (allargs
) + 2);
2817 cygallargs
= (char *) alloca (len
);
2818 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2819 #endif /* __USEWIDE */
2821 flags
|= DEBUG_PROCESS
;
2824 if (inferior_cwd
!= NULL
2825 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
2826 infcwd
, strlen (inferior_cwd
)) < 0)
2827 error (_("Error converting inferior cwd: %d"), errno
);
2830 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2831 * sizeof (wchar_t));
2832 wcscpy (args
, toexec
);
2833 wcscat (args
, L
" ");
2834 wcscat (args
, cygallargs
);
2835 #else /* !__USEWIDE */
2836 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2837 strcpy (args
, toexec
);
2839 strcat (args
, cygallargs
);
2840 #endif /* !__USEWIDE */
2842 #ifdef CW_CVT_ENV_TO_WINENV
2843 /* First try to create a direct Win32 copy of the POSIX environment. */
2844 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2845 if (w32_env
!= (PWCHAR
) -1)
2846 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2848 /* If that fails, fall back to old method tweaking GDB's environment. */
2849 #endif /* CW_CVT_ENV_TO_WINENV */
2851 /* Reset all Win32 environment variables to avoid leftover on next run. */
2852 clear_win32_environment (environ
);
2853 /* Prepare the environment vars for CreateProcess. */
2856 cygwin_internal (CW_SYNC_WINENV
);
2860 if (inferior_tty
== nullptr)
2861 tty
= ostdin
= ostdout
= ostderr
= -1;
2864 tty
= open (inferior_tty
, O_RDWR
| O_NOCTTY
);
2867 print_sys_errmsg (inferior_tty
, errno
);
2868 ostdin
= ostdout
= ostderr
= -1;
2881 windows_init_thread_list ();
2882 ret
= CreateProcess (0,
2883 args
, /* command line */
2884 NULL
, /* Security */
2886 TRUE
, /* inherit handles */
2887 flags
, /* start flags */
2888 w32_env
, /* environment */
2889 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
2894 /* Just free the Win32 environment, if it could be created. */
2898 /* Reset all environment variables to avoid leftover on next run. */
2899 clear_win32_environment (in_env
);
2900 /* Restore normal GDB environment variables. */
2902 cygwin_internal (CW_SYNC_WINENV
);
2915 #else /* !__CYGWIN__ */
2916 allargs_len
= strlen (allargs
);
2917 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
2918 if (strpbrk (allargs_copy
, "<>") != NULL
)
2923 redirect_inferior_handles (allargs
, allargs_copy
,
2924 &fd_inp
, &fd_out
, &fd_err
);
2926 warning (_("Error in redirection: %s."), safe_strerror (errno
));
2929 allargs_len
= strlen (allargs_copy
);
2931 /* If not all the standard streams are redirected by the command
2932 line, use INFERIOR_TTY for those which aren't. */
2933 if (inferior_tty
!= nullptr
2934 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
2936 SECURITY_ATTRIBUTES sa
;
2937 sa
.nLength
= sizeof(sa
);
2938 sa
.lpSecurityDescriptor
= 0;
2939 sa
.bInheritHandle
= TRUE
;
2940 tty
= CreateFileA (inferior_tty
, GENERIC_READ
| GENERIC_WRITE
,
2941 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2942 if (tty
== INVALID_HANDLE_VALUE
)
2943 warning (_("Warning: Failed to open TTY %s, error %#x."),
2944 inferior_tty
, (unsigned) GetLastError ());
2946 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
2949 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
2950 else if (tty
!= INVALID_HANDLE_VALUE
)
2953 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
2955 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
2956 else if (tty
!= INVALID_HANDLE_VALUE
)
2957 si
.hStdOutput
= tty
;
2959 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
2961 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
2962 else if (tty
!= INVALID_HANDLE_VALUE
)
2965 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
2966 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2970 /* Build the command line, a space-separated list of tokens where
2971 the first token is the name of the module to be executed.
2972 To avoid ambiguities introduced by spaces in the module name,
2974 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
2975 args
= (char *) alloca (args_len
);
2976 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
2978 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2980 /* CreateProcess takes the environment list as a null terminated set of
2981 strings (i.e. two nulls terminate the list). */
2983 /* Get total size for env strings. */
2984 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2985 envlen
+= strlen (in_env
[i
]) + 1;
2987 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2988 env
= (char **) alloca (envsize
);
2989 memcpy (env
, in_env
, envsize
);
2990 /* Windows programs expect the environment block to be sorted. */
2991 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2993 w32env
= (char *) alloca (envlen
+ 1);
2995 /* Copy env strings into new buffer. */
2996 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2998 strcpy (temp
, env
[i
]);
2999 temp
+= strlen (temp
) + 1;
3002 /* Final nil string to terminate new env. */
3005 windows_init_thread_list ();
3006 ret
= CreateProcessA (0,
3007 args
, /* command line */
3008 NULL
, /* Security */
3010 TRUE
, /* inherit handles */
3011 flags
, /* start flags */
3012 w32env
, /* environment */
3013 inferior_cwd
, /* current directory */
3016 if (tty
!= INVALID_HANDLE_VALUE
)
3024 #endif /* !__CYGWIN__ */
3027 error (_("Error creating process %s, (error %u)."),
3028 exec_file
, (unsigned) GetLastError ());
3032 if (IsWow64Process (pi
.hProcess
, &wow64
))
3033 wow64_process
= wow64
;
3036 CloseHandle (pi
.hThread
);
3037 CloseHandle (pi
.hProcess
);
3039 if (useshell
&& shell
[0] != '\0')
3044 do_initial_windows_stuff (pi
.dwProcessId
, 0);
3046 /* windows_continue (DBG_CONTINUE, -1, 0); */
3050 windows_nat_target::mourn_inferior ()
3052 (void) windows_continue (DBG_CONTINUE
, -1, 0);
3053 x86_cleanup_dregs();
3054 if (open_process_used
)
3056 CHECK (CloseHandle (current_process_handle
));
3057 open_process_used
= 0;
3059 siginfo_er
.ExceptionCode
= 0;
3060 inf_child_target::mourn_inferior ();
3063 /* Send a SIGINT to the process group. This acts just like the user typed a
3064 ^C on the controlling terminal. */
3067 windows_nat_target::interrupt ()
3069 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
3070 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
3071 registers_changed (); /* refresh register state */
3074 /* Helper for windows_xfer_partial that handles memory transfers.
3075 Arguments are like target_xfer_partial. */
3077 static enum target_xfer_status
3078 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3079 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
3083 DWORD lasterror
= 0;
3085 if (writebuf
!= NULL
)
3087 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
3088 pulongest (len
), core_addr_to_string (memaddr
)));
3089 success
= WriteProcessMemory (current_process_handle
,
3090 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
3093 lasterror
= GetLastError ();
3094 FlushInstructionCache (current_process_handle
,
3095 (LPCVOID
) (uintptr_t) memaddr
, len
);
3099 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
3100 pulongest (len
), core_addr_to_string (memaddr
)));
3101 success
= ReadProcessMemory (current_process_handle
,
3102 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
3105 lasterror
= GetLastError ();
3107 *xfered_len
= (ULONGEST
) done
;
3108 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
3109 return TARGET_XFER_OK
;
3111 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
3115 windows_nat_target::kill ()
3117 CHECK (TerminateProcess (current_process_handle
, 0));
3121 if (!windows_continue (DBG_CONTINUE
, -1, 1))
3123 if (!wait_for_debug_event (¤t_event
, INFINITE
))
3125 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
3129 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
3133 windows_nat_target::close ()
3135 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
3136 inferior_ptid
.pid ()));
3139 /* Convert pid to printable format. */
3141 windows_nat_target::pid_to_str (ptid_t ptid
)
3143 if (ptid
.lwp () != 0)
3144 return string_printf ("Thread %d.0x%lx", ptid
.pid (), ptid
.lwp ());
3146 return normal_pid_to_str (ptid
);
3149 static enum target_xfer_status
3150 windows_xfer_shared_libraries (struct target_ops
*ops
,
3151 enum target_object object
, const char *annex
,
3152 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3153 ULONGEST offset
, ULONGEST len
,
3154 ULONGEST
*xfered_len
)
3156 struct obstack obstack
;
3162 return TARGET_XFER_E_IO
;
3164 obstack_init (&obstack
);
3165 obstack_grow_str (&obstack
, "<library-list>\n");
3166 for (so
= solib_start
.next
; so
; so
= so
->next
)
3168 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
3170 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
3171 (uintptr_t) li
->load_addr
,
3173 target_gdbarch (), &obstack
);
3175 obstack_grow_str0 (&obstack
, "</library-list>\n");
3177 buf
= (const char *) obstack_finish (&obstack
);
3178 len_avail
= strlen (buf
);
3179 if (offset
>= len_avail
)
3183 if (len
> len_avail
- offset
)
3184 len
= len_avail
- offset
;
3185 memcpy (readbuf
, buf
+ offset
, len
);
3188 obstack_free (&obstack
, NULL
);
3189 *xfered_len
= (ULONGEST
) len
;
3190 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
3193 /* Helper for windows_nat_target::xfer_partial that handles signal info. */
3195 static enum target_xfer_status
3196 windows_xfer_siginfo (gdb_byte
*readbuf
, ULONGEST offset
, ULONGEST len
,
3197 ULONGEST
*xfered_len
)
3199 char *buf
= (char *) &siginfo_er
;
3200 size_t bufsize
= sizeof (siginfo_er
);
3203 EXCEPTION_RECORD32 er32
;
3206 buf
= (char *) &er32
;
3207 bufsize
= sizeof (er32
);
3209 er32
.ExceptionCode
= siginfo_er
.ExceptionCode
;
3210 er32
.ExceptionFlags
= siginfo_er
.ExceptionFlags
;
3211 er32
.ExceptionRecord
= (uintptr_t) siginfo_er
.ExceptionRecord
;
3212 er32
.ExceptionAddress
= (uintptr_t) siginfo_er
.ExceptionAddress
;
3213 er32
.NumberParameters
= siginfo_er
.NumberParameters
;
3215 for (i
= 0; i
< EXCEPTION_MAXIMUM_PARAMETERS
; i
++)
3216 er32
.ExceptionInformation
[i
] = siginfo_er
.ExceptionInformation
[i
];
3220 if (siginfo_er
.ExceptionCode
== 0)
3221 return TARGET_XFER_E_IO
;
3223 if (readbuf
== nullptr)
3224 return TARGET_XFER_E_IO
;
3226 if (offset
> bufsize
)
3227 return TARGET_XFER_E_IO
;
3229 if (offset
+ len
> bufsize
)
3230 len
= bufsize
- offset
;
3232 memcpy (readbuf
, buf
+ offset
, len
);
3235 return TARGET_XFER_OK
;
3238 enum target_xfer_status
3239 windows_nat_target::xfer_partial (enum target_object object
,
3240 const char *annex
, gdb_byte
*readbuf
,
3241 const gdb_byte
*writebuf
, ULONGEST offset
,
3242 ULONGEST len
, ULONGEST
*xfered_len
)
3246 case TARGET_OBJECT_MEMORY
:
3247 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
3249 case TARGET_OBJECT_LIBRARIES
:
3250 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
3251 writebuf
, offset
, len
, xfered_len
);
3253 case TARGET_OBJECT_SIGNAL_INFO
:
3254 return windows_xfer_siginfo (readbuf
, offset
, len
, xfered_len
);
3257 if (beneath () == NULL
)
3259 /* This can happen when requesting the transfer of unsupported
3260 objects before a program has been started (and therefore
3261 with the current_target having no target beneath). */
3262 return TARGET_XFER_E_IO
;
3264 return beneath ()->xfer_partial (object
, annex
,
3265 readbuf
, writebuf
, offset
, len
,
3270 /* Provide thread local base, i.e. Thread Information Block address.
3271 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
3274 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
3276 windows_thread_info
*th
;
3278 th
= thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
);
3283 *addr
= th
->thread_local_base
;
3289 windows_nat_target::get_ada_task_ptid (long lwp
, long thread
)
3291 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
3294 /* Implementation of the to_thread_name method. */
3297 windows_nat_target::thread_name (struct thread_info
*thr
)
3299 return thread_rec (thr
->ptid
, DONT_INVALIDATE_CONTEXT
)->name
.get ();
3303 void _initialize_windows_nat ();
3305 _initialize_windows_nat ()
3307 x86_dr_low
.set_control
= cygwin_set_dr7
;
3308 x86_dr_low
.set_addr
= cygwin_set_dr
;
3309 x86_dr_low
.get_addr
= cygwin_get_dr
;
3310 x86_dr_low
.get_status
= cygwin_get_dr6
;
3311 x86_dr_low
.get_control
= cygwin_get_dr7
;
3313 /* x86_dr_low.debug_register_length field is set by
3314 calling x86_set_debug_register_length function
3315 in processor windows specific native file. */
3317 add_inf_child_target (&the_windows_nat_target
);
3320 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3323 add_com ("signal-event", class_run
, signal_event_command
, _("\
3324 Signal a crashed process with event ID, to allow its debugging.\n\
3325 This command is needed in support of setting up GDB as JIT debugger on \
3326 MS-Windows. The command should be invoked from the GDB command line using \
3327 the '-ex' command-line option. The ID of the event that blocks the \
3328 crashed process will be supplied by the Windows JIT debugging mechanism."));
3331 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3332 Set use of shell to start subprocess."), _("\
3333 Show use of shell to start subprocess."), NULL
,
3335 NULL
, /* FIXME: i18n: */
3336 &setlist
, &showlist
);
3338 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3339 &cygwin_exceptions
, _("\
3340 Break when an exception is detected in the Cygwin DLL itself."), _("\
3341 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3343 NULL
, /* FIXME: i18n: */
3344 &setlist
, &showlist
);
3347 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3348 Set creation of new console when creating child process."), _("\
3349 Show creation of new console when creating child process."), NULL
,
3351 NULL
, /* FIXME: i18n: */
3352 &setlist
, &showlist
);
3354 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3355 Set creation of new group when creating child process."), _("\
3356 Show creation of new group when creating child process."), NULL
,
3358 NULL
, /* FIXME: i18n: */
3359 &setlist
, &showlist
);
3361 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3362 Set whether to display execution in child process."), _("\
3363 Show whether to display execution in child process."), NULL
,
3365 NULL
, /* FIXME: i18n: */
3366 &setlist
, &showlist
);
3368 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3369 Set whether to display kernel events in child process."), _("\
3370 Show whether to display kernel events in child process."), NULL
,
3372 NULL
, /* FIXME: i18n: */
3373 &setlist
, &showlist
);
3375 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3376 Set whether to display memory accesses in child process."), _("\
3377 Show whether to display memory accesses in child process."), NULL
,
3379 NULL
, /* FIXME: i18n: */
3380 &setlist
, &showlist
);
3382 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3383 &debug_exceptions
, _("\
3384 Set whether to display kernel exceptions in child process."), _("\
3385 Show whether to display kernel exceptions in child process."), NULL
,
3387 NULL
, /* FIXME: i18n: */
3388 &setlist
, &showlist
);
3390 init_w32_command_list ();
3392 add_cmd ("selector", class_info
, display_selectors
,
3393 _("Display selectors infos."),
3397 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3399 /* Pass the address ADDR to the inferior in the I'th debug register.
3400 Here we just store the address in dr array, the registers will be
3401 actually set up when windows_continue is called. */
3403 cygwin_set_dr (int i
, CORE_ADDR addr
)
3406 internal_error (__FILE__
, __LINE__
,
3407 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3409 debug_registers_changed
= 1;
3410 debug_registers_used
= 1;
3413 /* Pass the value VAL to the inferior in the DR7 debug control
3414 register. Here we just store the address in D_REGS, the watchpoint
3415 will be actually set up in windows_wait. */
3417 cygwin_set_dr7 (unsigned long val
)
3419 dr
[7] = (CORE_ADDR
) val
;
3420 debug_registers_changed
= 1;
3421 debug_registers_used
= 1;
3424 /* Get the value of debug register I from the inferior. */
3427 cygwin_get_dr (int i
)
3432 /* Get the value of the DR6 debug status register from the inferior.
3433 Here we just return the value stored in dr[6]
3434 by the last call to thread_rec for current_event.dwThreadId id. */
3435 static unsigned long
3436 cygwin_get_dr6 (void)
3438 return (unsigned long) dr
[6];
3441 /* Get the value of the DR7 debug status register from the inferior.
3442 Here we just return the value stored in dr[7] by the last call to
3443 thread_rec for current_event.dwThreadId id. */
3445 static unsigned long
3446 cygwin_get_dr7 (void)
3448 return (unsigned long) dr
[7];
3451 /* Determine if the thread referenced by "ptid" is alive
3452 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3453 it means that the thread has died. Otherwise it is assumed to be alive. */
3456 windows_nat_target::thread_alive (ptid_t ptid
)
3458 gdb_assert (ptid
.lwp () != 0);
3460 return (WaitForSingleObject (thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
)->h
, 0)
3464 void _initialize_check_for_gdb_ini ();
3466 _initialize_check_for_gdb_ini ()
3469 if (inhibit_gdbinit
)
3472 homedir
= getenv ("HOME");
3476 char *oldini
= (char *) alloca (strlen (homedir
) +
3477 sizeof ("gdb.ini") + 1);
3478 strcpy (oldini
, homedir
);
3479 p
= strchr (oldini
, '\0');
3480 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3482 strcpy (p
, "gdb.ini");
3483 if (access (oldini
, 0) == 0)
3485 int len
= strlen (oldini
);
3486 char *newini
= (char *) alloca (len
+ 2);
3488 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3489 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3490 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3495 /* Define dummy functions which always return error for the rare cases where
3496 these functions could not be found. */
3498 bad_DebugActiveProcessStop (DWORD w
)
3503 bad_DebugBreakProcess (HANDLE w
)
3508 bad_DebugSetProcessKillOnExit (BOOL w
)
3513 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3520 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3526 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3533 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3539 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3545 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3551 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3559 /* Load any functions which may not be available in ancient versions
3562 void _initialize_loadable ();
3564 _initialize_loadable ()
3568 #define GPA(m, func) \
3569 func = (func ## _ftype *) GetProcAddress (m, #func)
3571 hm
= LoadLibrary ("kernel32.dll");
3574 GPA (hm
, DebugActiveProcessStop
);
3575 GPA (hm
, DebugBreakProcess
);
3576 GPA (hm
, DebugSetProcessKillOnExit
);
3577 GPA (hm
, GetConsoleFontSize
);
3578 GPA (hm
, DebugActiveProcessStop
);
3579 GPA (hm
, GetCurrentConsoleFont
);
3581 GPA (hm
, Wow64SuspendThread
);
3582 GPA (hm
, Wow64GetThreadContext
);
3583 GPA (hm
, Wow64SetThreadContext
);
3584 GPA (hm
, Wow64GetThreadSelectorEntry
);
3588 /* Set variables to dummy versions of these processes if the function
3589 wasn't found in kernel32.dll. */
3590 if (!DebugBreakProcess
)
3591 DebugBreakProcess
= bad_DebugBreakProcess
;
3592 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3594 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3595 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3597 if (!GetConsoleFontSize
)
3598 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3599 if (!GetCurrentConsoleFont
)
3600 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3602 /* Load optional functions used for retrieving filename information
3603 associated with the currently debugged process or its dlls. */
3604 hm
= LoadLibrary ("psapi.dll");
3607 GPA (hm
, EnumProcessModules
);
3609 GPA (hm
, EnumProcessModulesEx
);
3611 GPA (hm
, GetModuleInformation
);
3612 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3613 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3616 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3618 /* Set variables to dummy versions of these processes if the function
3619 wasn't found in psapi.dll. */
3620 EnumProcessModules
= bad_EnumProcessModules
;
3621 GetModuleInformation
= bad_GetModuleInformation
;
3622 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3623 /* This will probably fail on Windows 9x/Me. Let the user know
3624 that we're missing some functionality. */
3626 cannot automatically find executable file or library to read symbols.\n\
3627 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3630 hm
= LoadLibrary ("advapi32.dll");
3633 GPA (hm
, OpenProcessToken
);
3634 GPA (hm
, LookupPrivilegeValueA
);
3635 GPA (hm
, AdjustTokenPrivileges
);
3636 /* Only need to set one of these since if OpenProcessToken fails nothing
3638 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3639 || !AdjustTokenPrivileges
)
3640 OpenProcessToken
= bad_OpenProcessToken
;