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 using namespace windows_nat
;
80 #define AdjustTokenPrivileges dyn_AdjustTokenPrivileges
81 #define DebugActiveProcessStop dyn_DebugActiveProcessStop
82 #define DebugBreakProcess dyn_DebugBreakProcess
83 #define DebugSetProcessKillOnExit dyn_DebugSetProcessKillOnExit
84 #define EnumProcessModules dyn_EnumProcessModules
85 #define EnumProcessModulesEx dyn_EnumProcessModulesEx
86 #define GetModuleInformation dyn_GetModuleInformation
87 #define LookupPrivilegeValueA dyn_LookupPrivilegeValueA
88 #define OpenProcessToken dyn_OpenProcessToken
89 #define GetConsoleFontSize dyn_GetConsoleFontSize
90 #define GetCurrentConsoleFont dyn_GetCurrentConsoleFont
91 #define Wow64SuspendThread dyn_Wow64SuspendThread
92 #define Wow64GetThreadContext dyn_Wow64GetThreadContext
93 #define Wow64SetThreadContext dyn_Wow64SetThreadContext
94 #define Wow64GetThreadSelectorEntry dyn_Wow64GetThreadSelectorEntry
96 typedef BOOL
WINAPI (AdjustTokenPrivileges_ftype
) (HANDLE
, BOOL
,
98 DWORD
, PTOKEN_PRIVILEGES
,
100 static AdjustTokenPrivileges_ftype
*AdjustTokenPrivileges
;
102 typedef BOOL
WINAPI (DebugActiveProcessStop_ftype
) (DWORD
);
103 static DebugActiveProcessStop_ftype
*DebugActiveProcessStop
;
105 typedef BOOL
WINAPI (DebugBreakProcess_ftype
) (HANDLE
);
106 static DebugBreakProcess_ftype
*DebugBreakProcess
;
108 typedef BOOL
WINAPI (DebugSetProcessKillOnExit_ftype
) (BOOL
);
109 static DebugSetProcessKillOnExit_ftype
*DebugSetProcessKillOnExit
;
111 typedef BOOL
WINAPI (EnumProcessModules_ftype
) (HANDLE
, HMODULE
*, DWORD
,
113 static EnumProcessModules_ftype
*EnumProcessModules
;
116 typedef BOOL
WINAPI (EnumProcessModulesEx_ftype
) (HANDLE
, HMODULE
*, DWORD
,
118 static EnumProcessModulesEx_ftype
*EnumProcessModulesEx
;
121 typedef BOOL
WINAPI (GetModuleInformation_ftype
) (HANDLE
, HMODULE
,
122 LPMODULEINFO
, DWORD
);
123 static GetModuleInformation_ftype
*GetModuleInformation
;
125 typedef BOOL
WINAPI (LookupPrivilegeValueA_ftype
) (LPCSTR
, LPCSTR
, PLUID
);
126 static LookupPrivilegeValueA_ftype
*LookupPrivilegeValueA
;
128 typedef BOOL
WINAPI (OpenProcessToken_ftype
) (HANDLE
, DWORD
, PHANDLE
);
129 static OpenProcessToken_ftype
*OpenProcessToken
;
131 typedef BOOL
WINAPI (GetCurrentConsoleFont_ftype
) (HANDLE
, BOOL
,
132 CONSOLE_FONT_INFO
*);
133 static GetCurrentConsoleFont_ftype
*GetCurrentConsoleFont
;
135 typedef COORD
WINAPI (GetConsoleFontSize_ftype
) (HANDLE
, DWORD
);
136 static GetConsoleFontSize_ftype
*GetConsoleFontSize
;
139 typedef DWORD
WINAPI (Wow64SuspendThread_ftype
) (HANDLE
);
140 static Wow64SuspendThread_ftype
*Wow64SuspendThread
;
142 typedef BOOL
WINAPI (Wow64GetThreadContext_ftype
) (HANDLE
, PWOW64_CONTEXT
);
143 static Wow64GetThreadContext_ftype
*Wow64GetThreadContext
;
145 typedef BOOL
WINAPI (Wow64SetThreadContext_ftype
) (HANDLE
,
146 const WOW64_CONTEXT
*);
147 static Wow64SetThreadContext_ftype
*Wow64SetThreadContext
;
149 typedef BOOL
WINAPI (Wow64GetThreadSelectorEntry_ftype
) (HANDLE
, DWORD
,
151 static Wow64GetThreadSelectorEntry_ftype
*Wow64GetThreadSelectorEntry
;
156 #undef GetModuleFileNameEx
159 # define __PMAX (MAX_PATH + 1)
160 typedef DWORD
WINAPI (GetModuleFileNameEx_ftype
) (HANDLE
, HMODULE
, LPSTR
, DWORD
);
161 static GetModuleFileNameEx_ftype
*GetModuleFileNameEx
;
162 # define STARTUPINFO STARTUPINFOA
163 # define CreateProcess CreateProcessA
164 # define GetModuleFileNameEx_name "GetModuleFileNameExA"
165 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
167 # define __PMAX PATH_MAX
168 /* The starting and ending address of the cygwin1.dll text segment. */
169 static CORE_ADDR cygwin_load_start
;
170 static CORE_ADDR cygwin_load_end
;
172 typedef wchar_t cygwin_buf_t
;
173 typedef DWORD
WINAPI (GetModuleFileNameEx_ftype
) (HANDLE
, HMODULE
,
175 static GetModuleFileNameEx_ftype
*GetModuleFileNameEx
;
176 # define STARTUPINFO STARTUPINFOW
177 # define CreateProcess CreateProcessW
178 # define GetModuleFileNameEx_name "GetModuleFileNameExW"
179 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExW
182 static int have_saved_context
; /* True if we've saved context from a
185 static CONTEXT saved_context
; /* Contains the saved context from a
189 /* If we're not using the old Cygwin header file set, define the
190 following which never should have been in the generic Win32 API
191 headers in the first place since they were our own invention... */
192 #ifndef _GNU_H_WINDOWS_H
195 FLAG_TRACE_BIT
= 0x100,
199 #ifndef CONTEXT_EXTENDED_REGISTERS
200 /* This macro is only defined on ia32. It only makes sense on this target,
201 so define it as zero if not already defined. */
202 #define CONTEXT_EXTENDED_REGISTERS 0
205 #define CONTEXT_DEBUGGER_DR CONTEXT_FULL | CONTEXT_FLOATING_POINT \
206 | CONTEXT_SEGMENTS | CONTEXT_DEBUG_REGISTERS \
207 | CONTEXT_EXTENDED_REGISTERS
209 static uintptr_t dr
[8];
210 static int debug_registers_changed
;
211 static int debug_registers_used
;
213 static int windows_initialization_done
;
214 #define DR6_CLEAR_VALUE 0xffff0ff0
216 /* The exception thrown by a program to tell the debugger the name of
217 a thread. The exception record contains an ID of a thread and a
218 name to give it. This exception has no documented name, but MSDN
219 dubs it "MS_VC_EXCEPTION" in one code example. */
220 #define MS_VC_EXCEPTION 0x406d1388
224 HANDLE_EXCEPTION_UNHANDLED
= 0,
225 HANDLE_EXCEPTION_HANDLED
,
226 HANDLE_EXCEPTION_IGNORED
227 } handle_exception_result
;
229 /* The string sent by cygwin when it processes a signal.
230 FIXME: This should be in a cygwin include file. */
231 #ifndef _CYGWIN_SIGNAL_STRING
232 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
235 #define CHECK(x) check (x, __FILE__,__LINE__)
236 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
237 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
238 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
239 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
241 static void cygwin_set_dr (int i
, CORE_ADDR addr
);
242 static void cygwin_set_dr7 (unsigned long val
);
243 static CORE_ADDR
cygwin_get_dr (int i
);
244 static unsigned long cygwin_get_dr6 (void);
245 static unsigned long cygwin_get_dr7 (void);
247 static enum gdb_signal last_sig
= GDB_SIGNAL_0
;
248 /* Set if a signal was received from the debugged process. */
250 static std::vector
<windows_thread_info
*> thread_list
;
252 /* The process and thread handles for the above context. */
254 /* The current debug event from WaitForDebugEvent or from a pending
256 static DEBUG_EVENT current_event
;
258 /* The most recent event from WaitForDebugEvent. Unlike
259 current_event, this is guaranteed never to come from a pending
260 stop. This is important because only data from the most recent
261 event from WaitForDebugEvent can be used when calling
262 ContinueDebugEvent. */
263 static DEBUG_EVENT last_wait_event
;
265 static HANDLE current_process_handle
; /* Currently executing process */
266 static windows_thread_info
*current_thread
; /* Info on currently selected thread */
267 static EXCEPTION_RECORD siginfo_er
; /* Contents of $_siginfo */
269 /* Counts of things. */
270 static int exception_count
= 0;
271 static int event_count
= 0;
272 static int saw_create
;
273 static int open_process_used
= 0;
275 static bool wow64_process
= false;
276 static bool ignore_first_breakpoint
= false;
280 static bool new_console
= false;
282 static bool cygwin_exceptions
= false;
284 static bool new_group
= true;
285 static bool debug_exec
= false; /* show execution */
286 static bool debug_events
= false; /* show events from kernel */
287 static bool debug_memory
= false; /* show target memory accesses */
288 static bool debug_exceptions
= false; /* show target exceptions */
289 static bool useshell
= false; /* use shell for subprocesses */
291 /* This vector maps GDB's idea of a register's number into an offset
292 in the windows exception context vector.
294 It also contains the bit mask needed to load the register in question.
296 The contents of this table can only be computed by the units
297 that provide CPU-specific support for Windows native debugging.
298 These units should set the table by calling
299 windows_set_context_register_offsets.
301 One day we could read a reg, we could inspect the context we
302 already have loaded, if it doesn't have the bit set that we need,
303 we read that set of registers in using GetThreadContext. If the
304 context already contains what we need, we just unpack it. Then to
305 write a register, first we have to ensure that the context contains
306 the other regs of the group, and then we copy the info in and set
309 static const int *mappings
;
311 /* The function to use in order to determine whether a register is
312 a segment register or not. */
313 static segment_register_p_ftype
*segment_register_p
;
315 /* See windows_nat_target::resume to understand why this is commented
318 /* This vector maps the target's idea of an exception (extracted
319 from the DEBUG_EVENT structure) to GDB's idea. */
321 struct xlate_exception
327 static const struct xlate_exception xlate
[] =
329 {EXCEPTION_ACCESS_VIOLATION
, GDB_SIGNAL_SEGV
},
330 {STATUS_STACK_OVERFLOW
, GDB_SIGNAL_SEGV
},
331 {EXCEPTION_BREAKPOINT
, GDB_SIGNAL_TRAP
},
332 {DBG_CONTROL_C
, GDB_SIGNAL_INT
},
333 {EXCEPTION_SINGLE_STEP
, GDB_SIGNAL_TRAP
},
334 {STATUS_FLOAT_DIVIDE_BY_ZERO
, GDB_SIGNAL_FPE
}
339 /* The ID of the thread for which we anticipate a stop event.
340 Normally this is -1, meaning we'll accept an event in any
342 static DWORD desired_stop_thread_id
= -1;
344 /* A single pending stop. See "pending_stops" for more
351 /* The target waitstatus we computed. */
352 target_waitstatus status
;
354 /* The event. A few fields of this can be referenced after a stop,
355 and it seemed simplest to store the entire event. */
359 /* A vector of pending stops. Sometimes, Windows will report a stop
360 on a thread that has been ostensibly suspended. We believe what
361 happens here is that two threads hit a breakpoint simultaneously,
362 and the Windows kernel queues the stop events. However, this can
363 result in the strange effect of trying to single step thread A --
364 leaving all other threads suspended -- and then seeing a stop in
365 thread B. To handle this scenario, we queue all such "pending"
366 stops here, and then process them once the step has completed. See
368 static std::vector
<pending_stop
> pending_stops
;
370 struct windows_nat_target final
: public x86_nat_target
<inf_child_target
>
372 void close () override
;
374 void attach (const char *, int) override
;
376 bool attach_no_wait () override
379 void detach (inferior
*, int) override
;
381 void resume (ptid_t
, int , enum gdb_signal
) override
;
383 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
385 void fetch_registers (struct regcache
*, int) override
;
386 void store_registers (struct regcache
*, int) override
;
388 bool stopped_by_sw_breakpoint () override
390 return current_thread
->stopped_at_software_breakpoint
;
393 bool supports_stopped_by_sw_breakpoint () override
398 enum target_xfer_status
xfer_partial (enum target_object object
,
401 const gdb_byte
*writebuf
,
402 ULONGEST offset
, ULONGEST len
,
403 ULONGEST
*xfered_len
) override
;
405 void files_info () override
;
407 void kill () override
;
409 void create_inferior (const char *, const std::string
&,
410 char **, int) override
;
412 void mourn_inferior () override
;
414 bool thread_alive (ptid_t ptid
) override
;
416 std::string
pid_to_str (ptid_t
) override
;
418 void interrupt () override
;
420 char *pid_to_exec_file (int pid
) override
;
422 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
424 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
426 const char *thread_name (struct thread_info
*) override
;
428 int get_windows_debug_event (int pid
, struct target_waitstatus
*ourstatus
);
431 static windows_nat_target the_windows_nat_target
;
433 /* Set the MAPPINGS static global to OFFSETS.
434 See the description of MAPPINGS for more details. */
437 windows_set_context_register_offsets (const int *offsets
)
442 /* Set the function that should be used by this module to determine
443 whether a given register is a segment register or not. */
446 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
448 segment_register_p
= fun
;
452 check (BOOL ok
, const char *file
, int line
)
455 printf_filtered ("error return %s:%d was %u\n", file
, line
,
456 (unsigned) GetLastError ());
459 /* Possible values to pass to 'thread_rec'. */
460 enum thread_disposition_type
462 /* Do not invalidate the thread's context, and do not suspend the
464 DONT_INVALIDATE_CONTEXT
,
465 /* Invalidate the context, but do not suspend the thread. */
467 /* Invalidate the context and suspend the thread. */
471 /* Find a thread record given a thread id. THREAD_DISPOSITION
472 controls whether the thread is suspended, and whether the context
474 static windows_thread_info
*
475 thread_rec (DWORD id
, enum thread_disposition_type disposition
)
477 for (windows_thread_info
*th
: thread_list
)
484 case DONT_INVALIDATE_CONTEXT
:
487 case INVALIDATE_CONTEXT
:
488 if (id
!= current_event
.dwThreadId
)
490 th
->reload_context
= true;
493 th
->reload_context
= true;
504 /* Add a thread to the thread list.
506 PTID is the ptid of the thread to be added.
507 H is its Windows handle.
508 TLB is its thread local base.
509 MAIN_THREAD_P should be true if the thread to be added is
510 the main thread, false otherwise. */
512 static windows_thread_info
*
513 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
, bool main_thread_p
)
515 windows_thread_info
*th
;
518 gdb_assert (ptid
.lwp () != 0);
522 if ((th
= thread_rec (id
, DONT_INVALIDATE_CONTEXT
)))
525 CORE_ADDR base
= (CORE_ADDR
) (uintptr_t) tlb
;
527 /* For WOW64 processes, this is actually the pointer to the 64bit TIB,
528 and the 32bit TIB is exactly 2 pages after it. */
532 th
= new windows_thread_info (id
, h
, base
);
533 thread_list
.push_back (th
);
535 /* Add this new thread to the list of threads.
537 To be consistent with what's done on other platforms, we add
538 the main thread silently (in reality, this thread is really
539 more of a process to the user than a thread). */
541 add_thread_silent (&the_windows_nat_target
, ptid
);
543 add_thread (&the_windows_nat_target
, ptid
);
545 /* Set the debug registers for the new thread if they are used. */
546 if (debug_registers_used
)
551 /* Only change the value of the debug registers. */
552 th
->wow64_context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
553 CHECK (Wow64GetThreadContext (th
->h
, &th
->wow64_context
));
554 th
->wow64_context
.Dr0
= dr
[0];
555 th
->wow64_context
.Dr1
= dr
[1];
556 th
->wow64_context
.Dr2
= dr
[2];
557 th
->wow64_context
.Dr3
= dr
[3];
558 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
559 th
->wow64_context
.Dr7
= dr
[7];
560 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
561 th
->wow64_context
.ContextFlags
= 0;
566 /* Only change the value of the debug registers. */
567 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
568 CHECK (GetThreadContext (th
->h
, &th
->context
));
569 th
->context
.Dr0
= dr
[0];
570 th
->context
.Dr1
= dr
[1];
571 th
->context
.Dr2
= dr
[2];
572 th
->context
.Dr3
= dr
[3];
573 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
574 th
->context
.Dr7
= dr
[7];
575 CHECK (SetThreadContext (th
->h
, &th
->context
));
576 th
->context
.ContextFlags
= 0;
582 /* Clear out any old thread list and reinitialize it to a
585 windows_init_thread_list (void)
587 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
590 for (windows_thread_info
*here
: thread_list
)
593 thread_list
.clear ();
596 /* Delete a thread from the list of threads.
598 PTID is the ptid of the thread to be deleted.
599 EXIT_CODE is the thread's exit code.
600 MAIN_THREAD_P should be true if the thread to be deleted is
601 the main thread, false otherwise. */
604 windows_delete_thread (ptid_t ptid
, DWORD exit_code
, bool main_thread_p
)
608 gdb_assert (ptid
.lwp () != 0);
612 /* Emit a notification about the thread being deleted.
614 Note that no notification was printed when the main thread
615 was created, and thus, unless in verbose mode, we should be
616 symmetrical, and avoid that notification for the main thread
620 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
).c_str ());
621 else if (print_thread_events
&& !main_thread_p
)
622 printf_unfiltered (_("[%s exited with code %u]\n"),
623 target_pid_to_str (ptid
).c_str (),
624 (unsigned) exit_code
);
626 delete_thread (find_thread_ptid (&the_windows_nat_target
, ptid
));
628 auto iter
= std::find_if (thread_list
.begin (), thread_list
.end (),
629 [=] (windows_thread_info
*th
)
631 return th
->tid
== id
;
634 if (iter
!= thread_list
.end ())
637 thread_list
.erase (iter
);
641 /* Fetches register number R from the given windows_thread_info,
642 and supplies its value to the given regcache.
644 This function assumes that R is non-negative. A failed assertion
645 is raised if that is not true.
647 This function assumes that TH->RELOAD_CONTEXT is not set, meaning
648 that the windows_thread_info has an up-to-date context. A failed
649 assertion is raised if that assumption is violated. */
652 windows_fetch_one_register (struct regcache
*regcache
,
653 windows_thread_info
*th
, int r
)
656 gdb_assert (!th
->reload_context
);
658 char *context_ptr
= (char *) &th
->context
;
661 context_ptr
= (char *) &th
->wow64_context
;
664 char *context_offset
= context_ptr
+ mappings
[r
];
665 struct gdbarch
*gdbarch
= regcache
->arch ();
666 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
668 gdb_assert (!gdbarch_read_pc_p (gdbarch
));
669 gdb_assert (gdbarch_pc_regnum (gdbarch
) >= 0);
670 gdb_assert (!gdbarch_write_pc_p (gdbarch
));
672 if (r
== I387_FISEG_REGNUM (tdep
))
674 long l
= *((long *) context_offset
) & 0xffff;
675 regcache
->raw_supply (r
, (char *) &l
);
677 else if (r
== I387_FOP_REGNUM (tdep
))
679 long l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
680 regcache
->raw_supply (r
, (char *) &l
);
682 else if (segment_register_p (r
))
684 /* GDB treats segment registers as 32bit registers, but they are
685 in fact only 16 bits long. Make sure we do not read extra
686 bits from our source buffer. */
687 long l
= *((long *) context_offset
) & 0xffff;
688 regcache
->raw_supply (r
, (char *) &l
);
692 if (th
->stopped_at_software_breakpoint
693 && r
== gdbarch_pc_regnum (gdbarch
))
695 int size
= register_size (gdbarch
, r
);
699 memcpy (&value
, context_offset
, size
);
700 value
-= gdbarch_decr_pc_after_break (gdbarch
);
701 memcpy (context_offset
, &value
, size
);
705 gdb_assert (size
== 8);
707 memcpy (&value
, context_offset
, size
);
708 value
-= gdbarch_decr_pc_after_break (gdbarch
);
709 memcpy (context_offset
, &value
, size
);
712 regcache
->raw_supply (r
, context_offset
);
717 windows_nat_target::fetch_registers (struct regcache
*regcache
, int r
)
719 DWORD tid
= regcache
->ptid ().lwp ();
720 windows_thread_info
*th
= thread_rec (tid
, INVALIDATE_CONTEXT
);
722 /* Check if TH exists. Windows sometimes uses a non-existent
723 thread id in its events. */
727 if (th
->reload_context
)
730 if (have_saved_context
)
732 /* Lie about where the program actually is stopped since
733 cygwin has informed us that we should consider the signal
734 to have occurred at another location which is stored in
736 memcpy (&th
->context
, &saved_context
,
737 __COPY_CONTEXT_SIZE
);
738 have_saved_context
= 0;
745 th
->wow64_context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
746 CHECK (Wow64GetThreadContext (th
->h
, &th
->wow64_context
));
747 /* Copy dr values from that thread.
748 But only if there were not modified since last stop.
750 if (!debug_registers_changed
)
752 dr
[0] = th
->wow64_context
.Dr0
;
753 dr
[1] = th
->wow64_context
.Dr1
;
754 dr
[2] = th
->wow64_context
.Dr2
;
755 dr
[3] = th
->wow64_context
.Dr3
;
756 dr
[6] = th
->wow64_context
.Dr6
;
757 dr
[7] = th
->wow64_context
.Dr7
;
763 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
764 CHECK (GetThreadContext (th
->h
, &th
->context
));
765 /* Copy dr values from that thread.
766 But only if there were not modified since last stop.
768 if (!debug_registers_changed
)
770 dr
[0] = th
->context
.Dr0
;
771 dr
[1] = th
->context
.Dr1
;
772 dr
[2] = th
->context
.Dr2
;
773 dr
[3] = th
->context
.Dr3
;
774 dr
[6] = th
->context
.Dr6
;
775 dr
[7] = th
->context
.Dr7
;
778 th
->reload_context
= false;
782 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch()); r
++)
783 windows_fetch_one_register (regcache
, th
, r
);
785 windows_fetch_one_register (regcache
, th
, r
);
788 /* Collect the register number R from the given regcache, and store
789 its value into the corresponding area of the given thread's context.
791 This function assumes that R is non-negative. A failed assertion
792 assertion is raised if that is not true. */
795 windows_store_one_register (const struct regcache
*regcache
,
796 windows_thread_info
*th
, int r
)
800 char *context_ptr
= (char *) &th
->context
;
803 context_ptr
= (char *) &th
->wow64_context
;
806 regcache
->raw_collect (r
, context_ptr
+ mappings
[r
]);
809 /* Store a new register value into the context of the thread tied to
813 windows_nat_target::store_registers (struct regcache
*regcache
, int r
)
815 DWORD tid
= regcache
->ptid ().lwp ();
816 windows_thread_info
*th
= thread_rec (tid
, INVALIDATE_CONTEXT
);
818 /* Check if TH exists. Windows sometimes uses a non-existent
819 thread id in its events. */
824 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch ()); r
++)
825 windows_store_one_register (regcache
, th
, r
);
827 windows_store_one_register (regcache
, th
, r
);
830 /* Maintain a linked list of "so" information. */
831 struct lm_info_windows
: public lm_info_base
833 LPVOID load_addr
= 0;
834 CORE_ADDR text_offset
= 0;
837 static struct so_list solib_start
, *solib_end
;
839 static struct so_list
*
840 windows_make_so (const char *name
, LPVOID load_addr
)
847 WIN32_FIND_DATA w32_fd
;
848 HANDLE h
= FindFirstFile(name
, &w32_fd
);
850 if (h
== INVALID_HANDLE_VALUE
)
856 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
858 p
= strrchr (buf
, '\\');
861 SetCurrentDirectory (buf
);
862 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
863 SetCurrentDirectory (cwd
);
866 if (strcasecmp (buf
, "ntdll.dll") == 0)
868 GetSystemDirectory (buf
, sizeof (buf
));
869 strcat (buf
, "\\ntdll.dll");
872 cygwin_buf_t buf
[__PMAX
];
875 if (access (name
, F_OK
) != 0)
877 if (strcasecmp (name
, "ntdll.dll") == 0)
880 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
881 wcscat (buf
, L
"\\ntdll.dll");
885 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
886 strcat (buf
, "\\ntdll.dll");
891 so
= XCNEW (struct so_list
);
892 lm_info_windows
*li
= new lm_info_windows
;
894 li
->load_addr
= load_addr
;
895 strcpy (so
->so_original_name
, name
);
897 strcpy (so
->so_name
, buf
);
900 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
901 SO_NAME_MAX_PATH_SIZE
);
904 char *rname
= realpath (name
, NULL
);
905 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
907 strcpy (so
->so_name
, rname
);
911 error (_("dll path too long"));
913 /* Record cygwin1.dll .text start/end. */
914 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
915 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
917 asection
*text
= NULL
;
919 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386", -1));
924 if (bfd_check_format (abfd
.get (), bfd_object
))
925 text
= bfd_get_section_by_name (abfd
.get (), ".text");
930 /* The symbols in a dll are offset by 0x1000, which is the
931 offset from 0 of the first byte in an image - because of the
932 file header and the section alignment. */
933 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
935 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (text
);
943 get_image_name (HANDLE h
, void *address
, int unicode
)
946 static char buf
[__PMAX
];
948 static char buf
[(2 * __PMAX
) + 1];
950 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
956 /* Attempt to read the name of the dll that was detected.
957 This is documented to work only when actively debugging
958 a program. It will not work for attached processes. */
962 /* See if we could read the address of a string, and that the
963 address isn't null. */
964 if (!ReadProcessMemory (h
, address
, &address_ptr
,
965 sizeof (address_ptr
), &done
)
966 || done
!= sizeof (address_ptr
) || !address_ptr
)
969 /* Find the length of the string. */
970 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
971 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
975 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
978 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
979 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
982 wcstombs (buf
, unicode_address
, __PMAX
);
984 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
992 /* Handle a DLL load event, and return 1.
994 This function assumes that this event did not occur during inferior
995 initialization, where their event info may be incomplete (see
996 do_initial_windows_stuff and windows_add_all_dlls for more info
997 on how we handle DLL loading during that phase). */
1002 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
1005 /* Try getting the DLL name via the lpImageName field of the event.
1006 Note that Microsoft documents this fields as strictly optional,
1007 in the sense that it might be NULL. And the first DLL event in
1008 particular is explicitly documented as "likely not pass[ed]"
1009 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
1010 dll_name
= get_image_name (current_process_handle
,
1011 event
->lpImageName
, event
->fUnicode
);
1015 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
1016 solib_end
= solib_end
->next
;
1018 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
1020 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
1021 host_address_to_string (li
->load_addr
)));
1025 windows_free_so (struct so_list
*so
)
1027 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
1033 /* Handle a DLL unload event.
1034 Return 1 if successful, or zero otherwise.
1036 This function assumes that this event did not occur during inferior
1037 initialization, where their event info may be incomplete (see
1038 do_initial_windows_stuff and windows_add_all_dlls for more info
1039 on how we handle DLL loading during that phase). */
1042 handle_unload_dll ()
1044 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
1047 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
1049 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
1051 if (li_next
->load_addr
== lpBaseOfDll
)
1053 struct so_list
*sodel
= so
->next
;
1055 so
->next
= sodel
->next
;
1058 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
1060 windows_free_so (sodel
);
1065 /* We did not find any DLL that was previously loaded at this address,
1066 so register a complaint. We do not report an error, because we have
1067 observed that this may be happening under some circumstances. For
1068 instance, running 32bit applications on x64 Windows causes us to receive
1069 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
1070 events are apparently caused by the WOW layer, the interface between
1071 32bit and 64bit worlds). */
1072 complaint (_("dll starting at %s not found."),
1073 host_address_to_string (lpBaseOfDll
));
1076 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
1080 catch_errors (void (*func
) ())
1086 catch (const gdb_exception
&ex
)
1088 exception_print (gdb_stderr
, ex
);
1092 /* Clear list of loaded DLLs. */
1094 windows_clear_solib (void)
1098 for (so
= solib_start
.next
; so
; so
= solib_start
.next
)
1100 solib_start
.next
= so
->next
;
1101 windows_free_so (so
);
1104 solib_end
= &solib_start
;
1108 signal_event_command (const char *args
, int from_tty
)
1110 uintptr_t event_id
= 0;
1111 char *endargs
= NULL
;
1114 error (_("signal-event requires an argument (integer event id)"));
1116 event_id
= strtoumax (args
, &endargs
, 10);
1118 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
1119 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
1120 error (_("Failed to convert `%s' to event id"), args
);
1122 SetEvent ((HANDLE
) event_id
);
1123 CloseHandle ((HANDLE
) event_id
);
1126 /* Handle DEBUG_STRING output from child process.
1127 Cygwin prepends its messages with a "cygwin:". Interpret this as
1128 a Cygwin signal. Otherwise just print the string as a warning. */
1130 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
1132 gdb::unique_xmalloc_ptr
<char> s
;
1135 if (!target_read_string
1136 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
1138 || !s
|| !*(s
.get ()))
1139 /* nothing to do */;
1140 else if (!startswith (s
.get (), _CYGWIN_SIGNAL_STRING
))
1143 if (!startswith (s
.get (), "cYg"))
1146 char *p
= strchr (s
.get (), '\0');
1148 if (p
> s
.get () && *--p
== '\n')
1150 warning (("%s"), s
.get ());
1156 /* Got a cygwin signal marker. A cygwin signal is followed by
1157 the signal number itself and then optionally followed by the
1158 thread id and address to saved context within the DLL. If
1159 these are supplied, then the given thread is assumed to have
1160 issued the signal and the context from the thread is assumed
1161 to be stored at the given address in the inferior. Tell gdb
1162 to treat this like a real signal. */
1164 int sig
= strtol (s
.get () + sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
1165 gdb_signal gotasig
= gdb_signal_from_host (sig
);
1167 ourstatus
->value
.sig
= gotasig
;
1173 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1174 retval
= strtoul (p
, &p
, 0);
1176 retval
= current_event
.dwThreadId
;
1177 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
1178 && ReadProcessMemory (current_process_handle
, x
,
1180 __COPY_CONTEXT_SIZE
, &n
)
1181 && n
== __COPY_CONTEXT_SIZE
)
1182 have_saved_context
= 1;
1191 display_selector (HANDLE thread
, DWORD sel
)
1197 ret
= Wow64GetThreadSelectorEntry (thread
, sel
, &info
);
1200 ret
= GetThreadSelectorEntry (thread
, sel
, &info
);
1204 printf_filtered ("0x%03x: ", (unsigned) sel
);
1205 if (!info
.HighWord
.Bits
.Pres
)
1207 puts_filtered ("Segment not present\n");
1210 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1211 (info
.HighWord
.Bits
.BaseMid
<< 16)
1213 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1214 if (info
.HighWord
.Bits
.Granularity
)
1215 limit
= (limit
<< 12) | 0xfff;
1216 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1217 if (info
.HighWord
.Bits
.Default_Big
)
1218 puts_filtered(" 32-bit ");
1220 puts_filtered(" 16-bit ");
1221 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1224 puts_filtered ("Data (Read-Only, Exp-up");
1227 puts_filtered ("Data (Read/Write, Exp-up");
1230 puts_filtered ("Unused segment (");
1233 puts_filtered ("Data (Read/Write, Exp-down");
1236 puts_filtered ("Code (Exec-Only, N.Conf");
1239 puts_filtered ("Code (Exec/Read, N.Conf");
1242 puts_filtered ("Code (Exec-Only, Conf");
1245 puts_filtered ("Code (Exec/Read, Conf");
1248 printf_filtered ("Unknown type 0x%lx",
1249 (unsigned long) info
.HighWord
.Bits
.Type
);
1251 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1252 puts_filtered(", N.Acc");
1253 puts_filtered (")\n");
1254 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1255 puts_filtered("System selector ");
1256 printf_filtered ("Priviledge level = %ld. ",
1257 (unsigned long) info
.HighWord
.Bits
.Dpl
);
1258 if (info
.HighWord
.Bits
.Granularity
)
1259 puts_filtered ("Page granular.\n");
1261 puts_filtered ("Byte granular.\n");
1266 DWORD err
= GetLastError ();
1267 if (err
== ERROR_NOT_SUPPORTED
)
1268 printf_filtered ("Function not supported\n");
1270 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1276 display_selectors (const char * args
, int from_tty
)
1278 if (!current_thread
)
1280 puts_filtered ("Impossible to display selectors now.\n");
1288 puts_filtered ("Selector $cs\n");
1289 display_selector (current_thread
->h
,
1290 current_thread
->wow64_context
.SegCs
);
1291 puts_filtered ("Selector $ds\n");
1292 display_selector (current_thread
->h
,
1293 current_thread
->wow64_context
.SegDs
);
1294 puts_filtered ("Selector $es\n");
1295 display_selector (current_thread
->h
,
1296 current_thread
->wow64_context
.SegEs
);
1297 puts_filtered ("Selector $ss\n");
1298 display_selector (current_thread
->h
,
1299 current_thread
->wow64_context
.SegSs
);
1300 puts_filtered ("Selector $fs\n");
1301 display_selector (current_thread
->h
,
1302 current_thread
->wow64_context
.SegFs
);
1303 puts_filtered ("Selector $gs\n");
1304 display_selector (current_thread
->h
,
1305 current_thread
->wow64_context
.SegGs
);
1310 puts_filtered ("Selector $cs\n");
1311 display_selector (current_thread
->h
,
1312 current_thread
->context
.SegCs
);
1313 puts_filtered ("Selector $ds\n");
1314 display_selector (current_thread
->h
,
1315 current_thread
->context
.SegDs
);
1316 puts_filtered ("Selector $es\n");
1317 display_selector (current_thread
->h
,
1318 current_thread
->context
.SegEs
);
1319 puts_filtered ("Selector $ss\n");
1320 display_selector (current_thread
->h
,
1321 current_thread
->context
.SegSs
);
1322 puts_filtered ("Selector $fs\n");
1323 display_selector (current_thread
->h
,
1324 current_thread
->context
.SegFs
);
1325 puts_filtered ("Selector $gs\n");
1326 display_selector (current_thread
->h
,
1327 current_thread
->context
.SegGs
);
1333 sel
= parse_and_eval_long (args
);
1334 printf_filtered ("Selector \"%s\"\n",args
);
1335 display_selector (current_thread
->h
, sel
);
1339 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1340 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1341 host_address_to_string (\
1342 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1344 static handle_exception_result
1345 handle_exception (struct target_waitstatus
*ourstatus
)
1347 EXCEPTION_RECORD
*rec
= ¤t_event
.u
.Exception
.ExceptionRecord
;
1348 DWORD code
= rec
->ExceptionCode
;
1349 handle_exception_result result
= HANDLE_EXCEPTION_HANDLED
;
1351 memcpy (&siginfo_er
, rec
, sizeof siginfo_er
);
1353 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1355 /* Record the context of the current thread. */
1356 thread_rec (current_event
.dwThreadId
, DONT_SUSPEND
);
1360 case EXCEPTION_ACCESS_VIOLATION
:
1361 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1362 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1365 /* See if the access violation happened within the cygwin DLL
1366 itself. Cygwin uses a kind of exception handling to deal
1367 with passed-in invalid addresses. gdb should not treat
1368 these as real SEGVs since they will be silently handled by
1369 cygwin. A real SEGV will (theoretically) be caught by
1370 cygwin later in the process and will be sent as a
1371 cygwin-specific-signal. So, ignore SEGVs if they show up
1372 within the text segment of the DLL itself. */
1374 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1376 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1377 && addr
< cygwin_load_end
))
1378 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1379 && startswith (fn
, "KERNEL32!IsBad")))
1380 return HANDLE_EXCEPTION_UNHANDLED
;
1384 case STATUS_STACK_OVERFLOW
:
1385 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1386 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1388 case STATUS_FLOAT_DENORMAL_OPERAND
:
1389 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1390 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1392 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1393 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1394 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1396 case STATUS_FLOAT_INEXACT_RESULT
:
1397 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1398 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1400 case STATUS_FLOAT_INVALID_OPERATION
:
1401 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1402 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1404 case STATUS_FLOAT_OVERFLOW
:
1405 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1406 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1408 case STATUS_FLOAT_STACK_CHECK
:
1409 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1410 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1412 case STATUS_FLOAT_UNDERFLOW
:
1413 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1414 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1416 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1417 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1418 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1420 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1421 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1422 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1424 case STATUS_INTEGER_OVERFLOW
:
1425 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1426 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1428 case EXCEPTION_BREAKPOINT
:
1430 if (ignore_first_breakpoint
)
1432 /* For WOW64 processes, there are always 2 breakpoint exceptions
1433 on startup, first a BREAKPOINT for the 64bit ntdll.dll,
1434 then a WX86_BREAKPOINT for the 32bit ntdll.dll.
1435 Here we only care about the WX86_BREAKPOINT's. */
1436 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1437 ignore_first_breakpoint
= false;
1441 case STATUS_WX86_BREAKPOINT
:
1442 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1443 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1446 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1447 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1449 case DBG_CONTROL_BREAK
:
1450 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1451 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1453 case EXCEPTION_SINGLE_STEP
:
1454 case STATUS_WX86_SINGLE_STEP
:
1455 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1456 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1458 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1459 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1460 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1462 case EXCEPTION_PRIV_INSTRUCTION
:
1463 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1464 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1466 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1467 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1468 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1470 case MS_VC_EXCEPTION
:
1471 if (rec
->NumberParameters
>= 3
1472 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1474 DWORD named_thread_id
;
1475 windows_thread_info
*named_thread
;
1476 CORE_ADDR thread_name_target
;
1478 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1480 thread_name_target
= rec
->ExceptionInformation
[1];
1481 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1483 if (named_thread_id
== (DWORD
) -1)
1484 named_thread_id
= current_event
.dwThreadId
;
1486 named_thread
= thread_rec (named_thread_id
, DONT_INVALIDATE_CONTEXT
);
1487 if (named_thread
!= NULL
)
1489 int thread_name_len
;
1490 gdb::unique_xmalloc_ptr
<char> thread_name
;
1492 thread_name_len
= target_read_string (thread_name_target
,
1493 &thread_name
, 1025, NULL
);
1494 if (thread_name_len
> 0)
1496 thread_name
.get ()[thread_name_len
- 1] = '\0';
1497 named_thread
->name
= std::move (thread_name
);
1500 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1501 result
= HANDLE_EXCEPTION_IGNORED
;
1504 /* treat improperly formed exception as unknown */
1507 /* Treat unhandled first chance exceptions specially. */
1508 if (current_event
.u
.Exception
.dwFirstChance
)
1509 return HANDLE_EXCEPTION_UNHANDLED
;
1510 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1511 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1512 host_address_to_string (
1513 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1514 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1518 last_sig
= ourstatus
->value
.sig
;
1522 /* Resume thread specified by ID, or all artificially suspended
1523 threads, if we are continuing execution. KILLED non-zero means we
1524 have killed the inferior, so we should ignore weird errors due to
1525 threads shutting down. */
1527 windows_continue (DWORD continue_status
, int id
, int killed
)
1531 desired_stop_thread_id
= id
;
1533 /* If there are pending stops, and we might plausibly hit one of
1534 them, we don't want to actually continue the inferior -- we just
1535 want to report the stop. In this case, we just pretend to
1536 continue. See the comment by the definition of "pending_stops"
1537 for details on why this is needed. */
1538 for (const auto &item
: pending_stops
)
1540 if (desired_stop_thread_id
== -1
1541 || desired_stop_thread_id
== item
.thread_id
)
1543 DEBUG_EVENTS (("windows_continue - pending stop anticipated, "
1544 "desired=0x%x, item=0x%x\n",
1545 desired_stop_thread_id
, item
.thread_id
));
1550 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1551 (unsigned) last_wait_event
.dwProcessId
,
1552 (unsigned) last_wait_event
.dwThreadId
,
1553 continue_status
== DBG_CONTINUE
?
1554 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1556 for (windows_thread_info
*th
: thread_list
)
1557 if (id
== -1 || id
== (int) th
->tid
)
1564 if (debug_registers_changed
)
1566 th
->wow64_context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1567 th
->wow64_context
.Dr0
= dr
[0];
1568 th
->wow64_context
.Dr1
= dr
[1];
1569 th
->wow64_context
.Dr2
= dr
[2];
1570 th
->wow64_context
.Dr3
= dr
[3];
1571 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1572 th
->wow64_context
.Dr7
= dr
[7];
1574 if (th
->wow64_context
.ContextFlags
)
1578 if (GetExitCodeThread (th
->h
, &ec
)
1579 && ec
== STILL_ACTIVE
)
1581 BOOL status
= Wow64SetThreadContext (th
->h
,
1582 &th
->wow64_context
);
1587 th
->wow64_context
.ContextFlags
= 0;
1593 if (debug_registers_changed
)
1595 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1596 th
->context
.Dr0
= dr
[0];
1597 th
->context
.Dr1
= dr
[1];
1598 th
->context
.Dr2
= dr
[2];
1599 th
->context
.Dr3
= dr
[3];
1600 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1601 th
->context
.Dr7
= dr
[7];
1603 if (th
->context
.ContextFlags
)
1607 if (GetExitCodeThread (th
->h
, &ec
)
1608 && ec
== STILL_ACTIVE
)
1610 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1615 th
->context
.ContextFlags
= 0;
1622 /* When single-stepping a specific thread, other threads must
1627 res
= ContinueDebugEvent (last_wait_event
.dwProcessId
,
1628 last_wait_event
.dwThreadId
,
1632 error (_("Failed to resume program execution"
1633 " (ContinueDebugEvent failed, error %u)"),
1634 (unsigned int) GetLastError ());
1636 debug_registers_changed
= 0;
1640 /* Called in pathological case where Windows fails to send a
1641 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1643 fake_create_process (void)
1645 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1646 current_event
.dwProcessId
);
1647 if (current_process_handle
!= NULL
)
1648 open_process_used
= 1;
1651 error (_("OpenProcess call failed, GetLastError = %u"),
1652 (unsigned) GetLastError ());
1653 /* We can not debug anything in that case. */
1656 = windows_add_thread (ptid_t (current_event
.dwProcessId
,
1657 current_event
.dwThreadId
, 0),
1658 current_event
.u
.CreateThread
.hThread
,
1659 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1660 true /* main_thread_p */);
1661 return current_event
.dwThreadId
;
1665 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1667 windows_thread_info
*th
;
1668 DWORD continue_status
= DBG_CONTINUE
;
1670 /* A specific PTID means `step only this thread id'. */
1671 int resume_all
= ptid
== minus_one_ptid
;
1673 /* If we're continuing all threads, it's the current inferior that
1674 should be handled specially. */
1676 ptid
= inferior_ptid
;
1678 if (sig
!= GDB_SIGNAL_0
)
1680 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1682 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1684 else if (sig
== last_sig
)
1685 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1688 /* This code does not seem to work, because
1689 the kernel does probably not consider changes in the ExceptionRecord
1690 structure when passing the exception to the inferior.
1691 Note that this seems possible in the exception handler itself. */
1693 for (const xlate_exception
&x
: xlate
)
1696 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1698 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1701 if (continue_status
== DBG_CONTINUE
)
1703 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1707 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1711 last_sig
= GDB_SIGNAL_0
;
1713 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=0x%x, step=%d, sig=%d);\n",
1714 ptid
.pid (), (unsigned) ptid
.lwp (), step
, sig
));
1716 /* Get context for currently selected thread. */
1717 th
= thread_rec (inferior_ptid
.lwp (), DONT_INVALIDATE_CONTEXT
);
1725 /* Single step by setting t bit. */
1726 struct regcache
*regcache
= get_current_regcache ();
1727 struct gdbarch
*gdbarch
= regcache
->arch ();
1728 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1729 th
->wow64_context
.EFlags
|= FLAG_TRACE_BIT
;
1732 if (th
->wow64_context
.ContextFlags
)
1734 if (debug_registers_changed
)
1736 th
->wow64_context
.Dr0
= dr
[0];
1737 th
->wow64_context
.Dr1
= dr
[1];
1738 th
->wow64_context
.Dr2
= dr
[2];
1739 th
->wow64_context
.Dr3
= dr
[3];
1740 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1741 th
->wow64_context
.Dr7
= dr
[7];
1743 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
1744 th
->wow64_context
.ContextFlags
= 0;
1752 /* Single step by setting t bit. */
1753 struct regcache
*regcache
= get_current_regcache ();
1754 struct gdbarch
*gdbarch
= regcache
->arch ();
1755 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1756 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1759 if (th
->context
.ContextFlags
)
1761 if (debug_registers_changed
)
1763 th
->context
.Dr0
= dr
[0];
1764 th
->context
.Dr1
= dr
[1];
1765 th
->context
.Dr2
= dr
[2];
1766 th
->context
.Dr3
= dr
[3];
1767 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1768 th
->context
.Dr7
= dr
[7];
1770 CHECK (SetThreadContext (th
->h
, &th
->context
));
1771 th
->context
.ContextFlags
= 0;
1776 /* Allow continuing with the same signal that interrupted us.
1777 Otherwise complain. */
1780 windows_continue (continue_status
, -1, 0);
1782 windows_continue (continue_status
, ptid
.lwp (), 0);
1785 /* Ctrl-C handler used when the inferior is not run in the same console. The
1786 handler is in charge of interrupting the inferior using DebugBreakProcess.
1787 Note that this function is not available prior to Windows XP. In this case
1788 we emit a warning. */
1790 ctrl_c_handler (DWORD event_type
)
1792 const int attach_flag
= current_inferior ()->attach_flag
;
1794 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1795 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1798 /* If the inferior and the debugger share the same console, do nothing as
1799 the inferior has also received the Ctrl-C event. */
1800 if (!new_console
&& !attach_flag
)
1803 if (!DebugBreakProcess (current_process_handle
))
1804 warning (_("Could not interrupt program. "
1805 "Press Ctrl-c in the program console."));
1807 /* Return true to tell that Ctrl-C has been handled. */
1811 /* A wrapper for WaitForDebugEvent that sets "last_wait_event"
1814 wait_for_debug_event (DEBUG_EVENT
*event
, DWORD timeout
)
1816 BOOL result
= WaitForDebugEvent (event
, timeout
);
1818 last_wait_event
= *event
;
1822 /* Get the next event from the child. Returns a non-zero thread id if the event
1823 requires handling by WFI (or whatever). */
1826 windows_nat_target::get_windows_debug_event (int pid
,
1827 struct target_waitstatus
*ourstatus
)
1830 DWORD continue_status
, event_code
;
1831 windows_thread_info
*th
;
1832 static windows_thread_info
dummy_thread_info (0, 0, 0);
1833 DWORD thread_id
= 0;
1835 /* If there is a relevant pending stop, report it now. See the
1836 comment by the definition of "pending_stops" for details on why
1838 for (auto iter
= pending_stops
.begin ();
1839 iter
!= pending_stops
.end ();
1842 if (desired_stop_thread_id
== -1
1843 || desired_stop_thread_id
== iter
->thread_id
)
1845 thread_id
= iter
->thread_id
;
1846 *ourstatus
= iter
->status
;
1847 current_event
= iter
->event
;
1849 inferior_ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1850 current_thread
= thread_rec (thread_id
, INVALIDATE_CONTEXT
);
1851 current_thread
->reload_context
= 1;
1853 DEBUG_EVENTS (("get_windows_debug_event - "
1854 "pending stop found in 0x%x (desired=0x%x)\n",
1855 thread_id
, desired_stop_thread_id
));
1857 pending_stops
.erase (iter
);
1862 last_sig
= GDB_SIGNAL_0
;
1864 if (!(debug_event
= wait_for_debug_event (¤t_event
, 1000)))
1868 continue_status
= DBG_CONTINUE
;
1870 event_code
= current_event
.dwDebugEventCode
;
1871 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1873 have_saved_context
= 0;
1877 case CREATE_THREAD_DEBUG_EVENT
:
1878 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1879 (unsigned) current_event
.dwProcessId
,
1880 (unsigned) current_event
.dwThreadId
,
1881 "CREATE_THREAD_DEBUG_EVENT"));
1882 if (saw_create
!= 1)
1884 inferior
*inf
= find_inferior_pid (this, current_event
.dwProcessId
);
1885 if (!saw_create
&& inf
->attach_flag
)
1887 /* Kludge around a Windows bug where first event is a create
1888 thread event. Caused when attached process does not have
1890 thread_id
= fake_create_process ();
1896 /* Record the existence of this thread. */
1897 thread_id
= current_event
.dwThreadId
;
1898 th
= windows_add_thread
1899 (ptid_t (current_event
.dwProcessId
, current_event
.dwThreadId
, 0),
1900 current_event
.u
.CreateThread
.hThread
,
1901 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1902 false /* main_thread_p */);
1906 case EXIT_THREAD_DEBUG_EVENT
:
1907 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1908 (unsigned) current_event
.dwProcessId
,
1909 (unsigned) current_event
.dwThreadId
,
1910 "EXIT_THREAD_DEBUG_EVENT"));
1911 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1912 current_event
.dwThreadId
, 0),
1913 current_event
.u
.ExitThread
.dwExitCode
,
1914 false /* main_thread_p */);
1915 th
= &dummy_thread_info
;
1918 case CREATE_PROCESS_DEBUG_EVENT
:
1919 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1920 (unsigned) current_event
.dwProcessId
,
1921 (unsigned) current_event
.dwThreadId
,
1922 "CREATE_PROCESS_DEBUG_EVENT"));
1923 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1924 if (++saw_create
!= 1)
1927 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1928 /* Add the main thread. */
1929 th
= windows_add_thread
1930 (ptid_t (current_event
.dwProcessId
,
1931 current_event
.dwThreadId
, 0),
1932 current_event
.u
.CreateProcessInfo
.hThread
,
1933 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
,
1934 true /* main_thread_p */);
1935 thread_id
= current_event
.dwThreadId
;
1938 case EXIT_PROCESS_DEBUG_EVENT
:
1939 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1940 (unsigned) current_event
.dwProcessId
,
1941 (unsigned) current_event
.dwThreadId
,
1942 "EXIT_PROCESS_DEBUG_EVENT"));
1943 if (!windows_initialization_done
)
1945 target_terminal::ours ();
1946 target_mourn_inferior (inferior_ptid
);
1947 error (_("During startup program exited with code 0x%x."),
1948 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1950 else if (saw_create
== 1)
1952 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1953 current_event
.dwThreadId
, 0),
1954 0, true /* main_thread_p */);
1955 DWORD exit_status
= current_event
.u
.ExitProcess
.dwExitCode
;
1956 /* If the exit status looks like a fatal exception, but we
1957 don't recognize the exception's code, make the original
1958 exit status value available, to avoid losing
1961 = WIFSIGNALED (exit_status
) ? WTERMSIG (exit_status
) : -1;
1962 if (exit_signal
== -1)
1964 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1965 ourstatus
->value
.integer
= exit_status
;
1969 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1970 ourstatus
->value
.sig
= gdb_signal_from_host (exit_signal
);
1972 thread_id
= current_event
.dwThreadId
;
1976 case LOAD_DLL_DEBUG_EVENT
:
1977 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1978 (unsigned) current_event
.dwProcessId
,
1979 (unsigned) current_event
.dwThreadId
,
1980 "LOAD_DLL_DEBUG_EVENT"));
1981 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1982 if (saw_create
!= 1 || ! windows_initialization_done
)
1984 catch_errors (handle_load_dll
);
1985 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1986 ourstatus
->value
.integer
= 0;
1987 thread_id
= current_event
.dwThreadId
;
1990 case UNLOAD_DLL_DEBUG_EVENT
:
1991 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1992 (unsigned) current_event
.dwProcessId
,
1993 (unsigned) current_event
.dwThreadId
,
1994 "UNLOAD_DLL_DEBUG_EVENT"));
1995 if (saw_create
!= 1 || ! windows_initialization_done
)
1997 catch_errors (handle_unload_dll
);
1998 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1999 ourstatus
->value
.integer
= 0;
2000 thread_id
= current_event
.dwThreadId
;
2003 case EXCEPTION_DEBUG_EVENT
:
2004 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
2005 (unsigned) current_event
.dwProcessId
,
2006 (unsigned) current_event
.dwThreadId
,
2007 "EXCEPTION_DEBUG_EVENT"));
2008 if (saw_create
!= 1)
2010 switch (handle_exception (ourstatus
))
2012 case HANDLE_EXCEPTION_UNHANDLED
:
2014 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
2016 case HANDLE_EXCEPTION_HANDLED
:
2017 thread_id
= current_event
.dwThreadId
;
2019 case HANDLE_EXCEPTION_IGNORED
:
2020 continue_status
= DBG_CONTINUE
;
2025 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
2026 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
2027 (unsigned) current_event
.dwProcessId
,
2028 (unsigned) current_event
.dwThreadId
,
2029 "OUTPUT_DEBUG_STRING_EVENT"));
2030 if (saw_create
!= 1)
2032 thread_id
= handle_output_debug_string (ourstatus
);
2036 if (saw_create
!= 1)
2038 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
2039 (unsigned) current_event
.dwProcessId
,
2040 (unsigned) current_event
.dwThreadId
);
2041 printf_unfiltered (" unknown event code %u\n",
2042 (unsigned) current_event
.dwDebugEventCode
);
2046 if (!thread_id
|| saw_create
!= 1)
2048 CHECK (windows_continue (continue_status
, desired_stop_thread_id
, 0));
2050 else if (desired_stop_thread_id
!= -1 && desired_stop_thread_id
!= thread_id
)
2052 /* Pending stop. See the comment by the definition of
2053 "pending_stops" for details on why this is needed. */
2054 DEBUG_EVENTS (("get_windows_debug_event - "
2055 "unexpected stop in 0x%x (expecting 0x%x)\n",
2056 thread_id
, desired_stop_thread_id
));
2058 if (current_event
.dwDebugEventCode
== EXCEPTION_DEBUG_EVENT
2059 && (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
2060 == EXCEPTION_BREAKPOINT
)
2061 && windows_initialization_done
)
2063 th
= thread_rec (thread_id
, INVALIDATE_CONTEXT
);
2064 th
->stopped_at_software_breakpoint
= true;
2066 pending_stops
.push_back ({thread_id
, *ourstatus
, current_event
});
2068 CHECK (windows_continue (continue_status
, desired_stop_thread_id
, 0));
2072 inferior_ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
2073 current_thread
= th
;
2074 if (!current_thread
)
2075 current_thread
= thread_rec (thread_id
, INVALIDATE_CONTEXT
);
2082 /* Wait for interesting events to occur in the target process. */
2084 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
2089 /* We loop when we get a non-standard exception rather than return
2090 with a SPURIOUS because resume can try and step or modify things,
2091 which needs a current_thread->h. But some of these exceptions mark
2092 the birth or death of threads, which mean that the current thread
2093 isn't necessarily what you think it is. */
2099 /* If the user presses Ctrl-c while the debugger is waiting
2100 for an event, he expects the debugger to interrupt his program
2101 and to get the prompt back. There are two possible situations:
2103 - The debugger and the program do not share the console, in
2104 which case the Ctrl-c event only reached the debugger.
2105 In that case, the ctrl_c handler will take care of interrupting
2106 the inferior. Note that this case is working starting with
2107 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
2110 - The debugger and the program share the same console, in which
2111 case both debugger and inferior will receive the Ctrl-c event.
2112 In that case the ctrl_c handler will ignore the event, as the
2113 Ctrl-c event generated inside the inferior will trigger the
2114 expected debug event.
2116 FIXME: brobecker/2008-05-20: If the inferior receives the
2117 signal first and the delay until GDB receives that signal
2118 is sufficiently long, GDB can sometimes receive the SIGINT
2119 after we have unblocked the CTRL+C handler. This would
2120 lead to the debugger stopping prematurely while handling
2121 the new-thread event that comes with the handling of the SIGINT
2122 inside the inferior, and then stop again immediately when
2123 the user tries to resume the execution in the inferior.
2124 This is a classic race that we should try to fix one day. */
2125 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
2126 retval
= get_windows_debug_event (pid
, ourstatus
);
2127 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
2131 ptid_t result
= ptid_t (current_event
.dwProcessId
, retval
, 0);
2133 if (current_thread
!= nullptr)
2135 current_thread
->stopped_at_software_breakpoint
= false;
2136 if (current_event
.dwDebugEventCode
== EXCEPTION_DEBUG_EVENT
2137 && (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
2138 == EXCEPTION_BREAKPOINT
)
2139 && windows_initialization_done
)
2140 current_thread
->stopped_at_software_breakpoint
= true;
2149 if (deprecated_ui_loop_hook
!= NULL
)
2150 detach
= deprecated_ui_loop_hook (0);
2158 /* Iterate over all DLLs currently mapped by our inferior, and
2159 add them to our list of solibs. */
2162 windows_add_all_dlls (void)
2164 HMODULE dummy_hmodule
;
2172 if (EnumProcessModulesEx (current_process_handle
, &dummy_hmodule
,
2173 sizeof (HMODULE
), &cb_needed
,
2174 LIST_MODULES_32BIT
) == 0)
2180 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
2181 sizeof (HMODULE
), &cb_needed
) == 0)
2188 hmodules
= (HMODULE
*) alloca (cb_needed
);
2192 if (EnumProcessModulesEx (current_process_handle
, hmodules
,
2193 cb_needed
, &cb_needed
,
2194 LIST_MODULES_32BIT
) == 0)
2200 if (EnumProcessModules (current_process_handle
, hmodules
,
2201 cb_needed
, &cb_needed
) == 0)
2205 char system_dir
[__PMAX
];
2206 char syswow_dir
[__PMAX
];
2207 size_t system_dir_len
= 0;
2208 bool convert_syswow_dir
= false;
2213 /* This fails on 32bit Windows because it has no SysWOW64 directory,
2214 and in this case a path conversion isn't necessary. */
2215 UINT len
= GetSystemWow64DirectoryA (syswow_dir
, sizeof (syswow_dir
));
2218 /* Check that we have passed a large enough buffer. */
2219 gdb_assert (len
< sizeof (syswow_dir
));
2221 len
= GetSystemDirectoryA (system_dir
, sizeof (system_dir
));
2223 gdb_assert (len
!= 0);
2224 /* Check that we have passed a large enough buffer. */
2225 gdb_assert (len
< sizeof (system_dir
));
2227 strcat (system_dir
, "\\");
2228 strcat (syswow_dir
, "\\");
2229 system_dir_len
= strlen (system_dir
);
2231 convert_syswow_dir
= true;
2235 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
2239 wchar_t dll_name
[__PMAX
];
2240 char dll_name_mb
[__PMAX
];
2242 char dll_name
[__PMAX
];
2245 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
2246 &mi
, sizeof (mi
)) == 0)
2248 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
2249 dll_name
, sizeof (dll_name
)) == 0)
2252 wcstombs (dll_name_mb
, dll_name
, __PMAX
);
2257 /* Convert the DLL path of 32bit processes returned by
2258 GetModuleFileNameEx from the 64bit system directory to the
2259 32bit syswow64 directory if necessary. */
2260 std::string syswow_dll_path
;
2261 if (convert_syswow_dir
2262 && strncasecmp (name
, system_dir
, system_dir_len
) == 0
2263 && strchr (name
+ system_dir_len
, '\\') == nullptr)
2265 syswow_dll_path
= syswow_dir
;
2266 syswow_dll_path
+= name
+ system_dir_len
;
2267 name
= syswow_dll_path
.c_str();
2270 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
2271 solib_end
= solib_end
->next
;
2276 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
2279 struct inferior
*inf
;
2281 last_sig
= GDB_SIGNAL_0
;
2283 exception_count
= 0;
2284 open_process_used
= 0;
2285 debug_registers_changed
= 0;
2286 debug_registers_used
= 0;
2287 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
2290 cygwin_load_start
= cygwin_load_end
= 0;
2292 current_event
.dwProcessId
= pid
;
2293 memset (¤t_event
, 0, sizeof (current_event
));
2294 if (!target_is_pushed (ops
))
2296 disable_breakpoints_in_shlibs ();
2297 windows_clear_solib ();
2298 clear_proceed_status (0);
2299 init_wait_for_inferior ();
2302 ignore_first_breakpoint
= !attaching
&& wow64_process
;
2306 windows_set_context_register_offsets (amd64_mappings
);
2307 windows_set_segment_register_p (amd64_windows_segment_register_p
);
2312 windows_set_context_register_offsets (i386_mappings
);
2313 windows_set_segment_register_p (i386_windows_segment_register_p
);
2316 inf
= current_inferior ();
2317 inferior_appeared (inf
, pid
);
2318 inf
->attach_flag
= attaching
;
2320 /* Make the new process the current inferior, so terminal handling
2321 can rely on it. When attaching, we don't know about any thread
2322 id here, but that's OK --- nothing should be referencing the
2323 current thread until we report an event out of windows_wait. */
2324 inferior_ptid
= ptid_t (pid
);
2326 target_terminal::init ();
2327 target_terminal::inferior ();
2329 windows_initialization_done
= 0;
2333 struct target_waitstatus status
;
2335 ops
->wait (minus_one_ptid
, &status
, 0);
2337 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
2339 if (status
.kind
!= TARGET_WAITKIND_LOADED
2340 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
2343 ops
->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
2346 /* Now that the inferior has been started and all DLLs have been mapped,
2347 we can iterate over all DLLs and load them in.
2349 We avoid doing it any earlier because, on certain versions of Windows,
2350 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
2351 we have seen on Windows 8.1 that the ntdll.dll load event does not
2352 include the DLL name, preventing us from creating an associated SO.
2353 A possible explanation is that ntdll.dll might be mapped before
2354 the SO info gets created by the Windows system -- ntdll.dll is
2355 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
2356 do not seem to suffer from that problem.
2358 Rather than try to work around this sort of issue, it is much
2359 simpler to just ignore DLL load/unload events during the startup
2360 phase, and then process them all in one batch now. */
2361 windows_add_all_dlls ();
2363 windows_initialization_done
= 1;
2367 /* Try to set or remove a user privilege to the current process. Return -1
2368 if that fails, the previous setting of that privilege otherwise.
2370 This code is copied from the Cygwin source code and rearranged to allow
2371 dynamically loading of the needed symbols from advapi32 which is only
2372 available on NT/2K/XP. */
2374 set_process_privilege (const char *privilege
, BOOL enable
)
2376 HANDLE token_hdl
= NULL
;
2378 TOKEN_PRIVILEGES new_priv
, orig_priv
;
2382 if (!OpenProcessToken (GetCurrentProcess (),
2383 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
2387 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
2390 new_priv
.PrivilegeCount
= 1;
2391 new_priv
.Privileges
[0].Luid
= restore_priv
;
2392 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
2394 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
2395 sizeof orig_priv
, &orig_priv
, &size
))
2398 /* Disabled, otherwise every `attach' in an unprivileged user session
2399 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
2400 windows_attach(). */
2401 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
2402 be enabled. GetLastError () returns an correct error code, though. */
2403 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
2407 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
2411 CloseHandle (token_hdl
);
2416 /* Attach to process PID, then initialize for debugging it. */
2419 windows_nat_target::attach (const char *args
, int from_tty
)
2424 pid
= parse_pid_to_attach (args
);
2426 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
2428 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
2429 printf_unfiltered ("This can cause attach to "
2430 "fail on Windows NT/2K/XP\n");
2433 windows_init_thread_list ();
2434 ok
= DebugActiveProcess (pid
);
2440 /* Try fall back to Cygwin pid. */
2441 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
2444 ok
= DebugActiveProcess (pid
);
2449 error (_("Can't attach to process %u (error %u)"),
2450 (unsigned) pid
, (unsigned) GetLastError ());
2452 DebugSetProcessKillOnExit (FALSE
);
2456 const char *exec_file
= get_exec_file (0);
2459 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
2460 target_pid_to_str (ptid_t (pid
)).c_str ());
2462 printf_unfiltered ("Attaching to %s\n",
2463 target_pid_to_str (ptid_t (pid
)).c_str ());
2467 HANDLE h
= OpenProcess (PROCESS_QUERY_INFORMATION
, FALSE
, pid
);
2471 if (IsWow64Process (h
, &wow64
))
2472 wow64_process
= wow64
;
2477 do_initial_windows_stuff (this, pid
, 1);
2478 target_terminal::ours ();
2482 windows_nat_target::detach (inferior
*inf
, int from_tty
)
2486 ptid_t ptid
= minus_one_ptid
;
2487 resume (ptid
, 0, GDB_SIGNAL_0
);
2489 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
2491 error (_("Can't detach process %u (error %u)"),
2492 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
2495 DebugSetProcessKillOnExit (FALSE
);
2497 if (detached
&& from_tty
)
2499 const char *exec_file
= get_exec_file (0);
2502 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
2503 (unsigned) current_event
.dwProcessId
);
2506 x86_cleanup_dregs ();
2507 inferior_ptid
= null_ptid
;
2508 detach_inferior (inf
);
2510 maybe_unpush_target ();
2513 /* Try to determine the executable filename.
2515 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2517 Upon success, the filename is stored inside EXE_NAME_RET, and
2518 this function returns nonzero.
2520 Otherwise, this function returns zero and the contents of
2521 EXE_NAME_RET is undefined. */
2524 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2534 if (!EnumProcessModulesEx (current_process_handle
, &dh_buf
,
2535 sizeof (HMODULE
), &cbNeeded
,
2536 LIST_MODULES_32BIT
) || !cbNeeded
)
2542 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2543 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2547 /* We know the executable is always first in the list of modules,
2548 which we just fetched. So no need to fetch more. */
2552 /* Cygwin prefers that the path be in /x/y/z format, so extract
2553 the filename into a temporary buffer first, and then convert it
2554 to POSIX format into the destination buffer. */
2555 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2557 len
= GetModuleFileNameEx (current_process_handle
,
2558 dh_buf
, pathbuf
, exe_name_max_len
);
2560 error (_("Error getting executable filename: %u."),
2561 (unsigned) GetLastError ());
2562 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2563 exe_name_max_len
) < 0)
2564 error (_("Error converting executable filename to POSIX: %d."), errno
);
2567 len
= GetModuleFileNameEx (current_process_handle
,
2568 dh_buf
, exe_name_ret
, exe_name_max_len
);
2570 error (_("Error getting executable filename: %u."),
2571 (unsigned) GetLastError ());
2574 return 1; /* success */
2577 /* The pid_to_exec_file target_ops method for this platform. */
2580 windows_nat_target::pid_to_exec_file (int pid
)
2582 static char path
[__PMAX
];
2584 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2586 char procexe
[sizeof ("/proc/4294967295/exe")];
2588 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2589 nchars
= readlink (procexe
, path
, sizeof(path
));
2590 if (nchars
> 0 && nchars
< sizeof (path
))
2592 path
[nchars
] = '\0'; /* Got it */
2597 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2598 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2599 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2605 /* Print status information about what we're accessing. */
2608 windows_nat_target::files_info ()
2610 struct inferior
*inf
= current_inferior ();
2612 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2613 inf
->attach_flag
? "attached" : "child",
2614 target_pid_to_str (inferior_ptid
).c_str ());
2617 /* Modify CreateProcess parameters for use of a new separate console.
2619 *FLAGS: DWORD parameter for general process creation flags.
2620 *SI: STARTUPINFO structure, for which the console window size and
2621 console buffer size is filled in if GDB is running in a console.
2622 to create the new console.
2623 The size of the used font is not available on all versions of
2624 Windows OS. Furthermore, the current font might not be the default
2625 font, but this is still better than before.
2626 If the windows and buffer sizes are computed,
2627 SI->DWFLAGS is changed so that this information is used
2628 by CreateProcess function. */
2631 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2633 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2634 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2636 if (hconsole
!= INVALID_HANDLE_VALUE
)
2638 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2640 CONSOLE_FONT_INFO cfi
;
2642 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2643 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2644 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2645 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2646 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2648 si
->dwXSize
*= font_size
.X
;
2652 si
->dwYSize
*= font_size
.Y
;
2655 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2656 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2657 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2659 *flags
|= CREATE_NEW_CONSOLE
;
2663 /* Function called by qsort to sort environment strings. */
2666 envvar_cmp (const void *a
, const void *b
)
2668 const char **p
= (const char **) a
;
2669 const char **q
= (const char **) b
;
2670 return strcasecmp (*p
, *q
);
2676 clear_win32_environment (char **env
)
2680 wchar_t *copy
= NULL
, *equalpos
;
2682 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2684 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2685 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2686 mbstowcs (copy
, env
[i
], len
);
2687 equalpos
= wcschr (copy
, L
'=');
2690 SetEnvironmentVariableW (copy
, NULL
);
2698 /* Redirection of inferior I/O streams for native MS-Windows programs.
2699 Unlike on Unix, where this is handled by invoking the inferior via
2700 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2702 The official documentation of the cmd.exe redirection features is here:
2704 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2706 (That page talks about Windows XP, but there's no newer
2707 documentation, so we assume later versions of cmd.exe didn't change
2710 Caveat: the documentation on that page seems to include a few lies.
2711 For example, it describes strange constructs 1<&2 and 2<&1, which
2712 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2713 think the cmd.exe parser of the redirection symbols simply doesn't
2714 care about the < vs > distinction in these cases. Therefore, the
2715 supported features are explicitly documented below.
2717 The emulation below aims at supporting all the valid use cases
2718 supported by cmd.exe, which include:
2720 < FILE redirect standard input from FILE
2721 0< FILE redirect standard input from FILE
2722 <&N redirect standard input from file descriptor N
2723 0<&N redirect standard input from file descriptor N
2724 > FILE redirect standard output to FILE
2725 >> FILE append standard output to FILE
2726 1>> FILE append standard output to FILE
2727 >&N redirect standard output to file descriptor N
2728 1>&N redirect standard output to file descriptor N
2729 >>&N append standard output to file descriptor N
2730 1>>&N append standard output to file descriptor N
2731 2> FILE redirect standard error to FILE
2732 2>> FILE append standard error to FILE
2733 2>&N redirect standard error to file descriptor N
2734 2>>&N append standard error to file descriptor N
2736 Note that using N > 2 in the above construct is supported, but
2737 requires that the corresponding file descriptor be open by some
2738 means elsewhere or outside GDB. Also note that using ">&0" or
2739 "<&2" will generally fail, because the file descriptor redirected
2740 from is normally open in an incompatible mode (e.g., FD 0 is open
2741 for reading only). IOW, use of such tricks is not recommended;
2742 you are on your own.
2744 We do NOT support redirection of file descriptors above 2, as in
2745 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2746 that needs special handling in the startup code that MinGW
2747 doesn't have). Pipes are also not supported.
2749 As for invalid use cases, where the redirection contains some
2750 error, the emulation below will detect that and produce some
2751 error and/or failure. But the behavior in those cases is not
2752 bug-for-bug compatible with what cmd.exe does in those cases.
2753 That's because what cmd.exe does then is not well defined, and
2754 seems to be a side effect of the cmd.exe parsing of the command
2755 line more than anything else. For example, try redirecting to an
2756 invalid file name, as in "> foo:bar".
2758 There are also minor syntactic deviations from what cmd.exe does
2759 in some corner cases. For example, it doesn't support the likes
2760 of "> &foo" to mean redirect to file named literally "&foo"; we
2761 do support that here, because that, too, sounds like some issue
2762 with the cmd.exe parser. Another nicety is that we support
2763 redirection targets that use file names with forward slashes,
2764 something cmd.exe doesn't -- this comes in handy since GDB
2765 file-name completion can be used when typing the command line for
2768 /* Support routines for redirecting standard handles of the inferior. */
2770 /* Parse a single redirection spec, open/duplicate the specified
2771 file/fd, and assign the appropriate value to one of the 3 standard
2772 file descriptors. */
2774 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2776 int *fd
, ref_fd
= -2;
2778 const char *fname
= redir_string
+ 1;
2779 int rc
= *redir_string
;
2794 fd
= (rc
== '2') ? err
: out
;
2795 mode
= O_WRONLY
| O_CREAT
;
2808 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2810 /* A reference to a file descriptor. */
2812 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2813 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2815 /* Don't allow redirection when open modes are incompatible. */
2816 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2817 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2824 else if (ref_fd
== 1)
2826 else if (ref_fd
== 2)
2836 fname
++; /* skip the separator space */
2837 /* If the descriptor is already open, close it. This allows
2838 multiple specs of redirections for the same stream, which is
2839 somewhat nonsensical, but still valid and supported by cmd.exe.
2840 (But cmd.exe only opens a single file in this case, the one
2841 specified by the last redirection spec on the command line.) */
2846 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2850 else if (ref_fd
== -1)
2851 *fd
= -1; /* reset to default destination */
2854 *fd
= _dup (ref_fd
);
2858 /* _open just sets a flag for O_APPEND, which won't be passed to the
2859 inferior, so we need to actually move the file pointer. */
2860 if ((mode
& O_APPEND
) != 0)
2861 _lseek (*fd
, 0L, SEEK_END
);
2865 /* Canonicalize a single redirection spec and set up the corresponding
2866 file descriptor as specified. */
2868 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2870 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2872 const char *start
= s
;
2875 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2876 if ((*start
== '>' || *start
== '1' || *start
== '2')
2880 if (*s
== '>' && *start
!= '>')
2883 else if (*start
== '0' && *s
== '<')
2885 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2888 while (isspace (*s
)) /* skip whitespace before file name */
2890 *d
++ = ' '; /* separate file name with a single space */
2893 /* Copy the file name. */
2896 /* Remove quoting characters from the file name in buf[]. */
2897 if (*s
== '"') /* could support '..' quoting here */
2901 else if (*s
== quote
)
2909 else if (*s
== '\\')
2911 if (s
[1] == '"') /* could support '..' here */
2915 else if (isspace (*s
) && !quote
)
2919 if (d
- buf
>= sizeof (buf
) - 1)
2921 errno
= ENAMETOOLONG
;
2927 /* Windows doesn't allow redirection characters in file names, so we
2928 can bail out early if they use them, or if there's no target file
2929 name after the redirection symbol. */
2930 if (d
[-1] == '>' || d
[-1] == '<')
2935 if (redir_open (buf
, inp
, out
, err
) == 0)
2940 /* Parse the command line for redirection specs and prepare the file
2941 descriptors for the 3 standard streams accordingly. */
2943 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2944 int *inp
, int *out
, int *err
)
2946 const char *s
= cmd_orig
;
2949 bool retval
= false;
2951 while (isspace (*s
))
2956 if (*s
== '"') /* could also support '..' quoting here */
2960 else if (*s
== quote
)
2963 else if (*s
== '\\')
2965 if (s
[1] == '"') /* escaped quote char */
2970 /* Process a single redirection candidate. */
2971 if (*s
== '<' || *s
== '>'
2972 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2973 || (*s
== '0' && s
[1] == '<'))
2975 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2989 #endif /* !__CYGWIN__ */
2991 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2992 EXEC_FILE is the file to run.
2993 ALLARGS is a string containing the arguments to the program.
2994 ENV is the environment vector to pass. Errors reported with error(). */
2997 windows_nat_target::create_inferior (const char *exec_file
,
2998 const std::string
&origallargs
,
2999 char **in_env
, int from_tty
)
3003 cygwin_buf_t real_path
[__PMAX
];
3004 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
3005 cygwin_buf_t infcwd
[__PMAX
];
3007 cygwin_buf_t
*toexec
;
3008 cygwin_buf_t
*cygallargs
;
3010 char **old_env
= NULL
;
3014 int ostdin
, ostdout
, ostderr
;
3015 #else /* !__CYGWIN__ */
3016 char shell
[__PMAX
]; /* Path to shell */
3018 char *args
, *allargs_copy
;
3019 size_t args_len
, allargs_len
;
3020 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
3021 HANDLE tty
= INVALID_HANDLE_VALUE
;
3022 bool redirected
= false;
3029 #endif /* !__CYGWIN__ */
3030 const char *allargs
= origallargs
.c_str ();
3031 PROCESS_INFORMATION pi
;
3034 const char *inferior_io_terminal
= get_inferior_io_terminal ();
3037 error (_("No executable specified, use `target exec'."));
3039 const char *inferior_cwd
= get_inferior_cwd ();
3040 std::string expanded_infcwd
;
3041 if (inferior_cwd
!= NULL
)
3043 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
3044 /* Mirror slashes on inferior's cwd. */
3045 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
3047 inferior_cwd
= expanded_infcwd
.c_str ();
3050 memset (&si
, 0, sizeof (si
));
3051 si
.cb
= sizeof (si
);
3054 flags
|= CREATE_NEW_PROCESS_GROUP
;
3057 windows_set_console_info (&si
, &flags
);
3062 flags
|= DEBUG_ONLY_THIS_PROCESS
;
3063 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
3064 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
3065 error (_("Error starting executable: %d"), errno
);
3068 len
= mbstowcs (NULL
, allargs
, 0) + 1;
3069 if (len
== (size_t) -1)
3070 error (_("Error starting executable: %d"), errno
);
3071 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
3072 mbstowcs (cygallargs
, allargs
, len
);
3073 #else /* !__USEWIDE */
3074 cygallargs
= allargs
;
3080 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
3081 error (_("Error starting executable via shell: %d"), errno
);
3083 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
3084 + mbstowcs (NULL
, allargs
, 0) + 2;
3085 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
3086 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
3087 #else /* !__USEWIDE */
3088 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
3089 + strlen (allargs
) + 2);
3090 cygallargs
= (char *) alloca (len
);
3091 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
3092 #endif /* __USEWIDE */
3094 flags
|= DEBUG_PROCESS
;
3097 if (inferior_cwd
!= NULL
3098 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
3099 infcwd
, strlen (inferior_cwd
)) < 0)
3100 error (_("Error converting inferior cwd: %d"), errno
);
3103 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
3104 * sizeof (wchar_t));
3105 wcscpy (args
, toexec
);
3106 wcscat (args
, L
" ");
3107 wcscat (args
, cygallargs
);
3108 #else /* !__USEWIDE */
3109 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
3110 strcpy (args
, toexec
);
3112 strcat (args
, cygallargs
);
3113 #endif /* !__USEWIDE */
3115 #ifdef CW_CVT_ENV_TO_WINENV
3116 /* First try to create a direct Win32 copy of the POSIX environment. */
3117 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
3118 if (w32_env
!= (PWCHAR
) -1)
3119 flags
|= CREATE_UNICODE_ENVIRONMENT
;
3121 /* If that fails, fall back to old method tweaking GDB's environment. */
3122 #endif /* CW_CVT_ENV_TO_WINENV */
3124 /* Reset all Win32 environment variables to avoid leftover on next run. */
3125 clear_win32_environment (environ
);
3126 /* Prepare the environment vars for CreateProcess. */
3129 cygwin_internal (CW_SYNC_WINENV
);
3133 if (!inferior_io_terminal
)
3134 tty
= ostdin
= ostdout
= ostderr
= -1;
3137 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
3140 print_sys_errmsg (inferior_io_terminal
, errno
);
3141 ostdin
= ostdout
= ostderr
= -1;
3154 windows_init_thread_list ();
3155 ret
= CreateProcess (0,
3156 args
, /* command line */
3157 NULL
, /* Security */
3159 TRUE
, /* inherit handles */
3160 flags
, /* start flags */
3161 w32_env
, /* environment */
3162 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
3167 /* Just free the Win32 environment, if it could be created. */
3171 /* Reset all environment variables to avoid leftover on next run. */
3172 clear_win32_environment (in_env
);
3173 /* Restore normal GDB environment variables. */
3175 cygwin_internal (CW_SYNC_WINENV
);
3188 #else /* !__CYGWIN__ */
3189 allargs_len
= strlen (allargs
);
3190 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
3191 if (strpbrk (allargs_copy
, "<>") != NULL
)
3196 redirect_inferior_handles (allargs
, allargs_copy
,
3197 &fd_inp
, &fd_out
, &fd_err
);
3199 warning (_("Error in redirection: %s."), safe_strerror (errno
));
3202 allargs_len
= strlen (allargs_copy
);
3204 /* If not all the standard streams are redirected by the command
3205 line, use inferior_io_terminal for those which aren't. */
3206 if (inferior_io_terminal
3207 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
3209 SECURITY_ATTRIBUTES sa
;
3210 sa
.nLength
= sizeof(sa
);
3211 sa
.lpSecurityDescriptor
= 0;
3212 sa
.bInheritHandle
= TRUE
;
3213 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
3214 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
3215 if (tty
== INVALID_HANDLE_VALUE
)
3216 warning (_("Warning: Failed to open TTY %s, error %#x."),
3217 inferior_io_terminal
, (unsigned) GetLastError ());
3219 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
3222 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
3223 else if (tty
!= INVALID_HANDLE_VALUE
)
3226 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
3228 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
3229 else if (tty
!= INVALID_HANDLE_VALUE
)
3230 si
.hStdOutput
= tty
;
3232 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
3234 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
3235 else if (tty
!= INVALID_HANDLE_VALUE
)
3238 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
3239 si
.dwFlags
|= STARTF_USESTDHANDLES
;
3243 /* Build the command line, a space-separated list of tokens where
3244 the first token is the name of the module to be executed.
3245 To avoid ambiguities introduced by spaces in the module name,
3247 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
3248 args
= (char *) alloca (args_len
);
3249 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
3251 flags
|= DEBUG_ONLY_THIS_PROCESS
;
3253 /* CreateProcess takes the environment list as a null terminated set of
3254 strings (i.e. two nulls terminate the list). */
3256 /* Get total size for env strings. */
3257 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
3258 envlen
+= strlen (in_env
[i
]) + 1;
3260 envsize
= sizeof (in_env
[0]) * (i
+ 1);
3261 env
= (char **) alloca (envsize
);
3262 memcpy (env
, in_env
, envsize
);
3263 /* Windows programs expect the environment block to be sorted. */
3264 qsort (env
, i
, sizeof (char *), envvar_cmp
);
3266 w32env
= (char *) alloca (envlen
+ 1);
3268 /* Copy env strings into new buffer. */
3269 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
3271 strcpy (temp
, env
[i
]);
3272 temp
+= strlen (temp
) + 1;
3275 /* Final nil string to terminate new env. */
3278 windows_init_thread_list ();
3279 ret
= CreateProcessA (0,
3280 args
, /* command line */
3281 NULL
, /* Security */
3283 TRUE
, /* inherit handles */
3284 flags
, /* start flags */
3285 w32env
, /* environment */
3286 inferior_cwd
, /* current directory */
3289 if (tty
!= INVALID_HANDLE_VALUE
)
3297 #endif /* !__CYGWIN__ */
3300 error (_("Error creating process %s, (error %u)."),
3301 exec_file
, (unsigned) GetLastError ());
3305 if (IsWow64Process (pi
.hProcess
, &wow64
))
3306 wow64_process
= wow64
;
3309 CloseHandle (pi
.hThread
);
3310 CloseHandle (pi
.hProcess
);
3312 if (useshell
&& shell
[0] != '\0')
3317 do_initial_windows_stuff (this, pi
.dwProcessId
, 0);
3319 /* windows_continue (DBG_CONTINUE, -1, 0); */
3323 windows_nat_target::mourn_inferior ()
3325 (void) windows_continue (DBG_CONTINUE
, -1, 0);
3326 x86_cleanup_dregs();
3327 if (open_process_used
)
3329 CHECK (CloseHandle (current_process_handle
));
3330 open_process_used
= 0;
3332 siginfo_er
.ExceptionCode
= 0;
3333 inf_child_target::mourn_inferior ();
3336 /* Send a SIGINT to the process group. This acts just like the user typed a
3337 ^C on the controlling terminal. */
3340 windows_nat_target::interrupt ()
3342 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
3343 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
3344 registers_changed (); /* refresh register state */
3347 /* Helper for windows_xfer_partial that handles memory transfers.
3348 Arguments are like target_xfer_partial. */
3350 static enum target_xfer_status
3351 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3352 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
3356 DWORD lasterror
= 0;
3358 if (writebuf
!= NULL
)
3360 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
3361 pulongest (len
), core_addr_to_string (memaddr
)));
3362 success
= WriteProcessMemory (current_process_handle
,
3363 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
3366 lasterror
= GetLastError ();
3367 FlushInstructionCache (current_process_handle
,
3368 (LPCVOID
) (uintptr_t) memaddr
, len
);
3372 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
3373 pulongest (len
), core_addr_to_string (memaddr
)));
3374 success
= ReadProcessMemory (current_process_handle
,
3375 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
3378 lasterror
= GetLastError ();
3380 *xfered_len
= (ULONGEST
) done
;
3381 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
3382 return TARGET_XFER_OK
;
3384 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
3388 windows_nat_target::kill ()
3390 CHECK (TerminateProcess (current_process_handle
, 0));
3394 if (!windows_continue (DBG_CONTINUE
, -1, 1))
3396 if (!wait_for_debug_event (¤t_event
, INFINITE
))
3398 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
3402 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
3406 windows_nat_target::close ()
3408 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
3409 inferior_ptid
.pid ()));
3412 /* Convert pid to printable format. */
3414 windows_nat_target::pid_to_str (ptid_t ptid
)
3416 if (ptid
.lwp () != 0)
3417 return string_printf ("Thread %d.0x%lx", ptid
.pid (), ptid
.lwp ());
3419 return normal_pid_to_str (ptid
);
3422 static enum target_xfer_status
3423 windows_xfer_shared_libraries (struct target_ops
*ops
,
3424 enum target_object object
, const char *annex
,
3425 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3426 ULONGEST offset
, ULONGEST len
,
3427 ULONGEST
*xfered_len
)
3429 struct obstack obstack
;
3435 return TARGET_XFER_E_IO
;
3437 obstack_init (&obstack
);
3438 obstack_grow_str (&obstack
, "<library-list>\n");
3439 for (so
= solib_start
.next
; so
; so
= so
->next
)
3441 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
3443 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
3444 (uintptr_t) li
->load_addr
,
3446 target_gdbarch (), &obstack
);
3448 obstack_grow_str0 (&obstack
, "</library-list>\n");
3450 buf
= (const char *) obstack_finish (&obstack
);
3451 len_avail
= strlen (buf
);
3452 if (offset
>= len_avail
)
3456 if (len
> len_avail
- offset
)
3457 len
= len_avail
- offset
;
3458 memcpy (readbuf
, buf
+ offset
, len
);
3461 obstack_free (&obstack
, NULL
);
3462 *xfered_len
= (ULONGEST
) len
;
3463 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
3466 /* Helper for windows_nat_target::xfer_partial that handles signal info. */
3468 static enum target_xfer_status
3469 windows_xfer_siginfo (gdb_byte
*readbuf
, ULONGEST offset
, ULONGEST len
,
3470 ULONGEST
*xfered_len
)
3472 char *buf
= (char *) &siginfo_er
;
3473 size_t bufsize
= sizeof (siginfo_er
);
3476 EXCEPTION_RECORD32 er32
;
3479 buf
= (char *) &er32
;
3480 bufsize
= sizeof (er32
);
3482 er32
.ExceptionCode
= siginfo_er
.ExceptionCode
;
3483 er32
.ExceptionFlags
= siginfo_er
.ExceptionFlags
;
3484 er32
.ExceptionRecord
= (uintptr_t) siginfo_er
.ExceptionRecord
;
3485 er32
.ExceptionAddress
= (uintptr_t) siginfo_er
.ExceptionAddress
;
3486 er32
.NumberParameters
= siginfo_er
.NumberParameters
;
3488 for (i
= 0; i
< EXCEPTION_MAXIMUM_PARAMETERS
; i
++)
3489 er32
.ExceptionInformation
[i
] = siginfo_er
.ExceptionInformation
[i
];
3493 if (siginfo_er
.ExceptionCode
== 0)
3494 return TARGET_XFER_E_IO
;
3496 if (readbuf
== nullptr)
3497 return TARGET_XFER_E_IO
;
3499 if (offset
> bufsize
)
3500 return TARGET_XFER_E_IO
;
3502 if (offset
+ len
> bufsize
)
3503 len
= bufsize
- offset
;
3505 memcpy (readbuf
, buf
+ offset
, len
);
3508 return TARGET_XFER_OK
;
3511 enum target_xfer_status
3512 windows_nat_target::xfer_partial (enum target_object object
,
3513 const char *annex
, gdb_byte
*readbuf
,
3514 const gdb_byte
*writebuf
, ULONGEST offset
,
3515 ULONGEST len
, ULONGEST
*xfered_len
)
3519 case TARGET_OBJECT_MEMORY
:
3520 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
3522 case TARGET_OBJECT_LIBRARIES
:
3523 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
3524 writebuf
, offset
, len
, xfered_len
);
3526 case TARGET_OBJECT_SIGNAL_INFO
:
3527 return windows_xfer_siginfo (readbuf
, offset
, len
, xfered_len
);
3530 if (beneath () == NULL
)
3532 /* This can happen when requesting the transfer of unsupported
3533 objects before a program has been started (and therefore
3534 with the current_target having no target beneath). */
3535 return TARGET_XFER_E_IO
;
3537 return beneath ()->xfer_partial (object
, annex
,
3538 readbuf
, writebuf
, offset
, len
,
3543 /* Provide thread local base, i.e. Thread Information Block address.
3544 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
3547 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
3549 windows_thread_info
*th
;
3551 th
= thread_rec (ptid
.lwp (), DONT_INVALIDATE_CONTEXT
);
3556 *addr
= th
->thread_local_base
;
3562 windows_nat_target::get_ada_task_ptid (long lwp
, long thread
)
3564 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
3567 /* Implementation of the to_thread_name method. */
3570 windows_nat_target::thread_name (struct thread_info
*thr
)
3572 return thread_rec (thr
->ptid
.lwp (), DONT_INVALIDATE_CONTEXT
)->name
.get ();
3576 void _initialize_windows_nat ();
3578 _initialize_windows_nat ()
3580 x86_dr_low
.set_control
= cygwin_set_dr7
;
3581 x86_dr_low
.set_addr
= cygwin_set_dr
;
3582 x86_dr_low
.get_addr
= cygwin_get_dr
;
3583 x86_dr_low
.get_status
= cygwin_get_dr6
;
3584 x86_dr_low
.get_control
= cygwin_get_dr7
;
3586 /* x86_dr_low.debug_register_length field is set by
3587 calling x86_set_debug_register_length function
3588 in processor windows specific native file. */
3590 add_inf_child_target (&the_windows_nat_target
);
3593 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3596 add_com ("signal-event", class_run
, signal_event_command
, _("\
3597 Signal a crashed process with event ID, to allow its debugging.\n\
3598 This command is needed in support of setting up GDB as JIT debugger on \
3599 MS-Windows. The command should be invoked from the GDB command line using \
3600 the '-ex' command-line option. The ID of the event that blocks the \
3601 crashed process will be supplied by the Windows JIT debugging mechanism."));
3604 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3605 Set use of shell to start subprocess."), _("\
3606 Show use of shell to start subprocess."), NULL
,
3608 NULL
, /* FIXME: i18n: */
3609 &setlist
, &showlist
);
3611 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3612 &cygwin_exceptions
, _("\
3613 Break when an exception is detected in the Cygwin DLL itself."), _("\
3614 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3616 NULL
, /* FIXME: i18n: */
3617 &setlist
, &showlist
);
3620 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3621 Set creation of new console when creating child process."), _("\
3622 Show creation of new console when creating child process."), NULL
,
3624 NULL
, /* FIXME: i18n: */
3625 &setlist
, &showlist
);
3627 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3628 Set creation of new group when creating child process."), _("\
3629 Show creation of new group when creating child process."), NULL
,
3631 NULL
, /* FIXME: i18n: */
3632 &setlist
, &showlist
);
3634 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3635 Set whether to display execution in child process."), _("\
3636 Show whether to display execution in child process."), NULL
,
3638 NULL
, /* FIXME: i18n: */
3639 &setlist
, &showlist
);
3641 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3642 Set whether to display kernel events in child process."), _("\
3643 Show whether to display kernel events in child process."), NULL
,
3645 NULL
, /* FIXME: i18n: */
3646 &setlist
, &showlist
);
3648 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3649 Set whether to display memory accesses in child process."), _("\
3650 Show whether to display memory accesses in child process."), NULL
,
3652 NULL
, /* FIXME: i18n: */
3653 &setlist
, &showlist
);
3655 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3656 &debug_exceptions
, _("\
3657 Set whether to display kernel exceptions in child process."), _("\
3658 Show whether to display kernel exceptions in child process."), NULL
,
3660 NULL
, /* FIXME: i18n: */
3661 &setlist
, &showlist
);
3663 init_w32_command_list ();
3665 add_cmd ("selector", class_info
, display_selectors
,
3666 _("Display selectors infos."),
3670 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3672 /* Pass the address ADDR to the inferior in the I'th debug register.
3673 Here we just store the address in dr array, the registers will be
3674 actually set up when windows_continue is called. */
3676 cygwin_set_dr (int i
, CORE_ADDR addr
)
3679 internal_error (__FILE__
, __LINE__
,
3680 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3682 debug_registers_changed
= 1;
3683 debug_registers_used
= 1;
3686 /* Pass the value VAL to the inferior in the DR7 debug control
3687 register. Here we just store the address in D_REGS, the watchpoint
3688 will be actually set up in windows_wait. */
3690 cygwin_set_dr7 (unsigned long val
)
3692 dr
[7] = (CORE_ADDR
) val
;
3693 debug_registers_changed
= 1;
3694 debug_registers_used
= 1;
3697 /* Get the value of debug register I from the inferior. */
3700 cygwin_get_dr (int i
)
3705 /* Get the value of the DR6 debug status register from the inferior.
3706 Here we just return the value stored in dr[6]
3707 by the last call to thread_rec for current_event.dwThreadId id. */
3708 static unsigned long
3709 cygwin_get_dr6 (void)
3711 return (unsigned long) dr
[6];
3714 /* Get the value of the DR7 debug status register from the inferior.
3715 Here we just return the value stored in dr[7] by the last call to
3716 thread_rec for current_event.dwThreadId id. */
3718 static unsigned long
3719 cygwin_get_dr7 (void)
3721 return (unsigned long) dr
[7];
3724 /* Determine if the thread referenced by "ptid" is alive
3725 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3726 it means that the thread has died. Otherwise it is assumed to be alive. */
3729 windows_nat_target::thread_alive (ptid_t ptid
)
3733 gdb_assert (ptid
.lwp () != 0);
3736 return (WaitForSingleObject (thread_rec (tid
, DONT_INVALIDATE_CONTEXT
)->h
, 0)
3740 void _initialize_check_for_gdb_ini ();
3742 _initialize_check_for_gdb_ini ()
3745 if (inhibit_gdbinit
)
3748 homedir
= getenv ("HOME");
3752 char *oldini
= (char *) alloca (strlen (homedir
) +
3753 sizeof ("gdb.ini") + 1);
3754 strcpy (oldini
, homedir
);
3755 p
= strchr (oldini
, '\0');
3756 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3758 strcpy (p
, "gdb.ini");
3759 if (access (oldini
, 0) == 0)
3761 int len
= strlen (oldini
);
3762 char *newini
= (char *) alloca (len
+ 2);
3764 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3765 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3766 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3771 /* Define dummy functions which always return error for the rare cases where
3772 these functions could not be found. */
3774 bad_DebugActiveProcessStop (DWORD w
)
3779 bad_DebugBreakProcess (HANDLE w
)
3784 bad_DebugSetProcessKillOnExit (BOOL w
)
3789 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3796 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3802 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3809 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3815 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3821 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3827 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3835 /* Load any functions which may not be available in ancient versions
3838 void _initialize_loadable ();
3840 _initialize_loadable ()
3844 #define GPA(m, func) \
3845 func = (func ## _ftype *) GetProcAddress (m, #func)
3847 hm
= LoadLibrary ("kernel32.dll");
3850 GPA (hm
, DebugActiveProcessStop
);
3851 GPA (hm
, DebugBreakProcess
);
3852 GPA (hm
, DebugSetProcessKillOnExit
);
3853 GPA (hm
, GetConsoleFontSize
);
3854 GPA (hm
, DebugActiveProcessStop
);
3855 GPA (hm
, GetCurrentConsoleFont
);
3857 GPA (hm
, Wow64SuspendThread
);
3858 GPA (hm
, Wow64GetThreadContext
);
3859 GPA (hm
, Wow64SetThreadContext
);
3860 GPA (hm
, Wow64GetThreadSelectorEntry
);
3864 /* Set variables to dummy versions of these processes if the function
3865 wasn't found in kernel32.dll. */
3866 if (!DebugBreakProcess
)
3867 DebugBreakProcess
= bad_DebugBreakProcess
;
3868 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3870 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3871 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3873 if (!GetConsoleFontSize
)
3874 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3875 if (!GetCurrentConsoleFont
)
3876 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3878 /* Load optional functions used for retrieving filename information
3879 associated with the currently debugged process or its dlls. */
3880 hm
= LoadLibrary ("psapi.dll");
3883 GPA (hm
, EnumProcessModules
);
3885 GPA (hm
, EnumProcessModulesEx
);
3887 GPA (hm
, GetModuleInformation
);
3888 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3889 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3892 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3894 /* Set variables to dummy versions of these processes if the function
3895 wasn't found in psapi.dll. */
3896 EnumProcessModules
= bad_EnumProcessModules
;
3897 GetModuleInformation
= bad_GetModuleInformation
;
3898 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3899 /* This will probably fail on Windows 9x/Me. Let the user know
3900 that we're missing some functionality. */
3902 cannot automatically find executable file or library to read symbols.\n\
3903 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3906 hm
= LoadLibrary ("advapi32.dll");
3909 GPA (hm
, OpenProcessToken
);
3910 GPA (hm
, LookupPrivilegeValueA
);
3911 GPA (hm
, AdjustTokenPrivileges
);
3912 /* Only need to set one of these since if OpenProcessToken fails nothing
3914 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3915 || !AdjustTokenPrivileges
)
3916 OpenProcessToken
= bad_OpenProcessToken
;