1 /* Target-vector operations for controlling windows child processes, for GDB.
3 Copyright (C) 1995-2020 Free Software Foundation, Inc.
5 Contributed by Cygnus Solutions, A Red Hat Company.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 /* Originally by Steve Chamberlain, sac@cygnus.com */
25 #include "frame.h" /* required by inferior.h */
31 #include "completer.h"
35 #include <sys/types.h>
42 #include <sys/cygwin.h>
43 #include <cygwin/version.h>
48 #include "filenames.h"
52 #include "gdb_obstack.h"
53 #include "gdbthread.h"
59 #include "xml-support.h"
62 #include "i386-tdep.h"
63 #include "i387-tdep.h"
65 #include "windows-tdep.h"
66 #include "windows-nat.h"
68 #include "complaints.h"
69 #include "inf-child.h"
70 #include "gdbsupport/gdb_tilde_expand.h"
71 #include "gdbsupport/pathstuff.h"
72 #include "gdbsupport/gdb_wait.h"
73 #include "nat/windows-nat.h"
75 using namespace windows_nat
;
77 #define AdjustTokenPrivileges dyn_AdjustTokenPrivileges
78 #define DebugActiveProcessStop dyn_DebugActiveProcessStop
79 #define DebugBreakProcess dyn_DebugBreakProcess
80 #define DebugSetProcessKillOnExit dyn_DebugSetProcessKillOnExit
81 #define EnumProcessModules dyn_EnumProcessModules
82 #define EnumProcessModulesEx dyn_EnumProcessModulesEx
83 #define GetModuleInformation dyn_GetModuleInformation
84 #define LookupPrivilegeValueA dyn_LookupPrivilegeValueA
85 #define OpenProcessToken dyn_OpenProcessToken
86 #define GetConsoleFontSize dyn_GetConsoleFontSize
87 #define GetCurrentConsoleFont dyn_GetCurrentConsoleFont
88 #define Wow64SuspendThread dyn_Wow64SuspendThread
89 #define Wow64GetThreadContext dyn_Wow64GetThreadContext
90 #define Wow64SetThreadContext dyn_Wow64SetThreadContext
91 #define Wow64GetThreadSelectorEntry dyn_Wow64GetThreadSelectorEntry
93 typedef BOOL
WINAPI (AdjustTokenPrivileges_ftype
) (HANDLE
, BOOL
,
95 DWORD
, PTOKEN_PRIVILEGES
,
97 static AdjustTokenPrivileges_ftype
*AdjustTokenPrivileges
;
99 typedef BOOL
WINAPI (DebugActiveProcessStop_ftype
) (DWORD
);
100 static DebugActiveProcessStop_ftype
*DebugActiveProcessStop
;
102 typedef BOOL
WINAPI (DebugBreakProcess_ftype
) (HANDLE
);
103 static DebugBreakProcess_ftype
*DebugBreakProcess
;
105 typedef BOOL
WINAPI (DebugSetProcessKillOnExit_ftype
) (BOOL
);
106 static DebugSetProcessKillOnExit_ftype
*DebugSetProcessKillOnExit
;
108 typedef BOOL
WINAPI (EnumProcessModules_ftype
) (HANDLE
, HMODULE
*, DWORD
,
110 static EnumProcessModules_ftype
*EnumProcessModules
;
113 typedef BOOL
WINAPI (EnumProcessModulesEx_ftype
) (HANDLE
, HMODULE
*, DWORD
,
115 static EnumProcessModulesEx_ftype
*EnumProcessModulesEx
;
118 typedef BOOL
WINAPI (GetModuleInformation_ftype
) (HANDLE
, HMODULE
,
119 LPMODULEINFO
, DWORD
);
120 static GetModuleInformation_ftype
*GetModuleInformation
;
122 typedef BOOL
WINAPI (LookupPrivilegeValueA_ftype
) (LPCSTR
, LPCSTR
, PLUID
);
123 static LookupPrivilegeValueA_ftype
*LookupPrivilegeValueA
;
125 typedef BOOL
WINAPI (OpenProcessToken_ftype
) (HANDLE
, DWORD
, PHANDLE
);
126 static OpenProcessToken_ftype
*OpenProcessToken
;
128 typedef BOOL
WINAPI (GetCurrentConsoleFont_ftype
) (HANDLE
, BOOL
,
129 CONSOLE_FONT_INFO
*);
130 static GetCurrentConsoleFont_ftype
*GetCurrentConsoleFont
;
132 typedef COORD
WINAPI (GetConsoleFontSize_ftype
) (HANDLE
, DWORD
);
133 static GetConsoleFontSize_ftype
*GetConsoleFontSize
;
136 typedef DWORD
WINAPI (Wow64SuspendThread_ftype
) (HANDLE
);
137 static Wow64SuspendThread_ftype
*Wow64SuspendThread
;
139 typedef BOOL
WINAPI (Wow64GetThreadContext_ftype
) (HANDLE
, PWOW64_CONTEXT
);
140 static Wow64GetThreadContext_ftype
*Wow64GetThreadContext
;
142 typedef BOOL
WINAPI (Wow64SetThreadContext_ftype
) (HANDLE
,
143 const WOW64_CONTEXT
*);
144 static Wow64SetThreadContext_ftype
*Wow64SetThreadContext
;
146 typedef BOOL
WINAPI (Wow64GetThreadSelectorEntry_ftype
) (HANDLE
, DWORD
,
148 static Wow64GetThreadSelectorEntry_ftype
*Wow64GetThreadSelectorEntry
;
153 #undef GetModuleFileNameEx
156 # define __PMAX (MAX_PATH + 1)
157 typedef DWORD
WINAPI (GetModuleFileNameEx_ftype
) (HANDLE
, HMODULE
, LPSTR
, DWORD
);
158 static GetModuleFileNameEx_ftype
*GetModuleFileNameEx
;
159 # define STARTUPINFO STARTUPINFOA
160 # define CreateProcess CreateProcessA
161 # define GetModuleFileNameEx_name "GetModuleFileNameExA"
162 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
164 # define __PMAX PATH_MAX
165 /* The starting and ending address of the cygwin1.dll text segment. */
166 static CORE_ADDR cygwin_load_start
;
167 static CORE_ADDR cygwin_load_end
;
169 typedef wchar_t cygwin_buf_t
;
170 typedef DWORD
WINAPI (GetModuleFileNameEx_ftype
) (HANDLE
, HMODULE
,
172 static GetModuleFileNameEx_ftype
*GetModuleFileNameEx
;
173 # define STARTUPINFO STARTUPINFOW
174 # define CreateProcess CreateProcessW
175 # define GetModuleFileNameEx_name "GetModuleFileNameExW"
176 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExW
179 static int have_saved_context
; /* True if we've saved context from a
182 static CONTEXT saved_context
; /* Contains the saved context from a
186 /* If we're not using the old Cygwin header file set, define the
187 following which never should have been in the generic Win32 API
188 headers in the first place since they were our own invention... */
189 #ifndef _GNU_H_WINDOWS_H
192 FLAG_TRACE_BIT
= 0x100,
196 #ifndef CONTEXT_EXTENDED_REGISTERS
197 /* This macro is only defined on ia32. It only makes sense on this target,
198 so define it as zero if not already defined. */
199 #define CONTEXT_EXTENDED_REGISTERS 0
202 #define CONTEXT_DEBUGGER_DR CONTEXT_FULL | CONTEXT_FLOATING_POINT \
203 | CONTEXT_SEGMENTS | CONTEXT_DEBUG_REGISTERS \
204 | CONTEXT_EXTENDED_REGISTERS
206 static uintptr_t dr
[8];
207 static int debug_registers_changed
;
208 static int debug_registers_used
;
210 static int windows_initialization_done
;
211 #define DR6_CLEAR_VALUE 0xffff0ff0
213 /* The string sent by cygwin when it processes a signal.
214 FIXME: This should be in a cygwin include file. */
215 #ifndef _CYGWIN_SIGNAL_STRING
216 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
219 #define CHECK(x) check (x, __FILE__,__LINE__)
220 #define DEBUG_EXEC(x) if (debug_exec) debug_printf x
221 #define DEBUG_EVENTS(x) if (debug_events) debug_printf x
222 #define DEBUG_MEM(x) if (debug_memory) debug_printf x
223 #define DEBUG_EXCEPT(x) if (debug_exceptions) debug_printf x
225 static void cygwin_set_dr (int i
, CORE_ADDR addr
);
226 static void cygwin_set_dr7 (unsigned long val
);
227 static CORE_ADDR
cygwin_get_dr (int i
);
228 static unsigned long cygwin_get_dr6 (void);
229 static unsigned long cygwin_get_dr7 (void);
231 static std::vector
<windows_thread_info
*> thread_list
;
233 /* Counts of things. */
234 static int saw_create
;
235 static int open_process_used
= 0;
237 static bool wow64_process
= false;
241 static bool new_console
= false;
243 static bool cygwin_exceptions
= false;
245 static bool new_group
= true;
246 static bool debug_exec
= false; /* show execution */
247 static bool debug_events
= false; /* show events from kernel */
248 static bool debug_memory
= false; /* show target memory accesses */
249 static bool debug_exceptions
= false; /* show target exceptions */
250 static bool useshell
= false; /* use shell for subprocesses */
252 /* This vector maps GDB's idea of a register's number into an offset
253 in the windows exception context vector.
255 It also contains the bit mask needed to load the register in question.
257 The contents of this table can only be computed by the units
258 that provide CPU-specific support for Windows native debugging.
259 These units should set the table by calling
260 windows_set_context_register_offsets.
262 One day we could read a reg, we could inspect the context we
263 already have loaded, if it doesn't have the bit set that we need,
264 we read that set of registers in using GetThreadContext. If the
265 context already contains what we need, we just unpack it. Then to
266 write a register, first we have to ensure that the context contains
267 the other regs of the group, and then we copy the info in and set
270 static const int *mappings
;
272 /* The function to use in order to determine whether a register is
273 a segment register or not. */
274 static segment_register_p_ftype
*segment_register_p
;
276 /* See windows_nat_target::resume to understand why this is commented
279 /* This vector maps the target's idea of an exception (extracted
280 from the DEBUG_EVENT structure) to GDB's idea. */
282 struct xlate_exception
288 static const struct xlate_exception xlate
[] =
290 {EXCEPTION_ACCESS_VIOLATION
, GDB_SIGNAL_SEGV
},
291 {STATUS_STACK_OVERFLOW
, GDB_SIGNAL_SEGV
},
292 {EXCEPTION_BREAKPOINT
, GDB_SIGNAL_TRAP
},
293 {DBG_CONTROL_C
, GDB_SIGNAL_INT
},
294 {EXCEPTION_SINGLE_STEP
, GDB_SIGNAL_TRAP
},
295 {STATUS_FLOAT_DIVIDE_BY_ZERO
, GDB_SIGNAL_FPE
}
300 struct windows_nat_target final
: public x86_nat_target
<inf_child_target
>
302 void close () override
;
304 void attach (const char *, int) override
;
306 bool attach_no_wait () override
309 void detach (inferior
*, int) override
;
311 void resume (ptid_t
, int , enum gdb_signal
) override
;
313 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
315 void fetch_registers (struct regcache
*, int) override
;
316 void store_registers (struct regcache
*, int) override
;
318 bool stopped_by_sw_breakpoint () override
320 return current_windows_thread
->stopped_at_software_breakpoint
;
323 bool supports_stopped_by_sw_breakpoint () override
328 enum target_xfer_status
xfer_partial (enum target_object object
,
331 const gdb_byte
*writebuf
,
332 ULONGEST offset
, ULONGEST len
,
333 ULONGEST
*xfered_len
) override
;
335 void files_info () override
;
337 void kill () override
;
339 void create_inferior (const char *, const std::string
&,
340 char **, int) override
;
342 void mourn_inferior () override
;
344 bool thread_alive (ptid_t ptid
) override
;
346 std::string
pid_to_str (ptid_t
) override
;
348 void interrupt () override
;
350 char *pid_to_exec_file (int pid
) override
;
352 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
354 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
356 const char *thread_name (struct thread_info
*) override
;
358 int get_windows_debug_event (int pid
, struct target_waitstatus
*ourstatus
);
361 static windows_nat_target the_windows_nat_target
;
363 /* Set the MAPPINGS static global to OFFSETS.
364 See the description of MAPPINGS for more details. */
367 windows_set_context_register_offsets (const int *offsets
)
372 /* Set the function that should be used by this module to determine
373 whether a given register is a segment register or not. */
376 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
378 segment_register_p
= fun
;
382 check (BOOL ok
, const char *file
, int line
)
385 printf_filtered ("error return %s:%d was %u\n", file
, line
,
386 (unsigned) GetLastError ());
389 /* See nat/windows-nat.h. */
391 windows_thread_info
*
392 windows_nat::thread_rec (ptid_t ptid
, thread_disposition_type disposition
)
394 for (windows_thread_info
*th
: thread_list
)
395 if (th
->tid
== ptid
.lwp ())
401 case DONT_INVALIDATE_CONTEXT
:
404 case INVALIDATE_CONTEXT
:
405 if (ptid
.lwp () != current_event
.dwThreadId
)
407 th
->reload_context
= true;
410 th
->reload_context
= true;
421 /* Add a thread to the thread list.
423 PTID is the ptid of the thread to be added.
424 H is its Windows handle.
425 TLB is its thread local base.
426 MAIN_THREAD_P should be true if the thread to be added is
427 the main thread, false otherwise. */
429 static windows_thread_info
*
430 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
, bool main_thread_p
)
432 windows_thread_info
*th
;
434 gdb_assert (ptid
.lwp () != 0);
436 if ((th
= thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
)))
439 CORE_ADDR base
= (CORE_ADDR
) (uintptr_t) tlb
;
441 /* For WOW64 processes, this is actually the pointer to the 64bit TIB,
442 and the 32bit TIB is exactly 2 pages after it. */
446 th
= new windows_thread_info (ptid
.lwp (), h
, base
);
447 thread_list
.push_back (th
);
449 /* Add this new thread to the list of threads.
451 To be consistent with what's done on other platforms, we add
452 the main thread silently (in reality, this thread is really
453 more of a process to the user than a thread). */
455 add_thread_silent (&the_windows_nat_target
, ptid
);
457 add_thread (&the_windows_nat_target
, ptid
);
459 /* Set the debug registers for the new thread if they are used. */
460 if (debug_registers_used
)
465 /* Only change the value of the debug registers. */
466 th
->wow64_context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
467 CHECK (Wow64GetThreadContext (th
->h
, &th
->wow64_context
));
468 th
->wow64_context
.Dr0
= dr
[0];
469 th
->wow64_context
.Dr1
= dr
[1];
470 th
->wow64_context
.Dr2
= dr
[2];
471 th
->wow64_context
.Dr3
= dr
[3];
472 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
473 th
->wow64_context
.Dr7
= dr
[7];
474 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
475 th
->wow64_context
.ContextFlags
= 0;
480 /* Only change the value of the debug registers. */
481 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
482 CHECK (GetThreadContext (th
->h
, &th
->context
));
483 th
->context
.Dr0
= dr
[0];
484 th
->context
.Dr1
= dr
[1];
485 th
->context
.Dr2
= dr
[2];
486 th
->context
.Dr3
= dr
[3];
487 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
488 th
->context
.Dr7
= dr
[7];
489 CHECK (SetThreadContext (th
->h
, &th
->context
));
490 th
->context
.ContextFlags
= 0;
496 /* Clear out any old thread list and reinitialize it to a
499 windows_init_thread_list (void)
501 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
504 for (windows_thread_info
*here
: thread_list
)
507 thread_list
.clear ();
510 /* Delete a thread from the list of threads.
512 PTID is the ptid of the thread to be deleted.
513 EXIT_CODE is the thread's exit code.
514 MAIN_THREAD_P should be true if the thread to be deleted is
515 the main thread, false otherwise. */
518 windows_delete_thread (ptid_t ptid
, DWORD exit_code
, bool main_thread_p
)
522 gdb_assert (ptid
.lwp () != 0);
526 /* Emit a notification about the thread being deleted.
528 Note that no notification was printed when the main thread
529 was created, and thus, unless in verbose mode, we should be
530 symmetrical, and avoid that notification for the main thread
534 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
).c_str ());
535 else if (print_thread_events
&& !main_thread_p
)
536 printf_unfiltered (_("[%s exited with code %u]\n"),
537 target_pid_to_str (ptid
).c_str (),
538 (unsigned) exit_code
);
540 delete_thread (find_thread_ptid (&the_windows_nat_target
, ptid
));
542 auto iter
= std::find_if (thread_list
.begin (), thread_list
.end (),
543 [=] (windows_thread_info
*th
)
545 return th
->tid
== id
;
548 if (iter
!= thread_list
.end ())
551 thread_list
.erase (iter
);
555 /* Fetches register number R from the given windows_thread_info,
556 and supplies its value to the given regcache.
558 This function assumes that R is non-negative. A failed assertion
559 is raised if that is not true.
561 This function assumes that TH->RELOAD_CONTEXT is not set, meaning
562 that the windows_thread_info has an up-to-date context. A failed
563 assertion is raised if that assumption is violated. */
566 windows_fetch_one_register (struct regcache
*regcache
,
567 windows_thread_info
*th
, int r
)
570 gdb_assert (!th
->reload_context
);
572 char *context_ptr
= (char *) &th
->context
;
575 context_ptr
= (char *) &th
->wow64_context
;
578 char *context_offset
= context_ptr
+ mappings
[r
];
579 struct gdbarch
*gdbarch
= regcache
->arch ();
580 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
582 gdb_assert (!gdbarch_read_pc_p (gdbarch
));
583 gdb_assert (gdbarch_pc_regnum (gdbarch
) >= 0);
584 gdb_assert (!gdbarch_write_pc_p (gdbarch
));
586 if (r
== I387_FISEG_REGNUM (tdep
))
588 long l
= *((long *) context_offset
) & 0xffff;
589 regcache
->raw_supply (r
, (char *) &l
);
591 else if (r
== I387_FOP_REGNUM (tdep
))
593 long l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
594 regcache
->raw_supply (r
, (char *) &l
);
596 else if (segment_register_p (r
))
598 /* GDB treats segment registers as 32bit registers, but they are
599 in fact only 16 bits long. Make sure we do not read extra
600 bits from our source buffer. */
601 long l
= *((long *) context_offset
) & 0xffff;
602 regcache
->raw_supply (r
, (char *) &l
);
606 if (th
->stopped_at_software_breakpoint
608 && r
== gdbarch_pc_regnum (gdbarch
))
610 int size
= register_size (gdbarch
, r
);
614 memcpy (&value
, context_offset
, size
);
615 value
-= gdbarch_decr_pc_after_break (gdbarch
);
616 memcpy (context_offset
, &value
, size
);
620 gdb_assert (size
== 8);
622 memcpy (&value
, context_offset
, size
);
623 value
-= gdbarch_decr_pc_after_break (gdbarch
);
624 memcpy (context_offset
, &value
, size
);
626 /* Make sure we only rewrite the PC a single time. */
627 th
->pc_adjusted
= true;
629 regcache
->raw_supply (r
, context_offset
);
634 windows_nat_target::fetch_registers (struct regcache
*regcache
, int r
)
636 windows_thread_info
*th
= thread_rec (regcache
->ptid (), INVALIDATE_CONTEXT
);
638 /* Check if TH exists. Windows sometimes uses a non-existent
639 thread id in its events. */
643 if (th
->reload_context
)
646 if (have_saved_context
)
648 /* Lie about where the program actually is stopped since
649 cygwin has informed us that we should consider the signal
650 to have occurred at another location which is stored in
652 memcpy (&th
->context
, &saved_context
,
653 __COPY_CONTEXT_SIZE
);
654 have_saved_context
= 0;
661 th
->wow64_context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
662 CHECK (Wow64GetThreadContext (th
->h
, &th
->wow64_context
));
663 /* Copy dr values from that thread.
664 But only if there were not modified since last stop.
666 if (!debug_registers_changed
)
668 dr
[0] = th
->wow64_context
.Dr0
;
669 dr
[1] = th
->wow64_context
.Dr1
;
670 dr
[2] = th
->wow64_context
.Dr2
;
671 dr
[3] = th
->wow64_context
.Dr3
;
672 dr
[6] = th
->wow64_context
.Dr6
;
673 dr
[7] = th
->wow64_context
.Dr7
;
679 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
680 CHECK (GetThreadContext (th
->h
, &th
->context
));
681 /* Copy dr values from that thread.
682 But only if there were not modified since last stop.
684 if (!debug_registers_changed
)
686 dr
[0] = th
->context
.Dr0
;
687 dr
[1] = th
->context
.Dr1
;
688 dr
[2] = th
->context
.Dr2
;
689 dr
[3] = th
->context
.Dr3
;
690 dr
[6] = th
->context
.Dr6
;
691 dr
[7] = th
->context
.Dr7
;
694 th
->reload_context
= false;
698 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch()); r
++)
699 windows_fetch_one_register (regcache
, th
, r
);
701 windows_fetch_one_register (regcache
, th
, r
);
704 /* Collect the register number R from the given regcache, and store
705 its value into the corresponding area of the given thread's context.
707 This function assumes that R is non-negative. A failed assertion
708 assertion is raised if that is not true. */
711 windows_store_one_register (const struct regcache
*regcache
,
712 windows_thread_info
*th
, int r
)
716 char *context_ptr
= (char *) &th
->context
;
719 context_ptr
= (char *) &th
->wow64_context
;
722 regcache
->raw_collect (r
, context_ptr
+ mappings
[r
]);
725 /* Store a new register value into the context of the thread tied to
729 windows_nat_target::store_registers (struct regcache
*regcache
, int r
)
731 windows_thread_info
*th
= thread_rec (regcache
->ptid (), INVALIDATE_CONTEXT
);
733 /* Check if TH exists. Windows sometimes uses a non-existent
734 thread id in its events. */
739 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch ()); r
++)
740 windows_store_one_register (regcache
, th
, r
);
742 windows_store_one_register (regcache
, th
, r
);
745 /* Maintain a linked list of "so" information. */
746 struct lm_info_windows
: public lm_info_base
748 LPVOID load_addr
= 0;
749 CORE_ADDR text_offset
= 0;
752 static struct so_list solib_start
, *solib_end
;
754 static struct so_list
*
755 windows_make_so (const char *name
, LPVOID load_addr
)
762 WIN32_FIND_DATA w32_fd
;
763 HANDLE h
= FindFirstFile(name
, &w32_fd
);
765 if (h
== INVALID_HANDLE_VALUE
)
771 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
773 p
= strrchr (buf
, '\\');
776 SetCurrentDirectory (buf
);
777 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
778 SetCurrentDirectory (cwd
);
781 if (strcasecmp (buf
, "ntdll.dll") == 0)
783 GetSystemDirectory (buf
, sizeof (buf
));
784 strcat (buf
, "\\ntdll.dll");
787 cygwin_buf_t buf
[__PMAX
];
790 if (access (name
, F_OK
) != 0)
792 if (strcasecmp (name
, "ntdll.dll") == 0)
795 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
796 wcscat (buf
, L
"\\ntdll.dll");
800 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
801 strcat (buf
, "\\ntdll.dll");
806 so
= XCNEW (struct so_list
);
807 lm_info_windows
*li
= new lm_info_windows
;
809 li
->load_addr
= load_addr
;
810 strcpy (so
->so_original_name
, name
);
812 strcpy (so
->so_name
, buf
);
815 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
816 SO_NAME_MAX_PATH_SIZE
);
819 char *rname
= realpath (name
, NULL
);
820 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
822 strcpy (so
->so_name
, rname
);
827 warning (_("dll path for \"%s\" too long or inaccessible"), name
);
828 strcpy (so
->so_name
, so
->so_original_name
);
831 /* Record cygwin1.dll .text start/end. */
832 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
833 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
835 asection
*text
= NULL
;
837 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386"));
842 if (bfd_check_format (abfd
.get (), bfd_object
))
843 text
= bfd_get_section_by_name (abfd
.get (), ".text");
848 /* The symbols in a dll are offset by 0x1000, which is the
849 offset from 0 of the first byte in an image - because of the
850 file header and the section alignment. */
851 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
853 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (text
);
860 /* See nat/windows-nat.h. */
863 windows_nat::handle_load_dll ()
865 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
866 const char *dll_name
;
868 /* Try getting the DLL name via the lpImageName field of the event.
869 Note that Microsoft documents this fields as strictly optional,
870 in the sense that it might be NULL. And the first DLL event in
871 particular is explicitly documented as "likely not pass[ed]"
872 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
873 dll_name
= get_image_name (current_process_handle
,
874 event
->lpImageName
, event
->fUnicode
);
878 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
879 solib_end
= solib_end
->next
;
881 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
883 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
884 host_address_to_string (li
->load_addr
)));
888 windows_free_so (struct so_list
*so
)
890 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
896 /* See nat/windows-nat.h. */
899 windows_nat::handle_unload_dll ()
901 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
904 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
906 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
908 if (li_next
->load_addr
== lpBaseOfDll
)
910 struct so_list
*sodel
= so
->next
;
912 so
->next
= sodel
->next
;
915 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
917 windows_free_so (sodel
);
922 /* We did not find any DLL that was previously loaded at this address,
923 so register a complaint. We do not report an error, because we have
924 observed that this may be happening under some circumstances. For
925 instance, running 32bit applications on x64 Windows causes us to receive
926 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
927 events are apparently caused by the WOW layer, the interface between
928 32bit and 64bit worlds). */
929 complaint (_("dll starting at %s not found."),
930 host_address_to_string (lpBaseOfDll
));
933 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
937 catch_errors (void (*func
) ())
943 catch (const gdb_exception
&ex
)
945 exception_print (gdb_stderr
, ex
);
949 /* Clear list of loaded DLLs. */
951 windows_clear_solib (void)
955 for (so
= solib_start
.next
; so
; so
= solib_start
.next
)
957 solib_start
.next
= so
->next
;
958 windows_free_so (so
);
961 solib_end
= &solib_start
;
965 signal_event_command (const char *args
, int from_tty
)
967 uintptr_t event_id
= 0;
968 char *endargs
= NULL
;
971 error (_("signal-event requires an argument (integer event id)"));
973 event_id
= strtoumax (args
, &endargs
, 10);
975 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
976 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
977 error (_("Failed to convert `%s' to event id"), args
);
979 SetEvent ((HANDLE
) event_id
);
980 CloseHandle ((HANDLE
) event_id
);
983 /* See nat/windows-nat.h. */
986 windows_nat::handle_output_debug_string (struct target_waitstatus
*ourstatus
)
990 gdb::unique_xmalloc_ptr
<char> s
991 = (target_read_string
992 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
994 if (s
== nullptr || !*(s
.get ()))
996 else if (!startswith (s
.get (), _CYGWIN_SIGNAL_STRING
))
999 if (!startswith (s
.get (), "cYg"))
1002 char *p
= strchr (s
.get (), '\0');
1004 if (p
> s
.get () && *--p
== '\n')
1006 warning (("%s"), s
.get ());
1012 /* Got a cygwin signal marker. A cygwin signal is followed by
1013 the signal number itself and then optionally followed by the
1014 thread id and address to saved context within the DLL. If
1015 these are supplied, then the given thread is assumed to have
1016 issued the signal and the context from the thread is assumed
1017 to be stored at the given address in the inferior. Tell gdb
1018 to treat this like a real signal. */
1020 int sig
= strtol (s
.get () + sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
1021 gdb_signal gotasig
= gdb_signal_from_host (sig
);
1023 ourstatus
->value
.sig
= gotasig
;
1029 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1030 retval
= strtoul (p
, &p
, 0);
1032 retval
= current_event
.dwThreadId
;
1033 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
1034 && ReadProcessMemory (current_process_handle
, x
,
1036 __COPY_CONTEXT_SIZE
, &n
)
1037 && n
== __COPY_CONTEXT_SIZE
)
1038 have_saved_context
= 1;
1047 display_selector (HANDLE thread
, DWORD sel
)
1053 ret
= Wow64GetThreadSelectorEntry (thread
, sel
, &info
);
1056 ret
= GetThreadSelectorEntry (thread
, sel
, &info
);
1060 printf_filtered ("0x%03x: ", (unsigned) sel
);
1061 if (!info
.HighWord
.Bits
.Pres
)
1063 puts_filtered ("Segment not present\n");
1066 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1067 (info
.HighWord
.Bits
.BaseMid
<< 16)
1069 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1070 if (info
.HighWord
.Bits
.Granularity
)
1071 limit
= (limit
<< 12) | 0xfff;
1072 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1073 if (info
.HighWord
.Bits
.Default_Big
)
1074 puts_filtered(" 32-bit ");
1076 puts_filtered(" 16-bit ");
1077 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1080 puts_filtered ("Data (Read-Only, Exp-up");
1083 puts_filtered ("Data (Read/Write, Exp-up");
1086 puts_filtered ("Unused segment (");
1089 puts_filtered ("Data (Read/Write, Exp-down");
1092 puts_filtered ("Code (Exec-Only, N.Conf");
1095 puts_filtered ("Code (Exec/Read, N.Conf");
1098 puts_filtered ("Code (Exec-Only, Conf");
1101 puts_filtered ("Code (Exec/Read, Conf");
1104 printf_filtered ("Unknown type 0x%lx",
1105 (unsigned long) info
.HighWord
.Bits
.Type
);
1107 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1108 puts_filtered(", N.Acc");
1109 puts_filtered (")\n");
1110 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1111 puts_filtered("System selector ");
1112 printf_filtered ("Priviledge level = %ld. ",
1113 (unsigned long) info
.HighWord
.Bits
.Dpl
);
1114 if (info
.HighWord
.Bits
.Granularity
)
1115 puts_filtered ("Page granular.\n");
1117 puts_filtered ("Byte granular.\n");
1122 DWORD err
= GetLastError ();
1123 if (err
== ERROR_NOT_SUPPORTED
)
1124 printf_filtered ("Function not supported\n");
1126 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1132 display_selectors (const char * args
, int from_tty
)
1134 if (!current_windows_thread
)
1136 puts_filtered ("Impossible to display selectors now.\n");
1144 puts_filtered ("Selector $cs\n");
1145 display_selector (current_windows_thread
->h
,
1146 current_windows_thread
->wow64_context
.SegCs
);
1147 puts_filtered ("Selector $ds\n");
1148 display_selector (current_windows_thread
->h
,
1149 current_windows_thread
->wow64_context
.SegDs
);
1150 puts_filtered ("Selector $es\n");
1151 display_selector (current_windows_thread
->h
,
1152 current_windows_thread
->wow64_context
.SegEs
);
1153 puts_filtered ("Selector $ss\n");
1154 display_selector (current_windows_thread
->h
,
1155 current_windows_thread
->wow64_context
.SegSs
);
1156 puts_filtered ("Selector $fs\n");
1157 display_selector (current_windows_thread
->h
,
1158 current_windows_thread
->wow64_context
.SegFs
);
1159 puts_filtered ("Selector $gs\n");
1160 display_selector (current_windows_thread
->h
,
1161 current_windows_thread
->wow64_context
.SegGs
);
1166 puts_filtered ("Selector $cs\n");
1167 display_selector (current_windows_thread
->h
,
1168 current_windows_thread
->context
.SegCs
);
1169 puts_filtered ("Selector $ds\n");
1170 display_selector (current_windows_thread
->h
,
1171 current_windows_thread
->context
.SegDs
);
1172 puts_filtered ("Selector $es\n");
1173 display_selector (current_windows_thread
->h
,
1174 current_windows_thread
->context
.SegEs
);
1175 puts_filtered ("Selector $ss\n");
1176 display_selector (current_windows_thread
->h
,
1177 current_windows_thread
->context
.SegSs
);
1178 puts_filtered ("Selector $fs\n");
1179 display_selector (current_windows_thread
->h
,
1180 current_windows_thread
->context
.SegFs
);
1181 puts_filtered ("Selector $gs\n");
1182 display_selector (current_windows_thread
->h
,
1183 current_windows_thread
->context
.SegGs
);
1189 sel
= parse_and_eval_long (args
);
1190 printf_filtered ("Selector \"%s\"\n",args
);
1191 display_selector (current_windows_thread
->h
, sel
);
1195 /* See nat/windows-nat.h. */
1198 windows_nat::handle_ms_vc_exception (const EXCEPTION_RECORD
*rec
)
1200 if (rec
->NumberParameters
>= 3
1201 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1203 DWORD named_thread_id
;
1204 windows_thread_info
*named_thread
;
1205 CORE_ADDR thread_name_target
;
1207 thread_name_target
= rec
->ExceptionInformation
[1];
1208 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1210 if (named_thread_id
== (DWORD
) -1)
1211 named_thread_id
= current_event
.dwThreadId
;
1213 named_thread
= thread_rec (ptid_t (current_event
.dwProcessId
,
1214 named_thread_id
, 0),
1215 DONT_INVALIDATE_CONTEXT
);
1216 if (named_thread
!= NULL
)
1218 int thread_name_len
;
1219 gdb::unique_xmalloc_ptr
<char> thread_name
1220 = target_read_string (thread_name_target
, 1025, &thread_name_len
);
1221 if (thread_name_len
> 0)
1223 thread_name
.get ()[thread_name_len
- 1] = '\0';
1224 named_thread
->name
= std::move (thread_name
);
1234 /* See nat/windows-nat.h. */
1237 windows_nat::handle_access_violation (const EXCEPTION_RECORD
*rec
)
1240 /* See if the access violation happened within the cygwin DLL
1241 itself. Cygwin uses a kind of exception handling to deal with
1242 passed-in invalid addresses. gdb should not treat these as real
1243 SEGVs since they will be silently handled by cygwin. A real SEGV
1244 will (theoretically) be caught by cygwin later in the process and
1245 will be sent as a cygwin-specific-signal. So, ignore SEGVs if
1246 they show up within the text segment of the DLL itself. */
1248 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1250 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1251 && addr
< cygwin_load_end
))
1252 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1253 && startswith (fn
, "KERNEL32!IsBad")))
1259 /* Resume thread specified by ID, or all artificially suspended
1260 threads, if we are continuing execution. KILLED non-zero means we
1261 have killed the inferior, so we should ignore weird errors due to
1262 threads shutting down. */
1264 windows_continue (DWORD continue_status
, int id
, int killed
)
1268 desired_stop_thread_id
= id
;
1270 if (matching_pending_stop (debug_events
))
1273 for (windows_thread_info
*th
: thread_list
)
1274 if (id
== -1 || id
== (int) th
->tid
)
1281 if (debug_registers_changed
)
1283 th
->wow64_context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1284 th
->wow64_context
.Dr0
= dr
[0];
1285 th
->wow64_context
.Dr1
= dr
[1];
1286 th
->wow64_context
.Dr2
= dr
[2];
1287 th
->wow64_context
.Dr3
= dr
[3];
1288 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1289 th
->wow64_context
.Dr7
= dr
[7];
1291 if (th
->wow64_context
.ContextFlags
)
1295 if (GetExitCodeThread (th
->h
, &ec
)
1296 && ec
== STILL_ACTIVE
)
1298 BOOL status
= Wow64SetThreadContext (th
->h
,
1299 &th
->wow64_context
);
1304 th
->wow64_context
.ContextFlags
= 0;
1310 if (debug_registers_changed
)
1312 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1313 th
->context
.Dr0
= dr
[0];
1314 th
->context
.Dr1
= dr
[1];
1315 th
->context
.Dr2
= dr
[2];
1316 th
->context
.Dr3
= dr
[3];
1317 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1318 th
->context
.Dr7
= dr
[7];
1320 if (th
->context
.ContextFlags
)
1324 if (GetExitCodeThread (th
->h
, &ec
)
1325 && ec
== STILL_ACTIVE
)
1327 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1332 th
->context
.ContextFlags
= 0;
1339 /* When single-stepping a specific thread, other threads must
1344 res
= continue_last_debug_event (continue_status
, debug_events
);
1347 error (_("Failed to resume program execution"
1348 " (ContinueDebugEvent failed, error %u)"),
1349 (unsigned int) GetLastError ());
1351 debug_registers_changed
= 0;
1355 /* Called in pathological case where Windows fails to send a
1356 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1358 fake_create_process (void)
1360 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1361 current_event
.dwProcessId
);
1362 if (current_process_handle
!= NULL
)
1363 open_process_used
= 1;
1366 error (_("OpenProcess call failed, GetLastError = %u"),
1367 (unsigned) GetLastError ());
1368 /* We can not debug anything in that case. */
1370 current_windows_thread
1371 = windows_add_thread (ptid_t (current_event
.dwProcessId
,
1372 current_event
.dwThreadId
, 0),
1373 current_event
.u
.CreateThread
.hThread
,
1374 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1375 true /* main_thread_p */);
1376 return current_event
.dwThreadId
;
1380 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1382 windows_thread_info
*th
;
1383 DWORD continue_status
= DBG_CONTINUE
;
1385 /* A specific PTID means `step only this thread id'. */
1386 int resume_all
= ptid
== minus_one_ptid
;
1388 /* If we're continuing all threads, it's the current inferior that
1389 should be handled specially. */
1391 ptid
= inferior_ptid
;
1393 if (sig
!= GDB_SIGNAL_0
)
1395 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1397 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1399 else if (sig
== last_sig
)
1400 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1403 /* This code does not seem to work, because
1404 the kernel does probably not consider changes in the ExceptionRecord
1405 structure when passing the exception to the inferior.
1406 Note that this seems possible in the exception handler itself. */
1408 for (const xlate_exception
&x
: xlate
)
1411 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1413 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1416 if (continue_status
== DBG_CONTINUE
)
1418 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1422 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1426 last_sig
= GDB_SIGNAL_0
;
1428 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=0x%x, step=%d, sig=%d);\n",
1429 ptid
.pid (), (unsigned) ptid
.lwp (), step
, sig
));
1431 /* Get context for currently selected thread. */
1432 th
= thread_rec (inferior_ptid
, DONT_INVALIDATE_CONTEXT
);
1440 /* Single step by setting t bit. */
1441 struct regcache
*regcache
= get_current_regcache ();
1442 struct gdbarch
*gdbarch
= regcache
->arch ();
1443 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1444 th
->wow64_context
.EFlags
|= FLAG_TRACE_BIT
;
1447 if (th
->wow64_context
.ContextFlags
)
1449 if (debug_registers_changed
)
1451 th
->wow64_context
.Dr0
= dr
[0];
1452 th
->wow64_context
.Dr1
= dr
[1];
1453 th
->wow64_context
.Dr2
= dr
[2];
1454 th
->wow64_context
.Dr3
= dr
[3];
1455 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1456 th
->wow64_context
.Dr7
= dr
[7];
1458 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
1459 th
->wow64_context
.ContextFlags
= 0;
1467 /* Single step by setting t bit. */
1468 struct regcache
*regcache
= get_current_regcache ();
1469 struct gdbarch
*gdbarch
= regcache
->arch ();
1470 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1471 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1474 if (th
->context
.ContextFlags
)
1476 if (debug_registers_changed
)
1478 th
->context
.Dr0
= dr
[0];
1479 th
->context
.Dr1
= dr
[1];
1480 th
->context
.Dr2
= dr
[2];
1481 th
->context
.Dr3
= dr
[3];
1482 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1483 th
->context
.Dr7
= dr
[7];
1485 CHECK (SetThreadContext (th
->h
, &th
->context
));
1486 th
->context
.ContextFlags
= 0;
1491 /* Allow continuing with the same signal that interrupted us.
1492 Otherwise complain. */
1495 windows_continue (continue_status
, -1, 0);
1497 windows_continue (continue_status
, ptid
.lwp (), 0);
1500 /* Ctrl-C handler used when the inferior is not run in the same console. The
1501 handler is in charge of interrupting the inferior using DebugBreakProcess.
1502 Note that this function is not available prior to Windows XP. In this case
1503 we emit a warning. */
1505 ctrl_c_handler (DWORD event_type
)
1507 const int attach_flag
= current_inferior ()->attach_flag
;
1509 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1510 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1513 /* If the inferior and the debugger share the same console, do nothing as
1514 the inferior has also received the Ctrl-C event. */
1515 if (!new_console
&& !attach_flag
)
1518 if (!DebugBreakProcess (current_process_handle
))
1519 warning (_("Could not interrupt program. "
1520 "Press Ctrl-c in the program console."));
1522 /* Return true to tell that Ctrl-C has been handled. */
1526 /* Get the next event from the child. Returns a non-zero thread id if the event
1527 requires handling by WFI (or whatever). */
1530 windows_nat_target::get_windows_debug_event (int pid
,
1531 struct target_waitstatus
*ourstatus
)
1534 DWORD continue_status
, event_code
;
1535 windows_thread_info
*th
;
1536 static windows_thread_info
dummy_thread_info (0, 0, 0);
1537 DWORD thread_id
= 0;
1539 /* If there is a relevant pending stop, report it now. See the
1540 comment by the definition of "pending_stops" for details on why
1542 gdb::optional
<pending_stop
> stop
= fetch_pending_stop (debug_events
);
1543 if (stop
.has_value ())
1545 thread_id
= stop
->thread_id
;
1546 *ourstatus
= stop
->status
;
1548 inferior_ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1549 current_windows_thread
= thread_rec (inferior_ptid
,
1550 INVALIDATE_CONTEXT
);
1551 current_windows_thread
->reload_context
= 1;
1556 last_sig
= GDB_SIGNAL_0
;
1558 if (!(debug_event
= wait_for_debug_event (¤t_event
, 1000)))
1561 continue_status
= DBG_CONTINUE
;
1563 event_code
= current_event
.dwDebugEventCode
;
1564 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1566 have_saved_context
= 0;
1570 case CREATE_THREAD_DEBUG_EVENT
:
1571 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1572 (unsigned) current_event
.dwProcessId
,
1573 (unsigned) current_event
.dwThreadId
,
1574 "CREATE_THREAD_DEBUG_EVENT"));
1575 if (saw_create
!= 1)
1577 inferior
*inf
= find_inferior_pid (this, current_event
.dwProcessId
);
1578 if (!saw_create
&& inf
->attach_flag
)
1580 /* Kludge around a Windows bug where first event is a create
1581 thread event. Caused when attached process does not have
1583 thread_id
= fake_create_process ();
1589 /* Record the existence of this thread. */
1590 thread_id
= current_event
.dwThreadId
;
1591 th
= windows_add_thread
1592 (ptid_t (current_event
.dwProcessId
, current_event
.dwThreadId
, 0),
1593 current_event
.u
.CreateThread
.hThread
,
1594 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1595 false /* main_thread_p */);
1599 case EXIT_THREAD_DEBUG_EVENT
:
1600 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1601 (unsigned) current_event
.dwProcessId
,
1602 (unsigned) current_event
.dwThreadId
,
1603 "EXIT_THREAD_DEBUG_EVENT"));
1604 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1605 current_event
.dwThreadId
, 0),
1606 current_event
.u
.ExitThread
.dwExitCode
,
1607 false /* main_thread_p */);
1608 th
= &dummy_thread_info
;
1611 case CREATE_PROCESS_DEBUG_EVENT
:
1612 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1613 (unsigned) current_event
.dwProcessId
,
1614 (unsigned) current_event
.dwThreadId
,
1615 "CREATE_PROCESS_DEBUG_EVENT"));
1616 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1617 if (++saw_create
!= 1)
1620 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1621 /* Add the main thread. */
1622 th
= windows_add_thread
1623 (ptid_t (current_event
.dwProcessId
,
1624 current_event
.dwThreadId
, 0),
1625 current_event
.u
.CreateProcessInfo
.hThread
,
1626 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
,
1627 true /* main_thread_p */);
1628 thread_id
= current_event
.dwThreadId
;
1631 case EXIT_PROCESS_DEBUG_EVENT
:
1632 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1633 (unsigned) current_event
.dwProcessId
,
1634 (unsigned) current_event
.dwThreadId
,
1635 "EXIT_PROCESS_DEBUG_EVENT"));
1636 if (!windows_initialization_done
)
1638 target_terminal::ours ();
1639 target_mourn_inferior (inferior_ptid
);
1640 error (_("During startup program exited with code 0x%x."),
1641 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1643 else if (saw_create
== 1)
1645 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1646 current_event
.dwThreadId
, 0),
1647 0, true /* main_thread_p */);
1648 DWORD exit_status
= current_event
.u
.ExitProcess
.dwExitCode
;
1649 /* If the exit status looks like a fatal exception, but we
1650 don't recognize the exception's code, make the original
1651 exit status value available, to avoid losing
1654 = WIFSIGNALED (exit_status
) ? WTERMSIG (exit_status
) : -1;
1655 if (exit_signal
== -1)
1657 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1658 ourstatus
->value
.integer
= exit_status
;
1662 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1663 ourstatus
->value
.sig
= gdb_signal_from_host (exit_signal
);
1665 thread_id
= current_event
.dwThreadId
;
1669 case LOAD_DLL_DEBUG_EVENT
:
1670 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1671 (unsigned) current_event
.dwProcessId
,
1672 (unsigned) current_event
.dwThreadId
,
1673 "LOAD_DLL_DEBUG_EVENT"));
1674 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1675 if (saw_create
!= 1 || ! windows_initialization_done
)
1677 catch_errors (handle_load_dll
);
1678 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1679 ourstatus
->value
.integer
= 0;
1680 thread_id
= current_event
.dwThreadId
;
1683 case UNLOAD_DLL_DEBUG_EVENT
:
1684 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1685 (unsigned) current_event
.dwProcessId
,
1686 (unsigned) current_event
.dwThreadId
,
1687 "UNLOAD_DLL_DEBUG_EVENT"));
1688 if (saw_create
!= 1 || ! windows_initialization_done
)
1690 catch_errors (handle_unload_dll
);
1691 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1692 ourstatus
->value
.integer
= 0;
1693 thread_id
= current_event
.dwThreadId
;
1696 case EXCEPTION_DEBUG_EVENT
:
1697 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1698 (unsigned) current_event
.dwProcessId
,
1699 (unsigned) current_event
.dwThreadId
,
1700 "EXCEPTION_DEBUG_EVENT"));
1701 if (saw_create
!= 1)
1703 switch (handle_exception (ourstatus
, debug_exceptions
))
1705 case HANDLE_EXCEPTION_UNHANDLED
:
1707 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1709 case HANDLE_EXCEPTION_HANDLED
:
1710 thread_id
= current_event
.dwThreadId
;
1712 case HANDLE_EXCEPTION_IGNORED
:
1713 continue_status
= DBG_CONTINUE
;
1718 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1719 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1720 (unsigned) current_event
.dwProcessId
,
1721 (unsigned) current_event
.dwThreadId
,
1722 "OUTPUT_DEBUG_STRING_EVENT"));
1723 if (saw_create
!= 1)
1725 thread_id
= handle_output_debug_string (ourstatus
);
1729 if (saw_create
!= 1)
1731 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1732 (unsigned) current_event
.dwProcessId
,
1733 (unsigned) current_event
.dwThreadId
);
1734 printf_unfiltered (" unknown event code %u\n",
1735 (unsigned) current_event
.dwDebugEventCode
);
1739 if (!thread_id
|| saw_create
!= 1)
1741 CHECK (windows_continue (continue_status
, desired_stop_thread_id
, 0));
1743 else if (desired_stop_thread_id
!= -1 && desired_stop_thread_id
!= thread_id
)
1745 /* Pending stop. See the comment by the definition of
1746 "pending_stops" for details on why this is needed. */
1747 DEBUG_EVENTS (("get_windows_debug_event - "
1748 "unexpected stop in 0x%x (expecting 0x%x)\n",
1749 thread_id
, desired_stop_thread_id
));
1751 if (current_event
.dwDebugEventCode
== EXCEPTION_DEBUG_EVENT
1752 && ((current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1753 == EXCEPTION_BREAKPOINT
)
1754 || (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1755 == STATUS_WX86_BREAKPOINT
))
1756 && windows_initialization_done
)
1758 ptid_t ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1759 th
= thread_rec (ptid
, INVALIDATE_CONTEXT
);
1760 th
->stopped_at_software_breakpoint
= true;
1761 th
->pc_adjusted
= false;
1763 pending_stops
.push_back ({thread_id
, *ourstatus
, current_event
});
1765 CHECK (windows_continue (continue_status
, desired_stop_thread_id
, 0));
1769 inferior_ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1770 current_windows_thread
= th
;
1771 if (!current_windows_thread
)
1772 current_windows_thread
= thread_rec (inferior_ptid
,
1773 INVALIDATE_CONTEXT
);
1780 /* Wait for interesting events to occur in the target process. */
1782 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1787 /* We loop when we get a non-standard exception rather than return
1788 with a SPURIOUS because resume can try and step or modify things,
1789 which needs a current_thread->h. But some of these exceptions mark
1790 the birth or death of threads, which mean that the current thread
1791 isn't necessarily what you think it is. */
1797 /* If the user presses Ctrl-c while the debugger is waiting
1798 for an event, he expects the debugger to interrupt his program
1799 and to get the prompt back. There are two possible situations:
1801 - The debugger and the program do not share the console, in
1802 which case the Ctrl-c event only reached the debugger.
1803 In that case, the ctrl_c handler will take care of interrupting
1804 the inferior. Note that this case is working starting with
1805 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1808 - The debugger and the program share the same console, in which
1809 case both debugger and inferior will receive the Ctrl-c event.
1810 In that case the ctrl_c handler will ignore the event, as the
1811 Ctrl-c event generated inside the inferior will trigger the
1812 expected debug event.
1814 FIXME: brobecker/2008-05-20: If the inferior receives the
1815 signal first and the delay until GDB receives that signal
1816 is sufficiently long, GDB can sometimes receive the SIGINT
1817 after we have unblocked the CTRL+C handler. This would
1818 lead to the debugger stopping prematurely while handling
1819 the new-thread event that comes with the handling of the SIGINT
1820 inside the inferior, and then stop again immediately when
1821 the user tries to resume the execution in the inferior.
1822 This is a classic race that we should try to fix one day. */
1823 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1824 retval
= get_windows_debug_event (pid
, ourstatus
);
1825 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1829 ptid_t result
= ptid_t (current_event
.dwProcessId
, retval
, 0);
1831 if (current_windows_thread
!= nullptr)
1833 current_windows_thread
->stopped_at_software_breakpoint
= false;
1834 if (current_event
.dwDebugEventCode
== EXCEPTION_DEBUG_EVENT
1835 && ((current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1836 == EXCEPTION_BREAKPOINT
)
1837 || (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1838 == STATUS_WX86_BREAKPOINT
))
1839 && windows_initialization_done
)
1841 current_windows_thread
->stopped_at_software_breakpoint
1843 current_windows_thread
->pc_adjusted
= false;
1853 if (deprecated_ui_loop_hook
!= NULL
)
1854 detach
= deprecated_ui_loop_hook (0);
1862 /* Iterate over all DLLs currently mapped by our inferior, and
1863 add them to our list of solibs. */
1866 windows_add_all_dlls (void)
1868 HMODULE dummy_hmodule
;
1876 if (EnumProcessModulesEx (current_process_handle
, &dummy_hmodule
,
1877 sizeof (HMODULE
), &cb_needed
,
1878 LIST_MODULES_32BIT
) == 0)
1884 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
1885 sizeof (HMODULE
), &cb_needed
) == 0)
1892 hmodules
= (HMODULE
*) alloca (cb_needed
);
1896 if (EnumProcessModulesEx (current_process_handle
, hmodules
,
1897 cb_needed
, &cb_needed
,
1898 LIST_MODULES_32BIT
) == 0)
1904 if (EnumProcessModules (current_process_handle
, hmodules
,
1905 cb_needed
, &cb_needed
) == 0)
1909 char system_dir
[__PMAX
];
1910 char syswow_dir
[__PMAX
];
1911 size_t system_dir_len
= 0;
1912 bool convert_syswow_dir
= false;
1917 /* This fails on 32bit Windows because it has no SysWOW64 directory,
1918 and in this case a path conversion isn't necessary. */
1919 UINT len
= GetSystemWow64DirectoryA (syswow_dir
, sizeof (syswow_dir
));
1922 /* Check that we have passed a large enough buffer. */
1923 gdb_assert (len
< sizeof (syswow_dir
));
1925 len
= GetSystemDirectoryA (system_dir
, sizeof (system_dir
));
1927 gdb_assert (len
!= 0);
1928 /* Check that we have passed a large enough buffer. */
1929 gdb_assert (len
< sizeof (system_dir
));
1931 strcat (system_dir
, "\\");
1932 strcat (syswow_dir
, "\\");
1933 system_dir_len
= strlen (system_dir
);
1935 convert_syswow_dir
= true;
1939 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
1943 wchar_t dll_name
[__PMAX
];
1944 char dll_name_mb
[__PMAX
];
1946 char dll_name
[__PMAX
];
1949 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
1950 &mi
, sizeof (mi
)) == 0)
1952 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
1953 dll_name
, sizeof (dll_name
)) == 0)
1956 wcstombs (dll_name_mb
, dll_name
, __PMAX
);
1961 /* Convert the DLL path of 32bit processes returned by
1962 GetModuleFileNameEx from the 64bit system directory to the
1963 32bit syswow64 directory if necessary. */
1964 std::string syswow_dll_path
;
1965 if (convert_syswow_dir
1966 && strncasecmp (name
, system_dir
, system_dir_len
) == 0
1967 && strchr (name
+ system_dir_len
, '\\') == nullptr)
1969 syswow_dll_path
= syswow_dir
;
1970 syswow_dll_path
+= name
+ system_dir_len
;
1971 name
= syswow_dll_path
.c_str();
1974 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
1975 solib_end
= solib_end
->next
;
1980 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1983 struct inferior
*inf
;
1985 last_sig
= GDB_SIGNAL_0
;
1986 open_process_used
= 0;
1987 debug_registers_changed
= 0;
1988 debug_registers_used
= 0;
1989 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1992 cygwin_load_start
= cygwin_load_end
= 0;
1994 current_event
.dwProcessId
= pid
;
1995 memset (¤t_event
, 0, sizeof (current_event
));
1996 if (!target_is_pushed (ops
))
1998 disable_breakpoints_in_shlibs ();
1999 windows_clear_solib ();
2000 clear_proceed_status (0);
2001 init_wait_for_inferior ();
2004 ignore_first_breakpoint
= !attaching
&& wow64_process
;
2008 windows_set_context_register_offsets (amd64_mappings
);
2009 windows_set_segment_register_p (amd64_windows_segment_register_p
);
2014 windows_set_context_register_offsets (i386_mappings
);
2015 windows_set_segment_register_p (i386_windows_segment_register_p
);
2018 inf
= current_inferior ();
2019 inferior_appeared (inf
, pid
);
2020 inf
->attach_flag
= attaching
;
2022 /* Make the new process the current inferior, so terminal handling
2023 can rely on it. When attaching, we don't know about any thread
2024 id here, but that's OK --- nothing should be referencing the
2025 current thread until we report an event out of windows_wait. */
2026 inferior_ptid
= ptid_t (pid
);
2028 target_terminal::init ();
2029 target_terminal::inferior ();
2031 windows_initialization_done
= 0;
2035 struct target_waitstatus status
;
2037 ops
->wait (minus_one_ptid
, &status
, 0);
2039 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
2041 if (status
.kind
!= TARGET_WAITKIND_LOADED
2042 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
2045 ops
->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
2048 /* Now that the inferior has been started and all DLLs have been mapped,
2049 we can iterate over all DLLs and load them in.
2051 We avoid doing it any earlier because, on certain versions of Windows,
2052 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
2053 we have seen on Windows 8.1 that the ntdll.dll load event does not
2054 include the DLL name, preventing us from creating an associated SO.
2055 A possible explanation is that ntdll.dll might be mapped before
2056 the SO info gets created by the Windows system -- ntdll.dll is
2057 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
2058 do not seem to suffer from that problem.
2060 Rather than try to work around this sort of issue, it is much
2061 simpler to just ignore DLL load/unload events during the startup
2062 phase, and then process them all in one batch now. */
2063 windows_add_all_dlls ();
2065 windows_initialization_done
= 1;
2069 /* Try to set or remove a user privilege to the current process. Return -1
2070 if that fails, the previous setting of that privilege otherwise.
2072 This code is copied from the Cygwin source code and rearranged to allow
2073 dynamically loading of the needed symbols from advapi32 which is only
2074 available on NT/2K/XP. */
2076 set_process_privilege (const char *privilege
, BOOL enable
)
2078 HANDLE token_hdl
= NULL
;
2080 TOKEN_PRIVILEGES new_priv
, orig_priv
;
2084 if (!OpenProcessToken (GetCurrentProcess (),
2085 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
2089 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
2092 new_priv
.PrivilegeCount
= 1;
2093 new_priv
.Privileges
[0].Luid
= restore_priv
;
2094 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
2096 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
2097 sizeof orig_priv
, &orig_priv
, &size
))
2100 /* Disabled, otherwise every `attach' in an unprivileged user session
2101 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
2102 windows_attach(). */
2103 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
2104 be enabled. GetLastError () returns an correct error code, though. */
2105 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
2109 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
2113 CloseHandle (token_hdl
);
2118 /* Attach to process PID, then initialize for debugging it. */
2121 windows_nat_target::attach (const char *args
, int from_tty
)
2126 pid
= parse_pid_to_attach (args
);
2128 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
2130 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
2131 printf_unfiltered ("This can cause attach to "
2132 "fail on Windows NT/2K/XP\n");
2135 windows_init_thread_list ();
2136 ok
= DebugActiveProcess (pid
);
2142 /* Try fall back to Cygwin pid. */
2143 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
2146 ok
= DebugActiveProcess (pid
);
2151 error (_("Can't attach to process %u (error %u)"),
2152 (unsigned) pid
, (unsigned) GetLastError ());
2154 DebugSetProcessKillOnExit (FALSE
);
2158 const char *exec_file
= get_exec_file (0);
2161 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
2162 target_pid_to_str (ptid_t (pid
)).c_str ());
2164 printf_unfiltered ("Attaching to %s\n",
2165 target_pid_to_str (ptid_t (pid
)).c_str ());
2169 HANDLE h
= OpenProcess (PROCESS_QUERY_INFORMATION
, FALSE
, pid
);
2173 if (IsWow64Process (h
, &wow64
))
2174 wow64_process
= wow64
;
2179 do_initial_windows_stuff (this, pid
, 1);
2180 target_terminal::ours ();
2184 windows_nat_target::detach (inferior
*inf
, int from_tty
)
2188 ptid_t ptid
= minus_one_ptid
;
2189 resume (ptid
, 0, GDB_SIGNAL_0
);
2191 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
2193 error (_("Can't detach process %u (error %u)"),
2194 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
2197 DebugSetProcessKillOnExit (FALSE
);
2199 if (detached
&& from_tty
)
2201 const char *exec_file
= get_exec_file (0);
2204 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
2205 (unsigned) current_event
.dwProcessId
);
2208 x86_cleanup_dregs ();
2209 inferior_ptid
= null_ptid
;
2210 detach_inferior (inf
);
2212 maybe_unpush_target ();
2215 /* Try to determine the executable filename.
2217 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2219 Upon success, the filename is stored inside EXE_NAME_RET, and
2220 this function returns nonzero.
2222 Otherwise, this function returns zero and the contents of
2223 EXE_NAME_RET is undefined. */
2226 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2236 if (!EnumProcessModulesEx (current_process_handle
, &dh_buf
,
2237 sizeof (HMODULE
), &cbNeeded
,
2238 LIST_MODULES_32BIT
) || !cbNeeded
)
2244 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2245 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2249 /* We know the executable is always first in the list of modules,
2250 which we just fetched. So no need to fetch more. */
2254 /* Cygwin prefers that the path be in /x/y/z format, so extract
2255 the filename into a temporary buffer first, and then convert it
2256 to POSIX format into the destination buffer. */
2257 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2259 len
= GetModuleFileNameEx (current_process_handle
,
2260 dh_buf
, pathbuf
, exe_name_max_len
);
2262 error (_("Error getting executable filename: %u."),
2263 (unsigned) GetLastError ());
2264 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2265 exe_name_max_len
) < 0)
2266 error (_("Error converting executable filename to POSIX: %d."), errno
);
2269 len
= GetModuleFileNameEx (current_process_handle
,
2270 dh_buf
, exe_name_ret
, exe_name_max_len
);
2272 error (_("Error getting executable filename: %u."),
2273 (unsigned) GetLastError ());
2276 return 1; /* success */
2279 /* The pid_to_exec_file target_ops method for this platform. */
2282 windows_nat_target::pid_to_exec_file (int pid
)
2284 static char path
[__PMAX
];
2286 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2288 char procexe
[sizeof ("/proc/4294967295/exe")];
2290 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2291 nchars
= readlink (procexe
, path
, sizeof(path
));
2292 if (nchars
> 0 && nchars
< sizeof (path
))
2294 path
[nchars
] = '\0'; /* Got it */
2299 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2300 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2301 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2307 /* Print status information about what we're accessing. */
2310 windows_nat_target::files_info ()
2312 struct inferior
*inf
= current_inferior ();
2314 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2315 inf
->attach_flag
? "attached" : "child",
2316 target_pid_to_str (inferior_ptid
).c_str ());
2319 /* Modify CreateProcess parameters for use of a new separate console.
2321 *FLAGS: DWORD parameter for general process creation flags.
2322 *SI: STARTUPINFO structure, for which the console window size and
2323 console buffer size is filled in if GDB is running in a console.
2324 to create the new console.
2325 The size of the used font is not available on all versions of
2326 Windows OS. Furthermore, the current font might not be the default
2327 font, but this is still better than before.
2328 If the windows and buffer sizes are computed,
2329 SI->DWFLAGS is changed so that this information is used
2330 by CreateProcess function. */
2333 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2335 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2336 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2338 if (hconsole
!= INVALID_HANDLE_VALUE
)
2340 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2342 CONSOLE_FONT_INFO cfi
;
2344 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2345 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2346 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2347 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2348 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2350 si
->dwXSize
*= font_size
.X
;
2354 si
->dwYSize
*= font_size
.Y
;
2357 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2358 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2359 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2361 *flags
|= CREATE_NEW_CONSOLE
;
2365 /* Function called by qsort to sort environment strings. */
2368 envvar_cmp (const void *a
, const void *b
)
2370 const char **p
= (const char **) a
;
2371 const char **q
= (const char **) b
;
2372 return strcasecmp (*p
, *q
);
2378 clear_win32_environment (char **env
)
2382 wchar_t *copy
= NULL
, *equalpos
;
2384 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2386 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2387 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2388 mbstowcs (copy
, env
[i
], len
);
2389 equalpos
= wcschr (copy
, L
'=');
2392 SetEnvironmentVariableW (copy
, NULL
);
2400 /* Redirection of inferior I/O streams for native MS-Windows programs.
2401 Unlike on Unix, where this is handled by invoking the inferior via
2402 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2404 The official documentation of the cmd.exe redirection features is here:
2406 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2408 (That page talks about Windows XP, but there's no newer
2409 documentation, so we assume later versions of cmd.exe didn't change
2412 Caveat: the documentation on that page seems to include a few lies.
2413 For example, it describes strange constructs 1<&2 and 2<&1, which
2414 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2415 think the cmd.exe parser of the redirection symbols simply doesn't
2416 care about the < vs > distinction in these cases. Therefore, the
2417 supported features are explicitly documented below.
2419 The emulation below aims at supporting all the valid use cases
2420 supported by cmd.exe, which include:
2422 < FILE redirect standard input from FILE
2423 0< FILE redirect standard input from FILE
2424 <&N redirect standard input from file descriptor N
2425 0<&N redirect standard input from file descriptor N
2426 > FILE redirect standard output to FILE
2427 >> FILE append standard output to FILE
2428 1>> FILE append standard output to FILE
2429 >&N redirect standard output to file descriptor N
2430 1>&N redirect standard output to file descriptor N
2431 >>&N append standard output to file descriptor N
2432 1>>&N append standard output to file descriptor N
2433 2> FILE redirect standard error to FILE
2434 2>> FILE append standard error to FILE
2435 2>&N redirect standard error to file descriptor N
2436 2>>&N append standard error to file descriptor N
2438 Note that using N > 2 in the above construct is supported, but
2439 requires that the corresponding file descriptor be open by some
2440 means elsewhere or outside GDB. Also note that using ">&0" or
2441 "<&2" will generally fail, because the file descriptor redirected
2442 from is normally open in an incompatible mode (e.g., FD 0 is open
2443 for reading only). IOW, use of such tricks is not recommended;
2444 you are on your own.
2446 We do NOT support redirection of file descriptors above 2, as in
2447 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2448 that needs special handling in the startup code that MinGW
2449 doesn't have). Pipes are also not supported.
2451 As for invalid use cases, where the redirection contains some
2452 error, the emulation below will detect that and produce some
2453 error and/or failure. But the behavior in those cases is not
2454 bug-for-bug compatible with what cmd.exe does in those cases.
2455 That's because what cmd.exe does then is not well defined, and
2456 seems to be a side effect of the cmd.exe parsing of the command
2457 line more than anything else. For example, try redirecting to an
2458 invalid file name, as in "> foo:bar".
2460 There are also minor syntactic deviations from what cmd.exe does
2461 in some corner cases. For example, it doesn't support the likes
2462 of "> &foo" to mean redirect to file named literally "&foo"; we
2463 do support that here, because that, too, sounds like some issue
2464 with the cmd.exe parser. Another nicety is that we support
2465 redirection targets that use file names with forward slashes,
2466 something cmd.exe doesn't -- this comes in handy since GDB
2467 file-name completion can be used when typing the command line for
2470 /* Support routines for redirecting standard handles of the inferior. */
2472 /* Parse a single redirection spec, open/duplicate the specified
2473 file/fd, and assign the appropriate value to one of the 3 standard
2474 file descriptors. */
2476 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2478 int *fd
, ref_fd
= -2;
2480 const char *fname
= redir_string
+ 1;
2481 int rc
= *redir_string
;
2496 fd
= (rc
== '2') ? err
: out
;
2497 mode
= O_WRONLY
| O_CREAT
;
2510 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2512 /* A reference to a file descriptor. */
2514 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2515 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2517 /* Don't allow redirection when open modes are incompatible. */
2518 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2519 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2526 else if (ref_fd
== 1)
2528 else if (ref_fd
== 2)
2538 fname
++; /* skip the separator space */
2539 /* If the descriptor is already open, close it. This allows
2540 multiple specs of redirections for the same stream, which is
2541 somewhat nonsensical, but still valid and supported by cmd.exe.
2542 (But cmd.exe only opens a single file in this case, the one
2543 specified by the last redirection spec on the command line.) */
2548 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2552 else if (ref_fd
== -1)
2553 *fd
= -1; /* reset to default destination */
2556 *fd
= _dup (ref_fd
);
2560 /* _open just sets a flag for O_APPEND, which won't be passed to the
2561 inferior, so we need to actually move the file pointer. */
2562 if ((mode
& O_APPEND
) != 0)
2563 _lseek (*fd
, 0L, SEEK_END
);
2567 /* Canonicalize a single redirection spec and set up the corresponding
2568 file descriptor as specified. */
2570 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2572 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2574 const char *start
= s
;
2577 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2578 if ((*start
== '>' || *start
== '1' || *start
== '2')
2582 if (*s
== '>' && *start
!= '>')
2585 else if (*start
== '0' && *s
== '<')
2587 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2590 while (isspace (*s
)) /* skip whitespace before file name */
2592 *d
++ = ' '; /* separate file name with a single space */
2595 /* Copy the file name. */
2598 /* Remove quoting characters from the file name in buf[]. */
2599 if (*s
== '"') /* could support '..' quoting here */
2603 else if (*s
== quote
)
2611 else if (*s
== '\\')
2613 if (s
[1] == '"') /* could support '..' here */
2617 else if (isspace (*s
) && !quote
)
2621 if (d
- buf
>= sizeof (buf
) - 1)
2623 errno
= ENAMETOOLONG
;
2629 /* Windows doesn't allow redirection characters in file names, so we
2630 can bail out early if they use them, or if there's no target file
2631 name after the redirection symbol. */
2632 if (d
[-1] == '>' || d
[-1] == '<')
2637 if (redir_open (buf
, inp
, out
, err
) == 0)
2642 /* Parse the command line for redirection specs and prepare the file
2643 descriptors for the 3 standard streams accordingly. */
2645 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2646 int *inp
, int *out
, int *err
)
2648 const char *s
= cmd_orig
;
2651 bool retval
= false;
2653 while (isspace (*s
))
2658 if (*s
== '"') /* could also support '..' quoting here */
2662 else if (*s
== quote
)
2665 else if (*s
== '\\')
2667 if (s
[1] == '"') /* escaped quote char */
2672 /* Process a single redirection candidate. */
2673 if (*s
== '<' || *s
== '>'
2674 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2675 || (*s
== '0' && s
[1] == '<'))
2677 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2691 #endif /* !__CYGWIN__ */
2693 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2694 EXEC_FILE is the file to run.
2695 ALLARGS is a string containing the arguments to the program.
2696 ENV is the environment vector to pass. Errors reported with error(). */
2699 windows_nat_target::create_inferior (const char *exec_file
,
2700 const std::string
&origallargs
,
2701 char **in_env
, int from_tty
)
2705 cygwin_buf_t real_path
[__PMAX
];
2706 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2707 cygwin_buf_t infcwd
[__PMAX
];
2709 cygwin_buf_t
*toexec
;
2710 cygwin_buf_t
*cygallargs
;
2712 char **old_env
= NULL
;
2716 int ostdin
, ostdout
, ostderr
;
2717 #else /* !__CYGWIN__ */
2718 char shell
[__PMAX
]; /* Path to shell */
2720 char *args
, *allargs_copy
;
2721 size_t args_len
, allargs_len
;
2722 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2723 HANDLE tty
= INVALID_HANDLE_VALUE
;
2724 bool redirected
= false;
2731 #endif /* !__CYGWIN__ */
2732 const char *allargs
= origallargs
.c_str ();
2733 PROCESS_INFORMATION pi
;
2736 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2739 error (_("No executable specified, use `target exec'."));
2741 const char *inferior_cwd
= get_inferior_cwd ();
2742 std::string expanded_infcwd
;
2743 if (inferior_cwd
!= NULL
)
2745 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
2746 /* Mirror slashes on inferior's cwd. */
2747 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
2749 inferior_cwd
= expanded_infcwd
.c_str ();
2752 memset (&si
, 0, sizeof (si
));
2753 si
.cb
= sizeof (si
);
2756 flags
|= CREATE_NEW_PROCESS_GROUP
;
2759 windows_set_console_info (&si
, &flags
);
2764 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2765 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2766 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2767 error (_("Error starting executable: %d"), errno
);
2770 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2771 if (len
== (size_t) -1)
2772 error (_("Error starting executable: %d"), errno
);
2773 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2774 mbstowcs (cygallargs
, allargs
, len
);
2775 #else /* !__USEWIDE */
2776 cygallargs
= allargs
;
2782 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2783 error (_("Error starting executable via shell: %d"), errno
);
2785 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2786 + mbstowcs (NULL
, allargs
, 0) + 2;
2787 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2788 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2789 #else /* !__USEWIDE */
2790 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2791 + strlen (allargs
) + 2);
2792 cygallargs
= (char *) alloca (len
);
2793 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2794 #endif /* __USEWIDE */
2796 flags
|= DEBUG_PROCESS
;
2799 if (inferior_cwd
!= NULL
2800 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
2801 infcwd
, strlen (inferior_cwd
)) < 0)
2802 error (_("Error converting inferior cwd: %d"), errno
);
2805 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2806 * sizeof (wchar_t));
2807 wcscpy (args
, toexec
);
2808 wcscat (args
, L
" ");
2809 wcscat (args
, cygallargs
);
2810 #else /* !__USEWIDE */
2811 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2812 strcpy (args
, toexec
);
2814 strcat (args
, cygallargs
);
2815 #endif /* !__USEWIDE */
2817 #ifdef CW_CVT_ENV_TO_WINENV
2818 /* First try to create a direct Win32 copy of the POSIX environment. */
2819 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2820 if (w32_env
!= (PWCHAR
) -1)
2821 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2823 /* If that fails, fall back to old method tweaking GDB's environment. */
2824 #endif /* CW_CVT_ENV_TO_WINENV */
2826 /* Reset all Win32 environment variables to avoid leftover on next run. */
2827 clear_win32_environment (environ
);
2828 /* Prepare the environment vars for CreateProcess. */
2831 cygwin_internal (CW_SYNC_WINENV
);
2835 if (!inferior_io_terminal
)
2836 tty
= ostdin
= ostdout
= ostderr
= -1;
2839 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2842 print_sys_errmsg (inferior_io_terminal
, errno
);
2843 ostdin
= ostdout
= ostderr
= -1;
2856 windows_init_thread_list ();
2857 ret
= CreateProcess (0,
2858 args
, /* command line */
2859 NULL
, /* Security */
2861 TRUE
, /* inherit handles */
2862 flags
, /* start flags */
2863 w32_env
, /* environment */
2864 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
2869 /* Just free the Win32 environment, if it could be created. */
2873 /* Reset all environment variables to avoid leftover on next run. */
2874 clear_win32_environment (in_env
);
2875 /* Restore normal GDB environment variables. */
2877 cygwin_internal (CW_SYNC_WINENV
);
2890 #else /* !__CYGWIN__ */
2891 allargs_len
= strlen (allargs
);
2892 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
2893 if (strpbrk (allargs_copy
, "<>") != NULL
)
2898 redirect_inferior_handles (allargs
, allargs_copy
,
2899 &fd_inp
, &fd_out
, &fd_err
);
2901 warning (_("Error in redirection: %s."), safe_strerror (errno
));
2904 allargs_len
= strlen (allargs_copy
);
2906 /* If not all the standard streams are redirected by the command
2907 line, use inferior_io_terminal for those which aren't. */
2908 if (inferior_io_terminal
2909 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
2911 SECURITY_ATTRIBUTES sa
;
2912 sa
.nLength
= sizeof(sa
);
2913 sa
.lpSecurityDescriptor
= 0;
2914 sa
.bInheritHandle
= TRUE
;
2915 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2916 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2917 if (tty
== INVALID_HANDLE_VALUE
)
2918 warning (_("Warning: Failed to open TTY %s, error %#x."),
2919 inferior_io_terminal
, (unsigned) GetLastError ());
2921 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
2924 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
2925 else if (tty
!= INVALID_HANDLE_VALUE
)
2928 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
2930 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
2931 else if (tty
!= INVALID_HANDLE_VALUE
)
2932 si
.hStdOutput
= tty
;
2934 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
2936 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
2937 else if (tty
!= INVALID_HANDLE_VALUE
)
2940 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
2941 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2945 /* Build the command line, a space-separated list of tokens where
2946 the first token is the name of the module to be executed.
2947 To avoid ambiguities introduced by spaces in the module name,
2949 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
2950 args
= (char *) alloca (args_len
);
2951 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
2953 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2955 /* CreateProcess takes the environment list as a null terminated set of
2956 strings (i.e. two nulls terminate the list). */
2958 /* Get total size for env strings. */
2959 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2960 envlen
+= strlen (in_env
[i
]) + 1;
2962 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2963 env
= (char **) alloca (envsize
);
2964 memcpy (env
, in_env
, envsize
);
2965 /* Windows programs expect the environment block to be sorted. */
2966 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2968 w32env
= (char *) alloca (envlen
+ 1);
2970 /* Copy env strings into new buffer. */
2971 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2973 strcpy (temp
, env
[i
]);
2974 temp
+= strlen (temp
) + 1;
2977 /* Final nil string to terminate new env. */
2980 windows_init_thread_list ();
2981 ret
= CreateProcessA (0,
2982 args
, /* command line */
2983 NULL
, /* Security */
2985 TRUE
, /* inherit handles */
2986 flags
, /* start flags */
2987 w32env
, /* environment */
2988 inferior_cwd
, /* current directory */
2991 if (tty
!= INVALID_HANDLE_VALUE
)
2999 #endif /* !__CYGWIN__ */
3002 error (_("Error creating process %s, (error %u)."),
3003 exec_file
, (unsigned) GetLastError ());
3007 if (IsWow64Process (pi
.hProcess
, &wow64
))
3008 wow64_process
= wow64
;
3011 CloseHandle (pi
.hThread
);
3012 CloseHandle (pi
.hProcess
);
3014 if (useshell
&& shell
[0] != '\0')
3019 do_initial_windows_stuff (this, pi
.dwProcessId
, 0);
3021 /* windows_continue (DBG_CONTINUE, -1, 0); */
3025 windows_nat_target::mourn_inferior ()
3027 (void) windows_continue (DBG_CONTINUE
, -1, 0);
3028 x86_cleanup_dregs();
3029 if (open_process_used
)
3031 CHECK (CloseHandle (current_process_handle
));
3032 open_process_used
= 0;
3034 siginfo_er
.ExceptionCode
= 0;
3035 inf_child_target::mourn_inferior ();
3038 /* Send a SIGINT to the process group. This acts just like the user typed a
3039 ^C on the controlling terminal. */
3042 windows_nat_target::interrupt ()
3044 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
3045 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
3046 registers_changed (); /* refresh register state */
3049 /* Helper for windows_xfer_partial that handles memory transfers.
3050 Arguments are like target_xfer_partial. */
3052 static enum target_xfer_status
3053 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3054 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
3058 DWORD lasterror
= 0;
3060 if (writebuf
!= NULL
)
3062 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
3063 pulongest (len
), core_addr_to_string (memaddr
)));
3064 success
= WriteProcessMemory (current_process_handle
,
3065 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
3068 lasterror
= GetLastError ();
3069 FlushInstructionCache (current_process_handle
,
3070 (LPCVOID
) (uintptr_t) memaddr
, len
);
3074 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
3075 pulongest (len
), core_addr_to_string (memaddr
)));
3076 success
= ReadProcessMemory (current_process_handle
,
3077 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
3080 lasterror
= GetLastError ();
3082 *xfered_len
= (ULONGEST
) done
;
3083 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
3084 return TARGET_XFER_OK
;
3086 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
3090 windows_nat_target::kill ()
3092 CHECK (TerminateProcess (current_process_handle
, 0));
3096 if (!windows_continue (DBG_CONTINUE
, -1, 1))
3098 if (!wait_for_debug_event (¤t_event
, INFINITE
))
3100 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
3104 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
3108 windows_nat_target::close ()
3110 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
3111 inferior_ptid
.pid ()));
3114 /* Convert pid to printable format. */
3116 windows_nat_target::pid_to_str (ptid_t ptid
)
3118 if (ptid
.lwp () != 0)
3119 return string_printf ("Thread %d.0x%lx", ptid
.pid (), ptid
.lwp ());
3121 return normal_pid_to_str (ptid
);
3124 static enum target_xfer_status
3125 windows_xfer_shared_libraries (struct target_ops
*ops
,
3126 enum target_object object
, const char *annex
,
3127 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3128 ULONGEST offset
, ULONGEST len
,
3129 ULONGEST
*xfered_len
)
3131 struct obstack obstack
;
3137 return TARGET_XFER_E_IO
;
3139 obstack_init (&obstack
);
3140 obstack_grow_str (&obstack
, "<library-list>\n");
3141 for (so
= solib_start
.next
; so
; so
= so
->next
)
3143 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
3145 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
3146 (uintptr_t) li
->load_addr
,
3148 target_gdbarch (), &obstack
);
3150 obstack_grow_str0 (&obstack
, "</library-list>\n");
3152 buf
= (const char *) obstack_finish (&obstack
);
3153 len_avail
= strlen (buf
);
3154 if (offset
>= len_avail
)
3158 if (len
> len_avail
- offset
)
3159 len
= len_avail
- offset
;
3160 memcpy (readbuf
, buf
+ offset
, len
);
3163 obstack_free (&obstack
, NULL
);
3164 *xfered_len
= (ULONGEST
) len
;
3165 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
3168 /* Helper for windows_nat_target::xfer_partial that handles signal info. */
3170 static enum target_xfer_status
3171 windows_xfer_siginfo (gdb_byte
*readbuf
, ULONGEST offset
, ULONGEST len
,
3172 ULONGEST
*xfered_len
)
3174 char *buf
= (char *) &siginfo_er
;
3175 size_t bufsize
= sizeof (siginfo_er
);
3178 EXCEPTION_RECORD32 er32
;
3181 buf
= (char *) &er32
;
3182 bufsize
= sizeof (er32
);
3184 er32
.ExceptionCode
= siginfo_er
.ExceptionCode
;
3185 er32
.ExceptionFlags
= siginfo_er
.ExceptionFlags
;
3186 er32
.ExceptionRecord
= (uintptr_t) siginfo_er
.ExceptionRecord
;
3187 er32
.ExceptionAddress
= (uintptr_t) siginfo_er
.ExceptionAddress
;
3188 er32
.NumberParameters
= siginfo_er
.NumberParameters
;
3190 for (i
= 0; i
< EXCEPTION_MAXIMUM_PARAMETERS
; i
++)
3191 er32
.ExceptionInformation
[i
] = siginfo_er
.ExceptionInformation
[i
];
3195 if (siginfo_er
.ExceptionCode
== 0)
3196 return TARGET_XFER_E_IO
;
3198 if (readbuf
== nullptr)
3199 return TARGET_XFER_E_IO
;
3201 if (offset
> bufsize
)
3202 return TARGET_XFER_E_IO
;
3204 if (offset
+ len
> bufsize
)
3205 len
= bufsize
- offset
;
3207 memcpy (readbuf
, buf
+ offset
, len
);
3210 return TARGET_XFER_OK
;
3213 enum target_xfer_status
3214 windows_nat_target::xfer_partial (enum target_object object
,
3215 const char *annex
, gdb_byte
*readbuf
,
3216 const gdb_byte
*writebuf
, ULONGEST offset
,
3217 ULONGEST len
, ULONGEST
*xfered_len
)
3221 case TARGET_OBJECT_MEMORY
:
3222 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
3224 case TARGET_OBJECT_LIBRARIES
:
3225 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
3226 writebuf
, offset
, len
, xfered_len
);
3228 case TARGET_OBJECT_SIGNAL_INFO
:
3229 return windows_xfer_siginfo (readbuf
, offset
, len
, xfered_len
);
3232 if (beneath () == NULL
)
3234 /* This can happen when requesting the transfer of unsupported
3235 objects before a program has been started (and therefore
3236 with the current_target having no target beneath). */
3237 return TARGET_XFER_E_IO
;
3239 return beneath ()->xfer_partial (object
, annex
,
3240 readbuf
, writebuf
, offset
, len
,
3245 /* Provide thread local base, i.e. Thread Information Block address.
3246 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
3249 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
3251 windows_thread_info
*th
;
3253 th
= thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
);
3258 *addr
= th
->thread_local_base
;
3264 windows_nat_target::get_ada_task_ptid (long lwp
, long thread
)
3266 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
3269 /* Implementation of the to_thread_name method. */
3272 windows_nat_target::thread_name (struct thread_info
*thr
)
3274 return thread_rec (thr
->ptid
, DONT_INVALIDATE_CONTEXT
)->name
.get ();
3278 void _initialize_windows_nat ();
3280 _initialize_windows_nat ()
3282 x86_dr_low
.set_control
= cygwin_set_dr7
;
3283 x86_dr_low
.set_addr
= cygwin_set_dr
;
3284 x86_dr_low
.get_addr
= cygwin_get_dr
;
3285 x86_dr_low
.get_status
= cygwin_get_dr6
;
3286 x86_dr_low
.get_control
= cygwin_get_dr7
;
3288 /* x86_dr_low.debug_register_length field is set by
3289 calling x86_set_debug_register_length function
3290 in processor windows specific native file. */
3292 add_inf_child_target (&the_windows_nat_target
);
3295 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3298 add_com ("signal-event", class_run
, signal_event_command
, _("\
3299 Signal a crashed process with event ID, to allow its debugging.\n\
3300 This command is needed in support of setting up GDB as JIT debugger on \
3301 MS-Windows. The command should be invoked from the GDB command line using \
3302 the '-ex' command-line option. The ID of the event that blocks the \
3303 crashed process will be supplied by the Windows JIT debugging mechanism."));
3306 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3307 Set use of shell to start subprocess."), _("\
3308 Show use of shell to start subprocess."), NULL
,
3310 NULL
, /* FIXME: i18n: */
3311 &setlist
, &showlist
);
3313 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3314 &cygwin_exceptions
, _("\
3315 Break when an exception is detected in the Cygwin DLL itself."), _("\
3316 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3318 NULL
, /* FIXME: i18n: */
3319 &setlist
, &showlist
);
3322 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3323 Set creation of new console when creating child process."), _("\
3324 Show creation of new console when creating child process."), NULL
,
3326 NULL
, /* FIXME: i18n: */
3327 &setlist
, &showlist
);
3329 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3330 Set creation of new group when creating child process."), _("\
3331 Show creation of new group when creating child process."), NULL
,
3333 NULL
, /* FIXME: i18n: */
3334 &setlist
, &showlist
);
3336 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3337 Set whether to display execution in child process."), _("\
3338 Show whether to display execution in child process."), NULL
,
3340 NULL
, /* FIXME: i18n: */
3341 &setlist
, &showlist
);
3343 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3344 Set whether to display kernel events in child process."), _("\
3345 Show whether to display kernel events in child process."), NULL
,
3347 NULL
, /* FIXME: i18n: */
3348 &setlist
, &showlist
);
3350 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3351 Set whether to display memory accesses in child process."), _("\
3352 Show whether to display memory accesses in child process."), NULL
,
3354 NULL
, /* FIXME: i18n: */
3355 &setlist
, &showlist
);
3357 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3358 &debug_exceptions
, _("\
3359 Set whether to display kernel exceptions in child process."), _("\
3360 Show whether to display kernel exceptions in child process."), NULL
,
3362 NULL
, /* FIXME: i18n: */
3363 &setlist
, &showlist
);
3365 init_w32_command_list ();
3367 add_cmd ("selector", class_info
, display_selectors
,
3368 _("Display selectors infos."),
3372 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3374 /* Pass the address ADDR to the inferior in the I'th debug register.
3375 Here we just store the address in dr array, the registers will be
3376 actually set up when windows_continue is called. */
3378 cygwin_set_dr (int i
, CORE_ADDR addr
)
3381 internal_error (__FILE__
, __LINE__
,
3382 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3384 debug_registers_changed
= 1;
3385 debug_registers_used
= 1;
3388 /* Pass the value VAL to the inferior in the DR7 debug control
3389 register. Here we just store the address in D_REGS, the watchpoint
3390 will be actually set up in windows_wait. */
3392 cygwin_set_dr7 (unsigned long val
)
3394 dr
[7] = (CORE_ADDR
) val
;
3395 debug_registers_changed
= 1;
3396 debug_registers_used
= 1;
3399 /* Get the value of debug register I from the inferior. */
3402 cygwin_get_dr (int i
)
3407 /* Get the value of the DR6 debug status register from the inferior.
3408 Here we just return the value stored in dr[6]
3409 by the last call to thread_rec for current_event.dwThreadId id. */
3410 static unsigned long
3411 cygwin_get_dr6 (void)
3413 return (unsigned long) dr
[6];
3416 /* Get the value of the DR7 debug status register from the inferior.
3417 Here we just return the value stored in dr[7] by the last call to
3418 thread_rec for current_event.dwThreadId id. */
3420 static unsigned long
3421 cygwin_get_dr7 (void)
3423 return (unsigned long) dr
[7];
3426 /* Determine if the thread referenced by "ptid" is alive
3427 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3428 it means that the thread has died. Otherwise it is assumed to be alive. */
3431 windows_nat_target::thread_alive (ptid_t ptid
)
3433 gdb_assert (ptid
.lwp () != 0);
3435 return (WaitForSingleObject (thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
)->h
, 0)
3439 void _initialize_check_for_gdb_ini ();
3441 _initialize_check_for_gdb_ini ()
3444 if (inhibit_gdbinit
)
3447 homedir
= getenv ("HOME");
3451 char *oldini
= (char *) alloca (strlen (homedir
) +
3452 sizeof ("gdb.ini") + 1);
3453 strcpy (oldini
, homedir
);
3454 p
= strchr (oldini
, '\0');
3455 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3457 strcpy (p
, "gdb.ini");
3458 if (access (oldini
, 0) == 0)
3460 int len
= strlen (oldini
);
3461 char *newini
= (char *) alloca (len
+ 2);
3463 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3464 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3465 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3470 /* Define dummy functions which always return error for the rare cases where
3471 these functions could not be found. */
3473 bad_DebugActiveProcessStop (DWORD w
)
3478 bad_DebugBreakProcess (HANDLE w
)
3483 bad_DebugSetProcessKillOnExit (BOOL w
)
3488 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3495 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3501 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3508 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3514 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3520 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3526 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3534 /* Load any functions which may not be available in ancient versions
3537 void _initialize_loadable ();
3539 _initialize_loadable ()
3543 #define GPA(m, func) \
3544 func = (func ## _ftype *) GetProcAddress (m, #func)
3546 hm
= LoadLibrary ("kernel32.dll");
3549 GPA (hm
, DebugActiveProcessStop
);
3550 GPA (hm
, DebugBreakProcess
);
3551 GPA (hm
, DebugSetProcessKillOnExit
);
3552 GPA (hm
, GetConsoleFontSize
);
3553 GPA (hm
, DebugActiveProcessStop
);
3554 GPA (hm
, GetCurrentConsoleFont
);
3556 GPA (hm
, Wow64SuspendThread
);
3557 GPA (hm
, Wow64GetThreadContext
);
3558 GPA (hm
, Wow64SetThreadContext
);
3559 GPA (hm
, Wow64GetThreadSelectorEntry
);
3563 /* Set variables to dummy versions of these processes if the function
3564 wasn't found in kernel32.dll. */
3565 if (!DebugBreakProcess
)
3566 DebugBreakProcess
= bad_DebugBreakProcess
;
3567 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3569 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3570 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3572 if (!GetConsoleFontSize
)
3573 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3574 if (!GetCurrentConsoleFont
)
3575 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3577 /* Load optional functions used for retrieving filename information
3578 associated with the currently debugged process or its dlls. */
3579 hm
= LoadLibrary ("psapi.dll");
3582 GPA (hm
, EnumProcessModules
);
3584 GPA (hm
, EnumProcessModulesEx
);
3586 GPA (hm
, GetModuleInformation
);
3587 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3588 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3591 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3593 /* Set variables to dummy versions of these processes if the function
3594 wasn't found in psapi.dll. */
3595 EnumProcessModules
= bad_EnumProcessModules
;
3596 GetModuleInformation
= bad_GetModuleInformation
;
3597 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3598 /* This will probably fail on Windows 9x/Me. Let the user know
3599 that we're missing some functionality. */
3601 cannot automatically find executable file or library to read symbols.\n\
3602 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3605 hm
= LoadLibrary ("advapi32.dll");
3608 GPA (hm
, OpenProcessToken
);
3609 GPA (hm
, LookupPrivilegeValueA
);
3610 GPA (hm
, AdjustTokenPrivileges
);
3611 /* Only need to set one of these since if OpenProcessToken fails nothing
3613 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3614 || !AdjustTokenPrivileges
)
3615 OpenProcessToken
= bad_OpenProcessToken
;