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 (matching_pending_stop (debug_events
))
1245 for (windows_thread_info
*th
: thread_list
)
1246 if (id
== -1 || id
== (int) th
->tid
)
1253 if (debug_registers_changed
)
1255 th
->wow64_context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1256 th
->wow64_context
.Dr0
= dr
[0];
1257 th
->wow64_context
.Dr1
= dr
[1];
1258 th
->wow64_context
.Dr2
= dr
[2];
1259 th
->wow64_context
.Dr3
= dr
[3];
1260 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1261 th
->wow64_context
.Dr7
= dr
[7];
1263 if (th
->wow64_context
.ContextFlags
)
1267 if (GetExitCodeThread (th
->h
, &ec
)
1268 && ec
== STILL_ACTIVE
)
1270 BOOL status
= Wow64SetThreadContext (th
->h
,
1271 &th
->wow64_context
);
1276 th
->wow64_context
.ContextFlags
= 0;
1282 if (debug_registers_changed
)
1284 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1285 th
->context
.Dr0
= dr
[0];
1286 th
->context
.Dr1
= dr
[1];
1287 th
->context
.Dr2
= dr
[2];
1288 th
->context
.Dr3
= dr
[3];
1289 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1290 th
->context
.Dr7
= dr
[7];
1292 if (th
->context
.ContextFlags
)
1296 if (GetExitCodeThread (th
->h
, &ec
)
1297 && ec
== STILL_ACTIVE
)
1299 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1304 th
->context
.ContextFlags
= 0;
1311 /* When single-stepping a specific thread, other threads must
1316 res
= continue_last_debug_event (continue_status
, debug_events
);
1319 error (_("Failed to resume program execution"
1320 " (ContinueDebugEvent failed, error %u)"),
1321 (unsigned int) GetLastError ());
1323 debug_registers_changed
= 0;
1327 /* Called in pathological case where Windows fails to send a
1328 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1330 fake_create_process (void)
1332 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1333 current_event
.dwProcessId
);
1334 if (current_process_handle
!= NULL
)
1335 open_process_used
= 1;
1338 error (_("OpenProcess call failed, GetLastError = %u"),
1339 (unsigned) GetLastError ());
1340 /* We can not debug anything in that case. */
1342 current_windows_thread
1343 = windows_add_thread (ptid_t (current_event
.dwProcessId
,
1344 current_event
.dwThreadId
, 0),
1345 current_event
.u
.CreateThread
.hThread
,
1346 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1347 true /* main_thread_p */);
1348 return current_event
.dwThreadId
;
1352 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1354 windows_thread_info
*th
;
1355 DWORD continue_status
= DBG_CONTINUE
;
1357 /* A specific PTID means `step only this thread id'. */
1358 int resume_all
= ptid
== minus_one_ptid
;
1360 /* If we're continuing all threads, it's the current inferior that
1361 should be handled specially. */
1363 ptid
= inferior_ptid
;
1365 if (sig
!= GDB_SIGNAL_0
)
1367 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1369 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1371 else if (sig
== last_sig
)
1372 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1375 /* This code does not seem to work, because
1376 the kernel does probably not consider changes in the ExceptionRecord
1377 structure when passing the exception to the inferior.
1378 Note that this seems possible in the exception handler itself. */
1380 for (const xlate_exception
&x
: xlate
)
1383 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1385 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1388 if (continue_status
== DBG_CONTINUE
)
1390 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1394 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1398 last_sig
= GDB_SIGNAL_0
;
1400 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=0x%x, step=%d, sig=%d);\n",
1401 ptid
.pid (), (unsigned) ptid
.lwp (), step
, sig
));
1403 /* Get context for currently selected thread. */
1404 th
= thread_rec (inferior_ptid
, DONT_INVALIDATE_CONTEXT
);
1412 /* Single step by setting t bit. */
1413 struct regcache
*regcache
= get_current_regcache ();
1414 struct gdbarch
*gdbarch
= regcache
->arch ();
1415 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1416 th
->wow64_context
.EFlags
|= FLAG_TRACE_BIT
;
1419 if (th
->wow64_context
.ContextFlags
)
1421 if (debug_registers_changed
)
1423 th
->wow64_context
.Dr0
= dr
[0];
1424 th
->wow64_context
.Dr1
= dr
[1];
1425 th
->wow64_context
.Dr2
= dr
[2];
1426 th
->wow64_context
.Dr3
= dr
[3];
1427 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1428 th
->wow64_context
.Dr7
= dr
[7];
1430 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
1431 th
->wow64_context
.ContextFlags
= 0;
1439 /* Single step by setting t bit. */
1440 struct regcache
*regcache
= get_current_regcache ();
1441 struct gdbarch
*gdbarch
= regcache
->arch ();
1442 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1443 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1446 if (th
->context
.ContextFlags
)
1448 if (debug_registers_changed
)
1450 th
->context
.Dr0
= dr
[0];
1451 th
->context
.Dr1
= dr
[1];
1452 th
->context
.Dr2
= dr
[2];
1453 th
->context
.Dr3
= dr
[3];
1454 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1455 th
->context
.Dr7
= dr
[7];
1457 CHECK (SetThreadContext (th
->h
, &th
->context
));
1458 th
->context
.ContextFlags
= 0;
1463 /* Allow continuing with the same signal that interrupted us.
1464 Otherwise complain. */
1467 windows_continue (continue_status
, -1, 0);
1469 windows_continue (continue_status
, ptid
.lwp (), 0);
1472 /* Ctrl-C handler used when the inferior is not run in the same console. The
1473 handler is in charge of interrupting the inferior using DebugBreakProcess.
1474 Note that this function is not available prior to Windows XP. In this case
1475 we emit a warning. */
1477 ctrl_c_handler (DWORD event_type
)
1479 const int attach_flag
= current_inferior ()->attach_flag
;
1481 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1482 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1485 /* If the inferior and the debugger share the same console, do nothing as
1486 the inferior has also received the Ctrl-C event. */
1487 if (!new_console
&& !attach_flag
)
1490 if (!DebugBreakProcess (current_process_handle
))
1491 warning (_("Could not interrupt program. "
1492 "Press Ctrl-c in the program console."));
1494 /* Return true to tell that Ctrl-C has been handled. */
1498 /* A wrapper for WaitForDebugEvent that sets "last_wait_event"
1501 wait_for_debug_event (DEBUG_EVENT
*event
, DWORD timeout
)
1503 BOOL result
= WaitForDebugEvent (event
, timeout
);
1505 last_wait_event
= *event
;
1509 /* Get the next event from the child. Returns a non-zero thread id if the event
1510 requires handling by WFI (or whatever). */
1513 windows_nat_target::get_windows_debug_event (int pid
,
1514 struct target_waitstatus
*ourstatus
)
1517 DWORD continue_status
, event_code
;
1518 windows_thread_info
*th
;
1519 static windows_thread_info
dummy_thread_info (0, 0, 0);
1520 DWORD thread_id
= 0;
1522 /* If there is a relevant pending stop, report it now. See the
1523 comment by the definition of "pending_stops" for details on why
1525 for (auto iter
= pending_stops
.begin ();
1526 iter
!= pending_stops
.end ();
1529 if (desired_stop_thread_id
== -1
1530 || desired_stop_thread_id
== iter
->thread_id
)
1532 thread_id
= iter
->thread_id
;
1533 *ourstatus
= iter
->status
;
1534 current_event
= iter
->event
;
1536 inferior_ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1537 current_windows_thread
= thread_rec (inferior_ptid
,
1538 INVALIDATE_CONTEXT
);
1539 current_windows_thread
->reload_context
= 1;
1541 DEBUG_EVENTS (("get_windows_debug_event - "
1542 "pending stop found in 0x%x (desired=0x%x)\n",
1543 thread_id
, desired_stop_thread_id
));
1545 pending_stops
.erase (iter
);
1550 last_sig
= GDB_SIGNAL_0
;
1552 if (!(debug_event
= wait_for_debug_event (¤t_event
, 1000)))
1555 continue_status
= DBG_CONTINUE
;
1557 event_code
= current_event
.dwDebugEventCode
;
1558 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1560 have_saved_context
= 0;
1564 case CREATE_THREAD_DEBUG_EVENT
:
1565 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1566 (unsigned) current_event
.dwProcessId
,
1567 (unsigned) current_event
.dwThreadId
,
1568 "CREATE_THREAD_DEBUG_EVENT"));
1569 if (saw_create
!= 1)
1571 inferior
*inf
= find_inferior_pid (this, current_event
.dwProcessId
);
1572 if (!saw_create
&& inf
->attach_flag
)
1574 /* Kludge around a Windows bug where first event is a create
1575 thread event. Caused when attached process does not have
1577 thread_id
= fake_create_process ();
1583 /* Record the existence of this thread. */
1584 thread_id
= current_event
.dwThreadId
;
1585 th
= windows_add_thread
1586 (ptid_t (current_event
.dwProcessId
, current_event
.dwThreadId
, 0),
1587 current_event
.u
.CreateThread
.hThread
,
1588 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1589 false /* main_thread_p */);
1593 case EXIT_THREAD_DEBUG_EVENT
:
1594 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1595 (unsigned) current_event
.dwProcessId
,
1596 (unsigned) current_event
.dwThreadId
,
1597 "EXIT_THREAD_DEBUG_EVENT"));
1598 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1599 current_event
.dwThreadId
, 0),
1600 current_event
.u
.ExitThread
.dwExitCode
,
1601 false /* main_thread_p */);
1602 th
= &dummy_thread_info
;
1605 case CREATE_PROCESS_DEBUG_EVENT
:
1606 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1607 (unsigned) current_event
.dwProcessId
,
1608 (unsigned) current_event
.dwThreadId
,
1609 "CREATE_PROCESS_DEBUG_EVENT"));
1610 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1611 if (++saw_create
!= 1)
1614 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1615 /* Add the main thread. */
1616 th
= windows_add_thread
1617 (ptid_t (current_event
.dwProcessId
,
1618 current_event
.dwThreadId
, 0),
1619 current_event
.u
.CreateProcessInfo
.hThread
,
1620 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
,
1621 true /* main_thread_p */);
1622 thread_id
= current_event
.dwThreadId
;
1625 case EXIT_PROCESS_DEBUG_EVENT
:
1626 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1627 (unsigned) current_event
.dwProcessId
,
1628 (unsigned) current_event
.dwThreadId
,
1629 "EXIT_PROCESS_DEBUG_EVENT"));
1630 if (!windows_initialization_done
)
1632 target_terminal::ours ();
1633 target_mourn_inferior (inferior_ptid
);
1634 error (_("During startup program exited with code 0x%x."),
1635 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1637 else if (saw_create
== 1)
1639 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1640 current_event
.dwThreadId
, 0),
1641 0, true /* main_thread_p */);
1642 DWORD exit_status
= current_event
.u
.ExitProcess
.dwExitCode
;
1643 /* If the exit status looks like a fatal exception, but we
1644 don't recognize the exception's code, make the original
1645 exit status value available, to avoid losing
1648 = WIFSIGNALED (exit_status
) ? WTERMSIG (exit_status
) : -1;
1649 if (exit_signal
== -1)
1651 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1652 ourstatus
->value
.integer
= exit_status
;
1656 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1657 ourstatus
->value
.sig
= gdb_signal_from_host (exit_signal
);
1659 thread_id
= current_event
.dwThreadId
;
1663 case LOAD_DLL_DEBUG_EVENT
:
1664 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1665 (unsigned) current_event
.dwProcessId
,
1666 (unsigned) current_event
.dwThreadId
,
1667 "LOAD_DLL_DEBUG_EVENT"));
1668 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1669 if (saw_create
!= 1 || ! windows_initialization_done
)
1671 catch_errors (handle_load_dll
);
1672 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1673 ourstatus
->value
.integer
= 0;
1674 thread_id
= current_event
.dwThreadId
;
1677 case UNLOAD_DLL_DEBUG_EVENT
:
1678 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1679 (unsigned) current_event
.dwProcessId
,
1680 (unsigned) current_event
.dwThreadId
,
1681 "UNLOAD_DLL_DEBUG_EVENT"));
1682 if (saw_create
!= 1 || ! windows_initialization_done
)
1684 catch_errors (handle_unload_dll
);
1685 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1686 ourstatus
->value
.integer
= 0;
1687 thread_id
= current_event
.dwThreadId
;
1690 case EXCEPTION_DEBUG_EVENT
:
1691 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1692 (unsigned) current_event
.dwProcessId
,
1693 (unsigned) current_event
.dwThreadId
,
1694 "EXCEPTION_DEBUG_EVENT"));
1695 if (saw_create
!= 1)
1697 switch (handle_exception (ourstatus
, debug_exceptions
))
1699 case HANDLE_EXCEPTION_UNHANDLED
:
1701 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1703 case HANDLE_EXCEPTION_HANDLED
:
1704 thread_id
= current_event
.dwThreadId
;
1706 case HANDLE_EXCEPTION_IGNORED
:
1707 continue_status
= DBG_CONTINUE
;
1712 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
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 "OUTPUT_DEBUG_STRING_EVENT"));
1717 if (saw_create
!= 1)
1719 thread_id
= handle_output_debug_string (ourstatus
);
1723 if (saw_create
!= 1)
1725 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1726 (unsigned) current_event
.dwProcessId
,
1727 (unsigned) current_event
.dwThreadId
);
1728 printf_unfiltered (" unknown event code %u\n",
1729 (unsigned) current_event
.dwDebugEventCode
);
1733 if (!thread_id
|| saw_create
!= 1)
1735 CHECK (windows_continue (continue_status
, desired_stop_thread_id
, 0));
1737 else if (desired_stop_thread_id
!= -1 && desired_stop_thread_id
!= thread_id
)
1739 /* Pending stop. See the comment by the definition of
1740 "pending_stops" for details on why this is needed. */
1741 DEBUG_EVENTS (("get_windows_debug_event - "
1742 "unexpected stop in 0x%x (expecting 0x%x)\n",
1743 thread_id
, desired_stop_thread_id
));
1745 if (current_event
.dwDebugEventCode
== EXCEPTION_DEBUG_EVENT
1746 && (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1747 == EXCEPTION_BREAKPOINT
)
1748 && windows_initialization_done
)
1750 ptid_t ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1751 th
= thread_rec (ptid
, INVALIDATE_CONTEXT
);
1752 th
->stopped_at_software_breakpoint
= true;
1754 pending_stops
.push_back ({thread_id
, *ourstatus
, current_event
});
1756 CHECK (windows_continue (continue_status
, desired_stop_thread_id
, 0));
1760 inferior_ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1761 current_windows_thread
= th
;
1762 if (!current_windows_thread
)
1763 current_windows_thread
= thread_rec (inferior_ptid
,
1764 INVALIDATE_CONTEXT
);
1771 /* Wait for interesting events to occur in the target process. */
1773 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1778 /* We loop when we get a non-standard exception rather than return
1779 with a SPURIOUS because resume can try and step or modify things,
1780 which needs a current_thread->h. But some of these exceptions mark
1781 the birth or death of threads, which mean that the current thread
1782 isn't necessarily what you think it is. */
1788 /* If the user presses Ctrl-c while the debugger is waiting
1789 for an event, he expects the debugger to interrupt his program
1790 and to get the prompt back. There are two possible situations:
1792 - The debugger and the program do not share the console, in
1793 which case the Ctrl-c event only reached the debugger.
1794 In that case, the ctrl_c handler will take care of interrupting
1795 the inferior. Note that this case is working starting with
1796 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1799 - The debugger and the program share the same console, in which
1800 case both debugger and inferior will receive the Ctrl-c event.
1801 In that case the ctrl_c handler will ignore the event, as the
1802 Ctrl-c event generated inside the inferior will trigger the
1803 expected debug event.
1805 FIXME: brobecker/2008-05-20: If the inferior receives the
1806 signal first and the delay until GDB receives that signal
1807 is sufficiently long, GDB can sometimes receive the SIGINT
1808 after we have unblocked the CTRL+C handler. This would
1809 lead to the debugger stopping prematurely while handling
1810 the new-thread event that comes with the handling of the SIGINT
1811 inside the inferior, and then stop again immediately when
1812 the user tries to resume the execution in the inferior.
1813 This is a classic race that we should try to fix one day. */
1814 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1815 retval
= get_windows_debug_event (pid
, ourstatus
);
1816 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1820 ptid_t result
= ptid_t (current_event
.dwProcessId
, retval
, 0);
1822 if (current_windows_thread
!= nullptr)
1824 current_windows_thread
->stopped_at_software_breakpoint
= false;
1825 if (current_event
.dwDebugEventCode
== EXCEPTION_DEBUG_EVENT
1826 && (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1827 == EXCEPTION_BREAKPOINT
)
1828 && windows_initialization_done
)
1829 current_windows_thread
->stopped_at_software_breakpoint
= true;
1838 if (deprecated_ui_loop_hook
!= NULL
)
1839 detach
= deprecated_ui_loop_hook (0);
1847 /* Iterate over all DLLs currently mapped by our inferior, and
1848 add them to our list of solibs. */
1851 windows_add_all_dlls (void)
1853 HMODULE dummy_hmodule
;
1861 if (EnumProcessModulesEx (current_process_handle
, &dummy_hmodule
,
1862 sizeof (HMODULE
), &cb_needed
,
1863 LIST_MODULES_32BIT
) == 0)
1869 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
1870 sizeof (HMODULE
), &cb_needed
) == 0)
1877 hmodules
= (HMODULE
*) alloca (cb_needed
);
1881 if (EnumProcessModulesEx (current_process_handle
, hmodules
,
1882 cb_needed
, &cb_needed
,
1883 LIST_MODULES_32BIT
) == 0)
1889 if (EnumProcessModules (current_process_handle
, hmodules
,
1890 cb_needed
, &cb_needed
) == 0)
1894 char system_dir
[__PMAX
];
1895 char syswow_dir
[__PMAX
];
1896 size_t system_dir_len
= 0;
1897 bool convert_syswow_dir
= false;
1902 /* This fails on 32bit Windows because it has no SysWOW64 directory,
1903 and in this case a path conversion isn't necessary. */
1904 UINT len
= GetSystemWow64DirectoryA (syswow_dir
, sizeof (syswow_dir
));
1907 /* Check that we have passed a large enough buffer. */
1908 gdb_assert (len
< sizeof (syswow_dir
));
1910 len
= GetSystemDirectoryA (system_dir
, sizeof (system_dir
));
1912 gdb_assert (len
!= 0);
1913 /* Check that we have passed a large enough buffer. */
1914 gdb_assert (len
< sizeof (system_dir
));
1916 strcat (system_dir
, "\\");
1917 strcat (syswow_dir
, "\\");
1918 system_dir_len
= strlen (system_dir
);
1920 convert_syswow_dir
= true;
1924 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
1928 wchar_t dll_name
[__PMAX
];
1929 char dll_name_mb
[__PMAX
];
1931 char dll_name
[__PMAX
];
1934 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
1935 &mi
, sizeof (mi
)) == 0)
1937 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
1938 dll_name
, sizeof (dll_name
)) == 0)
1941 wcstombs (dll_name_mb
, dll_name
, __PMAX
);
1946 /* Convert the DLL path of 32bit processes returned by
1947 GetModuleFileNameEx from the 64bit system directory to the
1948 32bit syswow64 directory if necessary. */
1949 std::string syswow_dll_path
;
1950 if (convert_syswow_dir
1951 && strncasecmp (name
, system_dir
, system_dir_len
) == 0
1952 && strchr (name
+ system_dir_len
, '\\') == nullptr)
1954 syswow_dll_path
= syswow_dir
;
1955 syswow_dll_path
+= name
+ system_dir_len
;
1956 name
= syswow_dll_path
.c_str();
1959 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
1960 solib_end
= solib_end
->next
;
1965 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1968 struct inferior
*inf
;
1970 last_sig
= GDB_SIGNAL_0
;
1971 open_process_used
= 0;
1972 debug_registers_changed
= 0;
1973 debug_registers_used
= 0;
1974 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1977 cygwin_load_start
= cygwin_load_end
= 0;
1979 current_event
.dwProcessId
= pid
;
1980 memset (¤t_event
, 0, sizeof (current_event
));
1981 if (!target_is_pushed (ops
))
1983 disable_breakpoints_in_shlibs ();
1984 windows_clear_solib ();
1985 clear_proceed_status (0);
1986 init_wait_for_inferior ();
1989 ignore_first_breakpoint
= !attaching
&& wow64_process
;
1993 windows_set_context_register_offsets (amd64_mappings
);
1994 windows_set_segment_register_p (amd64_windows_segment_register_p
);
1999 windows_set_context_register_offsets (i386_mappings
);
2000 windows_set_segment_register_p (i386_windows_segment_register_p
);
2003 inf
= current_inferior ();
2004 inferior_appeared (inf
, pid
);
2005 inf
->attach_flag
= attaching
;
2007 /* Make the new process the current inferior, so terminal handling
2008 can rely on it. When attaching, we don't know about any thread
2009 id here, but that's OK --- nothing should be referencing the
2010 current thread until we report an event out of windows_wait. */
2011 inferior_ptid
= ptid_t (pid
);
2013 target_terminal::init ();
2014 target_terminal::inferior ();
2016 windows_initialization_done
= 0;
2020 struct target_waitstatus status
;
2022 ops
->wait (minus_one_ptid
, &status
, 0);
2024 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
2026 if (status
.kind
!= TARGET_WAITKIND_LOADED
2027 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
2030 ops
->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
2033 /* Now that the inferior has been started and all DLLs have been mapped,
2034 we can iterate over all DLLs and load them in.
2036 We avoid doing it any earlier because, on certain versions of Windows,
2037 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
2038 we have seen on Windows 8.1 that the ntdll.dll load event does not
2039 include the DLL name, preventing us from creating an associated SO.
2040 A possible explanation is that ntdll.dll might be mapped before
2041 the SO info gets created by the Windows system -- ntdll.dll is
2042 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
2043 do not seem to suffer from that problem.
2045 Rather than try to work around this sort of issue, it is much
2046 simpler to just ignore DLL load/unload events during the startup
2047 phase, and then process them all in one batch now. */
2048 windows_add_all_dlls ();
2050 windows_initialization_done
= 1;
2054 /* Try to set or remove a user privilege to the current process. Return -1
2055 if that fails, the previous setting of that privilege otherwise.
2057 This code is copied from the Cygwin source code and rearranged to allow
2058 dynamically loading of the needed symbols from advapi32 which is only
2059 available on NT/2K/XP. */
2061 set_process_privilege (const char *privilege
, BOOL enable
)
2063 HANDLE token_hdl
= NULL
;
2065 TOKEN_PRIVILEGES new_priv
, orig_priv
;
2069 if (!OpenProcessToken (GetCurrentProcess (),
2070 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
2074 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
2077 new_priv
.PrivilegeCount
= 1;
2078 new_priv
.Privileges
[0].Luid
= restore_priv
;
2079 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
2081 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
2082 sizeof orig_priv
, &orig_priv
, &size
))
2085 /* Disabled, otherwise every `attach' in an unprivileged user session
2086 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
2087 windows_attach(). */
2088 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
2089 be enabled. GetLastError () returns an correct error code, though. */
2090 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
2094 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
2098 CloseHandle (token_hdl
);
2103 /* Attach to process PID, then initialize for debugging it. */
2106 windows_nat_target::attach (const char *args
, int from_tty
)
2111 pid
= parse_pid_to_attach (args
);
2113 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
2115 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
2116 printf_unfiltered ("This can cause attach to "
2117 "fail on Windows NT/2K/XP\n");
2120 windows_init_thread_list ();
2121 ok
= DebugActiveProcess (pid
);
2127 /* Try fall back to Cygwin pid. */
2128 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
2131 ok
= DebugActiveProcess (pid
);
2136 error (_("Can't attach to process %u (error %u)"),
2137 (unsigned) pid
, (unsigned) GetLastError ());
2139 DebugSetProcessKillOnExit (FALSE
);
2143 const char *exec_file
= get_exec_file (0);
2146 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
2147 target_pid_to_str (ptid_t (pid
)).c_str ());
2149 printf_unfiltered ("Attaching to %s\n",
2150 target_pid_to_str (ptid_t (pid
)).c_str ());
2154 HANDLE h
= OpenProcess (PROCESS_QUERY_INFORMATION
, FALSE
, pid
);
2158 if (IsWow64Process (h
, &wow64
))
2159 wow64_process
= wow64
;
2164 do_initial_windows_stuff (this, pid
, 1);
2165 target_terminal::ours ();
2169 windows_nat_target::detach (inferior
*inf
, int from_tty
)
2173 ptid_t ptid
= minus_one_ptid
;
2174 resume (ptid
, 0, GDB_SIGNAL_0
);
2176 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
2178 error (_("Can't detach process %u (error %u)"),
2179 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
2182 DebugSetProcessKillOnExit (FALSE
);
2184 if (detached
&& from_tty
)
2186 const char *exec_file
= get_exec_file (0);
2189 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
2190 (unsigned) current_event
.dwProcessId
);
2193 x86_cleanup_dregs ();
2194 inferior_ptid
= null_ptid
;
2195 detach_inferior (inf
);
2197 maybe_unpush_target ();
2200 /* Try to determine the executable filename.
2202 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2204 Upon success, the filename is stored inside EXE_NAME_RET, and
2205 this function returns nonzero.
2207 Otherwise, this function returns zero and the contents of
2208 EXE_NAME_RET is undefined. */
2211 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2221 if (!EnumProcessModulesEx (current_process_handle
, &dh_buf
,
2222 sizeof (HMODULE
), &cbNeeded
,
2223 LIST_MODULES_32BIT
) || !cbNeeded
)
2229 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2230 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2234 /* We know the executable is always first in the list of modules,
2235 which we just fetched. So no need to fetch more. */
2239 /* Cygwin prefers that the path be in /x/y/z format, so extract
2240 the filename into a temporary buffer first, and then convert it
2241 to POSIX format into the destination buffer. */
2242 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2244 len
= GetModuleFileNameEx (current_process_handle
,
2245 dh_buf
, pathbuf
, exe_name_max_len
);
2247 error (_("Error getting executable filename: %u."),
2248 (unsigned) GetLastError ());
2249 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2250 exe_name_max_len
) < 0)
2251 error (_("Error converting executable filename to POSIX: %d."), errno
);
2254 len
= GetModuleFileNameEx (current_process_handle
,
2255 dh_buf
, exe_name_ret
, exe_name_max_len
);
2257 error (_("Error getting executable filename: %u."),
2258 (unsigned) GetLastError ());
2261 return 1; /* success */
2264 /* The pid_to_exec_file target_ops method for this platform. */
2267 windows_nat_target::pid_to_exec_file (int pid
)
2269 static char path
[__PMAX
];
2271 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2273 char procexe
[sizeof ("/proc/4294967295/exe")];
2275 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2276 nchars
= readlink (procexe
, path
, sizeof(path
));
2277 if (nchars
> 0 && nchars
< sizeof (path
))
2279 path
[nchars
] = '\0'; /* Got it */
2284 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2285 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2286 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2292 /* Print status information about what we're accessing. */
2295 windows_nat_target::files_info ()
2297 struct inferior
*inf
= current_inferior ();
2299 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2300 inf
->attach_flag
? "attached" : "child",
2301 target_pid_to_str (inferior_ptid
).c_str ());
2304 /* Modify CreateProcess parameters for use of a new separate console.
2306 *FLAGS: DWORD parameter for general process creation flags.
2307 *SI: STARTUPINFO structure, for which the console window size and
2308 console buffer size is filled in if GDB is running in a console.
2309 to create the new console.
2310 The size of the used font is not available on all versions of
2311 Windows OS. Furthermore, the current font might not be the default
2312 font, but this is still better than before.
2313 If the windows and buffer sizes are computed,
2314 SI->DWFLAGS is changed so that this information is used
2315 by CreateProcess function. */
2318 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2320 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2321 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2323 if (hconsole
!= INVALID_HANDLE_VALUE
)
2325 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2327 CONSOLE_FONT_INFO cfi
;
2329 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2330 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2331 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2332 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2333 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2335 si
->dwXSize
*= font_size
.X
;
2339 si
->dwYSize
*= font_size
.Y
;
2342 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2343 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2344 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2346 *flags
|= CREATE_NEW_CONSOLE
;
2350 /* Function called by qsort to sort environment strings. */
2353 envvar_cmp (const void *a
, const void *b
)
2355 const char **p
= (const char **) a
;
2356 const char **q
= (const char **) b
;
2357 return strcasecmp (*p
, *q
);
2363 clear_win32_environment (char **env
)
2367 wchar_t *copy
= NULL
, *equalpos
;
2369 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2371 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2372 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2373 mbstowcs (copy
, env
[i
], len
);
2374 equalpos
= wcschr (copy
, L
'=');
2377 SetEnvironmentVariableW (copy
, NULL
);
2385 /* Redirection of inferior I/O streams for native MS-Windows programs.
2386 Unlike on Unix, where this is handled by invoking the inferior via
2387 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2389 The official documentation of the cmd.exe redirection features is here:
2391 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2393 (That page talks about Windows XP, but there's no newer
2394 documentation, so we assume later versions of cmd.exe didn't change
2397 Caveat: the documentation on that page seems to include a few lies.
2398 For example, it describes strange constructs 1<&2 and 2<&1, which
2399 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2400 think the cmd.exe parser of the redirection symbols simply doesn't
2401 care about the < vs > distinction in these cases. Therefore, the
2402 supported features are explicitly documented below.
2404 The emulation below aims at supporting all the valid use cases
2405 supported by cmd.exe, which include:
2407 < FILE redirect standard input from FILE
2408 0< FILE redirect standard input from FILE
2409 <&N redirect standard input from file descriptor N
2410 0<&N redirect standard input from file descriptor N
2411 > FILE redirect standard output to FILE
2412 >> FILE append standard output to FILE
2413 1>> FILE append standard output to FILE
2414 >&N redirect standard output to file descriptor N
2415 1>&N redirect standard output to file descriptor N
2416 >>&N append standard output to file descriptor N
2417 1>>&N append standard output to file descriptor N
2418 2> FILE redirect standard error to FILE
2419 2>> FILE append standard error to FILE
2420 2>&N redirect standard error to file descriptor N
2421 2>>&N append standard error to file descriptor N
2423 Note that using N > 2 in the above construct is supported, but
2424 requires that the corresponding file descriptor be open by some
2425 means elsewhere or outside GDB. Also note that using ">&0" or
2426 "<&2" will generally fail, because the file descriptor redirected
2427 from is normally open in an incompatible mode (e.g., FD 0 is open
2428 for reading only). IOW, use of such tricks is not recommended;
2429 you are on your own.
2431 We do NOT support redirection of file descriptors above 2, as in
2432 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2433 that needs special handling in the startup code that MinGW
2434 doesn't have). Pipes are also not supported.
2436 As for invalid use cases, where the redirection contains some
2437 error, the emulation below will detect that and produce some
2438 error and/or failure. But the behavior in those cases is not
2439 bug-for-bug compatible with what cmd.exe does in those cases.
2440 That's because what cmd.exe does then is not well defined, and
2441 seems to be a side effect of the cmd.exe parsing of the command
2442 line more than anything else. For example, try redirecting to an
2443 invalid file name, as in "> foo:bar".
2445 There are also minor syntactic deviations from what cmd.exe does
2446 in some corner cases. For example, it doesn't support the likes
2447 of "> &foo" to mean redirect to file named literally "&foo"; we
2448 do support that here, because that, too, sounds like some issue
2449 with the cmd.exe parser. Another nicety is that we support
2450 redirection targets that use file names with forward slashes,
2451 something cmd.exe doesn't -- this comes in handy since GDB
2452 file-name completion can be used when typing the command line for
2455 /* Support routines for redirecting standard handles of the inferior. */
2457 /* Parse a single redirection spec, open/duplicate the specified
2458 file/fd, and assign the appropriate value to one of the 3 standard
2459 file descriptors. */
2461 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2463 int *fd
, ref_fd
= -2;
2465 const char *fname
= redir_string
+ 1;
2466 int rc
= *redir_string
;
2481 fd
= (rc
== '2') ? err
: out
;
2482 mode
= O_WRONLY
| O_CREAT
;
2495 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2497 /* A reference to a file descriptor. */
2499 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2500 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2502 /* Don't allow redirection when open modes are incompatible. */
2503 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2504 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2511 else if (ref_fd
== 1)
2513 else if (ref_fd
== 2)
2523 fname
++; /* skip the separator space */
2524 /* If the descriptor is already open, close it. This allows
2525 multiple specs of redirections for the same stream, which is
2526 somewhat nonsensical, but still valid and supported by cmd.exe.
2527 (But cmd.exe only opens a single file in this case, the one
2528 specified by the last redirection spec on the command line.) */
2533 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2537 else if (ref_fd
== -1)
2538 *fd
= -1; /* reset to default destination */
2541 *fd
= _dup (ref_fd
);
2545 /* _open just sets a flag for O_APPEND, which won't be passed to the
2546 inferior, so we need to actually move the file pointer. */
2547 if ((mode
& O_APPEND
) != 0)
2548 _lseek (*fd
, 0L, SEEK_END
);
2552 /* Canonicalize a single redirection spec and set up the corresponding
2553 file descriptor as specified. */
2555 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2557 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2559 const char *start
= s
;
2562 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2563 if ((*start
== '>' || *start
== '1' || *start
== '2')
2567 if (*s
== '>' && *start
!= '>')
2570 else if (*start
== '0' && *s
== '<')
2572 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2575 while (isspace (*s
)) /* skip whitespace before file name */
2577 *d
++ = ' '; /* separate file name with a single space */
2580 /* Copy the file name. */
2583 /* Remove quoting characters from the file name in buf[]. */
2584 if (*s
== '"') /* could support '..' quoting here */
2588 else if (*s
== quote
)
2596 else if (*s
== '\\')
2598 if (s
[1] == '"') /* could support '..' here */
2602 else if (isspace (*s
) && !quote
)
2606 if (d
- buf
>= sizeof (buf
) - 1)
2608 errno
= ENAMETOOLONG
;
2614 /* Windows doesn't allow redirection characters in file names, so we
2615 can bail out early if they use them, or if there's no target file
2616 name after the redirection symbol. */
2617 if (d
[-1] == '>' || d
[-1] == '<')
2622 if (redir_open (buf
, inp
, out
, err
) == 0)
2627 /* Parse the command line for redirection specs and prepare the file
2628 descriptors for the 3 standard streams accordingly. */
2630 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2631 int *inp
, int *out
, int *err
)
2633 const char *s
= cmd_orig
;
2636 bool retval
= false;
2638 while (isspace (*s
))
2643 if (*s
== '"') /* could also support '..' quoting here */
2647 else if (*s
== quote
)
2650 else if (*s
== '\\')
2652 if (s
[1] == '"') /* escaped quote char */
2657 /* Process a single redirection candidate. */
2658 if (*s
== '<' || *s
== '>'
2659 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2660 || (*s
== '0' && s
[1] == '<'))
2662 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2676 #endif /* !__CYGWIN__ */
2678 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2679 EXEC_FILE is the file to run.
2680 ALLARGS is a string containing the arguments to the program.
2681 ENV is the environment vector to pass. Errors reported with error(). */
2684 windows_nat_target::create_inferior (const char *exec_file
,
2685 const std::string
&origallargs
,
2686 char **in_env
, int from_tty
)
2690 cygwin_buf_t real_path
[__PMAX
];
2691 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2692 cygwin_buf_t infcwd
[__PMAX
];
2694 cygwin_buf_t
*toexec
;
2695 cygwin_buf_t
*cygallargs
;
2697 char **old_env
= NULL
;
2701 int ostdin
, ostdout
, ostderr
;
2702 #else /* !__CYGWIN__ */
2703 char shell
[__PMAX
]; /* Path to shell */
2705 char *args
, *allargs_copy
;
2706 size_t args_len
, allargs_len
;
2707 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2708 HANDLE tty
= INVALID_HANDLE_VALUE
;
2709 bool redirected
= false;
2716 #endif /* !__CYGWIN__ */
2717 const char *allargs
= origallargs
.c_str ();
2718 PROCESS_INFORMATION pi
;
2721 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2724 error (_("No executable specified, use `target exec'."));
2726 const char *inferior_cwd
= get_inferior_cwd ();
2727 std::string expanded_infcwd
;
2728 if (inferior_cwd
!= NULL
)
2730 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
2731 /* Mirror slashes on inferior's cwd. */
2732 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
2734 inferior_cwd
= expanded_infcwd
.c_str ();
2737 memset (&si
, 0, sizeof (si
));
2738 si
.cb
= sizeof (si
);
2741 flags
|= CREATE_NEW_PROCESS_GROUP
;
2744 windows_set_console_info (&si
, &flags
);
2749 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2750 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2751 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2752 error (_("Error starting executable: %d"), errno
);
2755 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2756 if (len
== (size_t) -1)
2757 error (_("Error starting executable: %d"), errno
);
2758 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2759 mbstowcs (cygallargs
, allargs
, len
);
2760 #else /* !__USEWIDE */
2761 cygallargs
= allargs
;
2767 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2768 error (_("Error starting executable via shell: %d"), errno
);
2770 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2771 + mbstowcs (NULL
, allargs
, 0) + 2;
2772 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2773 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2774 #else /* !__USEWIDE */
2775 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2776 + strlen (allargs
) + 2);
2777 cygallargs
= (char *) alloca (len
);
2778 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2779 #endif /* __USEWIDE */
2781 flags
|= DEBUG_PROCESS
;
2784 if (inferior_cwd
!= NULL
2785 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
2786 infcwd
, strlen (inferior_cwd
)) < 0)
2787 error (_("Error converting inferior cwd: %d"), errno
);
2790 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2791 * sizeof (wchar_t));
2792 wcscpy (args
, toexec
);
2793 wcscat (args
, L
" ");
2794 wcscat (args
, cygallargs
);
2795 #else /* !__USEWIDE */
2796 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2797 strcpy (args
, toexec
);
2799 strcat (args
, cygallargs
);
2800 #endif /* !__USEWIDE */
2802 #ifdef CW_CVT_ENV_TO_WINENV
2803 /* First try to create a direct Win32 copy of the POSIX environment. */
2804 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2805 if (w32_env
!= (PWCHAR
) -1)
2806 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2808 /* If that fails, fall back to old method tweaking GDB's environment. */
2809 #endif /* CW_CVT_ENV_TO_WINENV */
2811 /* Reset all Win32 environment variables to avoid leftover on next run. */
2812 clear_win32_environment (environ
);
2813 /* Prepare the environment vars for CreateProcess. */
2816 cygwin_internal (CW_SYNC_WINENV
);
2820 if (!inferior_io_terminal
)
2821 tty
= ostdin
= ostdout
= ostderr
= -1;
2824 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2827 print_sys_errmsg (inferior_io_terminal
, errno
);
2828 ostdin
= ostdout
= ostderr
= -1;
2841 windows_init_thread_list ();
2842 ret
= CreateProcess (0,
2843 args
, /* command line */
2844 NULL
, /* Security */
2846 TRUE
, /* inherit handles */
2847 flags
, /* start flags */
2848 w32_env
, /* environment */
2849 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
2854 /* Just free the Win32 environment, if it could be created. */
2858 /* Reset all environment variables to avoid leftover on next run. */
2859 clear_win32_environment (in_env
);
2860 /* Restore normal GDB environment variables. */
2862 cygwin_internal (CW_SYNC_WINENV
);
2875 #else /* !__CYGWIN__ */
2876 allargs_len
= strlen (allargs
);
2877 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
2878 if (strpbrk (allargs_copy
, "<>") != NULL
)
2883 redirect_inferior_handles (allargs
, allargs_copy
,
2884 &fd_inp
, &fd_out
, &fd_err
);
2886 warning (_("Error in redirection: %s."), safe_strerror (errno
));
2889 allargs_len
= strlen (allargs_copy
);
2891 /* If not all the standard streams are redirected by the command
2892 line, use inferior_io_terminal for those which aren't. */
2893 if (inferior_io_terminal
2894 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
2896 SECURITY_ATTRIBUTES sa
;
2897 sa
.nLength
= sizeof(sa
);
2898 sa
.lpSecurityDescriptor
= 0;
2899 sa
.bInheritHandle
= TRUE
;
2900 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2901 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2902 if (tty
== INVALID_HANDLE_VALUE
)
2903 warning (_("Warning: Failed to open TTY %s, error %#x."),
2904 inferior_io_terminal
, (unsigned) GetLastError ());
2906 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
2909 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
2910 else if (tty
!= INVALID_HANDLE_VALUE
)
2913 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
2915 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
2916 else if (tty
!= INVALID_HANDLE_VALUE
)
2917 si
.hStdOutput
= tty
;
2919 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
2921 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
2922 else if (tty
!= INVALID_HANDLE_VALUE
)
2925 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
2926 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2930 /* Build the command line, a space-separated list of tokens where
2931 the first token is the name of the module to be executed.
2932 To avoid ambiguities introduced by spaces in the module name,
2934 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
2935 args
= (char *) alloca (args_len
);
2936 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
2938 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2940 /* CreateProcess takes the environment list as a null terminated set of
2941 strings (i.e. two nulls terminate the list). */
2943 /* Get total size for env strings. */
2944 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2945 envlen
+= strlen (in_env
[i
]) + 1;
2947 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2948 env
= (char **) alloca (envsize
);
2949 memcpy (env
, in_env
, envsize
);
2950 /* Windows programs expect the environment block to be sorted. */
2951 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2953 w32env
= (char *) alloca (envlen
+ 1);
2955 /* Copy env strings into new buffer. */
2956 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2958 strcpy (temp
, env
[i
]);
2959 temp
+= strlen (temp
) + 1;
2962 /* Final nil string to terminate new env. */
2965 windows_init_thread_list ();
2966 ret
= CreateProcessA (0,
2967 args
, /* command line */
2968 NULL
, /* Security */
2970 TRUE
, /* inherit handles */
2971 flags
, /* start flags */
2972 w32env
, /* environment */
2973 inferior_cwd
, /* current directory */
2976 if (tty
!= INVALID_HANDLE_VALUE
)
2984 #endif /* !__CYGWIN__ */
2987 error (_("Error creating process %s, (error %u)."),
2988 exec_file
, (unsigned) GetLastError ());
2992 if (IsWow64Process (pi
.hProcess
, &wow64
))
2993 wow64_process
= wow64
;
2996 CloseHandle (pi
.hThread
);
2997 CloseHandle (pi
.hProcess
);
2999 if (useshell
&& shell
[0] != '\0')
3004 do_initial_windows_stuff (this, pi
.dwProcessId
, 0);
3006 /* windows_continue (DBG_CONTINUE, -1, 0); */
3010 windows_nat_target::mourn_inferior ()
3012 (void) windows_continue (DBG_CONTINUE
, -1, 0);
3013 x86_cleanup_dregs();
3014 if (open_process_used
)
3016 CHECK (CloseHandle (current_process_handle
));
3017 open_process_used
= 0;
3019 siginfo_er
.ExceptionCode
= 0;
3020 inf_child_target::mourn_inferior ();
3023 /* Send a SIGINT to the process group. This acts just like the user typed a
3024 ^C on the controlling terminal. */
3027 windows_nat_target::interrupt ()
3029 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
3030 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
3031 registers_changed (); /* refresh register state */
3034 /* Helper for windows_xfer_partial that handles memory transfers.
3035 Arguments are like target_xfer_partial. */
3037 static enum target_xfer_status
3038 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3039 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
3043 DWORD lasterror
= 0;
3045 if (writebuf
!= NULL
)
3047 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
3048 pulongest (len
), core_addr_to_string (memaddr
)));
3049 success
= WriteProcessMemory (current_process_handle
,
3050 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
3053 lasterror
= GetLastError ();
3054 FlushInstructionCache (current_process_handle
,
3055 (LPCVOID
) (uintptr_t) memaddr
, len
);
3059 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
3060 pulongest (len
), core_addr_to_string (memaddr
)));
3061 success
= ReadProcessMemory (current_process_handle
,
3062 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
3065 lasterror
= GetLastError ();
3067 *xfered_len
= (ULONGEST
) done
;
3068 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
3069 return TARGET_XFER_OK
;
3071 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
3075 windows_nat_target::kill ()
3077 CHECK (TerminateProcess (current_process_handle
, 0));
3081 if (!windows_continue (DBG_CONTINUE
, -1, 1))
3083 if (!wait_for_debug_event (¤t_event
, INFINITE
))
3085 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
3089 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
3093 windows_nat_target::close ()
3095 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
3096 inferior_ptid
.pid ()));
3099 /* Convert pid to printable format. */
3101 windows_nat_target::pid_to_str (ptid_t ptid
)
3103 if (ptid
.lwp () != 0)
3104 return string_printf ("Thread %d.0x%lx", ptid
.pid (), ptid
.lwp ());
3106 return normal_pid_to_str (ptid
);
3109 static enum target_xfer_status
3110 windows_xfer_shared_libraries (struct target_ops
*ops
,
3111 enum target_object object
, const char *annex
,
3112 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3113 ULONGEST offset
, ULONGEST len
,
3114 ULONGEST
*xfered_len
)
3116 struct obstack obstack
;
3122 return TARGET_XFER_E_IO
;
3124 obstack_init (&obstack
);
3125 obstack_grow_str (&obstack
, "<library-list>\n");
3126 for (so
= solib_start
.next
; so
; so
= so
->next
)
3128 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
3130 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
3131 (uintptr_t) li
->load_addr
,
3133 target_gdbarch (), &obstack
);
3135 obstack_grow_str0 (&obstack
, "</library-list>\n");
3137 buf
= (const char *) obstack_finish (&obstack
);
3138 len_avail
= strlen (buf
);
3139 if (offset
>= len_avail
)
3143 if (len
> len_avail
- offset
)
3144 len
= len_avail
- offset
;
3145 memcpy (readbuf
, buf
+ offset
, len
);
3148 obstack_free (&obstack
, NULL
);
3149 *xfered_len
= (ULONGEST
) len
;
3150 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
3153 /* Helper for windows_nat_target::xfer_partial that handles signal info. */
3155 static enum target_xfer_status
3156 windows_xfer_siginfo (gdb_byte
*readbuf
, ULONGEST offset
, ULONGEST len
,
3157 ULONGEST
*xfered_len
)
3159 char *buf
= (char *) &siginfo_er
;
3160 size_t bufsize
= sizeof (siginfo_er
);
3163 EXCEPTION_RECORD32 er32
;
3166 buf
= (char *) &er32
;
3167 bufsize
= sizeof (er32
);
3169 er32
.ExceptionCode
= siginfo_er
.ExceptionCode
;
3170 er32
.ExceptionFlags
= siginfo_er
.ExceptionFlags
;
3171 er32
.ExceptionRecord
= (uintptr_t) siginfo_er
.ExceptionRecord
;
3172 er32
.ExceptionAddress
= (uintptr_t) siginfo_er
.ExceptionAddress
;
3173 er32
.NumberParameters
= siginfo_er
.NumberParameters
;
3175 for (i
= 0; i
< EXCEPTION_MAXIMUM_PARAMETERS
; i
++)
3176 er32
.ExceptionInformation
[i
] = siginfo_er
.ExceptionInformation
[i
];
3180 if (siginfo_er
.ExceptionCode
== 0)
3181 return TARGET_XFER_E_IO
;
3183 if (readbuf
== nullptr)
3184 return TARGET_XFER_E_IO
;
3186 if (offset
> bufsize
)
3187 return TARGET_XFER_E_IO
;
3189 if (offset
+ len
> bufsize
)
3190 len
= bufsize
- offset
;
3192 memcpy (readbuf
, buf
+ offset
, len
);
3195 return TARGET_XFER_OK
;
3198 enum target_xfer_status
3199 windows_nat_target::xfer_partial (enum target_object object
,
3200 const char *annex
, gdb_byte
*readbuf
,
3201 const gdb_byte
*writebuf
, ULONGEST offset
,
3202 ULONGEST len
, ULONGEST
*xfered_len
)
3206 case TARGET_OBJECT_MEMORY
:
3207 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
3209 case TARGET_OBJECT_LIBRARIES
:
3210 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
3211 writebuf
, offset
, len
, xfered_len
);
3213 case TARGET_OBJECT_SIGNAL_INFO
:
3214 return windows_xfer_siginfo (readbuf
, offset
, len
, xfered_len
);
3217 if (beneath () == NULL
)
3219 /* This can happen when requesting the transfer of unsupported
3220 objects before a program has been started (and therefore
3221 with the current_target having no target beneath). */
3222 return TARGET_XFER_E_IO
;
3224 return beneath ()->xfer_partial (object
, annex
,
3225 readbuf
, writebuf
, offset
, len
,
3230 /* Provide thread local base, i.e. Thread Information Block address.
3231 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
3234 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
3236 windows_thread_info
*th
;
3238 th
= thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
);
3243 *addr
= th
->thread_local_base
;
3249 windows_nat_target::get_ada_task_ptid (long lwp
, long thread
)
3251 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
3254 /* Implementation of the to_thread_name method. */
3257 windows_nat_target::thread_name (struct thread_info
*thr
)
3259 return thread_rec (thr
->ptid
, DONT_INVALIDATE_CONTEXT
)->name
.get ();
3263 void _initialize_windows_nat ();
3265 _initialize_windows_nat ()
3267 x86_dr_low
.set_control
= cygwin_set_dr7
;
3268 x86_dr_low
.set_addr
= cygwin_set_dr
;
3269 x86_dr_low
.get_addr
= cygwin_get_dr
;
3270 x86_dr_low
.get_status
= cygwin_get_dr6
;
3271 x86_dr_low
.get_control
= cygwin_get_dr7
;
3273 /* x86_dr_low.debug_register_length field is set by
3274 calling x86_set_debug_register_length function
3275 in processor windows specific native file. */
3277 add_inf_child_target (&the_windows_nat_target
);
3280 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3283 add_com ("signal-event", class_run
, signal_event_command
, _("\
3284 Signal a crashed process with event ID, to allow its debugging.\n\
3285 This command is needed in support of setting up GDB as JIT debugger on \
3286 MS-Windows. The command should be invoked from the GDB command line using \
3287 the '-ex' command-line option. The ID of the event that blocks the \
3288 crashed process will be supplied by the Windows JIT debugging mechanism."));
3291 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3292 Set use of shell to start subprocess."), _("\
3293 Show use of shell to start subprocess."), NULL
,
3295 NULL
, /* FIXME: i18n: */
3296 &setlist
, &showlist
);
3298 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3299 &cygwin_exceptions
, _("\
3300 Break when an exception is detected in the Cygwin DLL itself."), _("\
3301 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3303 NULL
, /* FIXME: i18n: */
3304 &setlist
, &showlist
);
3307 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3308 Set creation of new console when creating child process."), _("\
3309 Show creation of new console when creating child process."), NULL
,
3311 NULL
, /* FIXME: i18n: */
3312 &setlist
, &showlist
);
3314 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3315 Set creation of new group when creating child process."), _("\
3316 Show creation of new group when creating child process."), NULL
,
3318 NULL
, /* FIXME: i18n: */
3319 &setlist
, &showlist
);
3321 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3322 Set whether to display execution in child process."), _("\
3323 Show whether to display execution in child process."), NULL
,
3325 NULL
, /* FIXME: i18n: */
3326 &setlist
, &showlist
);
3328 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3329 Set whether to display kernel events in child process."), _("\
3330 Show whether to display kernel events in child process."), NULL
,
3332 NULL
, /* FIXME: i18n: */
3333 &setlist
, &showlist
);
3335 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3336 Set whether to display memory accesses in child process."), _("\
3337 Show whether to display memory accesses in child process."), NULL
,
3339 NULL
, /* FIXME: i18n: */
3340 &setlist
, &showlist
);
3342 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3343 &debug_exceptions
, _("\
3344 Set whether to display kernel exceptions in child process."), _("\
3345 Show whether to display kernel exceptions in child process."), NULL
,
3347 NULL
, /* FIXME: i18n: */
3348 &setlist
, &showlist
);
3350 init_w32_command_list ();
3352 add_cmd ("selector", class_info
, display_selectors
,
3353 _("Display selectors infos."),
3357 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3359 /* Pass the address ADDR to the inferior in the I'th debug register.
3360 Here we just store the address in dr array, the registers will be
3361 actually set up when windows_continue is called. */
3363 cygwin_set_dr (int i
, CORE_ADDR addr
)
3366 internal_error (__FILE__
, __LINE__
,
3367 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3369 debug_registers_changed
= 1;
3370 debug_registers_used
= 1;
3373 /* Pass the value VAL to the inferior in the DR7 debug control
3374 register. Here we just store the address in D_REGS, the watchpoint
3375 will be actually set up in windows_wait. */
3377 cygwin_set_dr7 (unsigned long val
)
3379 dr
[7] = (CORE_ADDR
) val
;
3380 debug_registers_changed
= 1;
3381 debug_registers_used
= 1;
3384 /* Get the value of debug register I from the inferior. */
3387 cygwin_get_dr (int i
)
3392 /* Get the value of the DR6 debug status register from the inferior.
3393 Here we just return the value stored in dr[6]
3394 by the last call to thread_rec for current_event.dwThreadId id. */
3395 static unsigned long
3396 cygwin_get_dr6 (void)
3398 return (unsigned long) dr
[6];
3401 /* Get the value of the DR7 debug status register from the inferior.
3402 Here we just return the value stored in dr[7] by the last call to
3403 thread_rec for current_event.dwThreadId id. */
3405 static unsigned long
3406 cygwin_get_dr7 (void)
3408 return (unsigned long) dr
[7];
3411 /* Determine if the thread referenced by "ptid" is alive
3412 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3413 it means that the thread has died. Otherwise it is assumed to be alive. */
3416 windows_nat_target::thread_alive (ptid_t ptid
)
3418 gdb_assert (ptid
.lwp () != 0);
3420 return (WaitForSingleObject (thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
)->h
, 0)
3424 void _initialize_check_for_gdb_ini ();
3426 _initialize_check_for_gdb_ini ()
3429 if (inhibit_gdbinit
)
3432 homedir
= getenv ("HOME");
3436 char *oldini
= (char *) alloca (strlen (homedir
) +
3437 sizeof ("gdb.ini") + 1);
3438 strcpy (oldini
, homedir
);
3439 p
= strchr (oldini
, '\0');
3440 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3442 strcpy (p
, "gdb.ini");
3443 if (access (oldini
, 0) == 0)
3445 int len
= strlen (oldini
);
3446 char *newini
= (char *) alloca (len
+ 2);
3448 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3449 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3450 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3455 /* Define dummy functions which always return error for the rare cases where
3456 these functions could not be found. */
3458 bad_DebugActiveProcessStop (DWORD w
)
3463 bad_DebugBreakProcess (HANDLE w
)
3468 bad_DebugSetProcessKillOnExit (BOOL w
)
3473 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3480 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3486 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3493 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3499 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3505 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3511 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3519 /* Load any functions which may not be available in ancient versions
3522 void _initialize_loadable ();
3524 _initialize_loadable ()
3528 #define GPA(m, func) \
3529 func = (func ## _ftype *) GetProcAddress (m, #func)
3531 hm
= LoadLibrary ("kernel32.dll");
3534 GPA (hm
, DebugActiveProcessStop
);
3535 GPA (hm
, DebugBreakProcess
);
3536 GPA (hm
, DebugSetProcessKillOnExit
);
3537 GPA (hm
, GetConsoleFontSize
);
3538 GPA (hm
, DebugActiveProcessStop
);
3539 GPA (hm
, GetCurrentConsoleFont
);
3541 GPA (hm
, Wow64SuspendThread
);
3542 GPA (hm
, Wow64GetThreadContext
);
3543 GPA (hm
, Wow64SetThreadContext
);
3544 GPA (hm
, Wow64GetThreadSelectorEntry
);
3548 /* Set variables to dummy versions of these processes if the function
3549 wasn't found in kernel32.dll. */
3550 if (!DebugBreakProcess
)
3551 DebugBreakProcess
= bad_DebugBreakProcess
;
3552 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3554 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3555 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3557 if (!GetConsoleFontSize
)
3558 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3559 if (!GetCurrentConsoleFont
)
3560 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3562 /* Load optional functions used for retrieving filename information
3563 associated with the currently debugged process or its dlls. */
3564 hm
= LoadLibrary ("psapi.dll");
3567 GPA (hm
, EnumProcessModules
);
3569 GPA (hm
, EnumProcessModulesEx
);
3571 GPA (hm
, GetModuleInformation
);
3572 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3573 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3576 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3578 /* Set variables to dummy versions of these processes if the function
3579 wasn't found in psapi.dll. */
3580 EnumProcessModules
= bad_EnumProcessModules
;
3581 GetModuleInformation
= bad_GetModuleInformation
;
3582 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3583 /* This will probably fail on Windows 9x/Me. Let the user know
3584 that we're missing some functionality. */
3586 cannot automatically find executable file or library to read symbols.\n\
3587 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3590 hm
= LoadLibrary ("advapi32.dll");
3593 GPA (hm
, OpenProcessToken
);
3594 GPA (hm
, LookupPrivilegeValueA
);
3595 GPA (hm
, AdjustTokenPrivileges
);
3596 /* Only need to set one of these since if OpenProcessToken fails nothing
3598 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3599 || !AdjustTokenPrivileges
)
3600 OpenProcessToken
= bad_OpenProcessToken
;