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 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
408 then also retrieve the context for this thread. If GET_CONTEXT is
409 negative, then don't suspend the thread. */
410 static windows_thread_info
*
411 thread_rec (DWORD id
, int get_context
)
413 for (windows_thread_info
*th
: thread_list
)
416 if (!th
->suspended
&& get_context
)
418 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
420 if (SuspendThread (th
->h
) == (DWORD
) -1)
422 DWORD err
= GetLastError ();
424 /* We get Access Denied (5) when trying to suspend
425 threads that Windows started on behalf of the
426 debuggee, usually when those threads are just
428 We can get Invalid Handle (6) if the main thread
430 if (err
!= ERROR_INVALID_HANDLE
431 && err
!= ERROR_ACCESS_DENIED
)
432 warning (_("SuspendThread (tid=0x%x) failed."
434 (unsigned) id
, (unsigned) err
);
440 else if (get_context
< 0)
442 th
->reload_context
= 1;
450 /* Add a thread to the thread list.
452 PTID is the ptid of the thread to be added.
453 H is its Windows handle.
454 TLB is its thread local base.
455 MAIN_THREAD_P should be true if the thread to be added is
456 the main thread, false otherwise. */
458 static windows_thread_info
*
459 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
, bool main_thread_p
)
461 windows_thread_info
*th
;
464 gdb_assert (ptid
.tid () != 0);
468 if ((th
= thread_rec (id
, FALSE
)))
471 th
= XCNEW (windows_thread_info
);
474 th
->thread_local_base
= (CORE_ADDR
) (uintptr_t) tlb
;
476 /* For WOW64 processes, this is actually the pointer to the 64bit TIB,
477 and the 32bit TIB is exactly 2 pages after it. */
479 th
->thread_local_base
+= 0x2000;
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
.tid () != 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 ())
584 xfree ((*iter
)->name
);
586 thread_list
.erase (iter
);
590 /* Fetches register number R from the given windows_thread_info,
591 and supplies its value to the given regcache.
593 This function assumes that R is non-negative. A failed assertion
594 is raised if that is not true.
596 This function assumes that TH->RELOAD_CONTEXT is not set, meaning
597 that the windows_thread_info has an up-to-date context. A failed
598 assertion is raised if that assumption is violated. */
601 windows_fetch_one_register (struct regcache
*regcache
,
602 windows_thread_info
*th
, int r
)
605 gdb_assert (!th
->reload_context
);
607 char *context_ptr
= (char *) &th
->context
;
610 context_ptr
= (char *) &th
->wow64_context
;
613 char *context_offset
= context_ptr
+ mappings
[r
];
614 struct gdbarch
*gdbarch
= regcache
->arch ();
615 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
617 if (r
== I387_FISEG_REGNUM (tdep
))
619 long l
= *((long *) context_offset
) & 0xffff;
620 regcache
->raw_supply (r
, (char *) &l
);
622 else if (r
== I387_FOP_REGNUM (tdep
))
624 long l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
625 regcache
->raw_supply (r
, (char *) &l
);
627 else if (segment_register_p (r
))
629 /* GDB treats segment registers as 32bit registers, but they are
630 in fact only 16 bits long. Make sure we do not read extra
631 bits from our source buffer. */
632 long l
= *((long *) context_offset
) & 0xffff;
633 regcache
->raw_supply (r
, (char *) &l
);
636 regcache
->raw_supply (r
, context_offset
);
640 windows_nat_target::fetch_registers (struct regcache
*regcache
, int r
)
642 DWORD tid
= regcache
->ptid ().tid ();
643 windows_thread_info
*th
= thread_rec (tid
, TRUE
);
645 /* Check if TH exists. Windows sometimes uses a non-existent
646 thread id in its events. */
650 if (th
->reload_context
)
653 if (have_saved_context
)
655 /* Lie about where the program actually is stopped since
656 cygwin has informed us that we should consider the signal
657 to have occurred at another location which is stored in
659 memcpy (&th
->context
, &saved_context
,
660 __COPY_CONTEXT_SIZE
);
661 have_saved_context
= 0;
668 th
->wow64_context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
669 CHECK (Wow64GetThreadContext (th
->h
, &th
->wow64_context
));
670 /* Copy dr values from that thread.
671 But only if there were not modified since last stop.
673 if (!debug_registers_changed
)
675 dr
[0] = th
->wow64_context
.Dr0
;
676 dr
[1] = th
->wow64_context
.Dr1
;
677 dr
[2] = th
->wow64_context
.Dr2
;
678 dr
[3] = th
->wow64_context
.Dr3
;
679 dr
[6] = th
->wow64_context
.Dr6
;
680 dr
[7] = th
->wow64_context
.Dr7
;
686 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
687 CHECK (GetThreadContext (th
->h
, &th
->context
));
688 /* Copy dr values from that thread.
689 But only if there were not modified since last stop.
691 if (!debug_registers_changed
)
693 dr
[0] = th
->context
.Dr0
;
694 dr
[1] = th
->context
.Dr1
;
695 dr
[2] = th
->context
.Dr2
;
696 dr
[3] = th
->context
.Dr3
;
697 dr
[6] = th
->context
.Dr6
;
698 dr
[7] = th
->context
.Dr7
;
701 th
->reload_context
= 0;
705 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch()); r
++)
706 windows_fetch_one_register (regcache
, th
, r
);
708 windows_fetch_one_register (regcache
, th
, r
);
711 /* Collect the register number R from the given regcache, and store
712 its value into the corresponding area of the given thread's context.
714 This function assumes that R is non-negative. A failed assertion
715 assertion is raised if that is not true. */
718 windows_store_one_register (const struct regcache
*regcache
,
719 windows_thread_info
*th
, int r
)
723 char *context_ptr
= (char *) &th
->context
;
726 context_ptr
= (char *) &th
->wow64_context
;
729 regcache
->raw_collect (r
, context_ptr
+ mappings
[r
]);
732 /* Store a new register value into the context of the thread tied to
736 windows_nat_target::store_registers (struct regcache
*regcache
, int r
)
738 DWORD tid
= regcache
->ptid ().tid ();
739 windows_thread_info
*th
= thread_rec (tid
, TRUE
);
741 /* Check if TH exists. Windows sometimes uses a non-existent
742 thread id in its events. */
747 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch ()); r
++)
748 windows_store_one_register (regcache
, th
, r
);
750 windows_store_one_register (regcache
, th
, r
);
753 /* Maintain a linked list of "so" information. */
754 struct lm_info_windows
: public lm_info_base
756 LPVOID load_addr
= 0;
757 CORE_ADDR text_offset
= 0;
760 static struct so_list solib_start
, *solib_end
;
762 static struct so_list
*
763 windows_make_so (const char *name
, LPVOID load_addr
)
770 WIN32_FIND_DATA w32_fd
;
771 HANDLE h
= FindFirstFile(name
, &w32_fd
);
773 if (h
== INVALID_HANDLE_VALUE
)
779 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
781 p
= strrchr (buf
, '\\');
784 SetCurrentDirectory (buf
);
785 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
786 SetCurrentDirectory (cwd
);
789 if (strcasecmp (buf
, "ntdll.dll") == 0)
791 GetSystemDirectory (buf
, sizeof (buf
));
792 strcat (buf
, "\\ntdll.dll");
795 cygwin_buf_t buf
[__PMAX
];
798 if (access (name
, F_OK
) != 0)
800 if (strcasecmp (name
, "ntdll.dll") == 0)
803 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
804 wcscat (buf
, L
"\\ntdll.dll");
808 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
809 strcat (buf
, "\\ntdll.dll");
814 so
= XCNEW (struct so_list
);
815 lm_info_windows
*li
= new lm_info_windows
;
817 li
->load_addr
= load_addr
;
818 strcpy (so
->so_original_name
, name
);
820 strcpy (so
->so_name
, buf
);
823 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
824 SO_NAME_MAX_PATH_SIZE
);
827 char *rname
= realpath (name
, NULL
);
828 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
830 strcpy (so
->so_name
, rname
);
834 error (_("dll path too long"));
836 /* Record cygwin1.dll .text start/end. */
837 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
838 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
840 asection
*text
= NULL
;
842 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386", -1));
847 if (bfd_check_format (abfd
.get (), bfd_object
))
848 text
= bfd_get_section_by_name (abfd
.get (), ".text");
853 /* The symbols in a dll are offset by 0x1000, which is the
854 offset from 0 of the first byte in an image - because of the
855 file header and the section alignment. */
856 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
858 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (text
);
866 get_image_name (HANDLE h
, void *address
, int unicode
)
869 static char buf
[__PMAX
];
871 static char buf
[(2 * __PMAX
) + 1];
873 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
879 /* Attempt to read the name of the dll that was detected.
880 This is documented to work only when actively debugging
881 a program. It will not work for attached processes. */
885 /* See if we could read the address of a string, and that the
886 address isn't null. */
887 if (!ReadProcessMemory (h
, address
, &address_ptr
,
888 sizeof (address_ptr
), &done
)
889 || done
!= sizeof (address_ptr
) || !address_ptr
)
892 /* Find the length of the string. */
893 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
894 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
898 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
901 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
902 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
905 wcstombs (buf
, unicode_address
, __PMAX
);
907 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
915 /* Handle a DLL load event, and return 1.
917 This function assumes that this event did not occur during inferior
918 initialization, where their event info may be incomplete (see
919 do_initial_windows_stuff and windows_add_all_dlls for more info
920 on how we handle DLL loading during that phase). */
925 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
928 /* Try getting the DLL name via the lpImageName field of the event.
929 Note that Microsoft documents this fields as strictly optional,
930 in the sense that it might be NULL. And the first DLL event in
931 particular is explicitly documented as "likely not pass[ed]"
932 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
933 dll_name
= get_image_name (current_process_handle
,
934 event
->lpImageName
, event
->fUnicode
);
938 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
939 solib_end
= solib_end
->next
;
941 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
943 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
944 host_address_to_string (li
->load_addr
)));
948 windows_free_so (struct so_list
*so
)
950 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
956 /* Handle a DLL unload event.
957 Return 1 if successful, or zero otherwise.
959 This function assumes that this event did not occur during inferior
960 initialization, where their event info may be incomplete (see
961 do_initial_windows_stuff and windows_add_all_dlls for more info
962 on how we handle DLL loading during that phase). */
967 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
970 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
972 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
974 if (li_next
->load_addr
== lpBaseOfDll
)
976 struct so_list
*sodel
= so
->next
;
978 so
->next
= sodel
->next
;
981 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
983 windows_free_so (sodel
);
988 /* We did not find any DLL that was previously loaded at this address,
989 so register a complaint. We do not report an error, because we have
990 observed that this may be happening under some circumstances. For
991 instance, running 32bit applications on x64 Windows causes us to receive
992 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
993 events are apparently caused by the WOW layer, the interface between
994 32bit and 64bit worlds). */
995 complaint (_("dll starting at %s not found."),
996 host_address_to_string (lpBaseOfDll
));
999 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
1003 catch_errors (void (*func
) ())
1009 catch (const gdb_exception
&ex
)
1011 exception_print (gdb_stderr
, ex
);
1015 /* Clear list of loaded DLLs. */
1017 windows_clear_solib (void)
1021 for (so
= solib_start
.next
; so
; so
= solib_start
.next
)
1023 solib_start
.next
= so
->next
;
1024 windows_free_so (so
);
1027 solib_end
= &solib_start
;
1031 signal_event_command (const char *args
, int from_tty
)
1033 uintptr_t event_id
= 0;
1034 char *endargs
= NULL
;
1037 error (_("signal-event requires an argument (integer event id)"));
1039 event_id
= strtoumax (args
, &endargs
, 10);
1041 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
1042 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
1043 error (_("Failed to convert `%s' to event id"), args
);
1045 SetEvent ((HANDLE
) event_id
);
1046 CloseHandle ((HANDLE
) event_id
);
1049 /* Handle DEBUG_STRING output from child process.
1050 Cygwin prepends its messages with a "cygwin:". Interpret this as
1051 a Cygwin signal. Otherwise just print the string as a warning. */
1053 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
1055 gdb::unique_xmalloc_ptr
<char> s
;
1058 if (!target_read_string
1059 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
1061 || !s
|| !*(s
.get ()))
1062 /* nothing to do */;
1063 else if (!startswith (s
.get (), _CYGWIN_SIGNAL_STRING
))
1066 if (!startswith (s
.get (), "cYg"))
1069 char *p
= strchr (s
.get (), '\0');
1071 if (p
> s
.get () && *--p
== '\n')
1073 warning (("%s"), s
.get ());
1079 /* Got a cygwin signal marker. A cygwin signal is followed by
1080 the signal number itself and then optionally followed by the
1081 thread id and address to saved context within the DLL. If
1082 these are supplied, then the given thread is assumed to have
1083 issued the signal and the context from the thread is assumed
1084 to be stored at the given address in the inferior. Tell gdb
1085 to treat this like a real signal. */
1087 int sig
= strtol (s
.get () + sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
1088 gdb_signal gotasig
= gdb_signal_from_host (sig
);
1090 ourstatus
->value
.sig
= gotasig
;
1096 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1097 retval
= strtoul (p
, &p
, 0);
1099 retval
= current_event
.dwThreadId
;
1100 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
1101 && ReadProcessMemory (current_process_handle
, x
,
1103 __COPY_CONTEXT_SIZE
, &n
)
1104 && n
== __COPY_CONTEXT_SIZE
)
1105 have_saved_context
= 1;
1114 display_selector (HANDLE thread
, DWORD sel
)
1120 ret
= Wow64GetThreadSelectorEntry (thread
, sel
, &info
);
1123 ret
= GetThreadSelectorEntry (thread
, sel
, &info
);
1127 printf_filtered ("0x%03x: ", (unsigned) sel
);
1128 if (!info
.HighWord
.Bits
.Pres
)
1130 puts_filtered ("Segment not present\n");
1133 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1134 (info
.HighWord
.Bits
.BaseMid
<< 16)
1136 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1137 if (info
.HighWord
.Bits
.Granularity
)
1138 limit
= (limit
<< 12) | 0xfff;
1139 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1140 if (info
.HighWord
.Bits
.Default_Big
)
1141 puts_filtered(" 32-bit ");
1143 puts_filtered(" 16-bit ");
1144 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1147 puts_filtered ("Data (Read-Only, Exp-up");
1150 puts_filtered ("Data (Read/Write, Exp-up");
1153 puts_filtered ("Unused segment (");
1156 puts_filtered ("Data (Read/Write, Exp-down");
1159 puts_filtered ("Code (Exec-Only, N.Conf");
1162 puts_filtered ("Code (Exec/Read, N.Conf");
1165 puts_filtered ("Code (Exec-Only, Conf");
1168 puts_filtered ("Code (Exec/Read, Conf");
1171 printf_filtered ("Unknown type 0x%lx",
1172 (unsigned long) info
.HighWord
.Bits
.Type
);
1174 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1175 puts_filtered(", N.Acc");
1176 puts_filtered (")\n");
1177 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1178 puts_filtered("System selector ");
1179 printf_filtered ("Priviledge level = %ld. ",
1180 (unsigned long) info
.HighWord
.Bits
.Dpl
);
1181 if (info
.HighWord
.Bits
.Granularity
)
1182 puts_filtered ("Page granular.\n");
1184 puts_filtered ("Byte granular.\n");
1189 DWORD err
= GetLastError ();
1190 if (err
== ERROR_NOT_SUPPORTED
)
1191 printf_filtered ("Function not supported\n");
1193 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1199 display_selectors (const char * args
, int from_tty
)
1201 if (!current_thread
)
1203 puts_filtered ("Impossible to display selectors now.\n");
1211 puts_filtered ("Selector $cs\n");
1212 display_selector (current_thread
->h
,
1213 current_thread
->wow64_context
.SegCs
);
1214 puts_filtered ("Selector $ds\n");
1215 display_selector (current_thread
->h
,
1216 current_thread
->wow64_context
.SegDs
);
1217 puts_filtered ("Selector $es\n");
1218 display_selector (current_thread
->h
,
1219 current_thread
->wow64_context
.SegEs
);
1220 puts_filtered ("Selector $ss\n");
1221 display_selector (current_thread
->h
,
1222 current_thread
->wow64_context
.SegSs
);
1223 puts_filtered ("Selector $fs\n");
1224 display_selector (current_thread
->h
,
1225 current_thread
->wow64_context
.SegFs
);
1226 puts_filtered ("Selector $gs\n");
1227 display_selector (current_thread
->h
,
1228 current_thread
->wow64_context
.SegGs
);
1233 puts_filtered ("Selector $cs\n");
1234 display_selector (current_thread
->h
,
1235 current_thread
->context
.SegCs
);
1236 puts_filtered ("Selector $ds\n");
1237 display_selector (current_thread
->h
,
1238 current_thread
->context
.SegDs
);
1239 puts_filtered ("Selector $es\n");
1240 display_selector (current_thread
->h
,
1241 current_thread
->context
.SegEs
);
1242 puts_filtered ("Selector $ss\n");
1243 display_selector (current_thread
->h
,
1244 current_thread
->context
.SegSs
);
1245 puts_filtered ("Selector $fs\n");
1246 display_selector (current_thread
->h
,
1247 current_thread
->context
.SegFs
);
1248 puts_filtered ("Selector $gs\n");
1249 display_selector (current_thread
->h
,
1250 current_thread
->context
.SegGs
);
1256 sel
= parse_and_eval_long (args
);
1257 printf_filtered ("Selector \"%s\"\n",args
);
1258 display_selector (current_thread
->h
, sel
);
1262 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1263 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1264 host_address_to_string (\
1265 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1267 static handle_exception_result
1268 handle_exception (struct target_waitstatus
*ourstatus
)
1270 EXCEPTION_RECORD
*rec
= ¤t_event
.u
.Exception
.ExceptionRecord
;
1271 DWORD code
= rec
->ExceptionCode
;
1272 handle_exception_result result
= HANDLE_EXCEPTION_HANDLED
;
1274 memcpy (&siginfo_er
, rec
, sizeof siginfo_er
);
1276 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1278 /* Record the context of the current thread. */
1279 thread_rec (current_event
.dwThreadId
, -1);
1283 case EXCEPTION_ACCESS_VIOLATION
:
1284 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1285 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1288 /* See if the access violation happened within the cygwin DLL
1289 itself. Cygwin uses a kind of exception handling to deal
1290 with passed-in invalid addresses. gdb should not treat
1291 these as real SEGVs since they will be silently handled by
1292 cygwin. A real SEGV will (theoretically) be caught by
1293 cygwin later in the process and will be sent as a
1294 cygwin-specific-signal. So, ignore SEGVs if they show up
1295 within the text segment of the DLL itself. */
1297 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1299 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1300 && addr
< cygwin_load_end
))
1301 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1302 && startswith (fn
, "KERNEL32!IsBad")))
1303 return HANDLE_EXCEPTION_UNHANDLED
;
1307 case STATUS_STACK_OVERFLOW
:
1308 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1309 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1311 case STATUS_FLOAT_DENORMAL_OPERAND
:
1312 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1313 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1315 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1316 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1317 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1319 case STATUS_FLOAT_INEXACT_RESULT
:
1320 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1321 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1323 case STATUS_FLOAT_INVALID_OPERATION
:
1324 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1325 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1327 case STATUS_FLOAT_OVERFLOW
:
1328 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1329 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1331 case STATUS_FLOAT_STACK_CHECK
:
1332 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1333 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1335 case STATUS_FLOAT_UNDERFLOW
:
1336 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1337 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1339 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1340 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1341 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1343 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1344 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1345 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1347 case STATUS_INTEGER_OVERFLOW
:
1348 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1349 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1351 case EXCEPTION_BREAKPOINT
:
1353 if (ignore_first_breakpoint
)
1355 /* For WOW64 processes, there are always 2 breakpoint exceptions
1356 on startup, first a BREAKPOINT for the 64bit ntdll.dll,
1357 then a WX86_BREAKPOINT for the 32bit ntdll.dll.
1358 Here we only care about the WX86_BREAKPOINT's. */
1359 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1360 ignore_first_breakpoint
= false;
1364 case STATUS_WX86_BREAKPOINT
:
1365 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1366 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1369 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1370 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1372 case DBG_CONTROL_BREAK
:
1373 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1374 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1376 case EXCEPTION_SINGLE_STEP
:
1377 case STATUS_WX86_SINGLE_STEP
:
1378 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1379 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1381 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1382 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1383 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1385 case EXCEPTION_PRIV_INSTRUCTION
:
1386 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1387 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1389 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1390 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1391 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1393 case MS_VC_EXCEPTION
:
1394 if (rec
->NumberParameters
>= 3
1395 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1397 DWORD named_thread_id
;
1398 windows_thread_info
*named_thread
;
1399 CORE_ADDR thread_name_target
;
1401 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1403 thread_name_target
= rec
->ExceptionInformation
[1];
1404 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1406 if (named_thread_id
== (DWORD
) -1)
1407 named_thread_id
= current_event
.dwThreadId
;
1409 named_thread
= thread_rec (named_thread_id
, 0);
1410 if (named_thread
!= NULL
)
1412 int thread_name_len
;
1413 gdb::unique_xmalloc_ptr
<char> thread_name
;
1415 thread_name_len
= target_read_string (thread_name_target
,
1416 &thread_name
, 1025, NULL
);
1417 if (thread_name_len
> 0)
1419 thread_name
.get ()[thread_name_len
- 1] = '\0';
1420 xfree (named_thread
->name
);
1421 named_thread
->name
= thread_name
.release ();
1424 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1425 result
= HANDLE_EXCEPTION_IGNORED
;
1428 /* treat improperly formed exception as unknown */
1431 /* Treat unhandled first chance exceptions specially. */
1432 if (current_event
.u
.Exception
.dwFirstChance
)
1433 return HANDLE_EXCEPTION_UNHANDLED
;
1434 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1435 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1436 host_address_to_string (
1437 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1438 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1442 last_sig
= ourstatus
->value
.sig
;
1446 /* Resume thread specified by ID, or all artificially suspended
1447 threads, if we are continuing execution. KILLED non-zero means we
1448 have killed the inferior, so we should ignore weird errors due to
1449 threads shutting down. */
1451 windows_continue (DWORD continue_status
, int id
, int killed
)
1455 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1456 (unsigned) current_event
.dwProcessId
,
1457 (unsigned) current_event
.dwThreadId
,
1458 continue_status
== DBG_CONTINUE
?
1459 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1461 for (windows_thread_info
*th
: thread_list
)
1462 if ((id
== -1 || id
== (int) th
->tid
)
1468 if (debug_registers_changed
)
1470 th
->wow64_context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1471 th
->wow64_context
.Dr0
= dr
[0];
1472 th
->wow64_context
.Dr1
= dr
[1];
1473 th
->wow64_context
.Dr2
= dr
[2];
1474 th
->wow64_context
.Dr3
= dr
[3];
1475 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1476 th
->wow64_context
.Dr7
= dr
[7];
1478 if (th
->wow64_context
.ContextFlags
)
1482 if (GetExitCodeThread (th
->h
, &ec
)
1483 && ec
== STILL_ACTIVE
)
1485 BOOL status
= Wow64SetThreadContext (th
->h
,
1486 &th
->wow64_context
);
1491 th
->wow64_context
.ContextFlags
= 0;
1497 if (debug_registers_changed
)
1499 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1500 th
->context
.Dr0
= dr
[0];
1501 th
->context
.Dr1
= dr
[1];
1502 th
->context
.Dr2
= dr
[2];
1503 th
->context
.Dr3
= dr
[3];
1504 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1505 th
->context
.Dr7
= dr
[7];
1507 if (th
->context
.ContextFlags
)
1511 if (GetExitCodeThread (th
->h
, &ec
)
1512 && ec
== STILL_ACTIVE
)
1514 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1519 th
->context
.ContextFlags
= 0;
1522 if (th
->suspended
> 0)
1523 (void) ResumeThread (th
->h
);
1527 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1528 current_event
.dwThreadId
,
1532 error (_("Failed to resume program execution"
1533 " (ContinueDebugEvent failed, error %u)"),
1534 (unsigned int) GetLastError ());
1536 debug_registers_changed
= 0;
1540 /* Called in pathological case where Windows fails to send a
1541 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1543 fake_create_process (void)
1545 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1546 current_event
.dwProcessId
);
1547 if (current_process_handle
!= NULL
)
1548 open_process_used
= 1;
1551 error (_("OpenProcess call failed, GetLastError = %u"),
1552 (unsigned) GetLastError ());
1553 /* We can not debug anything in that case. */
1556 = windows_add_thread (ptid_t (current_event
.dwProcessId
, 0,
1557 current_event
.dwThreadId
),
1558 current_event
.u
.CreateThread
.hThread
,
1559 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1560 true /* main_thread_p */);
1561 return current_event
.dwThreadId
;
1565 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1567 windows_thread_info
*th
;
1568 DWORD continue_status
= DBG_CONTINUE
;
1570 /* A specific PTID means `step only this thread id'. */
1571 int resume_all
= ptid
== minus_one_ptid
;
1573 /* If we're continuing all threads, it's the current inferior that
1574 should be handled specially. */
1576 ptid
= inferior_ptid
;
1578 if (sig
!= GDB_SIGNAL_0
)
1580 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1582 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1584 else if (sig
== last_sig
)
1585 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1588 /* This code does not seem to work, because
1589 the kernel does probably not consider changes in the ExceptionRecord
1590 structure when passing the exception to the inferior.
1591 Note that this seems possible in the exception handler itself. */
1593 for (const xlate_exception
&x
: xlate
)
1596 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1598 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1601 if (continue_status
== DBG_CONTINUE
)
1603 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1607 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1611 last_sig
= GDB_SIGNAL_0
;
1613 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=0x%x, step=%d, sig=%d);\n",
1614 ptid
.pid (), (unsigned) ptid
.tid (), step
, sig
));
1616 /* Get context for currently selected thread. */
1617 th
= thread_rec (inferior_ptid
.tid (), FALSE
);
1625 /* Single step by setting t bit. */
1626 struct regcache
*regcache
= get_current_regcache ();
1627 struct gdbarch
*gdbarch
= regcache
->arch ();
1628 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1629 th
->wow64_context
.EFlags
|= FLAG_TRACE_BIT
;
1632 if (th
->wow64_context
.ContextFlags
)
1634 if (debug_registers_changed
)
1636 th
->wow64_context
.Dr0
= dr
[0];
1637 th
->wow64_context
.Dr1
= dr
[1];
1638 th
->wow64_context
.Dr2
= dr
[2];
1639 th
->wow64_context
.Dr3
= dr
[3];
1640 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1641 th
->wow64_context
.Dr7
= dr
[7];
1643 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
1644 th
->wow64_context
.ContextFlags
= 0;
1652 /* Single step by setting t bit. */
1653 struct regcache
*regcache
= get_current_regcache ();
1654 struct gdbarch
*gdbarch
= regcache
->arch ();
1655 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1656 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1659 if (th
->context
.ContextFlags
)
1661 if (debug_registers_changed
)
1663 th
->context
.Dr0
= dr
[0];
1664 th
->context
.Dr1
= dr
[1];
1665 th
->context
.Dr2
= dr
[2];
1666 th
->context
.Dr3
= dr
[3];
1667 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1668 th
->context
.Dr7
= dr
[7];
1670 CHECK (SetThreadContext (th
->h
, &th
->context
));
1671 th
->context
.ContextFlags
= 0;
1676 /* Allow continuing with the same signal that interrupted us.
1677 Otherwise complain. */
1680 windows_continue (continue_status
, -1, 0);
1682 windows_continue (continue_status
, ptid
.tid (), 0);
1685 /* Ctrl-C handler used when the inferior is not run in the same console. The
1686 handler is in charge of interrupting the inferior using DebugBreakProcess.
1687 Note that this function is not available prior to Windows XP. In this case
1688 we emit a warning. */
1690 ctrl_c_handler (DWORD event_type
)
1692 const int attach_flag
= current_inferior ()->attach_flag
;
1694 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1695 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1698 /* If the inferior and the debugger share the same console, do nothing as
1699 the inferior has also received the Ctrl-C event. */
1700 if (!new_console
&& !attach_flag
)
1703 if (!DebugBreakProcess (current_process_handle
))
1704 warning (_("Could not interrupt program. "
1705 "Press Ctrl-c in the program console."));
1707 /* Return true to tell that Ctrl-C has been handled. */
1711 /* Get the next event from the child. Returns a non-zero thread id if the event
1712 requires handling by WFI (or whatever). */
1715 windows_nat_target::get_windows_debug_event (int pid
,
1716 struct target_waitstatus
*ourstatus
)
1719 DWORD continue_status
, event_code
;
1720 windows_thread_info
*th
;
1721 static windows_thread_info dummy_thread_info
;
1722 DWORD thread_id
= 0;
1724 last_sig
= GDB_SIGNAL_0
;
1726 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1730 continue_status
= DBG_CONTINUE
;
1732 event_code
= current_event
.dwDebugEventCode
;
1733 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1735 have_saved_context
= 0;
1739 case CREATE_THREAD_DEBUG_EVENT
:
1740 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1741 (unsigned) current_event
.dwProcessId
,
1742 (unsigned) current_event
.dwThreadId
,
1743 "CREATE_THREAD_DEBUG_EVENT"));
1744 if (saw_create
!= 1)
1746 inferior
*inf
= find_inferior_pid (this, current_event
.dwProcessId
);
1747 if (!saw_create
&& inf
->attach_flag
)
1749 /* Kludge around a Windows bug where first event is a create
1750 thread event. Caused when attached process does not have
1752 thread_id
= fake_create_process ();
1758 /* Record the existence of this thread. */
1759 thread_id
= current_event
.dwThreadId
;
1760 th
= windows_add_thread
1761 (ptid_t (current_event
.dwProcessId
, 0, current_event
.dwThreadId
),
1762 current_event
.u
.CreateThread
.hThread
,
1763 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1764 false /* main_thread_p */);
1768 case EXIT_THREAD_DEBUG_EVENT
:
1769 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1770 (unsigned) current_event
.dwProcessId
,
1771 (unsigned) current_event
.dwThreadId
,
1772 "EXIT_THREAD_DEBUG_EVENT"));
1773 windows_delete_thread (ptid_t (current_event
.dwProcessId
, 0,
1774 current_event
.dwThreadId
),
1775 current_event
.u
.ExitThread
.dwExitCode
,
1776 false /* main_thread_p */);
1777 th
= &dummy_thread_info
;
1780 case CREATE_PROCESS_DEBUG_EVENT
:
1781 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1782 (unsigned) current_event
.dwProcessId
,
1783 (unsigned) current_event
.dwThreadId
,
1784 "CREATE_PROCESS_DEBUG_EVENT"));
1785 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1786 if (++saw_create
!= 1)
1789 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1790 /* Add the main thread. */
1791 th
= windows_add_thread
1792 (ptid_t (current_event
.dwProcessId
, 0,
1793 current_event
.dwThreadId
),
1794 current_event
.u
.CreateProcessInfo
.hThread
,
1795 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
,
1796 true /* main_thread_p */);
1797 thread_id
= current_event
.dwThreadId
;
1800 case EXIT_PROCESS_DEBUG_EVENT
:
1801 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1802 (unsigned) current_event
.dwProcessId
,
1803 (unsigned) current_event
.dwThreadId
,
1804 "EXIT_PROCESS_DEBUG_EVENT"));
1805 if (!windows_initialization_done
)
1807 target_terminal::ours ();
1808 target_mourn_inferior (inferior_ptid
);
1809 error (_("During startup program exited with code 0x%x."),
1810 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1812 else if (saw_create
== 1)
1814 windows_delete_thread (ptid_t (current_event
.dwProcessId
, 0,
1815 current_event
.dwThreadId
),
1816 0, true /* main_thread_p */);
1817 DWORD exit_status
= current_event
.u
.ExitProcess
.dwExitCode
;
1818 /* If the exit status looks like a fatal exception, but we
1819 don't recognize the exception's code, make the original
1820 exit status value available, to avoid losing
1823 = WIFSIGNALED (exit_status
) ? WTERMSIG (exit_status
) : -1;
1824 if (exit_signal
== -1)
1826 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1827 ourstatus
->value
.integer
= exit_status
;
1831 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1832 ourstatus
->value
.sig
= gdb_signal_from_host (exit_signal
);
1834 thread_id
= current_event
.dwThreadId
;
1838 case LOAD_DLL_DEBUG_EVENT
:
1839 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1840 (unsigned) current_event
.dwProcessId
,
1841 (unsigned) current_event
.dwThreadId
,
1842 "LOAD_DLL_DEBUG_EVENT"));
1843 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1844 if (saw_create
!= 1 || ! windows_initialization_done
)
1846 catch_errors (handle_load_dll
);
1847 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1848 ourstatus
->value
.integer
= 0;
1849 thread_id
= current_event
.dwThreadId
;
1852 case UNLOAD_DLL_DEBUG_EVENT
:
1853 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1854 (unsigned) current_event
.dwProcessId
,
1855 (unsigned) current_event
.dwThreadId
,
1856 "UNLOAD_DLL_DEBUG_EVENT"));
1857 if (saw_create
!= 1 || ! windows_initialization_done
)
1859 catch_errors (handle_unload_dll
);
1860 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1861 ourstatus
->value
.integer
= 0;
1862 thread_id
= current_event
.dwThreadId
;
1865 case EXCEPTION_DEBUG_EVENT
:
1866 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1867 (unsigned) current_event
.dwProcessId
,
1868 (unsigned) current_event
.dwThreadId
,
1869 "EXCEPTION_DEBUG_EVENT"));
1870 if (saw_create
!= 1)
1872 switch (handle_exception (ourstatus
))
1874 case HANDLE_EXCEPTION_UNHANDLED
:
1876 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1878 case HANDLE_EXCEPTION_HANDLED
:
1879 thread_id
= current_event
.dwThreadId
;
1881 case HANDLE_EXCEPTION_IGNORED
:
1882 continue_status
= DBG_CONTINUE
;
1887 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1888 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1889 (unsigned) current_event
.dwProcessId
,
1890 (unsigned) current_event
.dwThreadId
,
1891 "OUTPUT_DEBUG_STRING_EVENT"));
1892 if (saw_create
!= 1)
1894 thread_id
= handle_output_debug_string (ourstatus
);
1898 if (saw_create
!= 1)
1900 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1901 (unsigned) current_event
.dwProcessId
,
1902 (unsigned) current_event
.dwThreadId
);
1903 printf_unfiltered (" unknown event code %u\n",
1904 (unsigned) current_event
.dwDebugEventCode
);
1908 if (!thread_id
|| saw_create
!= 1)
1910 CHECK (windows_continue (continue_status
, -1, 0));
1914 inferior_ptid
= ptid_t (current_event
.dwProcessId
, 0, thread_id
);
1915 current_thread
= th
;
1916 if (!current_thread
)
1917 current_thread
= thread_rec (thread_id
, TRUE
);
1924 /* Wait for interesting events to occur in the target process. */
1926 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1931 /* We loop when we get a non-standard exception rather than return
1932 with a SPURIOUS because resume can try and step or modify things,
1933 which needs a current_thread->h. But some of these exceptions mark
1934 the birth or death of threads, which mean that the current thread
1935 isn't necessarily what you think it is. */
1941 /* If the user presses Ctrl-c while the debugger is waiting
1942 for an event, he expects the debugger to interrupt his program
1943 and to get the prompt back. There are two possible situations:
1945 - The debugger and the program do not share the console, in
1946 which case the Ctrl-c event only reached the debugger.
1947 In that case, the ctrl_c handler will take care of interrupting
1948 the inferior. Note that this case is working starting with
1949 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1952 - The debugger and the program share the same console, in which
1953 case both debugger and inferior will receive the Ctrl-c event.
1954 In that case the ctrl_c handler will ignore the event, as the
1955 Ctrl-c event generated inside the inferior will trigger the
1956 expected debug event.
1958 FIXME: brobecker/2008-05-20: If the inferior receives the
1959 signal first and the delay until GDB receives that signal
1960 is sufficiently long, GDB can sometimes receive the SIGINT
1961 after we have unblocked the CTRL+C handler. This would
1962 lead to the debugger stopping prematurely while handling
1963 the new-thread event that comes with the handling of the SIGINT
1964 inside the inferior, and then stop again immediately when
1965 the user tries to resume the execution in the inferior.
1966 This is a classic race that we should try to fix one day. */
1967 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1968 retval
= get_windows_debug_event (pid
, ourstatus
);
1969 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1972 return ptid_t (current_event
.dwProcessId
, 0, retval
);
1977 if (deprecated_ui_loop_hook
!= NULL
)
1978 detach
= deprecated_ui_loop_hook (0);
1986 /* Iterate over all DLLs currently mapped by our inferior, and
1987 add them to our list of solibs. */
1990 windows_add_all_dlls (void)
1992 HMODULE dummy_hmodule
;
2000 if (EnumProcessModulesEx (current_process_handle
, &dummy_hmodule
,
2001 sizeof (HMODULE
), &cb_needed
,
2002 LIST_MODULES_32BIT
) == 0)
2008 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
2009 sizeof (HMODULE
), &cb_needed
) == 0)
2016 hmodules
= (HMODULE
*) alloca (cb_needed
);
2020 if (EnumProcessModulesEx (current_process_handle
, hmodules
,
2021 cb_needed
, &cb_needed
,
2022 LIST_MODULES_32BIT
) == 0)
2028 if (EnumProcessModules (current_process_handle
, hmodules
,
2029 cb_needed
, &cb_needed
) == 0)
2033 char system_dir
[__PMAX
];
2034 char syswow_dir
[__PMAX
];
2035 size_t system_dir_len
= 0;
2036 bool convert_syswow_dir
= false;
2041 /* This fails on 32bit Windows because it has no SysWOW64 directory,
2042 and in this case a path conversion isn't necessary. */
2043 UINT len
= GetSystemWow64DirectoryA (syswow_dir
, sizeof (syswow_dir
));
2046 /* Check that we have passed a large enough buffer. */
2047 gdb_assert (len
< sizeof (syswow_dir
));
2049 len
= GetSystemDirectoryA (system_dir
, sizeof (system_dir
));
2051 gdb_assert (len
!= 0);
2052 /* Check that we have passed a large enough buffer. */
2053 gdb_assert (len
< sizeof (system_dir
));
2055 strcat (system_dir
, "\\");
2056 strcat (syswow_dir
, "\\");
2057 system_dir_len
= strlen (system_dir
);
2059 convert_syswow_dir
= true;
2063 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
2067 wchar_t dll_name
[__PMAX
];
2068 char dll_name_mb
[__PMAX
];
2070 char dll_name
[__PMAX
];
2073 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
2074 &mi
, sizeof (mi
)) == 0)
2076 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
2077 dll_name
, sizeof (dll_name
)) == 0)
2080 wcstombs (dll_name_mb
, dll_name
, __PMAX
);
2085 /* Convert the DLL path of 32bit processes returned by
2086 GetModuleFileNameEx from the 64bit system directory to the
2087 32bit syswow64 directory if necessary. */
2088 std::string syswow_dll_path
;
2089 if (convert_syswow_dir
2090 && strncasecmp (name
, system_dir
, system_dir_len
) == 0
2091 && strchr (name
+ system_dir_len
, '\\') == nullptr)
2093 syswow_dll_path
= syswow_dir
;
2094 syswow_dll_path
+= name
+ system_dir_len
;
2095 name
= syswow_dll_path
.c_str();
2098 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
2099 solib_end
= solib_end
->next
;
2104 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
2107 struct inferior
*inf
;
2109 last_sig
= GDB_SIGNAL_0
;
2111 exception_count
= 0;
2112 open_process_used
= 0;
2113 debug_registers_changed
= 0;
2114 debug_registers_used
= 0;
2115 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
2118 cygwin_load_start
= cygwin_load_end
= 0;
2120 current_event
.dwProcessId
= pid
;
2121 memset (¤t_event
, 0, sizeof (current_event
));
2122 if (!target_is_pushed (ops
))
2124 disable_breakpoints_in_shlibs ();
2125 windows_clear_solib ();
2126 clear_proceed_status (0);
2127 init_wait_for_inferior ();
2130 ignore_first_breakpoint
= !attaching
&& wow64_process
;
2134 windows_set_context_register_offsets (amd64_mappings
);
2135 windows_set_segment_register_p (amd64_windows_segment_register_p
);
2140 windows_set_context_register_offsets (i386_mappings
);
2141 windows_set_segment_register_p (i386_windows_segment_register_p
);
2144 inf
= current_inferior ();
2145 inferior_appeared (inf
, pid
);
2146 inf
->attach_flag
= attaching
;
2148 /* Make the new process the current inferior, so terminal handling
2149 can rely on it. When attaching, we don't know about any thread
2150 id here, but that's OK --- nothing should be referencing the
2151 current thread until we report an event out of windows_wait. */
2152 inferior_ptid
= ptid_t (pid
);
2154 target_terminal::init ();
2155 target_terminal::inferior ();
2157 windows_initialization_done
= 0;
2161 struct target_waitstatus status
;
2163 ops
->wait (minus_one_ptid
, &status
, 0);
2165 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
2167 if (status
.kind
!= TARGET_WAITKIND_LOADED
2168 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
2171 ops
->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
2174 /* Now that the inferior has been started and all DLLs have been mapped,
2175 we can iterate over all DLLs and load them in.
2177 We avoid doing it any earlier because, on certain versions of Windows,
2178 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
2179 we have seen on Windows 8.1 that the ntdll.dll load event does not
2180 include the DLL name, preventing us from creating an associated SO.
2181 A possible explanation is that ntdll.dll might be mapped before
2182 the SO info gets created by the Windows system -- ntdll.dll is
2183 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
2184 do not seem to suffer from that problem.
2186 Rather than try to work around this sort of issue, it is much
2187 simpler to just ignore DLL load/unload events during the startup
2188 phase, and then process them all in one batch now. */
2189 windows_add_all_dlls ();
2191 windows_initialization_done
= 1;
2195 /* Try to set or remove a user privilege to the current process. Return -1
2196 if that fails, the previous setting of that privilege otherwise.
2198 This code is copied from the Cygwin source code and rearranged to allow
2199 dynamically loading of the needed symbols from advapi32 which is only
2200 available on NT/2K/XP. */
2202 set_process_privilege (const char *privilege
, BOOL enable
)
2204 HANDLE token_hdl
= NULL
;
2206 TOKEN_PRIVILEGES new_priv
, orig_priv
;
2210 if (!OpenProcessToken (GetCurrentProcess (),
2211 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
2215 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
2218 new_priv
.PrivilegeCount
= 1;
2219 new_priv
.Privileges
[0].Luid
= restore_priv
;
2220 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
2222 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
2223 sizeof orig_priv
, &orig_priv
, &size
))
2226 /* Disabled, otherwise every `attach' in an unprivileged user session
2227 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
2228 windows_attach(). */
2229 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
2230 be enabled. GetLastError () returns an correct error code, though. */
2231 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
2235 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
2239 CloseHandle (token_hdl
);
2244 /* Attach to process PID, then initialize for debugging it. */
2247 windows_nat_target::attach (const char *args
, int from_tty
)
2252 pid
= parse_pid_to_attach (args
);
2254 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
2256 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
2257 printf_unfiltered ("This can cause attach to "
2258 "fail on Windows NT/2K/XP\n");
2261 windows_init_thread_list ();
2262 ok
= DebugActiveProcess (pid
);
2268 /* Try fall back to Cygwin pid. */
2269 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
2272 ok
= DebugActiveProcess (pid
);
2277 error (_("Can't attach to process %u (error %u)"),
2278 (unsigned) pid
, (unsigned) GetLastError ());
2280 DebugSetProcessKillOnExit (FALSE
);
2284 const char *exec_file
= get_exec_file (0);
2287 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
2288 target_pid_to_str (ptid_t (pid
)).c_str ());
2290 printf_unfiltered ("Attaching to %s\n",
2291 target_pid_to_str (ptid_t (pid
)).c_str ());
2295 HANDLE h
= OpenProcess (PROCESS_QUERY_INFORMATION
, FALSE
, pid
);
2299 if (IsWow64Process (h
, &wow64
))
2300 wow64_process
= wow64
;
2305 do_initial_windows_stuff (this, pid
, 1);
2306 target_terminal::ours ();
2310 windows_nat_target::detach (inferior
*inf
, int from_tty
)
2314 ptid_t ptid
= minus_one_ptid
;
2315 resume (ptid
, 0, GDB_SIGNAL_0
);
2317 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
2319 error (_("Can't detach process %u (error %u)"),
2320 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
2323 DebugSetProcessKillOnExit (FALSE
);
2325 if (detached
&& from_tty
)
2327 const char *exec_file
= get_exec_file (0);
2330 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
2331 (unsigned) current_event
.dwProcessId
);
2334 x86_cleanup_dregs ();
2335 inferior_ptid
= null_ptid
;
2336 detach_inferior (inf
);
2338 maybe_unpush_target ();
2341 /* Try to determine the executable filename.
2343 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2345 Upon success, the filename is stored inside EXE_NAME_RET, and
2346 this function returns nonzero.
2348 Otherwise, this function returns zero and the contents of
2349 EXE_NAME_RET is undefined. */
2352 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2362 if (!EnumProcessModulesEx (current_process_handle
, &dh_buf
,
2363 sizeof (HMODULE
), &cbNeeded
,
2364 LIST_MODULES_32BIT
) || !cbNeeded
)
2370 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2371 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2375 /* We know the executable is always first in the list of modules,
2376 which we just fetched. So no need to fetch more. */
2380 /* Cygwin prefers that the path be in /x/y/z format, so extract
2381 the filename into a temporary buffer first, and then convert it
2382 to POSIX format into the destination buffer. */
2383 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2385 len
= GetModuleFileNameEx (current_process_handle
,
2386 dh_buf
, pathbuf
, exe_name_max_len
);
2388 error (_("Error getting executable filename: %u."),
2389 (unsigned) GetLastError ());
2390 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2391 exe_name_max_len
) < 0)
2392 error (_("Error converting executable filename to POSIX: %d."), errno
);
2395 len
= GetModuleFileNameEx (current_process_handle
,
2396 dh_buf
, exe_name_ret
, exe_name_max_len
);
2398 error (_("Error getting executable filename: %u."),
2399 (unsigned) GetLastError ());
2402 return 1; /* success */
2405 /* The pid_to_exec_file target_ops method for this platform. */
2408 windows_nat_target::pid_to_exec_file (int pid
)
2410 static char path
[__PMAX
];
2412 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2414 char procexe
[sizeof ("/proc/4294967295/exe")];
2416 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2417 nchars
= readlink (procexe
, path
, sizeof(path
));
2418 if (nchars
> 0 && nchars
< sizeof (path
))
2420 path
[nchars
] = '\0'; /* Got it */
2425 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2426 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2427 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2433 /* Print status information about what we're accessing. */
2436 windows_nat_target::files_info ()
2438 struct inferior
*inf
= current_inferior ();
2440 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2441 inf
->attach_flag
? "attached" : "child",
2442 target_pid_to_str (inferior_ptid
).c_str ());
2445 /* Modify CreateProcess parameters for use of a new separate console.
2447 *FLAGS: DWORD parameter for general process creation flags.
2448 *SI: STARTUPINFO structure, for which the console window size and
2449 console buffer size is filled in if GDB is running in a console.
2450 to create the new console.
2451 The size of the used font is not available on all versions of
2452 Windows OS. Furthermore, the current font might not be the default
2453 font, but this is still better than before.
2454 If the windows and buffer sizes are computed,
2455 SI->DWFLAGS is changed so that this information is used
2456 by CreateProcess function. */
2459 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2461 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2462 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2464 if (hconsole
!= INVALID_HANDLE_VALUE
)
2466 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2468 CONSOLE_FONT_INFO cfi
;
2470 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2471 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2472 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2473 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2474 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2476 si
->dwXSize
*= font_size
.X
;
2480 si
->dwYSize
*= font_size
.Y
;
2483 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2484 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2485 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2487 *flags
|= CREATE_NEW_CONSOLE
;
2491 /* Function called by qsort to sort environment strings. */
2494 envvar_cmp (const void *a
, const void *b
)
2496 const char **p
= (const char **) a
;
2497 const char **q
= (const char **) b
;
2498 return strcasecmp (*p
, *q
);
2504 clear_win32_environment (char **env
)
2508 wchar_t *copy
= NULL
, *equalpos
;
2510 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2512 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2513 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2514 mbstowcs (copy
, env
[i
], len
);
2515 equalpos
= wcschr (copy
, L
'=');
2518 SetEnvironmentVariableW (copy
, NULL
);
2526 /* Redirection of inferior I/O streams for native MS-Windows programs.
2527 Unlike on Unix, where this is handled by invoking the inferior via
2528 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2530 The official documentation of the cmd.exe redirection features is here:
2532 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2534 (That page talks about Windows XP, but there's no newer
2535 documentation, so we assume later versions of cmd.exe didn't change
2538 Caveat: the documentation on that page seems to include a few lies.
2539 For example, it describes strange constructs 1<&2 and 2<&1, which
2540 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2541 think the cmd.exe parser of the redirection symbols simply doesn't
2542 care about the < vs > distinction in these cases. Therefore, the
2543 supported features are explicitly documented below.
2545 The emulation below aims at supporting all the valid use cases
2546 supported by cmd.exe, which include:
2548 < FILE redirect standard input from FILE
2549 0< FILE redirect standard input from FILE
2550 <&N redirect standard input from file descriptor N
2551 0<&N redirect standard input from file descriptor N
2552 > FILE redirect standard output to FILE
2553 >> FILE append standard output to FILE
2554 1>> FILE append standard output to FILE
2555 >&N redirect standard output to file descriptor N
2556 1>&N redirect standard output to file descriptor N
2557 >>&N append standard output to file descriptor N
2558 1>>&N append standard output to file descriptor N
2559 2> FILE redirect standard error to FILE
2560 2>> FILE append standard error to FILE
2561 2>&N redirect standard error to file descriptor N
2562 2>>&N append standard error to file descriptor N
2564 Note that using N > 2 in the above construct is supported, but
2565 requires that the corresponding file descriptor be open by some
2566 means elsewhere or outside GDB. Also note that using ">&0" or
2567 "<&2" will generally fail, because the file descriptor redirected
2568 from is normally open in an incompatible mode (e.g., FD 0 is open
2569 for reading only). IOW, use of such tricks is not recommended;
2570 you are on your own.
2572 We do NOT support redirection of file descriptors above 2, as in
2573 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2574 that needs special handling in the startup code that MinGW
2575 doesn't have). Pipes are also not supported.
2577 As for invalid use cases, where the redirection contains some
2578 error, the emulation below will detect that and produce some
2579 error and/or failure. But the behavior in those cases is not
2580 bug-for-bug compatible with what cmd.exe does in those cases.
2581 That's because what cmd.exe does then is not well defined, and
2582 seems to be a side effect of the cmd.exe parsing of the command
2583 line more than anything else. For example, try redirecting to an
2584 invalid file name, as in "> foo:bar".
2586 There are also minor syntactic deviations from what cmd.exe does
2587 in some corner cases. For example, it doesn't support the likes
2588 of "> &foo" to mean redirect to file named literally "&foo"; we
2589 do support that here, because that, too, sounds like some issue
2590 with the cmd.exe parser. Another nicety is that we support
2591 redirection targets that use file names with forward slashes,
2592 something cmd.exe doesn't -- this comes in handy since GDB
2593 file-name completion can be used when typing the command line for
2596 /* Support routines for redirecting standard handles of the inferior. */
2598 /* Parse a single redirection spec, open/duplicate the specified
2599 file/fd, and assign the appropriate value to one of the 3 standard
2600 file descriptors. */
2602 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2604 int *fd
, ref_fd
= -2;
2606 const char *fname
= redir_string
+ 1;
2607 int rc
= *redir_string
;
2622 fd
= (rc
== '2') ? err
: out
;
2623 mode
= O_WRONLY
| O_CREAT
;
2636 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2638 /* A reference to a file descriptor. */
2640 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2641 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2643 /* Don't allow redirection when open modes are incompatible. */
2644 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2645 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2652 else if (ref_fd
== 1)
2654 else if (ref_fd
== 2)
2664 fname
++; /* skip the separator space */
2665 /* If the descriptor is already open, close it. This allows
2666 multiple specs of redirections for the same stream, which is
2667 somewhat nonsensical, but still valid and supported by cmd.exe.
2668 (But cmd.exe only opens a single file in this case, the one
2669 specified by the last redirection spec on the command line.) */
2674 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2678 else if (ref_fd
== -1)
2679 *fd
= -1; /* reset to default destination */
2682 *fd
= _dup (ref_fd
);
2686 /* _open just sets a flag for O_APPEND, which won't be passed to the
2687 inferior, so we need to actually move the file pointer. */
2688 if ((mode
& O_APPEND
) != 0)
2689 _lseek (*fd
, 0L, SEEK_END
);
2693 /* Canonicalize a single redirection spec and set up the corresponding
2694 file descriptor as specified. */
2696 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2698 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2700 const char *start
= s
;
2703 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2704 if ((*start
== '>' || *start
== '1' || *start
== '2')
2708 if (*s
== '>' && *start
!= '>')
2711 else if (*start
== '0' && *s
== '<')
2713 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2716 while (isspace (*s
)) /* skip whitespace before file name */
2718 *d
++ = ' '; /* separate file name with a single space */
2721 /* Copy the file name. */
2724 /* Remove quoting characters from the file name in buf[]. */
2725 if (*s
== '"') /* could support '..' quoting here */
2729 else if (*s
== quote
)
2737 else if (*s
== '\\')
2739 if (s
[1] == '"') /* could support '..' here */
2743 else if (isspace (*s
) && !quote
)
2747 if (d
- buf
>= sizeof (buf
) - 1)
2749 errno
= ENAMETOOLONG
;
2755 /* Windows doesn't allow redirection characters in file names, so we
2756 can bail out early if they use them, or if there's no target file
2757 name after the redirection symbol. */
2758 if (d
[-1] == '>' || d
[-1] == '<')
2763 if (redir_open (buf
, inp
, out
, err
) == 0)
2768 /* Parse the command line for redirection specs and prepare the file
2769 descriptors for the 3 standard streams accordingly. */
2771 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2772 int *inp
, int *out
, int *err
)
2774 const char *s
= cmd_orig
;
2777 bool retval
= false;
2779 while (isspace (*s
))
2784 if (*s
== '"') /* could also support '..' quoting here */
2788 else if (*s
== quote
)
2791 else if (*s
== '\\')
2793 if (s
[1] == '"') /* escaped quote char */
2798 /* Process a single redirection candidate. */
2799 if (*s
== '<' || *s
== '>'
2800 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2801 || (*s
== '0' && s
[1] == '<'))
2803 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2817 #endif /* !__CYGWIN__ */
2819 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2820 EXEC_FILE is the file to run.
2821 ALLARGS is a string containing the arguments to the program.
2822 ENV is the environment vector to pass. Errors reported with error(). */
2825 windows_nat_target::create_inferior (const char *exec_file
,
2826 const std::string
&origallargs
,
2827 char **in_env
, int from_tty
)
2831 cygwin_buf_t real_path
[__PMAX
];
2832 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2833 cygwin_buf_t infcwd
[__PMAX
];
2835 cygwin_buf_t
*toexec
;
2836 cygwin_buf_t
*cygallargs
;
2838 char **old_env
= NULL
;
2842 int ostdin
, ostdout
, ostderr
;
2843 #else /* !__CYGWIN__ */
2844 char shell
[__PMAX
]; /* Path to shell */
2846 char *args
, *allargs_copy
;
2847 size_t args_len
, allargs_len
;
2848 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2849 HANDLE tty
= INVALID_HANDLE_VALUE
;
2850 bool redirected
= false;
2857 #endif /* !__CYGWIN__ */
2858 const char *allargs
= origallargs
.c_str ();
2859 PROCESS_INFORMATION pi
;
2862 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2865 error (_("No executable specified, use `target exec'."));
2867 const char *inferior_cwd
= get_inferior_cwd ();
2868 std::string expanded_infcwd
;
2869 if (inferior_cwd
!= NULL
)
2871 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
2872 /* Mirror slashes on inferior's cwd. */
2873 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
2875 inferior_cwd
= expanded_infcwd
.c_str ();
2878 memset (&si
, 0, sizeof (si
));
2879 si
.cb
= sizeof (si
);
2882 flags
|= CREATE_NEW_PROCESS_GROUP
;
2885 windows_set_console_info (&si
, &flags
);
2890 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2891 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2892 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2893 error (_("Error starting executable: %d"), errno
);
2896 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2897 if (len
== (size_t) -1)
2898 error (_("Error starting executable: %d"), errno
);
2899 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2900 mbstowcs (cygallargs
, allargs
, len
);
2901 #else /* !__USEWIDE */
2902 cygallargs
= allargs
;
2908 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2909 error (_("Error starting executable via shell: %d"), errno
);
2911 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2912 + mbstowcs (NULL
, allargs
, 0) + 2;
2913 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2914 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2915 #else /* !__USEWIDE */
2916 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2917 + strlen (allargs
) + 2);
2918 cygallargs
= (char *) alloca (len
);
2919 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2920 #endif /* __USEWIDE */
2922 flags
|= DEBUG_PROCESS
;
2925 if (inferior_cwd
!= NULL
2926 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
2927 infcwd
, strlen (inferior_cwd
)) < 0)
2928 error (_("Error converting inferior cwd: %d"), errno
);
2931 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2932 * sizeof (wchar_t));
2933 wcscpy (args
, toexec
);
2934 wcscat (args
, L
" ");
2935 wcscat (args
, cygallargs
);
2936 #else /* !__USEWIDE */
2937 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2938 strcpy (args
, toexec
);
2940 strcat (args
, cygallargs
);
2941 #endif /* !__USEWIDE */
2943 #ifdef CW_CVT_ENV_TO_WINENV
2944 /* First try to create a direct Win32 copy of the POSIX environment. */
2945 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2946 if (w32_env
!= (PWCHAR
) -1)
2947 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2949 /* If that fails, fall back to old method tweaking GDB's environment. */
2950 #endif /* CW_CVT_ENV_TO_WINENV */
2952 /* Reset all Win32 environment variables to avoid leftover on next run. */
2953 clear_win32_environment (environ
);
2954 /* Prepare the environment vars for CreateProcess. */
2957 cygwin_internal (CW_SYNC_WINENV
);
2961 if (!inferior_io_terminal
)
2962 tty
= ostdin
= ostdout
= ostderr
= -1;
2965 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2968 print_sys_errmsg (inferior_io_terminal
, errno
);
2969 ostdin
= ostdout
= ostderr
= -1;
2982 windows_init_thread_list ();
2983 ret
= CreateProcess (0,
2984 args
, /* command line */
2985 NULL
, /* Security */
2987 TRUE
, /* inherit handles */
2988 flags
, /* start flags */
2989 w32_env
, /* environment */
2990 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
2995 /* Just free the Win32 environment, if it could be created. */
2999 /* Reset all environment variables to avoid leftover on next run. */
3000 clear_win32_environment (in_env
);
3001 /* Restore normal GDB environment variables. */
3003 cygwin_internal (CW_SYNC_WINENV
);
3016 #else /* !__CYGWIN__ */
3017 allargs_len
= strlen (allargs
);
3018 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
3019 if (strpbrk (allargs_copy
, "<>") != NULL
)
3024 redirect_inferior_handles (allargs
, allargs_copy
,
3025 &fd_inp
, &fd_out
, &fd_err
);
3027 warning (_("Error in redirection: %s."), safe_strerror (errno
));
3030 allargs_len
= strlen (allargs_copy
);
3032 /* If not all the standard streams are redirected by the command
3033 line, use inferior_io_terminal for those which aren't. */
3034 if (inferior_io_terminal
3035 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
3037 SECURITY_ATTRIBUTES sa
;
3038 sa
.nLength
= sizeof(sa
);
3039 sa
.lpSecurityDescriptor
= 0;
3040 sa
.bInheritHandle
= TRUE
;
3041 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
3042 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
3043 if (tty
== INVALID_HANDLE_VALUE
)
3044 warning (_("Warning: Failed to open TTY %s, error %#x."),
3045 inferior_io_terminal
, (unsigned) GetLastError ());
3047 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
3050 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
3051 else if (tty
!= INVALID_HANDLE_VALUE
)
3054 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
3056 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
3057 else if (tty
!= INVALID_HANDLE_VALUE
)
3058 si
.hStdOutput
= tty
;
3060 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
3062 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
3063 else if (tty
!= INVALID_HANDLE_VALUE
)
3066 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
3067 si
.dwFlags
|= STARTF_USESTDHANDLES
;
3071 /* Build the command line, a space-separated list of tokens where
3072 the first token is the name of the module to be executed.
3073 To avoid ambiguities introduced by spaces in the module name,
3075 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
3076 args
= (char *) alloca (args_len
);
3077 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
3079 flags
|= DEBUG_ONLY_THIS_PROCESS
;
3081 /* CreateProcess takes the environment list as a null terminated set of
3082 strings (i.e. two nulls terminate the list). */
3084 /* Get total size for env strings. */
3085 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
3086 envlen
+= strlen (in_env
[i
]) + 1;
3088 envsize
= sizeof (in_env
[0]) * (i
+ 1);
3089 env
= (char **) alloca (envsize
);
3090 memcpy (env
, in_env
, envsize
);
3091 /* Windows programs expect the environment block to be sorted. */
3092 qsort (env
, i
, sizeof (char *), envvar_cmp
);
3094 w32env
= (char *) alloca (envlen
+ 1);
3096 /* Copy env strings into new buffer. */
3097 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
3099 strcpy (temp
, env
[i
]);
3100 temp
+= strlen (temp
) + 1;
3103 /* Final nil string to terminate new env. */
3106 windows_init_thread_list ();
3107 ret
= CreateProcessA (0,
3108 args
, /* command line */
3109 NULL
, /* Security */
3111 TRUE
, /* inherit handles */
3112 flags
, /* start flags */
3113 w32env
, /* environment */
3114 inferior_cwd
, /* current directory */
3117 if (tty
!= INVALID_HANDLE_VALUE
)
3125 #endif /* !__CYGWIN__ */
3128 error (_("Error creating process %s, (error %u)."),
3129 exec_file
, (unsigned) GetLastError ());
3133 if (IsWow64Process (pi
.hProcess
, &wow64
))
3134 wow64_process
= wow64
;
3137 CloseHandle (pi
.hThread
);
3138 CloseHandle (pi
.hProcess
);
3140 if (useshell
&& shell
[0] != '\0')
3145 do_initial_windows_stuff (this, pi
.dwProcessId
, 0);
3147 /* windows_continue (DBG_CONTINUE, -1, 0); */
3151 windows_nat_target::mourn_inferior ()
3153 (void) windows_continue (DBG_CONTINUE
, -1, 0);
3154 x86_cleanup_dregs();
3155 if (open_process_used
)
3157 CHECK (CloseHandle (current_process_handle
));
3158 open_process_used
= 0;
3160 siginfo_er
.ExceptionCode
= 0;
3161 inf_child_target::mourn_inferior ();
3164 /* Send a SIGINT to the process group. This acts just like the user typed a
3165 ^C on the controlling terminal. */
3168 windows_nat_target::interrupt ()
3170 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
3171 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
3172 registers_changed (); /* refresh register state */
3175 /* Helper for windows_xfer_partial that handles memory transfers.
3176 Arguments are like target_xfer_partial. */
3178 static enum target_xfer_status
3179 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3180 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
3184 DWORD lasterror
= 0;
3186 if (writebuf
!= NULL
)
3188 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
3189 pulongest (len
), core_addr_to_string (memaddr
)));
3190 success
= WriteProcessMemory (current_process_handle
,
3191 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
3194 lasterror
= GetLastError ();
3195 FlushInstructionCache (current_process_handle
,
3196 (LPCVOID
) (uintptr_t) memaddr
, len
);
3200 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
3201 pulongest (len
), core_addr_to_string (memaddr
)));
3202 success
= ReadProcessMemory (current_process_handle
,
3203 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
3206 lasterror
= GetLastError ();
3208 *xfered_len
= (ULONGEST
) done
;
3209 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
3210 return TARGET_XFER_OK
;
3212 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
3216 windows_nat_target::kill ()
3218 CHECK (TerminateProcess (current_process_handle
, 0));
3222 if (!windows_continue (DBG_CONTINUE
, -1, 1))
3224 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
3226 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
3230 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
3234 windows_nat_target::close ()
3236 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
3237 inferior_ptid
.pid ()));
3240 /* Convert pid to printable format. */
3242 windows_nat_target::pid_to_str (ptid_t ptid
)
3244 if (ptid
.tid () != 0)
3245 return string_printf ("Thread %d.0x%lx", ptid
.pid (), ptid
.tid ());
3247 return normal_pid_to_str (ptid
);
3250 static enum target_xfer_status
3251 windows_xfer_shared_libraries (struct target_ops
*ops
,
3252 enum target_object object
, const char *annex
,
3253 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3254 ULONGEST offset
, ULONGEST len
,
3255 ULONGEST
*xfered_len
)
3257 struct obstack obstack
;
3263 return TARGET_XFER_E_IO
;
3265 obstack_init (&obstack
);
3266 obstack_grow_str (&obstack
, "<library-list>\n");
3267 for (so
= solib_start
.next
; so
; so
= so
->next
)
3269 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
3271 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
3272 (uintptr_t) li
->load_addr
,
3274 target_gdbarch (), &obstack
);
3276 obstack_grow_str0 (&obstack
, "</library-list>\n");
3278 buf
= (const char *) obstack_finish (&obstack
);
3279 len_avail
= strlen (buf
);
3280 if (offset
>= len_avail
)
3284 if (len
> len_avail
- offset
)
3285 len
= len_avail
- offset
;
3286 memcpy (readbuf
, buf
+ offset
, len
);
3289 obstack_free (&obstack
, NULL
);
3290 *xfered_len
= (ULONGEST
) len
;
3291 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
3294 /* Helper for windows_nat_target::xfer_partial that handles signal info. */
3296 static enum target_xfer_status
3297 windows_xfer_siginfo (gdb_byte
*readbuf
, ULONGEST offset
, ULONGEST len
,
3298 ULONGEST
*xfered_len
)
3300 char *buf
= (char *) &siginfo_er
;
3301 size_t bufsize
= sizeof (siginfo_er
);
3304 EXCEPTION_RECORD32 er32
;
3307 buf
= (char *) &er32
;
3308 bufsize
= sizeof (er32
);
3310 er32
.ExceptionCode
= siginfo_er
.ExceptionCode
;
3311 er32
.ExceptionFlags
= siginfo_er
.ExceptionFlags
;
3312 er32
.ExceptionRecord
= (uintptr_t) siginfo_er
.ExceptionRecord
;
3313 er32
.ExceptionAddress
= (uintptr_t) siginfo_er
.ExceptionAddress
;
3314 er32
.NumberParameters
= siginfo_er
.NumberParameters
;
3316 for (i
= 0; i
< EXCEPTION_MAXIMUM_PARAMETERS
; i
++)
3317 er32
.ExceptionInformation
[i
] = siginfo_er
.ExceptionInformation
[i
];
3321 if (siginfo_er
.ExceptionCode
== 0)
3322 return TARGET_XFER_E_IO
;
3324 if (readbuf
== nullptr)
3325 return TARGET_XFER_E_IO
;
3327 if (offset
> bufsize
)
3328 return TARGET_XFER_E_IO
;
3330 if (offset
+ len
> bufsize
)
3331 len
= bufsize
- offset
;
3333 memcpy (readbuf
, buf
+ offset
, len
);
3336 return TARGET_XFER_OK
;
3339 enum target_xfer_status
3340 windows_nat_target::xfer_partial (enum target_object object
,
3341 const char *annex
, gdb_byte
*readbuf
,
3342 const gdb_byte
*writebuf
, ULONGEST offset
,
3343 ULONGEST len
, ULONGEST
*xfered_len
)
3347 case TARGET_OBJECT_MEMORY
:
3348 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
3350 case TARGET_OBJECT_LIBRARIES
:
3351 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
3352 writebuf
, offset
, len
, xfered_len
);
3354 case TARGET_OBJECT_SIGNAL_INFO
:
3355 return windows_xfer_siginfo (readbuf
, offset
, len
, xfered_len
);
3358 if (beneath () == NULL
)
3360 /* This can happen when requesting the transfer of unsupported
3361 objects before a program has been started (and therefore
3362 with the current_target having no target beneath). */
3363 return TARGET_XFER_E_IO
;
3365 return beneath ()->xfer_partial (object
, annex
,
3366 readbuf
, writebuf
, offset
, len
,
3371 /* Provide thread local base, i.e. Thread Information Block address.
3372 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
3375 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
3377 windows_thread_info
*th
;
3379 th
= thread_rec (ptid
.tid (), 0);
3384 *addr
= th
->thread_local_base
;
3390 windows_nat_target::get_ada_task_ptid (long lwp
, long thread
)
3392 return ptid_t (inferior_ptid
.pid (), 0, lwp
);
3395 /* Implementation of the to_thread_name method. */
3398 windows_nat_target::thread_name (struct thread_info
*thr
)
3400 return thread_rec (thr
->ptid
.tid (), 0)->name
;
3404 void _initialize_windows_nat ();
3406 _initialize_windows_nat ()
3408 x86_dr_low
.set_control
= cygwin_set_dr7
;
3409 x86_dr_low
.set_addr
= cygwin_set_dr
;
3410 x86_dr_low
.get_addr
= cygwin_get_dr
;
3411 x86_dr_low
.get_status
= cygwin_get_dr6
;
3412 x86_dr_low
.get_control
= cygwin_get_dr7
;
3414 /* x86_dr_low.debug_register_length field is set by
3415 calling x86_set_debug_register_length function
3416 in processor windows specific native file. */
3418 add_inf_child_target (&the_windows_nat_target
);
3421 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3424 add_com ("signal-event", class_run
, signal_event_command
, _("\
3425 Signal a crashed process with event ID, to allow its debugging.\n\
3426 This command is needed in support of setting up GDB as JIT debugger on \
3427 MS-Windows. The command should be invoked from the GDB command line using \
3428 the '-ex' command-line option. The ID of the event that blocks the \
3429 crashed process will be supplied by the Windows JIT debugging mechanism."));
3432 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3433 Set use of shell to start subprocess."), _("\
3434 Show use of shell to start subprocess."), NULL
,
3436 NULL
, /* FIXME: i18n: */
3437 &setlist
, &showlist
);
3439 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3440 &cygwin_exceptions
, _("\
3441 Break when an exception is detected in the Cygwin DLL itself."), _("\
3442 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3444 NULL
, /* FIXME: i18n: */
3445 &setlist
, &showlist
);
3448 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3449 Set creation of new console when creating child process."), _("\
3450 Show creation of new console when creating child process."), NULL
,
3452 NULL
, /* FIXME: i18n: */
3453 &setlist
, &showlist
);
3455 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3456 Set creation of new group when creating child process."), _("\
3457 Show creation of new group when creating child process."), NULL
,
3459 NULL
, /* FIXME: i18n: */
3460 &setlist
, &showlist
);
3462 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3463 Set whether to display execution in child process."), _("\
3464 Show whether to display execution in child process."), NULL
,
3466 NULL
, /* FIXME: i18n: */
3467 &setlist
, &showlist
);
3469 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3470 Set whether to display kernel events in child process."), _("\
3471 Show whether to display kernel events in child process."), NULL
,
3473 NULL
, /* FIXME: i18n: */
3474 &setlist
, &showlist
);
3476 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3477 Set whether to display memory accesses in child process."), _("\
3478 Show whether to display memory accesses in child process."), NULL
,
3480 NULL
, /* FIXME: i18n: */
3481 &setlist
, &showlist
);
3483 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3484 &debug_exceptions
, _("\
3485 Set whether to display kernel exceptions in child process."), _("\
3486 Show whether to display kernel exceptions in child process."), NULL
,
3488 NULL
, /* FIXME: i18n: */
3489 &setlist
, &showlist
);
3491 init_w32_command_list ();
3493 add_cmd ("selector", class_info
, display_selectors
,
3494 _("Display selectors infos."),
3498 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3500 /* Pass the address ADDR to the inferior in the I'th debug register.
3501 Here we just store the address in dr array, the registers will be
3502 actually set up when windows_continue is called. */
3504 cygwin_set_dr (int i
, CORE_ADDR addr
)
3507 internal_error (__FILE__
, __LINE__
,
3508 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3510 debug_registers_changed
= 1;
3511 debug_registers_used
= 1;
3514 /* Pass the value VAL to the inferior in the DR7 debug control
3515 register. Here we just store the address in D_REGS, the watchpoint
3516 will be actually set up in windows_wait. */
3518 cygwin_set_dr7 (unsigned long val
)
3520 dr
[7] = (CORE_ADDR
) val
;
3521 debug_registers_changed
= 1;
3522 debug_registers_used
= 1;
3525 /* Get the value of debug register I from the inferior. */
3528 cygwin_get_dr (int i
)
3533 /* Get the value of the DR6 debug status register from the inferior.
3534 Here we just return the value stored in dr[6]
3535 by the last call to thread_rec for current_event.dwThreadId id. */
3536 static unsigned long
3537 cygwin_get_dr6 (void)
3539 return (unsigned long) dr
[6];
3542 /* Get the value of the DR7 debug status register from the inferior.
3543 Here we just return the value stored in dr[7] by the last call to
3544 thread_rec for current_event.dwThreadId id. */
3546 static unsigned long
3547 cygwin_get_dr7 (void)
3549 return (unsigned long) dr
[7];
3552 /* Determine if the thread referenced by "ptid" is alive
3553 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3554 it means that the thread has died. Otherwise it is assumed to be alive. */
3557 windows_nat_target::thread_alive (ptid_t ptid
)
3561 gdb_assert (ptid
.tid () != 0);
3564 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) != WAIT_OBJECT_0
;
3567 void _initialize_check_for_gdb_ini ();
3569 _initialize_check_for_gdb_ini ()
3572 if (inhibit_gdbinit
)
3575 homedir
= getenv ("HOME");
3579 char *oldini
= (char *) alloca (strlen (homedir
) +
3580 sizeof ("gdb.ini") + 1);
3581 strcpy (oldini
, homedir
);
3582 p
= strchr (oldini
, '\0');
3583 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3585 strcpy (p
, "gdb.ini");
3586 if (access (oldini
, 0) == 0)
3588 int len
= strlen (oldini
);
3589 char *newini
= (char *) alloca (len
+ 2);
3591 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3592 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3593 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3598 /* Define dummy functions which always return error for the rare cases where
3599 these functions could not be found. */
3601 bad_DebugActiveProcessStop (DWORD w
)
3606 bad_DebugBreakProcess (HANDLE w
)
3611 bad_DebugSetProcessKillOnExit (BOOL w
)
3616 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3623 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3629 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3636 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3642 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3648 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3654 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3662 /* Load any functions which may not be available in ancient versions
3665 void _initialize_loadable ();
3667 _initialize_loadable ()
3671 #define GPA(m, func) \
3672 func = (func ## _ftype *) GetProcAddress (m, #func)
3674 hm
= LoadLibrary ("kernel32.dll");
3677 GPA (hm
, DebugActiveProcessStop
);
3678 GPA (hm
, DebugBreakProcess
);
3679 GPA (hm
, DebugSetProcessKillOnExit
);
3680 GPA (hm
, GetConsoleFontSize
);
3681 GPA (hm
, DebugActiveProcessStop
);
3682 GPA (hm
, GetCurrentConsoleFont
);
3684 GPA (hm
, Wow64SuspendThread
);
3685 GPA (hm
, Wow64GetThreadContext
);
3686 GPA (hm
, Wow64SetThreadContext
);
3687 GPA (hm
, Wow64GetThreadSelectorEntry
);
3691 /* Set variables to dummy versions of these processes if the function
3692 wasn't found in kernel32.dll. */
3693 if (!DebugBreakProcess
)
3694 DebugBreakProcess
= bad_DebugBreakProcess
;
3695 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3697 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3698 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3700 if (!GetConsoleFontSize
)
3701 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3702 if (!GetCurrentConsoleFont
)
3703 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3705 /* Load optional functions used for retrieving filename information
3706 associated with the currently debugged process or its dlls. */
3707 hm
= LoadLibrary ("psapi.dll");
3710 GPA (hm
, EnumProcessModules
);
3712 GPA (hm
, EnumProcessModulesEx
);
3714 GPA (hm
, GetModuleInformation
);
3715 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3716 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3719 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3721 /* Set variables to dummy versions of these processes if the function
3722 wasn't found in psapi.dll. */
3723 EnumProcessModules
= bad_EnumProcessModules
;
3724 GetModuleInformation
= bad_GetModuleInformation
;
3725 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3726 /* This will probably fail on Windows 9x/Me. Let the user know
3727 that we're missing some functionality. */
3729 cannot automatically find executable file or library to read symbols.\n\
3730 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3733 hm
= LoadLibrary ("advapi32.dll");
3736 GPA (hm
, OpenProcessToken
);
3737 GPA (hm
, LookupPrivilegeValueA
);
3738 GPA (hm
, AdjustTokenPrivileges
);
3739 /* Only need to set one of these since if OpenProcessToken fails nothing
3741 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3742 || !AdjustTokenPrivileges
)
3743 OpenProcessToken
= bad_OpenProcessToken
;