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 #define STATUS_WX86_BREAKPOINT 0x4000001F
76 #define STATUS_WX86_SINGLE_STEP 0x4000001E
78 #define AdjustTokenPrivileges dyn_AdjustTokenPrivileges
79 #define DebugActiveProcessStop dyn_DebugActiveProcessStop
80 #define DebugBreakProcess dyn_DebugBreakProcess
81 #define DebugSetProcessKillOnExit dyn_DebugSetProcessKillOnExit
82 #define EnumProcessModules dyn_EnumProcessModules
83 #define EnumProcessModulesEx dyn_EnumProcessModulesEx
84 #define GetModuleInformation dyn_GetModuleInformation
85 #define LookupPrivilegeValueA dyn_LookupPrivilegeValueA
86 #define OpenProcessToken dyn_OpenProcessToken
87 #define GetConsoleFontSize dyn_GetConsoleFontSize
88 #define GetCurrentConsoleFont dyn_GetCurrentConsoleFont
89 #define Wow64SuspendThread dyn_Wow64SuspendThread
90 #define Wow64GetThreadContext dyn_Wow64GetThreadContext
91 #define Wow64SetThreadContext dyn_Wow64SetThreadContext
92 #define Wow64GetThreadSelectorEntry dyn_Wow64GetThreadSelectorEntry
94 typedef BOOL
WINAPI (AdjustTokenPrivileges_ftype
) (HANDLE
, BOOL
,
96 DWORD
, PTOKEN_PRIVILEGES
,
98 static AdjustTokenPrivileges_ftype
*AdjustTokenPrivileges
;
100 typedef BOOL
WINAPI (DebugActiveProcessStop_ftype
) (DWORD
);
101 static DebugActiveProcessStop_ftype
*DebugActiveProcessStop
;
103 typedef BOOL
WINAPI (DebugBreakProcess_ftype
) (HANDLE
);
104 static DebugBreakProcess_ftype
*DebugBreakProcess
;
106 typedef BOOL
WINAPI (DebugSetProcessKillOnExit_ftype
) (BOOL
);
107 static DebugSetProcessKillOnExit_ftype
*DebugSetProcessKillOnExit
;
109 typedef BOOL
WINAPI (EnumProcessModules_ftype
) (HANDLE
, HMODULE
*, DWORD
,
111 static EnumProcessModules_ftype
*EnumProcessModules
;
114 typedef BOOL
WINAPI (EnumProcessModulesEx_ftype
) (HANDLE
, HMODULE
*, DWORD
,
116 static EnumProcessModulesEx_ftype
*EnumProcessModulesEx
;
119 typedef BOOL
WINAPI (GetModuleInformation_ftype
) (HANDLE
, HMODULE
,
120 LPMODULEINFO
, DWORD
);
121 static GetModuleInformation_ftype
*GetModuleInformation
;
123 typedef BOOL
WINAPI (LookupPrivilegeValueA_ftype
) (LPCSTR
, LPCSTR
, PLUID
);
124 static LookupPrivilegeValueA_ftype
*LookupPrivilegeValueA
;
126 typedef BOOL
WINAPI (OpenProcessToken_ftype
) (HANDLE
, DWORD
, PHANDLE
);
127 static OpenProcessToken_ftype
*OpenProcessToken
;
129 typedef BOOL
WINAPI (GetCurrentConsoleFont_ftype
) (HANDLE
, BOOL
,
130 CONSOLE_FONT_INFO
*);
131 static GetCurrentConsoleFont_ftype
*GetCurrentConsoleFont
;
133 typedef COORD
WINAPI (GetConsoleFontSize_ftype
) (HANDLE
, DWORD
);
134 static GetConsoleFontSize_ftype
*GetConsoleFontSize
;
137 typedef DWORD
WINAPI (Wow64SuspendThread_ftype
) (HANDLE
);
138 static Wow64SuspendThread_ftype
*Wow64SuspendThread
;
140 typedef BOOL
WINAPI (Wow64GetThreadContext_ftype
) (HANDLE
, PWOW64_CONTEXT
);
141 static Wow64GetThreadContext_ftype
*Wow64GetThreadContext
;
143 typedef BOOL
WINAPI (Wow64SetThreadContext_ftype
) (HANDLE
,
144 const WOW64_CONTEXT
*);
145 static Wow64SetThreadContext_ftype
*Wow64SetThreadContext
;
147 typedef BOOL
WINAPI (Wow64GetThreadSelectorEntry_ftype
) (HANDLE
, DWORD
,
149 static Wow64GetThreadSelectorEntry_ftype
*Wow64GetThreadSelectorEntry
;
154 #undef GetModuleFileNameEx
157 # define __PMAX (MAX_PATH + 1)
158 typedef DWORD
WINAPI (GetModuleFileNameEx_ftype
) (HANDLE
, HMODULE
, LPSTR
, DWORD
);
159 static GetModuleFileNameEx_ftype
*GetModuleFileNameEx
;
160 # define STARTUPINFO STARTUPINFOA
161 # define CreateProcess CreateProcessA
162 # define GetModuleFileNameEx_name "GetModuleFileNameExA"
163 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
165 # define __PMAX PATH_MAX
166 /* The starting and ending address of the cygwin1.dll text segment. */
167 static CORE_ADDR cygwin_load_start
;
168 static CORE_ADDR cygwin_load_end
;
170 typedef wchar_t cygwin_buf_t
;
171 typedef DWORD
WINAPI (GetModuleFileNameEx_ftype
) (HANDLE
, HMODULE
,
173 static GetModuleFileNameEx_ftype
*GetModuleFileNameEx
;
174 # define STARTUPINFO STARTUPINFOW
175 # define CreateProcess CreateProcessW
176 # define GetModuleFileNameEx_name "GetModuleFileNameExW"
177 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExW
180 static int have_saved_context
; /* True if we've saved context from a
183 static CONTEXT saved_context
; /* Contains the saved context from a
187 /* If we're not using the old Cygwin header file set, define the
188 following which never should have been in the generic Win32 API
189 headers in the first place since they were our own invention... */
190 #ifndef _GNU_H_WINDOWS_H
193 FLAG_TRACE_BIT
= 0x100,
197 #ifndef CONTEXT_EXTENDED_REGISTERS
198 /* This macro is only defined on ia32. It only makes sense on this target,
199 so define it as zero if not already defined. */
200 #define CONTEXT_EXTENDED_REGISTERS 0
203 #define CONTEXT_DEBUGGER_DR CONTEXT_FULL | CONTEXT_FLOATING_POINT \
204 | CONTEXT_SEGMENTS | CONTEXT_DEBUG_REGISTERS \
205 | CONTEXT_EXTENDED_REGISTERS
207 static uintptr_t dr
[8];
208 static int debug_registers_changed
;
209 static int debug_registers_used
;
211 static int windows_initialization_done
;
212 #define DR6_CLEAR_VALUE 0xffff0ff0
214 /* The exception thrown by a program to tell the debugger the name of
215 a thread. The exception record contains an ID of a thread and a
216 name to give it. This exception has no documented name, but MSDN
217 dubs it "MS_VC_EXCEPTION" in one code example. */
218 #define MS_VC_EXCEPTION 0x406d1388
222 HANDLE_EXCEPTION_UNHANDLED
= 0,
223 HANDLE_EXCEPTION_HANDLED
,
224 HANDLE_EXCEPTION_IGNORED
225 } handle_exception_result
;
227 /* The string sent by cygwin when it processes a signal.
228 FIXME: This should be in a cygwin include file. */
229 #ifndef _CYGWIN_SIGNAL_STRING
230 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
233 #define CHECK(x) check (x, __FILE__,__LINE__)
234 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
235 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
236 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
237 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
239 static void cygwin_set_dr (int i
, CORE_ADDR addr
);
240 static void cygwin_set_dr7 (unsigned long val
);
241 static CORE_ADDR
cygwin_get_dr (int i
);
242 static unsigned long cygwin_get_dr6 (void);
243 static unsigned long cygwin_get_dr7 (void);
245 static enum gdb_signal last_sig
= GDB_SIGNAL_0
;
246 /* Set if a signal was received from the debugged process. */
248 static std::vector
<windows_thread_info
*> thread_list
;
250 /* The process and thread handles for the above context. */
252 static DEBUG_EVENT current_event
; /* The current debug event from
254 static HANDLE current_process_handle
; /* Currently executing process */
255 static windows_thread_info
*current_thread
; /* Info on currently selected thread */
256 static EXCEPTION_RECORD siginfo_er
; /* Contents of $_siginfo */
258 /* Counts of things. */
259 static int exception_count
= 0;
260 static int event_count
= 0;
261 static int saw_create
;
262 static int open_process_used
= 0;
264 static bool wow64_process
= false;
265 static bool ignore_first_breakpoint
= false;
269 static bool new_console
= false;
271 static bool cygwin_exceptions
= false;
273 static bool new_group
= true;
274 static bool debug_exec
= false; /* show execution */
275 static bool debug_events
= false; /* show events from kernel */
276 static bool debug_memory
= false; /* show target memory accesses */
277 static bool debug_exceptions
= false; /* show target exceptions */
278 static bool useshell
= false; /* use shell for subprocesses */
280 /* This vector maps GDB's idea of a register's number into an offset
281 in the windows exception context vector.
283 It also contains the bit mask needed to load the register in question.
285 The contents of this table can only be computed by the units
286 that provide CPU-specific support for Windows native debugging.
287 These units should set the table by calling
288 windows_set_context_register_offsets.
290 One day we could read a reg, we could inspect the context we
291 already have loaded, if it doesn't have the bit set that we need,
292 we read that set of registers in using GetThreadContext. If the
293 context already contains what we need, we just unpack it. Then to
294 write a register, first we have to ensure that the context contains
295 the other regs of the group, and then we copy the info in and set
298 static const int *mappings
;
300 /* The function to use in order to determine whether a register is
301 a segment register or not. */
302 static segment_register_p_ftype
*segment_register_p
;
304 /* See windows_nat_target::resume to understand why this is commented
307 /* This vector maps the target's idea of an exception (extracted
308 from the DEBUG_EVENT structure) to GDB's idea. */
310 struct xlate_exception
316 static const struct xlate_exception xlate
[] =
318 {EXCEPTION_ACCESS_VIOLATION
, GDB_SIGNAL_SEGV
},
319 {STATUS_STACK_OVERFLOW
, GDB_SIGNAL_SEGV
},
320 {EXCEPTION_BREAKPOINT
, GDB_SIGNAL_TRAP
},
321 {DBG_CONTROL_C
, GDB_SIGNAL_INT
},
322 {EXCEPTION_SINGLE_STEP
, GDB_SIGNAL_TRAP
},
323 {STATUS_FLOAT_DIVIDE_BY_ZERO
, GDB_SIGNAL_FPE
}
328 struct windows_nat_target final
: public x86_nat_target
<inf_child_target
>
330 void close () override
;
332 void attach (const char *, int) override
;
334 bool attach_no_wait () override
337 void detach (inferior
*, int) override
;
339 void resume (ptid_t
, int , enum gdb_signal
) override
;
341 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
343 void fetch_registers (struct regcache
*, int) override
;
344 void store_registers (struct regcache
*, int) override
;
346 enum target_xfer_status
xfer_partial (enum target_object object
,
349 const gdb_byte
*writebuf
,
350 ULONGEST offset
, ULONGEST len
,
351 ULONGEST
*xfered_len
) override
;
353 void files_info () override
;
355 void kill () override
;
357 void create_inferior (const char *, const std::string
&,
358 char **, int) override
;
360 void mourn_inferior () override
;
362 bool thread_alive (ptid_t ptid
) override
;
364 std::string
pid_to_str (ptid_t
) override
;
366 void interrupt () override
;
368 char *pid_to_exec_file (int pid
) override
;
370 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
372 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
374 const char *thread_name (struct thread_info
*) override
;
376 int get_windows_debug_event (int pid
, struct target_waitstatus
*ourstatus
);
379 static windows_nat_target the_windows_nat_target
;
381 /* Set the MAPPINGS static global to OFFSETS.
382 See the description of MAPPINGS for more details. */
385 windows_set_context_register_offsets (const int *offsets
)
390 /* Set the function that should be used by this module to determine
391 whether a given register is a segment register or not. */
394 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
396 segment_register_p
= fun
;
400 check (BOOL ok
, const char *file
, int line
)
403 printf_filtered ("error return %s:%d was %u\n", file
, line
,
404 (unsigned) GetLastError ());
407 /* Possible values to pass to 'thread_rec'. */
408 enum thread_disposition_type
410 /* Do not invalidate the thread's context, and do not suspend the
412 DONT_INVALIDATE_CONTEXT
,
413 /* Invalidate the context, but do not suspend the thread. */
415 /* Invalidate the context and suspend the thread. */
419 /* Find a thread record given a thread id. THREAD_DISPOSITION
420 controls whether the thread is suspended, and whether the context
422 static windows_thread_info
*
423 thread_rec (DWORD id
, enum thread_disposition_type disposition
)
425 for (windows_thread_info
*th
: thread_list
)
432 case DONT_INVALIDATE_CONTEXT
:
435 case INVALIDATE_CONTEXT
:
436 if (id
!= current_event
.dwThreadId
)
438 th
->reload_context
= true;
441 th
->reload_context
= true;
452 /* Add a thread to the thread list.
454 PTID is the ptid of the thread to be added.
455 H is its Windows handle.
456 TLB is its thread local base.
457 MAIN_THREAD_P should be true if the thread to be added is
458 the main thread, false otherwise. */
460 static windows_thread_info
*
461 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
, bool main_thread_p
)
463 windows_thread_info
*th
;
466 gdb_assert (ptid
.lwp () != 0);
470 if ((th
= thread_rec (id
, DONT_INVALIDATE_CONTEXT
)))
473 CORE_ADDR base
= (CORE_ADDR
) (uintptr_t) tlb
;
475 /* For WOW64 processes, this is actually the pointer to the 64bit TIB,
476 and the 32bit TIB is exactly 2 pages after it. */
480 th
= new windows_thread_info (id
, h
, base
);
481 thread_list
.push_back (th
);
483 /* Add this new thread to the list of threads.
485 To be consistent with what's done on other platforms, we add
486 the main thread silently (in reality, this thread is really
487 more of a process to the user than a thread). */
489 add_thread_silent (&the_windows_nat_target
, ptid
);
491 add_thread (&the_windows_nat_target
, ptid
);
493 /* Set the debug registers for the new thread if they are used. */
494 if (debug_registers_used
)
499 /* Only change the value of the debug registers. */
500 th
->wow64_context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
501 CHECK (Wow64GetThreadContext (th
->h
, &th
->wow64_context
));
502 th
->wow64_context
.Dr0
= dr
[0];
503 th
->wow64_context
.Dr1
= dr
[1];
504 th
->wow64_context
.Dr2
= dr
[2];
505 th
->wow64_context
.Dr3
= dr
[3];
506 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
507 th
->wow64_context
.Dr7
= dr
[7];
508 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
509 th
->wow64_context
.ContextFlags
= 0;
514 /* Only change the value of the debug registers. */
515 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
516 CHECK (GetThreadContext (th
->h
, &th
->context
));
517 th
->context
.Dr0
= dr
[0];
518 th
->context
.Dr1
= dr
[1];
519 th
->context
.Dr2
= dr
[2];
520 th
->context
.Dr3
= dr
[3];
521 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
522 th
->context
.Dr7
= dr
[7];
523 CHECK (SetThreadContext (th
->h
, &th
->context
));
524 th
->context
.ContextFlags
= 0;
530 /* Clear out any old thread list and reinitialize it to a
533 windows_init_thread_list (void)
535 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
538 for (windows_thread_info
*here
: thread_list
)
541 thread_list
.clear ();
544 /* Delete a thread from the list of threads.
546 PTID is the ptid of the thread to be deleted.
547 EXIT_CODE is the thread's exit code.
548 MAIN_THREAD_P should be true if the thread to be deleted is
549 the main thread, false otherwise. */
552 windows_delete_thread (ptid_t ptid
, DWORD exit_code
, bool main_thread_p
)
556 gdb_assert (ptid
.lwp () != 0);
560 /* Emit a notification about the thread being deleted.
562 Note that no notification was printed when the main thread
563 was created, and thus, unless in verbose mode, we should be
564 symmetrical, and avoid that notification for the main thread
568 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
).c_str ());
569 else if (print_thread_events
&& !main_thread_p
)
570 printf_unfiltered (_("[%s exited with code %u]\n"),
571 target_pid_to_str (ptid
).c_str (),
572 (unsigned) exit_code
);
574 delete_thread (find_thread_ptid (&the_windows_nat_target
, ptid
));
576 auto iter
= std::find_if (thread_list
.begin (), thread_list
.end (),
577 [=] (windows_thread_info
*th
)
579 return th
->tid
== id
;
582 if (iter
!= thread_list
.end ())
585 thread_list
.erase (iter
);
589 /* Fetches register number R from the given windows_thread_info,
590 and supplies its value to the given regcache.
592 This function assumes that R is non-negative. A failed assertion
593 is raised if that is not true.
595 This function assumes that TH->RELOAD_CONTEXT is not set, meaning
596 that the windows_thread_info has an up-to-date context. A failed
597 assertion is raised if that assumption is violated. */
600 windows_fetch_one_register (struct regcache
*regcache
,
601 windows_thread_info
*th
, int r
)
604 gdb_assert (!th
->reload_context
);
606 char *context_ptr
= (char *) &th
->context
;
609 context_ptr
= (char *) &th
->wow64_context
;
612 char *context_offset
= context_ptr
+ mappings
[r
];
613 struct gdbarch
*gdbarch
= regcache
->arch ();
614 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
616 if (r
== I387_FISEG_REGNUM (tdep
))
618 long l
= *((long *) context_offset
) & 0xffff;
619 regcache
->raw_supply (r
, (char *) &l
);
621 else if (r
== I387_FOP_REGNUM (tdep
))
623 long l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
624 regcache
->raw_supply (r
, (char *) &l
);
626 else if (segment_register_p (r
))
628 /* GDB treats segment registers as 32bit registers, but they are
629 in fact only 16 bits long. Make sure we do not read extra
630 bits from our source buffer. */
631 long l
= *((long *) context_offset
) & 0xffff;
632 regcache
->raw_supply (r
, (char *) &l
);
635 regcache
->raw_supply (r
, context_offset
);
639 windows_nat_target::fetch_registers (struct regcache
*regcache
, int r
)
641 DWORD tid
= regcache
->ptid ().lwp ();
642 windows_thread_info
*th
= thread_rec (tid
, INVALIDATE_CONTEXT
);
644 /* Check if TH exists. Windows sometimes uses a non-existent
645 thread id in its events. */
649 if (th
->reload_context
)
652 if (have_saved_context
)
654 /* Lie about where the program actually is stopped since
655 cygwin has informed us that we should consider the signal
656 to have occurred at another location which is stored in
658 memcpy (&th
->context
, &saved_context
,
659 __COPY_CONTEXT_SIZE
);
660 have_saved_context
= 0;
667 th
->wow64_context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
668 CHECK (Wow64GetThreadContext (th
->h
, &th
->wow64_context
));
669 /* Copy dr values from that thread.
670 But only if there were not modified since last stop.
672 if (!debug_registers_changed
)
674 dr
[0] = th
->wow64_context
.Dr0
;
675 dr
[1] = th
->wow64_context
.Dr1
;
676 dr
[2] = th
->wow64_context
.Dr2
;
677 dr
[3] = th
->wow64_context
.Dr3
;
678 dr
[6] = th
->wow64_context
.Dr6
;
679 dr
[7] = th
->wow64_context
.Dr7
;
685 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
686 CHECK (GetThreadContext (th
->h
, &th
->context
));
687 /* Copy dr values from that thread.
688 But only if there were not modified since last stop.
690 if (!debug_registers_changed
)
692 dr
[0] = th
->context
.Dr0
;
693 dr
[1] = th
->context
.Dr1
;
694 dr
[2] = th
->context
.Dr2
;
695 dr
[3] = th
->context
.Dr3
;
696 dr
[6] = th
->context
.Dr6
;
697 dr
[7] = th
->context
.Dr7
;
700 th
->reload_context
= false;
704 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch()); r
++)
705 windows_fetch_one_register (regcache
, th
, r
);
707 windows_fetch_one_register (regcache
, th
, r
);
710 /* Collect the register number R from the given regcache, and store
711 its value into the corresponding area of the given thread's context.
713 This function assumes that R is non-negative. A failed assertion
714 assertion is raised if that is not true. */
717 windows_store_one_register (const struct regcache
*regcache
,
718 windows_thread_info
*th
, int r
)
722 char *context_ptr
= (char *) &th
->context
;
725 context_ptr
= (char *) &th
->wow64_context
;
728 regcache
->raw_collect (r
, context_ptr
+ mappings
[r
]);
731 /* Store a new register value into the context of the thread tied to
735 windows_nat_target::store_registers (struct regcache
*regcache
, int r
)
737 DWORD tid
= regcache
->ptid ().lwp ();
738 windows_thread_info
*th
= thread_rec (tid
, INVALIDATE_CONTEXT
);
740 /* Check if TH exists. Windows sometimes uses a non-existent
741 thread id in its events. */
746 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch ()); r
++)
747 windows_store_one_register (regcache
, th
, r
);
749 windows_store_one_register (regcache
, th
, r
);
752 /* Maintain a linked list of "so" information. */
753 struct lm_info_windows
: public lm_info_base
755 LPVOID load_addr
= 0;
756 CORE_ADDR text_offset
= 0;
759 static struct so_list solib_start
, *solib_end
;
761 static struct so_list
*
762 windows_make_so (const char *name
, LPVOID load_addr
)
769 WIN32_FIND_DATA w32_fd
;
770 HANDLE h
= FindFirstFile(name
, &w32_fd
);
772 if (h
== INVALID_HANDLE_VALUE
)
778 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
780 p
= strrchr (buf
, '\\');
783 SetCurrentDirectory (buf
);
784 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
785 SetCurrentDirectory (cwd
);
788 if (strcasecmp (buf
, "ntdll.dll") == 0)
790 GetSystemDirectory (buf
, sizeof (buf
));
791 strcat (buf
, "\\ntdll.dll");
794 cygwin_buf_t buf
[__PMAX
];
797 if (access (name
, F_OK
) != 0)
799 if (strcasecmp (name
, "ntdll.dll") == 0)
802 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
803 wcscat (buf
, L
"\\ntdll.dll");
807 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
808 strcat (buf
, "\\ntdll.dll");
813 so
= XCNEW (struct so_list
);
814 lm_info_windows
*li
= new lm_info_windows
;
816 li
->load_addr
= load_addr
;
817 strcpy (so
->so_original_name
, name
);
819 strcpy (so
->so_name
, buf
);
822 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
823 SO_NAME_MAX_PATH_SIZE
);
826 char *rname
= realpath (name
, NULL
);
827 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
829 strcpy (so
->so_name
, rname
);
833 error (_("dll path too long"));
835 /* Record cygwin1.dll .text start/end. */
836 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
837 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
839 asection
*text
= NULL
;
841 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386", -1));
846 if (bfd_check_format (abfd
.get (), bfd_object
))
847 text
= bfd_get_section_by_name (abfd
.get (), ".text");
852 /* The symbols in a dll are offset by 0x1000, which is the
853 offset from 0 of the first byte in an image - because of the
854 file header and the section alignment. */
855 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
857 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (text
);
865 get_image_name (HANDLE h
, void *address
, int unicode
)
868 static char buf
[__PMAX
];
870 static char buf
[(2 * __PMAX
) + 1];
872 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
878 /* Attempt to read the name of the dll that was detected.
879 This is documented to work only when actively debugging
880 a program. It will not work for attached processes. */
884 /* See if we could read the address of a string, and that the
885 address isn't null. */
886 if (!ReadProcessMemory (h
, address
, &address_ptr
,
887 sizeof (address_ptr
), &done
)
888 || done
!= sizeof (address_ptr
) || !address_ptr
)
891 /* Find the length of the string. */
892 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
893 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
897 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
900 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
901 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
904 wcstombs (buf
, unicode_address
, __PMAX
);
906 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
914 /* Handle a DLL load event, and return 1.
916 This function assumes that this event did not occur during inferior
917 initialization, where their event info may be incomplete (see
918 do_initial_windows_stuff and windows_add_all_dlls for more info
919 on how we handle DLL loading during that phase). */
924 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
927 /* Try getting the DLL name via the lpImageName field of the event.
928 Note that Microsoft documents this fields as strictly optional,
929 in the sense that it might be NULL. And the first DLL event in
930 particular is explicitly documented as "likely not pass[ed]"
931 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
932 dll_name
= get_image_name (current_process_handle
,
933 event
->lpImageName
, event
->fUnicode
);
937 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
938 solib_end
= solib_end
->next
;
940 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
942 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
943 host_address_to_string (li
->load_addr
)));
947 windows_free_so (struct so_list
*so
)
949 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
955 /* Handle a DLL unload event.
956 Return 1 if successful, or zero otherwise.
958 This function assumes that this event did not occur during inferior
959 initialization, where their event info may be incomplete (see
960 do_initial_windows_stuff and windows_add_all_dlls for more info
961 on how we handle DLL loading during that phase). */
966 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
969 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
971 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
973 if (li_next
->load_addr
== lpBaseOfDll
)
975 struct so_list
*sodel
= so
->next
;
977 so
->next
= sodel
->next
;
980 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
982 windows_free_so (sodel
);
987 /* We did not find any DLL that was previously loaded at this address,
988 so register a complaint. We do not report an error, because we have
989 observed that this may be happening under some circumstances. For
990 instance, running 32bit applications on x64 Windows causes us to receive
991 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
992 events are apparently caused by the WOW layer, the interface between
993 32bit and 64bit worlds). */
994 complaint (_("dll starting at %s not found."),
995 host_address_to_string (lpBaseOfDll
));
998 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
1002 catch_errors (void (*func
) ())
1008 catch (const gdb_exception
&ex
)
1010 exception_print (gdb_stderr
, ex
);
1014 /* Clear list of loaded DLLs. */
1016 windows_clear_solib (void)
1020 for (so
= solib_start
.next
; so
; so
= solib_start
.next
)
1022 solib_start
.next
= so
->next
;
1023 windows_free_so (so
);
1026 solib_end
= &solib_start
;
1030 signal_event_command (const char *args
, int from_tty
)
1032 uintptr_t event_id
= 0;
1033 char *endargs
= NULL
;
1036 error (_("signal-event requires an argument (integer event id)"));
1038 event_id
= strtoumax (args
, &endargs
, 10);
1040 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
1041 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
1042 error (_("Failed to convert `%s' to event id"), args
);
1044 SetEvent ((HANDLE
) event_id
);
1045 CloseHandle ((HANDLE
) event_id
);
1048 /* Handle DEBUG_STRING output from child process.
1049 Cygwin prepends its messages with a "cygwin:". Interpret this as
1050 a Cygwin signal. Otherwise just print the string as a warning. */
1052 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
1054 gdb::unique_xmalloc_ptr
<char> s
;
1057 if (!target_read_string
1058 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
1060 || !s
|| !*(s
.get ()))
1061 /* nothing to do */;
1062 else if (!startswith (s
.get (), _CYGWIN_SIGNAL_STRING
))
1065 if (!startswith (s
.get (), "cYg"))
1068 char *p
= strchr (s
.get (), '\0');
1070 if (p
> s
.get () && *--p
== '\n')
1072 warning (("%s"), s
.get ());
1078 /* Got a cygwin signal marker. A cygwin signal is followed by
1079 the signal number itself and then optionally followed by the
1080 thread id and address to saved context within the DLL. If
1081 these are supplied, then the given thread is assumed to have
1082 issued the signal and the context from the thread is assumed
1083 to be stored at the given address in the inferior. Tell gdb
1084 to treat this like a real signal. */
1086 int sig
= strtol (s
.get () + sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
1087 gdb_signal gotasig
= gdb_signal_from_host (sig
);
1089 ourstatus
->value
.sig
= gotasig
;
1095 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1096 retval
= strtoul (p
, &p
, 0);
1098 retval
= current_event
.dwThreadId
;
1099 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
1100 && ReadProcessMemory (current_process_handle
, x
,
1102 __COPY_CONTEXT_SIZE
, &n
)
1103 && n
== __COPY_CONTEXT_SIZE
)
1104 have_saved_context
= 1;
1113 display_selector (HANDLE thread
, DWORD sel
)
1119 ret
= Wow64GetThreadSelectorEntry (thread
, sel
, &info
);
1122 ret
= GetThreadSelectorEntry (thread
, sel
, &info
);
1126 printf_filtered ("0x%03x: ", (unsigned) sel
);
1127 if (!info
.HighWord
.Bits
.Pres
)
1129 puts_filtered ("Segment not present\n");
1132 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1133 (info
.HighWord
.Bits
.BaseMid
<< 16)
1135 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1136 if (info
.HighWord
.Bits
.Granularity
)
1137 limit
= (limit
<< 12) | 0xfff;
1138 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1139 if (info
.HighWord
.Bits
.Default_Big
)
1140 puts_filtered(" 32-bit ");
1142 puts_filtered(" 16-bit ");
1143 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1146 puts_filtered ("Data (Read-Only, Exp-up");
1149 puts_filtered ("Data (Read/Write, Exp-up");
1152 puts_filtered ("Unused segment (");
1155 puts_filtered ("Data (Read/Write, Exp-down");
1158 puts_filtered ("Code (Exec-Only, N.Conf");
1161 puts_filtered ("Code (Exec/Read, N.Conf");
1164 puts_filtered ("Code (Exec-Only, Conf");
1167 puts_filtered ("Code (Exec/Read, Conf");
1170 printf_filtered ("Unknown type 0x%lx",
1171 (unsigned long) info
.HighWord
.Bits
.Type
);
1173 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1174 puts_filtered(", N.Acc");
1175 puts_filtered (")\n");
1176 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1177 puts_filtered("System selector ");
1178 printf_filtered ("Priviledge level = %ld. ",
1179 (unsigned long) info
.HighWord
.Bits
.Dpl
);
1180 if (info
.HighWord
.Bits
.Granularity
)
1181 puts_filtered ("Page granular.\n");
1183 puts_filtered ("Byte granular.\n");
1188 DWORD err
= GetLastError ();
1189 if (err
== ERROR_NOT_SUPPORTED
)
1190 printf_filtered ("Function not supported\n");
1192 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1198 display_selectors (const char * args
, int from_tty
)
1200 if (!current_thread
)
1202 puts_filtered ("Impossible to display selectors now.\n");
1210 puts_filtered ("Selector $cs\n");
1211 display_selector (current_thread
->h
,
1212 current_thread
->wow64_context
.SegCs
);
1213 puts_filtered ("Selector $ds\n");
1214 display_selector (current_thread
->h
,
1215 current_thread
->wow64_context
.SegDs
);
1216 puts_filtered ("Selector $es\n");
1217 display_selector (current_thread
->h
,
1218 current_thread
->wow64_context
.SegEs
);
1219 puts_filtered ("Selector $ss\n");
1220 display_selector (current_thread
->h
,
1221 current_thread
->wow64_context
.SegSs
);
1222 puts_filtered ("Selector $fs\n");
1223 display_selector (current_thread
->h
,
1224 current_thread
->wow64_context
.SegFs
);
1225 puts_filtered ("Selector $gs\n");
1226 display_selector (current_thread
->h
,
1227 current_thread
->wow64_context
.SegGs
);
1232 puts_filtered ("Selector $cs\n");
1233 display_selector (current_thread
->h
,
1234 current_thread
->context
.SegCs
);
1235 puts_filtered ("Selector $ds\n");
1236 display_selector (current_thread
->h
,
1237 current_thread
->context
.SegDs
);
1238 puts_filtered ("Selector $es\n");
1239 display_selector (current_thread
->h
,
1240 current_thread
->context
.SegEs
);
1241 puts_filtered ("Selector $ss\n");
1242 display_selector (current_thread
->h
,
1243 current_thread
->context
.SegSs
);
1244 puts_filtered ("Selector $fs\n");
1245 display_selector (current_thread
->h
,
1246 current_thread
->context
.SegFs
);
1247 puts_filtered ("Selector $gs\n");
1248 display_selector (current_thread
->h
,
1249 current_thread
->context
.SegGs
);
1255 sel
= parse_and_eval_long (args
);
1256 printf_filtered ("Selector \"%s\"\n",args
);
1257 display_selector (current_thread
->h
, sel
);
1261 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1262 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1263 host_address_to_string (\
1264 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1266 static handle_exception_result
1267 handle_exception (struct target_waitstatus
*ourstatus
)
1269 EXCEPTION_RECORD
*rec
= ¤t_event
.u
.Exception
.ExceptionRecord
;
1270 DWORD code
= rec
->ExceptionCode
;
1271 handle_exception_result result
= HANDLE_EXCEPTION_HANDLED
;
1273 memcpy (&siginfo_er
, rec
, sizeof siginfo_er
);
1275 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1277 /* Record the context of the current thread. */
1278 thread_rec (current_event
.dwThreadId
, DONT_SUSPEND
);
1282 case EXCEPTION_ACCESS_VIOLATION
:
1283 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1284 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1287 /* See if the access violation happened within the cygwin DLL
1288 itself. Cygwin uses a kind of exception handling to deal
1289 with passed-in invalid addresses. gdb should not treat
1290 these as real SEGVs since they will be silently handled by
1291 cygwin. A real SEGV will (theoretically) be caught by
1292 cygwin later in the process and will be sent as a
1293 cygwin-specific-signal. So, ignore SEGVs if they show up
1294 within the text segment of the DLL itself. */
1296 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1298 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1299 && addr
< cygwin_load_end
))
1300 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1301 && startswith (fn
, "KERNEL32!IsBad")))
1302 return HANDLE_EXCEPTION_UNHANDLED
;
1306 case STATUS_STACK_OVERFLOW
:
1307 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1308 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1310 case STATUS_FLOAT_DENORMAL_OPERAND
:
1311 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1312 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1314 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1315 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1316 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1318 case STATUS_FLOAT_INEXACT_RESULT
:
1319 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1320 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1322 case STATUS_FLOAT_INVALID_OPERATION
:
1323 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1324 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1326 case STATUS_FLOAT_OVERFLOW
:
1327 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1328 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1330 case STATUS_FLOAT_STACK_CHECK
:
1331 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1332 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1334 case STATUS_FLOAT_UNDERFLOW
:
1335 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1336 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1338 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1339 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1340 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1342 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1343 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1344 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1346 case STATUS_INTEGER_OVERFLOW
:
1347 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1348 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1350 case EXCEPTION_BREAKPOINT
:
1352 if (ignore_first_breakpoint
)
1354 /* For WOW64 processes, there are always 2 breakpoint exceptions
1355 on startup, first a BREAKPOINT for the 64bit ntdll.dll,
1356 then a WX86_BREAKPOINT for the 32bit ntdll.dll.
1357 Here we only care about the WX86_BREAKPOINT's. */
1358 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1359 ignore_first_breakpoint
= false;
1363 case STATUS_WX86_BREAKPOINT
:
1364 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1365 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1368 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1369 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1371 case DBG_CONTROL_BREAK
:
1372 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1373 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1375 case EXCEPTION_SINGLE_STEP
:
1376 case STATUS_WX86_SINGLE_STEP
:
1377 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1378 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1380 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1381 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1382 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1384 case EXCEPTION_PRIV_INSTRUCTION
:
1385 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1386 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1388 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1389 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1390 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1392 case MS_VC_EXCEPTION
:
1393 if (rec
->NumberParameters
>= 3
1394 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1396 DWORD named_thread_id
;
1397 windows_thread_info
*named_thread
;
1398 CORE_ADDR thread_name_target
;
1400 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1402 thread_name_target
= rec
->ExceptionInformation
[1];
1403 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1405 if (named_thread_id
== (DWORD
) -1)
1406 named_thread_id
= current_event
.dwThreadId
;
1408 named_thread
= thread_rec (named_thread_id
, DONT_INVALIDATE_CONTEXT
);
1409 if (named_thread
!= NULL
)
1411 int thread_name_len
;
1412 gdb::unique_xmalloc_ptr
<char> thread_name
;
1414 thread_name_len
= target_read_string (thread_name_target
,
1415 &thread_name
, 1025, NULL
);
1416 if (thread_name_len
> 0)
1418 thread_name
.get ()[thread_name_len
- 1] = '\0';
1419 named_thread
->name
= std::move (thread_name
);
1422 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1423 result
= HANDLE_EXCEPTION_IGNORED
;
1426 /* treat improperly formed exception as unknown */
1429 /* Treat unhandled first chance exceptions specially. */
1430 if (current_event
.u
.Exception
.dwFirstChance
)
1431 return HANDLE_EXCEPTION_UNHANDLED
;
1432 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1433 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1434 host_address_to_string (
1435 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1436 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1440 last_sig
= ourstatus
->value
.sig
;
1444 /* Resume thread specified by ID, or all artificially suspended
1445 threads, if we are continuing execution. KILLED non-zero means we
1446 have killed the inferior, so we should ignore weird errors due to
1447 threads shutting down. */
1449 windows_continue (DWORD continue_status
, int id
, int killed
)
1453 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1454 (unsigned) current_event
.dwProcessId
,
1455 (unsigned) current_event
.dwThreadId
,
1456 continue_status
== DBG_CONTINUE
?
1457 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1459 for (windows_thread_info
*th
: thread_list
)
1460 if ((id
== -1 || id
== (int) th
->tid
)
1466 if (debug_registers_changed
)
1468 th
->wow64_context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1469 th
->wow64_context
.Dr0
= dr
[0];
1470 th
->wow64_context
.Dr1
= dr
[1];
1471 th
->wow64_context
.Dr2
= dr
[2];
1472 th
->wow64_context
.Dr3
= dr
[3];
1473 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1474 th
->wow64_context
.Dr7
= dr
[7];
1476 if (th
->wow64_context
.ContextFlags
)
1480 if (GetExitCodeThread (th
->h
, &ec
)
1481 && ec
== STILL_ACTIVE
)
1483 BOOL status
= Wow64SetThreadContext (th
->h
,
1484 &th
->wow64_context
);
1489 th
->wow64_context
.ContextFlags
= 0;
1495 if (debug_registers_changed
)
1497 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1498 th
->context
.Dr0
= dr
[0];
1499 th
->context
.Dr1
= dr
[1];
1500 th
->context
.Dr2
= dr
[2];
1501 th
->context
.Dr3
= dr
[3];
1502 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1503 th
->context
.Dr7
= dr
[7];
1505 if (th
->context
.ContextFlags
)
1509 if (GetExitCodeThread (th
->h
, &ec
)
1510 && ec
== STILL_ACTIVE
)
1512 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1517 th
->context
.ContextFlags
= 0;
1523 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1524 current_event
.dwThreadId
,
1528 error (_("Failed to resume program execution"
1529 " (ContinueDebugEvent failed, error %u)"),
1530 (unsigned int) GetLastError ());
1532 debug_registers_changed
= 0;
1536 /* Called in pathological case where Windows fails to send a
1537 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1539 fake_create_process (void)
1541 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1542 current_event
.dwProcessId
);
1543 if (current_process_handle
!= NULL
)
1544 open_process_used
= 1;
1547 error (_("OpenProcess call failed, GetLastError = %u"),
1548 (unsigned) GetLastError ());
1549 /* We can not debug anything in that case. */
1552 = windows_add_thread (ptid_t (current_event
.dwProcessId
,
1553 current_event
.dwThreadId
, 0),
1554 current_event
.u
.CreateThread
.hThread
,
1555 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1556 true /* main_thread_p */);
1557 return current_event
.dwThreadId
;
1561 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1563 windows_thread_info
*th
;
1564 DWORD continue_status
= DBG_CONTINUE
;
1566 /* A specific PTID means `step only this thread id'. */
1567 int resume_all
= ptid
== minus_one_ptid
;
1569 /* If we're continuing all threads, it's the current inferior that
1570 should be handled specially. */
1572 ptid
= inferior_ptid
;
1574 if (sig
!= GDB_SIGNAL_0
)
1576 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1578 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1580 else if (sig
== last_sig
)
1581 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1584 /* This code does not seem to work, because
1585 the kernel does probably not consider changes in the ExceptionRecord
1586 structure when passing the exception to the inferior.
1587 Note that this seems possible in the exception handler itself. */
1589 for (const xlate_exception
&x
: xlate
)
1592 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1594 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1597 if (continue_status
== DBG_CONTINUE
)
1599 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1603 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1607 last_sig
= GDB_SIGNAL_0
;
1609 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=0x%x, step=%d, sig=%d);\n",
1610 ptid
.pid (), (unsigned) ptid
.lwp (), step
, sig
));
1612 /* Get context for currently selected thread. */
1613 th
= thread_rec (inferior_ptid
.lwp (), DONT_INVALIDATE_CONTEXT
);
1621 /* Single step by setting t bit. */
1622 struct regcache
*regcache
= get_current_regcache ();
1623 struct gdbarch
*gdbarch
= regcache
->arch ();
1624 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1625 th
->wow64_context
.EFlags
|= FLAG_TRACE_BIT
;
1628 if (th
->wow64_context
.ContextFlags
)
1630 if (debug_registers_changed
)
1632 th
->wow64_context
.Dr0
= dr
[0];
1633 th
->wow64_context
.Dr1
= dr
[1];
1634 th
->wow64_context
.Dr2
= dr
[2];
1635 th
->wow64_context
.Dr3
= dr
[3];
1636 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1637 th
->wow64_context
.Dr7
= dr
[7];
1639 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
1640 th
->wow64_context
.ContextFlags
= 0;
1648 /* Single step by setting t bit. */
1649 struct regcache
*regcache
= get_current_regcache ();
1650 struct gdbarch
*gdbarch
= regcache
->arch ();
1651 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1652 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1655 if (th
->context
.ContextFlags
)
1657 if (debug_registers_changed
)
1659 th
->context
.Dr0
= dr
[0];
1660 th
->context
.Dr1
= dr
[1];
1661 th
->context
.Dr2
= dr
[2];
1662 th
->context
.Dr3
= dr
[3];
1663 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1664 th
->context
.Dr7
= dr
[7];
1666 CHECK (SetThreadContext (th
->h
, &th
->context
));
1667 th
->context
.ContextFlags
= 0;
1672 /* Allow continuing with the same signal that interrupted us.
1673 Otherwise complain. */
1676 windows_continue (continue_status
, -1, 0);
1678 windows_continue (continue_status
, ptid
.lwp (), 0);
1681 /* Ctrl-C handler used when the inferior is not run in the same console. The
1682 handler is in charge of interrupting the inferior using DebugBreakProcess.
1683 Note that this function is not available prior to Windows XP. In this case
1684 we emit a warning. */
1686 ctrl_c_handler (DWORD event_type
)
1688 const int attach_flag
= current_inferior ()->attach_flag
;
1690 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1691 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1694 /* If the inferior and the debugger share the same console, do nothing as
1695 the inferior has also received the Ctrl-C event. */
1696 if (!new_console
&& !attach_flag
)
1699 if (!DebugBreakProcess (current_process_handle
))
1700 warning (_("Could not interrupt program. "
1701 "Press Ctrl-c in the program console."));
1703 /* Return true to tell that Ctrl-C has been handled. */
1707 /* Get the next event from the child. Returns a non-zero thread id if the event
1708 requires handling by WFI (or whatever). */
1711 windows_nat_target::get_windows_debug_event (int pid
,
1712 struct target_waitstatus
*ourstatus
)
1715 DWORD continue_status
, event_code
;
1716 windows_thread_info
*th
;
1717 static windows_thread_info
dummy_thread_info (0, 0, 0);
1718 DWORD thread_id
= 0;
1720 last_sig
= GDB_SIGNAL_0
;
1722 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1726 continue_status
= DBG_CONTINUE
;
1728 event_code
= current_event
.dwDebugEventCode
;
1729 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1731 have_saved_context
= 0;
1735 case CREATE_THREAD_DEBUG_EVENT
:
1736 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1737 (unsigned) current_event
.dwProcessId
,
1738 (unsigned) current_event
.dwThreadId
,
1739 "CREATE_THREAD_DEBUG_EVENT"));
1740 if (saw_create
!= 1)
1742 inferior
*inf
= find_inferior_pid (this, current_event
.dwProcessId
);
1743 if (!saw_create
&& inf
->attach_flag
)
1745 /* Kludge around a Windows bug where first event is a create
1746 thread event. Caused when attached process does not have
1748 thread_id
= fake_create_process ();
1754 /* Record the existence of this thread. */
1755 thread_id
= current_event
.dwThreadId
;
1756 th
= windows_add_thread
1757 (ptid_t (current_event
.dwProcessId
, current_event
.dwThreadId
, 0),
1758 current_event
.u
.CreateThread
.hThread
,
1759 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1760 false /* main_thread_p */);
1764 case EXIT_THREAD_DEBUG_EVENT
:
1765 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1766 (unsigned) current_event
.dwProcessId
,
1767 (unsigned) current_event
.dwThreadId
,
1768 "EXIT_THREAD_DEBUG_EVENT"));
1769 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1770 current_event
.dwThreadId
, 0),
1771 current_event
.u
.ExitThread
.dwExitCode
,
1772 false /* main_thread_p */);
1773 th
= &dummy_thread_info
;
1776 case CREATE_PROCESS_DEBUG_EVENT
:
1777 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1778 (unsigned) current_event
.dwProcessId
,
1779 (unsigned) current_event
.dwThreadId
,
1780 "CREATE_PROCESS_DEBUG_EVENT"));
1781 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1782 if (++saw_create
!= 1)
1785 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1786 /* Add the main thread. */
1787 th
= windows_add_thread
1788 (ptid_t (current_event
.dwProcessId
,
1789 current_event
.dwThreadId
, 0),
1790 current_event
.u
.CreateProcessInfo
.hThread
,
1791 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
,
1792 true /* main_thread_p */);
1793 thread_id
= current_event
.dwThreadId
;
1796 case EXIT_PROCESS_DEBUG_EVENT
:
1797 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1798 (unsigned) current_event
.dwProcessId
,
1799 (unsigned) current_event
.dwThreadId
,
1800 "EXIT_PROCESS_DEBUG_EVENT"));
1801 if (!windows_initialization_done
)
1803 target_terminal::ours ();
1804 target_mourn_inferior (inferior_ptid
);
1805 error (_("During startup program exited with code 0x%x."),
1806 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1808 else if (saw_create
== 1)
1810 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1811 current_event
.dwThreadId
, 0),
1812 0, true /* main_thread_p */);
1813 DWORD exit_status
= current_event
.u
.ExitProcess
.dwExitCode
;
1814 /* If the exit status looks like a fatal exception, but we
1815 don't recognize the exception's code, make the original
1816 exit status value available, to avoid losing
1819 = WIFSIGNALED (exit_status
) ? WTERMSIG (exit_status
) : -1;
1820 if (exit_signal
== -1)
1822 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1823 ourstatus
->value
.integer
= exit_status
;
1827 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1828 ourstatus
->value
.sig
= gdb_signal_from_host (exit_signal
);
1830 thread_id
= current_event
.dwThreadId
;
1834 case LOAD_DLL_DEBUG_EVENT
:
1835 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1836 (unsigned) current_event
.dwProcessId
,
1837 (unsigned) current_event
.dwThreadId
,
1838 "LOAD_DLL_DEBUG_EVENT"));
1839 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1840 if (saw_create
!= 1 || ! windows_initialization_done
)
1842 catch_errors (handle_load_dll
);
1843 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1844 ourstatus
->value
.integer
= 0;
1845 thread_id
= current_event
.dwThreadId
;
1848 case UNLOAD_DLL_DEBUG_EVENT
:
1849 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1850 (unsigned) current_event
.dwProcessId
,
1851 (unsigned) current_event
.dwThreadId
,
1852 "UNLOAD_DLL_DEBUG_EVENT"));
1853 if (saw_create
!= 1 || ! windows_initialization_done
)
1855 catch_errors (handle_unload_dll
);
1856 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1857 ourstatus
->value
.integer
= 0;
1858 thread_id
= current_event
.dwThreadId
;
1861 case EXCEPTION_DEBUG_EVENT
:
1862 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1863 (unsigned) current_event
.dwProcessId
,
1864 (unsigned) current_event
.dwThreadId
,
1865 "EXCEPTION_DEBUG_EVENT"));
1866 if (saw_create
!= 1)
1868 switch (handle_exception (ourstatus
))
1870 case HANDLE_EXCEPTION_UNHANDLED
:
1872 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1874 case HANDLE_EXCEPTION_HANDLED
:
1875 thread_id
= current_event
.dwThreadId
;
1877 case HANDLE_EXCEPTION_IGNORED
:
1878 continue_status
= DBG_CONTINUE
;
1883 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1884 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1885 (unsigned) current_event
.dwProcessId
,
1886 (unsigned) current_event
.dwThreadId
,
1887 "OUTPUT_DEBUG_STRING_EVENT"));
1888 if (saw_create
!= 1)
1890 thread_id
= handle_output_debug_string (ourstatus
);
1894 if (saw_create
!= 1)
1896 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1897 (unsigned) current_event
.dwProcessId
,
1898 (unsigned) current_event
.dwThreadId
);
1899 printf_unfiltered (" unknown event code %u\n",
1900 (unsigned) current_event
.dwDebugEventCode
);
1904 if (!thread_id
|| saw_create
!= 1)
1906 CHECK (windows_continue (continue_status
, -1, 0));
1910 inferior_ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1911 current_thread
= th
;
1912 if (!current_thread
)
1913 current_thread
= thread_rec (thread_id
, INVALIDATE_CONTEXT
);
1920 /* Wait for interesting events to occur in the target process. */
1922 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1927 /* We loop when we get a non-standard exception rather than return
1928 with a SPURIOUS because resume can try and step or modify things,
1929 which needs a current_thread->h. But some of these exceptions mark
1930 the birth or death of threads, which mean that the current thread
1931 isn't necessarily what you think it is. */
1937 /* If the user presses Ctrl-c while the debugger is waiting
1938 for an event, he expects the debugger to interrupt his program
1939 and to get the prompt back. There are two possible situations:
1941 - The debugger and the program do not share the console, in
1942 which case the Ctrl-c event only reached the debugger.
1943 In that case, the ctrl_c handler will take care of interrupting
1944 the inferior. Note that this case is working starting with
1945 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1948 - The debugger and the program share the same console, in which
1949 case both debugger and inferior will receive the Ctrl-c event.
1950 In that case the ctrl_c handler will ignore the event, as the
1951 Ctrl-c event generated inside the inferior will trigger the
1952 expected debug event.
1954 FIXME: brobecker/2008-05-20: If the inferior receives the
1955 signal first and the delay until GDB receives that signal
1956 is sufficiently long, GDB can sometimes receive the SIGINT
1957 after we have unblocked the CTRL+C handler. This would
1958 lead to the debugger stopping prematurely while handling
1959 the new-thread event that comes with the handling of the SIGINT
1960 inside the inferior, and then stop again immediately when
1961 the user tries to resume the execution in the inferior.
1962 This is a classic race that we should try to fix one day. */
1963 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1964 retval
= get_windows_debug_event (pid
, ourstatus
);
1965 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1968 return ptid_t (current_event
.dwProcessId
, retval
, 0);
1973 if (deprecated_ui_loop_hook
!= NULL
)
1974 detach
= deprecated_ui_loop_hook (0);
1982 /* Iterate over all DLLs currently mapped by our inferior, and
1983 add them to our list of solibs. */
1986 windows_add_all_dlls (void)
1988 HMODULE dummy_hmodule
;
1996 if (EnumProcessModulesEx (current_process_handle
, &dummy_hmodule
,
1997 sizeof (HMODULE
), &cb_needed
,
1998 LIST_MODULES_32BIT
) == 0)
2004 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
2005 sizeof (HMODULE
), &cb_needed
) == 0)
2012 hmodules
= (HMODULE
*) alloca (cb_needed
);
2016 if (EnumProcessModulesEx (current_process_handle
, hmodules
,
2017 cb_needed
, &cb_needed
,
2018 LIST_MODULES_32BIT
) == 0)
2024 if (EnumProcessModules (current_process_handle
, hmodules
,
2025 cb_needed
, &cb_needed
) == 0)
2029 char system_dir
[__PMAX
];
2030 char syswow_dir
[__PMAX
];
2031 size_t system_dir_len
= 0;
2032 bool convert_syswow_dir
= false;
2037 /* This fails on 32bit Windows because it has no SysWOW64 directory,
2038 and in this case a path conversion isn't necessary. */
2039 UINT len
= GetSystemWow64DirectoryA (syswow_dir
, sizeof (syswow_dir
));
2042 /* Check that we have passed a large enough buffer. */
2043 gdb_assert (len
< sizeof (syswow_dir
));
2045 len
= GetSystemDirectoryA (system_dir
, sizeof (system_dir
));
2047 gdb_assert (len
!= 0);
2048 /* Check that we have passed a large enough buffer. */
2049 gdb_assert (len
< sizeof (system_dir
));
2051 strcat (system_dir
, "\\");
2052 strcat (syswow_dir
, "\\");
2053 system_dir_len
= strlen (system_dir
);
2055 convert_syswow_dir
= true;
2059 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
2063 wchar_t dll_name
[__PMAX
];
2064 char dll_name_mb
[__PMAX
];
2066 char dll_name
[__PMAX
];
2069 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
2070 &mi
, sizeof (mi
)) == 0)
2072 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
2073 dll_name
, sizeof (dll_name
)) == 0)
2076 wcstombs (dll_name_mb
, dll_name
, __PMAX
);
2081 /* Convert the DLL path of 32bit processes returned by
2082 GetModuleFileNameEx from the 64bit system directory to the
2083 32bit syswow64 directory if necessary. */
2084 std::string syswow_dll_path
;
2085 if (convert_syswow_dir
2086 && strncasecmp (name
, system_dir
, system_dir_len
) == 0
2087 && strchr (name
+ system_dir_len
, '\\') == nullptr)
2089 syswow_dll_path
= syswow_dir
;
2090 syswow_dll_path
+= name
+ system_dir_len
;
2091 name
= syswow_dll_path
.c_str();
2094 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
2095 solib_end
= solib_end
->next
;
2100 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
2103 struct inferior
*inf
;
2105 last_sig
= GDB_SIGNAL_0
;
2107 exception_count
= 0;
2108 open_process_used
= 0;
2109 debug_registers_changed
= 0;
2110 debug_registers_used
= 0;
2111 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
2114 cygwin_load_start
= cygwin_load_end
= 0;
2116 current_event
.dwProcessId
= pid
;
2117 memset (¤t_event
, 0, sizeof (current_event
));
2118 if (!target_is_pushed (ops
))
2120 disable_breakpoints_in_shlibs ();
2121 windows_clear_solib ();
2122 clear_proceed_status (0);
2123 init_wait_for_inferior ();
2126 ignore_first_breakpoint
= !attaching
&& wow64_process
;
2130 windows_set_context_register_offsets (amd64_mappings
);
2131 windows_set_segment_register_p (amd64_windows_segment_register_p
);
2136 windows_set_context_register_offsets (i386_mappings
);
2137 windows_set_segment_register_p (i386_windows_segment_register_p
);
2140 inf
= current_inferior ();
2141 inferior_appeared (inf
, pid
);
2142 inf
->attach_flag
= attaching
;
2144 /* Make the new process the current inferior, so terminal handling
2145 can rely on it. When attaching, we don't know about any thread
2146 id here, but that's OK --- nothing should be referencing the
2147 current thread until we report an event out of windows_wait. */
2148 inferior_ptid
= ptid_t (pid
);
2150 target_terminal::init ();
2151 target_terminal::inferior ();
2153 windows_initialization_done
= 0;
2157 struct target_waitstatus status
;
2159 ops
->wait (minus_one_ptid
, &status
, 0);
2161 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
2163 if (status
.kind
!= TARGET_WAITKIND_LOADED
2164 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
2167 ops
->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
2170 /* Now that the inferior has been started and all DLLs have been mapped,
2171 we can iterate over all DLLs and load them in.
2173 We avoid doing it any earlier because, on certain versions of Windows,
2174 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
2175 we have seen on Windows 8.1 that the ntdll.dll load event does not
2176 include the DLL name, preventing us from creating an associated SO.
2177 A possible explanation is that ntdll.dll might be mapped before
2178 the SO info gets created by the Windows system -- ntdll.dll is
2179 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
2180 do not seem to suffer from that problem.
2182 Rather than try to work around this sort of issue, it is much
2183 simpler to just ignore DLL load/unload events during the startup
2184 phase, and then process them all in one batch now. */
2185 windows_add_all_dlls ();
2187 windows_initialization_done
= 1;
2191 /* Try to set or remove a user privilege to the current process. Return -1
2192 if that fails, the previous setting of that privilege otherwise.
2194 This code is copied from the Cygwin source code and rearranged to allow
2195 dynamically loading of the needed symbols from advapi32 which is only
2196 available on NT/2K/XP. */
2198 set_process_privilege (const char *privilege
, BOOL enable
)
2200 HANDLE token_hdl
= NULL
;
2202 TOKEN_PRIVILEGES new_priv
, orig_priv
;
2206 if (!OpenProcessToken (GetCurrentProcess (),
2207 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
2211 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
2214 new_priv
.PrivilegeCount
= 1;
2215 new_priv
.Privileges
[0].Luid
= restore_priv
;
2216 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
2218 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
2219 sizeof orig_priv
, &orig_priv
, &size
))
2222 /* Disabled, otherwise every `attach' in an unprivileged user session
2223 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
2224 windows_attach(). */
2225 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
2226 be enabled. GetLastError () returns an correct error code, though. */
2227 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
2231 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
2235 CloseHandle (token_hdl
);
2240 /* Attach to process PID, then initialize for debugging it. */
2243 windows_nat_target::attach (const char *args
, int from_tty
)
2248 pid
= parse_pid_to_attach (args
);
2250 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
2252 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
2253 printf_unfiltered ("This can cause attach to "
2254 "fail on Windows NT/2K/XP\n");
2257 windows_init_thread_list ();
2258 ok
= DebugActiveProcess (pid
);
2264 /* Try fall back to Cygwin pid. */
2265 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
2268 ok
= DebugActiveProcess (pid
);
2273 error (_("Can't attach to process %u (error %u)"),
2274 (unsigned) pid
, (unsigned) GetLastError ());
2276 DebugSetProcessKillOnExit (FALSE
);
2280 const char *exec_file
= get_exec_file (0);
2283 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
2284 target_pid_to_str (ptid_t (pid
)).c_str ());
2286 printf_unfiltered ("Attaching to %s\n",
2287 target_pid_to_str (ptid_t (pid
)).c_str ());
2291 HANDLE h
= OpenProcess (PROCESS_QUERY_INFORMATION
, FALSE
, pid
);
2295 if (IsWow64Process (h
, &wow64
))
2296 wow64_process
= wow64
;
2301 do_initial_windows_stuff (this, pid
, 1);
2302 target_terminal::ours ();
2306 windows_nat_target::detach (inferior
*inf
, int from_tty
)
2310 ptid_t ptid
= minus_one_ptid
;
2311 resume (ptid
, 0, GDB_SIGNAL_0
);
2313 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
2315 error (_("Can't detach process %u (error %u)"),
2316 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
2319 DebugSetProcessKillOnExit (FALSE
);
2321 if (detached
&& from_tty
)
2323 const char *exec_file
= get_exec_file (0);
2326 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
2327 (unsigned) current_event
.dwProcessId
);
2330 x86_cleanup_dregs ();
2331 inferior_ptid
= null_ptid
;
2332 detach_inferior (inf
);
2334 maybe_unpush_target ();
2337 /* Try to determine the executable filename.
2339 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2341 Upon success, the filename is stored inside EXE_NAME_RET, and
2342 this function returns nonzero.
2344 Otherwise, this function returns zero and the contents of
2345 EXE_NAME_RET is undefined. */
2348 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2358 if (!EnumProcessModulesEx (current_process_handle
, &dh_buf
,
2359 sizeof (HMODULE
), &cbNeeded
,
2360 LIST_MODULES_32BIT
) || !cbNeeded
)
2366 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2367 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2371 /* We know the executable is always first in the list of modules,
2372 which we just fetched. So no need to fetch more. */
2376 /* Cygwin prefers that the path be in /x/y/z format, so extract
2377 the filename into a temporary buffer first, and then convert it
2378 to POSIX format into the destination buffer. */
2379 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2381 len
= GetModuleFileNameEx (current_process_handle
,
2382 dh_buf
, pathbuf
, exe_name_max_len
);
2384 error (_("Error getting executable filename: %u."),
2385 (unsigned) GetLastError ());
2386 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2387 exe_name_max_len
) < 0)
2388 error (_("Error converting executable filename to POSIX: %d."), errno
);
2391 len
= GetModuleFileNameEx (current_process_handle
,
2392 dh_buf
, exe_name_ret
, exe_name_max_len
);
2394 error (_("Error getting executable filename: %u."),
2395 (unsigned) GetLastError ());
2398 return 1; /* success */
2401 /* The pid_to_exec_file target_ops method for this platform. */
2404 windows_nat_target::pid_to_exec_file (int pid
)
2406 static char path
[__PMAX
];
2408 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2410 char procexe
[sizeof ("/proc/4294967295/exe")];
2412 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2413 nchars
= readlink (procexe
, path
, sizeof(path
));
2414 if (nchars
> 0 && nchars
< sizeof (path
))
2416 path
[nchars
] = '\0'; /* Got it */
2421 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2422 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2423 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2429 /* Print status information about what we're accessing. */
2432 windows_nat_target::files_info ()
2434 struct inferior
*inf
= current_inferior ();
2436 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2437 inf
->attach_flag
? "attached" : "child",
2438 target_pid_to_str (inferior_ptid
).c_str ());
2441 /* Modify CreateProcess parameters for use of a new separate console.
2443 *FLAGS: DWORD parameter for general process creation flags.
2444 *SI: STARTUPINFO structure, for which the console window size and
2445 console buffer size is filled in if GDB is running in a console.
2446 to create the new console.
2447 The size of the used font is not available on all versions of
2448 Windows OS. Furthermore, the current font might not be the default
2449 font, but this is still better than before.
2450 If the windows and buffer sizes are computed,
2451 SI->DWFLAGS is changed so that this information is used
2452 by CreateProcess function. */
2455 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2457 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2458 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2460 if (hconsole
!= INVALID_HANDLE_VALUE
)
2462 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2464 CONSOLE_FONT_INFO cfi
;
2466 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2467 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2468 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2469 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2470 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2472 si
->dwXSize
*= font_size
.X
;
2476 si
->dwYSize
*= font_size
.Y
;
2479 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2480 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2481 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2483 *flags
|= CREATE_NEW_CONSOLE
;
2487 /* Function called by qsort to sort environment strings. */
2490 envvar_cmp (const void *a
, const void *b
)
2492 const char **p
= (const char **) a
;
2493 const char **q
= (const char **) b
;
2494 return strcasecmp (*p
, *q
);
2500 clear_win32_environment (char **env
)
2504 wchar_t *copy
= NULL
, *equalpos
;
2506 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2508 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2509 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2510 mbstowcs (copy
, env
[i
], len
);
2511 equalpos
= wcschr (copy
, L
'=');
2514 SetEnvironmentVariableW (copy
, NULL
);
2522 /* Redirection of inferior I/O streams for native MS-Windows programs.
2523 Unlike on Unix, where this is handled by invoking the inferior via
2524 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2526 The official documentation of the cmd.exe redirection features is here:
2528 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2530 (That page talks about Windows XP, but there's no newer
2531 documentation, so we assume later versions of cmd.exe didn't change
2534 Caveat: the documentation on that page seems to include a few lies.
2535 For example, it describes strange constructs 1<&2 and 2<&1, which
2536 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2537 think the cmd.exe parser of the redirection symbols simply doesn't
2538 care about the < vs > distinction in these cases. Therefore, the
2539 supported features are explicitly documented below.
2541 The emulation below aims at supporting all the valid use cases
2542 supported by cmd.exe, which include:
2544 < FILE redirect standard input from FILE
2545 0< FILE redirect standard input from FILE
2546 <&N redirect standard input from file descriptor N
2547 0<&N redirect standard input from file descriptor N
2548 > FILE redirect standard output to FILE
2549 >> FILE append standard output to FILE
2550 1>> FILE append standard output to FILE
2551 >&N redirect standard output to file descriptor N
2552 1>&N redirect standard output to file descriptor N
2553 >>&N append standard output to file descriptor N
2554 1>>&N append standard output to file descriptor N
2555 2> FILE redirect standard error to FILE
2556 2>> FILE append standard error to FILE
2557 2>&N redirect standard error to file descriptor N
2558 2>>&N append standard error to file descriptor N
2560 Note that using N > 2 in the above construct is supported, but
2561 requires that the corresponding file descriptor be open by some
2562 means elsewhere or outside GDB. Also note that using ">&0" or
2563 "<&2" will generally fail, because the file descriptor redirected
2564 from is normally open in an incompatible mode (e.g., FD 0 is open
2565 for reading only). IOW, use of such tricks is not recommended;
2566 you are on your own.
2568 We do NOT support redirection of file descriptors above 2, as in
2569 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2570 that needs special handling in the startup code that MinGW
2571 doesn't have). Pipes are also not supported.
2573 As for invalid use cases, where the redirection contains some
2574 error, the emulation below will detect that and produce some
2575 error and/or failure. But the behavior in those cases is not
2576 bug-for-bug compatible with what cmd.exe does in those cases.
2577 That's because what cmd.exe does then is not well defined, and
2578 seems to be a side effect of the cmd.exe parsing of the command
2579 line more than anything else. For example, try redirecting to an
2580 invalid file name, as in "> foo:bar".
2582 There are also minor syntactic deviations from what cmd.exe does
2583 in some corner cases. For example, it doesn't support the likes
2584 of "> &foo" to mean redirect to file named literally "&foo"; we
2585 do support that here, because that, too, sounds like some issue
2586 with the cmd.exe parser. Another nicety is that we support
2587 redirection targets that use file names with forward slashes,
2588 something cmd.exe doesn't -- this comes in handy since GDB
2589 file-name completion can be used when typing the command line for
2592 /* Support routines for redirecting standard handles of the inferior. */
2594 /* Parse a single redirection spec, open/duplicate the specified
2595 file/fd, and assign the appropriate value to one of the 3 standard
2596 file descriptors. */
2598 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2600 int *fd
, ref_fd
= -2;
2602 const char *fname
= redir_string
+ 1;
2603 int rc
= *redir_string
;
2618 fd
= (rc
== '2') ? err
: out
;
2619 mode
= O_WRONLY
| O_CREAT
;
2632 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2634 /* A reference to a file descriptor. */
2636 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2637 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2639 /* Don't allow redirection when open modes are incompatible. */
2640 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2641 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2648 else if (ref_fd
== 1)
2650 else if (ref_fd
== 2)
2660 fname
++; /* skip the separator space */
2661 /* If the descriptor is already open, close it. This allows
2662 multiple specs of redirections for the same stream, which is
2663 somewhat nonsensical, but still valid and supported by cmd.exe.
2664 (But cmd.exe only opens a single file in this case, the one
2665 specified by the last redirection spec on the command line.) */
2670 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2674 else if (ref_fd
== -1)
2675 *fd
= -1; /* reset to default destination */
2678 *fd
= _dup (ref_fd
);
2682 /* _open just sets a flag for O_APPEND, which won't be passed to the
2683 inferior, so we need to actually move the file pointer. */
2684 if ((mode
& O_APPEND
) != 0)
2685 _lseek (*fd
, 0L, SEEK_END
);
2689 /* Canonicalize a single redirection spec and set up the corresponding
2690 file descriptor as specified. */
2692 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2694 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2696 const char *start
= s
;
2699 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2700 if ((*start
== '>' || *start
== '1' || *start
== '2')
2704 if (*s
== '>' && *start
!= '>')
2707 else if (*start
== '0' && *s
== '<')
2709 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2712 while (isspace (*s
)) /* skip whitespace before file name */
2714 *d
++ = ' '; /* separate file name with a single space */
2717 /* Copy the file name. */
2720 /* Remove quoting characters from the file name in buf[]. */
2721 if (*s
== '"') /* could support '..' quoting here */
2725 else if (*s
== quote
)
2733 else if (*s
== '\\')
2735 if (s
[1] == '"') /* could support '..' here */
2739 else if (isspace (*s
) && !quote
)
2743 if (d
- buf
>= sizeof (buf
) - 1)
2745 errno
= ENAMETOOLONG
;
2751 /* Windows doesn't allow redirection characters in file names, so we
2752 can bail out early if they use them, or if there's no target file
2753 name after the redirection symbol. */
2754 if (d
[-1] == '>' || d
[-1] == '<')
2759 if (redir_open (buf
, inp
, out
, err
) == 0)
2764 /* Parse the command line for redirection specs and prepare the file
2765 descriptors for the 3 standard streams accordingly. */
2767 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2768 int *inp
, int *out
, int *err
)
2770 const char *s
= cmd_orig
;
2773 bool retval
= false;
2775 while (isspace (*s
))
2780 if (*s
== '"') /* could also support '..' quoting here */
2784 else if (*s
== quote
)
2787 else if (*s
== '\\')
2789 if (s
[1] == '"') /* escaped quote char */
2794 /* Process a single redirection candidate. */
2795 if (*s
== '<' || *s
== '>'
2796 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2797 || (*s
== '0' && s
[1] == '<'))
2799 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2813 #endif /* !__CYGWIN__ */
2815 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2816 EXEC_FILE is the file to run.
2817 ALLARGS is a string containing the arguments to the program.
2818 ENV is the environment vector to pass. Errors reported with error(). */
2821 windows_nat_target::create_inferior (const char *exec_file
,
2822 const std::string
&origallargs
,
2823 char **in_env
, int from_tty
)
2827 cygwin_buf_t real_path
[__PMAX
];
2828 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2829 cygwin_buf_t infcwd
[__PMAX
];
2831 cygwin_buf_t
*toexec
;
2832 cygwin_buf_t
*cygallargs
;
2834 char **old_env
= NULL
;
2838 int ostdin
, ostdout
, ostderr
;
2839 #else /* !__CYGWIN__ */
2840 char shell
[__PMAX
]; /* Path to shell */
2842 char *args
, *allargs_copy
;
2843 size_t args_len
, allargs_len
;
2844 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2845 HANDLE tty
= INVALID_HANDLE_VALUE
;
2846 bool redirected
= false;
2853 #endif /* !__CYGWIN__ */
2854 const char *allargs
= origallargs
.c_str ();
2855 PROCESS_INFORMATION pi
;
2858 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2861 error (_("No executable specified, use `target exec'."));
2863 const char *inferior_cwd
= get_inferior_cwd ();
2864 std::string expanded_infcwd
;
2865 if (inferior_cwd
!= NULL
)
2867 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
2868 /* Mirror slashes on inferior's cwd. */
2869 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
2871 inferior_cwd
= expanded_infcwd
.c_str ();
2874 memset (&si
, 0, sizeof (si
));
2875 si
.cb
= sizeof (si
);
2878 flags
|= CREATE_NEW_PROCESS_GROUP
;
2881 windows_set_console_info (&si
, &flags
);
2886 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2887 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2888 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2889 error (_("Error starting executable: %d"), errno
);
2892 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2893 if (len
== (size_t) -1)
2894 error (_("Error starting executable: %d"), errno
);
2895 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2896 mbstowcs (cygallargs
, allargs
, len
);
2897 #else /* !__USEWIDE */
2898 cygallargs
= allargs
;
2904 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2905 error (_("Error starting executable via shell: %d"), errno
);
2907 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2908 + mbstowcs (NULL
, allargs
, 0) + 2;
2909 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2910 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2911 #else /* !__USEWIDE */
2912 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2913 + strlen (allargs
) + 2);
2914 cygallargs
= (char *) alloca (len
);
2915 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2916 #endif /* __USEWIDE */
2918 flags
|= DEBUG_PROCESS
;
2921 if (inferior_cwd
!= NULL
2922 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
2923 infcwd
, strlen (inferior_cwd
)) < 0)
2924 error (_("Error converting inferior cwd: %d"), errno
);
2927 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2928 * sizeof (wchar_t));
2929 wcscpy (args
, toexec
);
2930 wcscat (args
, L
" ");
2931 wcscat (args
, cygallargs
);
2932 #else /* !__USEWIDE */
2933 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2934 strcpy (args
, toexec
);
2936 strcat (args
, cygallargs
);
2937 #endif /* !__USEWIDE */
2939 #ifdef CW_CVT_ENV_TO_WINENV
2940 /* First try to create a direct Win32 copy of the POSIX environment. */
2941 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2942 if (w32_env
!= (PWCHAR
) -1)
2943 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2945 /* If that fails, fall back to old method tweaking GDB's environment. */
2946 #endif /* CW_CVT_ENV_TO_WINENV */
2948 /* Reset all Win32 environment variables to avoid leftover on next run. */
2949 clear_win32_environment (environ
);
2950 /* Prepare the environment vars for CreateProcess. */
2953 cygwin_internal (CW_SYNC_WINENV
);
2957 if (!inferior_io_terminal
)
2958 tty
= ostdin
= ostdout
= ostderr
= -1;
2961 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2964 print_sys_errmsg (inferior_io_terminal
, errno
);
2965 ostdin
= ostdout
= ostderr
= -1;
2978 windows_init_thread_list ();
2979 ret
= CreateProcess (0,
2980 args
, /* command line */
2981 NULL
, /* Security */
2983 TRUE
, /* inherit handles */
2984 flags
, /* start flags */
2985 w32_env
, /* environment */
2986 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
2991 /* Just free the Win32 environment, if it could be created. */
2995 /* Reset all environment variables to avoid leftover on next run. */
2996 clear_win32_environment (in_env
);
2997 /* Restore normal GDB environment variables. */
2999 cygwin_internal (CW_SYNC_WINENV
);
3012 #else /* !__CYGWIN__ */
3013 allargs_len
= strlen (allargs
);
3014 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
3015 if (strpbrk (allargs_copy
, "<>") != NULL
)
3020 redirect_inferior_handles (allargs
, allargs_copy
,
3021 &fd_inp
, &fd_out
, &fd_err
);
3023 warning (_("Error in redirection: %s."), safe_strerror (errno
));
3026 allargs_len
= strlen (allargs_copy
);
3028 /* If not all the standard streams are redirected by the command
3029 line, use inferior_io_terminal for those which aren't. */
3030 if (inferior_io_terminal
3031 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
3033 SECURITY_ATTRIBUTES sa
;
3034 sa
.nLength
= sizeof(sa
);
3035 sa
.lpSecurityDescriptor
= 0;
3036 sa
.bInheritHandle
= TRUE
;
3037 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
3038 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
3039 if (tty
== INVALID_HANDLE_VALUE
)
3040 warning (_("Warning: Failed to open TTY %s, error %#x."),
3041 inferior_io_terminal
, (unsigned) GetLastError ());
3043 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
3046 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
3047 else if (tty
!= INVALID_HANDLE_VALUE
)
3050 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
3052 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
3053 else if (tty
!= INVALID_HANDLE_VALUE
)
3054 si
.hStdOutput
= tty
;
3056 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
3058 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
3059 else if (tty
!= INVALID_HANDLE_VALUE
)
3062 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
3063 si
.dwFlags
|= STARTF_USESTDHANDLES
;
3067 /* Build the command line, a space-separated list of tokens where
3068 the first token is the name of the module to be executed.
3069 To avoid ambiguities introduced by spaces in the module name,
3071 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
3072 args
= (char *) alloca (args_len
);
3073 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
3075 flags
|= DEBUG_ONLY_THIS_PROCESS
;
3077 /* CreateProcess takes the environment list as a null terminated set of
3078 strings (i.e. two nulls terminate the list). */
3080 /* Get total size for env strings. */
3081 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
3082 envlen
+= strlen (in_env
[i
]) + 1;
3084 envsize
= sizeof (in_env
[0]) * (i
+ 1);
3085 env
= (char **) alloca (envsize
);
3086 memcpy (env
, in_env
, envsize
);
3087 /* Windows programs expect the environment block to be sorted. */
3088 qsort (env
, i
, sizeof (char *), envvar_cmp
);
3090 w32env
= (char *) alloca (envlen
+ 1);
3092 /* Copy env strings into new buffer. */
3093 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
3095 strcpy (temp
, env
[i
]);
3096 temp
+= strlen (temp
) + 1;
3099 /* Final nil string to terminate new env. */
3102 windows_init_thread_list ();
3103 ret
= CreateProcessA (0,
3104 args
, /* command line */
3105 NULL
, /* Security */
3107 TRUE
, /* inherit handles */
3108 flags
, /* start flags */
3109 w32env
, /* environment */
3110 inferior_cwd
, /* current directory */
3113 if (tty
!= INVALID_HANDLE_VALUE
)
3121 #endif /* !__CYGWIN__ */
3124 error (_("Error creating process %s, (error %u)."),
3125 exec_file
, (unsigned) GetLastError ());
3129 if (IsWow64Process (pi
.hProcess
, &wow64
))
3130 wow64_process
= wow64
;
3133 CloseHandle (pi
.hThread
);
3134 CloseHandle (pi
.hProcess
);
3136 if (useshell
&& shell
[0] != '\0')
3141 do_initial_windows_stuff (this, pi
.dwProcessId
, 0);
3143 /* windows_continue (DBG_CONTINUE, -1, 0); */
3147 windows_nat_target::mourn_inferior ()
3149 (void) windows_continue (DBG_CONTINUE
, -1, 0);
3150 x86_cleanup_dregs();
3151 if (open_process_used
)
3153 CHECK (CloseHandle (current_process_handle
));
3154 open_process_used
= 0;
3156 siginfo_er
.ExceptionCode
= 0;
3157 inf_child_target::mourn_inferior ();
3160 /* Send a SIGINT to the process group. This acts just like the user typed a
3161 ^C on the controlling terminal. */
3164 windows_nat_target::interrupt ()
3166 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
3167 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
3168 registers_changed (); /* refresh register state */
3171 /* Helper for windows_xfer_partial that handles memory transfers.
3172 Arguments are like target_xfer_partial. */
3174 static enum target_xfer_status
3175 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3176 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
3180 DWORD lasterror
= 0;
3182 if (writebuf
!= NULL
)
3184 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
3185 pulongest (len
), core_addr_to_string (memaddr
)));
3186 success
= WriteProcessMemory (current_process_handle
,
3187 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
3190 lasterror
= GetLastError ();
3191 FlushInstructionCache (current_process_handle
,
3192 (LPCVOID
) (uintptr_t) memaddr
, len
);
3196 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
3197 pulongest (len
), core_addr_to_string (memaddr
)));
3198 success
= ReadProcessMemory (current_process_handle
,
3199 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
3202 lasterror
= GetLastError ();
3204 *xfered_len
= (ULONGEST
) done
;
3205 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
3206 return TARGET_XFER_OK
;
3208 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
3212 windows_nat_target::kill ()
3214 CHECK (TerminateProcess (current_process_handle
, 0));
3218 if (!windows_continue (DBG_CONTINUE
, -1, 1))
3220 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
3222 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
3226 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
3230 windows_nat_target::close ()
3232 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
3233 inferior_ptid
.pid ()));
3236 /* Convert pid to printable format. */
3238 windows_nat_target::pid_to_str (ptid_t ptid
)
3240 if (ptid
.lwp () != 0)
3241 return string_printf ("Thread %d.0x%lx", ptid
.pid (), ptid
.lwp ());
3243 return normal_pid_to_str (ptid
);
3246 static enum target_xfer_status
3247 windows_xfer_shared_libraries (struct target_ops
*ops
,
3248 enum target_object object
, const char *annex
,
3249 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3250 ULONGEST offset
, ULONGEST len
,
3251 ULONGEST
*xfered_len
)
3253 struct obstack obstack
;
3259 return TARGET_XFER_E_IO
;
3261 obstack_init (&obstack
);
3262 obstack_grow_str (&obstack
, "<library-list>\n");
3263 for (so
= solib_start
.next
; so
; so
= so
->next
)
3265 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
3267 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
3268 (uintptr_t) li
->load_addr
,
3270 target_gdbarch (), &obstack
);
3272 obstack_grow_str0 (&obstack
, "</library-list>\n");
3274 buf
= (const char *) obstack_finish (&obstack
);
3275 len_avail
= strlen (buf
);
3276 if (offset
>= len_avail
)
3280 if (len
> len_avail
- offset
)
3281 len
= len_avail
- offset
;
3282 memcpy (readbuf
, buf
+ offset
, len
);
3285 obstack_free (&obstack
, NULL
);
3286 *xfered_len
= (ULONGEST
) len
;
3287 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
3290 /* Helper for windows_nat_target::xfer_partial that handles signal info. */
3292 static enum target_xfer_status
3293 windows_xfer_siginfo (gdb_byte
*readbuf
, ULONGEST offset
, ULONGEST len
,
3294 ULONGEST
*xfered_len
)
3296 char *buf
= (char *) &siginfo_er
;
3297 size_t bufsize
= sizeof (siginfo_er
);
3300 EXCEPTION_RECORD32 er32
;
3303 buf
= (char *) &er32
;
3304 bufsize
= sizeof (er32
);
3306 er32
.ExceptionCode
= siginfo_er
.ExceptionCode
;
3307 er32
.ExceptionFlags
= siginfo_er
.ExceptionFlags
;
3308 er32
.ExceptionRecord
= (uintptr_t) siginfo_er
.ExceptionRecord
;
3309 er32
.ExceptionAddress
= (uintptr_t) siginfo_er
.ExceptionAddress
;
3310 er32
.NumberParameters
= siginfo_er
.NumberParameters
;
3312 for (i
= 0; i
< EXCEPTION_MAXIMUM_PARAMETERS
; i
++)
3313 er32
.ExceptionInformation
[i
] = siginfo_er
.ExceptionInformation
[i
];
3317 if (siginfo_er
.ExceptionCode
== 0)
3318 return TARGET_XFER_E_IO
;
3320 if (readbuf
== nullptr)
3321 return TARGET_XFER_E_IO
;
3323 if (offset
> bufsize
)
3324 return TARGET_XFER_E_IO
;
3326 if (offset
+ len
> bufsize
)
3327 len
= bufsize
- offset
;
3329 memcpy (readbuf
, buf
+ offset
, len
);
3332 return TARGET_XFER_OK
;
3335 enum target_xfer_status
3336 windows_nat_target::xfer_partial (enum target_object object
,
3337 const char *annex
, gdb_byte
*readbuf
,
3338 const gdb_byte
*writebuf
, ULONGEST offset
,
3339 ULONGEST len
, ULONGEST
*xfered_len
)
3343 case TARGET_OBJECT_MEMORY
:
3344 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
3346 case TARGET_OBJECT_LIBRARIES
:
3347 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
3348 writebuf
, offset
, len
, xfered_len
);
3350 case TARGET_OBJECT_SIGNAL_INFO
:
3351 return windows_xfer_siginfo (readbuf
, offset
, len
, xfered_len
);
3354 if (beneath () == NULL
)
3356 /* This can happen when requesting the transfer of unsupported
3357 objects before a program has been started (and therefore
3358 with the current_target having no target beneath). */
3359 return TARGET_XFER_E_IO
;
3361 return beneath ()->xfer_partial (object
, annex
,
3362 readbuf
, writebuf
, offset
, len
,
3367 /* Provide thread local base, i.e. Thread Information Block address.
3368 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
3371 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
3373 windows_thread_info
*th
;
3375 th
= thread_rec (ptid
.lwp (), DONT_INVALIDATE_CONTEXT
);
3380 *addr
= th
->thread_local_base
;
3386 windows_nat_target::get_ada_task_ptid (long lwp
, long thread
)
3388 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
3391 /* Implementation of the to_thread_name method. */
3394 windows_nat_target::thread_name (struct thread_info
*thr
)
3396 return thread_rec (thr
->ptid
.lwp (), DONT_INVALIDATE_CONTEXT
)->name
.get ();
3400 void _initialize_windows_nat ();
3402 _initialize_windows_nat ()
3404 x86_dr_low
.set_control
= cygwin_set_dr7
;
3405 x86_dr_low
.set_addr
= cygwin_set_dr
;
3406 x86_dr_low
.get_addr
= cygwin_get_dr
;
3407 x86_dr_low
.get_status
= cygwin_get_dr6
;
3408 x86_dr_low
.get_control
= cygwin_get_dr7
;
3410 /* x86_dr_low.debug_register_length field is set by
3411 calling x86_set_debug_register_length function
3412 in processor windows specific native file. */
3414 add_inf_child_target (&the_windows_nat_target
);
3417 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3420 add_com ("signal-event", class_run
, signal_event_command
, _("\
3421 Signal a crashed process with event ID, to allow its debugging.\n\
3422 This command is needed in support of setting up GDB as JIT debugger on \
3423 MS-Windows. The command should be invoked from the GDB command line using \
3424 the '-ex' command-line option. The ID of the event that blocks the \
3425 crashed process will be supplied by the Windows JIT debugging mechanism."));
3428 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3429 Set use of shell to start subprocess."), _("\
3430 Show use of shell to start subprocess."), NULL
,
3432 NULL
, /* FIXME: i18n: */
3433 &setlist
, &showlist
);
3435 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3436 &cygwin_exceptions
, _("\
3437 Break when an exception is detected in the Cygwin DLL itself."), _("\
3438 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3440 NULL
, /* FIXME: i18n: */
3441 &setlist
, &showlist
);
3444 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3445 Set creation of new console when creating child process."), _("\
3446 Show creation of new console when creating child process."), NULL
,
3448 NULL
, /* FIXME: i18n: */
3449 &setlist
, &showlist
);
3451 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3452 Set creation of new group when creating child process."), _("\
3453 Show creation of new group when creating child process."), NULL
,
3455 NULL
, /* FIXME: i18n: */
3456 &setlist
, &showlist
);
3458 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3459 Set whether to display execution in child process."), _("\
3460 Show whether to display execution in child process."), NULL
,
3462 NULL
, /* FIXME: i18n: */
3463 &setlist
, &showlist
);
3465 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3466 Set whether to display kernel events in child process."), _("\
3467 Show whether to display kernel events in child process."), NULL
,
3469 NULL
, /* FIXME: i18n: */
3470 &setlist
, &showlist
);
3472 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3473 Set whether to display memory accesses in child process."), _("\
3474 Show whether to display memory accesses in child process."), NULL
,
3476 NULL
, /* FIXME: i18n: */
3477 &setlist
, &showlist
);
3479 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3480 &debug_exceptions
, _("\
3481 Set whether to display kernel exceptions in child process."), _("\
3482 Show whether to display kernel exceptions in child process."), NULL
,
3484 NULL
, /* FIXME: i18n: */
3485 &setlist
, &showlist
);
3487 init_w32_command_list ();
3489 add_cmd ("selector", class_info
, display_selectors
,
3490 _("Display selectors infos."),
3494 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3496 /* Pass the address ADDR to the inferior in the I'th debug register.
3497 Here we just store the address in dr array, the registers will be
3498 actually set up when windows_continue is called. */
3500 cygwin_set_dr (int i
, CORE_ADDR addr
)
3503 internal_error (__FILE__
, __LINE__
,
3504 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3506 debug_registers_changed
= 1;
3507 debug_registers_used
= 1;
3510 /* Pass the value VAL to the inferior in the DR7 debug control
3511 register. Here we just store the address in D_REGS, the watchpoint
3512 will be actually set up in windows_wait. */
3514 cygwin_set_dr7 (unsigned long val
)
3516 dr
[7] = (CORE_ADDR
) val
;
3517 debug_registers_changed
= 1;
3518 debug_registers_used
= 1;
3521 /* Get the value of debug register I from the inferior. */
3524 cygwin_get_dr (int i
)
3529 /* Get the value of the DR6 debug status register from the inferior.
3530 Here we just return the value stored in dr[6]
3531 by the last call to thread_rec for current_event.dwThreadId id. */
3532 static unsigned long
3533 cygwin_get_dr6 (void)
3535 return (unsigned long) dr
[6];
3538 /* Get the value of the DR7 debug status register from the inferior.
3539 Here we just return the value stored in dr[7] by the last call to
3540 thread_rec for current_event.dwThreadId id. */
3542 static unsigned long
3543 cygwin_get_dr7 (void)
3545 return (unsigned long) dr
[7];
3548 /* Determine if the thread referenced by "ptid" is alive
3549 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3550 it means that the thread has died. Otherwise it is assumed to be alive. */
3553 windows_nat_target::thread_alive (ptid_t ptid
)
3557 gdb_assert (ptid
.lwp () != 0);
3560 return (WaitForSingleObject (thread_rec (tid
, DONT_INVALIDATE_CONTEXT
)->h
, 0)
3564 void _initialize_check_for_gdb_ini ();
3566 _initialize_check_for_gdb_ini ()
3569 if (inhibit_gdbinit
)
3572 homedir
= getenv ("HOME");
3576 char *oldini
= (char *) alloca (strlen (homedir
) +
3577 sizeof ("gdb.ini") + 1);
3578 strcpy (oldini
, homedir
);
3579 p
= strchr (oldini
, '\0');
3580 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3582 strcpy (p
, "gdb.ini");
3583 if (access (oldini
, 0) == 0)
3585 int len
= strlen (oldini
);
3586 char *newini
= (char *) alloca (len
+ 2);
3588 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3589 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3590 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3595 /* Define dummy functions which always return error for the rare cases where
3596 these functions could not be found. */
3598 bad_DebugActiveProcessStop (DWORD w
)
3603 bad_DebugBreakProcess (HANDLE w
)
3608 bad_DebugSetProcessKillOnExit (BOOL w
)
3613 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3620 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3626 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3633 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3639 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3645 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3651 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3659 /* Load any functions which may not be available in ancient versions
3662 void _initialize_loadable ();
3664 _initialize_loadable ()
3668 #define GPA(m, func) \
3669 func = (func ## _ftype *) GetProcAddress (m, #func)
3671 hm
= LoadLibrary ("kernel32.dll");
3674 GPA (hm
, DebugActiveProcessStop
);
3675 GPA (hm
, DebugBreakProcess
);
3676 GPA (hm
, DebugSetProcessKillOnExit
);
3677 GPA (hm
, GetConsoleFontSize
);
3678 GPA (hm
, DebugActiveProcessStop
);
3679 GPA (hm
, GetCurrentConsoleFont
);
3681 GPA (hm
, Wow64SuspendThread
);
3682 GPA (hm
, Wow64GetThreadContext
);
3683 GPA (hm
, Wow64SetThreadContext
);
3684 GPA (hm
, Wow64GetThreadSelectorEntry
);
3688 /* Set variables to dummy versions of these processes if the function
3689 wasn't found in kernel32.dll. */
3690 if (!DebugBreakProcess
)
3691 DebugBreakProcess
= bad_DebugBreakProcess
;
3692 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3694 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3695 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3697 if (!GetConsoleFontSize
)
3698 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3699 if (!GetCurrentConsoleFont
)
3700 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3702 /* Load optional functions used for retrieving filename information
3703 associated with the currently debugged process or its dlls. */
3704 hm
= LoadLibrary ("psapi.dll");
3707 GPA (hm
, EnumProcessModules
);
3709 GPA (hm
, EnumProcessModulesEx
);
3711 GPA (hm
, GetModuleInformation
);
3712 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3713 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3716 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3718 /* Set variables to dummy versions of these processes if the function
3719 wasn't found in psapi.dll. */
3720 EnumProcessModules
= bad_EnumProcessModules
;
3721 GetModuleInformation
= bad_GetModuleInformation
;
3722 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3723 /* This will probably fail on Windows 9x/Me. Let the user know
3724 that we're missing some functionality. */
3726 cannot automatically find executable file or library to read symbols.\n\
3727 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3730 hm
= LoadLibrary ("advapi32.dll");
3733 GPA (hm
, OpenProcessToken
);
3734 GPA (hm
, LookupPrivilegeValueA
);
3735 GPA (hm
, AdjustTokenPrivileges
);
3736 /* Only need to set one of these since if OpenProcessToken fails nothing
3738 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3739 || !AdjustTokenPrivileges
)
3740 OpenProcessToken
= bad_OpenProcessToken
;