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", -1));
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
)
988 gdb::unique_xmalloc_ptr
<char> s
;
991 if (!target_read_string
992 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
994 || !s
|| !*(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
;
1221 thread_name_len
= target_read_string (thread_name_target
,
1222 &thread_name
, 1025, NULL
);
1223 if (thread_name_len
> 0)
1225 thread_name
.get ()[thread_name_len
- 1] = '\0';
1226 named_thread
->name
= std::move (thread_name
);
1236 /* See nat/windows-nat.h. */
1239 windows_nat::handle_access_violation (const EXCEPTION_RECORD
*rec
)
1242 /* See if the access violation happened within the cygwin DLL
1243 itself. Cygwin uses a kind of exception handling to deal with
1244 passed-in invalid addresses. gdb should not treat these as real
1245 SEGVs since they will be silently handled by cygwin. A real SEGV
1246 will (theoretically) be caught by cygwin later in the process and
1247 will be sent as a cygwin-specific-signal. So, ignore SEGVs if
1248 they show up within the text segment of the DLL itself. */
1250 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1252 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1253 && addr
< cygwin_load_end
))
1254 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1255 && startswith (fn
, "KERNEL32!IsBad")))
1261 /* Resume thread specified by ID, or all artificially suspended
1262 threads, if we are continuing execution. KILLED non-zero means we
1263 have killed the inferior, so we should ignore weird errors due to
1264 threads shutting down. */
1266 windows_continue (DWORD continue_status
, int id
, int killed
)
1270 desired_stop_thread_id
= id
;
1272 if (matching_pending_stop (debug_events
))
1275 for (windows_thread_info
*th
: thread_list
)
1276 if (id
== -1 || id
== (int) th
->tid
)
1283 if (debug_registers_changed
)
1285 th
->wow64_context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1286 th
->wow64_context
.Dr0
= dr
[0];
1287 th
->wow64_context
.Dr1
= dr
[1];
1288 th
->wow64_context
.Dr2
= dr
[2];
1289 th
->wow64_context
.Dr3
= dr
[3];
1290 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1291 th
->wow64_context
.Dr7
= dr
[7];
1293 if (th
->wow64_context
.ContextFlags
)
1297 if (GetExitCodeThread (th
->h
, &ec
)
1298 && ec
== STILL_ACTIVE
)
1300 BOOL status
= Wow64SetThreadContext (th
->h
,
1301 &th
->wow64_context
);
1306 th
->wow64_context
.ContextFlags
= 0;
1312 if (debug_registers_changed
)
1314 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1315 th
->context
.Dr0
= dr
[0];
1316 th
->context
.Dr1
= dr
[1];
1317 th
->context
.Dr2
= dr
[2];
1318 th
->context
.Dr3
= dr
[3];
1319 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1320 th
->context
.Dr7
= dr
[7];
1322 if (th
->context
.ContextFlags
)
1326 if (GetExitCodeThread (th
->h
, &ec
)
1327 && ec
== STILL_ACTIVE
)
1329 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1334 th
->context
.ContextFlags
= 0;
1341 /* When single-stepping a specific thread, other threads must
1346 res
= continue_last_debug_event (continue_status
, debug_events
);
1349 error (_("Failed to resume program execution"
1350 " (ContinueDebugEvent failed, error %u)"),
1351 (unsigned int) GetLastError ());
1353 debug_registers_changed
= 0;
1357 /* Called in pathological case where Windows fails to send a
1358 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1360 fake_create_process (void)
1362 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1363 current_event
.dwProcessId
);
1364 if (current_process_handle
!= NULL
)
1365 open_process_used
= 1;
1368 error (_("OpenProcess call failed, GetLastError = %u"),
1369 (unsigned) GetLastError ());
1370 /* We can not debug anything in that case. */
1372 current_windows_thread
1373 = windows_add_thread (ptid_t (current_event
.dwProcessId
,
1374 current_event
.dwThreadId
, 0),
1375 current_event
.u
.CreateThread
.hThread
,
1376 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1377 true /* main_thread_p */);
1378 return current_event
.dwThreadId
;
1382 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1384 windows_thread_info
*th
;
1385 DWORD continue_status
= DBG_CONTINUE
;
1387 /* A specific PTID means `step only this thread id'. */
1388 int resume_all
= ptid
== minus_one_ptid
;
1390 /* If we're continuing all threads, it's the current inferior that
1391 should be handled specially. */
1393 ptid
= inferior_ptid
;
1395 if (sig
!= GDB_SIGNAL_0
)
1397 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1399 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1401 else if (sig
== last_sig
)
1402 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1405 /* This code does not seem to work, because
1406 the kernel does probably not consider changes in the ExceptionRecord
1407 structure when passing the exception to the inferior.
1408 Note that this seems possible in the exception handler itself. */
1410 for (const xlate_exception
&x
: xlate
)
1413 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1415 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1418 if (continue_status
== DBG_CONTINUE
)
1420 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1424 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1428 last_sig
= GDB_SIGNAL_0
;
1430 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=0x%x, step=%d, sig=%d);\n",
1431 ptid
.pid (), (unsigned) ptid
.lwp (), step
, sig
));
1433 /* Get context for currently selected thread. */
1434 th
= thread_rec (inferior_ptid
, DONT_INVALIDATE_CONTEXT
);
1442 /* Single step by setting t bit. */
1443 struct regcache
*regcache
= get_current_regcache ();
1444 struct gdbarch
*gdbarch
= regcache
->arch ();
1445 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1446 th
->wow64_context
.EFlags
|= FLAG_TRACE_BIT
;
1449 if (th
->wow64_context
.ContextFlags
)
1451 if (debug_registers_changed
)
1453 th
->wow64_context
.Dr0
= dr
[0];
1454 th
->wow64_context
.Dr1
= dr
[1];
1455 th
->wow64_context
.Dr2
= dr
[2];
1456 th
->wow64_context
.Dr3
= dr
[3];
1457 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1458 th
->wow64_context
.Dr7
= dr
[7];
1460 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
1461 th
->wow64_context
.ContextFlags
= 0;
1469 /* Single step by setting t bit. */
1470 struct regcache
*regcache
= get_current_regcache ();
1471 struct gdbarch
*gdbarch
= regcache
->arch ();
1472 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1473 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1476 if (th
->context
.ContextFlags
)
1478 if (debug_registers_changed
)
1480 th
->context
.Dr0
= dr
[0];
1481 th
->context
.Dr1
= dr
[1];
1482 th
->context
.Dr2
= dr
[2];
1483 th
->context
.Dr3
= dr
[3];
1484 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1485 th
->context
.Dr7
= dr
[7];
1487 CHECK (SetThreadContext (th
->h
, &th
->context
));
1488 th
->context
.ContextFlags
= 0;
1493 /* Allow continuing with the same signal that interrupted us.
1494 Otherwise complain. */
1497 windows_continue (continue_status
, -1, 0);
1499 windows_continue (continue_status
, ptid
.lwp (), 0);
1502 /* Ctrl-C handler used when the inferior is not run in the same console. The
1503 handler is in charge of interrupting the inferior using DebugBreakProcess.
1504 Note that this function is not available prior to Windows XP. In this case
1505 we emit a warning. */
1507 ctrl_c_handler (DWORD event_type
)
1509 const int attach_flag
= current_inferior ()->attach_flag
;
1511 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1512 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1515 /* If the inferior and the debugger share the same console, do nothing as
1516 the inferior has also received the Ctrl-C event. */
1517 if (!new_console
&& !attach_flag
)
1520 if (!DebugBreakProcess (current_process_handle
))
1521 warning (_("Could not interrupt program. "
1522 "Press Ctrl-c in the program console."));
1524 /* Return true to tell that Ctrl-C has been handled. */
1528 /* Get the next event from the child. Returns a non-zero thread id if the event
1529 requires handling by WFI (or whatever). */
1532 windows_nat_target::get_windows_debug_event (int pid
,
1533 struct target_waitstatus
*ourstatus
)
1536 DWORD continue_status
, event_code
;
1537 windows_thread_info
*th
;
1538 static windows_thread_info
dummy_thread_info (0, 0, 0);
1539 DWORD thread_id
= 0;
1541 /* If there is a relevant pending stop, report it now. See the
1542 comment by the definition of "pending_stops" for details on why
1544 gdb::optional
<pending_stop
> stop
= fetch_pending_stop (debug_events
);
1545 if (stop
.has_value ())
1547 thread_id
= stop
->thread_id
;
1548 *ourstatus
= stop
->status
;
1550 inferior_ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1551 current_windows_thread
= thread_rec (inferior_ptid
,
1552 INVALIDATE_CONTEXT
);
1553 current_windows_thread
->reload_context
= 1;
1558 last_sig
= GDB_SIGNAL_0
;
1560 if (!(debug_event
= wait_for_debug_event (¤t_event
, 1000)))
1563 continue_status
= DBG_CONTINUE
;
1565 event_code
= current_event
.dwDebugEventCode
;
1566 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1568 have_saved_context
= 0;
1572 case CREATE_THREAD_DEBUG_EVENT
:
1573 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1574 (unsigned) current_event
.dwProcessId
,
1575 (unsigned) current_event
.dwThreadId
,
1576 "CREATE_THREAD_DEBUG_EVENT"));
1577 if (saw_create
!= 1)
1579 inferior
*inf
= find_inferior_pid (this, current_event
.dwProcessId
);
1580 if (!saw_create
&& inf
->attach_flag
)
1582 /* Kludge around a Windows bug where first event is a create
1583 thread event. Caused when attached process does not have
1585 thread_id
= fake_create_process ();
1591 /* Record the existence of this thread. */
1592 thread_id
= current_event
.dwThreadId
;
1593 th
= windows_add_thread
1594 (ptid_t (current_event
.dwProcessId
, current_event
.dwThreadId
, 0),
1595 current_event
.u
.CreateThread
.hThread
,
1596 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1597 false /* main_thread_p */);
1601 case EXIT_THREAD_DEBUG_EVENT
:
1602 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1603 (unsigned) current_event
.dwProcessId
,
1604 (unsigned) current_event
.dwThreadId
,
1605 "EXIT_THREAD_DEBUG_EVENT"));
1606 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1607 current_event
.dwThreadId
, 0),
1608 current_event
.u
.ExitThread
.dwExitCode
,
1609 false /* main_thread_p */);
1610 th
= &dummy_thread_info
;
1613 case CREATE_PROCESS_DEBUG_EVENT
:
1614 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1615 (unsigned) current_event
.dwProcessId
,
1616 (unsigned) current_event
.dwThreadId
,
1617 "CREATE_PROCESS_DEBUG_EVENT"));
1618 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1619 if (++saw_create
!= 1)
1622 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1623 /* Add the main thread. */
1624 th
= windows_add_thread
1625 (ptid_t (current_event
.dwProcessId
,
1626 current_event
.dwThreadId
, 0),
1627 current_event
.u
.CreateProcessInfo
.hThread
,
1628 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
,
1629 true /* main_thread_p */);
1630 thread_id
= current_event
.dwThreadId
;
1633 case EXIT_PROCESS_DEBUG_EVENT
:
1634 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1635 (unsigned) current_event
.dwProcessId
,
1636 (unsigned) current_event
.dwThreadId
,
1637 "EXIT_PROCESS_DEBUG_EVENT"));
1638 if (!windows_initialization_done
)
1640 target_terminal::ours ();
1641 target_mourn_inferior (inferior_ptid
);
1642 error (_("During startup program exited with code 0x%x."),
1643 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1645 else if (saw_create
== 1)
1647 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1648 current_event
.dwThreadId
, 0),
1649 0, true /* main_thread_p */);
1650 DWORD exit_status
= current_event
.u
.ExitProcess
.dwExitCode
;
1651 /* If the exit status looks like a fatal exception, but we
1652 don't recognize the exception's code, make the original
1653 exit status value available, to avoid losing
1656 = WIFSIGNALED (exit_status
) ? WTERMSIG (exit_status
) : -1;
1657 if (exit_signal
== -1)
1659 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1660 ourstatus
->value
.integer
= exit_status
;
1664 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1665 ourstatus
->value
.sig
= gdb_signal_from_host (exit_signal
);
1667 thread_id
= current_event
.dwThreadId
;
1671 case LOAD_DLL_DEBUG_EVENT
:
1672 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1673 (unsigned) current_event
.dwProcessId
,
1674 (unsigned) current_event
.dwThreadId
,
1675 "LOAD_DLL_DEBUG_EVENT"));
1676 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1677 if (saw_create
!= 1 || ! windows_initialization_done
)
1679 catch_errors (handle_load_dll
);
1680 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1681 ourstatus
->value
.integer
= 0;
1682 thread_id
= current_event
.dwThreadId
;
1685 case UNLOAD_DLL_DEBUG_EVENT
:
1686 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1687 (unsigned) current_event
.dwProcessId
,
1688 (unsigned) current_event
.dwThreadId
,
1689 "UNLOAD_DLL_DEBUG_EVENT"));
1690 if (saw_create
!= 1 || ! windows_initialization_done
)
1692 catch_errors (handle_unload_dll
);
1693 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1694 ourstatus
->value
.integer
= 0;
1695 thread_id
= current_event
.dwThreadId
;
1698 case EXCEPTION_DEBUG_EVENT
:
1699 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1700 (unsigned) current_event
.dwProcessId
,
1701 (unsigned) current_event
.dwThreadId
,
1702 "EXCEPTION_DEBUG_EVENT"));
1703 if (saw_create
!= 1)
1705 switch (handle_exception (ourstatus
, debug_exceptions
))
1707 case HANDLE_EXCEPTION_UNHANDLED
:
1709 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1711 case HANDLE_EXCEPTION_HANDLED
:
1712 thread_id
= current_event
.dwThreadId
;
1714 case HANDLE_EXCEPTION_IGNORED
:
1715 continue_status
= DBG_CONTINUE
;
1720 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1721 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1722 (unsigned) current_event
.dwProcessId
,
1723 (unsigned) current_event
.dwThreadId
,
1724 "OUTPUT_DEBUG_STRING_EVENT"));
1725 if (saw_create
!= 1)
1727 thread_id
= handle_output_debug_string (ourstatus
);
1731 if (saw_create
!= 1)
1733 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1734 (unsigned) current_event
.dwProcessId
,
1735 (unsigned) current_event
.dwThreadId
);
1736 printf_unfiltered (" unknown event code %u\n",
1737 (unsigned) current_event
.dwDebugEventCode
);
1741 if (!thread_id
|| saw_create
!= 1)
1743 CHECK (windows_continue (continue_status
, desired_stop_thread_id
, 0));
1745 else if (desired_stop_thread_id
!= -1 && desired_stop_thread_id
!= thread_id
)
1747 /* Pending stop. See the comment by the definition of
1748 "pending_stops" for details on why this is needed. */
1749 DEBUG_EVENTS (("get_windows_debug_event - "
1750 "unexpected stop in 0x%x (expecting 0x%x)\n",
1751 thread_id
, desired_stop_thread_id
));
1753 if (current_event
.dwDebugEventCode
== EXCEPTION_DEBUG_EVENT
1754 && ((current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1755 == EXCEPTION_BREAKPOINT
)
1756 || (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1757 == STATUS_WX86_BREAKPOINT
))
1758 && windows_initialization_done
)
1760 ptid_t ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1761 th
= thread_rec (ptid
, INVALIDATE_CONTEXT
);
1762 th
->stopped_at_software_breakpoint
= true;
1763 th
->pc_adjusted
= false;
1765 pending_stops
.push_back ({thread_id
, *ourstatus
, current_event
});
1767 CHECK (windows_continue (continue_status
, desired_stop_thread_id
, 0));
1771 inferior_ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1772 current_windows_thread
= th
;
1773 if (!current_windows_thread
)
1774 current_windows_thread
= thread_rec (inferior_ptid
,
1775 INVALIDATE_CONTEXT
);
1782 /* Wait for interesting events to occur in the target process. */
1784 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1789 /* We loop when we get a non-standard exception rather than return
1790 with a SPURIOUS because resume can try and step or modify things,
1791 which needs a current_thread->h. But some of these exceptions mark
1792 the birth or death of threads, which mean that the current thread
1793 isn't necessarily what you think it is. */
1799 /* If the user presses Ctrl-c while the debugger is waiting
1800 for an event, he expects the debugger to interrupt his program
1801 and to get the prompt back. There are two possible situations:
1803 - The debugger and the program do not share the console, in
1804 which case the Ctrl-c event only reached the debugger.
1805 In that case, the ctrl_c handler will take care of interrupting
1806 the inferior. Note that this case is working starting with
1807 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1810 - The debugger and the program share the same console, in which
1811 case both debugger and inferior will receive the Ctrl-c event.
1812 In that case the ctrl_c handler will ignore the event, as the
1813 Ctrl-c event generated inside the inferior will trigger the
1814 expected debug event.
1816 FIXME: brobecker/2008-05-20: If the inferior receives the
1817 signal first and the delay until GDB receives that signal
1818 is sufficiently long, GDB can sometimes receive the SIGINT
1819 after we have unblocked the CTRL+C handler. This would
1820 lead to the debugger stopping prematurely while handling
1821 the new-thread event that comes with the handling of the SIGINT
1822 inside the inferior, and then stop again immediately when
1823 the user tries to resume the execution in the inferior.
1824 This is a classic race that we should try to fix one day. */
1825 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1826 retval
= get_windows_debug_event (pid
, ourstatus
);
1827 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1831 ptid_t result
= ptid_t (current_event
.dwProcessId
, retval
, 0);
1833 if (current_windows_thread
!= nullptr)
1835 current_windows_thread
->stopped_at_software_breakpoint
= false;
1836 if (current_event
.dwDebugEventCode
== EXCEPTION_DEBUG_EVENT
1837 && ((current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1838 == EXCEPTION_BREAKPOINT
)
1839 || (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1840 == STATUS_WX86_BREAKPOINT
))
1841 && windows_initialization_done
)
1843 current_windows_thread
->stopped_at_software_breakpoint
1845 current_windows_thread
->pc_adjusted
= false;
1855 if (deprecated_ui_loop_hook
!= NULL
)
1856 detach
= deprecated_ui_loop_hook (0);
1864 /* Iterate over all DLLs currently mapped by our inferior, and
1865 add them to our list of solibs. */
1868 windows_add_all_dlls (void)
1870 HMODULE dummy_hmodule
;
1878 if (EnumProcessModulesEx (current_process_handle
, &dummy_hmodule
,
1879 sizeof (HMODULE
), &cb_needed
,
1880 LIST_MODULES_32BIT
) == 0)
1886 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
1887 sizeof (HMODULE
), &cb_needed
) == 0)
1894 hmodules
= (HMODULE
*) alloca (cb_needed
);
1898 if (EnumProcessModulesEx (current_process_handle
, hmodules
,
1899 cb_needed
, &cb_needed
,
1900 LIST_MODULES_32BIT
) == 0)
1906 if (EnumProcessModules (current_process_handle
, hmodules
,
1907 cb_needed
, &cb_needed
) == 0)
1911 char system_dir
[__PMAX
];
1912 char syswow_dir
[__PMAX
];
1913 size_t system_dir_len
= 0;
1914 bool convert_syswow_dir
= false;
1919 /* This fails on 32bit Windows because it has no SysWOW64 directory,
1920 and in this case a path conversion isn't necessary. */
1921 UINT len
= GetSystemWow64DirectoryA (syswow_dir
, sizeof (syswow_dir
));
1924 /* Check that we have passed a large enough buffer. */
1925 gdb_assert (len
< sizeof (syswow_dir
));
1927 len
= GetSystemDirectoryA (system_dir
, sizeof (system_dir
));
1929 gdb_assert (len
!= 0);
1930 /* Check that we have passed a large enough buffer. */
1931 gdb_assert (len
< sizeof (system_dir
));
1933 strcat (system_dir
, "\\");
1934 strcat (syswow_dir
, "\\");
1935 system_dir_len
= strlen (system_dir
);
1937 convert_syswow_dir
= true;
1941 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
1945 wchar_t dll_name
[__PMAX
];
1946 char dll_name_mb
[__PMAX
];
1948 char dll_name
[__PMAX
];
1951 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
1952 &mi
, sizeof (mi
)) == 0)
1954 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
1955 dll_name
, sizeof (dll_name
)) == 0)
1958 wcstombs (dll_name_mb
, dll_name
, __PMAX
);
1963 /* Convert the DLL path of 32bit processes returned by
1964 GetModuleFileNameEx from the 64bit system directory to the
1965 32bit syswow64 directory if necessary. */
1966 std::string syswow_dll_path
;
1967 if (convert_syswow_dir
1968 && strncasecmp (name
, system_dir
, system_dir_len
) == 0
1969 && strchr (name
+ system_dir_len
, '\\') == nullptr)
1971 syswow_dll_path
= syswow_dir
;
1972 syswow_dll_path
+= name
+ system_dir_len
;
1973 name
= syswow_dll_path
.c_str();
1976 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
1977 solib_end
= solib_end
->next
;
1982 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1985 struct inferior
*inf
;
1987 last_sig
= GDB_SIGNAL_0
;
1988 open_process_used
= 0;
1989 debug_registers_changed
= 0;
1990 debug_registers_used
= 0;
1991 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1994 cygwin_load_start
= cygwin_load_end
= 0;
1996 current_event
.dwProcessId
= pid
;
1997 memset (¤t_event
, 0, sizeof (current_event
));
1998 if (!target_is_pushed (ops
))
2000 disable_breakpoints_in_shlibs ();
2001 windows_clear_solib ();
2002 clear_proceed_status (0);
2003 init_wait_for_inferior ();
2006 ignore_first_breakpoint
= !attaching
&& wow64_process
;
2010 windows_set_context_register_offsets (amd64_mappings
);
2011 windows_set_segment_register_p (amd64_windows_segment_register_p
);
2016 windows_set_context_register_offsets (i386_mappings
);
2017 windows_set_segment_register_p (i386_windows_segment_register_p
);
2020 inf
= current_inferior ();
2021 inferior_appeared (inf
, pid
);
2022 inf
->attach_flag
= attaching
;
2024 /* Make the new process the current inferior, so terminal handling
2025 can rely on it. When attaching, we don't know about any thread
2026 id here, but that's OK --- nothing should be referencing the
2027 current thread until we report an event out of windows_wait. */
2028 inferior_ptid
= ptid_t (pid
);
2030 target_terminal::init ();
2031 target_terminal::inferior ();
2033 windows_initialization_done
= 0;
2037 struct target_waitstatus status
;
2039 ops
->wait (minus_one_ptid
, &status
, 0);
2041 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
2043 if (status
.kind
!= TARGET_WAITKIND_LOADED
2044 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
2047 ops
->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
2050 /* Now that the inferior has been started and all DLLs have been mapped,
2051 we can iterate over all DLLs and load them in.
2053 We avoid doing it any earlier because, on certain versions of Windows,
2054 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
2055 we have seen on Windows 8.1 that the ntdll.dll load event does not
2056 include the DLL name, preventing us from creating an associated SO.
2057 A possible explanation is that ntdll.dll might be mapped before
2058 the SO info gets created by the Windows system -- ntdll.dll is
2059 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
2060 do not seem to suffer from that problem.
2062 Rather than try to work around this sort of issue, it is much
2063 simpler to just ignore DLL load/unload events during the startup
2064 phase, and then process them all in one batch now. */
2065 windows_add_all_dlls ();
2067 windows_initialization_done
= 1;
2071 /* Try to set or remove a user privilege to the current process. Return -1
2072 if that fails, the previous setting of that privilege otherwise.
2074 This code is copied from the Cygwin source code and rearranged to allow
2075 dynamically loading of the needed symbols from advapi32 which is only
2076 available on NT/2K/XP. */
2078 set_process_privilege (const char *privilege
, BOOL enable
)
2080 HANDLE token_hdl
= NULL
;
2082 TOKEN_PRIVILEGES new_priv
, orig_priv
;
2086 if (!OpenProcessToken (GetCurrentProcess (),
2087 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
2091 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
2094 new_priv
.PrivilegeCount
= 1;
2095 new_priv
.Privileges
[0].Luid
= restore_priv
;
2096 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
2098 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
2099 sizeof orig_priv
, &orig_priv
, &size
))
2102 /* Disabled, otherwise every `attach' in an unprivileged user session
2103 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
2104 windows_attach(). */
2105 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
2106 be enabled. GetLastError () returns an correct error code, though. */
2107 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
2111 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
2115 CloseHandle (token_hdl
);
2120 /* Attach to process PID, then initialize for debugging it. */
2123 windows_nat_target::attach (const char *args
, int from_tty
)
2128 pid
= parse_pid_to_attach (args
);
2130 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
2132 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
2133 printf_unfiltered ("This can cause attach to "
2134 "fail on Windows NT/2K/XP\n");
2137 windows_init_thread_list ();
2138 ok
= DebugActiveProcess (pid
);
2144 /* Try fall back to Cygwin pid. */
2145 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
2148 ok
= DebugActiveProcess (pid
);
2153 error (_("Can't attach to process %u (error %u)"),
2154 (unsigned) pid
, (unsigned) GetLastError ());
2156 DebugSetProcessKillOnExit (FALSE
);
2160 const char *exec_file
= get_exec_file (0);
2163 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
2164 target_pid_to_str (ptid_t (pid
)).c_str ());
2166 printf_unfiltered ("Attaching to %s\n",
2167 target_pid_to_str (ptid_t (pid
)).c_str ());
2171 HANDLE h
= OpenProcess (PROCESS_QUERY_INFORMATION
, FALSE
, pid
);
2175 if (IsWow64Process (h
, &wow64
))
2176 wow64_process
= wow64
;
2181 do_initial_windows_stuff (this, pid
, 1);
2182 target_terminal::ours ();
2186 windows_nat_target::detach (inferior
*inf
, int from_tty
)
2190 ptid_t ptid
= minus_one_ptid
;
2191 resume (ptid
, 0, GDB_SIGNAL_0
);
2193 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
2195 error (_("Can't detach process %u (error %u)"),
2196 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
2199 DebugSetProcessKillOnExit (FALSE
);
2201 if (detached
&& from_tty
)
2203 const char *exec_file
= get_exec_file (0);
2206 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
2207 (unsigned) current_event
.dwProcessId
);
2210 x86_cleanup_dregs ();
2211 inferior_ptid
= null_ptid
;
2212 detach_inferior (inf
);
2214 maybe_unpush_target ();
2217 /* Try to determine the executable filename.
2219 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2221 Upon success, the filename is stored inside EXE_NAME_RET, and
2222 this function returns nonzero.
2224 Otherwise, this function returns zero and the contents of
2225 EXE_NAME_RET is undefined. */
2228 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2238 if (!EnumProcessModulesEx (current_process_handle
, &dh_buf
,
2239 sizeof (HMODULE
), &cbNeeded
,
2240 LIST_MODULES_32BIT
) || !cbNeeded
)
2246 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2247 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2251 /* We know the executable is always first in the list of modules,
2252 which we just fetched. So no need to fetch more. */
2256 /* Cygwin prefers that the path be in /x/y/z format, so extract
2257 the filename into a temporary buffer first, and then convert it
2258 to POSIX format into the destination buffer. */
2259 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2261 len
= GetModuleFileNameEx (current_process_handle
,
2262 dh_buf
, pathbuf
, exe_name_max_len
);
2264 error (_("Error getting executable filename: %u."),
2265 (unsigned) GetLastError ());
2266 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2267 exe_name_max_len
) < 0)
2268 error (_("Error converting executable filename to POSIX: %d."), errno
);
2271 len
= GetModuleFileNameEx (current_process_handle
,
2272 dh_buf
, exe_name_ret
, exe_name_max_len
);
2274 error (_("Error getting executable filename: %u."),
2275 (unsigned) GetLastError ());
2278 return 1; /* success */
2281 /* The pid_to_exec_file target_ops method for this platform. */
2284 windows_nat_target::pid_to_exec_file (int pid
)
2286 static char path
[__PMAX
];
2288 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2290 char procexe
[sizeof ("/proc/4294967295/exe")];
2292 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2293 nchars
= readlink (procexe
, path
, sizeof(path
));
2294 if (nchars
> 0 && nchars
< sizeof (path
))
2296 path
[nchars
] = '\0'; /* Got it */
2301 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2302 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2303 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2309 /* Print status information about what we're accessing. */
2312 windows_nat_target::files_info ()
2314 struct inferior
*inf
= current_inferior ();
2316 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2317 inf
->attach_flag
? "attached" : "child",
2318 target_pid_to_str (inferior_ptid
).c_str ());
2321 /* Modify CreateProcess parameters for use of a new separate console.
2323 *FLAGS: DWORD parameter for general process creation flags.
2324 *SI: STARTUPINFO structure, for which the console window size and
2325 console buffer size is filled in if GDB is running in a console.
2326 to create the new console.
2327 The size of the used font is not available on all versions of
2328 Windows OS. Furthermore, the current font might not be the default
2329 font, but this is still better than before.
2330 If the windows and buffer sizes are computed,
2331 SI->DWFLAGS is changed so that this information is used
2332 by CreateProcess function. */
2335 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2337 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2338 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2340 if (hconsole
!= INVALID_HANDLE_VALUE
)
2342 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2344 CONSOLE_FONT_INFO cfi
;
2346 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2347 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2348 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2349 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2350 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2352 si
->dwXSize
*= font_size
.X
;
2356 si
->dwYSize
*= font_size
.Y
;
2359 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2360 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2361 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2363 *flags
|= CREATE_NEW_CONSOLE
;
2367 /* Function called by qsort to sort environment strings. */
2370 envvar_cmp (const void *a
, const void *b
)
2372 const char **p
= (const char **) a
;
2373 const char **q
= (const char **) b
;
2374 return strcasecmp (*p
, *q
);
2380 clear_win32_environment (char **env
)
2384 wchar_t *copy
= NULL
, *equalpos
;
2386 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2388 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2389 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2390 mbstowcs (copy
, env
[i
], len
);
2391 equalpos
= wcschr (copy
, L
'=');
2394 SetEnvironmentVariableW (copy
, NULL
);
2402 /* Redirection of inferior I/O streams for native MS-Windows programs.
2403 Unlike on Unix, where this is handled by invoking the inferior via
2404 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2406 The official documentation of the cmd.exe redirection features is here:
2408 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2410 (That page talks about Windows XP, but there's no newer
2411 documentation, so we assume later versions of cmd.exe didn't change
2414 Caveat: the documentation on that page seems to include a few lies.
2415 For example, it describes strange constructs 1<&2 and 2<&1, which
2416 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2417 think the cmd.exe parser of the redirection symbols simply doesn't
2418 care about the < vs > distinction in these cases. Therefore, the
2419 supported features are explicitly documented below.
2421 The emulation below aims at supporting all the valid use cases
2422 supported by cmd.exe, which include:
2424 < FILE redirect standard input from FILE
2425 0< FILE redirect standard input from FILE
2426 <&N redirect standard input from file descriptor N
2427 0<&N redirect standard input from file descriptor N
2428 > FILE redirect standard output to FILE
2429 >> FILE append standard output to FILE
2430 1>> FILE append standard output to FILE
2431 >&N redirect standard output to file descriptor N
2432 1>&N redirect standard output to file descriptor N
2433 >>&N append standard output to file descriptor N
2434 1>>&N append standard output to file descriptor N
2435 2> FILE redirect standard error to FILE
2436 2>> FILE append standard error to FILE
2437 2>&N redirect standard error to file descriptor N
2438 2>>&N append standard error to file descriptor N
2440 Note that using N > 2 in the above construct is supported, but
2441 requires that the corresponding file descriptor be open by some
2442 means elsewhere or outside GDB. Also note that using ">&0" or
2443 "<&2" will generally fail, because the file descriptor redirected
2444 from is normally open in an incompatible mode (e.g., FD 0 is open
2445 for reading only). IOW, use of such tricks is not recommended;
2446 you are on your own.
2448 We do NOT support redirection of file descriptors above 2, as in
2449 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2450 that needs special handling in the startup code that MinGW
2451 doesn't have). Pipes are also not supported.
2453 As for invalid use cases, where the redirection contains some
2454 error, the emulation below will detect that and produce some
2455 error and/or failure. But the behavior in those cases is not
2456 bug-for-bug compatible with what cmd.exe does in those cases.
2457 That's because what cmd.exe does then is not well defined, and
2458 seems to be a side effect of the cmd.exe parsing of the command
2459 line more than anything else. For example, try redirecting to an
2460 invalid file name, as in "> foo:bar".
2462 There are also minor syntactic deviations from what cmd.exe does
2463 in some corner cases. For example, it doesn't support the likes
2464 of "> &foo" to mean redirect to file named literally "&foo"; we
2465 do support that here, because that, too, sounds like some issue
2466 with the cmd.exe parser. Another nicety is that we support
2467 redirection targets that use file names with forward slashes,
2468 something cmd.exe doesn't -- this comes in handy since GDB
2469 file-name completion can be used when typing the command line for
2472 /* Support routines for redirecting standard handles of the inferior. */
2474 /* Parse a single redirection spec, open/duplicate the specified
2475 file/fd, and assign the appropriate value to one of the 3 standard
2476 file descriptors. */
2478 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2480 int *fd
, ref_fd
= -2;
2482 const char *fname
= redir_string
+ 1;
2483 int rc
= *redir_string
;
2498 fd
= (rc
== '2') ? err
: out
;
2499 mode
= O_WRONLY
| O_CREAT
;
2512 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2514 /* A reference to a file descriptor. */
2516 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2517 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2519 /* Don't allow redirection when open modes are incompatible. */
2520 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2521 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2528 else if (ref_fd
== 1)
2530 else if (ref_fd
== 2)
2540 fname
++; /* skip the separator space */
2541 /* If the descriptor is already open, close it. This allows
2542 multiple specs of redirections for the same stream, which is
2543 somewhat nonsensical, but still valid and supported by cmd.exe.
2544 (But cmd.exe only opens a single file in this case, the one
2545 specified by the last redirection spec on the command line.) */
2550 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2554 else if (ref_fd
== -1)
2555 *fd
= -1; /* reset to default destination */
2558 *fd
= _dup (ref_fd
);
2562 /* _open just sets a flag for O_APPEND, which won't be passed to the
2563 inferior, so we need to actually move the file pointer. */
2564 if ((mode
& O_APPEND
) != 0)
2565 _lseek (*fd
, 0L, SEEK_END
);
2569 /* Canonicalize a single redirection spec and set up the corresponding
2570 file descriptor as specified. */
2572 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2574 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2576 const char *start
= s
;
2579 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2580 if ((*start
== '>' || *start
== '1' || *start
== '2')
2584 if (*s
== '>' && *start
!= '>')
2587 else if (*start
== '0' && *s
== '<')
2589 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2592 while (isspace (*s
)) /* skip whitespace before file name */
2594 *d
++ = ' '; /* separate file name with a single space */
2597 /* Copy the file name. */
2600 /* Remove quoting characters from the file name in buf[]. */
2601 if (*s
== '"') /* could support '..' quoting here */
2605 else if (*s
== quote
)
2613 else if (*s
== '\\')
2615 if (s
[1] == '"') /* could support '..' here */
2619 else if (isspace (*s
) && !quote
)
2623 if (d
- buf
>= sizeof (buf
) - 1)
2625 errno
= ENAMETOOLONG
;
2631 /* Windows doesn't allow redirection characters in file names, so we
2632 can bail out early if they use them, or if there's no target file
2633 name after the redirection symbol. */
2634 if (d
[-1] == '>' || d
[-1] == '<')
2639 if (redir_open (buf
, inp
, out
, err
) == 0)
2644 /* Parse the command line for redirection specs and prepare the file
2645 descriptors for the 3 standard streams accordingly. */
2647 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2648 int *inp
, int *out
, int *err
)
2650 const char *s
= cmd_orig
;
2653 bool retval
= false;
2655 while (isspace (*s
))
2660 if (*s
== '"') /* could also support '..' quoting here */
2664 else if (*s
== quote
)
2667 else if (*s
== '\\')
2669 if (s
[1] == '"') /* escaped quote char */
2674 /* Process a single redirection candidate. */
2675 if (*s
== '<' || *s
== '>'
2676 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2677 || (*s
== '0' && s
[1] == '<'))
2679 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2693 #endif /* !__CYGWIN__ */
2695 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2696 EXEC_FILE is the file to run.
2697 ALLARGS is a string containing the arguments to the program.
2698 ENV is the environment vector to pass. Errors reported with error(). */
2701 windows_nat_target::create_inferior (const char *exec_file
,
2702 const std::string
&origallargs
,
2703 char **in_env
, int from_tty
)
2707 cygwin_buf_t real_path
[__PMAX
];
2708 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2709 cygwin_buf_t infcwd
[__PMAX
];
2711 cygwin_buf_t
*toexec
;
2712 cygwin_buf_t
*cygallargs
;
2714 char **old_env
= NULL
;
2718 int ostdin
, ostdout
, ostderr
;
2719 #else /* !__CYGWIN__ */
2720 char shell
[__PMAX
]; /* Path to shell */
2722 char *args
, *allargs_copy
;
2723 size_t args_len
, allargs_len
;
2724 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2725 HANDLE tty
= INVALID_HANDLE_VALUE
;
2726 bool redirected
= false;
2733 #endif /* !__CYGWIN__ */
2734 const char *allargs
= origallargs
.c_str ();
2735 PROCESS_INFORMATION pi
;
2738 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2741 error (_("No executable specified, use `target exec'."));
2743 const char *inferior_cwd
= get_inferior_cwd ();
2744 std::string expanded_infcwd
;
2745 if (inferior_cwd
!= NULL
)
2747 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
2748 /* Mirror slashes on inferior's cwd. */
2749 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
2751 inferior_cwd
= expanded_infcwd
.c_str ();
2754 memset (&si
, 0, sizeof (si
));
2755 si
.cb
= sizeof (si
);
2758 flags
|= CREATE_NEW_PROCESS_GROUP
;
2761 windows_set_console_info (&si
, &flags
);
2766 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2767 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2768 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2769 error (_("Error starting executable: %d"), errno
);
2772 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2773 if (len
== (size_t) -1)
2774 error (_("Error starting executable: %d"), errno
);
2775 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2776 mbstowcs (cygallargs
, allargs
, len
);
2777 #else /* !__USEWIDE */
2778 cygallargs
= allargs
;
2784 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2785 error (_("Error starting executable via shell: %d"), errno
);
2787 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2788 + mbstowcs (NULL
, allargs
, 0) + 2;
2789 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2790 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2791 #else /* !__USEWIDE */
2792 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2793 + strlen (allargs
) + 2);
2794 cygallargs
= (char *) alloca (len
);
2795 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2796 #endif /* __USEWIDE */
2798 flags
|= DEBUG_PROCESS
;
2801 if (inferior_cwd
!= NULL
2802 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
2803 infcwd
, strlen (inferior_cwd
)) < 0)
2804 error (_("Error converting inferior cwd: %d"), errno
);
2807 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2808 * sizeof (wchar_t));
2809 wcscpy (args
, toexec
);
2810 wcscat (args
, L
" ");
2811 wcscat (args
, cygallargs
);
2812 #else /* !__USEWIDE */
2813 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2814 strcpy (args
, toexec
);
2816 strcat (args
, cygallargs
);
2817 #endif /* !__USEWIDE */
2819 #ifdef CW_CVT_ENV_TO_WINENV
2820 /* First try to create a direct Win32 copy of the POSIX environment. */
2821 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2822 if (w32_env
!= (PWCHAR
) -1)
2823 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2825 /* If that fails, fall back to old method tweaking GDB's environment. */
2826 #endif /* CW_CVT_ENV_TO_WINENV */
2828 /* Reset all Win32 environment variables to avoid leftover on next run. */
2829 clear_win32_environment (environ
);
2830 /* Prepare the environment vars for CreateProcess. */
2833 cygwin_internal (CW_SYNC_WINENV
);
2837 if (!inferior_io_terminal
)
2838 tty
= ostdin
= ostdout
= ostderr
= -1;
2841 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2844 print_sys_errmsg (inferior_io_terminal
, errno
);
2845 ostdin
= ostdout
= ostderr
= -1;
2858 windows_init_thread_list ();
2859 ret
= CreateProcess (0,
2860 args
, /* command line */
2861 NULL
, /* Security */
2863 TRUE
, /* inherit handles */
2864 flags
, /* start flags */
2865 w32_env
, /* environment */
2866 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
2871 /* Just free the Win32 environment, if it could be created. */
2875 /* Reset all environment variables to avoid leftover on next run. */
2876 clear_win32_environment (in_env
);
2877 /* Restore normal GDB environment variables. */
2879 cygwin_internal (CW_SYNC_WINENV
);
2892 #else /* !__CYGWIN__ */
2893 allargs_len
= strlen (allargs
);
2894 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
2895 if (strpbrk (allargs_copy
, "<>") != NULL
)
2900 redirect_inferior_handles (allargs
, allargs_copy
,
2901 &fd_inp
, &fd_out
, &fd_err
);
2903 warning (_("Error in redirection: %s."), safe_strerror (errno
));
2906 allargs_len
= strlen (allargs_copy
);
2908 /* If not all the standard streams are redirected by the command
2909 line, use inferior_io_terminal for those which aren't. */
2910 if (inferior_io_terminal
2911 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
2913 SECURITY_ATTRIBUTES sa
;
2914 sa
.nLength
= sizeof(sa
);
2915 sa
.lpSecurityDescriptor
= 0;
2916 sa
.bInheritHandle
= TRUE
;
2917 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2918 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2919 if (tty
== INVALID_HANDLE_VALUE
)
2920 warning (_("Warning: Failed to open TTY %s, error %#x."),
2921 inferior_io_terminal
, (unsigned) GetLastError ());
2923 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
2926 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
2927 else if (tty
!= INVALID_HANDLE_VALUE
)
2930 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
2932 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
2933 else if (tty
!= INVALID_HANDLE_VALUE
)
2934 si
.hStdOutput
= tty
;
2936 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
2938 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
2939 else if (tty
!= INVALID_HANDLE_VALUE
)
2942 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
2943 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2947 /* Build the command line, a space-separated list of tokens where
2948 the first token is the name of the module to be executed.
2949 To avoid ambiguities introduced by spaces in the module name,
2951 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
2952 args
= (char *) alloca (args_len
);
2953 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
2955 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2957 /* CreateProcess takes the environment list as a null terminated set of
2958 strings (i.e. two nulls terminate the list). */
2960 /* Get total size for env strings. */
2961 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2962 envlen
+= strlen (in_env
[i
]) + 1;
2964 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2965 env
= (char **) alloca (envsize
);
2966 memcpy (env
, in_env
, envsize
);
2967 /* Windows programs expect the environment block to be sorted. */
2968 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2970 w32env
= (char *) alloca (envlen
+ 1);
2972 /* Copy env strings into new buffer. */
2973 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2975 strcpy (temp
, env
[i
]);
2976 temp
+= strlen (temp
) + 1;
2979 /* Final nil string to terminate new env. */
2982 windows_init_thread_list ();
2983 ret
= CreateProcessA (0,
2984 args
, /* command line */
2985 NULL
, /* Security */
2987 TRUE
, /* inherit handles */
2988 flags
, /* start flags */
2989 w32env
, /* environment */
2990 inferior_cwd
, /* current directory */
2993 if (tty
!= INVALID_HANDLE_VALUE
)
3001 #endif /* !__CYGWIN__ */
3004 error (_("Error creating process %s, (error %u)."),
3005 exec_file
, (unsigned) GetLastError ());
3009 if (IsWow64Process (pi
.hProcess
, &wow64
))
3010 wow64_process
= wow64
;
3013 CloseHandle (pi
.hThread
);
3014 CloseHandle (pi
.hProcess
);
3016 if (useshell
&& shell
[0] != '\0')
3021 do_initial_windows_stuff (this, pi
.dwProcessId
, 0);
3023 /* windows_continue (DBG_CONTINUE, -1, 0); */
3027 windows_nat_target::mourn_inferior ()
3029 (void) windows_continue (DBG_CONTINUE
, -1, 0);
3030 x86_cleanup_dregs();
3031 if (open_process_used
)
3033 CHECK (CloseHandle (current_process_handle
));
3034 open_process_used
= 0;
3036 siginfo_er
.ExceptionCode
= 0;
3037 inf_child_target::mourn_inferior ();
3040 /* Send a SIGINT to the process group. This acts just like the user typed a
3041 ^C on the controlling terminal. */
3044 windows_nat_target::interrupt ()
3046 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
3047 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
3048 registers_changed (); /* refresh register state */
3051 /* Helper for windows_xfer_partial that handles memory transfers.
3052 Arguments are like target_xfer_partial. */
3054 static enum target_xfer_status
3055 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3056 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
3060 DWORD lasterror
= 0;
3062 if (writebuf
!= NULL
)
3064 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
3065 pulongest (len
), core_addr_to_string (memaddr
)));
3066 success
= WriteProcessMemory (current_process_handle
,
3067 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
3070 lasterror
= GetLastError ();
3071 FlushInstructionCache (current_process_handle
,
3072 (LPCVOID
) (uintptr_t) memaddr
, len
);
3076 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
3077 pulongest (len
), core_addr_to_string (memaddr
)));
3078 success
= ReadProcessMemory (current_process_handle
,
3079 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
3082 lasterror
= GetLastError ();
3084 *xfered_len
= (ULONGEST
) done
;
3085 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
3086 return TARGET_XFER_OK
;
3088 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
3092 windows_nat_target::kill ()
3094 CHECK (TerminateProcess (current_process_handle
, 0));
3098 if (!windows_continue (DBG_CONTINUE
, -1, 1))
3100 if (!wait_for_debug_event (¤t_event
, INFINITE
))
3102 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
3106 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
3110 windows_nat_target::close ()
3112 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
3113 inferior_ptid
.pid ()));
3116 /* Convert pid to printable format. */
3118 windows_nat_target::pid_to_str (ptid_t ptid
)
3120 if (ptid
.lwp () != 0)
3121 return string_printf ("Thread %d.0x%lx", ptid
.pid (), ptid
.lwp ());
3123 return normal_pid_to_str (ptid
);
3126 static enum target_xfer_status
3127 windows_xfer_shared_libraries (struct target_ops
*ops
,
3128 enum target_object object
, const char *annex
,
3129 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3130 ULONGEST offset
, ULONGEST len
,
3131 ULONGEST
*xfered_len
)
3133 struct obstack obstack
;
3139 return TARGET_XFER_E_IO
;
3141 obstack_init (&obstack
);
3142 obstack_grow_str (&obstack
, "<library-list>\n");
3143 for (so
= solib_start
.next
; so
; so
= so
->next
)
3145 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
3147 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
3148 (uintptr_t) li
->load_addr
,
3150 target_gdbarch (), &obstack
);
3152 obstack_grow_str0 (&obstack
, "</library-list>\n");
3154 buf
= (const char *) obstack_finish (&obstack
);
3155 len_avail
= strlen (buf
);
3156 if (offset
>= len_avail
)
3160 if (len
> len_avail
- offset
)
3161 len
= len_avail
- offset
;
3162 memcpy (readbuf
, buf
+ offset
, len
);
3165 obstack_free (&obstack
, NULL
);
3166 *xfered_len
= (ULONGEST
) len
;
3167 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
3170 /* Helper for windows_nat_target::xfer_partial that handles signal info. */
3172 static enum target_xfer_status
3173 windows_xfer_siginfo (gdb_byte
*readbuf
, ULONGEST offset
, ULONGEST len
,
3174 ULONGEST
*xfered_len
)
3176 char *buf
= (char *) &siginfo_er
;
3177 size_t bufsize
= sizeof (siginfo_er
);
3180 EXCEPTION_RECORD32 er32
;
3183 buf
= (char *) &er32
;
3184 bufsize
= sizeof (er32
);
3186 er32
.ExceptionCode
= siginfo_er
.ExceptionCode
;
3187 er32
.ExceptionFlags
= siginfo_er
.ExceptionFlags
;
3188 er32
.ExceptionRecord
= (uintptr_t) siginfo_er
.ExceptionRecord
;
3189 er32
.ExceptionAddress
= (uintptr_t) siginfo_er
.ExceptionAddress
;
3190 er32
.NumberParameters
= siginfo_er
.NumberParameters
;
3192 for (i
= 0; i
< EXCEPTION_MAXIMUM_PARAMETERS
; i
++)
3193 er32
.ExceptionInformation
[i
] = siginfo_er
.ExceptionInformation
[i
];
3197 if (siginfo_er
.ExceptionCode
== 0)
3198 return TARGET_XFER_E_IO
;
3200 if (readbuf
== nullptr)
3201 return TARGET_XFER_E_IO
;
3203 if (offset
> bufsize
)
3204 return TARGET_XFER_E_IO
;
3206 if (offset
+ len
> bufsize
)
3207 len
= bufsize
- offset
;
3209 memcpy (readbuf
, buf
+ offset
, len
);
3212 return TARGET_XFER_OK
;
3215 enum target_xfer_status
3216 windows_nat_target::xfer_partial (enum target_object object
,
3217 const char *annex
, gdb_byte
*readbuf
,
3218 const gdb_byte
*writebuf
, ULONGEST offset
,
3219 ULONGEST len
, ULONGEST
*xfered_len
)
3223 case TARGET_OBJECT_MEMORY
:
3224 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
3226 case TARGET_OBJECT_LIBRARIES
:
3227 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
3228 writebuf
, offset
, len
, xfered_len
);
3230 case TARGET_OBJECT_SIGNAL_INFO
:
3231 return windows_xfer_siginfo (readbuf
, offset
, len
, xfered_len
);
3234 if (beneath () == NULL
)
3236 /* This can happen when requesting the transfer of unsupported
3237 objects before a program has been started (and therefore
3238 with the current_target having no target beneath). */
3239 return TARGET_XFER_E_IO
;
3241 return beneath ()->xfer_partial (object
, annex
,
3242 readbuf
, writebuf
, offset
, len
,
3247 /* Provide thread local base, i.e. Thread Information Block address.
3248 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
3251 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
3253 windows_thread_info
*th
;
3255 th
= thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
);
3260 *addr
= th
->thread_local_base
;
3266 windows_nat_target::get_ada_task_ptid (long lwp
, long thread
)
3268 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
3271 /* Implementation of the to_thread_name method. */
3274 windows_nat_target::thread_name (struct thread_info
*thr
)
3276 return thread_rec (thr
->ptid
, DONT_INVALIDATE_CONTEXT
)->name
.get ();
3280 void _initialize_windows_nat ();
3282 _initialize_windows_nat ()
3284 x86_dr_low
.set_control
= cygwin_set_dr7
;
3285 x86_dr_low
.set_addr
= cygwin_set_dr
;
3286 x86_dr_low
.get_addr
= cygwin_get_dr
;
3287 x86_dr_low
.get_status
= cygwin_get_dr6
;
3288 x86_dr_low
.get_control
= cygwin_get_dr7
;
3290 /* x86_dr_low.debug_register_length field is set by
3291 calling x86_set_debug_register_length function
3292 in processor windows specific native file. */
3294 add_inf_child_target (&the_windows_nat_target
);
3297 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3300 add_com ("signal-event", class_run
, signal_event_command
, _("\
3301 Signal a crashed process with event ID, to allow its debugging.\n\
3302 This command is needed in support of setting up GDB as JIT debugger on \
3303 MS-Windows. The command should be invoked from the GDB command line using \
3304 the '-ex' command-line option. The ID of the event that blocks the \
3305 crashed process will be supplied by the Windows JIT debugging mechanism."));
3308 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3309 Set use of shell to start subprocess."), _("\
3310 Show use of shell to start subprocess."), NULL
,
3312 NULL
, /* FIXME: i18n: */
3313 &setlist
, &showlist
);
3315 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3316 &cygwin_exceptions
, _("\
3317 Break when an exception is detected in the Cygwin DLL itself."), _("\
3318 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3320 NULL
, /* FIXME: i18n: */
3321 &setlist
, &showlist
);
3324 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3325 Set creation of new console when creating child process."), _("\
3326 Show creation of new console when creating child process."), NULL
,
3328 NULL
, /* FIXME: i18n: */
3329 &setlist
, &showlist
);
3331 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3332 Set creation of new group when creating child process."), _("\
3333 Show creation of new group when creating child process."), NULL
,
3335 NULL
, /* FIXME: i18n: */
3336 &setlist
, &showlist
);
3338 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3339 Set whether to display execution in child process."), _("\
3340 Show whether to display execution in child process."), NULL
,
3342 NULL
, /* FIXME: i18n: */
3343 &setlist
, &showlist
);
3345 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3346 Set whether to display kernel events in child process."), _("\
3347 Show whether to display kernel events in child process."), NULL
,
3349 NULL
, /* FIXME: i18n: */
3350 &setlist
, &showlist
);
3352 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3353 Set whether to display memory accesses in child process."), _("\
3354 Show whether to display memory accesses in child process."), NULL
,
3356 NULL
, /* FIXME: i18n: */
3357 &setlist
, &showlist
);
3359 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3360 &debug_exceptions
, _("\
3361 Set whether to display kernel exceptions in child process."), _("\
3362 Show whether to display kernel exceptions in child process."), NULL
,
3364 NULL
, /* FIXME: i18n: */
3365 &setlist
, &showlist
);
3367 init_w32_command_list ();
3369 add_cmd ("selector", class_info
, display_selectors
,
3370 _("Display selectors infos."),
3374 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3376 /* Pass the address ADDR to the inferior in the I'th debug register.
3377 Here we just store the address in dr array, the registers will be
3378 actually set up when windows_continue is called. */
3380 cygwin_set_dr (int i
, CORE_ADDR addr
)
3383 internal_error (__FILE__
, __LINE__
,
3384 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3386 debug_registers_changed
= 1;
3387 debug_registers_used
= 1;
3390 /* Pass the value VAL to the inferior in the DR7 debug control
3391 register. Here we just store the address in D_REGS, the watchpoint
3392 will be actually set up in windows_wait. */
3394 cygwin_set_dr7 (unsigned long val
)
3396 dr
[7] = (CORE_ADDR
) val
;
3397 debug_registers_changed
= 1;
3398 debug_registers_used
= 1;
3401 /* Get the value of debug register I from the inferior. */
3404 cygwin_get_dr (int i
)
3409 /* Get the value of the DR6 debug status register from the inferior.
3410 Here we just return the value stored in dr[6]
3411 by the last call to thread_rec for current_event.dwThreadId id. */
3412 static unsigned long
3413 cygwin_get_dr6 (void)
3415 return (unsigned long) dr
[6];
3418 /* Get the value of the DR7 debug status register from the inferior.
3419 Here we just return the value stored in dr[7] by the last call to
3420 thread_rec for current_event.dwThreadId id. */
3422 static unsigned long
3423 cygwin_get_dr7 (void)
3425 return (unsigned long) dr
[7];
3428 /* Determine if the thread referenced by "ptid" is alive
3429 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3430 it means that the thread has died. Otherwise it is assumed to be alive. */
3433 windows_nat_target::thread_alive (ptid_t ptid
)
3435 gdb_assert (ptid
.lwp () != 0);
3437 return (WaitForSingleObject (thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
)->h
, 0)
3441 void _initialize_check_for_gdb_ini ();
3443 _initialize_check_for_gdb_ini ()
3446 if (inhibit_gdbinit
)
3449 homedir
= getenv ("HOME");
3453 char *oldini
= (char *) alloca (strlen (homedir
) +
3454 sizeof ("gdb.ini") + 1);
3455 strcpy (oldini
, homedir
);
3456 p
= strchr (oldini
, '\0');
3457 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3459 strcpy (p
, "gdb.ini");
3460 if (access (oldini
, 0) == 0)
3462 int len
= strlen (oldini
);
3463 char *newini
= (char *) alloca (len
+ 2);
3465 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3466 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3467 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3472 /* Define dummy functions which always return error for the rare cases where
3473 these functions could not be found. */
3475 bad_DebugActiveProcessStop (DWORD w
)
3480 bad_DebugBreakProcess (HANDLE w
)
3485 bad_DebugSetProcessKillOnExit (BOOL w
)
3490 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3497 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3503 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3510 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3516 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3522 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3528 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3536 /* Load any functions which may not be available in ancient versions
3539 void _initialize_loadable ();
3541 _initialize_loadable ()
3545 #define GPA(m, func) \
3546 func = (func ## _ftype *) GetProcAddress (m, #func)
3548 hm
= LoadLibrary ("kernel32.dll");
3551 GPA (hm
, DebugActiveProcessStop
);
3552 GPA (hm
, DebugBreakProcess
);
3553 GPA (hm
, DebugSetProcessKillOnExit
);
3554 GPA (hm
, GetConsoleFontSize
);
3555 GPA (hm
, DebugActiveProcessStop
);
3556 GPA (hm
, GetCurrentConsoleFont
);
3558 GPA (hm
, Wow64SuspendThread
);
3559 GPA (hm
, Wow64GetThreadContext
);
3560 GPA (hm
, Wow64SetThreadContext
);
3561 GPA (hm
, Wow64GetThreadSelectorEntry
);
3565 /* Set variables to dummy versions of these processes if the function
3566 wasn't found in kernel32.dll. */
3567 if (!DebugBreakProcess
)
3568 DebugBreakProcess
= bad_DebugBreakProcess
;
3569 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3571 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3572 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3574 if (!GetConsoleFontSize
)
3575 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3576 if (!GetCurrentConsoleFont
)
3577 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3579 /* Load optional functions used for retrieving filename information
3580 associated with the currently debugged process or its dlls. */
3581 hm
= LoadLibrary ("psapi.dll");
3584 GPA (hm
, EnumProcessModules
);
3586 GPA (hm
, EnumProcessModulesEx
);
3588 GPA (hm
, GetModuleInformation
);
3589 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3590 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3593 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3595 /* Set variables to dummy versions of these processes if the function
3596 wasn't found in psapi.dll. */
3597 EnumProcessModules
= bad_EnumProcessModules
;
3598 GetModuleInformation
= bad_GetModuleInformation
;
3599 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3600 /* This will probably fail on Windows 9x/Me. Let the user know
3601 that we're missing some functionality. */
3603 cannot automatically find executable file or library to read symbols.\n\
3604 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3607 hm
= LoadLibrary ("advapi32.dll");
3610 GPA (hm
, OpenProcessToken
);
3611 GPA (hm
, LookupPrivilegeValueA
);
3612 GPA (hm
, AdjustTokenPrivileges
);
3613 /* Only need to set one of these since if OpenProcessToken fails nothing
3615 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3616 || !AdjustTokenPrivileges
)
3617 OpenProcessToken
= bad_OpenProcessToken
;