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
607 && r
== gdbarch_pc_regnum (gdbarch
))
609 int size
= register_size (gdbarch
, r
);
613 memcpy (&value
, context_offset
, size
);
614 value
-= gdbarch_decr_pc_after_break (gdbarch
);
615 memcpy (context_offset
, &value
, size
);
619 gdb_assert (size
== 8);
621 memcpy (&value
, context_offset
, size
);
622 value
-= gdbarch_decr_pc_after_break (gdbarch
);
623 memcpy (context_offset
, &value
, size
);
626 regcache
->raw_supply (r
, context_offset
);
631 windows_nat_target::fetch_registers (struct regcache
*regcache
, int r
)
633 windows_thread_info
*th
= thread_rec (regcache
->ptid (), INVALIDATE_CONTEXT
);
635 /* Check if TH exists. Windows sometimes uses a non-existent
636 thread id in its events. */
640 if (th
->reload_context
)
643 if (have_saved_context
)
645 /* Lie about where the program actually is stopped since
646 cygwin has informed us that we should consider the signal
647 to have occurred at another location which is stored in
649 memcpy (&th
->context
, &saved_context
,
650 __COPY_CONTEXT_SIZE
);
651 have_saved_context
= 0;
658 th
->wow64_context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
659 CHECK (Wow64GetThreadContext (th
->h
, &th
->wow64_context
));
660 /* Copy dr values from that thread.
661 But only if there were not modified since last stop.
663 if (!debug_registers_changed
)
665 dr
[0] = th
->wow64_context
.Dr0
;
666 dr
[1] = th
->wow64_context
.Dr1
;
667 dr
[2] = th
->wow64_context
.Dr2
;
668 dr
[3] = th
->wow64_context
.Dr3
;
669 dr
[6] = th
->wow64_context
.Dr6
;
670 dr
[7] = th
->wow64_context
.Dr7
;
676 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
677 CHECK (GetThreadContext (th
->h
, &th
->context
));
678 /* Copy dr values from that thread.
679 But only if there were not modified since last stop.
681 if (!debug_registers_changed
)
683 dr
[0] = th
->context
.Dr0
;
684 dr
[1] = th
->context
.Dr1
;
685 dr
[2] = th
->context
.Dr2
;
686 dr
[3] = th
->context
.Dr3
;
687 dr
[6] = th
->context
.Dr6
;
688 dr
[7] = th
->context
.Dr7
;
691 th
->reload_context
= false;
695 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch()); r
++)
696 windows_fetch_one_register (regcache
, th
, r
);
698 windows_fetch_one_register (regcache
, th
, r
);
701 /* Collect the register number R from the given regcache, and store
702 its value into the corresponding area of the given thread's context.
704 This function assumes that R is non-negative. A failed assertion
705 assertion is raised if that is not true. */
708 windows_store_one_register (const struct regcache
*regcache
,
709 windows_thread_info
*th
, int r
)
713 char *context_ptr
= (char *) &th
->context
;
716 context_ptr
= (char *) &th
->wow64_context
;
719 regcache
->raw_collect (r
, context_ptr
+ mappings
[r
]);
722 /* Store a new register value into the context of the thread tied to
726 windows_nat_target::store_registers (struct regcache
*regcache
, int r
)
728 windows_thread_info
*th
= thread_rec (regcache
->ptid (), INVALIDATE_CONTEXT
);
730 /* Check if TH exists. Windows sometimes uses a non-existent
731 thread id in its events. */
736 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch ()); r
++)
737 windows_store_one_register (regcache
, th
, r
);
739 windows_store_one_register (regcache
, th
, r
);
742 /* Maintain a linked list of "so" information. */
743 struct lm_info_windows
: public lm_info_base
745 LPVOID load_addr
= 0;
746 CORE_ADDR text_offset
= 0;
749 static struct so_list solib_start
, *solib_end
;
751 static struct so_list
*
752 windows_make_so (const char *name
, LPVOID load_addr
)
759 WIN32_FIND_DATA w32_fd
;
760 HANDLE h
= FindFirstFile(name
, &w32_fd
);
762 if (h
== INVALID_HANDLE_VALUE
)
768 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
770 p
= strrchr (buf
, '\\');
773 SetCurrentDirectory (buf
);
774 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
775 SetCurrentDirectory (cwd
);
778 if (strcasecmp (buf
, "ntdll.dll") == 0)
780 GetSystemDirectory (buf
, sizeof (buf
));
781 strcat (buf
, "\\ntdll.dll");
784 cygwin_buf_t buf
[__PMAX
];
787 if (access (name
, F_OK
) != 0)
789 if (strcasecmp (name
, "ntdll.dll") == 0)
792 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
793 wcscat (buf
, L
"\\ntdll.dll");
797 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
798 strcat (buf
, "\\ntdll.dll");
803 so
= XCNEW (struct so_list
);
804 lm_info_windows
*li
= new lm_info_windows
;
806 li
->load_addr
= load_addr
;
807 strcpy (so
->so_original_name
, name
);
809 strcpy (so
->so_name
, buf
);
812 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
813 SO_NAME_MAX_PATH_SIZE
);
816 char *rname
= realpath (name
, NULL
);
817 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
819 strcpy (so
->so_name
, rname
);
824 warning (_("dll path for \"%s\" too long or inaccessible"), name
);
825 strcpy (so
->so_name
, so
->so_original_name
);
828 /* Record cygwin1.dll .text start/end. */
829 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
830 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
832 asection
*text
= NULL
;
834 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386", -1));
839 if (bfd_check_format (abfd
.get (), bfd_object
))
840 text
= bfd_get_section_by_name (abfd
.get (), ".text");
845 /* The symbols in a dll are offset by 0x1000, which is the
846 offset from 0 of the first byte in an image - because of the
847 file header and the section alignment. */
848 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
850 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (text
);
857 /* See nat/windows-nat.h. */
860 windows_nat::handle_load_dll ()
862 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
863 const char *dll_name
;
865 /* Try getting the DLL name via the lpImageName field of the event.
866 Note that Microsoft documents this fields as strictly optional,
867 in the sense that it might be NULL. And the first DLL event in
868 particular is explicitly documented as "likely not pass[ed]"
869 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
870 dll_name
= get_image_name (current_process_handle
,
871 event
->lpImageName
, event
->fUnicode
);
875 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
876 solib_end
= solib_end
->next
;
878 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
880 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
881 host_address_to_string (li
->load_addr
)));
885 windows_free_so (struct so_list
*so
)
887 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
893 /* See nat/windows-nat.h. */
896 windows_nat::handle_unload_dll ()
898 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
901 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
903 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
905 if (li_next
->load_addr
== lpBaseOfDll
)
907 struct so_list
*sodel
= so
->next
;
909 so
->next
= sodel
->next
;
912 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
914 windows_free_so (sodel
);
919 /* We did not find any DLL that was previously loaded at this address,
920 so register a complaint. We do not report an error, because we have
921 observed that this may be happening under some circumstances. For
922 instance, running 32bit applications on x64 Windows causes us to receive
923 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
924 events are apparently caused by the WOW layer, the interface between
925 32bit and 64bit worlds). */
926 complaint (_("dll starting at %s not found."),
927 host_address_to_string (lpBaseOfDll
));
930 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
934 catch_errors (void (*func
) ())
940 catch (const gdb_exception
&ex
)
942 exception_print (gdb_stderr
, ex
);
946 /* Clear list of loaded DLLs. */
948 windows_clear_solib (void)
952 for (so
= solib_start
.next
; so
; so
= solib_start
.next
)
954 solib_start
.next
= so
->next
;
955 windows_free_so (so
);
958 solib_end
= &solib_start
;
962 signal_event_command (const char *args
, int from_tty
)
964 uintptr_t event_id
= 0;
965 char *endargs
= NULL
;
968 error (_("signal-event requires an argument (integer event id)"));
970 event_id
= strtoumax (args
, &endargs
, 10);
972 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
973 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
974 error (_("Failed to convert `%s' to event id"), args
);
976 SetEvent ((HANDLE
) event_id
);
977 CloseHandle ((HANDLE
) event_id
);
980 /* See nat/windows-nat.h. */
983 windows_nat::handle_output_debug_string (struct target_waitstatus
*ourstatus
)
985 gdb::unique_xmalloc_ptr
<char> s
;
988 if (!target_read_string
989 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
991 || !s
|| !*(s
.get ()))
993 else if (!startswith (s
.get (), _CYGWIN_SIGNAL_STRING
))
996 if (!startswith (s
.get (), "cYg"))
999 char *p
= strchr (s
.get (), '\0');
1001 if (p
> s
.get () && *--p
== '\n')
1003 warning (("%s"), s
.get ());
1009 /* Got a cygwin signal marker. A cygwin signal is followed by
1010 the signal number itself and then optionally followed by the
1011 thread id and address to saved context within the DLL. If
1012 these are supplied, then the given thread is assumed to have
1013 issued the signal and the context from the thread is assumed
1014 to be stored at the given address in the inferior. Tell gdb
1015 to treat this like a real signal. */
1017 int sig
= strtol (s
.get () + sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
1018 gdb_signal gotasig
= gdb_signal_from_host (sig
);
1020 ourstatus
->value
.sig
= gotasig
;
1026 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1027 retval
= strtoul (p
, &p
, 0);
1029 retval
= current_event
.dwThreadId
;
1030 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
1031 && ReadProcessMemory (current_process_handle
, x
,
1033 __COPY_CONTEXT_SIZE
, &n
)
1034 && n
== __COPY_CONTEXT_SIZE
)
1035 have_saved_context
= 1;
1044 display_selector (HANDLE thread
, DWORD sel
)
1050 ret
= Wow64GetThreadSelectorEntry (thread
, sel
, &info
);
1053 ret
= GetThreadSelectorEntry (thread
, sel
, &info
);
1057 printf_filtered ("0x%03x: ", (unsigned) sel
);
1058 if (!info
.HighWord
.Bits
.Pres
)
1060 puts_filtered ("Segment not present\n");
1063 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1064 (info
.HighWord
.Bits
.BaseMid
<< 16)
1066 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1067 if (info
.HighWord
.Bits
.Granularity
)
1068 limit
= (limit
<< 12) | 0xfff;
1069 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1070 if (info
.HighWord
.Bits
.Default_Big
)
1071 puts_filtered(" 32-bit ");
1073 puts_filtered(" 16-bit ");
1074 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1077 puts_filtered ("Data (Read-Only, Exp-up");
1080 puts_filtered ("Data (Read/Write, Exp-up");
1083 puts_filtered ("Unused segment (");
1086 puts_filtered ("Data (Read/Write, Exp-down");
1089 puts_filtered ("Code (Exec-Only, N.Conf");
1092 puts_filtered ("Code (Exec/Read, N.Conf");
1095 puts_filtered ("Code (Exec-Only, Conf");
1098 puts_filtered ("Code (Exec/Read, Conf");
1101 printf_filtered ("Unknown type 0x%lx",
1102 (unsigned long) info
.HighWord
.Bits
.Type
);
1104 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1105 puts_filtered(", N.Acc");
1106 puts_filtered (")\n");
1107 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1108 puts_filtered("System selector ");
1109 printf_filtered ("Priviledge level = %ld. ",
1110 (unsigned long) info
.HighWord
.Bits
.Dpl
);
1111 if (info
.HighWord
.Bits
.Granularity
)
1112 puts_filtered ("Page granular.\n");
1114 puts_filtered ("Byte granular.\n");
1119 DWORD err
= GetLastError ();
1120 if (err
== ERROR_NOT_SUPPORTED
)
1121 printf_filtered ("Function not supported\n");
1123 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1129 display_selectors (const char * args
, int from_tty
)
1131 if (!current_windows_thread
)
1133 puts_filtered ("Impossible to display selectors now.\n");
1141 puts_filtered ("Selector $cs\n");
1142 display_selector (current_windows_thread
->h
,
1143 current_windows_thread
->wow64_context
.SegCs
);
1144 puts_filtered ("Selector $ds\n");
1145 display_selector (current_windows_thread
->h
,
1146 current_windows_thread
->wow64_context
.SegDs
);
1147 puts_filtered ("Selector $es\n");
1148 display_selector (current_windows_thread
->h
,
1149 current_windows_thread
->wow64_context
.SegEs
);
1150 puts_filtered ("Selector $ss\n");
1151 display_selector (current_windows_thread
->h
,
1152 current_windows_thread
->wow64_context
.SegSs
);
1153 puts_filtered ("Selector $fs\n");
1154 display_selector (current_windows_thread
->h
,
1155 current_windows_thread
->wow64_context
.SegFs
);
1156 puts_filtered ("Selector $gs\n");
1157 display_selector (current_windows_thread
->h
,
1158 current_windows_thread
->wow64_context
.SegGs
);
1163 puts_filtered ("Selector $cs\n");
1164 display_selector (current_windows_thread
->h
,
1165 current_windows_thread
->context
.SegCs
);
1166 puts_filtered ("Selector $ds\n");
1167 display_selector (current_windows_thread
->h
,
1168 current_windows_thread
->context
.SegDs
);
1169 puts_filtered ("Selector $es\n");
1170 display_selector (current_windows_thread
->h
,
1171 current_windows_thread
->context
.SegEs
);
1172 puts_filtered ("Selector $ss\n");
1173 display_selector (current_windows_thread
->h
,
1174 current_windows_thread
->context
.SegSs
);
1175 puts_filtered ("Selector $fs\n");
1176 display_selector (current_windows_thread
->h
,
1177 current_windows_thread
->context
.SegFs
);
1178 puts_filtered ("Selector $gs\n");
1179 display_selector (current_windows_thread
->h
,
1180 current_windows_thread
->context
.SegGs
);
1186 sel
= parse_and_eval_long (args
);
1187 printf_filtered ("Selector \"%s\"\n",args
);
1188 display_selector (current_windows_thread
->h
, sel
);
1192 /* See nat/windows-nat.h. */
1195 windows_nat::handle_ms_vc_exception (const EXCEPTION_RECORD
*rec
)
1197 if (rec
->NumberParameters
>= 3
1198 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1200 DWORD named_thread_id
;
1201 windows_thread_info
*named_thread
;
1202 CORE_ADDR thread_name_target
;
1204 thread_name_target
= rec
->ExceptionInformation
[1];
1205 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1207 if (named_thread_id
== (DWORD
) -1)
1208 named_thread_id
= current_event
.dwThreadId
;
1210 named_thread
= thread_rec (ptid_t (current_event
.dwProcessId
,
1211 named_thread_id
, 0),
1212 DONT_INVALIDATE_CONTEXT
);
1213 if (named_thread
!= NULL
)
1215 int thread_name_len
;
1216 gdb::unique_xmalloc_ptr
<char> thread_name
;
1218 thread_name_len
= target_read_string (thread_name_target
,
1219 &thread_name
, 1025, NULL
);
1220 if (thread_name_len
> 0)
1222 thread_name
.get ()[thread_name_len
- 1] = '\0';
1223 named_thread
->name
= std::move (thread_name
);
1233 /* Resume thread specified by ID, or all artificially suspended
1234 threads, if we are continuing execution. KILLED non-zero means we
1235 have killed the inferior, so we should ignore weird errors due to
1236 threads shutting down. */
1238 windows_continue (DWORD continue_status
, int id
, int killed
)
1242 desired_stop_thread_id
= id
;
1244 if (matching_pending_stop (debug_events
))
1247 for (windows_thread_info
*th
: thread_list
)
1248 if (id
== -1 || id
== (int) th
->tid
)
1255 if (debug_registers_changed
)
1257 th
->wow64_context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1258 th
->wow64_context
.Dr0
= dr
[0];
1259 th
->wow64_context
.Dr1
= dr
[1];
1260 th
->wow64_context
.Dr2
= dr
[2];
1261 th
->wow64_context
.Dr3
= dr
[3];
1262 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1263 th
->wow64_context
.Dr7
= dr
[7];
1265 if (th
->wow64_context
.ContextFlags
)
1269 if (GetExitCodeThread (th
->h
, &ec
)
1270 && ec
== STILL_ACTIVE
)
1272 BOOL status
= Wow64SetThreadContext (th
->h
,
1273 &th
->wow64_context
);
1278 th
->wow64_context
.ContextFlags
= 0;
1284 if (debug_registers_changed
)
1286 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1287 th
->context
.Dr0
= dr
[0];
1288 th
->context
.Dr1
= dr
[1];
1289 th
->context
.Dr2
= dr
[2];
1290 th
->context
.Dr3
= dr
[3];
1291 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1292 th
->context
.Dr7
= dr
[7];
1294 if (th
->context
.ContextFlags
)
1298 if (GetExitCodeThread (th
->h
, &ec
)
1299 && ec
== STILL_ACTIVE
)
1301 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1306 th
->context
.ContextFlags
= 0;
1313 /* When single-stepping a specific thread, other threads must
1318 res
= continue_last_debug_event (continue_status
, debug_events
);
1321 error (_("Failed to resume program execution"
1322 " (ContinueDebugEvent failed, error %u)"),
1323 (unsigned int) GetLastError ());
1325 debug_registers_changed
= 0;
1329 /* Called in pathological case where Windows fails to send a
1330 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1332 fake_create_process (void)
1334 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1335 current_event
.dwProcessId
);
1336 if (current_process_handle
!= NULL
)
1337 open_process_used
= 1;
1340 error (_("OpenProcess call failed, GetLastError = %u"),
1341 (unsigned) GetLastError ());
1342 /* We can not debug anything in that case. */
1344 current_windows_thread
1345 = windows_add_thread (ptid_t (current_event
.dwProcessId
,
1346 current_event
.dwThreadId
, 0),
1347 current_event
.u
.CreateThread
.hThread
,
1348 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1349 true /* main_thread_p */);
1350 return current_event
.dwThreadId
;
1354 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1356 windows_thread_info
*th
;
1357 DWORD continue_status
= DBG_CONTINUE
;
1359 /* A specific PTID means `step only this thread id'. */
1360 int resume_all
= ptid
== minus_one_ptid
;
1362 /* If we're continuing all threads, it's the current inferior that
1363 should be handled specially. */
1365 ptid
= inferior_ptid
;
1367 if (sig
!= GDB_SIGNAL_0
)
1369 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1371 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1373 else if (sig
== last_sig
)
1374 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1377 /* This code does not seem to work, because
1378 the kernel does probably not consider changes in the ExceptionRecord
1379 structure when passing the exception to the inferior.
1380 Note that this seems possible in the exception handler itself. */
1382 for (const xlate_exception
&x
: xlate
)
1385 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1387 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1390 if (continue_status
== DBG_CONTINUE
)
1392 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1396 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1400 last_sig
= GDB_SIGNAL_0
;
1402 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=0x%x, step=%d, sig=%d);\n",
1403 ptid
.pid (), (unsigned) ptid
.lwp (), step
, sig
));
1405 /* Get context for currently selected thread. */
1406 th
= thread_rec (inferior_ptid
, DONT_INVALIDATE_CONTEXT
);
1414 /* Single step by setting t bit. */
1415 struct regcache
*regcache
= get_current_regcache ();
1416 struct gdbarch
*gdbarch
= regcache
->arch ();
1417 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1418 th
->wow64_context
.EFlags
|= FLAG_TRACE_BIT
;
1421 if (th
->wow64_context
.ContextFlags
)
1423 if (debug_registers_changed
)
1425 th
->wow64_context
.Dr0
= dr
[0];
1426 th
->wow64_context
.Dr1
= dr
[1];
1427 th
->wow64_context
.Dr2
= dr
[2];
1428 th
->wow64_context
.Dr3
= dr
[3];
1429 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1430 th
->wow64_context
.Dr7
= dr
[7];
1432 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
1433 th
->wow64_context
.ContextFlags
= 0;
1441 /* Single step by setting t bit. */
1442 struct regcache
*regcache
= get_current_regcache ();
1443 struct gdbarch
*gdbarch
= regcache
->arch ();
1444 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1445 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1448 if (th
->context
.ContextFlags
)
1450 if (debug_registers_changed
)
1452 th
->context
.Dr0
= dr
[0];
1453 th
->context
.Dr1
= dr
[1];
1454 th
->context
.Dr2
= dr
[2];
1455 th
->context
.Dr3
= dr
[3];
1456 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1457 th
->context
.Dr7
= dr
[7];
1459 CHECK (SetThreadContext (th
->h
, &th
->context
));
1460 th
->context
.ContextFlags
= 0;
1465 /* Allow continuing with the same signal that interrupted us.
1466 Otherwise complain. */
1469 windows_continue (continue_status
, -1, 0);
1471 windows_continue (continue_status
, ptid
.lwp (), 0);
1474 /* Ctrl-C handler used when the inferior is not run in the same console. The
1475 handler is in charge of interrupting the inferior using DebugBreakProcess.
1476 Note that this function is not available prior to Windows XP. In this case
1477 we emit a warning. */
1479 ctrl_c_handler (DWORD event_type
)
1481 const int attach_flag
= current_inferior ()->attach_flag
;
1483 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1484 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1487 /* If the inferior and the debugger share the same console, do nothing as
1488 the inferior has also received the Ctrl-C event. */
1489 if (!new_console
&& !attach_flag
)
1492 if (!DebugBreakProcess (current_process_handle
))
1493 warning (_("Could not interrupt program. "
1494 "Press Ctrl-c in the program console."));
1496 /* Return true to tell that Ctrl-C has been handled. */
1500 /* Get the next event from the child. Returns a non-zero thread id if the event
1501 requires handling by WFI (or whatever). */
1504 windows_nat_target::get_windows_debug_event (int pid
,
1505 struct target_waitstatus
*ourstatus
)
1508 DWORD continue_status
, event_code
;
1509 windows_thread_info
*th
;
1510 static windows_thread_info
dummy_thread_info (0, 0, 0);
1511 DWORD thread_id
= 0;
1513 /* If there is a relevant pending stop, report it now. See the
1514 comment by the definition of "pending_stops" for details on why
1516 gdb::optional
<pending_stop
> stop
= fetch_pending_stop (debug_events
);
1517 if (stop
.has_value ())
1519 thread_id
= stop
->thread_id
;
1520 *ourstatus
= stop
->status
;
1522 inferior_ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1523 current_windows_thread
= thread_rec (inferior_ptid
,
1524 INVALIDATE_CONTEXT
);
1525 current_windows_thread
->reload_context
= 1;
1530 last_sig
= GDB_SIGNAL_0
;
1532 if (!(debug_event
= wait_for_debug_event (¤t_event
, 1000)))
1535 continue_status
= DBG_CONTINUE
;
1537 event_code
= current_event
.dwDebugEventCode
;
1538 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1540 have_saved_context
= 0;
1544 case CREATE_THREAD_DEBUG_EVENT
:
1545 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1546 (unsigned) current_event
.dwProcessId
,
1547 (unsigned) current_event
.dwThreadId
,
1548 "CREATE_THREAD_DEBUG_EVENT"));
1549 if (saw_create
!= 1)
1551 inferior
*inf
= find_inferior_pid (this, current_event
.dwProcessId
);
1552 if (!saw_create
&& inf
->attach_flag
)
1554 /* Kludge around a Windows bug where first event is a create
1555 thread event. Caused when attached process does not have
1557 thread_id
= fake_create_process ();
1563 /* Record the existence of this thread. */
1564 thread_id
= current_event
.dwThreadId
;
1565 th
= windows_add_thread
1566 (ptid_t (current_event
.dwProcessId
, current_event
.dwThreadId
, 0),
1567 current_event
.u
.CreateThread
.hThread
,
1568 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1569 false /* main_thread_p */);
1573 case EXIT_THREAD_DEBUG_EVENT
:
1574 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1575 (unsigned) current_event
.dwProcessId
,
1576 (unsigned) current_event
.dwThreadId
,
1577 "EXIT_THREAD_DEBUG_EVENT"));
1578 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1579 current_event
.dwThreadId
, 0),
1580 current_event
.u
.ExitThread
.dwExitCode
,
1581 false /* main_thread_p */);
1582 th
= &dummy_thread_info
;
1585 case CREATE_PROCESS_DEBUG_EVENT
:
1586 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1587 (unsigned) current_event
.dwProcessId
,
1588 (unsigned) current_event
.dwThreadId
,
1589 "CREATE_PROCESS_DEBUG_EVENT"));
1590 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1591 if (++saw_create
!= 1)
1594 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1595 /* Add the main thread. */
1596 th
= windows_add_thread
1597 (ptid_t (current_event
.dwProcessId
,
1598 current_event
.dwThreadId
, 0),
1599 current_event
.u
.CreateProcessInfo
.hThread
,
1600 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
,
1601 true /* main_thread_p */);
1602 thread_id
= current_event
.dwThreadId
;
1605 case EXIT_PROCESS_DEBUG_EVENT
:
1606 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1607 (unsigned) current_event
.dwProcessId
,
1608 (unsigned) current_event
.dwThreadId
,
1609 "EXIT_PROCESS_DEBUG_EVENT"));
1610 if (!windows_initialization_done
)
1612 target_terminal::ours ();
1613 target_mourn_inferior (inferior_ptid
);
1614 error (_("During startup program exited with code 0x%x."),
1615 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1617 else if (saw_create
== 1)
1619 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1620 current_event
.dwThreadId
, 0),
1621 0, true /* main_thread_p */);
1622 DWORD exit_status
= current_event
.u
.ExitProcess
.dwExitCode
;
1623 /* If the exit status looks like a fatal exception, but we
1624 don't recognize the exception's code, make the original
1625 exit status value available, to avoid losing
1628 = WIFSIGNALED (exit_status
) ? WTERMSIG (exit_status
) : -1;
1629 if (exit_signal
== -1)
1631 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1632 ourstatus
->value
.integer
= exit_status
;
1636 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1637 ourstatus
->value
.sig
= gdb_signal_from_host (exit_signal
);
1639 thread_id
= current_event
.dwThreadId
;
1643 case LOAD_DLL_DEBUG_EVENT
:
1644 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1645 (unsigned) current_event
.dwProcessId
,
1646 (unsigned) current_event
.dwThreadId
,
1647 "LOAD_DLL_DEBUG_EVENT"));
1648 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1649 if (saw_create
!= 1 || ! windows_initialization_done
)
1651 catch_errors (handle_load_dll
);
1652 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1653 ourstatus
->value
.integer
= 0;
1654 thread_id
= current_event
.dwThreadId
;
1657 case UNLOAD_DLL_DEBUG_EVENT
:
1658 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1659 (unsigned) current_event
.dwProcessId
,
1660 (unsigned) current_event
.dwThreadId
,
1661 "UNLOAD_DLL_DEBUG_EVENT"));
1662 if (saw_create
!= 1 || ! windows_initialization_done
)
1664 catch_errors (handle_unload_dll
);
1665 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1666 ourstatus
->value
.integer
= 0;
1667 thread_id
= current_event
.dwThreadId
;
1670 case EXCEPTION_DEBUG_EVENT
:
1671 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1672 (unsigned) current_event
.dwProcessId
,
1673 (unsigned) current_event
.dwThreadId
,
1674 "EXCEPTION_DEBUG_EVENT"));
1675 if (saw_create
!= 1)
1677 switch (handle_exception (ourstatus
, debug_exceptions
))
1679 case HANDLE_EXCEPTION_UNHANDLED
:
1681 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1683 case HANDLE_EXCEPTION_HANDLED
:
1684 thread_id
= current_event
.dwThreadId
;
1686 case HANDLE_EXCEPTION_IGNORED
:
1687 continue_status
= DBG_CONTINUE
;
1692 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1693 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1694 (unsigned) current_event
.dwProcessId
,
1695 (unsigned) current_event
.dwThreadId
,
1696 "OUTPUT_DEBUG_STRING_EVENT"));
1697 if (saw_create
!= 1)
1699 thread_id
= handle_output_debug_string (ourstatus
);
1703 if (saw_create
!= 1)
1705 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1706 (unsigned) current_event
.dwProcessId
,
1707 (unsigned) current_event
.dwThreadId
);
1708 printf_unfiltered (" unknown event code %u\n",
1709 (unsigned) current_event
.dwDebugEventCode
);
1713 if (!thread_id
|| saw_create
!= 1)
1715 CHECK (windows_continue (continue_status
, desired_stop_thread_id
, 0));
1717 else if (desired_stop_thread_id
!= -1 && desired_stop_thread_id
!= thread_id
)
1719 /* Pending stop. See the comment by the definition of
1720 "pending_stops" for details on why this is needed. */
1721 DEBUG_EVENTS (("get_windows_debug_event - "
1722 "unexpected stop in 0x%x (expecting 0x%x)\n",
1723 thread_id
, desired_stop_thread_id
));
1725 if (current_event
.dwDebugEventCode
== EXCEPTION_DEBUG_EVENT
1726 && ((current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1727 == EXCEPTION_BREAKPOINT
)
1728 || (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1729 == STATUS_WX86_BREAKPOINT
))
1730 && windows_initialization_done
)
1732 ptid_t ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1733 th
= thread_rec (ptid
, INVALIDATE_CONTEXT
);
1734 th
->stopped_at_software_breakpoint
= true;
1736 pending_stops
.push_back ({thread_id
, *ourstatus
, current_event
});
1738 CHECK (windows_continue (continue_status
, desired_stop_thread_id
, 0));
1742 inferior_ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1743 current_windows_thread
= th
;
1744 if (!current_windows_thread
)
1745 current_windows_thread
= thread_rec (inferior_ptid
,
1746 INVALIDATE_CONTEXT
);
1753 /* Wait for interesting events to occur in the target process. */
1755 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1760 /* We loop when we get a non-standard exception rather than return
1761 with a SPURIOUS because resume can try and step or modify things,
1762 which needs a current_thread->h. But some of these exceptions mark
1763 the birth or death of threads, which mean that the current thread
1764 isn't necessarily what you think it is. */
1770 /* If the user presses Ctrl-c while the debugger is waiting
1771 for an event, he expects the debugger to interrupt his program
1772 and to get the prompt back. There are two possible situations:
1774 - The debugger and the program do not share the console, in
1775 which case the Ctrl-c event only reached the debugger.
1776 In that case, the ctrl_c handler will take care of interrupting
1777 the inferior. Note that this case is working starting with
1778 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1781 - The debugger and the program share the same console, in which
1782 case both debugger and inferior will receive the Ctrl-c event.
1783 In that case the ctrl_c handler will ignore the event, as the
1784 Ctrl-c event generated inside the inferior will trigger the
1785 expected debug event.
1787 FIXME: brobecker/2008-05-20: If the inferior receives the
1788 signal first and the delay until GDB receives that signal
1789 is sufficiently long, GDB can sometimes receive the SIGINT
1790 after we have unblocked the CTRL+C handler. This would
1791 lead to the debugger stopping prematurely while handling
1792 the new-thread event that comes with the handling of the SIGINT
1793 inside the inferior, and then stop again immediately when
1794 the user tries to resume the execution in the inferior.
1795 This is a classic race that we should try to fix one day. */
1796 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1797 retval
= get_windows_debug_event (pid
, ourstatus
);
1798 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1802 ptid_t result
= ptid_t (current_event
.dwProcessId
, retval
, 0);
1804 if (current_windows_thread
!= nullptr)
1806 current_windows_thread
->stopped_at_software_breakpoint
= false;
1807 if (current_event
.dwDebugEventCode
== EXCEPTION_DEBUG_EVENT
1808 && ((current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1809 == EXCEPTION_BREAKPOINT
)
1810 || (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1811 == STATUS_WX86_BREAKPOINT
))
1812 && windows_initialization_done
)
1813 current_windows_thread
->stopped_at_software_breakpoint
= true;
1822 if (deprecated_ui_loop_hook
!= NULL
)
1823 detach
= deprecated_ui_loop_hook (0);
1831 /* Iterate over all DLLs currently mapped by our inferior, and
1832 add them to our list of solibs. */
1835 windows_add_all_dlls (void)
1837 HMODULE dummy_hmodule
;
1845 if (EnumProcessModulesEx (current_process_handle
, &dummy_hmodule
,
1846 sizeof (HMODULE
), &cb_needed
,
1847 LIST_MODULES_32BIT
) == 0)
1853 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
1854 sizeof (HMODULE
), &cb_needed
) == 0)
1861 hmodules
= (HMODULE
*) alloca (cb_needed
);
1865 if (EnumProcessModulesEx (current_process_handle
, hmodules
,
1866 cb_needed
, &cb_needed
,
1867 LIST_MODULES_32BIT
) == 0)
1873 if (EnumProcessModules (current_process_handle
, hmodules
,
1874 cb_needed
, &cb_needed
) == 0)
1878 char system_dir
[__PMAX
];
1879 char syswow_dir
[__PMAX
];
1880 size_t system_dir_len
= 0;
1881 bool convert_syswow_dir
= false;
1886 /* This fails on 32bit Windows because it has no SysWOW64 directory,
1887 and in this case a path conversion isn't necessary. */
1888 UINT len
= GetSystemWow64DirectoryA (syswow_dir
, sizeof (syswow_dir
));
1891 /* Check that we have passed a large enough buffer. */
1892 gdb_assert (len
< sizeof (syswow_dir
));
1894 len
= GetSystemDirectoryA (system_dir
, sizeof (system_dir
));
1896 gdb_assert (len
!= 0);
1897 /* Check that we have passed a large enough buffer. */
1898 gdb_assert (len
< sizeof (system_dir
));
1900 strcat (system_dir
, "\\");
1901 strcat (syswow_dir
, "\\");
1902 system_dir_len
= strlen (system_dir
);
1904 convert_syswow_dir
= true;
1908 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
1912 wchar_t dll_name
[__PMAX
];
1913 char dll_name_mb
[__PMAX
];
1915 char dll_name
[__PMAX
];
1918 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
1919 &mi
, sizeof (mi
)) == 0)
1921 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
1922 dll_name
, sizeof (dll_name
)) == 0)
1925 wcstombs (dll_name_mb
, dll_name
, __PMAX
);
1930 /* Convert the DLL path of 32bit processes returned by
1931 GetModuleFileNameEx from the 64bit system directory to the
1932 32bit syswow64 directory if necessary. */
1933 std::string syswow_dll_path
;
1934 if (convert_syswow_dir
1935 && strncasecmp (name
, system_dir
, system_dir_len
) == 0
1936 && strchr (name
+ system_dir_len
, '\\') == nullptr)
1938 syswow_dll_path
= syswow_dir
;
1939 syswow_dll_path
+= name
+ system_dir_len
;
1940 name
= syswow_dll_path
.c_str();
1943 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
1944 solib_end
= solib_end
->next
;
1949 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1952 struct inferior
*inf
;
1954 last_sig
= GDB_SIGNAL_0
;
1955 open_process_used
= 0;
1956 debug_registers_changed
= 0;
1957 debug_registers_used
= 0;
1958 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1961 cygwin_load_start
= cygwin_load_end
= 0;
1963 current_event
.dwProcessId
= pid
;
1964 memset (¤t_event
, 0, sizeof (current_event
));
1965 if (!target_is_pushed (ops
))
1967 disable_breakpoints_in_shlibs ();
1968 windows_clear_solib ();
1969 clear_proceed_status (0);
1970 init_wait_for_inferior ();
1973 ignore_first_breakpoint
= !attaching
&& wow64_process
;
1977 windows_set_context_register_offsets (amd64_mappings
);
1978 windows_set_segment_register_p (amd64_windows_segment_register_p
);
1983 windows_set_context_register_offsets (i386_mappings
);
1984 windows_set_segment_register_p (i386_windows_segment_register_p
);
1987 inf
= current_inferior ();
1988 inferior_appeared (inf
, pid
);
1989 inf
->attach_flag
= attaching
;
1991 /* Make the new process the current inferior, so terminal handling
1992 can rely on it. When attaching, we don't know about any thread
1993 id here, but that's OK --- nothing should be referencing the
1994 current thread until we report an event out of windows_wait. */
1995 inferior_ptid
= ptid_t (pid
);
1997 target_terminal::init ();
1998 target_terminal::inferior ();
2000 windows_initialization_done
= 0;
2004 struct target_waitstatus status
;
2006 ops
->wait (minus_one_ptid
, &status
, 0);
2008 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
2010 if (status
.kind
!= TARGET_WAITKIND_LOADED
2011 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
2014 ops
->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
2017 /* Now that the inferior has been started and all DLLs have been mapped,
2018 we can iterate over all DLLs and load them in.
2020 We avoid doing it any earlier because, on certain versions of Windows,
2021 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
2022 we have seen on Windows 8.1 that the ntdll.dll load event does not
2023 include the DLL name, preventing us from creating an associated SO.
2024 A possible explanation is that ntdll.dll might be mapped before
2025 the SO info gets created by the Windows system -- ntdll.dll is
2026 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
2027 do not seem to suffer from that problem.
2029 Rather than try to work around this sort of issue, it is much
2030 simpler to just ignore DLL load/unload events during the startup
2031 phase, and then process them all in one batch now. */
2032 windows_add_all_dlls ();
2034 windows_initialization_done
= 1;
2038 /* Try to set or remove a user privilege to the current process. Return -1
2039 if that fails, the previous setting of that privilege otherwise.
2041 This code is copied from the Cygwin source code and rearranged to allow
2042 dynamically loading of the needed symbols from advapi32 which is only
2043 available on NT/2K/XP. */
2045 set_process_privilege (const char *privilege
, BOOL enable
)
2047 HANDLE token_hdl
= NULL
;
2049 TOKEN_PRIVILEGES new_priv
, orig_priv
;
2053 if (!OpenProcessToken (GetCurrentProcess (),
2054 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
2058 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
2061 new_priv
.PrivilegeCount
= 1;
2062 new_priv
.Privileges
[0].Luid
= restore_priv
;
2063 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
2065 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
2066 sizeof orig_priv
, &orig_priv
, &size
))
2069 /* Disabled, otherwise every `attach' in an unprivileged user session
2070 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
2071 windows_attach(). */
2072 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
2073 be enabled. GetLastError () returns an correct error code, though. */
2074 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
2078 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
2082 CloseHandle (token_hdl
);
2087 /* Attach to process PID, then initialize for debugging it. */
2090 windows_nat_target::attach (const char *args
, int from_tty
)
2095 pid
= parse_pid_to_attach (args
);
2097 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
2099 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
2100 printf_unfiltered ("This can cause attach to "
2101 "fail on Windows NT/2K/XP\n");
2104 windows_init_thread_list ();
2105 ok
= DebugActiveProcess (pid
);
2111 /* Try fall back to Cygwin pid. */
2112 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
2115 ok
= DebugActiveProcess (pid
);
2120 error (_("Can't attach to process %u (error %u)"),
2121 (unsigned) pid
, (unsigned) GetLastError ());
2123 DebugSetProcessKillOnExit (FALSE
);
2127 const char *exec_file
= get_exec_file (0);
2130 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
2131 target_pid_to_str (ptid_t (pid
)).c_str ());
2133 printf_unfiltered ("Attaching to %s\n",
2134 target_pid_to_str (ptid_t (pid
)).c_str ());
2138 HANDLE h
= OpenProcess (PROCESS_QUERY_INFORMATION
, FALSE
, pid
);
2142 if (IsWow64Process (h
, &wow64
))
2143 wow64_process
= wow64
;
2148 do_initial_windows_stuff (this, pid
, 1);
2149 target_terminal::ours ();
2153 windows_nat_target::detach (inferior
*inf
, int from_tty
)
2157 ptid_t ptid
= minus_one_ptid
;
2158 resume (ptid
, 0, GDB_SIGNAL_0
);
2160 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
2162 error (_("Can't detach process %u (error %u)"),
2163 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
2166 DebugSetProcessKillOnExit (FALSE
);
2168 if (detached
&& from_tty
)
2170 const char *exec_file
= get_exec_file (0);
2173 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
2174 (unsigned) current_event
.dwProcessId
);
2177 x86_cleanup_dregs ();
2178 inferior_ptid
= null_ptid
;
2179 detach_inferior (inf
);
2181 maybe_unpush_target ();
2184 /* Try to determine the executable filename.
2186 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2188 Upon success, the filename is stored inside EXE_NAME_RET, and
2189 this function returns nonzero.
2191 Otherwise, this function returns zero and the contents of
2192 EXE_NAME_RET is undefined. */
2195 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2205 if (!EnumProcessModulesEx (current_process_handle
, &dh_buf
,
2206 sizeof (HMODULE
), &cbNeeded
,
2207 LIST_MODULES_32BIT
) || !cbNeeded
)
2213 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2214 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2218 /* We know the executable is always first in the list of modules,
2219 which we just fetched. So no need to fetch more. */
2223 /* Cygwin prefers that the path be in /x/y/z format, so extract
2224 the filename into a temporary buffer first, and then convert it
2225 to POSIX format into the destination buffer. */
2226 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2228 len
= GetModuleFileNameEx (current_process_handle
,
2229 dh_buf
, pathbuf
, exe_name_max_len
);
2231 error (_("Error getting executable filename: %u."),
2232 (unsigned) GetLastError ());
2233 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2234 exe_name_max_len
) < 0)
2235 error (_("Error converting executable filename to POSIX: %d."), errno
);
2238 len
= GetModuleFileNameEx (current_process_handle
,
2239 dh_buf
, exe_name_ret
, exe_name_max_len
);
2241 error (_("Error getting executable filename: %u."),
2242 (unsigned) GetLastError ());
2245 return 1; /* success */
2248 /* The pid_to_exec_file target_ops method for this platform. */
2251 windows_nat_target::pid_to_exec_file (int pid
)
2253 static char path
[__PMAX
];
2255 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2257 char procexe
[sizeof ("/proc/4294967295/exe")];
2259 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2260 nchars
= readlink (procexe
, path
, sizeof(path
));
2261 if (nchars
> 0 && nchars
< sizeof (path
))
2263 path
[nchars
] = '\0'; /* Got it */
2268 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2269 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2270 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2276 /* Print status information about what we're accessing. */
2279 windows_nat_target::files_info ()
2281 struct inferior
*inf
= current_inferior ();
2283 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2284 inf
->attach_flag
? "attached" : "child",
2285 target_pid_to_str (inferior_ptid
).c_str ());
2288 /* Modify CreateProcess parameters for use of a new separate console.
2290 *FLAGS: DWORD parameter for general process creation flags.
2291 *SI: STARTUPINFO structure, for which the console window size and
2292 console buffer size is filled in if GDB is running in a console.
2293 to create the new console.
2294 The size of the used font is not available on all versions of
2295 Windows OS. Furthermore, the current font might not be the default
2296 font, but this is still better than before.
2297 If the windows and buffer sizes are computed,
2298 SI->DWFLAGS is changed so that this information is used
2299 by CreateProcess function. */
2302 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2304 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2305 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2307 if (hconsole
!= INVALID_HANDLE_VALUE
)
2309 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2311 CONSOLE_FONT_INFO cfi
;
2313 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2314 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2315 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2316 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2317 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2319 si
->dwXSize
*= font_size
.X
;
2323 si
->dwYSize
*= font_size
.Y
;
2326 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2327 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2328 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2330 *flags
|= CREATE_NEW_CONSOLE
;
2334 /* Function called by qsort to sort environment strings. */
2337 envvar_cmp (const void *a
, const void *b
)
2339 const char **p
= (const char **) a
;
2340 const char **q
= (const char **) b
;
2341 return strcasecmp (*p
, *q
);
2347 clear_win32_environment (char **env
)
2351 wchar_t *copy
= NULL
, *equalpos
;
2353 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2355 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2356 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2357 mbstowcs (copy
, env
[i
], len
);
2358 equalpos
= wcschr (copy
, L
'=');
2361 SetEnvironmentVariableW (copy
, NULL
);
2369 /* Redirection of inferior I/O streams for native MS-Windows programs.
2370 Unlike on Unix, where this is handled by invoking the inferior via
2371 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2373 The official documentation of the cmd.exe redirection features is here:
2375 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2377 (That page talks about Windows XP, but there's no newer
2378 documentation, so we assume later versions of cmd.exe didn't change
2381 Caveat: the documentation on that page seems to include a few lies.
2382 For example, it describes strange constructs 1<&2 and 2<&1, which
2383 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2384 think the cmd.exe parser of the redirection symbols simply doesn't
2385 care about the < vs > distinction in these cases. Therefore, the
2386 supported features are explicitly documented below.
2388 The emulation below aims at supporting all the valid use cases
2389 supported by cmd.exe, which include:
2391 < FILE redirect standard input from FILE
2392 0< FILE redirect standard input from FILE
2393 <&N redirect standard input from file descriptor N
2394 0<&N redirect standard input from file descriptor N
2395 > FILE redirect standard output to FILE
2396 >> FILE append standard output to FILE
2397 1>> FILE append standard output to FILE
2398 >&N redirect standard output to file descriptor N
2399 1>&N redirect standard output to file descriptor N
2400 >>&N append standard output to file descriptor N
2401 1>>&N append standard output to file descriptor N
2402 2> FILE redirect standard error to FILE
2403 2>> FILE append standard error to FILE
2404 2>&N redirect standard error to file descriptor N
2405 2>>&N append standard error to file descriptor N
2407 Note that using N > 2 in the above construct is supported, but
2408 requires that the corresponding file descriptor be open by some
2409 means elsewhere or outside GDB. Also note that using ">&0" or
2410 "<&2" will generally fail, because the file descriptor redirected
2411 from is normally open in an incompatible mode (e.g., FD 0 is open
2412 for reading only). IOW, use of such tricks is not recommended;
2413 you are on your own.
2415 We do NOT support redirection of file descriptors above 2, as in
2416 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2417 that needs special handling in the startup code that MinGW
2418 doesn't have). Pipes are also not supported.
2420 As for invalid use cases, where the redirection contains some
2421 error, the emulation below will detect that and produce some
2422 error and/or failure. But the behavior in those cases is not
2423 bug-for-bug compatible with what cmd.exe does in those cases.
2424 That's because what cmd.exe does then is not well defined, and
2425 seems to be a side effect of the cmd.exe parsing of the command
2426 line more than anything else. For example, try redirecting to an
2427 invalid file name, as in "> foo:bar".
2429 There are also minor syntactic deviations from what cmd.exe does
2430 in some corner cases. For example, it doesn't support the likes
2431 of "> &foo" to mean redirect to file named literally "&foo"; we
2432 do support that here, because that, too, sounds like some issue
2433 with the cmd.exe parser. Another nicety is that we support
2434 redirection targets that use file names with forward slashes,
2435 something cmd.exe doesn't -- this comes in handy since GDB
2436 file-name completion can be used when typing the command line for
2439 /* Support routines for redirecting standard handles of the inferior. */
2441 /* Parse a single redirection spec, open/duplicate the specified
2442 file/fd, and assign the appropriate value to one of the 3 standard
2443 file descriptors. */
2445 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2447 int *fd
, ref_fd
= -2;
2449 const char *fname
= redir_string
+ 1;
2450 int rc
= *redir_string
;
2465 fd
= (rc
== '2') ? err
: out
;
2466 mode
= O_WRONLY
| O_CREAT
;
2479 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2481 /* A reference to a file descriptor. */
2483 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2484 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2486 /* Don't allow redirection when open modes are incompatible. */
2487 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2488 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2495 else if (ref_fd
== 1)
2497 else if (ref_fd
== 2)
2507 fname
++; /* skip the separator space */
2508 /* If the descriptor is already open, close it. This allows
2509 multiple specs of redirections for the same stream, which is
2510 somewhat nonsensical, but still valid and supported by cmd.exe.
2511 (But cmd.exe only opens a single file in this case, the one
2512 specified by the last redirection spec on the command line.) */
2517 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2521 else if (ref_fd
== -1)
2522 *fd
= -1; /* reset to default destination */
2525 *fd
= _dup (ref_fd
);
2529 /* _open just sets a flag for O_APPEND, which won't be passed to the
2530 inferior, so we need to actually move the file pointer. */
2531 if ((mode
& O_APPEND
) != 0)
2532 _lseek (*fd
, 0L, SEEK_END
);
2536 /* Canonicalize a single redirection spec and set up the corresponding
2537 file descriptor as specified. */
2539 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2541 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2543 const char *start
= s
;
2546 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2547 if ((*start
== '>' || *start
== '1' || *start
== '2')
2551 if (*s
== '>' && *start
!= '>')
2554 else if (*start
== '0' && *s
== '<')
2556 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2559 while (isspace (*s
)) /* skip whitespace before file name */
2561 *d
++ = ' '; /* separate file name with a single space */
2564 /* Copy the file name. */
2567 /* Remove quoting characters from the file name in buf[]. */
2568 if (*s
== '"') /* could support '..' quoting here */
2572 else if (*s
== quote
)
2580 else if (*s
== '\\')
2582 if (s
[1] == '"') /* could support '..' here */
2586 else if (isspace (*s
) && !quote
)
2590 if (d
- buf
>= sizeof (buf
) - 1)
2592 errno
= ENAMETOOLONG
;
2598 /* Windows doesn't allow redirection characters in file names, so we
2599 can bail out early if they use them, or if there's no target file
2600 name after the redirection symbol. */
2601 if (d
[-1] == '>' || d
[-1] == '<')
2606 if (redir_open (buf
, inp
, out
, err
) == 0)
2611 /* Parse the command line for redirection specs and prepare the file
2612 descriptors for the 3 standard streams accordingly. */
2614 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2615 int *inp
, int *out
, int *err
)
2617 const char *s
= cmd_orig
;
2620 bool retval
= false;
2622 while (isspace (*s
))
2627 if (*s
== '"') /* could also support '..' quoting here */
2631 else if (*s
== quote
)
2634 else if (*s
== '\\')
2636 if (s
[1] == '"') /* escaped quote char */
2641 /* Process a single redirection candidate. */
2642 if (*s
== '<' || *s
== '>'
2643 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2644 || (*s
== '0' && s
[1] == '<'))
2646 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2660 #endif /* !__CYGWIN__ */
2662 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2663 EXEC_FILE is the file to run.
2664 ALLARGS is a string containing the arguments to the program.
2665 ENV is the environment vector to pass. Errors reported with error(). */
2668 windows_nat_target::create_inferior (const char *exec_file
,
2669 const std::string
&origallargs
,
2670 char **in_env
, int from_tty
)
2674 cygwin_buf_t real_path
[__PMAX
];
2675 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2676 cygwin_buf_t infcwd
[__PMAX
];
2678 cygwin_buf_t
*toexec
;
2679 cygwin_buf_t
*cygallargs
;
2681 char **old_env
= NULL
;
2685 int ostdin
, ostdout
, ostderr
;
2686 #else /* !__CYGWIN__ */
2687 char shell
[__PMAX
]; /* Path to shell */
2689 char *args
, *allargs_copy
;
2690 size_t args_len
, allargs_len
;
2691 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2692 HANDLE tty
= INVALID_HANDLE_VALUE
;
2693 bool redirected
= false;
2700 #endif /* !__CYGWIN__ */
2701 const char *allargs
= origallargs
.c_str ();
2702 PROCESS_INFORMATION pi
;
2705 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2708 error (_("No executable specified, use `target exec'."));
2710 const char *inferior_cwd
= get_inferior_cwd ();
2711 std::string expanded_infcwd
;
2712 if (inferior_cwd
!= NULL
)
2714 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
2715 /* Mirror slashes on inferior's cwd. */
2716 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
2718 inferior_cwd
= expanded_infcwd
.c_str ();
2721 memset (&si
, 0, sizeof (si
));
2722 si
.cb
= sizeof (si
);
2725 flags
|= CREATE_NEW_PROCESS_GROUP
;
2728 windows_set_console_info (&si
, &flags
);
2733 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2734 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2735 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2736 error (_("Error starting executable: %d"), errno
);
2739 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2740 if (len
== (size_t) -1)
2741 error (_("Error starting executable: %d"), errno
);
2742 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2743 mbstowcs (cygallargs
, allargs
, len
);
2744 #else /* !__USEWIDE */
2745 cygallargs
= allargs
;
2751 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2752 error (_("Error starting executable via shell: %d"), errno
);
2754 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2755 + mbstowcs (NULL
, allargs
, 0) + 2;
2756 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2757 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2758 #else /* !__USEWIDE */
2759 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2760 + strlen (allargs
) + 2);
2761 cygallargs
= (char *) alloca (len
);
2762 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2763 #endif /* __USEWIDE */
2765 flags
|= DEBUG_PROCESS
;
2768 if (inferior_cwd
!= NULL
2769 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
2770 infcwd
, strlen (inferior_cwd
)) < 0)
2771 error (_("Error converting inferior cwd: %d"), errno
);
2774 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2775 * sizeof (wchar_t));
2776 wcscpy (args
, toexec
);
2777 wcscat (args
, L
" ");
2778 wcscat (args
, cygallargs
);
2779 #else /* !__USEWIDE */
2780 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2781 strcpy (args
, toexec
);
2783 strcat (args
, cygallargs
);
2784 #endif /* !__USEWIDE */
2786 #ifdef CW_CVT_ENV_TO_WINENV
2787 /* First try to create a direct Win32 copy of the POSIX environment. */
2788 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2789 if (w32_env
!= (PWCHAR
) -1)
2790 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2792 /* If that fails, fall back to old method tweaking GDB's environment. */
2793 #endif /* CW_CVT_ENV_TO_WINENV */
2795 /* Reset all Win32 environment variables to avoid leftover on next run. */
2796 clear_win32_environment (environ
);
2797 /* Prepare the environment vars for CreateProcess. */
2800 cygwin_internal (CW_SYNC_WINENV
);
2804 if (!inferior_io_terminal
)
2805 tty
= ostdin
= ostdout
= ostderr
= -1;
2808 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2811 print_sys_errmsg (inferior_io_terminal
, errno
);
2812 ostdin
= ostdout
= ostderr
= -1;
2825 windows_init_thread_list ();
2826 ret
= CreateProcess (0,
2827 args
, /* command line */
2828 NULL
, /* Security */
2830 TRUE
, /* inherit handles */
2831 flags
, /* start flags */
2832 w32_env
, /* environment */
2833 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
2838 /* Just free the Win32 environment, if it could be created. */
2842 /* Reset all environment variables to avoid leftover on next run. */
2843 clear_win32_environment (in_env
);
2844 /* Restore normal GDB environment variables. */
2846 cygwin_internal (CW_SYNC_WINENV
);
2859 #else /* !__CYGWIN__ */
2860 allargs_len
= strlen (allargs
);
2861 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
2862 if (strpbrk (allargs_copy
, "<>") != NULL
)
2867 redirect_inferior_handles (allargs
, allargs_copy
,
2868 &fd_inp
, &fd_out
, &fd_err
);
2870 warning (_("Error in redirection: %s."), safe_strerror (errno
));
2873 allargs_len
= strlen (allargs_copy
);
2875 /* If not all the standard streams are redirected by the command
2876 line, use inferior_io_terminal for those which aren't. */
2877 if (inferior_io_terminal
2878 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
2880 SECURITY_ATTRIBUTES sa
;
2881 sa
.nLength
= sizeof(sa
);
2882 sa
.lpSecurityDescriptor
= 0;
2883 sa
.bInheritHandle
= TRUE
;
2884 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2885 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2886 if (tty
== INVALID_HANDLE_VALUE
)
2887 warning (_("Warning: Failed to open TTY %s, error %#x."),
2888 inferior_io_terminal
, (unsigned) GetLastError ());
2890 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
2893 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
2894 else if (tty
!= INVALID_HANDLE_VALUE
)
2897 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
2899 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
2900 else if (tty
!= INVALID_HANDLE_VALUE
)
2901 si
.hStdOutput
= tty
;
2903 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
2905 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
2906 else if (tty
!= INVALID_HANDLE_VALUE
)
2909 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
2910 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2914 /* Build the command line, a space-separated list of tokens where
2915 the first token is the name of the module to be executed.
2916 To avoid ambiguities introduced by spaces in the module name,
2918 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
2919 args
= (char *) alloca (args_len
);
2920 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
2922 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2924 /* CreateProcess takes the environment list as a null terminated set of
2925 strings (i.e. two nulls terminate the list). */
2927 /* Get total size for env strings. */
2928 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2929 envlen
+= strlen (in_env
[i
]) + 1;
2931 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2932 env
= (char **) alloca (envsize
);
2933 memcpy (env
, in_env
, envsize
);
2934 /* Windows programs expect the environment block to be sorted. */
2935 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2937 w32env
= (char *) alloca (envlen
+ 1);
2939 /* Copy env strings into new buffer. */
2940 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2942 strcpy (temp
, env
[i
]);
2943 temp
+= strlen (temp
) + 1;
2946 /* Final nil string to terminate new env. */
2949 windows_init_thread_list ();
2950 ret
= CreateProcessA (0,
2951 args
, /* command line */
2952 NULL
, /* Security */
2954 TRUE
, /* inherit handles */
2955 flags
, /* start flags */
2956 w32env
, /* environment */
2957 inferior_cwd
, /* current directory */
2960 if (tty
!= INVALID_HANDLE_VALUE
)
2968 #endif /* !__CYGWIN__ */
2971 error (_("Error creating process %s, (error %u)."),
2972 exec_file
, (unsigned) GetLastError ());
2976 if (IsWow64Process (pi
.hProcess
, &wow64
))
2977 wow64_process
= wow64
;
2980 CloseHandle (pi
.hThread
);
2981 CloseHandle (pi
.hProcess
);
2983 if (useshell
&& shell
[0] != '\0')
2988 do_initial_windows_stuff (this, pi
.dwProcessId
, 0);
2990 /* windows_continue (DBG_CONTINUE, -1, 0); */
2994 windows_nat_target::mourn_inferior ()
2996 (void) windows_continue (DBG_CONTINUE
, -1, 0);
2997 x86_cleanup_dregs();
2998 if (open_process_used
)
3000 CHECK (CloseHandle (current_process_handle
));
3001 open_process_used
= 0;
3003 siginfo_er
.ExceptionCode
= 0;
3004 inf_child_target::mourn_inferior ();
3007 /* Send a SIGINT to the process group. This acts just like the user typed a
3008 ^C on the controlling terminal. */
3011 windows_nat_target::interrupt ()
3013 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
3014 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
3015 registers_changed (); /* refresh register state */
3018 /* Helper for windows_xfer_partial that handles memory transfers.
3019 Arguments are like target_xfer_partial. */
3021 static enum target_xfer_status
3022 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3023 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
3027 DWORD lasterror
= 0;
3029 if (writebuf
!= NULL
)
3031 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
3032 pulongest (len
), core_addr_to_string (memaddr
)));
3033 success
= WriteProcessMemory (current_process_handle
,
3034 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
3037 lasterror
= GetLastError ();
3038 FlushInstructionCache (current_process_handle
,
3039 (LPCVOID
) (uintptr_t) memaddr
, len
);
3043 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
3044 pulongest (len
), core_addr_to_string (memaddr
)));
3045 success
= ReadProcessMemory (current_process_handle
,
3046 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
3049 lasterror
= GetLastError ();
3051 *xfered_len
= (ULONGEST
) done
;
3052 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
3053 return TARGET_XFER_OK
;
3055 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
3059 windows_nat_target::kill ()
3061 CHECK (TerminateProcess (current_process_handle
, 0));
3065 if (!windows_continue (DBG_CONTINUE
, -1, 1))
3067 if (!wait_for_debug_event (¤t_event
, INFINITE
))
3069 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
3073 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
3077 windows_nat_target::close ()
3079 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
3080 inferior_ptid
.pid ()));
3083 /* Convert pid to printable format. */
3085 windows_nat_target::pid_to_str (ptid_t ptid
)
3087 if (ptid
.lwp () != 0)
3088 return string_printf ("Thread %d.0x%lx", ptid
.pid (), ptid
.lwp ());
3090 return normal_pid_to_str (ptid
);
3093 static enum target_xfer_status
3094 windows_xfer_shared_libraries (struct target_ops
*ops
,
3095 enum target_object object
, const char *annex
,
3096 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3097 ULONGEST offset
, ULONGEST len
,
3098 ULONGEST
*xfered_len
)
3100 struct obstack obstack
;
3106 return TARGET_XFER_E_IO
;
3108 obstack_init (&obstack
);
3109 obstack_grow_str (&obstack
, "<library-list>\n");
3110 for (so
= solib_start
.next
; so
; so
= so
->next
)
3112 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
3114 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
3115 (uintptr_t) li
->load_addr
,
3117 target_gdbarch (), &obstack
);
3119 obstack_grow_str0 (&obstack
, "</library-list>\n");
3121 buf
= (const char *) obstack_finish (&obstack
);
3122 len_avail
= strlen (buf
);
3123 if (offset
>= len_avail
)
3127 if (len
> len_avail
- offset
)
3128 len
= len_avail
- offset
;
3129 memcpy (readbuf
, buf
+ offset
, len
);
3132 obstack_free (&obstack
, NULL
);
3133 *xfered_len
= (ULONGEST
) len
;
3134 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
3137 /* Helper for windows_nat_target::xfer_partial that handles signal info. */
3139 static enum target_xfer_status
3140 windows_xfer_siginfo (gdb_byte
*readbuf
, ULONGEST offset
, ULONGEST len
,
3141 ULONGEST
*xfered_len
)
3143 char *buf
= (char *) &siginfo_er
;
3144 size_t bufsize
= sizeof (siginfo_er
);
3147 EXCEPTION_RECORD32 er32
;
3150 buf
= (char *) &er32
;
3151 bufsize
= sizeof (er32
);
3153 er32
.ExceptionCode
= siginfo_er
.ExceptionCode
;
3154 er32
.ExceptionFlags
= siginfo_er
.ExceptionFlags
;
3155 er32
.ExceptionRecord
= (uintptr_t) siginfo_er
.ExceptionRecord
;
3156 er32
.ExceptionAddress
= (uintptr_t) siginfo_er
.ExceptionAddress
;
3157 er32
.NumberParameters
= siginfo_er
.NumberParameters
;
3159 for (i
= 0; i
< EXCEPTION_MAXIMUM_PARAMETERS
; i
++)
3160 er32
.ExceptionInformation
[i
] = siginfo_er
.ExceptionInformation
[i
];
3164 if (siginfo_er
.ExceptionCode
== 0)
3165 return TARGET_XFER_E_IO
;
3167 if (readbuf
== nullptr)
3168 return TARGET_XFER_E_IO
;
3170 if (offset
> bufsize
)
3171 return TARGET_XFER_E_IO
;
3173 if (offset
+ len
> bufsize
)
3174 len
= bufsize
- offset
;
3176 memcpy (readbuf
, buf
+ offset
, len
);
3179 return TARGET_XFER_OK
;
3182 enum target_xfer_status
3183 windows_nat_target::xfer_partial (enum target_object object
,
3184 const char *annex
, gdb_byte
*readbuf
,
3185 const gdb_byte
*writebuf
, ULONGEST offset
,
3186 ULONGEST len
, ULONGEST
*xfered_len
)
3190 case TARGET_OBJECT_MEMORY
:
3191 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
3193 case TARGET_OBJECT_LIBRARIES
:
3194 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
3195 writebuf
, offset
, len
, xfered_len
);
3197 case TARGET_OBJECT_SIGNAL_INFO
:
3198 return windows_xfer_siginfo (readbuf
, offset
, len
, xfered_len
);
3201 if (beneath () == NULL
)
3203 /* This can happen when requesting the transfer of unsupported
3204 objects before a program has been started (and therefore
3205 with the current_target having no target beneath). */
3206 return TARGET_XFER_E_IO
;
3208 return beneath ()->xfer_partial (object
, annex
,
3209 readbuf
, writebuf
, offset
, len
,
3214 /* Provide thread local base, i.e. Thread Information Block address.
3215 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
3218 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
3220 windows_thread_info
*th
;
3222 th
= thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
);
3227 *addr
= th
->thread_local_base
;
3233 windows_nat_target::get_ada_task_ptid (long lwp
, long thread
)
3235 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
3238 /* Implementation of the to_thread_name method. */
3241 windows_nat_target::thread_name (struct thread_info
*thr
)
3243 return thread_rec (thr
->ptid
, DONT_INVALIDATE_CONTEXT
)->name
.get ();
3247 void _initialize_windows_nat ();
3249 _initialize_windows_nat ()
3251 x86_dr_low
.set_control
= cygwin_set_dr7
;
3252 x86_dr_low
.set_addr
= cygwin_set_dr
;
3253 x86_dr_low
.get_addr
= cygwin_get_dr
;
3254 x86_dr_low
.get_status
= cygwin_get_dr6
;
3255 x86_dr_low
.get_control
= cygwin_get_dr7
;
3257 /* x86_dr_low.debug_register_length field is set by
3258 calling x86_set_debug_register_length function
3259 in processor windows specific native file. */
3261 add_inf_child_target (&the_windows_nat_target
);
3264 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3267 add_com ("signal-event", class_run
, signal_event_command
, _("\
3268 Signal a crashed process with event ID, to allow its debugging.\n\
3269 This command is needed in support of setting up GDB as JIT debugger on \
3270 MS-Windows. The command should be invoked from the GDB command line using \
3271 the '-ex' command-line option. The ID of the event that blocks the \
3272 crashed process will be supplied by the Windows JIT debugging mechanism."));
3275 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3276 Set use of shell to start subprocess."), _("\
3277 Show use of shell to start subprocess."), NULL
,
3279 NULL
, /* FIXME: i18n: */
3280 &setlist
, &showlist
);
3282 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3283 &cygwin_exceptions
, _("\
3284 Break when an exception is detected in the Cygwin DLL itself."), _("\
3285 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3287 NULL
, /* FIXME: i18n: */
3288 &setlist
, &showlist
);
3291 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3292 Set creation of new console when creating child process."), _("\
3293 Show creation of new console when creating child process."), NULL
,
3295 NULL
, /* FIXME: i18n: */
3296 &setlist
, &showlist
);
3298 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3299 Set creation of new group when creating child process."), _("\
3300 Show creation of new group when creating child process."), NULL
,
3302 NULL
, /* FIXME: i18n: */
3303 &setlist
, &showlist
);
3305 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3306 Set whether to display execution in child process."), _("\
3307 Show whether to display execution in child process."), NULL
,
3309 NULL
, /* FIXME: i18n: */
3310 &setlist
, &showlist
);
3312 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3313 Set whether to display kernel events in child process."), _("\
3314 Show whether to display kernel events in child process."), NULL
,
3316 NULL
, /* FIXME: i18n: */
3317 &setlist
, &showlist
);
3319 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3320 Set whether to display memory accesses in child process."), _("\
3321 Show whether to display memory accesses in child process."), NULL
,
3323 NULL
, /* FIXME: i18n: */
3324 &setlist
, &showlist
);
3326 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3327 &debug_exceptions
, _("\
3328 Set whether to display kernel exceptions in child process."), _("\
3329 Show whether to display kernel exceptions in child process."), NULL
,
3331 NULL
, /* FIXME: i18n: */
3332 &setlist
, &showlist
);
3334 init_w32_command_list ();
3336 add_cmd ("selector", class_info
, display_selectors
,
3337 _("Display selectors infos."),
3341 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3343 /* Pass the address ADDR to the inferior in the I'th debug register.
3344 Here we just store the address in dr array, the registers will be
3345 actually set up when windows_continue is called. */
3347 cygwin_set_dr (int i
, CORE_ADDR addr
)
3350 internal_error (__FILE__
, __LINE__
,
3351 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3353 debug_registers_changed
= 1;
3354 debug_registers_used
= 1;
3357 /* Pass the value VAL to the inferior in the DR7 debug control
3358 register. Here we just store the address in D_REGS, the watchpoint
3359 will be actually set up in windows_wait. */
3361 cygwin_set_dr7 (unsigned long val
)
3363 dr
[7] = (CORE_ADDR
) val
;
3364 debug_registers_changed
= 1;
3365 debug_registers_used
= 1;
3368 /* Get the value of debug register I from the inferior. */
3371 cygwin_get_dr (int i
)
3376 /* Get the value of the DR6 debug status register from the inferior.
3377 Here we just return the value stored in dr[6]
3378 by the last call to thread_rec for current_event.dwThreadId id. */
3379 static unsigned long
3380 cygwin_get_dr6 (void)
3382 return (unsigned long) dr
[6];
3385 /* Get the value of the DR7 debug status register from the inferior.
3386 Here we just return the value stored in dr[7] by the last call to
3387 thread_rec for current_event.dwThreadId id. */
3389 static unsigned long
3390 cygwin_get_dr7 (void)
3392 return (unsigned long) dr
[7];
3395 /* Determine if the thread referenced by "ptid" is alive
3396 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3397 it means that the thread has died. Otherwise it is assumed to be alive. */
3400 windows_nat_target::thread_alive (ptid_t ptid
)
3402 gdb_assert (ptid
.lwp () != 0);
3404 return (WaitForSingleObject (thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
)->h
, 0)
3408 void _initialize_check_for_gdb_ini ();
3410 _initialize_check_for_gdb_ini ()
3413 if (inhibit_gdbinit
)
3416 homedir
= getenv ("HOME");
3420 char *oldini
= (char *) alloca (strlen (homedir
) +
3421 sizeof ("gdb.ini") + 1);
3422 strcpy (oldini
, homedir
);
3423 p
= strchr (oldini
, '\0');
3424 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3426 strcpy (p
, "gdb.ini");
3427 if (access (oldini
, 0) == 0)
3429 int len
= strlen (oldini
);
3430 char *newini
= (char *) alloca (len
+ 2);
3432 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3433 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3434 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3439 /* Define dummy functions which always return error for the rare cases where
3440 these functions could not be found. */
3442 bad_DebugActiveProcessStop (DWORD w
)
3447 bad_DebugBreakProcess (HANDLE w
)
3452 bad_DebugSetProcessKillOnExit (BOOL w
)
3457 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3464 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3470 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3477 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3483 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3489 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3495 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3503 /* Load any functions which may not be available in ancient versions
3506 void _initialize_loadable ();
3508 _initialize_loadable ()
3512 #define GPA(m, func) \
3513 func = (func ## _ftype *) GetProcAddress (m, #func)
3515 hm
= LoadLibrary ("kernel32.dll");
3518 GPA (hm
, DebugActiveProcessStop
);
3519 GPA (hm
, DebugBreakProcess
);
3520 GPA (hm
, DebugSetProcessKillOnExit
);
3521 GPA (hm
, GetConsoleFontSize
);
3522 GPA (hm
, DebugActiveProcessStop
);
3523 GPA (hm
, GetCurrentConsoleFont
);
3525 GPA (hm
, Wow64SuspendThread
);
3526 GPA (hm
, Wow64GetThreadContext
);
3527 GPA (hm
, Wow64SetThreadContext
);
3528 GPA (hm
, Wow64GetThreadSelectorEntry
);
3532 /* Set variables to dummy versions of these processes if the function
3533 wasn't found in kernel32.dll. */
3534 if (!DebugBreakProcess
)
3535 DebugBreakProcess
= bad_DebugBreakProcess
;
3536 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3538 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3539 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3541 if (!GetConsoleFontSize
)
3542 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3543 if (!GetCurrentConsoleFont
)
3544 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3546 /* Load optional functions used for retrieving filename information
3547 associated with the currently debugged process or its dlls. */
3548 hm
= LoadLibrary ("psapi.dll");
3551 GPA (hm
, EnumProcessModules
);
3553 GPA (hm
, EnumProcessModulesEx
);
3555 GPA (hm
, GetModuleInformation
);
3556 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3557 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3560 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3562 /* Set variables to dummy versions of these processes if the function
3563 wasn't found in psapi.dll. */
3564 EnumProcessModules
= bad_EnumProcessModules
;
3565 GetModuleInformation
= bad_GetModuleInformation
;
3566 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3567 /* This will probably fail on Windows 9x/Me. Let the user know
3568 that we're missing some functionality. */
3570 cannot automatically find executable file or library to read symbols.\n\
3571 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3574 hm
= LoadLibrary ("advapi32.dll");
3577 GPA (hm
, OpenProcessToken
);
3578 GPA (hm
, LookupPrivilegeValueA
);
3579 GPA (hm
, AdjustTokenPrivileges
);
3580 /* Only need to set one of these since if OpenProcessToken fails nothing
3582 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3583 || !AdjustTokenPrivileges
)
3584 OpenProcessToken
= bad_OpenProcessToken
;