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 windows_thread_info
*th
321 = thread_rec (inferior_ptid
, DONT_INVALIDATE_CONTEXT
);
322 return th
->stopped_at_software_breakpoint
;
325 bool supports_stopped_by_sw_breakpoint () override
330 enum target_xfer_status
xfer_partial (enum target_object object
,
333 const gdb_byte
*writebuf
,
334 ULONGEST offset
, ULONGEST len
,
335 ULONGEST
*xfered_len
) override
;
337 void files_info () override
;
339 void kill () override
;
341 void create_inferior (const char *, const std::string
&,
342 char **, int) override
;
344 void mourn_inferior () override
;
346 bool thread_alive (ptid_t ptid
) override
;
348 std::string
pid_to_str (ptid_t
) override
;
350 void interrupt () override
;
352 char *pid_to_exec_file (int pid
) override
;
354 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
356 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
358 const char *thread_name (struct thread_info
*) override
;
360 int get_windows_debug_event (int pid
, struct target_waitstatus
*ourstatus
);
362 void do_initial_windows_stuff (DWORD pid
, bool attaching
);
365 static windows_nat_target the_windows_nat_target
;
367 /* Set the MAPPINGS static global to OFFSETS.
368 See the description of MAPPINGS for more details. */
371 windows_set_context_register_offsets (const int *offsets
)
376 /* Set the function that should be used by this module to determine
377 whether a given register is a segment register or not. */
380 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
382 segment_register_p
= fun
;
386 check (BOOL ok
, const char *file
, int line
)
389 printf_filtered ("error return %s:%d was %u\n", file
, line
,
390 (unsigned) GetLastError ());
393 /* See nat/windows-nat.h. */
395 windows_thread_info
*
396 windows_nat::thread_rec (ptid_t ptid
, thread_disposition_type disposition
)
398 for (windows_thread_info
*th
: thread_list
)
399 if (th
->tid
== ptid
.lwp ())
405 case DONT_INVALIDATE_CONTEXT
:
408 case INVALIDATE_CONTEXT
:
409 if (ptid
.lwp () != current_event
.dwThreadId
)
411 th
->reload_context
= true;
414 th
->reload_context
= true;
425 /* Add a thread to the thread list.
427 PTID is the ptid of the thread to be added.
428 H is its Windows handle.
429 TLB is its thread local base.
430 MAIN_THREAD_P should be true if the thread to be added is
431 the main thread, false otherwise. */
433 static windows_thread_info
*
434 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
, bool main_thread_p
)
436 windows_thread_info
*th
;
438 gdb_assert (ptid
.lwp () != 0);
440 if ((th
= thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
)))
443 CORE_ADDR base
= (CORE_ADDR
) (uintptr_t) tlb
;
445 /* For WOW64 processes, this is actually the pointer to the 64bit TIB,
446 and the 32bit TIB is exactly 2 pages after it. */
450 th
= new windows_thread_info (ptid
.lwp (), h
, base
);
451 thread_list
.push_back (th
);
453 /* Add this new thread to the list of threads.
455 To be consistent with what's done on other platforms, we add
456 the main thread silently (in reality, this thread is really
457 more of a process to the user than a thread). */
459 add_thread_silent (&the_windows_nat_target
, ptid
);
461 add_thread (&the_windows_nat_target
, ptid
);
463 /* Set the debug registers for the new thread if they are used. */
464 if (debug_registers_used
)
469 /* Only change the value of the debug registers. */
470 th
->wow64_context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
471 CHECK (Wow64GetThreadContext (th
->h
, &th
->wow64_context
));
472 th
->wow64_context
.Dr0
= dr
[0];
473 th
->wow64_context
.Dr1
= dr
[1];
474 th
->wow64_context
.Dr2
= dr
[2];
475 th
->wow64_context
.Dr3
= dr
[3];
476 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
477 th
->wow64_context
.Dr7
= dr
[7];
478 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
479 th
->wow64_context
.ContextFlags
= 0;
484 /* Only change the value of the debug registers. */
485 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
486 CHECK (GetThreadContext (th
->h
, &th
->context
));
487 th
->context
.Dr0
= dr
[0];
488 th
->context
.Dr1
= dr
[1];
489 th
->context
.Dr2
= dr
[2];
490 th
->context
.Dr3
= dr
[3];
491 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
492 th
->context
.Dr7
= dr
[7];
493 CHECK (SetThreadContext (th
->h
, &th
->context
));
494 th
->context
.ContextFlags
= 0;
500 /* Clear out any old thread list and reinitialize it to a
503 windows_init_thread_list (void)
505 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
508 for (windows_thread_info
*here
: thread_list
)
511 thread_list
.clear ();
514 /* Delete a thread from the list of threads.
516 PTID is the ptid of the thread to be deleted.
517 EXIT_CODE is the thread's exit code.
518 MAIN_THREAD_P should be true if the thread to be deleted is
519 the main thread, false otherwise. */
522 windows_delete_thread (ptid_t ptid
, DWORD exit_code
, bool main_thread_p
)
526 gdb_assert (ptid
.lwp () != 0);
530 /* Emit a notification about the thread being deleted.
532 Note that no notification was printed when the main thread
533 was created, and thus, unless in verbose mode, we should be
534 symmetrical, and avoid that notification for the main thread
538 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
).c_str ());
539 else if (print_thread_events
&& !main_thread_p
)
540 printf_unfiltered (_("[%s exited with code %u]\n"),
541 target_pid_to_str (ptid
).c_str (),
542 (unsigned) exit_code
);
544 delete_thread (find_thread_ptid (&the_windows_nat_target
, ptid
));
546 auto iter
= std::find_if (thread_list
.begin (), thread_list
.end (),
547 [=] (windows_thread_info
*th
)
549 return th
->tid
== id
;
552 if (iter
!= thread_list
.end ())
555 thread_list
.erase (iter
);
559 /* Fetches register number R from the given windows_thread_info,
560 and supplies its value to the given regcache.
562 This function assumes that R is non-negative. A failed assertion
563 is raised if that is not true.
565 This function assumes that TH->RELOAD_CONTEXT is not set, meaning
566 that the windows_thread_info has an up-to-date context. A failed
567 assertion is raised if that assumption is violated. */
570 windows_fetch_one_register (struct regcache
*regcache
,
571 windows_thread_info
*th
, int r
)
574 gdb_assert (!th
->reload_context
);
576 char *context_ptr
= (char *) &th
->context
;
579 context_ptr
= (char *) &th
->wow64_context
;
582 char *context_offset
= context_ptr
+ mappings
[r
];
583 struct gdbarch
*gdbarch
= regcache
->arch ();
584 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
586 gdb_assert (!gdbarch_read_pc_p (gdbarch
));
587 gdb_assert (gdbarch_pc_regnum (gdbarch
) >= 0);
588 gdb_assert (!gdbarch_write_pc_p (gdbarch
));
590 if (r
== I387_FISEG_REGNUM (tdep
))
592 long l
= *((long *) context_offset
) & 0xffff;
593 regcache
->raw_supply (r
, (char *) &l
);
595 else if (r
== I387_FOP_REGNUM (tdep
))
597 long l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
598 regcache
->raw_supply (r
, (char *) &l
);
600 else if (segment_register_p (r
))
602 /* GDB treats segment registers as 32bit registers, but they are
603 in fact only 16 bits long. Make sure we do not read extra
604 bits from our source buffer. */
605 long l
= *((long *) context_offset
) & 0xffff;
606 regcache
->raw_supply (r
, (char *) &l
);
610 if (th
->stopped_at_software_breakpoint
612 && r
== gdbarch_pc_regnum (gdbarch
))
614 int size
= register_size (gdbarch
, r
);
618 memcpy (&value
, context_offset
, size
);
619 value
-= gdbarch_decr_pc_after_break (gdbarch
);
620 memcpy (context_offset
, &value
, size
);
624 gdb_assert (size
== 8);
626 memcpy (&value
, context_offset
, size
);
627 value
-= gdbarch_decr_pc_after_break (gdbarch
);
628 memcpy (context_offset
, &value
, size
);
630 /* Make sure we only rewrite the PC a single time. */
631 th
->pc_adjusted
= true;
633 regcache
->raw_supply (r
, context_offset
);
638 windows_nat_target::fetch_registers (struct regcache
*regcache
, int r
)
640 windows_thread_info
*th
= thread_rec (regcache
->ptid (), INVALIDATE_CONTEXT
);
642 /* Check if TH exists. Windows sometimes uses a non-existent
643 thread id in its events. */
647 if (th
->reload_context
)
650 if (have_saved_context
)
652 /* Lie about where the program actually is stopped since
653 cygwin has informed us that we should consider the signal
654 to have occurred at another location which is stored in
656 memcpy (&th
->context
, &saved_context
,
657 __COPY_CONTEXT_SIZE
);
658 have_saved_context
= 0;
665 th
->wow64_context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
666 CHECK (Wow64GetThreadContext (th
->h
, &th
->wow64_context
));
667 /* Copy dr values from that thread.
668 But only if there were not modified since last stop.
670 if (!debug_registers_changed
)
672 dr
[0] = th
->wow64_context
.Dr0
;
673 dr
[1] = th
->wow64_context
.Dr1
;
674 dr
[2] = th
->wow64_context
.Dr2
;
675 dr
[3] = th
->wow64_context
.Dr3
;
676 dr
[6] = th
->wow64_context
.Dr6
;
677 dr
[7] = th
->wow64_context
.Dr7
;
683 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
684 CHECK (GetThreadContext (th
->h
, &th
->context
));
685 /* Copy dr values from that thread.
686 But only if there were not modified since last stop.
688 if (!debug_registers_changed
)
690 dr
[0] = th
->context
.Dr0
;
691 dr
[1] = th
->context
.Dr1
;
692 dr
[2] = th
->context
.Dr2
;
693 dr
[3] = th
->context
.Dr3
;
694 dr
[6] = th
->context
.Dr6
;
695 dr
[7] = th
->context
.Dr7
;
698 th
->reload_context
= false;
702 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch()); r
++)
703 windows_fetch_one_register (regcache
, th
, r
);
705 windows_fetch_one_register (regcache
, th
, r
);
708 /* Collect the register number R from the given regcache, and store
709 its value into the corresponding area of the given thread's context.
711 This function assumes that R is non-negative. A failed assertion
712 assertion is raised if that is not true. */
715 windows_store_one_register (const struct regcache
*regcache
,
716 windows_thread_info
*th
, int r
)
720 char *context_ptr
= (char *) &th
->context
;
723 context_ptr
= (char *) &th
->wow64_context
;
726 regcache
->raw_collect (r
, context_ptr
+ mappings
[r
]);
729 /* Store a new register value into the context of the thread tied to
733 windows_nat_target::store_registers (struct regcache
*regcache
, int r
)
735 windows_thread_info
*th
= thread_rec (regcache
->ptid (), INVALIDATE_CONTEXT
);
737 /* Check if TH exists. Windows sometimes uses a non-existent
738 thread id in its events. */
743 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch ()); r
++)
744 windows_store_one_register (regcache
, th
, r
);
746 windows_store_one_register (regcache
, th
, r
);
749 /* Maintain a linked list of "so" information. */
750 struct lm_info_windows
: public lm_info_base
752 LPVOID load_addr
= 0;
753 CORE_ADDR text_offset
= 0;
756 static struct so_list solib_start
, *solib_end
;
758 static struct so_list
*
759 windows_make_so (const char *name
, LPVOID load_addr
)
766 WIN32_FIND_DATA w32_fd
;
767 HANDLE h
= FindFirstFile(name
, &w32_fd
);
769 if (h
== INVALID_HANDLE_VALUE
)
775 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
777 p
= strrchr (buf
, '\\');
780 SetCurrentDirectory (buf
);
781 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
782 SetCurrentDirectory (cwd
);
785 if (strcasecmp (buf
, "ntdll.dll") == 0)
787 GetSystemDirectory (buf
, sizeof (buf
));
788 strcat (buf
, "\\ntdll.dll");
791 cygwin_buf_t buf
[__PMAX
];
794 if (access (name
, F_OK
) != 0)
796 if (strcasecmp (name
, "ntdll.dll") == 0)
799 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
800 wcscat (buf
, L
"\\ntdll.dll");
804 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
805 strcat (buf
, "\\ntdll.dll");
810 so
= XCNEW (struct so_list
);
811 lm_info_windows
*li
= new lm_info_windows
;
813 li
->load_addr
= load_addr
;
814 strcpy (so
->so_original_name
, name
);
816 strcpy (so
->so_name
, buf
);
819 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
820 SO_NAME_MAX_PATH_SIZE
);
823 char *rname
= realpath (name
, NULL
);
824 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
826 strcpy (so
->so_name
, rname
);
831 warning (_("dll path for \"%s\" too long or inaccessible"), name
);
832 strcpy (so
->so_name
, so
->so_original_name
);
835 /* Record cygwin1.dll .text start/end. */
836 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
837 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
839 asection
*text
= NULL
;
841 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386"));
846 if (bfd_check_format (abfd
.get (), bfd_object
))
847 text
= bfd_get_section_by_name (abfd
.get (), ".text");
852 /* The symbols in a dll are offset by 0x1000, which is the
853 offset from 0 of the first byte in an image - because of the
854 file header and the section alignment. */
855 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
857 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (text
);
864 /* See nat/windows-nat.h. */
867 windows_nat::handle_load_dll ()
869 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
870 const char *dll_name
;
872 /* Try getting the DLL name via the lpImageName field of the event.
873 Note that Microsoft documents this fields as strictly optional,
874 in the sense that it might be NULL. And the first DLL event in
875 particular is explicitly documented as "likely not pass[ed]"
876 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
877 dll_name
= get_image_name (current_process_handle
,
878 event
->lpImageName
, event
->fUnicode
);
882 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
883 solib_end
= solib_end
->next
;
885 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
887 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
888 host_address_to_string (li
->load_addr
)));
892 windows_free_so (struct so_list
*so
)
894 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
900 /* See nat/windows-nat.h. */
903 windows_nat::handle_unload_dll ()
905 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
908 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
910 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
912 if (li_next
->load_addr
== lpBaseOfDll
)
914 struct so_list
*sodel
= so
->next
;
916 so
->next
= sodel
->next
;
919 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
921 windows_free_so (sodel
);
926 /* We did not find any DLL that was previously loaded at this address,
927 so register a complaint. We do not report an error, because we have
928 observed that this may be happening under some circumstances. For
929 instance, running 32bit applications on x64 Windows causes us to receive
930 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
931 events are apparently caused by the WOW layer, the interface between
932 32bit and 64bit worlds). */
933 complaint (_("dll starting at %s not found."),
934 host_address_to_string (lpBaseOfDll
));
937 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
941 catch_errors (void (*func
) ())
947 catch (const gdb_exception
&ex
)
949 exception_print (gdb_stderr
, ex
);
953 /* Clear list of loaded DLLs. */
955 windows_clear_solib (void)
959 for (so
= solib_start
.next
; so
; so
= solib_start
.next
)
961 solib_start
.next
= so
->next
;
962 windows_free_so (so
);
965 solib_end
= &solib_start
;
969 signal_event_command (const char *args
, int from_tty
)
971 uintptr_t event_id
= 0;
972 char *endargs
= NULL
;
975 error (_("signal-event requires an argument (integer event id)"));
977 event_id
= strtoumax (args
, &endargs
, 10);
979 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
980 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
981 error (_("Failed to convert `%s' to event id"), args
);
983 SetEvent ((HANDLE
) event_id
);
984 CloseHandle ((HANDLE
) event_id
);
987 /* See nat/windows-nat.h. */
990 windows_nat::handle_output_debug_string (struct target_waitstatus
*ourstatus
)
994 gdb::unique_xmalloc_ptr
<char> s
995 = (target_read_string
996 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
998 if (s
== nullptr || !*(s
.get ()))
1000 else if (!startswith (s
.get (), _CYGWIN_SIGNAL_STRING
))
1003 if (!startswith (s
.get (), "cYg"))
1006 char *p
= strchr (s
.get (), '\0');
1008 if (p
> s
.get () && *--p
== '\n')
1010 warning (("%s"), s
.get ());
1016 /* Got a cygwin signal marker. A cygwin signal is followed by
1017 the signal number itself and then optionally followed by the
1018 thread id and address to saved context within the DLL. If
1019 these are supplied, then the given thread is assumed to have
1020 issued the signal and the context from the thread is assumed
1021 to be stored at the given address in the inferior. Tell gdb
1022 to treat this like a real signal. */
1024 int sig
= strtol (s
.get () + sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
1025 gdb_signal gotasig
= gdb_signal_from_host (sig
);
1027 ourstatus
->value
.sig
= gotasig
;
1033 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1034 retval
= strtoul (p
, &p
, 0);
1036 retval
= current_event
.dwThreadId
;
1037 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
1038 && ReadProcessMemory (current_process_handle
, x
,
1040 __COPY_CONTEXT_SIZE
, &n
)
1041 && n
== __COPY_CONTEXT_SIZE
)
1042 have_saved_context
= 1;
1051 display_selector (HANDLE thread
, DWORD sel
)
1057 ret
= Wow64GetThreadSelectorEntry (thread
, sel
, &info
);
1060 ret
= GetThreadSelectorEntry (thread
, sel
, &info
);
1064 printf_filtered ("0x%03x: ", (unsigned) sel
);
1065 if (!info
.HighWord
.Bits
.Pres
)
1067 puts_filtered ("Segment not present\n");
1070 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1071 (info
.HighWord
.Bits
.BaseMid
<< 16)
1073 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1074 if (info
.HighWord
.Bits
.Granularity
)
1075 limit
= (limit
<< 12) | 0xfff;
1076 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1077 if (info
.HighWord
.Bits
.Default_Big
)
1078 puts_filtered(" 32-bit ");
1080 puts_filtered(" 16-bit ");
1081 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1084 puts_filtered ("Data (Read-Only, Exp-up");
1087 puts_filtered ("Data (Read/Write, Exp-up");
1090 puts_filtered ("Unused segment (");
1093 puts_filtered ("Data (Read/Write, Exp-down");
1096 puts_filtered ("Code (Exec-Only, N.Conf");
1099 puts_filtered ("Code (Exec/Read, N.Conf");
1102 puts_filtered ("Code (Exec-Only, Conf");
1105 puts_filtered ("Code (Exec/Read, Conf");
1108 printf_filtered ("Unknown type 0x%lx",
1109 (unsigned long) info
.HighWord
.Bits
.Type
);
1111 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1112 puts_filtered(", N.Acc");
1113 puts_filtered (")\n");
1114 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1115 puts_filtered("System selector ");
1116 printf_filtered ("Priviledge level = %ld. ",
1117 (unsigned long) info
.HighWord
.Bits
.Dpl
);
1118 if (info
.HighWord
.Bits
.Granularity
)
1119 puts_filtered ("Page granular.\n");
1121 puts_filtered ("Byte granular.\n");
1126 DWORD err
= GetLastError ();
1127 if (err
== ERROR_NOT_SUPPORTED
)
1128 printf_filtered ("Function not supported\n");
1130 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1136 display_selectors (const char * args
, int from_tty
)
1138 if (inferior_ptid
== null_ptid
)
1140 puts_filtered ("Impossible to display selectors now.\n");
1144 windows_thread_info
*current_windows_thread
1145 = thread_rec (inferior_ptid
, DONT_INVALIDATE_CONTEXT
);
1152 puts_filtered ("Selector $cs\n");
1153 display_selector (current_windows_thread
->h
,
1154 current_windows_thread
->wow64_context
.SegCs
);
1155 puts_filtered ("Selector $ds\n");
1156 display_selector (current_windows_thread
->h
,
1157 current_windows_thread
->wow64_context
.SegDs
);
1158 puts_filtered ("Selector $es\n");
1159 display_selector (current_windows_thread
->h
,
1160 current_windows_thread
->wow64_context
.SegEs
);
1161 puts_filtered ("Selector $ss\n");
1162 display_selector (current_windows_thread
->h
,
1163 current_windows_thread
->wow64_context
.SegSs
);
1164 puts_filtered ("Selector $fs\n");
1165 display_selector (current_windows_thread
->h
,
1166 current_windows_thread
->wow64_context
.SegFs
);
1167 puts_filtered ("Selector $gs\n");
1168 display_selector (current_windows_thread
->h
,
1169 current_windows_thread
->wow64_context
.SegGs
);
1174 puts_filtered ("Selector $cs\n");
1175 display_selector (current_windows_thread
->h
,
1176 current_windows_thread
->context
.SegCs
);
1177 puts_filtered ("Selector $ds\n");
1178 display_selector (current_windows_thread
->h
,
1179 current_windows_thread
->context
.SegDs
);
1180 puts_filtered ("Selector $es\n");
1181 display_selector (current_windows_thread
->h
,
1182 current_windows_thread
->context
.SegEs
);
1183 puts_filtered ("Selector $ss\n");
1184 display_selector (current_windows_thread
->h
,
1185 current_windows_thread
->context
.SegSs
);
1186 puts_filtered ("Selector $fs\n");
1187 display_selector (current_windows_thread
->h
,
1188 current_windows_thread
->context
.SegFs
);
1189 puts_filtered ("Selector $gs\n");
1190 display_selector (current_windows_thread
->h
,
1191 current_windows_thread
->context
.SegGs
);
1197 sel
= parse_and_eval_long (args
);
1198 printf_filtered ("Selector \"%s\"\n",args
);
1199 display_selector (current_windows_thread
->h
, sel
);
1203 /* See nat/windows-nat.h. */
1206 windows_nat::handle_ms_vc_exception (const EXCEPTION_RECORD
*rec
)
1208 if (rec
->NumberParameters
>= 3
1209 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1211 DWORD named_thread_id
;
1212 windows_thread_info
*named_thread
;
1213 CORE_ADDR thread_name_target
;
1215 thread_name_target
= rec
->ExceptionInformation
[1];
1216 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1218 if (named_thread_id
== (DWORD
) -1)
1219 named_thread_id
= current_event
.dwThreadId
;
1221 named_thread
= thread_rec (ptid_t (current_event
.dwProcessId
,
1222 named_thread_id
, 0),
1223 DONT_INVALIDATE_CONTEXT
);
1224 if (named_thread
!= NULL
)
1226 int thread_name_len
;
1227 gdb::unique_xmalloc_ptr
<char> thread_name
1228 = target_read_string (thread_name_target
, 1025, &thread_name_len
);
1229 if (thread_name_len
> 0)
1231 thread_name
.get ()[thread_name_len
- 1] = '\0';
1232 named_thread
->name
= std::move (thread_name
);
1242 /* See nat/windows-nat.h. */
1245 windows_nat::handle_access_violation (const EXCEPTION_RECORD
*rec
)
1248 /* See if the access violation happened within the cygwin DLL
1249 itself. Cygwin uses a kind of exception handling to deal with
1250 passed-in invalid addresses. gdb should not treat these as real
1251 SEGVs since they will be silently handled by cygwin. A real SEGV
1252 will (theoretically) be caught by cygwin later in the process and
1253 will be sent as a cygwin-specific-signal. So, ignore SEGVs if
1254 they show up within the text segment of the DLL itself. */
1256 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1258 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1259 && addr
< cygwin_load_end
))
1260 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1261 && startswith (fn
, "KERNEL32!IsBad")))
1267 /* Resume thread specified by ID, or all artificially suspended
1268 threads, if we are continuing execution. KILLED non-zero means we
1269 have killed the inferior, so we should ignore weird errors due to
1270 threads shutting down. */
1272 windows_continue (DWORD continue_status
, int id
, int killed
)
1276 desired_stop_thread_id
= id
;
1278 if (matching_pending_stop (debug_events
))
1281 for (windows_thread_info
*th
: thread_list
)
1282 if (id
== -1 || id
== (int) th
->tid
)
1289 if (debug_registers_changed
)
1291 th
->wow64_context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1292 th
->wow64_context
.Dr0
= dr
[0];
1293 th
->wow64_context
.Dr1
= dr
[1];
1294 th
->wow64_context
.Dr2
= dr
[2];
1295 th
->wow64_context
.Dr3
= dr
[3];
1296 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1297 th
->wow64_context
.Dr7
= dr
[7];
1299 if (th
->wow64_context
.ContextFlags
)
1303 if (GetExitCodeThread (th
->h
, &ec
)
1304 && ec
== STILL_ACTIVE
)
1306 BOOL status
= Wow64SetThreadContext (th
->h
,
1307 &th
->wow64_context
);
1312 th
->wow64_context
.ContextFlags
= 0;
1318 if (debug_registers_changed
)
1320 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1321 th
->context
.Dr0
= dr
[0];
1322 th
->context
.Dr1
= dr
[1];
1323 th
->context
.Dr2
= dr
[2];
1324 th
->context
.Dr3
= dr
[3];
1325 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1326 th
->context
.Dr7
= dr
[7];
1328 if (th
->context
.ContextFlags
)
1332 if (GetExitCodeThread (th
->h
, &ec
)
1333 && ec
== STILL_ACTIVE
)
1335 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1340 th
->context
.ContextFlags
= 0;
1347 /* When single-stepping a specific thread, other threads must
1352 res
= continue_last_debug_event (continue_status
, debug_events
);
1355 error (_("Failed to resume program execution"
1356 " (ContinueDebugEvent failed, error %u)"),
1357 (unsigned int) GetLastError ());
1359 debug_registers_changed
= 0;
1363 /* Called in pathological case where Windows fails to send a
1364 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1366 fake_create_process (void)
1368 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1369 current_event
.dwProcessId
);
1370 if (current_process_handle
!= NULL
)
1371 open_process_used
= 1;
1374 error (_("OpenProcess call failed, GetLastError = %u"),
1375 (unsigned) GetLastError ());
1376 /* We can not debug anything in that case. */
1378 windows_add_thread (ptid_t (current_event
.dwProcessId
, 0,
1379 current_event
.dwThreadId
),
1380 current_event
.u
.CreateThread
.hThread
,
1381 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1382 true /* main_thread_p */);
1383 return current_event
.dwThreadId
;
1387 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1389 windows_thread_info
*th
;
1390 DWORD continue_status
= DBG_CONTINUE
;
1392 /* A specific PTID means `step only this thread id'. */
1393 int resume_all
= ptid
== minus_one_ptid
;
1395 /* If we're continuing all threads, it's the current inferior that
1396 should be handled specially. */
1398 ptid
= inferior_ptid
;
1400 if (sig
!= GDB_SIGNAL_0
)
1402 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1404 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1406 else if (sig
== last_sig
)
1407 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1410 /* This code does not seem to work, because
1411 the kernel does probably not consider changes in the ExceptionRecord
1412 structure when passing the exception to the inferior.
1413 Note that this seems possible in the exception handler itself. */
1415 for (const xlate_exception
&x
: xlate
)
1418 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1420 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1423 if (continue_status
== DBG_CONTINUE
)
1425 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1429 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1433 last_sig
= GDB_SIGNAL_0
;
1435 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=0x%x, step=%d, sig=%d);\n",
1436 ptid
.pid (), (unsigned) ptid
.lwp (), step
, sig
));
1438 /* Get context for currently selected thread. */
1439 th
= thread_rec (inferior_ptid
, DONT_INVALIDATE_CONTEXT
);
1447 /* Single step by setting t bit. */
1448 struct regcache
*regcache
= get_current_regcache ();
1449 struct gdbarch
*gdbarch
= regcache
->arch ();
1450 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1451 th
->wow64_context
.EFlags
|= FLAG_TRACE_BIT
;
1454 if (th
->wow64_context
.ContextFlags
)
1456 if (debug_registers_changed
)
1458 th
->wow64_context
.Dr0
= dr
[0];
1459 th
->wow64_context
.Dr1
= dr
[1];
1460 th
->wow64_context
.Dr2
= dr
[2];
1461 th
->wow64_context
.Dr3
= dr
[3];
1462 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1463 th
->wow64_context
.Dr7
= dr
[7];
1465 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
1466 th
->wow64_context
.ContextFlags
= 0;
1474 /* Single step by setting t bit. */
1475 struct regcache
*regcache
= get_current_regcache ();
1476 struct gdbarch
*gdbarch
= regcache
->arch ();
1477 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1478 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1481 if (th
->context
.ContextFlags
)
1483 if (debug_registers_changed
)
1485 th
->context
.Dr0
= dr
[0];
1486 th
->context
.Dr1
= dr
[1];
1487 th
->context
.Dr2
= dr
[2];
1488 th
->context
.Dr3
= dr
[3];
1489 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1490 th
->context
.Dr7
= dr
[7];
1492 CHECK (SetThreadContext (th
->h
, &th
->context
));
1493 th
->context
.ContextFlags
= 0;
1498 /* Allow continuing with the same signal that interrupted us.
1499 Otherwise complain. */
1502 windows_continue (continue_status
, -1, 0);
1504 windows_continue (continue_status
, ptid
.lwp (), 0);
1507 /* Ctrl-C handler used when the inferior is not run in the same console. The
1508 handler is in charge of interrupting the inferior using DebugBreakProcess.
1509 Note that this function is not available prior to Windows XP. In this case
1510 we emit a warning. */
1512 ctrl_c_handler (DWORD event_type
)
1514 const int attach_flag
= current_inferior ()->attach_flag
;
1516 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1517 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1520 /* If the inferior and the debugger share the same console, do nothing as
1521 the inferior has also received the Ctrl-C event. */
1522 if (!new_console
&& !attach_flag
)
1525 if (!DebugBreakProcess (current_process_handle
))
1526 warning (_("Could not interrupt program. "
1527 "Press Ctrl-c in the program console."));
1529 /* Return true to tell that Ctrl-C has been handled. */
1533 /* Get the next event from the child. Returns a non-zero thread id if the event
1534 requires handling by WFI (or whatever). */
1537 windows_nat_target::get_windows_debug_event (int pid
,
1538 struct target_waitstatus
*ourstatus
)
1541 DWORD continue_status
, event_code
;
1542 DWORD thread_id
= 0;
1544 /* If there is a relevant pending stop, report it now. See the
1545 comment by the definition of "pending_stops" for details on why
1547 gdb::optional
<pending_stop
> stop
= fetch_pending_stop (debug_events
);
1548 if (stop
.has_value ())
1550 thread_id
= stop
->thread_id
;
1551 *ourstatus
= stop
->status
;
1553 ptid_t
ptid (current_event
.dwProcessId
, thread_id
);
1554 windows_thread_info
*th
= thread_rec (ptid
, INVALIDATE_CONTEXT
);
1555 th
->reload_context
= 1;
1560 last_sig
= GDB_SIGNAL_0
;
1562 if (!(debug_event
= wait_for_debug_event (¤t_event
, 1000)))
1565 continue_status
= DBG_CONTINUE
;
1567 event_code
= current_event
.dwDebugEventCode
;
1568 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1569 have_saved_context
= 0;
1573 case CREATE_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 "CREATE_THREAD_DEBUG_EVENT"));
1578 if (saw_create
!= 1)
1580 inferior
*inf
= find_inferior_pid (this, current_event
.dwProcessId
);
1581 if (!saw_create
&& inf
->attach_flag
)
1583 /* Kludge around a Windows bug where first event is a create
1584 thread event. Caused when attached process does not have
1586 thread_id
= fake_create_process ();
1592 /* Record the existence of this thread. */
1593 thread_id
= current_event
.dwThreadId
;
1595 (ptid_t (current_event
.dwProcessId
, current_event
.dwThreadId
, 0),
1596 current_event
.u
.CreateThread
.hThread
,
1597 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1598 false /* main_thread_p */);
1602 case EXIT_THREAD_DEBUG_EVENT
:
1603 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1604 (unsigned) current_event
.dwProcessId
,
1605 (unsigned) current_event
.dwThreadId
,
1606 "EXIT_THREAD_DEBUG_EVENT"));
1607 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1608 current_event
.dwThreadId
, 0),
1609 current_event
.u
.ExitThread
.dwExitCode
,
1610 false /* main_thread_p */);
1613 case CREATE_PROCESS_DEBUG_EVENT
:
1614 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1615 (unsigned) current_event
.dwProcessId
,
1616 (unsigned) current_event
.dwThreadId
,
1617 "CREATE_PROCESS_DEBUG_EVENT"));
1618 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1619 if (++saw_create
!= 1)
1622 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1623 /* Add the main thread. */
1625 (ptid_t (current_event
.dwProcessId
,
1626 current_event
.dwThreadId
, 0),
1627 current_event
.u
.CreateProcessInfo
.hThread
,
1628 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
,
1629 true /* main_thread_p */);
1630 thread_id
= current_event
.dwThreadId
;
1633 case EXIT_PROCESS_DEBUG_EVENT
:
1634 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1635 (unsigned) current_event
.dwProcessId
,
1636 (unsigned) current_event
.dwThreadId
,
1637 "EXIT_PROCESS_DEBUG_EVENT"));
1638 if (!windows_initialization_done
)
1640 target_terminal::ours ();
1641 target_mourn_inferior (inferior_ptid
);
1642 error (_("During startup program exited with code 0x%x."),
1643 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1645 else if (saw_create
== 1)
1647 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1648 current_event
.dwThreadId
, 0),
1649 0, true /* main_thread_p */);
1650 DWORD exit_status
= current_event
.u
.ExitProcess
.dwExitCode
;
1651 /* If the exit status looks like a fatal exception, but we
1652 don't recognize the exception's code, make the original
1653 exit status value available, to avoid losing
1656 = WIFSIGNALED (exit_status
) ? WTERMSIG (exit_status
) : -1;
1657 if (exit_signal
== -1)
1659 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1660 ourstatus
->value
.integer
= exit_status
;
1664 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1665 ourstatus
->value
.sig
= gdb_signal_from_host (exit_signal
);
1667 thread_id
= current_event
.dwThreadId
;
1671 case LOAD_DLL_DEBUG_EVENT
:
1672 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1673 (unsigned) current_event
.dwProcessId
,
1674 (unsigned) current_event
.dwThreadId
,
1675 "LOAD_DLL_DEBUG_EVENT"));
1676 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1677 if (saw_create
!= 1 || ! windows_initialization_done
)
1679 catch_errors (handle_load_dll
);
1680 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1681 ourstatus
->value
.integer
= 0;
1682 thread_id
= current_event
.dwThreadId
;
1685 case UNLOAD_DLL_DEBUG_EVENT
:
1686 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1687 (unsigned) current_event
.dwProcessId
,
1688 (unsigned) current_event
.dwThreadId
,
1689 "UNLOAD_DLL_DEBUG_EVENT"));
1690 if (saw_create
!= 1 || ! windows_initialization_done
)
1692 catch_errors (handle_unload_dll
);
1693 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1694 ourstatus
->value
.integer
= 0;
1695 thread_id
= current_event
.dwThreadId
;
1698 case EXCEPTION_DEBUG_EVENT
:
1699 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1700 (unsigned) current_event
.dwProcessId
,
1701 (unsigned) current_event
.dwThreadId
,
1702 "EXCEPTION_DEBUG_EVENT"));
1703 if (saw_create
!= 1)
1705 switch (handle_exception (ourstatus
, debug_exceptions
))
1707 case HANDLE_EXCEPTION_UNHANDLED
:
1709 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1711 case HANDLE_EXCEPTION_HANDLED
:
1712 thread_id
= current_event
.dwThreadId
;
1714 case HANDLE_EXCEPTION_IGNORED
:
1715 continue_status
= DBG_CONTINUE
;
1720 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1721 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1722 (unsigned) current_event
.dwProcessId
,
1723 (unsigned) current_event
.dwThreadId
,
1724 "OUTPUT_DEBUG_STRING_EVENT"));
1725 if (saw_create
!= 1)
1727 thread_id
= handle_output_debug_string (ourstatus
);
1731 if (saw_create
!= 1)
1733 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1734 (unsigned) current_event
.dwProcessId
,
1735 (unsigned) current_event
.dwThreadId
);
1736 printf_unfiltered (" unknown event code %u\n",
1737 (unsigned) current_event
.dwDebugEventCode
);
1741 if (!thread_id
|| saw_create
!= 1)
1743 CHECK (windows_continue (continue_status
, desired_stop_thread_id
, 0));
1745 else if (desired_stop_thread_id
!= -1 && desired_stop_thread_id
!= thread_id
)
1747 /* Pending stop. See the comment by the definition of
1748 "pending_stops" for details on why this is needed. */
1749 DEBUG_EVENTS (("get_windows_debug_event - "
1750 "unexpected stop in 0x%x (expecting 0x%x)\n",
1751 thread_id
, desired_stop_thread_id
));
1753 if (current_event
.dwDebugEventCode
== EXCEPTION_DEBUG_EVENT
1754 && ((current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1755 == EXCEPTION_BREAKPOINT
)
1756 || (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1757 == STATUS_WX86_BREAKPOINT
))
1758 && windows_initialization_done
)
1760 ptid_t ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1761 windows_thread_info
*th
= thread_rec (ptid
, INVALIDATE_CONTEXT
);
1762 th
->stopped_at_software_breakpoint
= true;
1763 th
->pc_adjusted
= false;
1765 pending_stops
.push_back ({thread_id
, *ourstatus
, current_event
});
1767 CHECK (windows_continue (continue_status
, desired_stop_thread_id
, 0));
1774 /* Wait for interesting events to occur in the target process. */
1776 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1781 /* We loop when we get a non-standard exception rather than return
1782 with a SPURIOUS because resume can try and step or modify things,
1783 which needs a current_thread->h. But some of these exceptions mark
1784 the birth or death of threads, which mean that the current thread
1785 isn't necessarily what you think it is. */
1791 /* If the user presses Ctrl-c while the debugger is waiting
1792 for an event, he expects the debugger to interrupt his program
1793 and to get the prompt back. There are two possible situations:
1795 - The debugger and the program do not share the console, in
1796 which case the Ctrl-c event only reached the debugger.
1797 In that case, the ctrl_c handler will take care of interrupting
1798 the inferior. Note that this case is working starting with
1799 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1802 - The debugger and the program share the same console, in which
1803 case both debugger and inferior will receive the Ctrl-c event.
1804 In that case the ctrl_c handler will ignore the event, as the
1805 Ctrl-c event generated inside the inferior will trigger the
1806 expected debug event.
1808 FIXME: brobecker/2008-05-20: If the inferior receives the
1809 signal first and the delay until GDB receives that signal
1810 is sufficiently long, GDB can sometimes receive the SIGINT
1811 after we have unblocked the CTRL+C handler. This would
1812 lead to the debugger stopping prematurely while handling
1813 the new-thread event that comes with the handling of the SIGINT
1814 inside the inferior, and then stop again immediately when
1815 the user tries to resume the execution in the inferior.
1816 This is a classic race that we should try to fix one day. */
1817 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1818 retval
= get_windows_debug_event (pid
, ourstatus
);
1819 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1823 ptid_t result
= ptid_t (current_event
.dwProcessId
, retval
, 0);
1825 if (ourstatus
->kind
!= TARGET_WAITKIND_EXITED
1826 && ourstatus
->kind
!= TARGET_WAITKIND_SIGNALLED
)
1828 windows_thread_info
*th
= thread_rec (result
, INVALIDATE_CONTEXT
);
1832 th
->stopped_at_software_breakpoint
= false;
1833 if (current_event
.dwDebugEventCode
== EXCEPTION_DEBUG_EVENT
1834 && ((current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1835 == EXCEPTION_BREAKPOINT
)
1836 || (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1837 == STATUS_WX86_BREAKPOINT
))
1838 && windows_initialization_done
)
1840 th
->stopped_at_software_breakpoint
= true;
1841 th
->pc_adjusted
= false;
1852 if (deprecated_ui_loop_hook
!= NULL
)
1853 detach
= deprecated_ui_loop_hook (0);
1861 /* Iterate over all DLLs currently mapped by our inferior, and
1862 add them to our list of solibs. */
1865 windows_add_all_dlls (void)
1867 HMODULE dummy_hmodule
;
1875 if (EnumProcessModulesEx (current_process_handle
, &dummy_hmodule
,
1876 sizeof (HMODULE
), &cb_needed
,
1877 LIST_MODULES_32BIT
) == 0)
1883 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
1884 sizeof (HMODULE
), &cb_needed
) == 0)
1891 hmodules
= (HMODULE
*) alloca (cb_needed
);
1895 if (EnumProcessModulesEx (current_process_handle
, hmodules
,
1896 cb_needed
, &cb_needed
,
1897 LIST_MODULES_32BIT
) == 0)
1903 if (EnumProcessModules (current_process_handle
, hmodules
,
1904 cb_needed
, &cb_needed
) == 0)
1908 char system_dir
[__PMAX
];
1909 char syswow_dir
[__PMAX
];
1910 size_t system_dir_len
= 0;
1911 bool convert_syswow_dir
= false;
1916 /* This fails on 32bit Windows because it has no SysWOW64 directory,
1917 and in this case a path conversion isn't necessary. */
1918 UINT len
= GetSystemWow64DirectoryA (syswow_dir
, sizeof (syswow_dir
));
1921 /* Check that we have passed a large enough buffer. */
1922 gdb_assert (len
< sizeof (syswow_dir
));
1924 len
= GetSystemDirectoryA (system_dir
, sizeof (system_dir
));
1926 gdb_assert (len
!= 0);
1927 /* Check that we have passed a large enough buffer. */
1928 gdb_assert (len
< sizeof (system_dir
));
1930 strcat (system_dir
, "\\");
1931 strcat (syswow_dir
, "\\");
1932 system_dir_len
= strlen (system_dir
);
1934 convert_syswow_dir
= true;
1938 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
1942 wchar_t dll_name
[__PMAX
];
1943 char dll_name_mb
[__PMAX
];
1945 char dll_name
[__PMAX
];
1948 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
1949 &mi
, sizeof (mi
)) == 0)
1951 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
1952 dll_name
, sizeof (dll_name
)) == 0)
1955 wcstombs (dll_name_mb
, dll_name
, __PMAX
);
1960 /* Convert the DLL path of 32bit processes returned by
1961 GetModuleFileNameEx from the 64bit system directory to the
1962 32bit syswow64 directory if necessary. */
1963 std::string syswow_dll_path
;
1964 if (convert_syswow_dir
1965 && strncasecmp (name
, system_dir
, system_dir_len
) == 0
1966 && strchr (name
+ system_dir_len
, '\\') == nullptr)
1968 syswow_dll_path
= syswow_dir
;
1969 syswow_dll_path
+= name
+ system_dir_len
;
1970 name
= syswow_dll_path
.c_str();
1973 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
1974 solib_end
= solib_end
->next
;
1979 windows_nat_target::do_initial_windows_stuff (DWORD pid
, bool attaching
)
1982 struct inferior
*inf
;
1984 last_sig
= GDB_SIGNAL_0
;
1985 open_process_used
= 0;
1986 debug_registers_changed
= 0;
1987 debug_registers_used
= 0;
1988 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1991 cygwin_load_start
= cygwin_load_end
= 0;
1993 current_event
.dwProcessId
= pid
;
1994 memset (¤t_event
, 0, sizeof (current_event
));
1995 if (!target_is_pushed (this))
1997 disable_breakpoints_in_shlibs ();
1998 windows_clear_solib ();
1999 clear_proceed_status (0);
2000 init_wait_for_inferior ();
2003 ignore_first_breakpoint
= !attaching
&& wow64_process
;
2007 windows_set_context_register_offsets (amd64_mappings
);
2008 windows_set_segment_register_p (amd64_windows_segment_register_p
);
2013 windows_set_context_register_offsets (i386_mappings
);
2014 windows_set_segment_register_p (i386_windows_segment_register_p
);
2017 inf
= current_inferior ();
2018 inferior_appeared (inf
, pid
);
2019 inf
->attach_flag
= attaching
;
2021 target_terminal::init ();
2022 target_terminal::inferior ();
2024 windows_initialization_done
= 0;
2030 struct target_waitstatus status
;
2032 last_ptid
= this->wait (minus_one_ptid
, &status
, 0);
2034 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
2036 if (status
.kind
!= TARGET_WAITKIND_LOADED
2037 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
2040 this->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
2043 switch_to_thread (find_thread_ptid (this, last_ptid
));
2045 /* Now that the inferior has been started and all DLLs have been mapped,
2046 we can iterate over all DLLs and load them in.
2048 We avoid doing it any earlier because, on certain versions of Windows,
2049 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
2050 we have seen on Windows 8.1 that the ntdll.dll load event does not
2051 include the DLL name, preventing us from creating an associated SO.
2052 A possible explanation is that ntdll.dll might be mapped before
2053 the SO info gets created by the Windows system -- ntdll.dll is
2054 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
2055 do not seem to suffer from that problem.
2057 Rather than try to work around this sort of issue, it is much
2058 simpler to just ignore DLL load/unload events during the startup
2059 phase, and then process them all in one batch now. */
2060 windows_add_all_dlls ();
2062 windows_initialization_done
= 1;
2066 /* Try to set or remove a user privilege to the current process. Return -1
2067 if that fails, the previous setting of that privilege otherwise.
2069 This code is copied from the Cygwin source code and rearranged to allow
2070 dynamically loading of the needed symbols from advapi32 which is only
2071 available on NT/2K/XP. */
2073 set_process_privilege (const char *privilege
, BOOL enable
)
2075 HANDLE token_hdl
= NULL
;
2077 TOKEN_PRIVILEGES new_priv
, orig_priv
;
2081 if (!OpenProcessToken (GetCurrentProcess (),
2082 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
2086 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
2089 new_priv
.PrivilegeCount
= 1;
2090 new_priv
.Privileges
[0].Luid
= restore_priv
;
2091 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
2093 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
2094 sizeof orig_priv
, &orig_priv
, &size
))
2097 /* Disabled, otherwise every `attach' in an unprivileged user session
2098 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
2099 windows_attach(). */
2100 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
2101 be enabled. GetLastError () returns an correct error code, though. */
2102 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
2106 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
2110 CloseHandle (token_hdl
);
2115 /* Attach to process PID, then initialize for debugging it. */
2118 windows_nat_target::attach (const char *args
, int from_tty
)
2123 pid
= parse_pid_to_attach (args
);
2125 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
2127 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
2128 printf_unfiltered ("This can cause attach to "
2129 "fail on Windows NT/2K/XP\n");
2132 windows_init_thread_list ();
2133 ok
= DebugActiveProcess (pid
);
2139 /* Try fall back to Cygwin pid. */
2140 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
2143 ok
= DebugActiveProcess (pid
);
2148 error (_("Can't attach to process %u (error %u)"),
2149 (unsigned) pid
, (unsigned) GetLastError ());
2151 DebugSetProcessKillOnExit (FALSE
);
2155 const char *exec_file
= get_exec_file (0);
2158 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
2159 target_pid_to_str (ptid_t (pid
)).c_str ());
2161 printf_unfiltered ("Attaching to %s\n",
2162 target_pid_to_str (ptid_t (pid
)).c_str ());
2166 HANDLE h
= OpenProcess (PROCESS_QUERY_INFORMATION
, FALSE
, pid
);
2170 if (IsWow64Process (h
, &wow64
))
2171 wow64_process
= wow64
;
2176 do_initial_windows_stuff (pid
, 1);
2177 target_terminal::ours ();
2181 windows_nat_target::detach (inferior
*inf
, int from_tty
)
2185 ptid_t ptid
= minus_one_ptid
;
2186 resume (ptid
, 0, GDB_SIGNAL_0
);
2188 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
2190 error (_("Can't detach process %u (error %u)"),
2191 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
2194 DebugSetProcessKillOnExit (FALSE
);
2196 if (detached
&& from_tty
)
2198 const char *exec_file
= get_exec_file (0);
2201 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
2202 (unsigned) current_event
.dwProcessId
);
2205 x86_cleanup_dregs ();
2206 switch_to_no_thread ();
2207 detach_inferior (inf
);
2209 maybe_unpush_target ();
2212 /* Try to determine the executable filename.
2214 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2216 Upon success, the filename is stored inside EXE_NAME_RET, and
2217 this function returns nonzero.
2219 Otherwise, this function returns zero and the contents of
2220 EXE_NAME_RET is undefined. */
2223 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2233 if (!EnumProcessModulesEx (current_process_handle
, &dh_buf
,
2234 sizeof (HMODULE
), &cbNeeded
,
2235 LIST_MODULES_32BIT
) || !cbNeeded
)
2241 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2242 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2246 /* We know the executable is always first in the list of modules,
2247 which we just fetched. So no need to fetch more. */
2251 /* Cygwin prefers that the path be in /x/y/z format, so extract
2252 the filename into a temporary buffer first, and then convert it
2253 to POSIX format into the destination buffer. */
2254 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2256 len
= GetModuleFileNameEx (current_process_handle
,
2257 dh_buf
, pathbuf
, exe_name_max_len
);
2259 error (_("Error getting executable filename: %u."),
2260 (unsigned) GetLastError ());
2261 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2262 exe_name_max_len
) < 0)
2263 error (_("Error converting executable filename to POSIX: %d."), errno
);
2266 len
= GetModuleFileNameEx (current_process_handle
,
2267 dh_buf
, exe_name_ret
, exe_name_max_len
);
2269 error (_("Error getting executable filename: %u."),
2270 (unsigned) GetLastError ());
2273 return 1; /* success */
2276 /* The pid_to_exec_file target_ops method for this platform. */
2279 windows_nat_target::pid_to_exec_file (int pid
)
2281 static char path
[__PMAX
];
2283 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2285 char procexe
[sizeof ("/proc/4294967295/exe")];
2287 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2288 nchars
= readlink (procexe
, path
, sizeof(path
));
2289 if (nchars
> 0 && nchars
< sizeof (path
))
2291 path
[nchars
] = '\0'; /* Got it */
2296 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2297 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2298 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2304 /* Print status information about what we're accessing. */
2307 windows_nat_target::files_info ()
2309 struct inferior
*inf
= current_inferior ();
2311 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2312 inf
->attach_flag
? "attached" : "child",
2313 target_pid_to_str (inferior_ptid
).c_str ());
2316 /* Modify CreateProcess parameters for use of a new separate console.
2318 *FLAGS: DWORD parameter for general process creation flags.
2319 *SI: STARTUPINFO structure, for which the console window size and
2320 console buffer size is filled in if GDB is running in a console.
2321 to create the new console.
2322 The size of the used font is not available on all versions of
2323 Windows OS. Furthermore, the current font might not be the default
2324 font, but this is still better than before.
2325 If the windows and buffer sizes are computed,
2326 SI->DWFLAGS is changed so that this information is used
2327 by CreateProcess function. */
2330 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2332 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2333 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2335 if (hconsole
!= INVALID_HANDLE_VALUE
)
2337 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2339 CONSOLE_FONT_INFO cfi
;
2341 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2342 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2343 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2344 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2345 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2347 si
->dwXSize
*= font_size
.X
;
2351 si
->dwYSize
*= font_size
.Y
;
2354 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2355 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2356 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2358 *flags
|= CREATE_NEW_CONSOLE
;
2362 /* Function called by qsort to sort environment strings. */
2365 envvar_cmp (const void *a
, const void *b
)
2367 const char **p
= (const char **) a
;
2368 const char **q
= (const char **) b
;
2369 return strcasecmp (*p
, *q
);
2375 clear_win32_environment (char **env
)
2379 wchar_t *copy
= NULL
, *equalpos
;
2381 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2383 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2384 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2385 mbstowcs (copy
, env
[i
], len
);
2386 equalpos
= wcschr (copy
, L
'=');
2389 SetEnvironmentVariableW (copy
, NULL
);
2397 /* Redirection of inferior I/O streams for native MS-Windows programs.
2398 Unlike on Unix, where this is handled by invoking the inferior via
2399 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2401 The official documentation of the cmd.exe redirection features is here:
2403 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2405 (That page talks about Windows XP, but there's no newer
2406 documentation, so we assume later versions of cmd.exe didn't change
2409 Caveat: the documentation on that page seems to include a few lies.
2410 For example, it describes strange constructs 1<&2 and 2<&1, which
2411 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2412 think the cmd.exe parser of the redirection symbols simply doesn't
2413 care about the < vs > distinction in these cases. Therefore, the
2414 supported features are explicitly documented below.
2416 The emulation below aims at supporting all the valid use cases
2417 supported by cmd.exe, which include:
2419 < FILE redirect standard input from FILE
2420 0< FILE redirect standard input from FILE
2421 <&N redirect standard input from file descriptor N
2422 0<&N redirect standard input from file descriptor N
2423 > FILE redirect standard output to FILE
2424 >> FILE append standard output to FILE
2425 1>> FILE append standard output to FILE
2426 >&N redirect standard output to file descriptor N
2427 1>&N redirect standard output to file descriptor N
2428 >>&N append standard output to file descriptor N
2429 1>>&N append standard output to file descriptor N
2430 2> FILE redirect standard error to FILE
2431 2>> FILE append standard error to FILE
2432 2>&N redirect standard error to file descriptor N
2433 2>>&N append standard error to file descriptor N
2435 Note that using N > 2 in the above construct is supported, but
2436 requires that the corresponding file descriptor be open by some
2437 means elsewhere or outside GDB. Also note that using ">&0" or
2438 "<&2" will generally fail, because the file descriptor redirected
2439 from is normally open in an incompatible mode (e.g., FD 0 is open
2440 for reading only). IOW, use of such tricks is not recommended;
2441 you are on your own.
2443 We do NOT support redirection of file descriptors above 2, as in
2444 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2445 that needs special handling in the startup code that MinGW
2446 doesn't have). Pipes are also not supported.
2448 As for invalid use cases, where the redirection contains some
2449 error, the emulation below will detect that and produce some
2450 error and/or failure. But the behavior in those cases is not
2451 bug-for-bug compatible with what cmd.exe does in those cases.
2452 That's because what cmd.exe does then is not well defined, and
2453 seems to be a side effect of the cmd.exe parsing of the command
2454 line more than anything else. For example, try redirecting to an
2455 invalid file name, as in "> foo:bar".
2457 There are also minor syntactic deviations from what cmd.exe does
2458 in some corner cases. For example, it doesn't support the likes
2459 of "> &foo" to mean redirect to file named literally "&foo"; we
2460 do support that here, because that, too, sounds like some issue
2461 with the cmd.exe parser. Another nicety is that we support
2462 redirection targets that use file names with forward slashes,
2463 something cmd.exe doesn't -- this comes in handy since GDB
2464 file-name completion can be used when typing the command line for
2467 /* Support routines for redirecting standard handles of the inferior. */
2469 /* Parse a single redirection spec, open/duplicate the specified
2470 file/fd, and assign the appropriate value to one of the 3 standard
2471 file descriptors. */
2473 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2475 int *fd
, ref_fd
= -2;
2477 const char *fname
= redir_string
+ 1;
2478 int rc
= *redir_string
;
2493 fd
= (rc
== '2') ? err
: out
;
2494 mode
= O_WRONLY
| O_CREAT
;
2507 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2509 /* A reference to a file descriptor. */
2511 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2512 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2514 /* Don't allow redirection when open modes are incompatible. */
2515 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2516 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2523 else if (ref_fd
== 1)
2525 else if (ref_fd
== 2)
2535 fname
++; /* skip the separator space */
2536 /* If the descriptor is already open, close it. This allows
2537 multiple specs of redirections for the same stream, which is
2538 somewhat nonsensical, but still valid and supported by cmd.exe.
2539 (But cmd.exe only opens a single file in this case, the one
2540 specified by the last redirection spec on the command line.) */
2545 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2549 else if (ref_fd
== -1)
2550 *fd
= -1; /* reset to default destination */
2553 *fd
= _dup (ref_fd
);
2557 /* _open just sets a flag for O_APPEND, which won't be passed to the
2558 inferior, so we need to actually move the file pointer. */
2559 if ((mode
& O_APPEND
) != 0)
2560 _lseek (*fd
, 0L, SEEK_END
);
2564 /* Canonicalize a single redirection spec and set up the corresponding
2565 file descriptor as specified. */
2567 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2569 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2571 const char *start
= s
;
2574 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2575 if ((*start
== '>' || *start
== '1' || *start
== '2')
2579 if (*s
== '>' && *start
!= '>')
2582 else if (*start
== '0' && *s
== '<')
2584 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2587 while (isspace (*s
)) /* skip whitespace before file name */
2589 *d
++ = ' '; /* separate file name with a single space */
2592 /* Copy the file name. */
2595 /* Remove quoting characters from the file name in buf[]. */
2596 if (*s
== '"') /* could support '..' quoting here */
2600 else if (*s
== quote
)
2608 else if (*s
== '\\')
2610 if (s
[1] == '"') /* could support '..' here */
2614 else if (isspace (*s
) && !quote
)
2618 if (d
- buf
>= sizeof (buf
) - 1)
2620 errno
= ENAMETOOLONG
;
2626 /* Windows doesn't allow redirection characters in file names, so we
2627 can bail out early if they use them, or if there's no target file
2628 name after the redirection symbol. */
2629 if (d
[-1] == '>' || d
[-1] == '<')
2634 if (redir_open (buf
, inp
, out
, err
) == 0)
2639 /* Parse the command line for redirection specs and prepare the file
2640 descriptors for the 3 standard streams accordingly. */
2642 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2643 int *inp
, int *out
, int *err
)
2645 const char *s
= cmd_orig
;
2648 bool retval
= false;
2650 while (isspace (*s
))
2655 if (*s
== '"') /* could also support '..' quoting here */
2659 else if (*s
== quote
)
2662 else if (*s
== '\\')
2664 if (s
[1] == '"') /* escaped quote char */
2669 /* Process a single redirection candidate. */
2670 if (*s
== '<' || *s
== '>'
2671 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2672 || (*s
== '0' && s
[1] == '<'))
2674 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2688 #endif /* !__CYGWIN__ */
2690 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2691 EXEC_FILE is the file to run.
2692 ALLARGS is a string containing the arguments to the program.
2693 ENV is the environment vector to pass. Errors reported with error(). */
2696 windows_nat_target::create_inferior (const char *exec_file
,
2697 const std::string
&origallargs
,
2698 char **in_env
, int from_tty
)
2702 cygwin_buf_t real_path
[__PMAX
];
2703 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2704 cygwin_buf_t infcwd
[__PMAX
];
2706 cygwin_buf_t
*toexec
;
2707 cygwin_buf_t
*cygallargs
;
2709 char **old_env
= NULL
;
2713 int ostdin
, ostdout
, ostderr
;
2714 #else /* !__CYGWIN__ */
2715 char shell
[__PMAX
]; /* Path to shell */
2717 char *args
, *allargs_copy
;
2718 size_t args_len
, allargs_len
;
2719 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2720 HANDLE tty
= INVALID_HANDLE_VALUE
;
2721 bool redirected
= false;
2728 #endif /* !__CYGWIN__ */
2729 const char *allargs
= origallargs
.c_str ();
2730 PROCESS_INFORMATION pi
;
2733 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2736 error (_("No executable specified, use `target exec'."));
2738 const char *inferior_cwd
= get_inferior_cwd ();
2739 std::string expanded_infcwd
;
2740 if (inferior_cwd
!= NULL
)
2742 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
2743 /* Mirror slashes on inferior's cwd. */
2744 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
2746 inferior_cwd
= expanded_infcwd
.c_str ();
2749 memset (&si
, 0, sizeof (si
));
2750 si
.cb
= sizeof (si
);
2753 flags
|= CREATE_NEW_PROCESS_GROUP
;
2756 windows_set_console_info (&si
, &flags
);
2761 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2762 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2763 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2764 error (_("Error starting executable: %d"), errno
);
2767 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2768 if (len
== (size_t) -1)
2769 error (_("Error starting executable: %d"), errno
);
2770 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2771 mbstowcs (cygallargs
, allargs
, len
);
2772 #else /* !__USEWIDE */
2773 cygallargs
= allargs
;
2779 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2780 error (_("Error starting executable via shell: %d"), errno
);
2782 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2783 + mbstowcs (NULL
, allargs
, 0) + 2;
2784 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2785 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2786 #else /* !__USEWIDE */
2787 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2788 + strlen (allargs
) + 2);
2789 cygallargs
= (char *) alloca (len
);
2790 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2791 #endif /* __USEWIDE */
2793 flags
|= DEBUG_PROCESS
;
2796 if (inferior_cwd
!= NULL
2797 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
2798 infcwd
, strlen (inferior_cwd
)) < 0)
2799 error (_("Error converting inferior cwd: %d"), errno
);
2802 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2803 * sizeof (wchar_t));
2804 wcscpy (args
, toexec
);
2805 wcscat (args
, L
" ");
2806 wcscat (args
, cygallargs
);
2807 #else /* !__USEWIDE */
2808 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2809 strcpy (args
, toexec
);
2811 strcat (args
, cygallargs
);
2812 #endif /* !__USEWIDE */
2814 #ifdef CW_CVT_ENV_TO_WINENV
2815 /* First try to create a direct Win32 copy of the POSIX environment. */
2816 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2817 if (w32_env
!= (PWCHAR
) -1)
2818 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2820 /* If that fails, fall back to old method tweaking GDB's environment. */
2821 #endif /* CW_CVT_ENV_TO_WINENV */
2823 /* Reset all Win32 environment variables to avoid leftover on next run. */
2824 clear_win32_environment (environ
);
2825 /* Prepare the environment vars for CreateProcess. */
2828 cygwin_internal (CW_SYNC_WINENV
);
2832 if (!inferior_io_terminal
)
2833 tty
= ostdin
= ostdout
= ostderr
= -1;
2836 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2839 print_sys_errmsg (inferior_io_terminal
, errno
);
2840 ostdin
= ostdout
= ostderr
= -1;
2853 windows_init_thread_list ();
2854 ret
= CreateProcess (0,
2855 args
, /* command line */
2856 NULL
, /* Security */
2858 TRUE
, /* inherit handles */
2859 flags
, /* start flags */
2860 w32_env
, /* environment */
2861 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
2866 /* Just free the Win32 environment, if it could be created. */
2870 /* Reset all environment variables to avoid leftover on next run. */
2871 clear_win32_environment (in_env
);
2872 /* Restore normal GDB environment variables. */
2874 cygwin_internal (CW_SYNC_WINENV
);
2887 #else /* !__CYGWIN__ */
2888 allargs_len
= strlen (allargs
);
2889 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
2890 if (strpbrk (allargs_copy
, "<>") != NULL
)
2895 redirect_inferior_handles (allargs
, allargs_copy
,
2896 &fd_inp
, &fd_out
, &fd_err
);
2898 warning (_("Error in redirection: %s."), safe_strerror (errno
));
2901 allargs_len
= strlen (allargs_copy
);
2903 /* If not all the standard streams are redirected by the command
2904 line, use inferior_io_terminal for those which aren't. */
2905 if (inferior_io_terminal
2906 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
2908 SECURITY_ATTRIBUTES sa
;
2909 sa
.nLength
= sizeof(sa
);
2910 sa
.lpSecurityDescriptor
= 0;
2911 sa
.bInheritHandle
= TRUE
;
2912 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2913 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2914 if (tty
== INVALID_HANDLE_VALUE
)
2915 warning (_("Warning: Failed to open TTY %s, error %#x."),
2916 inferior_io_terminal
, (unsigned) GetLastError ());
2918 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
2921 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
2922 else if (tty
!= INVALID_HANDLE_VALUE
)
2925 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
2927 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
2928 else if (tty
!= INVALID_HANDLE_VALUE
)
2929 si
.hStdOutput
= tty
;
2931 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
2933 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
2934 else if (tty
!= INVALID_HANDLE_VALUE
)
2937 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
2938 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2942 /* Build the command line, a space-separated list of tokens where
2943 the first token is the name of the module to be executed.
2944 To avoid ambiguities introduced by spaces in the module name,
2946 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
2947 args
= (char *) alloca (args_len
);
2948 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
2950 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2952 /* CreateProcess takes the environment list as a null terminated set of
2953 strings (i.e. two nulls terminate the list). */
2955 /* Get total size for env strings. */
2956 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2957 envlen
+= strlen (in_env
[i
]) + 1;
2959 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2960 env
= (char **) alloca (envsize
);
2961 memcpy (env
, in_env
, envsize
);
2962 /* Windows programs expect the environment block to be sorted. */
2963 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2965 w32env
= (char *) alloca (envlen
+ 1);
2967 /* Copy env strings into new buffer. */
2968 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2970 strcpy (temp
, env
[i
]);
2971 temp
+= strlen (temp
) + 1;
2974 /* Final nil string to terminate new env. */
2977 windows_init_thread_list ();
2978 ret
= CreateProcessA (0,
2979 args
, /* command line */
2980 NULL
, /* Security */
2982 TRUE
, /* inherit handles */
2983 flags
, /* start flags */
2984 w32env
, /* environment */
2985 inferior_cwd
, /* current directory */
2988 if (tty
!= INVALID_HANDLE_VALUE
)
2996 #endif /* !__CYGWIN__ */
2999 error (_("Error creating process %s, (error %u)."),
3000 exec_file
, (unsigned) GetLastError ());
3004 if (IsWow64Process (pi
.hProcess
, &wow64
))
3005 wow64_process
= wow64
;
3008 CloseHandle (pi
.hThread
);
3009 CloseHandle (pi
.hProcess
);
3011 if (useshell
&& shell
[0] != '\0')
3016 do_initial_windows_stuff (pi
.dwProcessId
, 0);
3018 /* windows_continue (DBG_CONTINUE, -1, 0); */
3022 windows_nat_target::mourn_inferior ()
3024 (void) windows_continue (DBG_CONTINUE
, -1, 0);
3025 x86_cleanup_dregs();
3026 if (open_process_used
)
3028 CHECK (CloseHandle (current_process_handle
));
3029 open_process_used
= 0;
3031 siginfo_er
.ExceptionCode
= 0;
3032 inf_child_target::mourn_inferior ();
3035 /* Send a SIGINT to the process group. This acts just like the user typed a
3036 ^C on the controlling terminal. */
3039 windows_nat_target::interrupt ()
3041 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
3042 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
3043 registers_changed (); /* refresh register state */
3046 /* Helper for windows_xfer_partial that handles memory transfers.
3047 Arguments are like target_xfer_partial. */
3049 static enum target_xfer_status
3050 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3051 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
3055 DWORD lasterror
= 0;
3057 if (writebuf
!= NULL
)
3059 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
3060 pulongest (len
), core_addr_to_string (memaddr
)));
3061 success
= WriteProcessMemory (current_process_handle
,
3062 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
3065 lasterror
= GetLastError ();
3066 FlushInstructionCache (current_process_handle
,
3067 (LPCVOID
) (uintptr_t) memaddr
, len
);
3071 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
3072 pulongest (len
), core_addr_to_string (memaddr
)));
3073 success
= ReadProcessMemory (current_process_handle
,
3074 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
3077 lasterror
= GetLastError ();
3079 *xfered_len
= (ULONGEST
) done
;
3080 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
3081 return TARGET_XFER_OK
;
3083 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
3087 windows_nat_target::kill ()
3089 CHECK (TerminateProcess (current_process_handle
, 0));
3093 if (!windows_continue (DBG_CONTINUE
, -1, 1))
3095 if (!wait_for_debug_event (¤t_event
, INFINITE
))
3097 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
3101 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
3105 windows_nat_target::close ()
3107 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
3108 inferior_ptid
.pid ()));
3111 /* Convert pid to printable format. */
3113 windows_nat_target::pid_to_str (ptid_t ptid
)
3115 if (ptid
.lwp () != 0)
3116 return string_printf ("Thread %d.0x%lx", ptid
.pid (), ptid
.lwp ());
3118 return normal_pid_to_str (ptid
);
3121 static enum target_xfer_status
3122 windows_xfer_shared_libraries (struct target_ops
*ops
,
3123 enum target_object object
, const char *annex
,
3124 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3125 ULONGEST offset
, ULONGEST len
,
3126 ULONGEST
*xfered_len
)
3128 struct obstack obstack
;
3134 return TARGET_XFER_E_IO
;
3136 obstack_init (&obstack
);
3137 obstack_grow_str (&obstack
, "<library-list>\n");
3138 for (so
= solib_start
.next
; so
; so
= so
->next
)
3140 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
3142 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
3143 (uintptr_t) li
->load_addr
,
3145 target_gdbarch (), &obstack
);
3147 obstack_grow_str0 (&obstack
, "</library-list>\n");
3149 buf
= (const char *) obstack_finish (&obstack
);
3150 len_avail
= strlen (buf
);
3151 if (offset
>= len_avail
)
3155 if (len
> len_avail
- offset
)
3156 len
= len_avail
- offset
;
3157 memcpy (readbuf
, buf
+ offset
, len
);
3160 obstack_free (&obstack
, NULL
);
3161 *xfered_len
= (ULONGEST
) len
;
3162 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
3165 /* Helper for windows_nat_target::xfer_partial that handles signal info. */
3167 static enum target_xfer_status
3168 windows_xfer_siginfo (gdb_byte
*readbuf
, ULONGEST offset
, ULONGEST len
,
3169 ULONGEST
*xfered_len
)
3171 char *buf
= (char *) &siginfo_er
;
3172 size_t bufsize
= sizeof (siginfo_er
);
3175 EXCEPTION_RECORD32 er32
;
3178 buf
= (char *) &er32
;
3179 bufsize
= sizeof (er32
);
3181 er32
.ExceptionCode
= siginfo_er
.ExceptionCode
;
3182 er32
.ExceptionFlags
= siginfo_er
.ExceptionFlags
;
3183 er32
.ExceptionRecord
= (uintptr_t) siginfo_er
.ExceptionRecord
;
3184 er32
.ExceptionAddress
= (uintptr_t) siginfo_er
.ExceptionAddress
;
3185 er32
.NumberParameters
= siginfo_er
.NumberParameters
;
3187 for (i
= 0; i
< EXCEPTION_MAXIMUM_PARAMETERS
; i
++)
3188 er32
.ExceptionInformation
[i
] = siginfo_er
.ExceptionInformation
[i
];
3192 if (siginfo_er
.ExceptionCode
== 0)
3193 return TARGET_XFER_E_IO
;
3195 if (readbuf
== nullptr)
3196 return TARGET_XFER_E_IO
;
3198 if (offset
> bufsize
)
3199 return TARGET_XFER_E_IO
;
3201 if (offset
+ len
> bufsize
)
3202 len
= bufsize
- offset
;
3204 memcpy (readbuf
, buf
+ offset
, len
);
3207 return TARGET_XFER_OK
;
3210 enum target_xfer_status
3211 windows_nat_target::xfer_partial (enum target_object object
,
3212 const char *annex
, gdb_byte
*readbuf
,
3213 const gdb_byte
*writebuf
, ULONGEST offset
,
3214 ULONGEST len
, ULONGEST
*xfered_len
)
3218 case TARGET_OBJECT_MEMORY
:
3219 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
3221 case TARGET_OBJECT_LIBRARIES
:
3222 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
3223 writebuf
, offset
, len
, xfered_len
);
3225 case TARGET_OBJECT_SIGNAL_INFO
:
3226 return windows_xfer_siginfo (readbuf
, offset
, len
, xfered_len
);
3229 if (beneath () == NULL
)
3231 /* This can happen when requesting the transfer of unsupported
3232 objects before a program has been started (and therefore
3233 with the current_target having no target beneath). */
3234 return TARGET_XFER_E_IO
;
3236 return beneath ()->xfer_partial (object
, annex
,
3237 readbuf
, writebuf
, offset
, len
,
3242 /* Provide thread local base, i.e. Thread Information Block address.
3243 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
3246 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
3248 windows_thread_info
*th
;
3250 th
= thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
);
3255 *addr
= th
->thread_local_base
;
3261 windows_nat_target::get_ada_task_ptid (long lwp
, long thread
)
3263 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
3266 /* Implementation of the to_thread_name method. */
3269 windows_nat_target::thread_name (struct thread_info
*thr
)
3271 return thread_rec (thr
->ptid
, DONT_INVALIDATE_CONTEXT
)->name
.get ();
3275 void _initialize_windows_nat ();
3277 _initialize_windows_nat ()
3279 x86_dr_low
.set_control
= cygwin_set_dr7
;
3280 x86_dr_low
.set_addr
= cygwin_set_dr
;
3281 x86_dr_low
.get_addr
= cygwin_get_dr
;
3282 x86_dr_low
.get_status
= cygwin_get_dr6
;
3283 x86_dr_low
.get_control
= cygwin_get_dr7
;
3285 /* x86_dr_low.debug_register_length field is set by
3286 calling x86_set_debug_register_length function
3287 in processor windows specific native file. */
3289 add_inf_child_target (&the_windows_nat_target
);
3292 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3295 add_com ("signal-event", class_run
, signal_event_command
, _("\
3296 Signal a crashed process with event ID, to allow its debugging.\n\
3297 This command is needed in support of setting up GDB as JIT debugger on \
3298 MS-Windows. The command should be invoked from the GDB command line using \
3299 the '-ex' command-line option. The ID of the event that blocks the \
3300 crashed process will be supplied by the Windows JIT debugging mechanism."));
3303 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3304 Set use of shell to start subprocess."), _("\
3305 Show use of shell to start subprocess."), NULL
,
3307 NULL
, /* FIXME: i18n: */
3308 &setlist
, &showlist
);
3310 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3311 &cygwin_exceptions
, _("\
3312 Break when an exception is detected in the Cygwin DLL itself."), _("\
3313 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3315 NULL
, /* FIXME: i18n: */
3316 &setlist
, &showlist
);
3319 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3320 Set creation of new console when creating child process."), _("\
3321 Show creation of new console when creating child process."), NULL
,
3323 NULL
, /* FIXME: i18n: */
3324 &setlist
, &showlist
);
3326 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3327 Set creation of new group when creating child process."), _("\
3328 Show creation of new group when creating child process."), NULL
,
3330 NULL
, /* FIXME: i18n: */
3331 &setlist
, &showlist
);
3333 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3334 Set whether to display execution in child process."), _("\
3335 Show whether to display execution in child process."), NULL
,
3337 NULL
, /* FIXME: i18n: */
3338 &setlist
, &showlist
);
3340 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3341 Set whether to display kernel events in child process."), _("\
3342 Show whether to display kernel events in child process."), NULL
,
3344 NULL
, /* FIXME: i18n: */
3345 &setlist
, &showlist
);
3347 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3348 Set whether to display memory accesses in child process."), _("\
3349 Show whether to display memory accesses in child process."), NULL
,
3351 NULL
, /* FIXME: i18n: */
3352 &setlist
, &showlist
);
3354 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3355 &debug_exceptions
, _("\
3356 Set whether to display kernel exceptions in child process."), _("\
3357 Show whether to display kernel exceptions in child process."), NULL
,
3359 NULL
, /* FIXME: i18n: */
3360 &setlist
, &showlist
);
3362 init_w32_command_list ();
3364 add_cmd ("selector", class_info
, display_selectors
,
3365 _("Display selectors infos."),
3369 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3371 /* Pass the address ADDR to the inferior in the I'th debug register.
3372 Here we just store the address in dr array, the registers will be
3373 actually set up when windows_continue is called. */
3375 cygwin_set_dr (int i
, CORE_ADDR addr
)
3378 internal_error (__FILE__
, __LINE__
,
3379 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3381 debug_registers_changed
= 1;
3382 debug_registers_used
= 1;
3385 /* Pass the value VAL to the inferior in the DR7 debug control
3386 register. Here we just store the address in D_REGS, the watchpoint
3387 will be actually set up in windows_wait. */
3389 cygwin_set_dr7 (unsigned long val
)
3391 dr
[7] = (CORE_ADDR
) val
;
3392 debug_registers_changed
= 1;
3393 debug_registers_used
= 1;
3396 /* Get the value of debug register I from the inferior. */
3399 cygwin_get_dr (int i
)
3404 /* Get the value of the DR6 debug status register from the inferior.
3405 Here we just return the value stored in dr[6]
3406 by the last call to thread_rec for current_event.dwThreadId id. */
3407 static unsigned long
3408 cygwin_get_dr6 (void)
3410 return (unsigned long) dr
[6];
3413 /* Get the value of the DR7 debug status register from the inferior.
3414 Here we just return the value stored in dr[7] by the last call to
3415 thread_rec for current_event.dwThreadId id. */
3417 static unsigned long
3418 cygwin_get_dr7 (void)
3420 return (unsigned long) dr
[7];
3423 /* Determine if the thread referenced by "ptid" is alive
3424 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3425 it means that the thread has died. Otherwise it is assumed to be alive. */
3428 windows_nat_target::thread_alive (ptid_t ptid
)
3430 gdb_assert (ptid
.lwp () != 0);
3432 return (WaitForSingleObject (thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
)->h
, 0)
3436 void _initialize_check_for_gdb_ini ();
3438 _initialize_check_for_gdb_ini ()
3441 if (inhibit_gdbinit
)
3444 homedir
= getenv ("HOME");
3448 char *oldini
= (char *) alloca (strlen (homedir
) +
3449 sizeof ("gdb.ini") + 1);
3450 strcpy (oldini
, homedir
);
3451 p
= strchr (oldini
, '\0');
3452 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3454 strcpy (p
, "gdb.ini");
3455 if (access (oldini
, 0) == 0)
3457 int len
= strlen (oldini
);
3458 char *newini
= (char *) alloca (len
+ 2);
3460 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3461 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3462 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3467 /* Define dummy functions which always return error for the rare cases where
3468 these functions could not be found. */
3470 bad_DebugActiveProcessStop (DWORD w
)
3475 bad_DebugBreakProcess (HANDLE w
)
3480 bad_DebugSetProcessKillOnExit (BOOL w
)
3485 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3492 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3498 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3505 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3511 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3517 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3523 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3531 /* Load any functions which may not be available in ancient versions
3534 void _initialize_loadable ();
3536 _initialize_loadable ()
3540 #define GPA(m, func) \
3541 func = (func ## _ftype *) GetProcAddress (m, #func)
3543 hm
= LoadLibrary ("kernel32.dll");
3546 GPA (hm
, DebugActiveProcessStop
);
3547 GPA (hm
, DebugBreakProcess
);
3548 GPA (hm
, DebugSetProcessKillOnExit
);
3549 GPA (hm
, GetConsoleFontSize
);
3550 GPA (hm
, DebugActiveProcessStop
);
3551 GPA (hm
, GetCurrentConsoleFont
);
3553 GPA (hm
, Wow64SuspendThread
);
3554 GPA (hm
, Wow64GetThreadContext
);
3555 GPA (hm
, Wow64SetThreadContext
);
3556 GPA (hm
, Wow64GetThreadSelectorEntry
);
3560 /* Set variables to dummy versions of these processes if the function
3561 wasn't found in kernel32.dll. */
3562 if (!DebugBreakProcess
)
3563 DebugBreakProcess
= bad_DebugBreakProcess
;
3564 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3566 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3567 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3569 if (!GetConsoleFontSize
)
3570 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3571 if (!GetCurrentConsoleFont
)
3572 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3574 /* Load optional functions used for retrieving filename information
3575 associated with the currently debugged process or its dlls. */
3576 hm
= LoadLibrary ("psapi.dll");
3579 GPA (hm
, EnumProcessModules
);
3581 GPA (hm
, EnumProcessModulesEx
);
3583 GPA (hm
, GetModuleInformation
);
3584 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3585 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3588 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3590 /* Set variables to dummy versions of these processes if the function
3591 wasn't found in psapi.dll. */
3592 EnumProcessModules
= bad_EnumProcessModules
;
3593 GetModuleInformation
= bad_GetModuleInformation
;
3594 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3595 /* This will probably fail on Windows 9x/Me. Let the user know
3596 that we're missing some functionality. */
3598 cannot automatically find executable file or library to read symbols.\n\
3599 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3602 hm
= LoadLibrary ("advapi32.dll");
3605 GPA (hm
, OpenProcessToken
);
3606 GPA (hm
, LookupPrivilegeValueA
);
3607 GPA (hm
, AdjustTokenPrivileges
);
3608 /* Only need to set one of these since if OpenProcessToken fails nothing
3610 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3611 || !AdjustTokenPrivileges
)
3612 OpenProcessToken
= bad_OpenProcessToken
;