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) printf_unfiltered x
221 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
222 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
223 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered 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;
238 static bool ignore_first_breakpoint
= false;
242 static bool new_console
= false;
244 static bool cygwin_exceptions
= false;
246 static bool new_group
= true;
247 static bool debug_exec
= false; /* show execution */
248 static bool debug_events
= false; /* show events from kernel */
249 static bool debug_memory
= false; /* show target memory accesses */
250 static bool debug_exceptions
= false; /* show target exceptions */
251 static bool useshell
= false; /* use shell for subprocesses */
253 /* This vector maps GDB's idea of a register's number into an offset
254 in the windows exception context vector.
256 It also contains the bit mask needed to load the register in question.
258 The contents of this table can only be computed by the units
259 that provide CPU-specific support for Windows native debugging.
260 These units should set the table by calling
261 windows_set_context_register_offsets.
263 One day we could read a reg, we could inspect the context we
264 already have loaded, if it doesn't have the bit set that we need,
265 we read that set of registers in using GetThreadContext. If the
266 context already contains what we need, we just unpack it. Then to
267 write a register, first we have to ensure that the context contains
268 the other regs of the group, and then we copy the info in and set
271 static const int *mappings
;
273 /* The function to use in order to determine whether a register is
274 a segment register or not. */
275 static segment_register_p_ftype
*segment_register_p
;
277 /* See windows_nat_target::resume to understand why this is commented
280 /* This vector maps the target's idea of an exception (extracted
281 from the DEBUG_EVENT structure) to GDB's idea. */
283 struct xlate_exception
289 static const struct xlate_exception xlate
[] =
291 {EXCEPTION_ACCESS_VIOLATION
, GDB_SIGNAL_SEGV
},
292 {STATUS_STACK_OVERFLOW
, GDB_SIGNAL_SEGV
},
293 {EXCEPTION_BREAKPOINT
, GDB_SIGNAL_TRAP
},
294 {DBG_CONTROL_C
, GDB_SIGNAL_INT
},
295 {EXCEPTION_SINGLE_STEP
, GDB_SIGNAL_TRAP
},
296 {STATUS_FLOAT_DIVIDE_BY_ZERO
, GDB_SIGNAL_FPE
}
301 struct windows_nat_target final
: public x86_nat_target
<inf_child_target
>
303 void close () override
;
305 void attach (const char *, int) override
;
307 bool attach_no_wait () override
310 void detach (inferior
*, int) override
;
312 void resume (ptid_t
, int , enum gdb_signal
) override
;
314 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
316 void fetch_registers (struct regcache
*, int) override
;
317 void store_registers (struct regcache
*, int) override
;
319 bool stopped_by_sw_breakpoint () override
321 return current_windows_thread
->stopped_at_software_breakpoint
;
324 bool supports_stopped_by_sw_breakpoint () override
329 enum target_xfer_status
xfer_partial (enum target_object object
,
332 const gdb_byte
*writebuf
,
333 ULONGEST offset
, ULONGEST len
,
334 ULONGEST
*xfered_len
) override
;
336 void files_info () override
;
338 void kill () override
;
340 void create_inferior (const char *, const std::string
&,
341 char **, int) override
;
343 void mourn_inferior () override
;
345 bool thread_alive (ptid_t ptid
) override
;
347 std::string
pid_to_str (ptid_t
) override
;
349 void interrupt () override
;
351 char *pid_to_exec_file (int pid
) override
;
353 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
355 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
357 const char *thread_name (struct thread_info
*) override
;
359 int get_windows_debug_event (int pid
, struct target_waitstatus
*ourstatus
);
362 static windows_nat_target the_windows_nat_target
;
364 /* Set the MAPPINGS static global to OFFSETS.
365 See the description of MAPPINGS for more details. */
368 windows_set_context_register_offsets (const int *offsets
)
373 /* Set the function that should be used by this module to determine
374 whether a given register is a segment register or not. */
377 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
379 segment_register_p
= fun
;
383 check (BOOL ok
, const char *file
, int line
)
386 printf_filtered ("error return %s:%d was %u\n", file
, line
,
387 (unsigned) GetLastError ());
390 /* See nat/windows-nat.h. */
392 windows_thread_info
*
393 windows_nat::thread_rec (ptid_t ptid
, thread_disposition_type disposition
)
395 for (windows_thread_info
*th
: thread_list
)
396 if (th
->tid
== ptid
.lwp ())
402 case DONT_INVALIDATE_CONTEXT
:
405 case INVALIDATE_CONTEXT
:
406 if (ptid
.lwp () != current_event
.dwThreadId
)
408 th
->reload_context
= true;
411 th
->reload_context
= true;
422 /* Add a thread to the thread list.
424 PTID is the ptid of the thread to be added.
425 H is its Windows handle.
426 TLB is its thread local base.
427 MAIN_THREAD_P should be true if the thread to be added is
428 the main thread, false otherwise. */
430 static windows_thread_info
*
431 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
, bool main_thread_p
)
433 windows_thread_info
*th
;
435 gdb_assert (ptid
.lwp () != 0);
437 if ((th
= thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
)))
440 CORE_ADDR base
= (CORE_ADDR
) (uintptr_t) tlb
;
442 /* For WOW64 processes, this is actually the pointer to the 64bit TIB,
443 and the 32bit TIB is exactly 2 pages after it. */
447 th
= new windows_thread_info (ptid
.lwp (), h
, base
);
448 thread_list
.push_back (th
);
450 /* Add this new thread to the list of threads.
452 To be consistent with what's done on other platforms, we add
453 the main thread silently (in reality, this thread is really
454 more of a process to the user than a thread). */
456 add_thread_silent (&the_windows_nat_target
, ptid
);
458 add_thread (&the_windows_nat_target
, ptid
);
460 /* Set the debug registers for the new thread if they are used. */
461 if (debug_registers_used
)
466 /* Only change the value of the debug registers. */
467 th
->wow64_context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
468 CHECK (Wow64GetThreadContext (th
->h
, &th
->wow64_context
));
469 th
->wow64_context
.Dr0
= dr
[0];
470 th
->wow64_context
.Dr1
= dr
[1];
471 th
->wow64_context
.Dr2
= dr
[2];
472 th
->wow64_context
.Dr3
= dr
[3];
473 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
474 th
->wow64_context
.Dr7
= dr
[7];
475 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
476 th
->wow64_context
.ContextFlags
= 0;
481 /* Only change the value of the debug registers. */
482 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
483 CHECK (GetThreadContext (th
->h
, &th
->context
));
484 th
->context
.Dr0
= dr
[0];
485 th
->context
.Dr1
= dr
[1];
486 th
->context
.Dr2
= dr
[2];
487 th
->context
.Dr3
= dr
[3];
488 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
489 th
->context
.Dr7
= dr
[7];
490 CHECK (SetThreadContext (th
->h
, &th
->context
));
491 th
->context
.ContextFlags
= 0;
497 /* Clear out any old thread list and reinitialize it to a
500 windows_init_thread_list (void)
502 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
505 for (windows_thread_info
*here
: thread_list
)
508 thread_list
.clear ();
511 /* Delete a thread from the list of threads.
513 PTID is the ptid of the thread to be deleted.
514 EXIT_CODE is the thread's exit code.
515 MAIN_THREAD_P should be true if the thread to be deleted is
516 the main thread, false otherwise. */
519 windows_delete_thread (ptid_t ptid
, DWORD exit_code
, bool main_thread_p
)
523 gdb_assert (ptid
.lwp () != 0);
527 /* Emit a notification about the thread being deleted.
529 Note that no notification was printed when the main thread
530 was created, and thus, unless in verbose mode, we should be
531 symmetrical, and avoid that notification for the main thread
535 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
).c_str ());
536 else if (print_thread_events
&& !main_thread_p
)
537 printf_unfiltered (_("[%s exited with code %u]\n"),
538 target_pid_to_str (ptid
).c_str (),
539 (unsigned) exit_code
);
541 delete_thread (find_thread_ptid (&the_windows_nat_target
, ptid
));
543 auto iter
= std::find_if (thread_list
.begin (), thread_list
.end (),
544 [=] (windows_thread_info
*th
)
546 return th
->tid
== id
;
549 if (iter
!= thread_list
.end ())
552 thread_list
.erase (iter
);
556 /* Fetches register number R from the given windows_thread_info,
557 and supplies its value to the given regcache.
559 This function assumes that R is non-negative. A failed assertion
560 is raised if that is not true.
562 This function assumes that TH->RELOAD_CONTEXT is not set, meaning
563 that the windows_thread_info has an up-to-date context. A failed
564 assertion is raised if that assumption is violated. */
567 windows_fetch_one_register (struct regcache
*regcache
,
568 windows_thread_info
*th
, int r
)
571 gdb_assert (!th
->reload_context
);
573 char *context_ptr
= (char *) &th
->context
;
576 context_ptr
= (char *) &th
->wow64_context
;
579 char *context_offset
= context_ptr
+ mappings
[r
];
580 struct gdbarch
*gdbarch
= regcache
->arch ();
581 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
583 gdb_assert (!gdbarch_read_pc_p (gdbarch
));
584 gdb_assert (gdbarch_pc_regnum (gdbarch
) >= 0);
585 gdb_assert (!gdbarch_write_pc_p (gdbarch
));
587 if (r
== I387_FISEG_REGNUM (tdep
))
589 long l
= *((long *) context_offset
) & 0xffff;
590 regcache
->raw_supply (r
, (char *) &l
);
592 else if (r
== I387_FOP_REGNUM (tdep
))
594 long l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
595 regcache
->raw_supply (r
, (char *) &l
);
597 else if (segment_register_p (r
))
599 /* GDB treats segment registers as 32bit registers, but they are
600 in fact only 16 bits long. Make sure we do not read extra
601 bits from our source buffer. */
602 long l
= *((long *) context_offset
) & 0xffff;
603 regcache
->raw_supply (r
, (char *) &l
);
607 if (th
->stopped_at_software_breakpoint
608 && r
== gdbarch_pc_regnum (gdbarch
))
610 int size
= register_size (gdbarch
, r
);
614 memcpy (&value
, context_offset
, size
);
615 value
-= gdbarch_decr_pc_after_break (gdbarch
);
616 memcpy (context_offset
, &value
, size
);
620 gdb_assert (size
== 8);
622 memcpy (&value
, context_offset
, size
);
623 value
-= gdbarch_decr_pc_after_break (gdbarch
);
624 memcpy (context_offset
, &value
, size
);
627 regcache
->raw_supply (r
, context_offset
);
632 windows_nat_target::fetch_registers (struct regcache
*regcache
, int r
)
634 windows_thread_info
*th
= thread_rec (regcache
->ptid (), INVALIDATE_CONTEXT
);
636 /* Check if TH exists. Windows sometimes uses a non-existent
637 thread id in its events. */
641 if (th
->reload_context
)
644 if (have_saved_context
)
646 /* Lie about where the program actually is stopped since
647 cygwin has informed us that we should consider the signal
648 to have occurred at another location which is stored in
650 memcpy (&th
->context
, &saved_context
,
651 __COPY_CONTEXT_SIZE
);
652 have_saved_context
= 0;
659 th
->wow64_context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
660 CHECK (Wow64GetThreadContext (th
->h
, &th
->wow64_context
));
661 /* Copy dr values from that thread.
662 But only if there were not modified since last stop.
664 if (!debug_registers_changed
)
666 dr
[0] = th
->wow64_context
.Dr0
;
667 dr
[1] = th
->wow64_context
.Dr1
;
668 dr
[2] = th
->wow64_context
.Dr2
;
669 dr
[3] = th
->wow64_context
.Dr3
;
670 dr
[6] = th
->wow64_context
.Dr6
;
671 dr
[7] = th
->wow64_context
.Dr7
;
677 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
678 CHECK (GetThreadContext (th
->h
, &th
->context
));
679 /* Copy dr values from that thread.
680 But only if there were not modified since last stop.
682 if (!debug_registers_changed
)
684 dr
[0] = th
->context
.Dr0
;
685 dr
[1] = th
->context
.Dr1
;
686 dr
[2] = th
->context
.Dr2
;
687 dr
[3] = th
->context
.Dr3
;
688 dr
[6] = th
->context
.Dr6
;
689 dr
[7] = th
->context
.Dr7
;
692 th
->reload_context
= false;
696 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch()); r
++)
697 windows_fetch_one_register (regcache
, th
, r
);
699 windows_fetch_one_register (regcache
, th
, r
);
702 /* Collect the register number R from the given regcache, and store
703 its value into the corresponding area of the given thread's context.
705 This function assumes that R is non-negative. A failed assertion
706 assertion is raised if that is not true. */
709 windows_store_one_register (const struct regcache
*regcache
,
710 windows_thread_info
*th
, int r
)
714 char *context_ptr
= (char *) &th
->context
;
717 context_ptr
= (char *) &th
->wow64_context
;
720 regcache
->raw_collect (r
, context_ptr
+ mappings
[r
]);
723 /* Store a new register value into the context of the thread tied to
727 windows_nat_target::store_registers (struct regcache
*regcache
, int r
)
729 windows_thread_info
*th
= thread_rec (regcache
->ptid (), INVALIDATE_CONTEXT
);
731 /* Check if TH exists. Windows sometimes uses a non-existent
732 thread id in its events. */
737 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch ()); r
++)
738 windows_store_one_register (regcache
, th
, r
);
740 windows_store_one_register (regcache
, th
, r
);
743 /* Maintain a linked list of "so" information. */
744 struct lm_info_windows
: public lm_info_base
746 LPVOID load_addr
= 0;
747 CORE_ADDR text_offset
= 0;
750 static struct so_list solib_start
, *solib_end
;
752 static struct so_list
*
753 windows_make_so (const char *name
, LPVOID load_addr
)
760 WIN32_FIND_DATA w32_fd
;
761 HANDLE h
= FindFirstFile(name
, &w32_fd
);
763 if (h
== INVALID_HANDLE_VALUE
)
769 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
771 p
= strrchr (buf
, '\\');
774 SetCurrentDirectory (buf
);
775 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
776 SetCurrentDirectory (cwd
);
779 if (strcasecmp (buf
, "ntdll.dll") == 0)
781 GetSystemDirectory (buf
, sizeof (buf
));
782 strcat (buf
, "\\ntdll.dll");
785 cygwin_buf_t buf
[__PMAX
];
788 if (access (name
, F_OK
) != 0)
790 if (strcasecmp (name
, "ntdll.dll") == 0)
793 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
794 wcscat (buf
, L
"\\ntdll.dll");
798 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
799 strcat (buf
, "\\ntdll.dll");
804 so
= XCNEW (struct so_list
);
805 lm_info_windows
*li
= new lm_info_windows
;
807 li
->load_addr
= load_addr
;
808 strcpy (so
->so_original_name
, name
);
810 strcpy (so
->so_name
, buf
);
813 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
814 SO_NAME_MAX_PATH_SIZE
);
817 char *rname
= realpath (name
, NULL
);
818 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
820 strcpy (so
->so_name
, rname
);
824 error (_("dll path too long"));
826 /* Record cygwin1.dll .text start/end. */
827 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
828 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
830 asection
*text
= NULL
;
832 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386", -1));
837 if (bfd_check_format (abfd
.get (), bfd_object
))
838 text
= bfd_get_section_by_name (abfd
.get (), ".text");
843 /* The symbols in a dll are offset by 0x1000, which is the
844 offset from 0 of the first byte in an image - because of the
845 file header and the section alignment. */
846 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
848 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (text
);
855 /* See nat/windows-nat.h. */
858 windows_nat::handle_load_dll ()
860 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
861 const char *dll_name
;
863 /* Try getting the DLL name via the lpImageName field of the event.
864 Note that Microsoft documents this fields as strictly optional,
865 in the sense that it might be NULL. And the first DLL event in
866 particular is explicitly documented as "likely not pass[ed]"
867 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
868 dll_name
= get_image_name (current_process_handle
,
869 event
->lpImageName
, event
->fUnicode
);
873 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
874 solib_end
= solib_end
->next
;
876 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
878 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
879 host_address_to_string (li
->load_addr
)));
883 windows_free_so (struct so_list
*so
)
885 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
891 /* See nat/windows-nat.h. */
894 windows_nat::handle_unload_dll ()
896 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
899 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
901 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
903 if (li_next
->load_addr
== lpBaseOfDll
)
905 struct so_list
*sodel
= so
->next
;
907 so
->next
= sodel
->next
;
910 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
912 windows_free_so (sodel
);
917 /* We did not find any DLL that was previously loaded at this address,
918 so register a complaint. We do not report an error, because we have
919 observed that this may be happening under some circumstances. For
920 instance, running 32bit applications on x64 Windows causes us to receive
921 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
922 events are apparently caused by the WOW layer, the interface between
923 32bit and 64bit worlds). */
924 complaint (_("dll starting at %s not found."),
925 host_address_to_string (lpBaseOfDll
));
928 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
932 catch_errors (void (*func
) ())
938 catch (const gdb_exception
&ex
)
940 exception_print (gdb_stderr
, ex
);
944 /* Clear list of loaded DLLs. */
946 windows_clear_solib (void)
950 for (so
= solib_start
.next
; so
; so
= solib_start
.next
)
952 solib_start
.next
= so
->next
;
953 windows_free_so (so
);
956 solib_end
= &solib_start
;
960 signal_event_command (const char *args
, int from_tty
)
962 uintptr_t event_id
= 0;
963 char *endargs
= NULL
;
966 error (_("signal-event requires an argument (integer event id)"));
968 event_id
= strtoumax (args
, &endargs
, 10);
970 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
971 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
972 error (_("Failed to convert `%s' to event id"), args
);
974 SetEvent ((HANDLE
) event_id
);
975 CloseHandle ((HANDLE
) event_id
);
978 /* See nat/windows-nat.h. */
981 windows_nat::handle_output_debug_string (struct target_waitstatus
*ourstatus
)
983 gdb::unique_xmalloc_ptr
<char> s
;
986 if (!target_read_string
987 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
989 || !s
|| !*(s
.get ()))
991 else if (!startswith (s
.get (), _CYGWIN_SIGNAL_STRING
))
994 if (!startswith (s
.get (), "cYg"))
997 char *p
= strchr (s
.get (), '\0');
999 if (p
> s
.get () && *--p
== '\n')
1001 warning (("%s"), s
.get ());
1007 /* Got a cygwin signal marker. A cygwin signal is followed by
1008 the signal number itself and then optionally followed by the
1009 thread id and address to saved context within the DLL. If
1010 these are supplied, then the given thread is assumed to have
1011 issued the signal and the context from the thread is assumed
1012 to be stored at the given address in the inferior. Tell gdb
1013 to treat this like a real signal. */
1015 int sig
= strtol (s
.get () + sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
1016 gdb_signal gotasig
= gdb_signal_from_host (sig
);
1018 ourstatus
->value
.sig
= gotasig
;
1024 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1025 retval
= strtoul (p
, &p
, 0);
1027 retval
= current_event
.dwThreadId
;
1028 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
1029 && ReadProcessMemory (current_process_handle
, x
,
1031 __COPY_CONTEXT_SIZE
, &n
)
1032 && n
== __COPY_CONTEXT_SIZE
)
1033 have_saved_context
= 1;
1042 display_selector (HANDLE thread
, DWORD sel
)
1048 ret
= Wow64GetThreadSelectorEntry (thread
, sel
, &info
);
1051 ret
= GetThreadSelectorEntry (thread
, sel
, &info
);
1055 printf_filtered ("0x%03x: ", (unsigned) sel
);
1056 if (!info
.HighWord
.Bits
.Pres
)
1058 puts_filtered ("Segment not present\n");
1061 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1062 (info
.HighWord
.Bits
.BaseMid
<< 16)
1064 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1065 if (info
.HighWord
.Bits
.Granularity
)
1066 limit
= (limit
<< 12) | 0xfff;
1067 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1068 if (info
.HighWord
.Bits
.Default_Big
)
1069 puts_filtered(" 32-bit ");
1071 puts_filtered(" 16-bit ");
1072 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1075 puts_filtered ("Data (Read-Only, Exp-up");
1078 puts_filtered ("Data (Read/Write, Exp-up");
1081 puts_filtered ("Unused segment (");
1084 puts_filtered ("Data (Read/Write, Exp-down");
1087 puts_filtered ("Code (Exec-Only, N.Conf");
1090 puts_filtered ("Code (Exec/Read, N.Conf");
1093 puts_filtered ("Code (Exec-Only, Conf");
1096 puts_filtered ("Code (Exec/Read, Conf");
1099 printf_filtered ("Unknown type 0x%lx",
1100 (unsigned long) info
.HighWord
.Bits
.Type
);
1102 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1103 puts_filtered(", N.Acc");
1104 puts_filtered (")\n");
1105 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1106 puts_filtered("System selector ");
1107 printf_filtered ("Priviledge level = %ld. ",
1108 (unsigned long) info
.HighWord
.Bits
.Dpl
);
1109 if (info
.HighWord
.Bits
.Granularity
)
1110 puts_filtered ("Page granular.\n");
1112 puts_filtered ("Byte granular.\n");
1117 DWORD err
= GetLastError ();
1118 if (err
== ERROR_NOT_SUPPORTED
)
1119 printf_filtered ("Function not supported\n");
1121 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1127 display_selectors (const char * args
, int from_tty
)
1129 if (!current_windows_thread
)
1131 puts_filtered ("Impossible to display selectors now.\n");
1139 puts_filtered ("Selector $cs\n");
1140 display_selector (current_windows_thread
->h
,
1141 current_windows_thread
->wow64_context
.SegCs
);
1142 puts_filtered ("Selector $ds\n");
1143 display_selector (current_windows_thread
->h
,
1144 current_windows_thread
->wow64_context
.SegDs
);
1145 puts_filtered ("Selector $es\n");
1146 display_selector (current_windows_thread
->h
,
1147 current_windows_thread
->wow64_context
.SegEs
);
1148 puts_filtered ("Selector $ss\n");
1149 display_selector (current_windows_thread
->h
,
1150 current_windows_thread
->wow64_context
.SegSs
);
1151 puts_filtered ("Selector $fs\n");
1152 display_selector (current_windows_thread
->h
,
1153 current_windows_thread
->wow64_context
.SegFs
);
1154 puts_filtered ("Selector $gs\n");
1155 display_selector (current_windows_thread
->h
,
1156 current_windows_thread
->wow64_context
.SegGs
);
1161 puts_filtered ("Selector $cs\n");
1162 display_selector (current_windows_thread
->h
,
1163 current_windows_thread
->context
.SegCs
);
1164 puts_filtered ("Selector $ds\n");
1165 display_selector (current_windows_thread
->h
,
1166 current_windows_thread
->context
.SegDs
);
1167 puts_filtered ("Selector $es\n");
1168 display_selector (current_windows_thread
->h
,
1169 current_windows_thread
->context
.SegEs
);
1170 puts_filtered ("Selector $ss\n");
1171 display_selector (current_windows_thread
->h
,
1172 current_windows_thread
->context
.SegSs
);
1173 puts_filtered ("Selector $fs\n");
1174 display_selector (current_windows_thread
->h
,
1175 current_windows_thread
->context
.SegFs
);
1176 puts_filtered ("Selector $gs\n");
1177 display_selector (current_windows_thread
->h
,
1178 current_windows_thread
->context
.SegGs
);
1184 sel
= parse_and_eval_long (args
);
1185 printf_filtered ("Selector \"%s\"\n",args
);
1186 display_selector (current_windows_thread
->h
, sel
);
1190 /* See nat/windows-nat.h. */
1193 windows_nat::handle_ms_vc_exception (const EXCEPTION_RECORD
*rec
)
1195 if (rec
->NumberParameters
>= 3
1196 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1198 DWORD named_thread_id
;
1199 windows_thread_info
*named_thread
;
1200 CORE_ADDR thread_name_target
;
1202 thread_name_target
= rec
->ExceptionInformation
[1];
1203 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1205 if (named_thread_id
== (DWORD
) -1)
1206 named_thread_id
= current_event
.dwThreadId
;
1208 named_thread
= thread_rec (ptid_t (current_event
.dwProcessId
,
1209 named_thread_id
, 0),
1210 DONT_INVALIDATE_CONTEXT
);
1211 if (named_thread
!= NULL
)
1213 int thread_name_len
;
1214 gdb::unique_xmalloc_ptr
<char> thread_name
;
1216 thread_name_len
= target_read_string (thread_name_target
,
1217 &thread_name
, 1025, NULL
);
1218 if (thread_name_len
> 0)
1220 thread_name
.get ()[thread_name_len
- 1] = '\0';
1221 named_thread
->name
= std::move (thread_name
);
1231 /* Resume thread specified by ID, or all artificially suspended
1232 threads, if we are continuing execution. KILLED non-zero means we
1233 have killed the inferior, so we should ignore weird errors due to
1234 threads shutting down. */
1236 windows_continue (DWORD continue_status
, int id
, int killed
)
1240 desired_stop_thread_id
= id
;
1242 /* If there are pending stops, and we might plausibly hit one of
1243 them, we don't want to actually continue the inferior -- we just
1244 want to report the stop. In this case, we just pretend to
1245 continue. See the comment by the definition of "pending_stops"
1246 for details on why this is needed. */
1247 for (const auto &item
: pending_stops
)
1249 if (desired_stop_thread_id
== -1
1250 || desired_stop_thread_id
== item
.thread_id
)
1252 DEBUG_EVENTS (("windows_continue - pending stop anticipated, "
1253 "desired=0x%x, item=0x%x\n",
1254 desired_stop_thread_id
, item
.thread_id
));
1259 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1260 (unsigned) last_wait_event
.dwProcessId
,
1261 (unsigned) last_wait_event
.dwThreadId
,
1262 continue_status
== DBG_CONTINUE
?
1263 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1265 for (windows_thread_info
*th
: thread_list
)
1266 if (id
== -1 || id
== (int) th
->tid
)
1273 if (debug_registers_changed
)
1275 th
->wow64_context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1276 th
->wow64_context
.Dr0
= dr
[0];
1277 th
->wow64_context
.Dr1
= dr
[1];
1278 th
->wow64_context
.Dr2
= dr
[2];
1279 th
->wow64_context
.Dr3
= dr
[3];
1280 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1281 th
->wow64_context
.Dr7
= dr
[7];
1283 if (th
->wow64_context
.ContextFlags
)
1287 if (GetExitCodeThread (th
->h
, &ec
)
1288 && ec
== STILL_ACTIVE
)
1290 BOOL status
= Wow64SetThreadContext (th
->h
,
1291 &th
->wow64_context
);
1296 th
->wow64_context
.ContextFlags
= 0;
1302 if (debug_registers_changed
)
1304 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1305 th
->context
.Dr0
= dr
[0];
1306 th
->context
.Dr1
= dr
[1];
1307 th
->context
.Dr2
= dr
[2];
1308 th
->context
.Dr3
= dr
[3];
1309 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1310 th
->context
.Dr7
= dr
[7];
1312 if (th
->context
.ContextFlags
)
1316 if (GetExitCodeThread (th
->h
, &ec
)
1317 && ec
== STILL_ACTIVE
)
1319 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1324 th
->context
.ContextFlags
= 0;
1331 /* When single-stepping a specific thread, other threads must
1336 res
= ContinueDebugEvent (last_wait_event
.dwProcessId
,
1337 last_wait_event
.dwThreadId
,
1341 error (_("Failed to resume program execution"
1342 " (ContinueDebugEvent failed, error %u)"),
1343 (unsigned int) GetLastError ());
1345 debug_registers_changed
= 0;
1349 /* Called in pathological case where Windows fails to send a
1350 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1352 fake_create_process (void)
1354 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1355 current_event
.dwProcessId
);
1356 if (current_process_handle
!= NULL
)
1357 open_process_used
= 1;
1360 error (_("OpenProcess call failed, GetLastError = %u"),
1361 (unsigned) GetLastError ());
1362 /* We can not debug anything in that case. */
1364 current_windows_thread
1365 = windows_add_thread (ptid_t (current_event
.dwProcessId
,
1366 current_event
.dwThreadId
, 0),
1367 current_event
.u
.CreateThread
.hThread
,
1368 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1369 true /* main_thread_p */);
1370 return current_event
.dwThreadId
;
1374 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1376 windows_thread_info
*th
;
1377 DWORD continue_status
= DBG_CONTINUE
;
1379 /* A specific PTID means `step only this thread id'. */
1380 int resume_all
= ptid
== minus_one_ptid
;
1382 /* If we're continuing all threads, it's the current inferior that
1383 should be handled specially. */
1385 ptid
= inferior_ptid
;
1387 if (sig
!= GDB_SIGNAL_0
)
1389 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1391 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1393 else if (sig
== last_sig
)
1394 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1397 /* This code does not seem to work, because
1398 the kernel does probably not consider changes in the ExceptionRecord
1399 structure when passing the exception to the inferior.
1400 Note that this seems possible in the exception handler itself. */
1402 for (const xlate_exception
&x
: xlate
)
1405 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1407 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1410 if (continue_status
== DBG_CONTINUE
)
1412 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1416 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1420 last_sig
= GDB_SIGNAL_0
;
1422 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=0x%x, step=%d, sig=%d);\n",
1423 ptid
.pid (), (unsigned) ptid
.lwp (), step
, sig
));
1425 /* Get context for currently selected thread. */
1426 th
= thread_rec (inferior_ptid
, DONT_INVALIDATE_CONTEXT
);
1434 /* Single step by setting t bit. */
1435 struct regcache
*regcache
= get_current_regcache ();
1436 struct gdbarch
*gdbarch
= regcache
->arch ();
1437 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1438 th
->wow64_context
.EFlags
|= FLAG_TRACE_BIT
;
1441 if (th
->wow64_context
.ContextFlags
)
1443 if (debug_registers_changed
)
1445 th
->wow64_context
.Dr0
= dr
[0];
1446 th
->wow64_context
.Dr1
= dr
[1];
1447 th
->wow64_context
.Dr2
= dr
[2];
1448 th
->wow64_context
.Dr3
= dr
[3];
1449 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1450 th
->wow64_context
.Dr7
= dr
[7];
1452 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
1453 th
->wow64_context
.ContextFlags
= 0;
1461 /* Single step by setting t bit. */
1462 struct regcache
*regcache
= get_current_regcache ();
1463 struct gdbarch
*gdbarch
= regcache
->arch ();
1464 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1465 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1468 if (th
->context
.ContextFlags
)
1470 if (debug_registers_changed
)
1472 th
->context
.Dr0
= dr
[0];
1473 th
->context
.Dr1
= dr
[1];
1474 th
->context
.Dr2
= dr
[2];
1475 th
->context
.Dr3
= dr
[3];
1476 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1477 th
->context
.Dr7
= dr
[7];
1479 CHECK (SetThreadContext (th
->h
, &th
->context
));
1480 th
->context
.ContextFlags
= 0;
1485 /* Allow continuing with the same signal that interrupted us.
1486 Otherwise complain. */
1489 windows_continue (continue_status
, -1, 0);
1491 windows_continue (continue_status
, ptid
.lwp (), 0);
1494 /* Ctrl-C handler used when the inferior is not run in the same console. The
1495 handler is in charge of interrupting the inferior using DebugBreakProcess.
1496 Note that this function is not available prior to Windows XP. In this case
1497 we emit a warning. */
1499 ctrl_c_handler (DWORD event_type
)
1501 const int attach_flag
= current_inferior ()->attach_flag
;
1503 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1504 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1507 /* If the inferior and the debugger share the same console, do nothing as
1508 the inferior has also received the Ctrl-C event. */
1509 if (!new_console
&& !attach_flag
)
1512 if (!DebugBreakProcess (current_process_handle
))
1513 warning (_("Could not interrupt program. "
1514 "Press Ctrl-c in the program console."));
1516 /* Return true to tell that Ctrl-C has been handled. */
1520 /* A wrapper for WaitForDebugEvent that sets "last_wait_event"
1523 wait_for_debug_event (DEBUG_EVENT
*event
, DWORD timeout
)
1525 BOOL result
= WaitForDebugEvent (event
, timeout
);
1527 last_wait_event
= *event
;
1531 /* Get the next event from the child. Returns a non-zero thread id if the event
1532 requires handling by WFI (or whatever). */
1535 windows_nat_target::get_windows_debug_event (int pid
,
1536 struct target_waitstatus
*ourstatus
)
1539 DWORD continue_status
, event_code
;
1540 windows_thread_info
*th
;
1541 static windows_thread_info
dummy_thread_info (0, 0, 0);
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 for (auto iter
= pending_stops
.begin ();
1548 iter
!= pending_stops
.end ();
1551 if (desired_stop_thread_id
== -1
1552 || desired_stop_thread_id
== iter
->thread_id
)
1554 thread_id
= iter
->thread_id
;
1555 *ourstatus
= iter
->status
;
1556 current_event
= iter
->event
;
1558 inferior_ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1559 current_windows_thread
= thread_rec (inferior_ptid
,
1560 INVALIDATE_CONTEXT
);
1561 current_windows_thread
->reload_context
= 1;
1563 DEBUG_EVENTS (("get_windows_debug_event - "
1564 "pending stop found in 0x%x (desired=0x%x)\n",
1565 thread_id
, desired_stop_thread_id
));
1567 pending_stops
.erase (iter
);
1572 last_sig
= GDB_SIGNAL_0
;
1574 if (!(debug_event
= wait_for_debug_event (¤t_event
, 1000)))
1577 continue_status
= DBG_CONTINUE
;
1579 event_code
= current_event
.dwDebugEventCode
;
1580 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1582 have_saved_context
= 0;
1586 case CREATE_THREAD_DEBUG_EVENT
:
1587 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1588 (unsigned) current_event
.dwProcessId
,
1589 (unsigned) current_event
.dwThreadId
,
1590 "CREATE_THREAD_DEBUG_EVENT"));
1591 if (saw_create
!= 1)
1593 inferior
*inf
= find_inferior_pid (this, current_event
.dwProcessId
);
1594 if (!saw_create
&& inf
->attach_flag
)
1596 /* Kludge around a Windows bug where first event is a create
1597 thread event. Caused when attached process does not have
1599 thread_id
= fake_create_process ();
1605 /* Record the existence of this thread. */
1606 thread_id
= current_event
.dwThreadId
;
1607 th
= windows_add_thread
1608 (ptid_t (current_event
.dwProcessId
, current_event
.dwThreadId
, 0),
1609 current_event
.u
.CreateThread
.hThread
,
1610 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1611 false /* main_thread_p */);
1615 case EXIT_THREAD_DEBUG_EVENT
:
1616 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1617 (unsigned) current_event
.dwProcessId
,
1618 (unsigned) current_event
.dwThreadId
,
1619 "EXIT_THREAD_DEBUG_EVENT"));
1620 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1621 current_event
.dwThreadId
, 0),
1622 current_event
.u
.ExitThread
.dwExitCode
,
1623 false /* main_thread_p */);
1624 th
= &dummy_thread_info
;
1627 case CREATE_PROCESS_DEBUG_EVENT
:
1628 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1629 (unsigned) current_event
.dwProcessId
,
1630 (unsigned) current_event
.dwThreadId
,
1631 "CREATE_PROCESS_DEBUG_EVENT"));
1632 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1633 if (++saw_create
!= 1)
1636 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1637 /* Add the main thread. */
1638 th
= windows_add_thread
1639 (ptid_t (current_event
.dwProcessId
,
1640 current_event
.dwThreadId
, 0),
1641 current_event
.u
.CreateProcessInfo
.hThread
,
1642 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
,
1643 true /* main_thread_p */);
1644 thread_id
= current_event
.dwThreadId
;
1647 case EXIT_PROCESS_DEBUG_EVENT
:
1648 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1649 (unsigned) current_event
.dwProcessId
,
1650 (unsigned) current_event
.dwThreadId
,
1651 "EXIT_PROCESS_DEBUG_EVENT"));
1652 if (!windows_initialization_done
)
1654 target_terminal::ours ();
1655 target_mourn_inferior (inferior_ptid
);
1656 error (_("During startup program exited with code 0x%x."),
1657 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1659 else if (saw_create
== 1)
1661 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1662 current_event
.dwThreadId
, 0),
1663 0, true /* main_thread_p */);
1664 DWORD exit_status
= current_event
.u
.ExitProcess
.dwExitCode
;
1665 /* If the exit status looks like a fatal exception, but we
1666 don't recognize the exception's code, make the original
1667 exit status value available, to avoid losing
1670 = WIFSIGNALED (exit_status
) ? WTERMSIG (exit_status
) : -1;
1671 if (exit_signal
== -1)
1673 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1674 ourstatus
->value
.integer
= exit_status
;
1678 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1679 ourstatus
->value
.sig
= gdb_signal_from_host (exit_signal
);
1681 thread_id
= current_event
.dwThreadId
;
1685 case LOAD_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 "LOAD_DLL_DEBUG_EVENT"));
1690 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1691 if (saw_create
!= 1 || ! windows_initialization_done
)
1693 catch_errors (handle_load_dll
);
1694 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1695 ourstatus
->value
.integer
= 0;
1696 thread_id
= current_event
.dwThreadId
;
1699 case UNLOAD_DLL_DEBUG_EVENT
:
1700 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1701 (unsigned) current_event
.dwProcessId
,
1702 (unsigned) current_event
.dwThreadId
,
1703 "UNLOAD_DLL_DEBUG_EVENT"));
1704 if (saw_create
!= 1 || ! windows_initialization_done
)
1706 catch_errors (handle_unload_dll
);
1707 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1708 ourstatus
->value
.integer
= 0;
1709 thread_id
= current_event
.dwThreadId
;
1712 case EXCEPTION_DEBUG_EVENT
:
1713 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1714 (unsigned) current_event
.dwProcessId
,
1715 (unsigned) current_event
.dwThreadId
,
1716 "EXCEPTION_DEBUG_EVENT"));
1717 if (saw_create
!= 1)
1719 switch (handle_exception (ourstatus
, debug_exceptions
))
1721 case HANDLE_EXCEPTION_UNHANDLED
:
1723 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1725 case HANDLE_EXCEPTION_HANDLED
:
1726 thread_id
= current_event
.dwThreadId
;
1728 case HANDLE_EXCEPTION_IGNORED
:
1729 continue_status
= DBG_CONTINUE
;
1734 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1735 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1736 (unsigned) current_event
.dwProcessId
,
1737 (unsigned) current_event
.dwThreadId
,
1738 "OUTPUT_DEBUG_STRING_EVENT"));
1739 if (saw_create
!= 1)
1741 thread_id
= handle_output_debug_string (ourstatus
);
1745 if (saw_create
!= 1)
1747 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1748 (unsigned) current_event
.dwProcessId
,
1749 (unsigned) current_event
.dwThreadId
);
1750 printf_unfiltered (" unknown event code %u\n",
1751 (unsigned) current_event
.dwDebugEventCode
);
1755 if (!thread_id
|| saw_create
!= 1)
1757 CHECK (windows_continue (continue_status
, desired_stop_thread_id
, 0));
1759 else if (desired_stop_thread_id
!= -1 && desired_stop_thread_id
!= thread_id
)
1761 /* Pending stop. See the comment by the definition of
1762 "pending_stops" for details on why this is needed. */
1763 DEBUG_EVENTS (("get_windows_debug_event - "
1764 "unexpected stop in 0x%x (expecting 0x%x)\n",
1765 thread_id
, desired_stop_thread_id
));
1767 if (current_event
.dwDebugEventCode
== EXCEPTION_DEBUG_EVENT
1768 && (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1769 == EXCEPTION_BREAKPOINT
)
1770 && windows_initialization_done
)
1772 ptid_t ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1773 th
= thread_rec (ptid
, INVALIDATE_CONTEXT
);
1774 th
->stopped_at_software_breakpoint
= true;
1776 pending_stops
.push_back ({thread_id
, *ourstatus
, current_event
});
1778 CHECK (windows_continue (continue_status
, desired_stop_thread_id
, 0));
1782 inferior_ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1783 current_windows_thread
= th
;
1784 if (!current_windows_thread
)
1785 current_windows_thread
= thread_rec (inferior_ptid
,
1786 INVALIDATE_CONTEXT
);
1793 /* Wait for interesting events to occur in the target process. */
1795 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1800 /* We loop when we get a non-standard exception rather than return
1801 with a SPURIOUS because resume can try and step or modify things,
1802 which needs a current_thread->h. But some of these exceptions mark
1803 the birth or death of threads, which mean that the current thread
1804 isn't necessarily what you think it is. */
1810 /* If the user presses Ctrl-c while the debugger is waiting
1811 for an event, he expects the debugger to interrupt his program
1812 and to get the prompt back. There are two possible situations:
1814 - The debugger and the program do not share the console, in
1815 which case the Ctrl-c event only reached the debugger.
1816 In that case, the ctrl_c handler will take care of interrupting
1817 the inferior. Note that this case is working starting with
1818 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1821 - The debugger and the program share the same console, in which
1822 case both debugger and inferior will receive the Ctrl-c event.
1823 In that case the ctrl_c handler will ignore the event, as the
1824 Ctrl-c event generated inside the inferior will trigger the
1825 expected debug event.
1827 FIXME: brobecker/2008-05-20: If the inferior receives the
1828 signal first and the delay until GDB receives that signal
1829 is sufficiently long, GDB can sometimes receive the SIGINT
1830 after we have unblocked the CTRL+C handler. This would
1831 lead to the debugger stopping prematurely while handling
1832 the new-thread event that comes with the handling of the SIGINT
1833 inside the inferior, and then stop again immediately when
1834 the user tries to resume the execution in the inferior.
1835 This is a classic race that we should try to fix one day. */
1836 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1837 retval
= get_windows_debug_event (pid
, ourstatus
);
1838 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1842 ptid_t result
= ptid_t (current_event
.dwProcessId
, retval
, 0);
1844 if (current_windows_thread
!= nullptr)
1846 current_windows_thread
->stopped_at_software_breakpoint
= false;
1847 if (current_event
.dwDebugEventCode
== EXCEPTION_DEBUG_EVENT
1848 && (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1849 == EXCEPTION_BREAKPOINT
)
1850 && windows_initialization_done
)
1851 current_windows_thread
->stopped_at_software_breakpoint
= true;
1860 if (deprecated_ui_loop_hook
!= NULL
)
1861 detach
= deprecated_ui_loop_hook (0);
1869 /* Iterate over all DLLs currently mapped by our inferior, and
1870 add them to our list of solibs. */
1873 windows_add_all_dlls (void)
1875 HMODULE dummy_hmodule
;
1883 if (EnumProcessModulesEx (current_process_handle
, &dummy_hmodule
,
1884 sizeof (HMODULE
), &cb_needed
,
1885 LIST_MODULES_32BIT
) == 0)
1891 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
1892 sizeof (HMODULE
), &cb_needed
) == 0)
1899 hmodules
= (HMODULE
*) alloca (cb_needed
);
1903 if (EnumProcessModulesEx (current_process_handle
, hmodules
,
1904 cb_needed
, &cb_needed
,
1905 LIST_MODULES_32BIT
) == 0)
1911 if (EnumProcessModules (current_process_handle
, hmodules
,
1912 cb_needed
, &cb_needed
) == 0)
1916 char system_dir
[__PMAX
];
1917 char syswow_dir
[__PMAX
];
1918 size_t system_dir_len
= 0;
1919 bool convert_syswow_dir
= false;
1924 /* This fails on 32bit Windows because it has no SysWOW64 directory,
1925 and in this case a path conversion isn't necessary. */
1926 UINT len
= GetSystemWow64DirectoryA (syswow_dir
, sizeof (syswow_dir
));
1929 /* Check that we have passed a large enough buffer. */
1930 gdb_assert (len
< sizeof (syswow_dir
));
1932 len
= GetSystemDirectoryA (system_dir
, sizeof (system_dir
));
1934 gdb_assert (len
!= 0);
1935 /* Check that we have passed a large enough buffer. */
1936 gdb_assert (len
< sizeof (system_dir
));
1938 strcat (system_dir
, "\\");
1939 strcat (syswow_dir
, "\\");
1940 system_dir_len
= strlen (system_dir
);
1942 convert_syswow_dir
= true;
1946 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
1950 wchar_t dll_name
[__PMAX
];
1951 char dll_name_mb
[__PMAX
];
1953 char dll_name
[__PMAX
];
1956 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
1957 &mi
, sizeof (mi
)) == 0)
1959 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
1960 dll_name
, sizeof (dll_name
)) == 0)
1963 wcstombs (dll_name_mb
, dll_name
, __PMAX
);
1968 /* Convert the DLL path of 32bit processes returned by
1969 GetModuleFileNameEx from the 64bit system directory to the
1970 32bit syswow64 directory if necessary. */
1971 std::string syswow_dll_path
;
1972 if (convert_syswow_dir
1973 && strncasecmp (name
, system_dir
, system_dir_len
) == 0
1974 && strchr (name
+ system_dir_len
, '\\') == nullptr)
1976 syswow_dll_path
= syswow_dir
;
1977 syswow_dll_path
+= name
+ system_dir_len
;
1978 name
= syswow_dll_path
.c_str();
1981 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
1982 solib_end
= solib_end
->next
;
1987 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1990 struct inferior
*inf
;
1992 last_sig
= GDB_SIGNAL_0
;
1993 open_process_used
= 0;
1994 debug_registers_changed
= 0;
1995 debug_registers_used
= 0;
1996 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1999 cygwin_load_start
= cygwin_load_end
= 0;
2001 current_event
.dwProcessId
= pid
;
2002 memset (¤t_event
, 0, sizeof (current_event
));
2003 if (!target_is_pushed (ops
))
2005 disable_breakpoints_in_shlibs ();
2006 windows_clear_solib ();
2007 clear_proceed_status (0);
2008 init_wait_for_inferior ();
2011 ignore_first_breakpoint
= !attaching
&& wow64_process
;
2015 windows_set_context_register_offsets (amd64_mappings
);
2016 windows_set_segment_register_p (amd64_windows_segment_register_p
);
2021 windows_set_context_register_offsets (i386_mappings
);
2022 windows_set_segment_register_p (i386_windows_segment_register_p
);
2025 inf
= current_inferior ();
2026 inferior_appeared (inf
, pid
);
2027 inf
->attach_flag
= attaching
;
2029 /* Make the new process the current inferior, so terminal handling
2030 can rely on it. When attaching, we don't know about any thread
2031 id here, but that's OK --- nothing should be referencing the
2032 current thread until we report an event out of windows_wait. */
2033 inferior_ptid
= ptid_t (pid
);
2035 target_terminal::init ();
2036 target_terminal::inferior ();
2038 windows_initialization_done
= 0;
2042 struct target_waitstatus status
;
2044 ops
->wait (minus_one_ptid
, &status
, 0);
2046 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
2048 if (status
.kind
!= TARGET_WAITKIND_LOADED
2049 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
2052 ops
->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
2055 /* Now that the inferior has been started and all DLLs have been mapped,
2056 we can iterate over all DLLs and load them in.
2058 We avoid doing it any earlier because, on certain versions of Windows,
2059 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
2060 we have seen on Windows 8.1 that the ntdll.dll load event does not
2061 include the DLL name, preventing us from creating an associated SO.
2062 A possible explanation is that ntdll.dll might be mapped before
2063 the SO info gets created by the Windows system -- ntdll.dll is
2064 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
2065 do not seem to suffer from that problem.
2067 Rather than try to work around this sort of issue, it is much
2068 simpler to just ignore DLL load/unload events during the startup
2069 phase, and then process them all in one batch now. */
2070 windows_add_all_dlls ();
2072 windows_initialization_done
= 1;
2076 /* Try to set or remove a user privilege to the current process. Return -1
2077 if that fails, the previous setting of that privilege otherwise.
2079 This code is copied from the Cygwin source code and rearranged to allow
2080 dynamically loading of the needed symbols from advapi32 which is only
2081 available on NT/2K/XP. */
2083 set_process_privilege (const char *privilege
, BOOL enable
)
2085 HANDLE token_hdl
= NULL
;
2087 TOKEN_PRIVILEGES new_priv
, orig_priv
;
2091 if (!OpenProcessToken (GetCurrentProcess (),
2092 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
2096 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
2099 new_priv
.PrivilegeCount
= 1;
2100 new_priv
.Privileges
[0].Luid
= restore_priv
;
2101 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
2103 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
2104 sizeof orig_priv
, &orig_priv
, &size
))
2107 /* Disabled, otherwise every `attach' in an unprivileged user session
2108 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
2109 windows_attach(). */
2110 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
2111 be enabled. GetLastError () returns an correct error code, though. */
2112 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
2116 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
2120 CloseHandle (token_hdl
);
2125 /* Attach to process PID, then initialize for debugging it. */
2128 windows_nat_target::attach (const char *args
, int from_tty
)
2133 pid
= parse_pid_to_attach (args
);
2135 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
2137 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
2138 printf_unfiltered ("This can cause attach to "
2139 "fail on Windows NT/2K/XP\n");
2142 windows_init_thread_list ();
2143 ok
= DebugActiveProcess (pid
);
2149 /* Try fall back to Cygwin pid. */
2150 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
2153 ok
= DebugActiveProcess (pid
);
2158 error (_("Can't attach to process %u (error %u)"),
2159 (unsigned) pid
, (unsigned) GetLastError ());
2161 DebugSetProcessKillOnExit (FALSE
);
2165 const char *exec_file
= get_exec_file (0);
2168 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
2169 target_pid_to_str (ptid_t (pid
)).c_str ());
2171 printf_unfiltered ("Attaching to %s\n",
2172 target_pid_to_str (ptid_t (pid
)).c_str ());
2176 HANDLE h
= OpenProcess (PROCESS_QUERY_INFORMATION
, FALSE
, pid
);
2180 if (IsWow64Process (h
, &wow64
))
2181 wow64_process
= wow64
;
2186 do_initial_windows_stuff (this, pid
, 1);
2187 target_terminal::ours ();
2191 windows_nat_target::detach (inferior
*inf
, int from_tty
)
2195 ptid_t ptid
= minus_one_ptid
;
2196 resume (ptid
, 0, GDB_SIGNAL_0
);
2198 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
2200 error (_("Can't detach process %u (error %u)"),
2201 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
2204 DebugSetProcessKillOnExit (FALSE
);
2206 if (detached
&& from_tty
)
2208 const char *exec_file
= get_exec_file (0);
2211 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
2212 (unsigned) current_event
.dwProcessId
);
2215 x86_cleanup_dregs ();
2216 inferior_ptid
= null_ptid
;
2217 detach_inferior (inf
);
2219 maybe_unpush_target ();
2222 /* Try to determine the executable filename.
2224 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2226 Upon success, the filename is stored inside EXE_NAME_RET, and
2227 this function returns nonzero.
2229 Otherwise, this function returns zero and the contents of
2230 EXE_NAME_RET is undefined. */
2233 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2243 if (!EnumProcessModulesEx (current_process_handle
, &dh_buf
,
2244 sizeof (HMODULE
), &cbNeeded
,
2245 LIST_MODULES_32BIT
) || !cbNeeded
)
2251 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2252 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2256 /* We know the executable is always first in the list of modules,
2257 which we just fetched. So no need to fetch more. */
2261 /* Cygwin prefers that the path be in /x/y/z format, so extract
2262 the filename into a temporary buffer first, and then convert it
2263 to POSIX format into the destination buffer. */
2264 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2266 len
= GetModuleFileNameEx (current_process_handle
,
2267 dh_buf
, pathbuf
, exe_name_max_len
);
2269 error (_("Error getting executable filename: %u."),
2270 (unsigned) GetLastError ());
2271 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2272 exe_name_max_len
) < 0)
2273 error (_("Error converting executable filename to POSIX: %d."), errno
);
2276 len
= GetModuleFileNameEx (current_process_handle
,
2277 dh_buf
, exe_name_ret
, exe_name_max_len
);
2279 error (_("Error getting executable filename: %u."),
2280 (unsigned) GetLastError ());
2283 return 1; /* success */
2286 /* The pid_to_exec_file target_ops method for this platform. */
2289 windows_nat_target::pid_to_exec_file (int pid
)
2291 static char path
[__PMAX
];
2293 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2295 char procexe
[sizeof ("/proc/4294967295/exe")];
2297 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2298 nchars
= readlink (procexe
, path
, sizeof(path
));
2299 if (nchars
> 0 && nchars
< sizeof (path
))
2301 path
[nchars
] = '\0'; /* Got it */
2306 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2307 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2308 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2314 /* Print status information about what we're accessing. */
2317 windows_nat_target::files_info ()
2319 struct inferior
*inf
= current_inferior ();
2321 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2322 inf
->attach_flag
? "attached" : "child",
2323 target_pid_to_str (inferior_ptid
).c_str ());
2326 /* Modify CreateProcess parameters for use of a new separate console.
2328 *FLAGS: DWORD parameter for general process creation flags.
2329 *SI: STARTUPINFO structure, for which the console window size and
2330 console buffer size is filled in if GDB is running in a console.
2331 to create the new console.
2332 The size of the used font is not available on all versions of
2333 Windows OS. Furthermore, the current font might not be the default
2334 font, but this is still better than before.
2335 If the windows and buffer sizes are computed,
2336 SI->DWFLAGS is changed so that this information is used
2337 by CreateProcess function. */
2340 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2342 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2343 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2345 if (hconsole
!= INVALID_HANDLE_VALUE
)
2347 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2349 CONSOLE_FONT_INFO cfi
;
2351 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2352 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2353 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2354 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2355 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2357 si
->dwXSize
*= font_size
.X
;
2361 si
->dwYSize
*= font_size
.Y
;
2364 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2365 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2366 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2368 *flags
|= CREATE_NEW_CONSOLE
;
2372 /* Function called by qsort to sort environment strings. */
2375 envvar_cmp (const void *a
, const void *b
)
2377 const char **p
= (const char **) a
;
2378 const char **q
= (const char **) b
;
2379 return strcasecmp (*p
, *q
);
2385 clear_win32_environment (char **env
)
2389 wchar_t *copy
= NULL
, *equalpos
;
2391 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2393 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2394 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2395 mbstowcs (copy
, env
[i
], len
);
2396 equalpos
= wcschr (copy
, L
'=');
2399 SetEnvironmentVariableW (copy
, NULL
);
2407 /* Redirection of inferior I/O streams for native MS-Windows programs.
2408 Unlike on Unix, where this is handled by invoking the inferior via
2409 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2411 The official documentation of the cmd.exe redirection features is here:
2413 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2415 (That page talks about Windows XP, but there's no newer
2416 documentation, so we assume later versions of cmd.exe didn't change
2419 Caveat: the documentation on that page seems to include a few lies.
2420 For example, it describes strange constructs 1<&2 and 2<&1, which
2421 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2422 think the cmd.exe parser of the redirection symbols simply doesn't
2423 care about the < vs > distinction in these cases. Therefore, the
2424 supported features are explicitly documented below.
2426 The emulation below aims at supporting all the valid use cases
2427 supported by cmd.exe, which include:
2429 < FILE redirect standard input from FILE
2430 0< FILE redirect standard input from FILE
2431 <&N redirect standard input from file descriptor N
2432 0<&N redirect standard input from file descriptor N
2433 > FILE redirect standard output to FILE
2434 >> FILE append standard output to FILE
2435 1>> FILE append standard output to FILE
2436 >&N redirect standard output to file descriptor N
2437 1>&N redirect standard output to file descriptor N
2438 >>&N append standard output to file descriptor N
2439 1>>&N append standard output to file descriptor N
2440 2> FILE redirect standard error to FILE
2441 2>> FILE append standard error to FILE
2442 2>&N redirect standard error to file descriptor N
2443 2>>&N append standard error to file descriptor N
2445 Note that using N > 2 in the above construct is supported, but
2446 requires that the corresponding file descriptor be open by some
2447 means elsewhere or outside GDB. Also note that using ">&0" or
2448 "<&2" will generally fail, because the file descriptor redirected
2449 from is normally open in an incompatible mode (e.g., FD 0 is open
2450 for reading only). IOW, use of such tricks is not recommended;
2451 you are on your own.
2453 We do NOT support redirection of file descriptors above 2, as in
2454 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2455 that needs special handling in the startup code that MinGW
2456 doesn't have). Pipes are also not supported.
2458 As for invalid use cases, where the redirection contains some
2459 error, the emulation below will detect that and produce some
2460 error and/or failure. But the behavior in those cases is not
2461 bug-for-bug compatible with what cmd.exe does in those cases.
2462 That's because what cmd.exe does then is not well defined, and
2463 seems to be a side effect of the cmd.exe parsing of the command
2464 line more than anything else. For example, try redirecting to an
2465 invalid file name, as in "> foo:bar".
2467 There are also minor syntactic deviations from what cmd.exe does
2468 in some corner cases. For example, it doesn't support the likes
2469 of "> &foo" to mean redirect to file named literally "&foo"; we
2470 do support that here, because that, too, sounds like some issue
2471 with the cmd.exe parser. Another nicety is that we support
2472 redirection targets that use file names with forward slashes,
2473 something cmd.exe doesn't -- this comes in handy since GDB
2474 file-name completion can be used when typing the command line for
2477 /* Support routines for redirecting standard handles of the inferior. */
2479 /* Parse a single redirection spec, open/duplicate the specified
2480 file/fd, and assign the appropriate value to one of the 3 standard
2481 file descriptors. */
2483 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2485 int *fd
, ref_fd
= -2;
2487 const char *fname
= redir_string
+ 1;
2488 int rc
= *redir_string
;
2503 fd
= (rc
== '2') ? err
: out
;
2504 mode
= O_WRONLY
| O_CREAT
;
2517 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2519 /* A reference to a file descriptor. */
2521 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2522 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2524 /* Don't allow redirection when open modes are incompatible. */
2525 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2526 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2533 else if (ref_fd
== 1)
2535 else if (ref_fd
== 2)
2545 fname
++; /* skip the separator space */
2546 /* If the descriptor is already open, close it. This allows
2547 multiple specs of redirections for the same stream, which is
2548 somewhat nonsensical, but still valid and supported by cmd.exe.
2549 (But cmd.exe only opens a single file in this case, the one
2550 specified by the last redirection spec on the command line.) */
2555 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2559 else if (ref_fd
== -1)
2560 *fd
= -1; /* reset to default destination */
2563 *fd
= _dup (ref_fd
);
2567 /* _open just sets a flag for O_APPEND, which won't be passed to the
2568 inferior, so we need to actually move the file pointer. */
2569 if ((mode
& O_APPEND
) != 0)
2570 _lseek (*fd
, 0L, SEEK_END
);
2574 /* Canonicalize a single redirection spec and set up the corresponding
2575 file descriptor as specified. */
2577 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2579 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2581 const char *start
= s
;
2584 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2585 if ((*start
== '>' || *start
== '1' || *start
== '2')
2589 if (*s
== '>' && *start
!= '>')
2592 else if (*start
== '0' && *s
== '<')
2594 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2597 while (isspace (*s
)) /* skip whitespace before file name */
2599 *d
++ = ' '; /* separate file name with a single space */
2602 /* Copy the file name. */
2605 /* Remove quoting characters from the file name in buf[]. */
2606 if (*s
== '"') /* could support '..' quoting here */
2610 else if (*s
== quote
)
2618 else if (*s
== '\\')
2620 if (s
[1] == '"') /* could support '..' here */
2624 else if (isspace (*s
) && !quote
)
2628 if (d
- buf
>= sizeof (buf
) - 1)
2630 errno
= ENAMETOOLONG
;
2636 /* Windows doesn't allow redirection characters in file names, so we
2637 can bail out early if they use them, or if there's no target file
2638 name after the redirection symbol. */
2639 if (d
[-1] == '>' || d
[-1] == '<')
2644 if (redir_open (buf
, inp
, out
, err
) == 0)
2649 /* Parse the command line for redirection specs and prepare the file
2650 descriptors for the 3 standard streams accordingly. */
2652 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2653 int *inp
, int *out
, int *err
)
2655 const char *s
= cmd_orig
;
2658 bool retval
= false;
2660 while (isspace (*s
))
2665 if (*s
== '"') /* could also support '..' quoting here */
2669 else if (*s
== quote
)
2672 else if (*s
== '\\')
2674 if (s
[1] == '"') /* escaped quote char */
2679 /* Process a single redirection candidate. */
2680 if (*s
== '<' || *s
== '>'
2681 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2682 || (*s
== '0' && s
[1] == '<'))
2684 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2698 #endif /* !__CYGWIN__ */
2700 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2701 EXEC_FILE is the file to run.
2702 ALLARGS is a string containing the arguments to the program.
2703 ENV is the environment vector to pass. Errors reported with error(). */
2706 windows_nat_target::create_inferior (const char *exec_file
,
2707 const std::string
&origallargs
,
2708 char **in_env
, int from_tty
)
2712 cygwin_buf_t real_path
[__PMAX
];
2713 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2714 cygwin_buf_t infcwd
[__PMAX
];
2716 cygwin_buf_t
*toexec
;
2717 cygwin_buf_t
*cygallargs
;
2719 char **old_env
= NULL
;
2723 int ostdin
, ostdout
, ostderr
;
2724 #else /* !__CYGWIN__ */
2725 char shell
[__PMAX
]; /* Path to shell */
2727 char *args
, *allargs_copy
;
2728 size_t args_len
, allargs_len
;
2729 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2730 HANDLE tty
= INVALID_HANDLE_VALUE
;
2731 bool redirected
= false;
2738 #endif /* !__CYGWIN__ */
2739 const char *allargs
= origallargs
.c_str ();
2740 PROCESS_INFORMATION pi
;
2743 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2746 error (_("No executable specified, use `target exec'."));
2748 const char *inferior_cwd
= get_inferior_cwd ();
2749 std::string expanded_infcwd
;
2750 if (inferior_cwd
!= NULL
)
2752 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
2753 /* Mirror slashes on inferior's cwd. */
2754 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
2756 inferior_cwd
= expanded_infcwd
.c_str ();
2759 memset (&si
, 0, sizeof (si
));
2760 si
.cb
= sizeof (si
);
2763 flags
|= CREATE_NEW_PROCESS_GROUP
;
2766 windows_set_console_info (&si
, &flags
);
2771 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2772 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2773 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2774 error (_("Error starting executable: %d"), errno
);
2777 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2778 if (len
== (size_t) -1)
2779 error (_("Error starting executable: %d"), errno
);
2780 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2781 mbstowcs (cygallargs
, allargs
, len
);
2782 #else /* !__USEWIDE */
2783 cygallargs
= allargs
;
2789 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2790 error (_("Error starting executable via shell: %d"), errno
);
2792 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2793 + mbstowcs (NULL
, allargs
, 0) + 2;
2794 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2795 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2796 #else /* !__USEWIDE */
2797 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2798 + strlen (allargs
) + 2);
2799 cygallargs
= (char *) alloca (len
);
2800 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2801 #endif /* __USEWIDE */
2803 flags
|= DEBUG_PROCESS
;
2806 if (inferior_cwd
!= NULL
2807 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
2808 infcwd
, strlen (inferior_cwd
)) < 0)
2809 error (_("Error converting inferior cwd: %d"), errno
);
2812 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2813 * sizeof (wchar_t));
2814 wcscpy (args
, toexec
);
2815 wcscat (args
, L
" ");
2816 wcscat (args
, cygallargs
);
2817 #else /* !__USEWIDE */
2818 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2819 strcpy (args
, toexec
);
2821 strcat (args
, cygallargs
);
2822 #endif /* !__USEWIDE */
2824 #ifdef CW_CVT_ENV_TO_WINENV
2825 /* First try to create a direct Win32 copy of the POSIX environment. */
2826 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2827 if (w32_env
!= (PWCHAR
) -1)
2828 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2830 /* If that fails, fall back to old method tweaking GDB's environment. */
2831 #endif /* CW_CVT_ENV_TO_WINENV */
2833 /* Reset all Win32 environment variables to avoid leftover on next run. */
2834 clear_win32_environment (environ
);
2835 /* Prepare the environment vars for CreateProcess. */
2838 cygwin_internal (CW_SYNC_WINENV
);
2842 if (!inferior_io_terminal
)
2843 tty
= ostdin
= ostdout
= ostderr
= -1;
2846 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2849 print_sys_errmsg (inferior_io_terminal
, errno
);
2850 ostdin
= ostdout
= ostderr
= -1;
2863 windows_init_thread_list ();
2864 ret
= CreateProcess (0,
2865 args
, /* command line */
2866 NULL
, /* Security */
2868 TRUE
, /* inherit handles */
2869 flags
, /* start flags */
2870 w32_env
, /* environment */
2871 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
2876 /* Just free the Win32 environment, if it could be created. */
2880 /* Reset all environment variables to avoid leftover on next run. */
2881 clear_win32_environment (in_env
);
2882 /* Restore normal GDB environment variables. */
2884 cygwin_internal (CW_SYNC_WINENV
);
2897 #else /* !__CYGWIN__ */
2898 allargs_len
= strlen (allargs
);
2899 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
2900 if (strpbrk (allargs_copy
, "<>") != NULL
)
2905 redirect_inferior_handles (allargs
, allargs_copy
,
2906 &fd_inp
, &fd_out
, &fd_err
);
2908 warning (_("Error in redirection: %s."), safe_strerror (errno
));
2911 allargs_len
= strlen (allargs_copy
);
2913 /* If not all the standard streams are redirected by the command
2914 line, use inferior_io_terminal for those which aren't. */
2915 if (inferior_io_terminal
2916 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
2918 SECURITY_ATTRIBUTES sa
;
2919 sa
.nLength
= sizeof(sa
);
2920 sa
.lpSecurityDescriptor
= 0;
2921 sa
.bInheritHandle
= TRUE
;
2922 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2923 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2924 if (tty
== INVALID_HANDLE_VALUE
)
2925 warning (_("Warning: Failed to open TTY %s, error %#x."),
2926 inferior_io_terminal
, (unsigned) GetLastError ());
2928 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
2931 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
2932 else if (tty
!= INVALID_HANDLE_VALUE
)
2935 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
2937 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
2938 else if (tty
!= INVALID_HANDLE_VALUE
)
2939 si
.hStdOutput
= tty
;
2941 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
2943 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
2944 else if (tty
!= INVALID_HANDLE_VALUE
)
2947 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
2948 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2952 /* Build the command line, a space-separated list of tokens where
2953 the first token is the name of the module to be executed.
2954 To avoid ambiguities introduced by spaces in the module name,
2956 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
2957 args
= (char *) alloca (args_len
);
2958 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
2960 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2962 /* CreateProcess takes the environment list as a null terminated set of
2963 strings (i.e. two nulls terminate the list). */
2965 /* Get total size for env strings. */
2966 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2967 envlen
+= strlen (in_env
[i
]) + 1;
2969 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2970 env
= (char **) alloca (envsize
);
2971 memcpy (env
, in_env
, envsize
);
2972 /* Windows programs expect the environment block to be sorted. */
2973 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2975 w32env
= (char *) alloca (envlen
+ 1);
2977 /* Copy env strings into new buffer. */
2978 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2980 strcpy (temp
, env
[i
]);
2981 temp
+= strlen (temp
) + 1;
2984 /* Final nil string to terminate new env. */
2987 windows_init_thread_list ();
2988 ret
= CreateProcessA (0,
2989 args
, /* command line */
2990 NULL
, /* Security */
2992 TRUE
, /* inherit handles */
2993 flags
, /* start flags */
2994 w32env
, /* environment */
2995 inferior_cwd
, /* current directory */
2998 if (tty
!= INVALID_HANDLE_VALUE
)
3006 #endif /* !__CYGWIN__ */
3009 error (_("Error creating process %s, (error %u)."),
3010 exec_file
, (unsigned) GetLastError ());
3014 if (IsWow64Process (pi
.hProcess
, &wow64
))
3015 wow64_process
= wow64
;
3018 CloseHandle (pi
.hThread
);
3019 CloseHandle (pi
.hProcess
);
3021 if (useshell
&& shell
[0] != '\0')
3026 do_initial_windows_stuff (this, pi
.dwProcessId
, 0);
3028 /* windows_continue (DBG_CONTINUE, -1, 0); */
3032 windows_nat_target::mourn_inferior ()
3034 (void) windows_continue (DBG_CONTINUE
, -1, 0);
3035 x86_cleanup_dregs();
3036 if (open_process_used
)
3038 CHECK (CloseHandle (current_process_handle
));
3039 open_process_used
= 0;
3041 siginfo_er
.ExceptionCode
= 0;
3042 inf_child_target::mourn_inferior ();
3045 /* Send a SIGINT to the process group. This acts just like the user typed a
3046 ^C on the controlling terminal. */
3049 windows_nat_target::interrupt ()
3051 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
3052 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
3053 registers_changed (); /* refresh register state */
3056 /* Helper for windows_xfer_partial that handles memory transfers.
3057 Arguments are like target_xfer_partial. */
3059 static enum target_xfer_status
3060 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3061 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
3065 DWORD lasterror
= 0;
3067 if (writebuf
!= NULL
)
3069 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
3070 pulongest (len
), core_addr_to_string (memaddr
)));
3071 success
= WriteProcessMemory (current_process_handle
,
3072 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
3075 lasterror
= GetLastError ();
3076 FlushInstructionCache (current_process_handle
,
3077 (LPCVOID
) (uintptr_t) memaddr
, len
);
3081 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
3082 pulongest (len
), core_addr_to_string (memaddr
)));
3083 success
= ReadProcessMemory (current_process_handle
,
3084 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
3087 lasterror
= GetLastError ();
3089 *xfered_len
= (ULONGEST
) done
;
3090 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
3091 return TARGET_XFER_OK
;
3093 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
3097 windows_nat_target::kill ()
3099 CHECK (TerminateProcess (current_process_handle
, 0));
3103 if (!windows_continue (DBG_CONTINUE
, -1, 1))
3105 if (!wait_for_debug_event (¤t_event
, INFINITE
))
3107 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
3111 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
3115 windows_nat_target::close ()
3117 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
3118 inferior_ptid
.pid ()));
3121 /* Convert pid to printable format. */
3123 windows_nat_target::pid_to_str (ptid_t ptid
)
3125 if (ptid
.lwp () != 0)
3126 return string_printf ("Thread %d.0x%lx", ptid
.pid (), ptid
.lwp ());
3128 return normal_pid_to_str (ptid
);
3131 static enum target_xfer_status
3132 windows_xfer_shared_libraries (struct target_ops
*ops
,
3133 enum target_object object
, const char *annex
,
3134 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3135 ULONGEST offset
, ULONGEST len
,
3136 ULONGEST
*xfered_len
)
3138 struct obstack obstack
;
3144 return TARGET_XFER_E_IO
;
3146 obstack_init (&obstack
);
3147 obstack_grow_str (&obstack
, "<library-list>\n");
3148 for (so
= solib_start
.next
; so
; so
= so
->next
)
3150 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
3152 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
3153 (uintptr_t) li
->load_addr
,
3155 target_gdbarch (), &obstack
);
3157 obstack_grow_str0 (&obstack
, "</library-list>\n");
3159 buf
= (const char *) obstack_finish (&obstack
);
3160 len_avail
= strlen (buf
);
3161 if (offset
>= len_avail
)
3165 if (len
> len_avail
- offset
)
3166 len
= len_avail
- offset
;
3167 memcpy (readbuf
, buf
+ offset
, len
);
3170 obstack_free (&obstack
, NULL
);
3171 *xfered_len
= (ULONGEST
) len
;
3172 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
3175 /* Helper for windows_nat_target::xfer_partial that handles signal info. */
3177 static enum target_xfer_status
3178 windows_xfer_siginfo (gdb_byte
*readbuf
, ULONGEST offset
, ULONGEST len
,
3179 ULONGEST
*xfered_len
)
3181 char *buf
= (char *) &siginfo_er
;
3182 size_t bufsize
= sizeof (siginfo_er
);
3185 EXCEPTION_RECORD32 er32
;
3188 buf
= (char *) &er32
;
3189 bufsize
= sizeof (er32
);
3191 er32
.ExceptionCode
= siginfo_er
.ExceptionCode
;
3192 er32
.ExceptionFlags
= siginfo_er
.ExceptionFlags
;
3193 er32
.ExceptionRecord
= (uintptr_t) siginfo_er
.ExceptionRecord
;
3194 er32
.ExceptionAddress
= (uintptr_t) siginfo_er
.ExceptionAddress
;
3195 er32
.NumberParameters
= siginfo_er
.NumberParameters
;
3197 for (i
= 0; i
< EXCEPTION_MAXIMUM_PARAMETERS
; i
++)
3198 er32
.ExceptionInformation
[i
] = siginfo_er
.ExceptionInformation
[i
];
3202 if (siginfo_er
.ExceptionCode
== 0)
3203 return TARGET_XFER_E_IO
;
3205 if (readbuf
== nullptr)
3206 return TARGET_XFER_E_IO
;
3208 if (offset
> bufsize
)
3209 return TARGET_XFER_E_IO
;
3211 if (offset
+ len
> bufsize
)
3212 len
= bufsize
- offset
;
3214 memcpy (readbuf
, buf
+ offset
, len
);
3217 return TARGET_XFER_OK
;
3220 enum target_xfer_status
3221 windows_nat_target::xfer_partial (enum target_object object
,
3222 const char *annex
, gdb_byte
*readbuf
,
3223 const gdb_byte
*writebuf
, ULONGEST offset
,
3224 ULONGEST len
, ULONGEST
*xfered_len
)
3228 case TARGET_OBJECT_MEMORY
:
3229 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
3231 case TARGET_OBJECT_LIBRARIES
:
3232 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
3233 writebuf
, offset
, len
, xfered_len
);
3235 case TARGET_OBJECT_SIGNAL_INFO
:
3236 return windows_xfer_siginfo (readbuf
, offset
, len
, xfered_len
);
3239 if (beneath () == NULL
)
3241 /* This can happen when requesting the transfer of unsupported
3242 objects before a program has been started (and therefore
3243 with the current_target having no target beneath). */
3244 return TARGET_XFER_E_IO
;
3246 return beneath ()->xfer_partial (object
, annex
,
3247 readbuf
, writebuf
, offset
, len
,
3252 /* Provide thread local base, i.e. Thread Information Block address.
3253 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
3256 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
3258 windows_thread_info
*th
;
3260 th
= thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
);
3265 *addr
= th
->thread_local_base
;
3271 windows_nat_target::get_ada_task_ptid (long lwp
, long thread
)
3273 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
3276 /* Implementation of the to_thread_name method. */
3279 windows_nat_target::thread_name (struct thread_info
*thr
)
3281 return thread_rec (thr
->ptid
, DONT_INVALIDATE_CONTEXT
)->name
.get ();
3285 void _initialize_windows_nat ();
3287 _initialize_windows_nat ()
3289 x86_dr_low
.set_control
= cygwin_set_dr7
;
3290 x86_dr_low
.set_addr
= cygwin_set_dr
;
3291 x86_dr_low
.get_addr
= cygwin_get_dr
;
3292 x86_dr_low
.get_status
= cygwin_get_dr6
;
3293 x86_dr_low
.get_control
= cygwin_get_dr7
;
3295 /* x86_dr_low.debug_register_length field is set by
3296 calling x86_set_debug_register_length function
3297 in processor windows specific native file. */
3299 add_inf_child_target (&the_windows_nat_target
);
3302 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3305 add_com ("signal-event", class_run
, signal_event_command
, _("\
3306 Signal a crashed process with event ID, to allow its debugging.\n\
3307 This command is needed in support of setting up GDB as JIT debugger on \
3308 MS-Windows. The command should be invoked from the GDB command line using \
3309 the '-ex' command-line option. The ID of the event that blocks the \
3310 crashed process will be supplied by the Windows JIT debugging mechanism."));
3313 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3314 Set use of shell to start subprocess."), _("\
3315 Show use of shell to start subprocess."), NULL
,
3317 NULL
, /* FIXME: i18n: */
3318 &setlist
, &showlist
);
3320 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3321 &cygwin_exceptions
, _("\
3322 Break when an exception is detected in the Cygwin DLL itself."), _("\
3323 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3325 NULL
, /* FIXME: i18n: */
3326 &setlist
, &showlist
);
3329 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3330 Set creation of new console when creating child process."), _("\
3331 Show creation of new console when creating child process."), NULL
,
3333 NULL
, /* FIXME: i18n: */
3334 &setlist
, &showlist
);
3336 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3337 Set creation of new group when creating child process."), _("\
3338 Show creation of new group when creating child process."), NULL
,
3340 NULL
, /* FIXME: i18n: */
3341 &setlist
, &showlist
);
3343 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3344 Set whether to display execution in child process."), _("\
3345 Show whether to display execution in child process."), NULL
,
3347 NULL
, /* FIXME: i18n: */
3348 &setlist
, &showlist
);
3350 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3351 Set whether to display kernel events in child process."), _("\
3352 Show whether to display kernel events in child process."), NULL
,
3354 NULL
, /* FIXME: i18n: */
3355 &setlist
, &showlist
);
3357 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3358 Set whether to display memory accesses in child process."), _("\
3359 Show whether to display memory accesses in child process."), NULL
,
3361 NULL
, /* FIXME: i18n: */
3362 &setlist
, &showlist
);
3364 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3365 &debug_exceptions
, _("\
3366 Set whether to display kernel exceptions in child process."), _("\
3367 Show whether to display kernel exceptions in child process."), NULL
,
3369 NULL
, /* FIXME: i18n: */
3370 &setlist
, &showlist
);
3372 init_w32_command_list ();
3374 add_cmd ("selector", class_info
, display_selectors
,
3375 _("Display selectors infos."),
3379 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3381 /* Pass the address ADDR to the inferior in the I'th debug register.
3382 Here we just store the address in dr array, the registers will be
3383 actually set up when windows_continue is called. */
3385 cygwin_set_dr (int i
, CORE_ADDR addr
)
3388 internal_error (__FILE__
, __LINE__
,
3389 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3391 debug_registers_changed
= 1;
3392 debug_registers_used
= 1;
3395 /* Pass the value VAL to the inferior in the DR7 debug control
3396 register. Here we just store the address in D_REGS, the watchpoint
3397 will be actually set up in windows_wait. */
3399 cygwin_set_dr7 (unsigned long val
)
3401 dr
[7] = (CORE_ADDR
) val
;
3402 debug_registers_changed
= 1;
3403 debug_registers_used
= 1;
3406 /* Get the value of debug register I from the inferior. */
3409 cygwin_get_dr (int i
)
3414 /* Get the value of the DR6 debug status register from the inferior.
3415 Here we just return the value stored in dr[6]
3416 by the last call to thread_rec for current_event.dwThreadId id. */
3417 static unsigned long
3418 cygwin_get_dr6 (void)
3420 return (unsigned long) dr
[6];
3423 /* Get the value of the DR7 debug status register from the inferior.
3424 Here we just return the value stored in dr[7] by the last call to
3425 thread_rec for current_event.dwThreadId id. */
3427 static unsigned long
3428 cygwin_get_dr7 (void)
3430 return (unsigned long) dr
[7];
3433 /* Determine if the thread referenced by "ptid" is alive
3434 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3435 it means that the thread has died. Otherwise it is assumed to be alive. */
3438 windows_nat_target::thread_alive (ptid_t ptid
)
3440 gdb_assert (ptid
.lwp () != 0);
3442 return (WaitForSingleObject (thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
)->h
, 0)
3446 void _initialize_check_for_gdb_ini ();
3448 _initialize_check_for_gdb_ini ()
3451 if (inhibit_gdbinit
)
3454 homedir
= getenv ("HOME");
3458 char *oldini
= (char *) alloca (strlen (homedir
) +
3459 sizeof ("gdb.ini") + 1);
3460 strcpy (oldini
, homedir
);
3461 p
= strchr (oldini
, '\0');
3462 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3464 strcpy (p
, "gdb.ini");
3465 if (access (oldini
, 0) == 0)
3467 int len
= strlen (oldini
);
3468 char *newini
= (char *) alloca (len
+ 2);
3470 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3471 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3472 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3477 /* Define dummy functions which always return error for the rare cases where
3478 these functions could not be found. */
3480 bad_DebugActiveProcessStop (DWORD w
)
3485 bad_DebugBreakProcess (HANDLE w
)
3490 bad_DebugSetProcessKillOnExit (BOOL w
)
3495 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3502 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3508 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3515 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3521 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3527 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3533 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3541 /* Load any functions which may not be available in ancient versions
3544 void _initialize_loadable ();
3546 _initialize_loadable ()
3550 #define GPA(m, func) \
3551 func = (func ## _ftype *) GetProcAddress (m, #func)
3553 hm
= LoadLibrary ("kernel32.dll");
3556 GPA (hm
, DebugActiveProcessStop
);
3557 GPA (hm
, DebugBreakProcess
);
3558 GPA (hm
, DebugSetProcessKillOnExit
);
3559 GPA (hm
, GetConsoleFontSize
);
3560 GPA (hm
, DebugActiveProcessStop
);
3561 GPA (hm
, GetCurrentConsoleFont
);
3563 GPA (hm
, Wow64SuspendThread
);
3564 GPA (hm
, Wow64GetThreadContext
);
3565 GPA (hm
, Wow64SetThreadContext
);
3566 GPA (hm
, Wow64GetThreadSelectorEntry
);
3570 /* Set variables to dummy versions of these processes if the function
3571 wasn't found in kernel32.dll. */
3572 if (!DebugBreakProcess
)
3573 DebugBreakProcess
= bad_DebugBreakProcess
;
3574 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3576 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3577 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3579 if (!GetConsoleFontSize
)
3580 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3581 if (!GetCurrentConsoleFont
)
3582 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3584 /* Load optional functions used for retrieving filename information
3585 associated with the currently debugged process or its dlls. */
3586 hm
= LoadLibrary ("psapi.dll");
3589 GPA (hm
, EnumProcessModules
);
3591 GPA (hm
, EnumProcessModulesEx
);
3593 GPA (hm
, GetModuleInformation
);
3594 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3595 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3598 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3600 /* Set variables to dummy versions of these processes if the function
3601 wasn't found in psapi.dll. */
3602 EnumProcessModules
= bad_EnumProcessModules
;
3603 GetModuleInformation
= bad_GetModuleInformation
;
3604 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3605 /* This will probably fail on Windows 9x/Me. Let the user know
3606 that we're missing some functionality. */
3608 cannot automatically find executable file or library to read symbols.\n\
3609 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3612 hm
= LoadLibrary ("advapi32.dll");
3615 GPA (hm
, OpenProcessToken
);
3616 GPA (hm
, LookupPrivilegeValueA
);
3617 GPA (hm
, AdjustTokenPrivileges
);
3618 /* Only need to set one of these since if OpenProcessToken fails nothing
3620 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3621 || !AdjustTokenPrivileges
)
3622 OpenProcessToken
= bad_OpenProcessToken
;