1 /* Target-vector operations for controlling windows child processes, for GDB.
3 Copyright (C) 1995-2020 Free Software Foundation, Inc.
5 Contributed by Cygnus Solutions, A Red Hat Company.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 /* Originally by Steve Chamberlain, sac@cygnus.com */
25 #include "frame.h" /* required by inferior.h */
31 #include "completer.h"
35 #include <sys/types.h>
42 #include <sys/cygwin.h>
43 #include <cygwin/version.h>
48 #include "filenames.h"
52 #include "gdb_obstack.h"
53 #include "gdbthread.h"
59 #include "xml-support.h"
62 #include "i386-tdep.h"
63 #include "i387-tdep.h"
65 #include "windows-tdep.h"
66 #include "windows-nat.h"
68 #include "complaints.h"
69 #include "inf-child.h"
70 #include "gdbsupport/gdb_tilde_expand.h"
71 #include "gdbsupport/pathstuff.h"
72 #include "gdbsupport/gdb_wait.h"
73 #include "nat/windows-nat.h"
75 #define STATUS_WX86_BREAKPOINT 0x4000001F
76 #define STATUS_WX86_SINGLE_STEP 0x4000001E
78 #define AdjustTokenPrivileges dyn_AdjustTokenPrivileges
79 #define DebugActiveProcessStop dyn_DebugActiveProcessStop
80 #define DebugBreakProcess dyn_DebugBreakProcess
81 #define DebugSetProcessKillOnExit dyn_DebugSetProcessKillOnExit
82 #define EnumProcessModules dyn_EnumProcessModules
83 #define EnumProcessModulesEx dyn_EnumProcessModulesEx
84 #define GetModuleInformation dyn_GetModuleInformation
85 #define LookupPrivilegeValueA dyn_LookupPrivilegeValueA
86 #define OpenProcessToken dyn_OpenProcessToken
87 #define GetConsoleFontSize dyn_GetConsoleFontSize
88 #define GetCurrentConsoleFont dyn_GetCurrentConsoleFont
89 #define Wow64SuspendThread dyn_Wow64SuspendThread
90 #define Wow64GetThreadContext dyn_Wow64GetThreadContext
91 #define Wow64SetThreadContext dyn_Wow64SetThreadContext
92 #define Wow64GetThreadSelectorEntry dyn_Wow64GetThreadSelectorEntry
94 typedef BOOL
WINAPI (AdjustTokenPrivileges_ftype
) (HANDLE
, BOOL
,
96 DWORD
, PTOKEN_PRIVILEGES
,
98 static AdjustTokenPrivileges_ftype
*AdjustTokenPrivileges
;
100 typedef BOOL
WINAPI (DebugActiveProcessStop_ftype
) (DWORD
);
101 static DebugActiveProcessStop_ftype
*DebugActiveProcessStop
;
103 typedef BOOL
WINAPI (DebugBreakProcess_ftype
) (HANDLE
);
104 static DebugBreakProcess_ftype
*DebugBreakProcess
;
106 typedef BOOL
WINAPI (DebugSetProcessKillOnExit_ftype
) (BOOL
);
107 static DebugSetProcessKillOnExit_ftype
*DebugSetProcessKillOnExit
;
109 typedef BOOL
WINAPI (EnumProcessModules_ftype
) (HANDLE
, HMODULE
*, DWORD
,
111 static EnumProcessModules_ftype
*EnumProcessModules
;
114 typedef BOOL
WINAPI (EnumProcessModulesEx_ftype
) (HANDLE
, HMODULE
*, DWORD
,
116 static EnumProcessModulesEx_ftype
*EnumProcessModulesEx
;
119 typedef BOOL
WINAPI (GetModuleInformation_ftype
) (HANDLE
, HMODULE
,
120 LPMODULEINFO
, DWORD
);
121 static GetModuleInformation_ftype
*GetModuleInformation
;
123 typedef BOOL
WINAPI (LookupPrivilegeValueA_ftype
) (LPCSTR
, LPCSTR
, PLUID
);
124 static LookupPrivilegeValueA_ftype
*LookupPrivilegeValueA
;
126 typedef BOOL
WINAPI (OpenProcessToken_ftype
) (HANDLE
, DWORD
, PHANDLE
);
127 static OpenProcessToken_ftype
*OpenProcessToken
;
129 typedef BOOL
WINAPI (GetCurrentConsoleFont_ftype
) (HANDLE
, BOOL
,
130 CONSOLE_FONT_INFO
*);
131 static GetCurrentConsoleFont_ftype
*GetCurrentConsoleFont
;
133 typedef COORD
WINAPI (GetConsoleFontSize_ftype
) (HANDLE
, DWORD
);
134 static GetConsoleFontSize_ftype
*GetConsoleFontSize
;
137 typedef DWORD
WINAPI (Wow64SuspendThread_ftype
) (HANDLE
);
138 static Wow64SuspendThread_ftype
*Wow64SuspendThread
;
140 typedef BOOL
WINAPI (Wow64GetThreadContext_ftype
) (HANDLE
, PWOW64_CONTEXT
);
141 static Wow64GetThreadContext_ftype
*Wow64GetThreadContext
;
143 typedef BOOL
WINAPI (Wow64SetThreadContext_ftype
) (HANDLE
,
144 const WOW64_CONTEXT
*);
145 static Wow64SetThreadContext_ftype
*Wow64SetThreadContext
;
147 typedef BOOL
WINAPI (Wow64GetThreadSelectorEntry_ftype
) (HANDLE
, DWORD
,
149 static Wow64GetThreadSelectorEntry_ftype
*Wow64GetThreadSelectorEntry
;
154 #undef GetModuleFileNameEx
157 # define __PMAX (MAX_PATH + 1)
158 typedef DWORD
WINAPI (GetModuleFileNameEx_ftype
) (HANDLE
, HMODULE
, LPSTR
, DWORD
);
159 static GetModuleFileNameEx_ftype
*GetModuleFileNameEx
;
160 # define STARTUPINFO STARTUPINFOA
161 # define CreateProcess CreateProcessA
162 # define GetModuleFileNameEx_name "GetModuleFileNameExA"
163 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
165 # define __PMAX PATH_MAX
166 /* The starting and ending address of the cygwin1.dll text segment. */
167 static CORE_ADDR cygwin_load_start
;
168 static CORE_ADDR cygwin_load_end
;
170 typedef wchar_t cygwin_buf_t
;
171 typedef DWORD
WINAPI (GetModuleFileNameEx_ftype
) (HANDLE
, HMODULE
,
173 static GetModuleFileNameEx_ftype
*GetModuleFileNameEx
;
174 # define STARTUPINFO STARTUPINFOW
175 # define CreateProcess CreateProcessW
176 # define GetModuleFileNameEx_name "GetModuleFileNameExW"
177 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExW
180 static int have_saved_context
; /* True if we've saved context from a
183 static CONTEXT saved_context
; /* Contains the saved context from a
187 /* If we're not using the old Cygwin header file set, define the
188 following which never should have been in the generic Win32 API
189 headers in the first place since they were our own invention... */
190 #ifndef _GNU_H_WINDOWS_H
193 FLAG_TRACE_BIT
= 0x100,
197 #ifndef CONTEXT_EXTENDED_REGISTERS
198 /* This macro is only defined on ia32. It only makes sense on this target,
199 so define it as zero if not already defined. */
200 #define CONTEXT_EXTENDED_REGISTERS 0
203 #define CONTEXT_DEBUGGER_DR CONTEXT_FULL | CONTEXT_FLOATING_POINT \
204 | CONTEXT_SEGMENTS | CONTEXT_DEBUG_REGISTERS \
205 | CONTEXT_EXTENDED_REGISTERS
207 static uintptr_t dr
[8];
208 static int debug_registers_changed
;
209 static int debug_registers_used
;
211 static int windows_initialization_done
;
212 #define DR6_CLEAR_VALUE 0xffff0ff0
214 /* The exception thrown by a program to tell the debugger the name of
215 a thread. The exception record contains an ID of a thread and a
216 name to give it. This exception has no documented name, but MSDN
217 dubs it "MS_VC_EXCEPTION" in one code example. */
218 #define MS_VC_EXCEPTION 0x406d1388
222 HANDLE_EXCEPTION_UNHANDLED
= 0,
223 HANDLE_EXCEPTION_HANDLED
,
224 HANDLE_EXCEPTION_IGNORED
225 } handle_exception_result
;
227 /* The string sent by cygwin when it processes a signal.
228 FIXME: This should be in a cygwin include file. */
229 #ifndef _CYGWIN_SIGNAL_STRING
230 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
233 #define CHECK(x) check (x, __FILE__,__LINE__)
234 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
235 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
236 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
237 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
239 static void cygwin_set_dr (int i
, CORE_ADDR addr
);
240 static void cygwin_set_dr7 (unsigned long val
);
241 static CORE_ADDR
cygwin_get_dr (int i
);
242 static unsigned long cygwin_get_dr6 (void);
243 static unsigned long cygwin_get_dr7 (void);
245 static enum gdb_signal last_sig
= GDB_SIGNAL_0
;
246 /* Set if a signal was received from the debugged process. */
248 static std::vector
<windows_thread_info
*> thread_list
;
250 /* The process and thread handles for the above context. */
252 /* The current debug event from WaitForDebugEvent or from a pending
254 static DEBUG_EVENT current_event
;
256 /* The most recent event from WaitForDebugEvent. Unlike
257 current_event, this is guaranteed never to come from a pending
258 stop. This is important because only data from the most recent
259 event from WaitForDebugEvent can be used when calling
260 ContinueDebugEvent. */
261 static DEBUG_EVENT last_wait_event
;
263 static HANDLE current_process_handle
; /* Currently executing process */
264 static windows_thread_info
*current_thread
; /* Info on currently selected thread */
265 static EXCEPTION_RECORD siginfo_er
; /* Contents of $_siginfo */
267 /* Counts of things. */
268 static int exception_count
= 0;
269 static int event_count
= 0;
270 static int saw_create
;
271 static int open_process_used
= 0;
273 static bool wow64_process
= false;
274 static bool ignore_first_breakpoint
= false;
278 static bool new_console
= false;
280 static bool cygwin_exceptions
= false;
282 static bool new_group
= true;
283 static bool debug_exec
= false; /* show execution */
284 static bool debug_events
= false; /* show events from kernel */
285 static bool debug_memory
= false; /* show target memory accesses */
286 static bool debug_exceptions
= false; /* show target exceptions */
287 static bool useshell
= false; /* use shell for subprocesses */
289 /* This vector maps GDB's idea of a register's number into an offset
290 in the windows exception context vector.
292 It also contains the bit mask needed to load the register in question.
294 The contents of this table can only be computed by the units
295 that provide CPU-specific support for Windows native debugging.
296 These units should set the table by calling
297 windows_set_context_register_offsets.
299 One day we could read a reg, we could inspect the context we
300 already have loaded, if it doesn't have the bit set that we need,
301 we read that set of registers in using GetThreadContext. If the
302 context already contains what we need, we just unpack it. Then to
303 write a register, first we have to ensure that the context contains
304 the other regs of the group, and then we copy the info in and set
307 static const int *mappings
;
309 /* The function to use in order to determine whether a register is
310 a segment register or not. */
311 static segment_register_p_ftype
*segment_register_p
;
313 /* See windows_nat_target::resume to understand why this is commented
316 /* This vector maps the target's idea of an exception (extracted
317 from the DEBUG_EVENT structure) to GDB's idea. */
319 struct xlate_exception
325 static const struct xlate_exception xlate
[] =
327 {EXCEPTION_ACCESS_VIOLATION
, GDB_SIGNAL_SEGV
},
328 {STATUS_STACK_OVERFLOW
, GDB_SIGNAL_SEGV
},
329 {EXCEPTION_BREAKPOINT
, GDB_SIGNAL_TRAP
},
330 {DBG_CONTROL_C
, GDB_SIGNAL_INT
},
331 {EXCEPTION_SINGLE_STEP
, GDB_SIGNAL_TRAP
},
332 {STATUS_FLOAT_DIVIDE_BY_ZERO
, GDB_SIGNAL_FPE
}
337 /* The ID of the thread for which we anticipate a stop event.
338 Normally this is -1, meaning we'll accept an event in any
340 static DWORD desired_stop_thread_id
= -1;
342 /* A single pending stop. See "pending_stops" for more
349 /* The target waitstatus we computed. */
350 target_waitstatus status
;
352 /* The event. A few fields of this can be referenced after a stop,
353 and it seemed simplest to store the entire event. */
357 /* A vector of pending stops. Sometimes, Windows will report a stop
358 on a thread that has been ostensibly suspended. We believe what
359 happens here is that two threads hit a breakpoint simultaneously,
360 and the Windows kernel queues the stop events. However, this can
361 result in the strange effect of trying to single step thread A --
362 leaving all other threads suspended -- and then seeing a stop in
363 thread B. To handle this scenario, we queue all such "pending"
364 stops here, and then process them once the step has completed. See
366 static std::vector
<pending_stop
> pending_stops
;
368 struct windows_nat_target final
: public x86_nat_target
<inf_child_target
>
370 void close () override
;
372 void attach (const char *, int) override
;
374 bool attach_no_wait () override
377 void detach (inferior
*, int) override
;
379 void resume (ptid_t
, int , enum gdb_signal
) override
;
381 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
383 void fetch_registers (struct regcache
*, int) override
;
384 void store_registers (struct regcache
*, int) override
;
386 bool stopped_by_sw_breakpoint () override
388 return current_thread
->stopped_at_software_breakpoint
;
391 bool supports_stopped_by_sw_breakpoint () override
396 enum target_xfer_status
xfer_partial (enum target_object object
,
399 const gdb_byte
*writebuf
,
400 ULONGEST offset
, ULONGEST len
,
401 ULONGEST
*xfered_len
) override
;
403 void files_info () override
;
405 void kill () override
;
407 void create_inferior (const char *, const std::string
&,
408 char **, int) override
;
410 void mourn_inferior () override
;
412 bool thread_alive (ptid_t ptid
) override
;
414 std::string
pid_to_str (ptid_t
) override
;
416 void interrupt () override
;
418 char *pid_to_exec_file (int pid
) override
;
420 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
422 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
424 const char *thread_name (struct thread_info
*) override
;
426 int get_windows_debug_event (int pid
, struct target_waitstatus
*ourstatus
);
429 static windows_nat_target the_windows_nat_target
;
431 /* Set the MAPPINGS static global to OFFSETS.
432 See the description of MAPPINGS for more details. */
435 windows_set_context_register_offsets (const int *offsets
)
440 /* Set the function that should be used by this module to determine
441 whether a given register is a segment register or not. */
444 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
446 segment_register_p
= fun
;
450 check (BOOL ok
, const char *file
, int line
)
453 printf_filtered ("error return %s:%d was %u\n", file
, line
,
454 (unsigned) GetLastError ());
457 /* Possible values to pass to 'thread_rec'. */
458 enum thread_disposition_type
460 /* Do not invalidate the thread's context, and do not suspend the
462 DONT_INVALIDATE_CONTEXT
,
463 /* Invalidate the context, but do not suspend the thread. */
465 /* Invalidate the context and suspend the thread. */
469 /* Find a thread record given a thread id. THREAD_DISPOSITION
470 controls whether the thread is suspended, and whether the context
472 static windows_thread_info
*
473 thread_rec (DWORD id
, enum thread_disposition_type disposition
)
475 for (windows_thread_info
*th
: thread_list
)
482 case DONT_INVALIDATE_CONTEXT
:
485 case INVALIDATE_CONTEXT
:
486 if (id
!= current_event
.dwThreadId
)
488 th
->reload_context
= true;
491 th
->reload_context
= true;
502 /* Add a thread to the thread list.
504 PTID is the ptid of the thread to be added.
505 H is its Windows handle.
506 TLB is its thread local base.
507 MAIN_THREAD_P should be true if the thread to be added is
508 the main thread, false otherwise. */
510 static windows_thread_info
*
511 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
, bool main_thread_p
)
513 windows_thread_info
*th
;
516 gdb_assert (ptid
.lwp () != 0);
520 if ((th
= thread_rec (id
, DONT_INVALIDATE_CONTEXT
)))
523 CORE_ADDR base
= (CORE_ADDR
) (uintptr_t) tlb
;
525 /* For WOW64 processes, this is actually the pointer to the 64bit TIB,
526 and the 32bit TIB is exactly 2 pages after it. */
530 th
= new windows_thread_info (id
, h
, base
);
531 thread_list
.push_back (th
);
533 /* Add this new thread to the list of threads.
535 To be consistent with what's done on other platforms, we add
536 the main thread silently (in reality, this thread is really
537 more of a process to the user than a thread). */
539 add_thread_silent (&the_windows_nat_target
, ptid
);
541 add_thread (&the_windows_nat_target
, ptid
);
543 /* Set the debug registers for the new thread if they are used. */
544 if (debug_registers_used
)
549 /* Only change the value of the debug registers. */
550 th
->wow64_context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
551 CHECK (Wow64GetThreadContext (th
->h
, &th
->wow64_context
));
552 th
->wow64_context
.Dr0
= dr
[0];
553 th
->wow64_context
.Dr1
= dr
[1];
554 th
->wow64_context
.Dr2
= dr
[2];
555 th
->wow64_context
.Dr3
= dr
[3];
556 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
557 th
->wow64_context
.Dr7
= dr
[7];
558 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
559 th
->wow64_context
.ContextFlags
= 0;
564 /* Only change the value of the debug registers. */
565 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
566 CHECK (GetThreadContext (th
->h
, &th
->context
));
567 th
->context
.Dr0
= dr
[0];
568 th
->context
.Dr1
= dr
[1];
569 th
->context
.Dr2
= dr
[2];
570 th
->context
.Dr3
= dr
[3];
571 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
572 th
->context
.Dr7
= dr
[7];
573 CHECK (SetThreadContext (th
->h
, &th
->context
));
574 th
->context
.ContextFlags
= 0;
580 /* Clear out any old thread list and reinitialize it to a
583 windows_init_thread_list (void)
585 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
588 for (windows_thread_info
*here
: thread_list
)
591 thread_list
.clear ();
594 /* Delete a thread from the list of threads.
596 PTID is the ptid of the thread to be deleted.
597 EXIT_CODE is the thread's exit code.
598 MAIN_THREAD_P should be true if the thread to be deleted is
599 the main thread, false otherwise. */
602 windows_delete_thread (ptid_t ptid
, DWORD exit_code
, bool main_thread_p
)
606 gdb_assert (ptid
.lwp () != 0);
610 /* Emit a notification about the thread being deleted.
612 Note that no notification was printed when the main thread
613 was created, and thus, unless in verbose mode, we should be
614 symmetrical, and avoid that notification for the main thread
618 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
).c_str ());
619 else if (print_thread_events
&& !main_thread_p
)
620 printf_unfiltered (_("[%s exited with code %u]\n"),
621 target_pid_to_str (ptid
).c_str (),
622 (unsigned) exit_code
);
624 delete_thread (find_thread_ptid (&the_windows_nat_target
, ptid
));
626 auto iter
= std::find_if (thread_list
.begin (), thread_list
.end (),
627 [=] (windows_thread_info
*th
)
629 return th
->tid
== id
;
632 if (iter
!= thread_list
.end ())
635 thread_list
.erase (iter
);
639 /* Fetches register number R from the given windows_thread_info,
640 and supplies its value to the given regcache.
642 This function assumes that R is non-negative. A failed assertion
643 is raised if that is not true.
645 This function assumes that TH->RELOAD_CONTEXT is not set, meaning
646 that the windows_thread_info has an up-to-date context. A failed
647 assertion is raised if that assumption is violated. */
650 windows_fetch_one_register (struct regcache
*regcache
,
651 windows_thread_info
*th
, int r
)
654 gdb_assert (!th
->reload_context
);
656 char *context_ptr
= (char *) &th
->context
;
659 context_ptr
= (char *) &th
->wow64_context
;
662 char *context_offset
= context_ptr
+ mappings
[r
];
663 struct gdbarch
*gdbarch
= regcache
->arch ();
664 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
666 gdb_assert (!gdbarch_read_pc_p (gdbarch
));
667 gdb_assert (gdbarch_pc_regnum (gdbarch
) >= 0);
668 gdb_assert (!gdbarch_write_pc_p (gdbarch
));
670 if (r
== I387_FISEG_REGNUM (tdep
))
672 long l
= *((long *) context_offset
) & 0xffff;
673 regcache
->raw_supply (r
, (char *) &l
);
675 else if (r
== I387_FOP_REGNUM (tdep
))
677 long l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
678 regcache
->raw_supply (r
, (char *) &l
);
680 else if (segment_register_p (r
))
682 /* GDB treats segment registers as 32bit registers, but they are
683 in fact only 16 bits long. Make sure we do not read extra
684 bits from our source buffer. */
685 long l
= *((long *) context_offset
) & 0xffff;
686 regcache
->raw_supply (r
, (char *) &l
);
690 if (th
->stopped_at_software_breakpoint
691 && r
== gdbarch_pc_regnum (gdbarch
))
693 int size
= register_size (gdbarch
, r
);
697 memcpy (&value
, context_offset
, size
);
698 value
-= gdbarch_decr_pc_after_break (gdbarch
);
699 memcpy (context_offset
, &value
, size
);
703 gdb_assert (size
== 8);
705 memcpy (&value
, context_offset
, size
);
706 value
-= gdbarch_decr_pc_after_break (gdbarch
);
707 memcpy (context_offset
, &value
, size
);
710 regcache
->raw_supply (r
, context_offset
);
715 windows_nat_target::fetch_registers (struct regcache
*regcache
, int r
)
717 DWORD tid
= regcache
->ptid ().lwp ();
718 windows_thread_info
*th
= thread_rec (tid
, INVALIDATE_CONTEXT
);
720 /* Check if TH exists. Windows sometimes uses a non-existent
721 thread id in its events. */
725 if (th
->reload_context
)
728 if (have_saved_context
)
730 /* Lie about where the program actually is stopped since
731 cygwin has informed us that we should consider the signal
732 to have occurred at another location which is stored in
734 memcpy (&th
->context
, &saved_context
,
735 __COPY_CONTEXT_SIZE
);
736 have_saved_context
= 0;
743 th
->wow64_context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
744 CHECK (Wow64GetThreadContext (th
->h
, &th
->wow64_context
));
745 /* Copy dr values from that thread.
746 But only if there were not modified since last stop.
748 if (!debug_registers_changed
)
750 dr
[0] = th
->wow64_context
.Dr0
;
751 dr
[1] = th
->wow64_context
.Dr1
;
752 dr
[2] = th
->wow64_context
.Dr2
;
753 dr
[3] = th
->wow64_context
.Dr3
;
754 dr
[6] = th
->wow64_context
.Dr6
;
755 dr
[7] = th
->wow64_context
.Dr7
;
761 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
762 CHECK (GetThreadContext (th
->h
, &th
->context
));
763 /* Copy dr values from that thread.
764 But only if there were not modified since last stop.
766 if (!debug_registers_changed
)
768 dr
[0] = th
->context
.Dr0
;
769 dr
[1] = th
->context
.Dr1
;
770 dr
[2] = th
->context
.Dr2
;
771 dr
[3] = th
->context
.Dr3
;
772 dr
[6] = th
->context
.Dr6
;
773 dr
[7] = th
->context
.Dr7
;
776 th
->reload_context
= false;
780 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch()); r
++)
781 windows_fetch_one_register (regcache
, th
, r
);
783 windows_fetch_one_register (regcache
, th
, r
);
786 /* Collect the register number R from the given regcache, and store
787 its value into the corresponding area of the given thread's context.
789 This function assumes that R is non-negative. A failed assertion
790 assertion is raised if that is not true. */
793 windows_store_one_register (const struct regcache
*regcache
,
794 windows_thread_info
*th
, int r
)
798 char *context_ptr
= (char *) &th
->context
;
801 context_ptr
= (char *) &th
->wow64_context
;
804 regcache
->raw_collect (r
, context_ptr
+ mappings
[r
]);
807 /* Store a new register value into the context of the thread tied to
811 windows_nat_target::store_registers (struct regcache
*regcache
, int r
)
813 DWORD tid
= regcache
->ptid ().lwp ();
814 windows_thread_info
*th
= thread_rec (tid
, INVALIDATE_CONTEXT
);
816 /* Check if TH exists. Windows sometimes uses a non-existent
817 thread id in its events. */
822 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch ()); r
++)
823 windows_store_one_register (regcache
, th
, r
);
825 windows_store_one_register (regcache
, th
, r
);
828 /* Maintain a linked list of "so" information. */
829 struct lm_info_windows
: public lm_info_base
831 LPVOID load_addr
= 0;
832 CORE_ADDR text_offset
= 0;
835 static struct so_list solib_start
, *solib_end
;
837 static struct so_list
*
838 windows_make_so (const char *name
, LPVOID load_addr
)
845 WIN32_FIND_DATA w32_fd
;
846 HANDLE h
= FindFirstFile(name
, &w32_fd
);
848 if (h
== INVALID_HANDLE_VALUE
)
854 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
856 p
= strrchr (buf
, '\\');
859 SetCurrentDirectory (buf
);
860 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
861 SetCurrentDirectory (cwd
);
864 if (strcasecmp (buf
, "ntdll.dll") == 0)
866 GetSystemDirectory (buf
, sizeof (buf
));
867 strcat (buf
, "\\ntdll.dll");
870 cygwin_buf_t buf
[__PMAX
];
873 if (access (name
, F_OK
) != 0)
875 if (strcasecmp (name
, "ntdll.dll") == 0)
878 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
879 wcscat (buf
, L
"\\ntdll.dll");
883 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
884 strcat (buf
, "\\ntdll.dll");
889 so
= XCNEW (struct so_list
);
890 lm_info_windows
*li
= new lm_info_windows
;
892 li
->load_addr
= load_addr
;
893 strcpy (so
->so_original_name
, name
);
895 strcpy (so
->so_name
, buf
);
898 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
899 SO_NAME_MAX_PATH_SIZE
);
902 char *rname
= realpath (name
, NULL
);
903 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
905 strcpy (so
->so_name
, rname
);
909 error (_("dll path too long"));
911 /* Record cygwin1.dll .text start/end. */
912 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
913 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
915 asection
*text
= NULL
;
917 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386", -1));
922 if (bfd_check_format (abfd
.get (), bfd_object
))
923 text
= bfd_get_section_by_name (abfd
.get (), ".text");
928 /* The symbols in a dll are offset by 0x1000, which is the
929 offset from 0 of the first byte in an image - because of the
930 file header and the section alignment. */
931 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
933 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (text
);
941 get_image_name (HANDLE h
, void *address
, int unicode
)
944 static char buf
[__PMAX
];
946 static char buf
[(2 * __PMAX
) + 1];
948 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
954 /* Attempt to read the name of the dll that was detected.
955 This is documented to work only when actively debugging
956 a program. It will not work for attached processes. */
960 /* See if we could read the address of a string, and that the
961 address isn't null. */
962 if (!ReadProcessMemory (h
, address
, &address_ptr
,
963 sizeof (address_ptr
), &done
)
964 || done
!= sizeof (address_ptr
) || !address_ptr
)
967 /* Find the length of the string. */
968 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
969 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
973 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
976 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
977 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
980 wcstombs (buf
, unicode_address
, __PMAX
);
982 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
990 /* Handle a DLL load event, and return 1.
992 This function assumes that this event did not occur during inferior
993 initialization, where their event info may be incomplete (see
994 do_initial_windows_stuff and windows_add_all_dlls for more info
995 on how we handle DLL loading during that phase). */
1000 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
1003 /* Try getting the DLL name via the lpImageName field of the event.
1004 Note that Microsoft documents this fields as strictly optional,
1005 in the sense that it might be NULL. And the first DLL event in
1006 particular is explicitly documented as "likely not pass[ed]"
1007 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
1008 dll_name
= get_image_name (current_process_handle
,
1009 event
->lpImageName
, event
->fUnicode
);
1013 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
1014 solib_end
= solib_end
->next
;
1016 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
1018 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
1019 host_address_to_string (li
->load_addr
)));
1023 windows_free_so (struct so_list
*so
)
1025 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
1031 /* Handle a DLL unload event.
1032 Return 1 if successful, or zero otherwise.
1034 This function assumes that this event did not occur during inferior
1035 initialization, where their event info may be incomplete (see
1036 do_initial_windows_stuff and windows_add_all_dlls for more info
1037 on how we handle DLL loading during that phase). */
1040 handle_unload_dll ()
1042 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
1045 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
1047 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
1049 if (li_next
->load_addr
== lpBaseOfDll
)
1051 struct so_list
*sodel
= so
->next
;
1053 so
->next
= sodel
->next
;
1056 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
1058 windows_free_so (sodel
);
1063 /* We did not find any DLL that was previously loaded at this address,
1064 so register a complaint. We do not report an error, because we have
1065 observed that this may be happening under some circumstances. For
1066 instance, running 32bit applications on x64 Windows causes us to receive
1067 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
1068 events are apparently caused by the WOW layer, the interface between
1069 32bit and 64bit worlds). */
1070 complaint (_("dll starting at %s not found."),
1071 host_address_to_string (lpBaseOfDll
));
1074 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
1078 catch_errors (void (*func
) ())
1084 catch (const gdb_exception
&ex
)
1086 exception_print (gdb_stderr
, ex
);
1090 /* Clear list of loaded DLLs. */
1092 windows_clear_solib (void)
1096 for (so
= solib_start
.next
; so
; so
= solib_start
.next
)
1098 solib_start
.next
= so
->next
;
1099 windows_free_so (so
);
1102 solib_end
= &solib_start
;
1106 signal_event_command (const char *args
, int from_tty
)
1108 uintptr_t event_id
= 0;
1109 char *endargs
= NULL
;
1112 error (_("signal-event requires an argument (integer event id)"));
1114 event_id
= strtoumax (args
, &endargs
, 10);
1116 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
1117 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
1118 error (_("Failed to convert `%s' to event id"), args
);
1120 SetEvent ((HANDLE
) event_id
);
1121 CloseHandle ((HANDLE
) event_id
);
1124 /* Handle DEBUG_STRING output from child process.
1125 Cygwin prepends its messages with a "cygwin:". Interpret this as
1126 a Cygwin signal. Otherwise just print the string as a warning. */
1128 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
1130 gdb::unique_xmalloc_ptr
<char> s
;
1133 if (!target_read_string
1134 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
1136 || !s
|| !*(s
.get ()))
1137 /* nothing to do */;
1138 else if (!startswith (s
.get (), _CYGWIN_SIGNAL_STRING
))
1141 if (!startswith (s
.get (), "cYg"))
1144 char *p
= strchr (s
.get (), '\0');
1146 if (p
> s
.get () && *--p
== '\n')
1148 warning (("%s"), s
.get ());
1154 /* Got a cygwin signal marker. A cygwin signal is followed by
1155 the signal number itself and then optionally followed by the
1156 thread id and address to saved context within the DLL. If
1157 these are supplied, then the given thread is assumed to have
1158 issued the signal and the context from the thread is assumed
1159 to be stored at the given address in the inferior. Tell gdb
1160 to treat this like a real signal. */
1162 int sig
= strtol (s
.get () + sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
1163 gdb_signal gotasig
= gdb_signal_from_host (sig
);
1165 ourstatus
->value
.sig
= gotasig
;
1171 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1172 retval
= strtoul (p
, &p
, 0);
1174 retval
= current_event
.dwThreadId
;
1175 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
1176 && ReadProcessMemory (current_process_handle
, x
,
1178 __COPY_CONTEXT_SIZE
, &n
)
1179 && n
== __COPY_CONTEXT_SIZE
)
1180 have_saved_context
= 1;
1189 display_selector (HANDLE thread
, DWORD sel
)
1195 ret
= Wow64GetThreadSelectorEntry (thread
, sel
, &info
);
1198 ret
= GetThreadSelectorEntry (thread
, sel
, &info
);
1202 printf_filtered ("0x%03x: ", (unsigned) sel
);
1203 if (!info
.HighWord
.Bits
.Pres
)
1205 puts_filtered ("Segment not present\n");
1208 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1209 (info
.HighWord
.Bits
.BaseMid
<< 16)
1211 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1212 if (info
.HighWord
.Bits
.Granularity
)
1213 limit
= (limit
<< 12) | 0xfff;
1214 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1215 if (info
.HighWord
.Bits
.Default_Big
)
1216 puts_filtered(" 32-bit ");
1218 puts_filtered(" 16-bit ");
1219 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1222 puts_filtered ("Data (Read-Only, Exp-up");
1225 puts_filtered ("Data (Read/Write, Exp-up");
1228 puts_filtered ("Unused segment (");
1231 puts_filtered ("Data (Read/Write, Exp-down");
1234 puts_filtered ("Code (Exec-Only, N.Conf");
1237 puts_filtered ("Code (Exec/Read, N.Conf");
1240 puts_filtered ("Code (Exec-Only, Conf");
1243 puts_filtered ("Code (Exec/Read, Conf");
1246 printf_filtered ("Unknown type 0x%lx",
1247 (unsigned long) info
.HighWord
.Bits
.Type
);
1249 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1250 puts_filtered(", N.Acc");
1251 puts_filtered (")\n");
1252 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1253 puts_filtered("System selector ");
1254 printf_filtered ("Priviledge level = %ld. ",
1255 (unsigned long) info
.HighWord
.Bits
.Dpl
);
1256 if (info
.HighWord
.Bits
.Granularity
)
1257 puts_filtered ("Page granular.\n");
1259 puts_filtered ("Byte granular.\n");
1264 DWORD err
= GetLastError ();
1265 if (err
== ERROR_NOT_SUPPORTED
)
1266 printf_filtered ("Function not supported\n");
1268 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1274 display_selectors (const char * args
, int from_tty
)
1276 if (!current_thread
)
1278 puts_filtered ("Impossible to display selectors now.\n");
1286 puts_filtered ("Selector $cs\n");
1287 display_selector (current_thread
->h
,
1288 current_thread
->wow64_context
.SegCs
);
1289 puts_filtered ("Selector $ds\n");
1290 display_selector (current_thread
->h
,
1291 current_thread
->wow64_context
.SegDs
);
1292 puts_filtered ("Selector $es\n");
1293 display_selector (current_thread
->h
,
1294 current_thread
->wow64_context
.SegEs
);
1295 puts_filtered ("Selector $ss\n");
1296 display_selector (current_thread
->h
,
1297 current_thread
->wow64_context
.SegSs
);
1298 puts_filtered ("Selector $fs\n");
1299 display_selector (current_thread
->h
,
1300 current_thread
->wow64_context
.SegFs
);
1301 puts_filtered ("Selector $gs\n");
1302 display_selector (current_thread
->h
,
1303 current_thread
->wow64_context
.SegGs
);
1308 puts_filtered ("Selector $cs\n");
1309 display_selector (current_thread
->h
,
1310 current_thread
->context
.SegCs
);
1311 puts_filtered ("Selector $ds\n");
1312 display_selector (current_thread
->h
,
1313 current_thread
->context
.SegDs
);
1314 puts_filtered ("Selector $es\n");
1315 display_selector (current_thread
->h
,
1316 current_thread
->context
.SegEs
);
1317 puts_filtered ("Selector $ss\n");
1318 display_selector (current_thread
->h
,
1319 current_thread
->context
.SegSs
);
1320 puts_filtered ("Selector $fs\n");
1321 display_selector (current_thread
->h
,
1322 current_thread
->context
.SegFs
);
1323 puts_filtered ("Selector $gs\n");
1324 display_selector (current_thread
->h
,
1325 current_thread
->context
.SegGs
);
1331 sel
= parse_and_eval_long (args
);
1332 printf_filtered ("Selector \"%s\"\n",args
);
1333 display_selector (current_thread
->h
, sel
);
1337 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1338 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1339 host_address_to_string (\
1340 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1342 static handle_exception_result
1343 handle_exception (struct target_waitstatus
*ourstatus
)
1345 EXCEPTION_RECORD
*rec
= ¤t_event
.u
.Exception
.ExceptionRecord
;
1346 DWORD code
= rec
->ExceptionCode
;
1347 handle_exception_result result
= HANDLE_EXCEPTION_HANDLED
;
1349 memcpy (&siginfo_er
, rec
, sizeof siginfo_er
);
1351 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1353 /* Record the context of the current thread. */
1354 thread_rec (current_event
.dwThreadId
, DONT_SUSPEND
);
1358 case EXCEPTION_ACCESS_VIOLATION
:
1359 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1360 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1363 /* See if the access violation happened within the cygwin DLL
1364 itself. Cygwin uses a kind of exception handling to deal
1365 with passed-in invalid addresses. gdb should not treat
1366 these as real SEGVs since they will be silently handled by
1367 cygwin. A real SEGV will (theoretically) be caught by
1368 cygwin later in the process and will be sent as a
1369 cygwin-specific-signal. So, ignore SEGVs if they show up
1370 within the text segment of the DLL itself. */
1372 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1374 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1375 && addr
< cygwin_load_end
))
1376 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1377 && startswith (fn
, "KERNEL32!IsBad")))
1378 return HANDLE_EXCEPTION_UNHANDLED
;
1382 case STATUS_STACK_OVERFLOW
:
1383 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1384 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1386 case STATUS_FLOAT_DENORMAL_OPERAND
:
1387 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1388 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1390 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1391 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1392 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1394 case STATUS_FLOAT_INEXACT_RESULT
:
1395 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1396 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1398 case STATUS_FLOAT_INVALID_OPERATION
:
1399 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1400 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1402 case STATUS_FLOAT_OVERFLOW
:
1403 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1404 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1406 case STATUS_FLOAT_STACK_CHECK
:
1407 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1408 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1410 case STATUS_FLOAT_UNDERFLOW
:
1411 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1412 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1414 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1415 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1416 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1418 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1419 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1420 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1422 case STATUS_INTEGER_OVERFLOW
:
1423 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1424 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1426 case EXCEPTION_BREAKPOINT
:
1428 if (ignore_first_breakpoint
)
1430 /* For WOW64 processes, there are always 2 breakpoint exceptions
1431 on startup, first a BREAKPOINT for the 64bit ntdll.dll,
1432 then a WX86_BREAKPOINT for the 32bit ntdll.dll.
1433 Here we only care about the WX86_BREAKPOINT's. */
1434 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1435 ignore_first_breakpoint
= false;
1439 case STATUS_WX86_BREAKPOINT
:
1440 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1441 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1444 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1445 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1447 case DBG_CONTROL_BREAK
:
1448 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1449 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1451 case EXCEPTION_SINGLE_STEP
:
1452 case STATUS_WX86_SINGLE_STEP
:
1453 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1454 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1456 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1457 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1458 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1460 case EXCEPTION_PRIV_INSTRUCTION
:
1461 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1462 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1464 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1465 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1466 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1468 case MS_VC_EXCEPTION
:
1469 if (rec
->NumberParameters
>= 3
1470 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1472 DWORD named_thread_id
;
1473 windows_thread_info
*named_thread
;
1474 CORE_ADDR thread_name_target
;
1476 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1478 thread_name_target
= rec
->ExceptionInformation
[1];
1479 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1481 if (named_thread_id
== (DWORD
) -1)
1482 named_thread_id
= current_event
.dwThreadId
;
1484 named_thread
= thread_rec (named_thread_id
, DONT_INVALIDATE_CONTEXT
);
1485 if (named_thread
!= NULL
)
1487 int thread_name_len
;
1488 gdb::unique_xmalloc_ptr
<char> thread_name
;
1490 thread_name_len
= target_read_string (thread_name_target
,
1491 &thread_name
, 1025, NULL
);
1492 if (thread_name_len
> 0)
1494 thread_name
.get ()[thread_name_len
- 1] = '\0';
1495 named_thread
->name
= std::move (thread_name
);
1498 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1499 result
= HANDLE_EXCEPTION_IGNORED
;
1502 /* treat improperly formed exception as unknown */
1505 /* Treat unhandled first chance exceptions specially. */
1506 if (current_event
.u
.Exception
.dwFirstChance
)
1507 return HANDLE_EXCEPTION_UNHANDLED
;
1508 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1509 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1510 host_address_to_string (
1511 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1512 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1516 last_sig
= ourstatus
->value
.sig
;
1520 /* Resume thread specified by ID, or all artificially suspended
1521 threads, if we are continuing execution. KILLED non-zero means we
1522 have killed the inferior, so we should ignore weird errors due to
1523 threads shutting down. */
1525 windows_continue (DWORD continue_status
, int id
, int killed
)
1529 desired_stop_thread_id
= id
;
1531 /* If there are pending stops, and we might plausibly hit one of
1532 them, we don't want to actually continue the inferior -- we just
1533 want to report the stop. In this case, we just pretend to
1534 continue. See the comment by the definition of "pending_stops"
1535 for details on why this is needed. */
1536 for (const auto &item
: pending_stops
)
1538 if (desired_stop_thread_id
== -1
1539 || desired_stop_thread_id
== item
.thread_id
)
1541 DEBUG_EVENTS (("windows_continue - pending stop anticipated, "
1542 "desired=0x%x, item=0x%x\n",
1543 desired_stop_thread_id
, item
.thread_id
));
1548 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1549 (unsigned) last_wait_event
.dwProcessId
,
1550 (unsigned) last_wait_event
.dwThreadId
,
1551 continue_status
== DBG_CONTINUE
?
1552 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1554 for (windows_thread_info
*th
: thread_list
)
1555 if (id
== -1 || id
== (int) th
->tid
)
1562 if (debug_registers_changed
)
1564 th
->wow64_context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1565 th
->wow64_context
.Dr0
= dr
[0];
1566 th
->wow64_context
.Dr1
= dr
[1];
1567 th
->wow64_context
.Dr2
= dr
[2];
1568 th
->wow64_context
.Dr3
= dr
[3];
1569 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1570 th
->wow64_context
.Dr7
= dr
[7];
1572 if (th
->wow64_context
.ContextFlags
)
1576 if (GetExitCodeThread (th
->h
, &ec
)
1577 && ec
== STILL_ACTIVE
)
1579 BOOL status
= Wow64SetThreadContext (th
->h
,
1580 &th
->wow64_context
);
1585 th
->wow64_context
.ContextFlags
= 0;
1591 if (debug_registers_changed
)
1593 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1594 th
->context
.Dr0
= dr
[0];
1595 th
->context
.Dr1
= dr
[1];
1596 th
->context
.Dr2
= dr
[2];
1597 th
->context
.Dr3
= dr
[3];
1598 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1599 th
->context
.Dr7
= dr
[7];
1601 if (th
->context
.ContextFlags
)
1605 if (GetExitCodeThread (th
->h
, &ec
)
1606 && ec
== STILL_ACTIVE
)
1608 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1613 th
->context
.ContextFlags
= 0;
1620 /* When single-stepping a specific thread, other threads must
1625 res
= ContinueDebugEvent (last_wait_event
.dwProcessId
,
1626 last_wait_event
.dwThreadId
,
1630 error (_("Failed to resume program execution"
1631 " (ContinueDebugEvent failed, error %u)"),
1632 (unsigned int) GetLastError ());
1634 debug_registers_changed
= 0;
1638 /* Called in pathological case where Windows fails to send a
1639 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1641 fake_create_process (void)
1643 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1644 current_event
.dwProcessId
);
1645 if (current_process_handle
!= NULL
)
1646 open_process_used
= 1;
1649 error (_("OpenProcess call failed, GetLastError = %u"),
1650 (unsigned) GetLastError ());
1651 /* We can not debug anything in that case. */
1654 = windows_add_thread (ptid_t (current_event
.dwProcessId
,
1655 current_event
.dwThreadId
, 0),
1656 current_event
.u
.CreateThread
.hThread
,
1657 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1658 true /* main_thread_p */);
1659 return current_event
.dwThreadId
;
1663 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1665 windows_thread_info
*th
;
1666 DWORD continue_status
= DBG_CONTINUE
;
1668 /* A specific PTID means `step only this thread id'. */
1669 int resume_all
= ptid
== minus_one_ptid
;
1671 /* If we're continuing all threads, it's the current inferior that
1672 should be handled specially. */
1674 ptid
= inferior_ptid
;
1676 if (sig
!= GDB_SIGNAL_0
)
1678 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1680 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1682 else if (sig
== last_sig
)
1683 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1686 /* This code does not seem to work, because
1687 the kernel does probably not consider changes in the ExceptionRecord
1688 structure when passing the exception to the inferior.
1689 Note that this seems possible in the exception handler itself. */
1691 for (const xlate_exception
&x
: xlate
)
1694 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1696 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1699 if (continue_status
== DBG_CONTINUE
)
1701 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1705 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1709 last_sig
= GDB_SIGNAL_0
;
1711 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=0x%x, step=%d, sig=%d);\n",
1712 ptid
.pid (), (unsigned) ptid
.lwp (), step
, sig
));
1714 /* Get context for currently selected thread. */
1715 th
= thread_rec (inferior_ptid
.lwp (), DONT_INVALIDATE_CONTEXT
);
1723 /* Single step by setting t bit. */
1724 struct regcache
*regcache
= get_current_regcache ();
1725 struct gdbarch
*gdbarch
= regcache
->arch ();
1726 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1727 th
->wow64_context
.EFlags
|= FLAG_TRACE_BIT
;
1730 if (th
->wow64_context
.ContextFlags
)
1732 if (debug_registers_changed
)
1734 th
->wow64_context
.Dr0
= dr
[0];
1735 th
->wow64_context
.Dr1
= dr
[1];
1736 th
->wow64_context
.Dr2
= dr
[2];
1737 th
->wow64_context
.Dr3
= dr
[3];
1738 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1739 th
->wow64_context
.Dr7
= dr
[7];
1741 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
1742 th
->wow64_context
.ContextFlags
= 0;
1750 /* Single step by setting t bit. */
1751 struct regcache
*regcache
= get_current_regcache ();
1752 struct gdbarch
*gdbarch
= regcache
->arch ();
1753 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1754 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1757 if (th
->context
.ContextFlags
)
1759 if (debug_registers_changed
)
1761 th
->context
.Dr0
= dr
[0];
1762 th
->context
.Dr1
= dr
[1];
1763 th
->context
.Dr2
= dr
[2];
1764 th
->context
.Dr3
= dr
[3];
1765 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1766 th
->context
.Dr7
= dr
[7];
1768 CHECK (SetThreadContext (th
->h
, &th
->context
));
1769 th
->context
.ContextFlags
= 0;
1774 /* Allow continuing with the same signal that interrupted us.
1775 Otherwise complain. */
1778 windows_continue (continue_status
, -1, 0);
1780 windows_continue (continue_status
, ptid
.lwp (), 0);
1783 /* Ctrl-C handler used when the inferior is not run in the same console. The
1784 handler is in charge of interrupting the inferior using DebugBreakProcess.
1785 Note that this function is not available prior to Windows XP. In this case
1786 we emit a warning. */
1788 ctrl_c_handler (DWORD event_type
)
1790 const int attach_flag
= current_inferior ()->attach_flag
;
1792 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1793 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1796 /* If the inferior and the debugger share the same console, do nothing as
1797 the inferior has also received the Ctrl-C event. */
1798 if (!new_console
&& !attach_flag
)
1801 if (!DebugBreakProcess (current_process_handle
))
1802 warning (_("Could not interrupt program. "
1803 "Press Ctrl-c in the program console."));
1805 /* Return true to tell that Ctrl-C has been handled. */
1809 /* A wrapper for WaitForDebugEvent that sets "last_wait_event"
1812 wait_for_debug_event (DEBUG_EVENT
*event
, DWORD timeout
)
1814 BOOL result
= WaitForDebugEvent (event
, timeout
);
1816 last_wait_event
= *event
;
1820 /* Get the next event from the child. Returns a non-zero thread id if the event
1821 requires handling by WFI (or whatever). */
1824 windows_nat_target::get_windows_debug_event (int pid
,
1825 struct target_waitstatus
*ourstatus
)
1828 DWORD continue_status
, event_code
;
1829 windows_thread_info
*th
;
1830 static windows_thread_info
dummy_thread_info (0, 0, 0);
1831 DWORD thread_id
= 0;
1833 /* If there is a relevant pending stop, report it now. See the
1834 comment by the definition of "pending_stops" for details on why
1836 for (auto iter
= pending_stops
.begin ();
1837 iter
!= pending_stops
.end ();
1840 if (desired_stop_thread_id
== -1
1841 || desired_stop_thread_id
== iter
->thread_id
)
1843 thread_id
= iter
->thread_id
;
1844 *ourstatus
= iter
->status
;
1845 current_event
= iter
->event
;
1847 inferior_ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1848 current_thread
= thread_rec (thread_id
, INVALIDATE_CONTEXT
);
1849 current_thread
->reload_context
= 1;
1851 DEBUG_EVENTS (("get_windows_debug_event - "
1852 "pending stop found in 0x%x (desired=0x%x)\n",
1853 thread_id
, desired_stop_thread_id
));
1855 pending_stops
.erase (iter
);
1860 last_sig
= GDB_SIGNAL_0
;
1862 if (!(debug_event
= wait_for_debug_event (¤t_event
, 1000)))
1866 continue_status
= DBG_CONTINUE
;
1868 event_code
= current_event
.dwDebugEventCode
;
1869 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1871 have_saved_context
= 0;
1875 case CREATE_THREAD_DEBUG_EVENT
:
1876 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1877 (unsigned) current_event
.dwProcessId
,
1878 (unsigned) current_event
.dwThreadId
,
1879 "CREATE_THREAD_DEBUG_EVENT"));
1880 if (saw_create
!= 1)
1882 inferior
*inf
= find_inferior_pid (this, current_event
.dwProcessId
);
1883 if (!saw_create
&& inf
->attach_flag
)
1885 /* Kludge around a Windows bug where first event is a create
1886 thread event. Caused when attached process does not have
1888 thread_id
= fake_create_process ();
1894 /* Record the existence of this thread. */
1895 thread_id
= current_event
.dwThreadId
;
1896 th
= windows_add_thread
1897 (ptid_t (current_event
.dwProcessId
, current_event
.dwThreadId
, 0),
1898 current_event
.u
.CreateThread
.hThread
,
1899 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1900 false /* main_thread_p */);
1904 case EXIT_THREAD_DEBUG_EVENT
:
1905 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1906 (unsigned) current_event
.dwProcessId
,
1907 (unsigned) current_event
.dwThreadId
,
1908 "EXIT_THREAD_DEBUG_EVENT"));
1909 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1910 current_event
.dwThreadId
, 0),
1911 current_event
.u
.ExitThread
.dwExitCode
,
1912 false /* main_thread_p */);
1913 th
= &dummy_thread_info
;
1916 case CREATE_PROCESS_DEBUG_EVENT
:
1917 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1918 (unsigned) current_event
.dwProcessId
,
1919 (unsigned) current_event
.dwThreadId
,
1920 "CREATE_PROCESS_DEBUG_EVENT"));
1921 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1922 if (++saw_create
!= 1)
1925 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1926 /* Add the main thread. */
1927 th
= windows_add_thread
1928 (ptid_t (current_event
.dwProcessId
,
1929 current_event
.dwThreadId
, 0),
1930 current_event
.u
.CreateProcessInfo
.hThread
,
1931 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
,
1932 true /* main_thread_p */);
1933 thread_id
= current_event
.dwThreadId
;
1936 case EXIT_PROCESS_DEBUG_EVENT
:
1937 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1938 (unsigned) current_event
.dwProcessId
,
1939 (unsigned) current_event
.dwThreadId
,
1940 "EXIT_PROCESS_DEBUG_EVENT"));
1941 if (!windows_initialization_done
)
1943 target_terminal::ours ();
1944 target_mourn_inferior (inferior_ptid
);
1945 error (_("During startup program exited with code 0x%x."),
1946 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1948 else if (saw_create
== 1)
1950 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1951 current_event
.dwThreadId
, 0),
1952 0, true /* main_thread_p */);
1953 DWORD exit_status
= current_event
.u
.ExitProcess
.dwExitCode
;
1954 /* If the exit status looks like a fatal exception, but we
1955 don't recognize the exception's code, make the original
1956 exit status value available, to avoid losing
1959 = WIFSIGNALED (exit_status
) ? WTERMSIG (exit_status
) : -1;
1960 if (exit_signal
== -1)
1962 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1963 ourstatus
->value
.integer
= exit_status
;
1967 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1968 ourstatus
->value
.sig
= gdb_signal_from_host (exit_signal
);
1970 thread_id
= current_event
.dwThreadId
;
1974 case LOAD_DLL_DEBUG_EVENT
:
1975 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1976 (unsigned) current_event
.dwProcessId
,
1977 (unsigned) current_event
.dwThreadId
,
1978 "LOAD_DLL_DEBUG_EVENT"));
1979 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1980 if (saw_create
!= 1 || ! windows_initialization_done
)
1982 catch_errors (handle_load_dll
);
1983 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1984 ourstatus
->value
.integer
= 0;
1985 thread_id
= current_event
.dwThreadId
;
1988 case UNLOAD_DLL_DEBUG_EVENT
:
1989 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1990 (unsigned) current_event
.dwProcessId
,
1991 (unsigned) current_event
.dwThreadId
,
1992 "UNLOAD_DLL_DEBUG_EVENT"));
1993 if (saw_create
!= 1 || ! windows_initialization_done
)
1995 catch_errors (handle_unload_dll
);
1996 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1997 ourstatus
->value
.integer
= 0;
1998 thread_id
= current_event
.dwThreadId
;
2001 case EXCEPTION_DEBUG_EVENT
:
2002 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
2003 (unsigned) current_event
.dwProcessId
,
2004 (unsigned) current_event
.dwThreadId
,
2005 "EXCEPTION_DEBUG_EVENT"));
2006 if (saw_create
!= 1)
2008 switch (handle_exception (ourstatus
))
2010 case HANDLE_EXCEPTION_UNHANDLED
:
2012 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
2014 case HANDLE_EXCEPTION_HANDLED
:
2015 thread_id
= current_event
.dwThreadId
;
2017 case HANDLE_EXCEPTION_IGNORED
:
2018 continue_status
= DBG_CONTINUE
;
2023 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
2024 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
2025 (unsigned) current_event
.dwProcessId
,
2026 (unsigned) current_event
.dwThreadId
,
2027 "OUTPUT_DEBUG_STRING_EVENT"));
2028 if (saw_create
!= 1)
2030 thread_id
= handle_output_debug_string (ourstatus
);
2034 if (saw_create
!= 1)
2036 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
2037 (unsigned) current_event
.dwProcessId
,
2038 (unsigned) current_event
.dwThreadId
);
2039 printf_unfiltered (" unknown event code %u\n",
2040 (unsigned) current_event
.dwDebugEventCode
);
2044 if (!thread_id
|| saw_create
!= 1)
2046 CHECK (windows_continue (continue_status
, desired_stop_thread_id
, 0));
2048 else if (desired_stop_thread_id
!= -1 && desired_stop_thread_id
!= thread_id
)
2050 /* Pending stop. See the comment by the definition of
2051 "pending_stops" for details on why this is needed. */
2052 DEBUG_EVENTS (("get_windows_debug_event - "
2053 "unexpected stop in 0x%x (expecting 0x%x)\n",
2054 thread_id
, desired_stop_thread_id
));
2056 if (current_event
.dwDebugEventCode
== EXCEPTION_DEBUG_EVENT
2057 && (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
2058 == EXCEPTION_BREAKPOINT
)
2059 && windows_initialization_done
)
2061 th
= thread_rec (thread_id
, INVALIDATE_CONTEXT
);
2062 th
->stopped_at_software_breakpoint
= true;
2064 pending_stops
.push_back ({thread_id
, *ourstatus
, current_event
});
2066 CHECK (windows_continue (continue_status
, desired_stop_thread_id
, 0));
2070 inferior_ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
2071 current_thread
= th
;
2072 if (!current_thread
)
2073 current_thread
= thread_rec (thread_id
, INVALIDATE_CONTEXT
);
2080 /* Wait for interesting events to occur in the target process. */
2082 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
2087 /* We loop when we get a non-standard exception rather than return
2088 with a SPURIOUS because resume can try and step or modify things,
2089 which needs a current_thread->h. But some of these exceptions mark
2090 the birth or death of threads, which mean that the current thread
2091 isn't necessarily what you think it is. */
2097 /* If the user presses Ctrl-c while the debugger is waiting
2098 for an event, he expects the debugger to interrupt his program
2099 and to get the prompt back. There are two possible situations:
2101 - The debugger and the program do not share the console, in
2102 which case the Ctrl-c event only reached the debugger.
2103 In that case, the ctrl_c handler will take care of interrupting
2104 the inferior. Note that this case is working starting with
2105 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
2108 - The debugger and the program share the same console, in which
2109 case both debugger and inferior will receive the Ctrl-c event.
2110 In that case the ctrl_c handler will ignore the event, as the
2111 Ctrl-c event generated inside the inferior will trigger the
2112 expected debug event.
2114 FIXME: brobecker/2008-05-20: If the inferior receives the
2115 signal first and the delay until GDB receives that signal
2116 is sufficiently long, GDB can sometimes receive the SIGINT
2117 after we have unblocked the CTRL+C handler. This would
2118 lead to the debugger stopping prematurely while handling
2119 the new-thread event that comes with the handling of the SIGINT
2120 inside the inferior, and then stop again immediately when
2121 the user tries to resume the execution in the inferior.
2122 This is a classic race that we should try to fix one day. */
2123 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
2124 retval
= get_windows_debug_event (pid
, ourstatus
);
2125 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
2129 ptid_t result
= ptid_t (current_event
.dwProcessId
, retval
, 0);
2131 if (current_thread
!= nullptr)
2133 current_thread
->stopped_at_software_breakpoint
= false;
2134 if (current_event
.dwDebugEventCode
== EXCEPTION_DEBUG_EVENT
2135 && (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
2136 == EXCEPTION_BREAKPOINT
)
2137 && windows_initialization_done
)
2138 current_thread
->stopped_at_software_breakpoint
= true;
2147 if (deprecated_ui_loop_hook
!= NULL
)
2148 detach
= deprecated_ui_loop_hook (0);
2156 /* Iterate over all DLLs currently mapped by our inferior, and
2157 add them to our list of solibs. */
2160 windows_add_all_dlls (void)
2162 HMODULE dummy_hmodule
;
2170 if (EnumProcessModulesEx (current_process_handle
, &dummy_hmodule
,
2171 sizeof (HMODULE
), &cb_needed
,
2172 LIST_MODULES_32BIT
) == 0)
2178 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
2179 sizeof (HMODULE
), &cb_needed
) == 0)
2186 hmodules
= (HMODULE
*) alloca (cb_needed
);
2190 if (EnumProcessModulesEx (current_process_handle
, hmodules
,
2191 cb_needed
, &cb_needed
,
2192 LIST_MODULES_32BIT
) == 0)
2198 if (EnumProcessModules (current_process_handle
, hmodules
,
2199 cb_needed
, &cb_needed
) == 0)
2203 char system_dir
[__PMAX
];
2204 char syswow_dir
[__PMAX
];
2205 size_t system_dir_len
= 0;
2206 bool convert_syswow_dir
= false;
2211 /* This fails on 32bit Windows because it has no SysWOW64 directory,
2212 and in this case a path conversion isn't necessary. */
2213 UINT len
= GetSystemWow64DirectoryA (syswow_dir
, sizeof (syswow_dir
));
2216 /* Check that we have passed a large enough buffer. */
2217 gdb_assert (len
< sizeof (syswow_dir
));
2219 len
= GetSystemDirectoryA (system_dir
, sizeof (system_dir
));
2221 gdb_assert (len
!= 0);
2222 /* Check that we have passed a large enough buffer. */
2223 gdb_assert (len
< sizeof (system_dir
));
2225 strcat (system_dir
, "\\");
2226 strcat (syswow_dir
, "\\");
2227 system_dir_len
= strlen (system_dir
);
2229 convert_syswow_dir
= true;
2233 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
2237 wchar_t dll_name
[__PMAX
];
2238 char dll_name_mb
[__PMAX
];
2240 char dll_name
[__PMAX
];
2243 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
2244 &mi
, sizeof (mi
)) == 0)
2246 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
2247 dll_name
, sizeof (dll_name
)) == 0)
2250 wcstombs (dll_name_mb
, dll_name
, __PMAX
);
2255 /* Convert the DLL path of 32bit processes returned by
2256 GetModuleFileNameEx from the 64bit system directory to the
2257 32bit syswow64 directory if necessary. */
2258 std::string syswow_dll_path
;
2259 if (convert_syswow_dir
2260 && strncasecmp (name
, system_dir
, system_dir_len
) == 0
2261 && strchr (name
+ system_dir_len
, '\\') == nullptr)
2263 syswow_dll_path
= syswow_dir
;
2264 syswow_dll_path
+= name
+ system_dir_len
;
2265 name
= syswow_dll_path
.c_str();
2268 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
2269 solib_end
= solib_end
->next
;
2274 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
2277 struct inferior
*inf
;
2279 last_sig
= GDB_SIGNAL_0
;
2281 exception_count
= 0;
2282 open_process_used
= 0;
2283 debug_registers_changed
= 0;
2284 debug_registers_used
= 0;
2285 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
2288 cygwin_load_start
= cygwin_load_end
= 0;
2290 current_event
.dwProcessId
= pid
;
2291 memset (¤t_event
, 0, sizeof (current_event
));
2292 if (!target_is_pushed (ops
))
2294 disable_breakpoints_in_shlibs ();
2295 windows_clear_solib ();
2296 clear_proceed_status (0);
2297 init_wait_for_inferior ();
2300 ignore_first_breakpoint
= !attaching
&& wow64_process
;
2304 windows_set_context_register_offsets (amd64_mappings
);
2305 windows_set_segment_register_p (amd64_windows_segment_register_p
);
2310 windows_set_context_register_offsets (i386_mappings
);
2311 windows_set_segment_register_p (i386_windows_segment_register_p
);
2314 inf
= current_inferior ();
2315 inferior_appeared (inf
, pid
);
2316 inf
->attach_flag
= attaching
;
2318 /* Make the new process the current inferior, so terminal handling
2319 can rely on it. When attaching, we don't know about any thread
2320 id here, but that's OK --- nothing should be referencing the
2321 current thread until we report an event out of windows_wait. */
2322 inferior_ptid
= ptid_t (pid
);
2324 target_terminal::init ();
2325 target_terminal::inferior ();
2327 windows_initialization_done
= 0;
2331 struct target_waitstatus status
;
2333 ops
->wait (minus_one_ptid
, &status
, 0);
2335 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
2337 if (status
.kind
!= TARGET_WAITKIND_LOADED
2338 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
2341 ops
->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
2344 /* Now that the inferior has been started and all DLLs have been mapped,
2345 we can iterate over all DLLs and load them in.
2347 We avoid doing it any earlier because, on certain versions of Windows,
2348 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
2349 we have seen on Windows 8.1 that the ntdll.dll load event does not
2350 include the DLL name, preventing us from creating an associated SO.
2351 A possible explanation is that ntdll.dll might be mapped before
2352 the SO info gets created by the Windows system -- ntdll.dll is
2353 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
2354 do not seem to suffer from that problem.
2356 Rather than try to work around this sort of issue, it is much
2357 simpler to just ignore DLL load/unload events during the startup
2358 phase, and then process them all in one batch now. */
2359 windows_add_all_dlls ();
2361 windows_initialization_done
= 1;
2365 /* Try to set or remove a user privilege to the current process. Return -1
2366 if that fails, the previous setting of that privilege otherwise.
2368 This code is copied from the Cygwin source code and rearranged to allow
2369 dynamically loading of the needed symbols from advapi32 which is only
2370 available on NT/2K/XP. */
2372 set_process_privilege (const char *privilege
, BOOL enable
)
2374 HANDLE token_hdl
= NULL
;
2376 TOKEN_PRIVILEGES new_priv
, orig_priv
;
2380 if (!OpenProcessToken (GetCurrentProcess (),
2381 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
2385 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
2388 new_priv
.PrivilegeCount
= 1;
2389 new_priv
.Privileges
[0].Luid
= restore_priv
;
2390 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
2392 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
2393 sizeof orig_priv
, &orig_priv
, &size
))
2396 /* Disabled, otherwise every `attach' in an unprivileged user session
2397 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
2398 windows_attach(). */
2399 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
2400 be enabled. GetLastError () returns an correct error code, though. */
2401 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
2405 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
2409 CloseHandle (token_hdl
);
2414 /* Attach to process PID, then initialize for debugging it. */
2417 windows_nat_target::attach (const char *args
, int from_tty
)
2422 pid
= parse_pid_to_attach (args
);
2424 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
2426 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
2427 printf_unfiltered ("This can cause attach to "
2428 "fail on Windows NT/2K/XP\n");
2431 windows_init_thread_list ();
2432 ok
= DebugActiveProcess (pid
);
2438 /* Try fall back to Cygwin pid. */
2439 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
2442 ok
= DebugActiveProcess (pid
);
2447 error (_("Can't attach to process %u (error %u)"),
2448 (unsigned) pid
, (unsigned) GetLastError ());
2450 DebugSetProcessKillOnExit (FALSE
);
2454 const char *exec_file
= get_exec_file (0);
2457 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
2458 target_pid_to_str (ptid_t (pid
)).c_str ());
2460 printf_unfiltered ("Attaching to %s\n",
2461 target_pid_to_str (ptid_t (pid
)).c_str ());
2465 HANDLE h
= OpenProcess (PROCESS_QUERY_INFORMATION
, FALSE
, pid
);
2469 if (IsWow64Process (h
, &wow64
))
2470 wow64_process
= wow64
;
2475 do_initial_windows_stuff (this, pid
, 1);
2476 target_terminal::ours ();
2480 windows_nat_target::detach (inferior
*inf
, int from_tty
)
2484 ptid_t ptid
= minus_one_ptid
;
2485 resume (ptid
, 0, GDB_SIGNAL_0
);
2487 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
2489 error (_("Can't detach process %u (error %u)"),
2490 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
2493 DebugSetProcessKillOnExit (FALSE
);
2495 if (detached
&& from_tty
)
2497 const char *exec_file
= get_exec_file (0);
2500 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
2501 (unsigned) current_event
.dwProcessId
);
2504 x86_cleanup_dregs ();
2505 inferior_ptid
= null_ptid
;
2506 detach_inferior (inf
);
2508 maybe_unpush_target ();
2511 /* Try to determine the executable filename.
2513 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2515 Upon success, the filename is stored inside EXE_NAME_RET, and
2516 this function returns nonzero.
2518 Otherwise, this function returns zero and the contents of
2519 EXE_NAME_RET is undefined. */
2522 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2532 if (!EnumProcessModulesEx (current_process_handle
, &dh_buf
,
2533 sizeof (HMODULE
), &cbNeeded
,
2534 LIST_MODULES_32BIT
) || !cbNeeded
)
2540 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2541 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2545 /* We know the executable is always first in the list of modules,
2546 which we just fetched. So no need to fetch more. */
2550 /* Cygwin prefers that the path be in /x/y/z format, so extract
2551 the filename into a temporary buffer first, and then convert it
2552 to POSIX format into the destination buffer. */
2553 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2555 len
= GetModuleFileNameEx (current_process_handle
,
2556 dh_buf
, pathbuf
, exe_name_max_len
);
2558 error (_("Error getting executable filename: %u."),
2559 (unsigned) GetLastError ());
2560 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2561 exe_name_max_len
) < 0)
2562 error (_("Error converting executable filename to POSIX: %d."), errno
);
2565 len
= GetModuleFileNameEx (current_process_handle
,
2566 dh_buf
, exe_name_ret
, exe_name_max_len
);
2568 error (_("Error getting executable filename: %u."),
2569 (unsigned) GetLastError ());
2572 return 1; /* success */
2575 /* The pid_to_exec_file target_ops method for this platform. */
2578 windows_nat_target::pid_to_exec_file (int pid
)
2580 static char path
[__PMAX
];
2582 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2584 char procexe
[sizeof ("/proc/4294967295/exe")];
2586 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2587 nchars
= readlink (procexe
, path
, sizeof(path
));
2588 if (nchars
> 0 && nchars
< sizeof (path
))
2590 path
[nchars
] = '\0'; /* Got it */
2595 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2596 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2597 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2603 /* Print status information about what we're accessing. */
2606 windows_nat_target::files_info ()
2608 struct inferior
*inf
= current_inferior ();
2610 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2611 inf
->attach_flag
? "attached" : "child",
2612 target_pid_to_str (inferior_ptid
).c_str ());
2615 /* Modify CreateProcess parameters for use of a new separate console.
2617 *FLAGS: DWORD parameter for general process creation flags.
2618 *SI: STARTUPINFO structure, for which the console window size and
2619 console buffer size is filled in if GDB is running in a console.
2620 to create the new console.
2621 The size of the used font is not available on all versions of
2622 Windows OS. Furthermore, the current font might not be the default
2623 font, but this is still better than before.
2624 If the windows and buffer sizes are computed,
2625 SI->DWFLAGS is changed so that this information is used
2626 by CreateProcess function. */
2629 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2631 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2632 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2634 if (hconsole
!= INVALID_HANDLE_VALUE
)
2636 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2638 CONSOLE_FONT_INFO cfi
;
2640 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2641 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2642 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2643 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2644 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2646 si
->dwXSize
*= font_size
.X
;
2650 si
->dwYSize
*= font_size
.Y
;
2653 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2654 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2655 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2657 *flags
|= CREATE_NEW_CONSOLE
;
2661 /* Function called by qsort to sort environment strings. */
2664 envvar_cmp (const void *a
, const void *b
)
2666 const char **p
= (const char **) a
;
2667 const char **q
= (const char **) b
;
2668 return strcasecmp (*p
, *q
);
2674 clear_win32_environment (char **env
)
2678 wchar_t *copy
= NULL
, *equalpos
;
2680 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2682 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2683 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2684 mbstowcs (copy
, env
[i
], len
);
2685 equalpos
= wcschr (copy
, L
'=');
2688 SetEnvironmentVariableW (copy
, NULL
);
2696 /* Redirection of inferior I/O streams for native MS-Windows programs.
2697 Unlike on Unix, where this is handled by invoking the inferior via
2698 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2700 The official documentation of the cmd.exe redirection features is here:
2702 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2704 (That page talks about Windows XP, but there's no newer
2705 documentation, so we assume later versions of cmd.exe didn't change
2708 Caveat: the documentation on that page seems to include a few lies.
2709 For example, it describes strange constructs 1<&2 and 2<&1, which
2710 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2711 think the cmd.exe parser of the redirection symbols simply doesn't
2712 care about the < vs > distinction in these cases. Therefore, the
2713 supported features are explicitly documented below.
2715 The emulation below aims at supporting all the valid use cases
2716 supported by cmd.exe, which include:
2718 < FILE redirect standard input from FILE
2719 0< FILE redirect standard input from FILE
2720 <&N redirect standard input from file descriptor N
2721 0<&N redirect standard input from file descriptor N
2722 > FILE redirect standard output to FILE
2723 >> FILE append standard output to FILE
2724 1>> FILE append standard output to FILE
2725 >&N redirect standard output to file descriptor N
2726 1>&N redirect standard output to file descriptor N
2727 >>&N append standard output to file descriptor N
2728 1>>&N append standard output to file descriptor N
2729 2> FILE redirect standard error to FILE
2730 2>> FILE append standard error to FILE
2731 2>&N redirect standard error to file descriptor N
2732 2>>&N append standard error to file descriptor N
2734 Note that using N > 2 in the above construct is supported, but
2735 requires that the corresponding file descriptor be open by some
2736 means elsewhere or outside GDB. Also note that using ">&0" or
2737 "<&2" will generally fail, because the file descriptor redirected
2738 from is normally open in an incompatible mode (e.g., FD 0 is open
2739 for reading only). IOW, use of such tricks is not recommended;
2740 you are on your own.
2742 We do NOT support redirection of file descriptors above 2, as in
2743 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2744 that needs special handling in the startup code that MinGW
2745 doesn't have). Pipes are also not supported.
2747 As for invalid use cases, where the redirection contains some
2748 error, the emulation below will detect that and produce some
2749 error and/or failure. But the behavior in those cases is not
2750 bug-for-bug compatible with what cmd.exe does in those cases.
2751 That's because what cmd.exe does then is not well defined, and
2752 seems to be a side effect of the cmd.exe parsing of the command
2753 line more than anything else. For example, try redirecting to an
2754 invalid file name, as in "> foo:bar".
2756 There are also minor syntactic deviations from what cmd.exe does
2757 in some corner cases. For example, it doesn't support the likes
2758 of "> &foo" to mean redirect to file named literally "&foo"; we
2759 do support that here, because that, too, sounds like some issue
2760 with the cmd.exe parser. Another nicety is that we support
2761 redirection targets that use file names with forward slashes,
2762 something cmd.exe doesn't -- this comes in handy since GDB
2763 file-name completion can be used when typing the command line for
2766 /* Support routines for redirecting standard handles of the inferior. */
2768 /* Parse a single redirection spec, open/duplicate the specified
2769 file/fd, and assign the appropriate value to one of the 3 standard
2770 file descriptors. */
2772 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2774 int *fd
, ref_fd
= -2;
2776 const char *fname
= redir_string
+ 1;
2777 int rc
= *redir_string
;
2792 fd
= (rc
== '2') ? err
: out
;
2793 mode
= O_WRONLY
| O_CREAT
;
2806 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2808 /* A reference to a file descriptor. */
2810 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2811 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2813 /* Don't allow redirection when open modes are incompatible. */
2814 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2815 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2822 else if (ref_fd
== 1)
2824 else if (ref_fd
== 2)
2834 fname
++; /* skip the separator space */
2835 /* If the descriptor is already open, close it. This allows
2836 multiple specs of redirections for the same stream, which is
2837 somewhat nonsensical, but still valid and supported by cmd.exe.
2838 (But cmd.exe only opens a single file in this case, the one
2839 specified by the last redirection spec on the command line.) */
2844 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2848 else if (ref_fd
== -1)
2849 *fd
= -1; /* reset to default destination */
2852 *fd
= _dup (ref_fd
);
2856 /* _open just sets a flag for O_APPEND, which won't be passed to the
2857 inferior, so we need to actually move the file pointer. */
2858 if ((mode
& O_APPEND
) != 0)
2859 _lseek (*fd
, 0L, SEEK_END
);
2863 /* Canonicalize a single redirection spec and set up the corresponding
2864 file descriptor as specified. */
2866 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2868 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2870 const char *start
= s
;
2873 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2874 if ((*start
== '>' || *start
== '1' || *start
== '2')
2878 if (*s
== '>' && *start
!= '>')
2881 else if (*start
== '0' && *s
== '<')
2883 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2886 while (isspace (*s
)) /* skip whitespace before file name */
2888 *d
++ = ' '; /* separate file name with a single space */
2891 /* Copy the file name. */
2894 /* Remove quoting characters from the file name in buf[]. */
2895 if (*s
== '"') /* could support '..' quoting here */
2899 else if (*s
== quote
)
2907 else if (*s
== '\\')
2909 if (s
[1] == '"') /* could support '..' here */
2913 else if (isspace (*s
) && !quote
)
2917 if (d
- buf
>= sizeof (buf
) - 1)
2919 errno
= ENAMETOOLONG
;
2925 /* Windows doesn't allow redirection characters in file names, so we
2926 can bail out early if they use them, or if there's no target file
2927 name after the redirection symbol. */
2928 if (d
[-1] == '>' || d
[-1] == '<')
2933 if (redir_open (buf
, inp
, out
, err
) == 0)
2938 /* Parse the command line for redirection specs and prepare the file
2939 descriptors for the 3 standard streams accordingly. */
2941 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2942 int *inp
, int *out
, int *err
)
2944 const char *s
= cmd_orig
;
2947 bool retval
= false;
2949 while (isspace (*s
))
2954 if (*s
== '"') /* could also support '..' quoting here */
2958 else if (*s
== quote
)
2961 else if (*s
== '\\')
2963 if (s
[1] == '"') /* escaped quote char */
2968 /* Process a single redirection candidate. */
2969 if (*s
== '<' || *s
== '>'
2970 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2971 || (*s
== '0' && s
[1] == '<'))
2973 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2987 #endif /* !__CYGWIN__ */
2989 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2990 EXEC_FILE is the file to run.
2991 ALLARGS is a string containing the arguments to the program.
2992 ENV is the environment vector to pass. Errors reported with error(). */
2995 windows_nat_target::create_inferior (const char *exec_file
,
2996 const std::string
&origallargs
,
2997 char **in_env
, int from_tty
)
3001 cygwin_buf_t real_path
[__PMAX
];
3002 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
3003 cygwin_buf_t infcwd
[__PMAX
];
3005 cygwin_buf_t
*toexec
;
3006 cygwin_buf_t
*cygallargs
;
3008 char **old_env
= NULL
;
3012 int ostdin
, ostdout
, ostderr
;
3013 #else /* !__CYGWIN__ */
3014 char shell
[__PMAX
]; /* Path to shell */
3016 char *args
, *allargs_copy
;
3017 size_t args_len
, allargs_len
;
3018 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
3019 HANDLE tty
= INVALID_HANDLE_VALUE
;
3020 bool redirected
= false;
3027 #endif /* !__CYGWIN__ */
3028 const char *allargs
= origallargs
.c_str ();
3029 PROCESS_INFORMATION pi
;
3032 const char *inferior_io_terminal
= get_inferior_io_terminal ();
3035 error (_("No executable specified, use `target exec'."));
3037 const char *inferior_cwd
= get_inferior_cwd ();
3038 std::string expanded_infcwd
;
3039 if (inferior_cwd
!= NULL
)
3041 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
3042 /* Mirror slashes on inferior's cwd. */
3043 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
3045 inferior_cwd
= expanded_infcwd
.c_str ();
3048 memset (&si
, 0, sizeof (si
));
3049 si
.cb
= sizeof (si
);
3052 flags
|= CREATE_NEW_PROCESS_GROUP
;
3055 windows_set_console_info (&si
, &flags
);
3060 flags
|= DEBUG_ONLY_THIS_PROCESS
;
3061 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
3062 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
3063 error (_("Error starting executable: %d"), errno
);
3066 len
= mbstowcs (NULL
, allargs
, 0) + 1;
3067 if (len
== (size_t) -1)
3068 error (_("Error starting executable: %d"), errno
);
3069 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
3070 mbstowcs (cygallargs
, allargs
, len
);
3071 #else /* !__USEWIDE */
3072 cygallargs
= allargs
;
3078 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
3079 error (_("Error starting executable via shell: %d"), errno
);
3081 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
3082 + mbstowcs (NULL
, allargs
, 0) + 2;
3083 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
3084 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
3085 #else /* !__USEWIDE */
3086 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
3087 + strlen (allargs
) + 2);
3088 cygallargs
= (char *) alloca (len
);
3089 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
3090 #endif /* __USEWIDE */
3092 flags
|= DEBUG_PROCESS
;
3095 if (inferior_cwd
!= NULL
3096 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
3097 infcwd
, strlen (inferior_cwd
)) < 0)
3098 error (_("Error converting inferior cwd: %d"), errno
);
3101 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
3102 * sizeof (wchar_t));
3103 wcscpy (args
, toexec
);
3104 wcscat (args
, L
" ");
3105 wcscat (args
, cygallargs
);
3106 #else /* !__USEWIDE */
3107 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
3108 strcpy (args
, toexec
);
3110 strcat (args
, cygallargs
);
3111 #endif /* !__USEWIDE */
3113 #ifdef CW_CVT_ENV_TO_WINENV
3114 /* First try to create a direct Win32 copy of the POSIX environment. */
3115 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
3116 if (w32_env
!= (PWCHAR
) -1)
3117 flags
|= CREATE_UNICODE_ENVIRONMENT
;
3119 /* If that fails, fall back to old method tweaking GDB's environment. */
3120 #endif /* CW_CVT_ENV_TO_WINENV */
3122 /* Reset all Win32 environment variables to avoid leftover on next run. */
3123 clear_win32_environment (environ
);
3124 /* Prepare the environment vars for CreateProcess. */
3127 cygwin_internal (CW_SYNC_WINENV
);
3131 if (!inferior_io_terminal
)
3132 tty
= ostdin
= ostdout
= ostderr
= -1;
3135 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
3138 print_sys_errmsg (inferior_io_terminal
, errno
);
3139 ostdin
= ostdout
= ostderr
= -1;
3152 windows_init_thread_list ();
3153 ret
= CreateProcess (0,
3154 args
, /* command line */
3155 NULL
, /* Security */
3157 TRUE
, /* inherit handles */
3158 flags
, /* start flags */
3159 w32_env
, /* environment */
3160 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
3165 /* Just free the Win32 environment, if it could be created. */
3169 /* Reset all environment variables to avoid leftover on next run. */
3170 clear_win32_environment (in_env
);
3171 /* Restore normal GDB environment variables. */
3173 cygwin_internal (CW_SYNC_WINENV
);
3186 #else /* !__CYGWIN__ */
3187 allargs_len
= strlen (allargs
);
3188 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
3189 if (strpbrk (allargs_copy
, "<>") != NULL
)
3194 redirect_inferior_handles (allargs
, allargs_copy
,
3195 &fd_inp
, &fd_out
, &fd_err
);
3197 warning (_("Error in redirection: %s."), safe_strerror (errno
));
3200 allargs_len
= strlen (allargs_copy
);
3202 /* If not all the standard streams are redirected by the command
3203 line, use inferior_io_terminal for those which aren't. */
3204 if (inferior_io_terminal
3205 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
3207 SECURITY_ATTRIBUTES sa
;
3208 sa
.nLength
= sizeof(sa
);
3209 sa
.lpSecurityDescriptor
= 0;
3210 sa
.bInheritHandle
= TRUE
;
3211 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
3212 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
3213 if (tty
== INVALID_HANDLE_VALUE
)
3214 warning (_("Warning: Failed to open TTY %s, error %#x."),
3215 inferior_io_terminal
, (unsigned) GetLastError ());
3217 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
3220 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
3221 else if (tty
!= INVALID_HANDLE_VALUE
)
3224 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
3226 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
3227 else if (tty
!= INVALID_HANDLE_VALUE
)
3228 si
.hStdOutput
= tty
;
3230 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
3232 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
3233 else if (tty
!= INVALID_HANDLE_VALUE
)
3236 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
3237 si
.dwFlags
|= STARTF_USESTDHANDLES
;
3241 /* Build the command line, a space-separated list of tokens where
3242 the first token is the name of the module to be executed.
3243 To avoid ambiguities introduced by spaces in the module name,
3245 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
3246 args
= (char *) alloca (args_len
);
3247 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
3249 flags
|= DEBUG_ONLY_THIS_PROCESS
;
3251 /* CreateProcess takes the environment list as a null terminated set of
3252 strings (i.e. two nulls terminate the list). */
3254 /* Get total size for env strings. */
3255 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
3256 envlen
+= strlen (in_env
[i
]) + 1;
3258 envsize
= sizeof (in_env
[0]) * (i
+ 1);
3259 env
= (char **) alloca (envsize
);
3260 memcpy (env
, in_env
, envsize
);
3261 /* Windows programs expect the environment block to be sorted. */
3262 qsort (env
, i
, sizeof (char *), envvar_cmp
);
3264 w32env
= (char *) alloca (envlen
+ 1);
3266 /* Copy env strings into new buffer. */
3267 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
3269 strcpy (temp
, env
[i
]);
3270 temp
+= strlen (temp
) + 1;
3273 /* Final nil string to terminate new env. */
3276 windows_init_thread_list ();
3277 ret
= CreateProcessA (0,
3278 args
, /* command line */
3279 NULL
, /* Security */
3281 TRUE
, /* inherit handles */
3282 flags
, /* start flags */
3283 w32env
, /* environment */
3284 inferior_cwd
, /* current directory */
3287 if (tty
!= INVALID_HANDLE_VALUE
)
3295 #endif /* !__CYGWIN__ */
3298 error (_("Error creating process %s, (error %u)."),
3299 exec_file
, (unsigned) GetLastError ());
3303 if (IsWow64Process (pi
.hProcess
, &wow64
))
3304 wow64_process
= wow64
;
3307 CloseHandle (pi
.hThread
);
3308 CloseHandle (pi
.hProcess
);
3310 if (useshell
&& shell
[0] != '\0')
3315 do_initial_windows_stuff (this, pi
.dwProcessId
, 0);
3317 /* windows_continue (DBG_CONTINUE, -1, 0); */
3321 windows_nat_target::mourn_inferior ()
3323 (void) windows_continue (DBG_CONTINUE
, -1, 0);
3324 x86_cleanup_dregs();
3325 if (open_process_used
)
3327 CHECK (CloseHandle (current_process_handle
));
3328 open_process_used
= 0;
3330 siginfo_er
.ExceptionCode
= 0;
3331 inf_child_target::mourn_inferior ();
3334 /* Send a SIGINT to the process group. This acts just like the user typed a
3335 ^C on the controlling terminal. */
3338 windows_nat_target::interrupt ()
3340 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
3341 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
3342 registers_changed (); /* refresh register state */
3345 /* Helper for windows_xfer_partial that handles memory transfers.
3346 Arguments are like target_xfer_partial. */
3348 static enum target_xfer_status
3349 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3350 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
3354 DWORD lasterror
= 0;
3356 if (writebuf
!= NULL
)
3358 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
3359 pulongest (len
), core_addr_to_string (memaddr
)));
3360 success
= WriteProcessMemory (current_process_handle
,
3361 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
3364 lasterror
= GetLastError ();
3365 FlushInstructionCache (current_process_handle
,
3366 (LPCVOID
) (uintptr_t) memaddr
, len
);
3370 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
3371 pulongest (len
), core_addr_to_string (memaddr
)));
3372 success
= ReadProcessMemory (current_process_handle
,
3373 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
3376 lasterror
= GetLastError ();
3378 *xfered_len
= (ULONGEST
) done
;
3379 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
3380 return TARGET_XFER_OK
;
3382 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
3386 windows_nat_target::kill ()
3388 CHECK (TerminateProcess (current_process_handle
, 0));
3392 if (!windows_continue (DBG_CONTINUE
, -1, 1))
3394 if (!wait_for_debug_event (¤t_event
, INFINITE
))
3396 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
3400 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
3404 windows_nat_target::close ()
3406 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
3407 inferior_ptid
.pid ()));
3410 /* Convert pid to printable format. */
3412 windows_nat_target::pid_to_str (ptid_t ptid
)
3414 if (ptid
.lwp () != 0)
3415 return string_printf ("Thread %d.0x%lx", ptid
.pid (), ptid
.lwp ());
3417 return normal_pid_to_str (ptid
);
3420 static enum target_xfer_status
3421 windows_xfer_shared_libraries (struct target_ops
*ops
,
3422 enum target_object object
, const char *annex
,
3423 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3424 ULONGEST offset
, ULONGEST len
,
3425 ULONGEST
*xfered_len
)
3427 struct obstack obstack
;
3433 return TARGET_XFER_E_IO
;
3435 obstack_init (&obstack
);
3436 obstack_grow_str (&obstack
, "<library-list>\n");
3437 for (so
= solib_start
.next
; so
; so
= so
->next
)
3439 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
3441 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
3442 (uintptr_t) li
->load_addr
,
3444 target_gdbarch (), &obstack
);
3446 obstack_grow_str0 (&obstack
, "</library-list>\n");
3448 buf
= (const char *) obstack_finish (&obstack
);
3449 len_avail
= strlen (buf
);
3450 if (offset
>= len_avail
)
3454 if (len
> len_avail
- offset
)
3455 len
= len_avail
- offset
;
3456 memcpy (readbuf
, buf
+ offset
, len
);
3459 obstack_free (&obstack
, NULL
);
3460 *xfered_len
= (ULONGEST
) len
;
3461 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
3464 /* Helper for windows_nat_target::xfer_partial that handles signal info. */
3466 static enum target_xfer_status
3467 windows_xfer_siginfo (gdb_byte
*readbuf
, ULONGEST offset
, ULONGEST len
,
3468 ULONGEST
*xfered_len
)
3470 char *buf
= (char *) &siginfo_er
;
3471 size_t bufsize
= sizeof (siginfo_er
);
3474 EXCEPTION_RECORD32 er32
;
3477 buf
= (char *) &er32
;
3478 bufsize
= sizeof (er32
);
3480 er32
.ExceptionCode
= siginfo_er
.ExceptionCode
;
3481 er32
.ExceptionFlags
= siginfo_er
.ExceptionFlags
;
3482 er32
.ExceptionRecord
= (uintptr_t) siginfo_er
.ExceptionRecord
;
3483 er32
.ExceptionAddress
= (uintptr_t) siginfo_er
.ExceptionAddress
;
3484 er32
.NumberParameters
= siginfo_er
.NumberParameters
;
3486 for (i
= 0; i
< EXCEPTION_MAXIMUM_PARAMETERS
; i
++)
3487 er32
.ExceptionInformation
[i
] = siginfo_er
.ExceptionInformation
[i
];
3491 if (siginfo_er
.ExceptionCode
== 0)
3492 return TARGET_XFER_E_IO
;
3494 if (readbuf
== nullptr)
3495 return TARGET_XFER_E_IO
;
3497 if (offset
> bufsize
)
3498 return TARGET_XFER_E_IO
;
3500 if (offset
+ len
> bufsize
)
3501 len
= bufsize
- offset
;
3503 memcpy (readbuf
, buf
+ offset
, len
);
3506 return TARGET_XFER_OK
;
3509 enum target_xfer_status
3510 windows_nat_target::xfer_partial (enum target_object object
,
3511 const char *annex
, gdb_byte
*readbuf
,
3512 const gdb_byte
*writebuf
, ULONGEST offset
,
3513 ULONGEST len
, ULONGEST
*xfered_len
)
3517 case TARGET_OBJECT_MEMORY
:
3518 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
3520 case TARGET_OBJECT_LIBRARIES
:
3521 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
3522 writebuf
, offset
, len
, xfered_len
);
3524 case TARGET_OBJECT_SIGNAL_INFO
:
3525 return windows_xfer_siginfo (readbuf
, offset
, len
, xfered_len
);
3528 if (beneath () == NULL
)
3530 /* This can happen when requesting the transfer of unsupported
3531 objects before a program has been started (and therefore
3532 with the current_target having no target beneath). */
3533 return TARGET_XFER_E_IO
;
3535 return beneath ()->xfer_partial (object
, annex
,
3536 readbuf
, writebuf
, offset
, len
,
3541 /* Provide thread local base, i.e. Thread Information Block address.
3542 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
3545 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
3547 windows_thread_info
*th
;
3549 th
= thread_rec (ptid
.lwp (), DONT_INVALIDATE_CONTEXT
);
3554 *addr
= th
->thread_local_base
;
3560 windows_nat_target::get_ada_task_ptid (long lwp
, long thread
)
3562 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
3565 /* Implementation of the to_thread_name method. */
3568 windows_nat_target::thread_name (struct thread_info
*thr
)
3570 return thread_rec (thr
->ptid
.lwp (), DONT_INVALIDATE_CONTEXT
)->name
.get ();
3574 void _initialize_windows_nat ();
3576 _initialize_windows_nat ()
3578 x86_dr_low
.set_control
= cygwin_set_dr7
;
3579 x86_dr_low
.set_addr
= cygwin_set_dr
;
3580 x86_dr_low
.get_addr
= cygwin_get_dr
;
3581 x86_dr_low
.get_status
= cygwin_get_dr6
;
3582 x86_dr_low
.get_control
= cygwin_get_dr7
;
3584 /* x86_dr_low.debug_register_length field is set by
3585 calling x86_set_debug_register_length function
3586 in processor windows specific native file. */
3588 add_inf_child_target (&the_windows_nat_target
);
3591 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3594 add_com ("signal-event", class_run
, signal_event_command
, _("\
3595 Signal a crashed process with event ID, to allow its debugging.\n\
3596 This command is needed in support of setting up GDB as JIT debugger on \
3597 MS-Windows. The command should be invoked from the GDB command line using \
3598 the '-ex' command-line option. The ID of the event that blocks the \
3599 crashed process will be supplied by the Windows JIT debugging mechanism."));
3602 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3603 Set use of shell to start subprocess."), _("\
3604 Show use of shell to start subprocess."), NULL
,
3606 NULL
, /* FIXME: i18n: */
3607 &setlist
, &showlist
);
3609 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3610 &cygwin_exceptions
, _("\
3611 Break when an exception is detected in the Cygwin DLL itself."), _("\
3612 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3614 NULL
, /* FIXME: i18n: */
3615 &setlist
, &showlist
);
3618 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3619 Set creation of new console when creating child process."), _("\
3620 Show creation of new console when creating child process."), NULL
,
3622 NULL
, /* FIXME: i18n: */
3623 &setlist
, &showlist
);
3625 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3626 Set creation of new group when creating child process."), _("\
3627 Show creation of new group when creating child process."), NULL
,
3629 NULL
, /* FIXME: i18n: */
3630 &setlist
, &showlist
);
3632 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3633 Set whether to display execution in child process."), _("\
3634 Show whether to display execution in child process."), NULL
,
3636 NULL
, /* FIXME: i18n: */
3637 &setlist
, &showlist
);
3639 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3640 Set whether to display kernel events in child process."), _("\
3641 Show whether to display kernel events in child process."), NULL
,
3643 NULL
, /* FIXME: i18n: */
3644 &setlist
, &showlist
);
3646 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3647 Set whether to display memory accesses in child process."), _("\
3648 Show whether to display memory accesses in child process."), NULL
,
3650 NULL
, /* FIXME: i18n: */
3651 &setlist
, &showlist
);
3653 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3654 &debug_exceptions
, _("\
3655 Set whether to display kernel exceptions in child process."), _("\
3656 Show whether to display kernel exceptions in child process."), NULL
,
3658 NULL
, /* FIXME: i18n: */
3659 &setlist
, &showlist
);
3661 init_w32_command_list ();
3663 add_cmd ("selector", class_info
, display_selectors
,
3664 _("Display selectors infos."),
3668 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3670 /* Pass the address ADDR to the inferior in the I'th debug register.
3671 Here we just store the address in dr array, the registers will be
3672 actually set up when windows_continue is called. */
3674 cygwin_set_dr (int i
, CORE_ADDR addr
)
3677 internal_error (__FILE__
, __LINE__
,
3678 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3680 debug_registers_changed
= 1;
3681 debug_registers_used
= 1;
3684 /* Pass the value VAL to the inferior in the DR7 debug control
3685 register. Here we just store the address in D_REGS, the watchpoint
3686 will be actually set up in windows_wait. */
3688 cygwin_set_dr7 (unsigned long val
)
3690 dr
[7] = (CORE_ADDR
) val
;
3691 debug_registers_changed
= 1;
3692 debug_registers_used
= 1;
3695 /* Get the value of debug register I from the inferior. */
3698 cygwin_get_dr (int i
)
3703 /* Get the value of the DR6 debug status register from the inferior.
3704 Here we just return the value stored in dr[6]
3705 by the last call to thread_rec for current_event.dwThreadId id. */
3706 static unsigned long
3707 cygwin_get_dr6 (void)
3709 return (unsigned long) dr
[6];
3712 /* Get the value of the DR7 debug status register from the inferior.
3713 Here we just return the value stored in dr[7] by the last call to
3714 thread_rec for current_event.dwThreadId id. */
3716 static unsigned long
3717 cygwin_get_dr7 (void)
3719 return (unsigned long) dr
[7];
3722 /* Determine if the thread referenced by "ptid" is alive
3723 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3724 it means that the thread has died. Otherwise it is assumed to be alive. */
3727 windows_nat_target::thread_alive (ptid_t ptid
)
3731 gdb_assert (ptid
.lwp () != 0);
3734 return (WaitForSingleObject (thread_rec (tid
, DONT_INVALIDATE_CONTEXT
)->h
, 0)
3738 void _initialize_check_for_gdb_ini ();
3740 _initialize_check_for_gdb_ini ()
3743 if (inhibit_gdbinit
)
3746 homedir
= getenv ("HOME");
3750 char *oldini
= (char *) alloca (strlen (homedir
) +
3751 sizeof ("gdb.ini") + 1);
3752 strcpy (oldini
, homedir
);
3753 p
= strchr (oldini
, '\0');
3754 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3756 strcpy (p
, "gdb.ini");
3757 if (access (oldini
, 0) == 0)
3759 int len
= strlen (oldini
);
3760 char *newini
= (char *) alloca (len
+ 2);
3762 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3763 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3764 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3769 /* Define dummy functions which always return error for the rare cases where
3770 these functions could not be found. */
3772 bad_DebugActiveProcessStop (DWORD w
)
3777 bad_DebugBreakProcess (HANDLE w
)
3782 bad_DebugSetProcessKillOnExit (BOOL w
)
3787 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3794 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3800 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3807 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3813 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3819 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3825 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3833 /* Load any functions which may not be available in ancient versions
3836 void _initialize_loadable ();
3838 _initialize_loadable ()
3842 #define GPA(m, func) \
3843 func = (func ## _ftype *) GetProcAddress (m, #func)
3845 hm
= LoadLibrary ("kernel32.dll");
3848 GPA (hm
, DebugActiveProcessStop
);
3849 GPA (hm
, DebugBreakProcess
);
3850 GPA (hm
, DebugSetProcessKillOnExit
);
3851 GPA (hm
, GetConsoleFontSize
);
3852 GPA (hm
, DebugActiveProcessStop
);
3853 GPA (hm
, GetCurrentConsoleFont
);
3855 GPA (hm
, Wow64SuspendThread
);
3856 GPA (hm
, Wow64GetThreadContext
);
3857 GPA (hm
, Wow64SetThreadContext
);
3858 GPA (hm
, Wow64GetThreadSelectorEntry
);
3862 /* Set variables to dummy versions of these processes if the function
3863 wasn't found in kernel32.dll. */
3864 if (!DebugBreakProcess
)
3865 DebugBreakProcess
= bad_DebugBreakProcess
;
3866 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3868 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3869 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3871 if (!GetConsoleFontSize
)
3872 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3873 if (!GetCurrentConsoleFont
)
3874 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3876 /* Load optional functions used for retrieving filename information
3877 associated with the currently debugged process or its dlls. */
3878 hm
= LoadLibrary ("psapi.dll");
3881 GPA (hm
, EnumProcessModules
);
3883 GPA (hm
, EnumProcessModulesEx
);
3885 GPA (hm
, GetModuleInformation
);
3886 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3887 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3890 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3892 /* Set variables to dummy versions of these processes if the function
3893 wasn't found in psapi.dll. */
3894 EnumProcessModules
= bad_EnumProcessModules
;
3895 GetModuleInformation
= bad_GetModuleInformation
;
3896 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3897 /* This will probably fail on Windows 9x/Me. Let the user know
3898 that we're missing some functionality. */
3900 cannot automatically find executable file or library to read symbols.\n\
3901 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3904 hm
= LoadLibrary ("advapi32.dll");
3907 GPA (hm
, OpenProcessToken
);
3908 GPA (hm
, LookupPrivilegeValueA
);
3909 GPA (hm
, AdjustTokenPrivileges
);
3910 /* Only need to set one of these since if OpenProcessToken fails nothing
3912 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3913 || !AdjustTokenPrivileges
)
3914 OpenProcessToken
= bad_OpenProcessToken
;