1 /* Target-vector operations for controlling windows child processes, for GDB.
3 Copyright (C) 1995-2020 Free Software Foundation, Inc.
5 Contributed by Cygnus Solutions, A Red Hat Company.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 /* Originally by Steve Chamberlain, sac@cygnus.com */
25 #include "frame.h" /* required by inferior.h */
31 #include "completer.h"
35 #include <sys/types.h>
42 #include <sys/cygwin.h>
43 #include <cygwin/version.h>
48 #include "filenames.h"
52 #include "gdb_obstack.h"
53 #include "gdbthread.h"
59 #include "xml-support.h"
62 #include "i386-tdep.h"
63 #include "i387-tdep.h"
65 #include "windows-tdep.h"
66 #include "windows-nat.h"
68 #include "complaints.h"
69 #include "inf-child.h"
70 #include "gdbsupport/gdb_tilde_expand.h"
71 #include "gdbsupport/pathstuff.h"
72 #include "gdbsupport/gdb_wait.h"
73 #include "nat/windows-nat.h"
75 #define STATUS_WX86_BREAKPOINT 0x4000001F
76 #define STATUS_WX86_SINGLE_STEP 0x4000001E
78 using namespace windows_nat
;
80 #define AdjustTokenPrivileges dyn_AdjustTokenPrivileges
81 #define DebugActiveProcessStop dyn_DebugActiveProcessStop
82 #define DebugBreakProcess dyn_DebugBreakProcess
83 #define DebugSetProcessKillOnExit dyn_DebugSetProcessKillOnExit
84 #define EnumProcessModules dyn_EnumProcessModules
85 #define EnumProcessModulesEx dyn_EnumProcessModulesEx
86 #define GetModuleInformation dyn_GetModuleInformation
87 #define LookupPrivilegeValueA dyn_LookupPrivilegeValueA
88 #define OpenProcessToken dyn_OpenProcessToken
89 #define GetConsoleFontSize dyn_GetConsoleFontSize
90 #define GetCurrentConsoleFont dyn_GetCurrentConsoleFont
91 #define Wow64SuspendThread dyn_Wow64SuspendThread
92 #define Wow64GetThreadContext dyn_Wow64GetThreadContext
93 #define Wow64SetThreadContext dyn_Wow64SetThreadContext
94 #define Wow64GetThreadSelectorEntry dyn_Wow64GetThreadSelectorEntry
96 typedef BOOL
WINAPI (AdjustTokenPrivileges_ftype
) (HANDLE
, BOOL
,
98 DWORD
, PTOKEN_PRIVILEGES
,
100 static AdjustTokenPrivileges_ftype
*AdjustTokenPrivileges
;
102 typedef BOOL
WINAPI (DebugActiveProcessStop_ftype
) (DWORD
);
103 static DebugActiveProcessStop_ftype
*DebugActiveProcessStop
;
105 typedef BOOL
WINAPI (DebugBreakProcess_ftype
) (HANDLE
);
106 static DebugBreakProcess_ftype
*DebugBreakProcess
;
108 typedef BOOL
WINAPI (DebugSetProcessKillOnExit_ftype
) (BOOL
);
109 static DebugSetProcessKillOnExit_ftype
*DebugSetProcessKillOnExit
;
111 typedef BOOL
WINAPI (EnumProcessModules_ftype
) (HANDLE
, HMODULE
*, DWORD
,
113 static EnumProcessModules_ftype
*EnumProcessModules
;
116 typedef BOOL
WINAPI (EnumProcessModulesEx_ftype
) (HANDLE
, HMODULE
*, DWORD
,
118 static EnumProcessModulesEx_ftype
*EnumProcessModulesEx
;
121 typedef BOOL
WINAPI (GetModuleInformation_ftype
) (HANDLE
, HMODULE
,
122 LPMODULEINFO
, DWORD
);
123 static GetModuleInformation_ftype
*GetModuleInformation
;
125 typedef BOOL
WINAPI (LookupPrivilegeValueA_ftype
) (LPCSTR
, LPCSTR
, PLUID
);
126 static LookupPrivilegeValueA_ftype
*LookupPrivilegeValueA
;
128 typedef BOOL
WINAPI (OpenProcessToken_ftype
) (HANDLE
, DWORD
, PHANDLE
);
129 static OpenProcessToken_ftype
*OpenProcessToken
;
131 typedef BOOL
WINAPI (GetCurrentConsoleFont_ftype
) (HANDLE
, BOOL
,
132 CONSOLE_FONT_INFO
*);
133 static GetCurrentConsoleFont_ftype
*GetCurrentConsoleFont
;
135 typedef COORD
WINAPI (GetConsoleFontSize_ftype
) (HANDLE
, DWORD
);
136 static GetConsoleFontSize_ftype
*GetConsoleFontSize
;
139 typedef DWORD
WINAPI (Wow64SuspendThread_ftype
) (HANDLE
);
140 static Wow64SuspendThread_ftype
*Wow64SuspendThread
;
142 typedef BOOL
WINAPI (Wow64GetThreadContext_ftype
) (HANDLE
, PWOW64_CONTEXT
);
143 static Wow64GetThreadContext_ftype
*Wow64GetThreadContext
;
145 typedef BOOL
WINAPI (Wow64SetThreadContext_ftype
) (HANDLE
,
146 const WOW64_CONTEXT
*);
147 static Wow64SetThreadContext_ftype
*Wow64SetThreadContext
;
149 typedef BOOL
WINAPI (Wow64GetThreadSelectorEntry_ftype
) (HANDLE
, DWORD
,
151 static Wow64GetThreadSelectorEntry_ftype
*Wow64GetThreadSelectorEntry
;
156 #undef GetModuleFileNameEx
159 # define __PMAX (MAX_PATH + 1)
160 typedef DWORD
WINAPI (GetModuleFileNameEx_ftype
) (HANDLE
, HMODULE
, LPSTR
, DWORD
);
161 static GetModuleFileNameEx_ftype
*GetModuleFileNameEx
;
162 # define STARTUPINFO STARTUPINFOA
163 # define CreateProcess CreateProcessA
164 # define GetModuleFileNameEx_name "GetModuleFileNameExA"
165 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
167 # define __PMAX PATH_MAX
168 /* The starting and ending address of the cygwin1.dll text segment. */
169 static CORE_ADDR cygwin_load_start
;
170 static CORE_ADDR cygwin_load_end
;
172 typedef wchar_t cygwin_buf_t
;
173 typedef DWORD
WINAPI (GetModuleFileNameEx_ftype
) (HANDLE
, HMODULE
,
175 static GetModuleFileNameEx_ftype
*GetModuleFileNameEx
;
176 # define STARTUPINFO STARTUPINFOW
177 # define CreateProcess CreateProcessW
178 # define GetModuleFileNameEx_name "GetModuleFileNameExW"
179 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExW
182 static int have_saved_context
; /* True if we've saved context from a
185 static CONTEXT saved_context
; /* Contains the saved context from a
189 /* If we're not using the old Cygwin header file set, define the
190 following which never should have been in the generic Win32 API
191 headers in the first place since they were our own invention... */
192 #ifndef _GNU_H_WINDOWS_H
195 FLAG_TRACE_BIT
= 0x100,
199 #ifndef CONTEXT_EXTENDED_REGISTERS
200 /* This macro is only defined on ia32. It only makes sense on this target,
201 so define it as zero if not already defined. */
202 #define CONTEXT_EXTENDED_REGISTERS 0
205 #define CONTEXT_DEBUGGER_DR CONTEXT_FULL | CONTEXT_FLOATING_POINT \
206 | CONTEXT_SEGMENTS | CONTEXT_DEBUG_REGISTERS \
207 | CONTEXT_EXTENDED_REGISTERS
209 static uintptr_t dr
[8];
210 static int debug_registers_changed
;
211 static int debug_registers_used
;
213 static int windows_initialization_done
;
214 #define DR6_CLEAR_VALUE 0xffff0ff0
216 /* The exception thrown by a program to tell the debugger the name of
217 a thread. The exception record contains an ID of a thread and a
218 name to give it. This exception has no documented name, but MSDN
219 dubs it "MS_VC_EXCEPTION" in one code example. */
220 #define MS_VC_EXCEPTION 0x406d1388
224 HANDLE_EXCEPTION_UNHANDLED
= 0,
225 HANDLE_EXCEPTION_HANDLED
,
226 HANDLE_EXCEPTION_IGNORED
227 } handle_exception_result
;
229 /* The string sent by cygwin when it processes a signal.
230 FIXME: This should be in a cygwin include file. */
231 #ifndef _CYGWIN_SIGNAL_STRING
232 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
235 #define CHECK(x) check (x, __FILE__,__LINE__)
236 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
237 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
238 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
239 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
241 static void cygwin_set_dr (int i
, CORE_ADDR addr
);
242 static void cygwin_set_dr7 (unsigned long val
);
243 static CORE_ADDR
cygwin_get_dr (int i
);
244 static unsigned long cygwin_get_dr6 (void);
245 static unsigned long cygwin_get_dr7 (void);
247 static enum gdb_signal last_sig
= GDB_SIGNAL_0
;
248 /* Set if a signal was received from the debugged process. */
250 static std::vector
<windows_thread_info
*> thread_list
;
252 /* The process and thread handles for the above context. */
254 /* The current debug event from WaitForDebugEvent or from a pending
256 static DEBUG_EVENT current_event
;
258 /* The most recent event from WaitForDebugEvent. Unlike
259 current_event, this is guaranteed never to come from a pending
260 stop. This is important because only data from the most recent
261 event from WaitForDebugEvent can be used when calling
262 ContinueDebugEvent. */
263 static DEBUG_EVENT last_wait_event
;
265 static HANDLE current_process_handle
; /* Currently executing process */
266 static windows_thread_info
*current_thread
; /* Info on currently selected thread */
267 static EXCEPTION_RECORD siginfo_er
; /* Contents of $_siginfo */
269 /* Counts of things. */
270 static int exception_count
= 0;
271 static int event_count
= 0;
272 static int saw_create
;
273 static int open_process_used
= 0;
275 static bool wow64_process
= false;
276 static bool ignore_first_breakpoint
= false;
280 static bool new_console
= false;
282 static bool cygwin_exceptions
= false;
284 static bool new_group
= true;
285 static bool debug_exec
= false; /* show execution */
286 static bool debug_events
= false; /* show events from kernel */
287 static bool debug_memory
= false; /* show target memory accesses */
288 static bool debug_exceptions
= false; /* show target exceptions */
289 static bool useshell
= false; /* use shell for subprocesses */
291 /* This vector maps GDB's idea of a register's number into an offset
292 in the windows exception context vector.
294 It also contains the bit mask needed to load the register in question.
296 The contents of this table can only be computed by the units
297 that provide CPU-specific support for Windows native debugging.
298 These units should set the table by calling
299 windows_set_context_register_offsets.
301 One day we could read a reg, we could inspect the context we
302 already have loaded, if it doesn't have the bit set that we need,
303 we read that set of registers in using GetThreadContext. If the
304 context already contains what we need, we just unpack it. Then to
305 write a register, first we have to ensure that the context contains
306 the other regs of the group, and then we copy the info in and set
309 static const int *mappings
;
311 /* The function to use in order to determine whether a register is
312 a segment register or not. */
313 static segment_register_p_ftype
*segment_register_p
;
315 /* See windows_nat_target::resume to understand why this is commented
318 /* This vector maps the target's idea of an exception (extracted
319 from the DEBUG_EVENT structure) to GDB's idea. */
321 struct xlate_exception
327 static const struct xlate_exception xlate
[] =
329 {EXCEPTION_ACCESS_VIOLATION
, GDB_SIGNAL_SEGV
},
330 {STATUS_STACK_OVERFLOW
, GDB_SIGNAL_SEGV
},
331 {EXCEPTION_BREAKPOINT
, GDB_SIGNAL_TRAP
},
332 {DBG_CONTROL_C
, GDB_SIGNAL_INT
},
333 {EXCEPTION_SINGLE_STEP
, GDB_SIGNAL_TRAP
},
334 {STATUS_FLOAT_DIVIDE_BY_ZERO
, GDB_SIGNAL_FPE
}
339 /* The ID of the thread for which we anticipate a stop event.
340 Normally this is -1, meaning we'll accept an event in any
342 static DWORD desired_stop_thread_id
= -1;
344 /* A single pending stop. See "pending_stops" for more
351 /* The target waitstatus we computed. */
352 target_waitstatus status
;
354 /* The event. A few fields of this can be referenced after a stop,
355 and it seemed simplest to store the entire event. */
359 /* A vector of pending stops. Sometimes, Windows will report a stop
360 on a thread that has been ostensibly suspended. We believe what
361 happens here is that two threads hit a breakpoint simultaneously,
362 and the Windows kernel queues the stop events. However, this can
363 result in the strange effect of trying to single step thread A --
364 leaving all other threads suspended -- and then seeing a stop in
365 thread B. To handle this scenario, we queue all such "pending"
366 stops here, and then process them once the step has completed. See
368 static std::vector
<pending_stop
> pending_stops
;
370 struct windows_nat_target final
: public x86_nat_target
<inf_child_target
>
372 void close () override
;
374 void attach (const char *, int) override
;
376 bool attach_no_wait () override
379 void detach (inferior
*, int) override
;
381 void resume (ptid_t
, int , enum gdb_signal
) override
;
383 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
385 void fetch_registers (struct regcache
*, int) override
;
386 void store_registers (struct regcache
*, int) override
;
388 bool stopped_by_sw_breakpoint () override
390 return current_thread
->stopped_at_software_breakpoint
;
393 bool supports_stopped_by_sw_breakpoint () override
398 enum target_xfer_status
xfer_partial (enum target_object object
,
401 const gdb_byte
*writebuf
,
402 ULONGEST offset
, ULONGEST len
,
403 ULONGEST
*xfered_len
) override
;
405 void files_info () override
;
407 void kill () override
;
409 void create_inferior (const char *, const std::string
&,
410 char **, int) override
;
412 void mourn_inferior () override
;
414 bool thread_alive (ptid_t ptid
) override
;
416 std::string
pid_to_str (ptid_t
) override
;
418 void interrupt () override
;
420 char *pid_to_exec_file (int pid
) override
;
422 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
424 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
426 const char *thread_name (struct thread_info
*) override
;
428 int get_windows_debug_event (int pid
, struct target_waitstatus
*ourstatus
);
431 static windows_nat_target the_windows_nat_target
;
433 /* Set the MAPPINGS static global to OFFSETS.
434 See the description of MAPPINGS for more details. */
437 windows_set_context_register_offsets (const int *offsets
)
442 /* Set the function that should be used by this module to determine
443 whether a given register is a segment register or not. */
446 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
448 segment_register_p
= fun
;
452 check (BOOL ok
, const char *file
, int line
)
455 printf_filtered ("error return %s:%d was %u\n", file
, line
,
456 (unsigned) GetLastError ());
459 /* See nat/windows-nat.h. */
461 windows_thread_info
*
462 windows_nat::thread_rec (ptid_t ptid
, thread_disposition_type disposition
)
464 for (windows_thread_info
*th
: thread_list
)
465 if (th
->tid
== ptid
.lwp ())
471 case DONT_INVALIDATE_CONTEXT
:
474 case INVALIDATE_CONTEXT
:
475 if (ptid
.lwp () != current_event
.dwThreadId
)
477 th
->reload_context
= true;
480 th
->reload_context
= true;
491 /* Add a thread to the thread list.
493 PTID is the ptid of the thread to be added.
494 H is its Windows handle.
495 TLB is its thread local base.
496 MAIN_THREAD_P should be true if the thread to be added is
497 the main thread, false otherwise. */
499 static windows_thread_info
*
500 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
, bool main_thread_p
)
502 windows_thread_info
*th
;
504 gdb_assert (ptid
.lwp () != 0);
506 if ((th
= thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
)))
509 CORE_ADDR base
= (CORE_ADDR
) (uintptr_t) tlb
;
511 /* For WOW64 processes, this is actually the pointer to the 64bit TIB,
512 and the 32bit TIB is exactly 2 pages after it. */
516 th
= new windows_thread_info (ptid
.lwp (), h
, base
);
517 thread_list
.push_back (th
);
519 /* Add this new thread to the list of threads.
521 To be consistent with what's done on other platforms, we add
522 the main thread silently (in reality, this thread is really
523 more of a process to the user than a thread). */
525 add_thread_silent (&the_windows_nat_target
, ptid
);
527 add_thread (&the_windows_nat_target
, ptid
);
529 /* Set the debug registers for the new thread if they are used. */
530 if (debug_registers_used
)
535 /* Only change the value of the debug registers. */
536 th
->wow64_context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
537 CHECK (Wow64GetThreadContext (th
->h
, &th
->wow64_context
));
538 th
->wow64_context
.Dr0
= dr
[0];
539 th
->wow64_context
.Dr1
= dr
[1];
540 th
->wow64_context
.Dr2
= dr
[2];
541 th
->wow64_context
.Dr3
= dr
[3];
542 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
543 th
->wow64_context
.Dr7
= dr
[7];
544 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
545 th
->wow64_context
.ContextFlags
= 0;
550 /* Only change the value of the debug registers. */
551 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
552 CHECK (GetThreadContext (th
->h
, &th
->context
));
553 th
->context
.Dr0
= dr
[0];
554 th
->context
.Dr1
= dr
[1];
555 th
->context
.Dr2
= dr
[2];
556 th
->context
.Dr3
= dr
[3];
557 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
558 th
->context
.Dr7
= dr
[7];
559 CHECK (SetThreadContext (th
->h
, &th
->context
));
560 th
->context
.ContextFlags
= 0;
566 /* Clear out any old thread list and reinitialize it to a
569 windows_init_thread_list (void)
571 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
574 for (windows_thread_info
*here
: thread_list
)
577 thread_list
.clear ();
580 /* Delete a thread from the list of threads.
582 PTID is the ptid of the thread to be deleted.
583 EXIT_CODE is the thread's exit code.
584 MAIN_THREAD_P should be true if the thread to be deleted is
585 the main thread, false otherwise. */
588 windows_delete_thread (ptid_t ptid
, DWORD exit_code
, bool main_thread_p
)
592 gdb_assert (ptid
.lwp () != 0);
596 /* Emit a notification about the thread being deleted.
598 Note that no notification was printed when the main thread
599 was created, and thus, unless in verbose mode, we should be
600 symmetrical, and avoid that notification for the main thread
604 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
).c_str ());
605 else if (print_thread_events
&& !main_thread_p
)
606 printf_unfiltered (_("[%s exited with code %u]\n"),
607 target_pid_to_str (ptid
).c_str (),
608 (unsigned) exit_code
);
610 delete_thread (find_thread_ptid (&the_windows_nat_target
, ptid
));
612 auto iter
= std::find_if (thread_list
.begin (), thread_list
.end (),
613 [=] (windows_thread_info
*th
)
615 return th
->tid
== id
;
618 if (iter
!= thread_list
.end ())
621 thread_list
.erase (iter
);
625 /* Fetches register number R from the given windows_thread_info,
626 and supplies its value to the given regcache.
628 This function assumes that R is non-negative. A failed assertion
629 is raised if that is not true.
631 This function assumes that TH->RELOAD_CONTEXT is not set, meaning
632 that the windows_thread_info has an up-to-date context. A failed
633 assertion is raised if that assumption is violated. */
636 windows_fetch_one_register (struct regcache
*regcache
,
637 windows_thread_info
*th
, int r
)
640 gdb_assert (!th
->reload_context
);
642 char *context_ptr
= (char *) &th
->context
;
645 context_ptr
= (char *) &th
->wow64_context
;
648 char *context_offset
= context_ptr
+ mappings
[r
];
649 struct gdbarch
*gdbarch
= regcache
->arch ();
650 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
652 gdb_assert (!gdbarch_read_pc_p (gdbarch
));
653 gdb_assert (gdbarch_pc_regnum (gdbarch
) >= 0);
654 gdb_assert (!gdbarch_write_pc_p (gdbarch
));
656 if (r
== I387_FISEG_REGNUM (tdep
))
658 long l
= *((long *) context_offset
) & 0xffff;
659 regcache
->raw_supply (r
, (char *) &l
);
661 else if (r
== I387_FOP_REGNUM (tdep
))
663 long l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
664 regcache
->raw_supply (r
, (char *) &l
);
666 else if (segment_register_p (r
))
668 /* GDB treats segment registers as 32bit registers, but they are
669 in fact only 16 bits long. Make sure we do not read extra
670 bits from our source buffer. */
671 long l
= *((long *) context_offset
) & 0xffff;
672 regcache
->raw_supply (r
, (char *) &l
);
676 if (th
->stopped_at_software_breakpoint
677 && r
== gdbarch_pc_regnum (gdbarch
))
679 int size
= register_size (gdbarch
, r
);
683 memcpy (&value
, context_offset
, size
);
684 value
-= gdbarch_decr_pc_after_break (gdbarch
);
685 memcpy (context_offset
, &value
, size
);
689 gdb_assert (size
== 8);
691 memcpy (&value
, context_offset
, size
);
692 value
-= gdbarch_decr_pc_after_break (gdbarch
);
693 memcpy (context_offset
, &value
, size
);
696 regcache
->raw_supply (r
, context_offset
);
701 windows_nat_target::fetch_registers (struct regcache
*regcache
, int r
)
703 windows_thread_info
*th
= thread_rec (regcache
->ptid (), INVALIDATE_CONTEXT
);
705 /* Check if TH exists. Windows sometimes uses a non-existent
706 thread id in its events. */
710 if (th
->reload_context
)
713 if (have_saved_context
)
715 /* Lie about where the program actually is stopped since
716 cygwin has informed us that we should consider the signal
717 to have occurred at another location which is stored in
719 memcpy (&th
->context
, &saved_context
,
720 __COPY_CONTEXT_SIZE
);
721 have_saved_context
= 0;
728 th
->wow64_context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
729 CHECK (Wow64GetThreadContext (th
->h
, &th
->wow64_context
));
730 /* Copy dr values from that thread.
731 But only if there were not modified since last stop.
733 if (!debug_registers_changed
)
735 dr
[0] = th
->wow64_context
.Dr0
;
736 dr
[1] = th
->wow64_context
.Dr1
;
737 dr
[2] = th
->wow64_context
.Dr2
;
738 dr
[3] = th
->wow64_context
.Dr3
;
739 dr
[6] = th
->wow64_context
.Dr6
;
740 dr
[7] = th
->wow64_context
.Dr7
;
746 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
747 CHECK (GetThreadContext (th
->h
, &th
->context
));
748 /* Copy dr values from that thread.
749 But only if there were not modified since last stop.
751 if (!debug_registers_changed
)
753 dr
[0] = th
->context
.Dr0
;
754 dr
[1] = th
->context
.Dr1
;
755 dr
[2] = th
->context
.Dr2
;
756 dr
[3] = th
->context
.Dr3
;
757 dr
[6] = th
->context
.Dr6
;
758 dr
[7] = th
->context
.Dr7
;
761 th
->reload_context
= false;
765 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch()); r
++)
766 windows_fetch_one_register (regcache
, th
, r
);
768 windows_fetch_one_register (regcache
, th
, r
);
771 /* Collect the register number R from the given regcache, and store
772 its value into the corresponding area of the given thread's context.
774 This function assumes that R is non-negative. A failed assertion
775 assertion is raised if that is not true. */
778 windows_store_one_register (const struct regcache
*regcache
,
779 windows_thread_info
*th
, int r
)
783 char *context_ptr
= (char *) &th
->context
;
786 context_ptr
= (char *) &th
->wow64_context
;
789 regcache
->raw_collect (r
, context_ptr
+ mappings
[r
]);
792 /* Store a new register value into the context of the thread tied to
796 windows_nat_target::store_registers (struct regcache
*regcache
, int r
)
798 windows_thread_info
*th
= thread_rec (regcache
->ptid (), INVALIDATE_CONTEXT
);
800 /* Check if TH exists. Windows sometimes uses a non-existent
801 thread id in its events. */
806 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch ()); r
++)
807 windows_store_one_register (regcache
, th
, r
);
809 windows_store_one_register (regcache
, th
, r
);
812 /* Maintain a linked list of "so" information. */
813 struct lm_info_windows
: public lm_info_base
815 LPVOID load_addr
= 0;
816 CORE_ADDR text_offset
= 0;
819 static struct so_list solib_start
, *solib_end
;
821 static struct so_list
*
822 windows_make_so (const char *name
, LPVOID load_addr
)
829 WIN32_FIND_DATA w32_fd
;
830 HANDLE h
= FindFirstFile(name
, &w32_fd
);
832 if (h
== INVALID_HANDLE_VALUE
)
838 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
840 p
= strrchr (buf
, '\\');
843 SetCurrentDirectory (buf
);
844 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
845 SetCurrentDirectory (cwd
);
848 if (strcasecmp (buf
, "ntdll.dll") == 0)
850 GetSystemDirectory (buf
, sizeof (buf
));
851 strcat (buf
, "\\ntdll.dll");
854 cygwin_buf_t buf
[__PMAX
];
857 if (access (name
, F_OK
) != 0)
859 if (strcasecmp (name
, "ntdll.dll") == 0)
862 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
863 wcscat (buf
, L
"\\ntdll.dll");
867 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
868 strcat (buf
, "\\ntdll.dll");
873 so
= XCNEW (struct so_list
);
874 lm_info_windows
*li
= new lm_info_windows
;
876 li
->load_addr
= load_addr
;
877 strcpy (so
->so_original_name
, name
);
879 strcpy (so
->so_name
, buf
);
882 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
883 SO_NAME_MAX_PATH_SIZE
);
886 char *rname
= realpath (name
, NULL
);
887 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
889 strcpy (so
->so_name
, rname
);
893 error (_("dll path too long"));
895 /* Record cygwin1.dll .text start/end. */
896 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
897 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
899 asection
*text
= NULL
;
901 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386", -1));
906 if (bfd_check_format (abfd
.get (), bfd_object
))
907 text
= bfd_get_section_by_name (abfd
.get (), ".text");
912 /* The symbols in a dll are offset by 0x1000, which is the
913 offset from 0 of the first byte in an image - because of the
914 file header and the section alignment. */
915 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
917 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (text
);
925 get_image_name (HANDLE h
, void *address
, int unicode
)
928 static char buf
[__PMAX
];
930 static char buf
[(2 * __PMAX
) + 1];
932 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
938 /* Attempt to read the name of the dll that was detected.
939 This is documented to work only when actively debugging
940 a program. It will not work for attached processes. */
944 /* See if we could read the address of a string, and that the
945 address isn't null. */
946 if (!ReadProcessMemory (h
, address
, &address_ptr
,
947 sizeof (address_ptr
), &done
)
948 || done
!= sizeof (address_ptr
) || !address_ptr
)
951 /* Find the length of the string. */
952 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
953 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
957 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
960 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
961 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
964 wcstombs (buf
, unicode_address
, __PMAX
);
966 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
974 /* Handle a DLL load event, and return 1.
976 This function assumes that this event did not occur during inferior
977 initialization, where their event info may be incomplete (see
978 do_initial_windows_stuff and windows_add_all_dlls for more info
979 on how we handle DLL loading during that phase). */
984 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
987 /* Try getting the DLL name via the lpImageName field of the event.
988 Note that Microsoft documents this fields as strictly optional,
989 in the sense that it might be NULL. And the first DLL event in
990 particular is explicitly documented as "likely not pass[ed]"
991 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
992 dll_name
= get_image_name (current_process_handle
,
993 event
->lpImageName
, event
->fUnicode
);
997 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
998 solib_end
= solib_end
->next
;
1000 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
1002 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
1003 host_address_to_string (li
->load_addr
)));
1007 windows_free_so (struct so_list
*so
)
1009 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
1015 /* Handle a DLL unload event.
1016 Return 1 if successful, or zero otherwise.
1018 This function assumes that this event did not occur during inferior
1019 initialization, where their event info may be incomplete (see
1020 do_initial_windows_stuff and windows_add_all_dlls for more info
1021 on how we handle DLL loading during that phase). */
1024 handle_unload_dll ()
1026 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
1029 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
1031 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
1033 if (li_next
->load_addr
== lpBaseOfDll
)
1035 struct so_list
*sodel
= so
->next
;
1037 so
->next
= sodel
->next
;
1040 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
1042 windows_free_so (sodel
);
1047 /* We did not find any DLL that was previously loaded at this address,
1048 so register a complaint. We do not report an error, because we have
1049 observed that this may be happening under some circumstances. For
1050 instance, running 32bit applications on x64 Windows causes us to receive
1051 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
1052 events are apparently caused by the WOW layer, the interface between
1053 32bit and 64bit worlds). */
1054 complaint (_("dll starting at %s not found."),
1055 host_address_to_string (lpBaseOfDll
));
1058 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
1062 catch_errors (void (*func
) ())
1068 catch (const gdb_exception
&ex
)
1070 exception_print (gdb_stderr
, ex
);
1074 /* Clear list of loaded DLLs. */
1076 windows_clear_solib (void)
1080 for (so
= solib_start
.next
; so
; so
= solib_start
.next
)
1082 solib_start
.next
= so
->next
;
1083 windows_free_so (so
);
1086 solib_end
= &solib_start
;
1090 signal_event_command (const char *args
, int from_tty
)
1092 uintptr_t event_id
= 0;
1093 char *endargs
= NULL
;
1096 error (_("signal-event requires an argument (integer event id)"));
1098 event_id
= strtoumax (args
, &endargs
, 10);
1100 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
1101 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
1102 error (_("Failed to convert `%s' to event id"), args
);
1104 SetEvent ((HANDLE
) event_id
);
1105 CloseHandle ((HANDLE
) event_id
);
1108 /* Handle DEBUG_STRING output from child process.
1109 Cygwin prepends its messages with a "cygwin:". Interpret this as
1110 a Cygwin signal. Otherwise just print the string as a warning. */
1112 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
1114 gdb::unique_xmalloc_ptr
<char> s
;
1117 if (!target_read_string
1118 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
1120 || !s
|| !*(s
.get ()))
1121 /* nothing to do */;
1122 else if (!startswith (s
.get (), _CYGWIN_SIGNAL_STRING
))
1125 if (!startswith (s
.get (), "cYg"))
1128 char *p
= strchr (s
.get (), '\0');
1130 if (p
> s
.get () && *--p
== '\n')
1132 warning (("%s"), s
.get ());
1138 /* Got a cygwin signal marker. A cygwin signal is followed by
1139 the signal number itself and then optionally followed by the
1140 thread id and address to saved context within the DLL. If
1141 these are supplied, then the given thread is assumed to have
1142 issued the signal and the context from the thread is assumed
1143 to be stored at the given address in the inferior. Tell gdb
1144 to treat this like a real signal. */
1146 int sig
= strtol (s
.get () + sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
1147 gdb_signal gotasig
= gdb_signal_from_host (sig
);
1149 ourstatus
->value
.sig
= gotasig
;
1155 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1156 retval
= strtoul (p
, &p
, 0);
1158 retval
= current_event
.dwThreadId
;
1159 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
1160 && ReadProcessMemory (current_process_handle
, x
,
1162 __COPY_CONTEXT_SIZE
, &n
)
1163 && n
== __COPY_CONTEXT_SIZE
)
1164 have_saved_context
= 1;
1173 display_selector (HANDLE thread
, DWORD sel
)
1179 ret
= Wow64GetThreadSelectorEntry (thread
, sel
, &info
);
1182 ret
= GetThreadSelectorEntry (thread
, sel
, &info
);
1186 printf_filtered ("0x%03x: ", (unsigned) sel
);
1187 if (!info
.HighWord
.Bits
.Pres
)
1189 puts_filtered ("Segment not present\n");
1192 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1193 (info
.HighWord
.Bits
.BaseMid
<< 16)
1195 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1196 if (info
.HighWord
.Bits
.Granularity
)
1197 limit
= (limit
<< 12) | 0xfff;
1198 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1199 if (info
.HighWord
.Bits
.Default_Big
)
1200 puts_filtered(" 32-bit ");
1202 puts_filtered(" 16-bit ");
1203 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1206 puts_filtered ("Data (Read-Only, Exp-up");
1209 puts_filtered ("Data (Read/Write, Exp-up");
1212 puts_filtered ("Unused segment (");
1215 puts_filtered ("Data (Read/Write, Exp-down");
1218 puts_filtered ("Code (Exec-Only, N.Conf");
1221 puts_filtered ("Code (Exec/Read, N.Conf");
1224 puts_filtered ("Code (Exec-Only, Conf");
1227 puts_filtered ("Code (Exec/Read, Conf");
1230 printf_filtered ("Unknown type 0x%lx",
1231 (unsigned long) info
.HighWord
.Bits
.Type
);
1233 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1234 puts_filtered(", N.Acc");
1235 puts_filtered (")\n");
1236 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1237 puts_filtered("System selector ");
1238 printf_filtered ("Priviledge level = %ld. ",
1239 (unsigned long) info
.HighWord
.Bits
.Dpl
);
1240 if (info
.HighWord
.Bits
.Granularity
)
1241 puts_filtered ("Page granular.\n");
1243 puts_filtered ("Byte granular.\n");
1248 DWORD err
= GetLastError ();
1249 if (err
== ERROR_NOT_SUPPORTED
)
1250 printf_filtered ("Function not supported\n");
1252 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1258 display_selectors (const char * args
, int from_tty
)
1260 if (!current_thread
)
1262 puts_filtered ("Impossible to display selectors now.\n");
1270 puts_filtered ("Selector $cs\n");
1271 display_selector (current_thread
->h
,
1272 current_thread
->wow64_context
.SegCs
);
1273 puts_filtered ("Selector $ds\n");
1274 display_selector (current_thread
->h
,
1275 current_thread
->wow64_context
.SegDs
);
1276 puts_filtered ("Selector $es\n");
1277 display_selector (current_thread
->h
,
1278 current_thread
->wow64_context
.SegEs
);
1279 puts_filtered ("Selector $ss\n");
1280 display_selector (current_thread
->h
,
1281 current_thread
->wow64_context
.SegSs
);
1282 puts_filtered ("Selector $fs\n");
1283 display_selector (current_thread
->h
,
1284 current_thread
->wow64_context
.SegFs
);
1285 puts_filtered ("Selector $gs\n");
1286 display_selector (current_thread
->h
,
1287 current_thread
->wow64_context
.SegGs
);
1292 puts_filtered ("Selector $cs\n");
1293 display_selector (current_thread
->h
,
1294 current_thread
->context
.SegCs
);
1295 puts_filtered ("Selector $ds\n");
1296 display_selector (current_thread
->h
,
1297 current_thread
->context
.SegDs
);
1298 puts_filtered ("Selector $es\n");
1299 display_selector (current_thread
->h
,
1300 current_thread
->context
.SegEs
);
1301 puts_filtered ("Selector $ss\n");
1302 display_selector (current_thread
->h
,
1303 current_thread
->context
.SegSs
);
1304 puts_filtered ("Selector $fs\n");
1305 display_selector (current_thread
->h
,
1306 current_thread
->context
.SegFs
);
1307 puts_filtered ("Selector $gs\n");
1308 display_selector (current_thread
->h
,
1309 current_thread
->context
.SegGs
);
1315 sel
= parse_and_eval_long (args
);
1316 printf_filtered ("Selector \"%s\"\n",args
);
1317 display_selector (current_thread
->h
, sel
);
1321 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1322 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1323 host_address_to_string (\
1324 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1326 static handle_exception_result
1327 handle_exception (struct target_waitstatus
*ourstatus
)
1329 EXCEPTION_RECORD
*rec
= ¤t_event
.u
.Exception
.ExceptionRecord
;
1330 DWORD code
= rec
->ExceptionCode
;
1331 handle_exception_result result
= HANDLE_EXCEPTION_HANDLED
;
1333 memcpy (&siginfo_er
, rec
, sizeof siginfo_er
);
1335 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1337 /* Record the context of the current thread. */
1338 thread_rec (ptid_t (current_event
.dwProcessId
, current_event
.dwThreadId
, 0),
1343 case EXCEPTION_ACCESS_VIOLATION
:
1344 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1345 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1348 /* See if the access violation happened within the cygwin DLL
1349 itself. Cygwin uses a kind of exception handling to deal
1350 with passed-in invalid addresses. gdb should not treat
1351 these as real SEGVs since they will be silently handled by
1352 cygwin. A real SEGV will (theoretically) be caught by
1353 cygwin later in the process and will be sent as a
1354 cygwin-specific-signal. So, ignore SEGVs if they show up
1355 within the text segment of the DLL itself. */
1357 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1359 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1360 && addr
< cygwin_load_end
))
1361 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1362 && startswith (fn
, "KERNEL32!IsBad")))
1363 return HANDLE_EXCEPTION_UNHANDLED
;
1367 case STATUS_STACK_OVERFLOW
:
1368 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1369 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1371 case STATUS_FLOAT_DENORMAL_OPERAND
:
1372 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1373 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1375 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1376 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1377 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1379 case STATUS_FLOAT_INEXACT_RESULT
:
1380 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1381 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1383 case STATUS_FLOAT_INVALID_OPERATION
:
1384 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1385 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1387 case STATUS_FLOAT_OVERFLOW
:
1388 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1389 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1391 case STATUS_FLOAT_STACK_CHECK
:
1392 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1393 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1395 case STATUS_FLOAT_UNDERFLOW
:
1396 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1397 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1399 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1400 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1401 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1403 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1404 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1405 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1407 case STATUS_INTEGER_OVERFLOW
:
1408 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1409 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1411 case EXCEPTION_BREAKPOINT
:
1413 if (ignore_first_breakpoint
)
1415 /* For WOW64 processes, there are always 2 breakpoint exceptions
1416 on startup, first a BREAKPOINT for the 64bit ntdll.dll,
1417 then a WX86_BREAKPOINT for the 32bit ntdll.dll.
1418 Here we only care about the WX86_BREAKPOINT's. */
1419 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1420 ignore_first_breakpoint
= false;
1424 case STATUS_WX86_BREAKPOINT
:
1425 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1426 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1429 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1430 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1432 case DBG_CONTROL_BREAK
:
1433 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1434 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1436 case EXCEPTION_SINGLE_STEP
:
1437 case STATUS_WX86_SINGLE_STEP
:
1438 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1439 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1441 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1442 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1443 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1445 case EXCEPTION_PRIV_INSTRUCTION
:
1446 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1447 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1449 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1450 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1451 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1453 case MS_VC_EXCEPTION
:
1454 if (rec
->NumberParameters
>= 3
1455 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1457 DWORD named_thread_id
;
1458 windows_thread_info
*named_thread
;
1459 CORE_ADDR thread_name_target
;
1461 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1463 thread_name_target
= rec
->ExceptionInformation
[1];
1464 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1466 if (named_thread_id
== (DWORD
) -1)
1467 named_thread_id
= current_event
.dwThreadId
;
1469 named_thread
= thread_rec (ptid_t (current_event
.dwProcessId
,
1470 named_thread_id
, 0),
1471 DONT_INVALIDATE_CONTEXT
);
1472 if (named_thread
!= NULL
)
1474 int thread_name_len
;
1475 gdb::unique_xmalloc_ptr
<char> thread_name
;
1477 thread_name_len
= target_read_string (thread_name_target
,
1478 &thread_name
, 1025, NULL
);
1479 if (thread_name_len
> 0)
1481 thread_name
.get ()[thread_name_len
- 1] = '\0';
1482 named_thread
->name
= std::move (thread_name
);
1485 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1486 result
= HANDLE_EXCEPTION_IGNORED
;
1489 /* treat improperly formed exception as unknown */
1492 /* Treat unhandled first chance exceptions specially. */
1493 if (current_event
.u
.Exception
.dwFirstChance
)
1494 return HANDLE_EXCEPTION_UNHANDLED
;
1495 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1496 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1497 host_address_to_string (
1498 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1499 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1503 last_sig
= ourstatus
->value
.sig
;
1507 /* Resume thread specified by ID, or all artificially suspended
1508 threads, if we are continuing execution. KILLED non-zero means we
1509 have killed the inferior, so we should ignore weird errors due to
1510 threads shutting down. */
1512 windows_continue (DWORD continue_status
, int id
, int killed
)
1516 desired_stop_thread_id
= id
;
1518 /* If there are pending stops, and we might plausibly hit one of
1519 them, we don't want to actually continue the inferior -- we just
1520 want to report the stop. In this case, we just pretend to
1521 continue. See the comment by the definition of "pending_stops"
1522 for details on why this is needed. */
1523 for (const auto &item
: pending_stops
)
1525 if (desired_stop_thread_id
== -1
1526 || desired_stop_thread_id
== item
.thread_id
)
1528 DEBUG_EVENTS (("windows_continue - pending stop anticipated, "
1529 "desired=0x%x, item=0x%x\n",
1530 desired_stop_thread_id
, item
.thread_id
));
1535 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1536 (unsigned) last_wait_event
.dwProcessId
,
1537 (unsigned) last_wait_event
.dwThreadId
,
1538 continue_status
== DBG_CONTINUE
?
1539 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1541 for (windows_thread_info
*th
: thread_list
)
1542 if (id
== -1 || id
== (int) th
->tid
)
1549 if (debug_registers_changed
)
1551 th
->wow64_context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1552 th
->wow64_context
.Dr0
= dr
[0];
1553 th
->wow64_context
.Dr1
= dr
[1];
1554 th
->wow64_context
.Dr2
= dr
[2];
1555 th
->wow64_context
.Dr3
= dr
[3];
1556 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1557 th
->wow64_context
.Dr7
= dr
[7];
1559 if (th
->wow64_context
.ContextFlags
)
1563 if (GetExitCodeThread (th
->h
, &ec
)
1564 && ec
== STILL_ACTIVE
)
1566 BOOL status
= Wow64SetThreadContext (th
->h
,
1567 &th
->wow64_context
);
1572 th
->wow64_context
.ContextFlags
= 0;
1578 if (debug_registers_changed
)
1580 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1581 th
->context
.Dr0
= dr
[0];
1582 th
->context
.Dr1
= dr
[1];
1583 th
->context
.Dr2
= dr
[2];
1584 th
->context
.Dr3
= dr
[3];
1585 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1586 th
->context
.Dr7
= dr
[7];
1588 if (th
->context
.ContextFlags
)
1592 if (GetExitCodeThread (th
->h
, &ec
)
1593 && ec
== STILL_ACTIVE
)
1595 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1600 th
->context
.ContextFlags
= 0;
1607 /* When single-stepping a specific thread, other threads must
1612 res
= ContinueDebugEvent (last_wait_event
.dwProcessId
,
1613 last_wait_event
.dwThreadId
,
1617 error (_("Failed to resume program execution"
1618 " (ContinueDebugEvent failed, error %u)"),
1619 (unsigned int) GetLastError ());
1621 debug_registers_changed
= 0;
1625 /* Called in pathological case where Windows fails to send a
1626 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1628 fake_create_process (void)
1630 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1631 current_event
.dwProcessId
);
1632 if (current_process_handle
!= NULL
)
1633 open_process_used
= 1;
1636 error (_("OpenProcess call failed, GetLastError = %u"),
1637 (unsigned) GetLastError ());
1638 /* We can not debug anything in that case. */
1641 = windows_add_thread (ptid_t (current_event
.dwProcessId
,
1642 current_event
.dwThreadId
, 0),
1643 current_event
.u
.CreateThread
.hThread
,
1644 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1645 true /* main_thread_p */);
1646 return current_event
.dwThreadId
;
1650 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1652 windows_thread_info
*th
;
1653 DWORD continue_status
= DBG_CONTINUE
;
1655 /* A specific PTID means `step only this thread id'. */
1656 int resume_all
= ptid
== minus_one_ptid
;
1658 /* If we're continuing all threads, it's the current inferior that
1659 should be handled specially. */
1661 ptid
= inferior_ptid
;
1663 if (sig
!= GDB_SIGNAL_0
)
1665 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1667 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1669 else if (sig
== last_sig
)
1670 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1673 /* This code does not seem to work, because
1674 the kernel does probably not consider changes in the ExceptionRecord
1675 structure when passing the exception to the inferior.
1676 Note that this seems possible in the exception handler itself. */
1678 for (const xlate_exception
&x
: xlate
)
1681 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1683 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1686 if (continue_status
== DBG_CONTINUE
)
1688 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1692 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1696 last_sig
= GDB_SIGNAL_0
;
1698 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=0x%x, step=%d, sig=%d);\n",
1699 ptid
.pid (), (unsigned) ptid
.lwp (), step
, sig
));
1701 /* Get context for currently selected thread. */
1702 th
= thread_rec (inferior_ptid
, DONT_INVALIDATE_CONTEXT
);
1710 /* Single step by setting t bit. */
1711 struct regcache
*regcache
= get_current_regcache ();
1712 struct gdbarch
*gdbarch
= regcache
->arch ();
1713 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1714 th
->wow64_context
.EFlags
|= FLAG_TRACE_BIT
;
1717 if (th
->wow64_context
.ContextFlags
)
1719 if (debug_registers_changed
)
1721 th
->wow64_context
.Dr0
= dr
[0];
1722 th
->wow64_context
.Dr1
= dr
[1];
1723 th
->wow64_context
.Dr2
= dr
[2];
1724 th
->wow64_context
.Dr3
= dr
[3];
1725 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1726 th
->wow64_context
.Dr7
= dr
[7];
1728 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
1729 th
->wow64_context
.ContextFlags
= 0;
1737 /* Single step by setting t bit. */
1738 struct regcache
*regcache
= get_current_regcache ();
1739 struct gdbarch
*gdbarch
= regcache
->arch ();
1740 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1741 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1744 if (th
->context
.ContextFlags
)
1746 if (debug_registers_changed
)
1748 th
->context
.Dr0
= dr
[0];
1749 th
->context
.Dr1
= dr
[1];
1750 th
->context
.Dr2
= dr
[2];
1751 th
->context
.Dr3
= dr
[3];
1752 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1753 th
->context
.Dr7
= dr
[7];
1755 CHECK (SetThreadContext (th
->h
, &th
->context
));
1756 th
->context
.ContextFlags
= 0;
1761 /* Allow continuing with the same signal that interrupted us.
1762 Otherwise complain. */
1765 windows_continue (continue_status
, -1, 0);
1767 windows_continue (continue_status
, ptid
.lwp (), 0);
1770 /* Ctrl-C handler used when the inferior is not run in the same console. The
1771 handler is in charge of interrupting the inferior using DebugBreakProcess.
1772 Note that this function is not available prior to Windows XP. In this case
1773 we emit a warning. */
1775 ctrl_c_handler (DWORD event_type
)
1777 const int attach_flag
= current_inferior ()->attach_flag
;
1779 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1780 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1783 /* If the inferior and the debugger share the same console, do nothing as
1784 the inferior has also received the Ctrl-C event. */
1785 if (!new_console
&& !attach_flag
)
1788 if (!DebugBreakProcess (current_process_handle
))
1789 warning (_("Could not interrupt program. "
1790 "Press Ctrl-c in the program console."));
1792 /* Return true to tell that Ctrl-C has been handled. */
1796 /* A wrapper for WaitForDebugEvent that sets "last_wait_event"
1799 wait_for_debug_event (DEBUG_EVENT
*event
, DWORD timeout
)
1801 BOOL result
= WaitForDebugEvent (event
, timeout
);
1803 last_wait_event
= *event
;
1807 /* Get the next event from the child. Returns a non-zero thread id if the event
1808 requires handling by WFI (or whatever). */
1811 windows_nat_target::get_windows_debug_event (int pid
,
1812 struct target_waitstatus
*ourstatus
)
1815 DWORD continue_status
, event_code
;
1816 windows_thread_info
*th
;
1817 static windows_thread_info
dummy_thread_info (0, 0, 0);
1818 DWORD thread_id
= 0;
1820 /* If there is a relevant pending stop, report it now. See the
1821 comment by the definition of "pending_stops" for details on why
1823 for (auto iter
= pending_stops
.begin ();
1824 iter
!= pending_stops
.end ();
1827 if (desired_stop_thread_id
== -1
1828 || desired_stop_thread_id
== iter
->thread_id
)
1830 thread_id
= iter
->thread_id
;
1831 *ourstatus
= iter
->status
;
1832 current_event
= iter
->event
;
1834 inferior_ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1835 current_thread
= thread_rec (inferior_ptid
, INVALIDATE_CONTEXT
);
1836 current_thread
->reload_context
= 1;
1838 DEBUG_EVENTS (("get_windows_debug_event - "
1839 "pending stop found in 0x%x (desired=0x%x)\n",
1840 thread_id
, desired_stop_thread_id
));
1842 pending_stops
.erase (iter
);
1847 last_sig
= GDB_SIGNAL_0
;
1849 if (!(debug_event
= wait_for_debug_event (¤t_event
, 1000)))
1853 continue_status
= DBG_CONTINUE
;
1855 event_code
= current_event
.dwDebugEventCode
;
1856 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1858 have_saved_context
= 0;
1862 case CREATE_THREAD_DEBUG_EVENT
:
1863 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1864 (unsigned) current_event
.dwProcessId
,
1865 (unsigned) current_event
.dwThreadId
,
1866 "CREATE_THREAD_DEBUG_EVENT"));
1867 if (saw_create
!= 1)
1869 inferior
*inf
= find_inferior_pid (this, current_event
.dwProcessId
);
1870 if (!saw_create
&& inf
->attach_flag
)
1872 /* Kludge around a Windows bug where first event is a create
1873 thread event. Caused when attached process does not have
1875 thread_id
= fake_create_process ();
1881 /* Record the existence of this thread. */
1882 thread_id
= current_event
.dwThreadId
;
1883 th
= windows_add_thread
1884 (ptid_t (current_event
.dwProcessId
, current_event
.dwThreadId
, 0),
1885 current_event
.u
.CreateThread
.hThread
,
1886 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1887 false /* main_thread_p */);
1891 case EXIT_THREAD_DEBUG_EVENT
:
1892 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1893 (unsigned) current_event
.dwProcessId
,
1894 (unsigned) current_event
.dwThreadId
,
1895 "EXIT_THREAD_DEBUG_EVENT"));
1896 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1897 current_event
.dwThreadId
, 0),
1898 current_event
.u
.ExitThread
.dwExitCode
,
1899 false /* main_thread_p */);
1900 th
= &dummy_thread_info
;
1903 case CREATE_PROCESS_DEBUG_EVENT
:
1904 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1905 (unsigned) current_event
.dwProcessId
,
1906 (unsigned) current_event
.dwThreadId
,
1907 "CREATE_PROCESS_DEBUG_EVENT"));
1908 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1909 if (++saw_create
!= 1)
1912 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1913 /* Add the main thread. */
1914 th
= windows_add_thread
1915 (ptid_t (current_event
.dwProcessId
,
1916 current_event
.dwThreadId
, 0),
1917 current_event
.u
.CreateProcessInfo
.hThread
,
1918 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
,
1919 true /* main_thread_p */);
1920 thread_id
= current_event
.dwThreadId
;
1923 case EXIT_PROCESS_DEBUG_EVENT
:
1924 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1925 (unsigned) current_event
.dwProcessId
,
1926 (unsigned) current_event
.dwThreadId
,
1927 "EXIT_PROCESS_DEBUG_EVENT"));
1928 if (!windows_initialization_done
)
1930 target_terminal::ours ();
1931 target_mourn_inferior (inferior_ptid
);
1932 error (_("During startup program exited with code 0x%x."),
1933 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1935 else if (saw_create
== 1)
1937 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1938 current_event
.dwThreadId
, 0),
1939 0, true /* main_thread_p */);
1940 DWORD exit_status
= current_event
.u
.ExitProcess
.dwExitCode
;
1941 /* If the exit status looks like a fatal exception, but we
1942 don't recognize the exception's code, make the original
1943 exit status value available, to avoid losing
1946 = WIFSIGNALED (exit_status
) ? WTERMSIG (exit_status
) : -1;
1947 if (exit_signal
== -1)
1949 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1950 ourstatus
->value
.integer
= exit_status
;
1954 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1955 ourstatus
->value
.sig
= gdb_signal_from_host (exit_signal
);
1957 thread_id
= current_event
.dwThreadId
;
1961 case LOAD_DLL_DEBUG_EVENT
:
1962 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1963 (unsigned) current_event
.dwProcessId
,
1964 (unsigned) current_event
.dwThreadId
,
1965 "LOAD_DLL_DEBUG_EVENT"));
1966 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1967 if (saw_create
!= 1 || ! windows_initialization_done
)
1969 catch_errors (handle_load_dll
);
1970 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1971 ourstatus
->value
.integer
= 0;
1972 thread_id
= current_event
.dwThreadId
;
1975 case UNLOAD_DLL_DEBUG_EVENT
:
1976 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1977 (unsigned) current_event
.dwProcessId
,
1978 (unsigned) current_event
.dwThreadId
,
1979 "UNLOAD_DLL_DEBUG_EVENT"));
1980 if (saw_create
!= 1 || ! windows_initialization_done
)
1982 catch_errors (handle_unload_dll
);
1983 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1984 ourstatus
->value
.integer
= 0;
1985 thread_id
= current_event
.dwThreadId
;
1988 case EXCEPTION_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 "EXCEPTION_DEBUG_EVENT"));
1993 if (saw_create
!= 1)
1995 switch (handle_exception (ourstatus
))
1997 case HANDLE_EXCEPTION_UNHANDLED
:
1999 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
2001 case HANDLE_EXCEPTION_HANDLED
:
2002 thread_id
= current_event
.dwThreadId
;
2004 case HANDLE_EXCEPTION_IGNORED
:
2005 continue_status
= DBG_CONTINUE
;
2010 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
2011 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
2012 (unsigned) current_event
.dwProcessId
,
2013 (unsigned) current_event
.dwThreadId
,
2014 "OUTPUT_DEBUG_STRING_EVENT"));
2015 if (saw_create
!= 1)
2017 thread_id
= handle_output_debug_string (ourstatus
);
2021 if (saw_create
!= 1)
2023 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
2024 (unsigned) current_event
.dwProcessId
,
2025 (unsigned) current_event
.dwThreadId
);
2026 printf_unfiltered (" unknown event code %u\n",
2027 (unsigned) current_event
.dwDebugEventCode
);
2031 if (!thread_id
|| saw_create
!= 1)
2033 CHECK (windows_continue (continue_status
, desired_stop_thread_id
, 0));
2035 else if (desired_stop_thread_id
!= -1 && desired_stop_thread_id
!= thread_id
)
2037 /* Pending stop. See the comment by the definition of
2038 "pending_stops" for details on why this is needed. */
2039 DEBUG_EVENTS (("get_windows_debug_event - "
2040 "unexpected stop in 0x%x (expecting 0x%x)\n",
2041 thread_id
, desired_stop_thread_id
));
2043 if (current_event
.dwDebugEventCode
== EXCEPTION_DEBUG_EVENT
2044 && (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
2045 == EXCEPTION_BREAKPOINT
)
2046 && windows_initialization_done
)
2048 ptid_t ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
2049 th
= thread_rec (ptid
, INVALIDATE_CONTEXT
);
2050 th
->stopped_at_software_breakpoint
= true;
2052 pending_stops
.push_back ({thread_id
, *ourstatus
, current_event
});
2054 CHECK (windows_continue (continue_status
, desired_stop_thread_id
, 0));
2058 inferior_ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
2059 current_thread
= th
;
2060 if (!current_thread
)
2061 current_thread
= thread_rec (inferior_ptid
, INVALIDATE_CONTEXT
);
2068 /* Wait for interesting events to occur in the target process. */
2070 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
2075 /* We loop when we get a non-standard exception rather than return
2076 with a SPURIOUS because resume can try and step or modify things,
2077 which needs a current_thread->h. But some of these exceptions mark
2078 the birth or death of threads, which mean that the current thread
2079 isn't necessarily what you think it is. */
2085 /* If the user presses Ctrl-c while the debugger is waiting
2086 for an event, he expects the debugger to interrupt his program
2087 and to get the prompt back. There are two possible situations:
2089 - The debugger and the program do not share the console, in
2090 which case the Ctrl-c event only reached the debugger.
2091 In that case, the ctrl_c handler will take care of interrupting
2092 the inferior. Note that this case is working starting with
2093 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
2096 - The debugger and the program share the same console, in which
2097 case both debugger and inferior will receive the Ctrl-c event.
2098 In that case the ctrl_c handler will ignore the event, as the
2099 Ctrl-c event generated inside the inferior will trigger the
2100 expected debug event.
2102 FIXME: brobecker/2008-05-20: If the inferior receives the
2103 signal first and the delay until GDB receives that signal
2104 is sufficiently long, GDB can sometimes receive the SIGINT
2105 after we have unblocked the CTRL+C handler. This would
2106 lead to the debugger stopping prematurely while handling
2107 the new-thread event that comes with the handling of the SIGINT
2108 inside the inferior, and then stop again immediately when
2109 the user tries to resume the execution in the inferior.
2110 This is a classic race that we should try to fix one day. */
2111 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
2112 retval
= get_windows_debug_event (pid
, ourstatus
);
2113 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
2117 ptid_t result
= ptid_t (current_event
.dwProcessId
, retval
, 0);
2119 if (current_thread
!= nullptr)
2121 current_thread
->stopped_at_software_breakpoint
= false;
2122 if (current_event
.dwDebugEventCode
== EXCEPTION_DEBUG_EVENT
2123 && (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
2124 == EXCEPTION_BREAKPOINT
)
2125 && windows_initialization_done
)
2126 current_thread
->stopped_at_software_breakpoint
= true;
2135 if (deprecated_ui_loop_hook
!= NULL
)
2136 detach
= deprecated_ui_loop_hook (0);
2144 /* Iterate over all DLLs currently mapped by our inferior, and
2145 add them to our list of solibs. */
2148 windows_add_all_dlls (void)
2150 HMODULE dummy_hmodule
;
2158 if (EnumProcessModulesEx (current_process_handle
, &dummy_hmodule
,
2159 sizeof (HMODULE
), &cb_needed
,
2160 LIST_MODULES_32BIT
) == 0)
2166 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
2167 sizeof (HMODULE
), &cb_needed
) == 0)
2174 hmodules
= (HMODULE
*) alloca (cb_needed
);
2178 if (EnumProcessModulesEx (current_process_handle
, hmodules
,
2179 cb_needed
, &cb_needed
,
2180 LIST_MODULES_32BIT
) == 0)
2186 if (EnumProcessModules (current_process_handle
, hmodules
,
2187 cb_needed
, &cb_needed
) == 0)
2191 char system_dir
[__PMAX
];
2192 char syswow_dir
[__PMAX
];
2193 size_t system_dir_len
= 0;
2194 bool convert_syswow_dir
= false;
2199 /* This fails on 32bit Windows because it has no SysWOW64 directory,
2200 and in this case a path conversion isn't necessary. */
2201 UINT len
= GetSystemWow64DirectoryA (syswow_dir
, sizeof (syswow_dir
));
2204 /* Check that we have passed a large enough buffer. */
2205 gdb_assert (len
< sizeof (syswow_dir
));
2207 len
= GetSystemDirectoryA (system_dir
, sizeof (system_dir
));
2209 gdb_assert (len
!= 0);
2210 /* Check that we have passed a large enough buffer. */
2211 gdb_assert (len
< sizeof (system_dir
));
2213 strcat (system_dir
, "\\");
2214 strcat (syswow_dir
, "\\");
2215 system_dir_len
= strlen (system_dir
);
2217 convert_syswow_dir
= true;
2221 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
2225 wchar_t dll_name
[__PMAX
];
2226 char dll_name_mb
[__PMAX
];
2228 char dll_name
[__PMAX
];
2231 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
2232 &mi
, sizeof (mi
)) == 0)
2234 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
2235 dll_name
, sizeof (dll_name
)) == 0)
2238 wcstombs (dll_name_mb
, dll_name
, __PMAX
);
2243 /* Convert the DLL path of 32bit processes returned by
2244 GetModuleFileNameEx from the 64bit system directory to the
2245 32bit syswow64 directory if necessary. */
2246 std::string syswow_dll_path
;
2247 if (convert_syswow_dir
2248 && strncasecmp (name
, system_dir
, system_dir_len
) == 0
2249 && strchr (name
+ system_dir_len
, '\\') == nullptr)
2251 syswow_dll_path
= syswow_dir
;
2252 syswow_dll_path
+= name
+ system_dir_len
;
2253 name
= syswow_dll_path
.c_str();
2256 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
2257 solib_end
= solib_end
->next
;
2262 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
2265 struct inferior
*inf
;
2267 last_sig
= GDB_SIGNAL_0
;
2269 exception_count
= 0;
2270 open_process_used
= 0;
2271 debug_registers_changed
= 0;
2272 debug_registers_used
= 0;
2273 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
2276 cygwin_load_start
= cygwin_load_end
= 0;
2278 current_event
.dwProcessId
= pid
;
2279 memset (¤t_event
, 0, sizeof (current_event
));
2280 if (!target_is_pushed (ops
))
2282 disable_breakpoints_in_shlibs ();
2283 windows_clear_solib ();
2284 clear_proceed_status (0);
2285 init_wait_for_inferior ();
2288 ignore_first_breakpoint
= !attaching
&& wow64_process
;
2292 windows_set_context_register_offsets (amd64_mappings
);
2293 windows_set_segment_register_p (amd64_windows_segment_register_p
);
2298 windows_set_context_register_offsets (i386_mappings
);
2299 windows_set_segment_register_p (i386_windows_segment_register_p
);
2302 inf
= current_inferior ();
2303 inferior_appeared (inf
, pid
);
2304 inf
->attach_flag
= attaching
;
2306 /* Make the new process the current inferior, so terminal handling
2307 can rely on it. When attaching, we don't know about any thread
2308 id here, but that's OK --- nothing should be referencing the
2309 current thread until we report an event out of windows_wait. */
2310 inferior_ptid
= ptid_t (pid
);
2312 target_terminal::init ();
2313 target_terminal::inferior ();
2315 windows_initialization_done
= 0;
2319 struct target_waitstatus status
;
2321 ops
->wait (minus_one_ptid
, &status
, 0);
2323 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
2325 if (status
.kind
!= TARGET_WAITKIND_LOADED
2326 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
2329 ops
->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
2332 /* Now that the inferior has been started and all DLLs have been mapped,
2333 we can iterate over all DLLs and load them in.
2335 We avoid doing it any earlier because, on certain versions of Windows,
2336 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
2337 we have seen on Windows 8.1 that the ntdll.dll load event does not
2338 include the DLL name, preventing us from creating an associated SO.
2339 A possible explanation is that ntdll.dll might be mapped before
2340 the SO info gets created by the Windows system -- ntdll.dll is
2341 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
2342 do not seem to suffer from that problem.
2344 Rather than try to work around this sort of issue, it is much
2345 simpler to just ignore DLL load/unload events during the startup
2346 phase, and then process them all in one batch now. */
2347 windows_add_all_dlls ();
2349 windows_initialization_done
= 1;
2353 /* Try to set or remove a user privilege to the current process. Return -1
2354 if that fails, the previous setting of that privilege otherwise.
2356 This code is copied from the Cygwin source code and rearranged to allow
2357 dynamically loading of the needed symbols from advapi32 which is only
2358 available on NT/2K/XP. */
2360 set_process_privilege (const char *privilege
, BOOL enable
)
2362 HANDLE token_hdl
= NULL
;
2364 TOKEN_PRIVILEGES new_priv
, orig_priv
;
2368 if (!OpenProcessToken (GetCurrentProcess (),
2369 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
2373 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
2376 new_priv
.PrivilegeCount
= 1;
2377 new_priv
.Privileges
[0].Luid
= restore_priv
;
2378 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
2380 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
2381 sizeof orig_priv
, &orig_priv
, &size
))
2384 /* Disabled, otherwise every `attach' in an unprivileged user session
2385 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
2386 windows_attach(). */
2387 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
2388 be enabled. GetLastError () returns an correct error code, though. */
2389 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
2393 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
2397 CloseHandle (token_hdl
);
2402 /* Attach to process PID, then initialize for debugging it. */
2405 windows_nat_target::attach (const char *args
, int from_tty
)
2410 pid
= parse_pid_to_attach (args
);
2412 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
2414 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
2415 printf_unfiltered ("This can cause attach to "
2416 "fail on Windows NT/2K/XP\n");
2419 windows_init_thread_list ();
2420 ok
= DebugActiveProcess (pid
);
2426 /* Try fall back to Cygwin pid. */
2427 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
2430 ok
= DebugActiveProcess (pid
);
2435 error (_("Can't attach to process %u (error %u)"),
2436 (unsigned) pid
, (unsigned) GetLastError ());
2438 DebugSetProcessKillOnExit (FALSE
);
2442 const char *exec_file
= get_exec_file (0);
2445 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
2446 target_pid_to_str (ptid_t (pid
)).c_str ());
2448 printf_unfiltered ("Attaching to %s\n",
2449 target_pid_to_str (ptid_t (pid
)).c_str ());
2453 HANDLE h
= OpenProcess (PROCESS_QUERY_INFORMATION
, FALSE
, pid
);
2457 if (IsWow64Process (h
, &wow64
))
2458 wow64_process
= wow64
;
2463 do_initial_windows_stuff (this, pid
, 1);
2464 target_terminal::ours ();
2468 windows_nat_target::detach (inferior
*inf
, int from_tty
)
2472 ptid_t ptid
= minus_one_ptid
;
2473 resume (ptid
, 0, GDB_SIGNAL_0
);
2475 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
2477 error (_("Can't detach process %u (error %u)"),
2478 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
2481 DebugSetProcessKillOnExit (FALSE
);
2483 if (detached
&& from_tty
)
2485 const char *exec_file
= get_exec_file (0);
2488 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
2489 (unsigned) current_event
.dwProcessId
);
2492 x86_cleanup_dregs ();
2493 inferior_ptid
= null_ptid
;
2494 detach_inferior (inf
);
2496 maybe_unpush_target ();
2499 /* Try to determine the executable filename.
2501 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2503 Upon success, the filename is stored inside EXE_NAME_RET, and
2504 this function returns nonzero.
2506 Otherwise, this function returns zero and the contents of
2507 EXE_NAME_RET is undefined. */
2510 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2520 if (!EnumProcessModulesEx (current_process_handle
, &dh_buf
,
2521 sizeof (HMODULE
), &cbNeeded
,
2522 LIST_MODULES_32BIT
) || !cbNeeded
)
2528 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2529 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2533 /* We know the executable is always first in the list of modules,
2534 which we just fetched. So no need to fetch more. */
2538 /* Cygwin prefers that the path be in /x/y/z format, so extract
2539 the filename into a temporary buffer first, and then convert it
2540 to POSIX format into the destination buffer. */
2541 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2543 len
= GetModuleFileNameEx (current_process_handle
,
2544 dh_buf
, pathbuf
, exe_name_max_len
);
2546 error (_("Error getting executable filename: %u."),
2547 (unsigned) GetLastError ());
2548 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2549 exe_name_max_len
) < 0)
2550 error (_("Error converting executable filename to POSIX: %d."), errno
);
2553 len
= GetModuleFileNameEx (current_process_handle
,
2554 dh_buf
, exe_name_ret
, exe_name_max_len
);
2556 error (_("Error getting executable filename: %u."),
2557 (unsigned) GetLastError ());
2560 return 1; /* success */
2563 /* The pid_to_exec_file target_ops method for this platform. */
2566 windows_nat_target::pid_to_exec_file (int pid
)
2568 static char path
[__PMAX
];
2570 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2572 char procexe
[sizeof ("/proc/4294967295/exe")];
2574 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2575 nchars
= readlink (procexe
, path
, sizeof(path
));
2576 if (nchars
> 0 && nchars
< sizeof (path
))
2578 path
[nchars
] = '\0'; /* Got it */
2583 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2584 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2585 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2591 /* Print status information about what we're accessing. */
2594 windows_nat_target::files_info ()
2596 struct inferior
*inf
= current_inferior ();
2598 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2599 inf
->attach_flag
? "attached" : "child",
2600 target_pid_to_str (inferior_ptid
).c_str ());
2603 /* Modify CreateProcess parameters for use of a new separate console.
2605 *FLAGS: DWORD parameter for general process creation flags.
2606 *SI: STARTUPINFO structure, for which the console window size and
2607 console buffer size is filled in if GDB is running in a console.
2608 to create the new console.
2609 The size of the used font is not available on all versions of
2610 Windows OS. Furthermore, the current font might not be the default
2611 font, but this is still better than before.
2612 If the windows and buffer sizes are computed,
2613 SI->DWFLAGS is changed so that this information is used
2614 by CreateProcess function. */
2617 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2619 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2620 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2622 if (hconsole
!= INVALID_HANDLE_VALUE
)
2624 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2626 CONSOLE_FONT_INFO cfi
;
2628 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2629 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2630 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2631 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2632 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2634 si
->dwXSize
*= font_size
.X
;
2638 si
->dwYSize
*= font_size
.Y
;
2641 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2642 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2643 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2645 *flags
|= CREATE_NEW_CONSOLE
;
2649 /* Function called by qsort to sort environment strings. */
2652 envvar_cmp (const void *a
, const void *b
)
2654 const char **p
= (const char **) a
;
2655 const char **q
= (const char **) b
;
2656 return strcasecmp (*p
, *q
);
2662 clear_win32_environment (char **env
)
2666 wchar_t *copy
= NULL
, *equalpos
;
2668 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2670 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2671 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2672 mbstowcs (copy
, env
[i
], len
);
2673 equalpos
= wcschr (copy
, L
'=');
2676 SetEnvironmentVariableW (copy
, NULL
);
2684 /* Redirection of inferior I/O streams for native MS-Windows programs.
2685 Unlike on Unix, where this is handled by invoking the inferior via
2686 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2688 The official documentation of the cmd.exe redirection features is here:
2690 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2692 (That page talks about Windows XP, but there's no newer
2693 documentation, so we assume later versions of cmd.exe didn't change
2696 Caveat: the documentation on that page seems to include a few lies.
2697 For example, it describes strange constructs 1<&2 and 2<&1, which
2698 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2699 think the cmd.exe parser of the redirection symbols simply doesn't
2700 care about the < vs > distinction in these cases. Therefore, the
2701 supported features are explicitly documented below.
2703 The emulation below aims at supporting all the valid use cases
2704 supported by cmd.exe, which include:
2706 < FILE redirect standard input from FILE
2707 0< FILE redirect standard input from FILE
2708 <&N redirect standard input from file descriptor N
2709 0<&N redirect standard input from file descriptor N
2710 > FILE redirect standard output to FILE
2711 >> FILE append standard output to FILE
2712 1>> FILE append standard output to FILE
2713 >&N redirect standard output to file descriptor N
2714 1>&N redirect standard output to file descriptor N
2715 >>&N append standard output to file descriptor N
2716 1>>&N append standard output to file descriptor N
2717 2> FILE redirect standard error to FILE
2718 2>> FILE append standard error to FILE
2719 2>&N redirect standard error to file descriptor N
2720 2>>&N append standard error to file descriptor N
2722 Note that using N > 2 in the above construct is supported, but
2723 requires that the corresponding file descriptor be open by some
2724 means elsewhere or outside GDB. Also note that using ">&0" or
2725 "<&2" will generally fail, because the file descriptor redirected
2726 from is normally open in an incompatible mode (e.g., FD 0 is open
2727 for reading only). IOW, use of such tricks is not recommended;
2728 you are on your own.
2730 We do NOT support redirection of file descriptors above 2, as in
2731 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2732 that needs special handling in the startup code that MinGW
2733 doesn't have). Pipes are also not supported.
2735 As for invalid use cases, where the redirection contains some
2736 error, the emulation below will detect that and produce some
2737 error and/or failure. But the behavior in those cases is not
2738 bug-for-bug compatible with what cmd.exe does in those cases.
2739 That's because what cmd.exe does then is not well defined, and
2740 seems to be a side effect of the cmd.exe parsing of the command
2741 line more than anything else. For example, try redirecting to an
2742 invalid file name, as in "> foo:bar".
2744 There are also minor syntactic deviations from what cmd.exe does
2745 in some corner cases. For example, it doesn't support the likes
2746 of "> &foo" to mean redirect to file named literally "&foo"; we
2747 do support that here, because that, too, sounds like some issue
2748 with the cmd.exe parser. Another nicety is that we support
2749 redirection targets that use file names with forward slashes,
2750 something cmd.exe doesn't -- this comes in handy since GDB
2751 file-name completion can be used when typing the command line for
2754 /* Support routines for redirecting standard handles of the inferior. */
2756 /* Parse a single redirection spec, open/duplicate the specified
2757 file/fd, and assign the appropriate value to one of the 3 standard
2758 file descriptors. */
2760 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2762 int *fd
, ref_fd
= -2;
2764 const char *fname
= redir_string
+ 1;
2765 int rc
= *redir_string
;
2780 fd
= (rc
== '2') ? err
: out
;
2781 mode
= O_WRONLY
| O_CREAT
;
2794 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2796 /* A reference to a file descriptor. */
2798 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2799 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2801 /* Don't allow redirection when open modes are incompatible. */
2802 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2803 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2810 else if (ref_fd
== 1)
2812 else if (ref_fd
== 2)
2822 fname
++; /* skip the separator space */
2823 /* If the descriptor is already open, close it. This allows
2824 multiple specs of redirections for the same stream, which is
2825 somewhat nonsensical, but still valid and supported by cmd.exe.
2826 (But cmd.exe only opens a single file in this case, the one
2827 specified by the last redirection spec on the command line.) */
2832 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2836 else if (ref_fd
== -1)
2837 *fd
= -1; /* reset to default destination */
2840 *fd
= _dup (ref_fd
);
2844 /* _open just sets a flag for O_APPEND, which won't be passed to the
2845 inferior, so we need to actually move the file pointer. */
2846 if ((mode
& O_APPEND
) != 0)
2847 _lseek (*fd
, 0L, SEEK_END
);
2851 /* Canonicalize a single redirection spec and set up the corresponding
2852 file descriptor as specified. */
2854 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2856 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2858 const char *start
= s
;
2861 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2862 if ((*start
== '>' || *start
== '1' || *start
== '2')
2866 if (*s
== '>' && *start
!= '>')
2869 else if (*start
== '0' && *s
== '<')
2871 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2874 while (isspace (*s
)) /* skip whitespace before file name */
2876 *d
++ = ' '; /* separate file name with a single space */
2879 /* Copy the file name. */
2882 /* Remove quoting characters from the file name in buf[]. */
2883 if (*s
== '"') /* could support '..' quoting here */
2887 else if (*s
== quote
)
2895 else if (*s
== '\\')
2897 if (s
[1] == '"') /* could support '..' here */
2901 else if (isspace (*s
) && !quote
)
2905 if (d
- buf
>= sizeof (buf
) - 1)
2907 errno
= ENAMETOOLONG
;
2913 /* Windows doesn't allow redirection characters in file names, so we
2914 can bail out early if they use them, or if there's no target file
2915 name after the redirection symbol. */
2916 if (d
[-1] == '>' || d
[-1] == '<')
2921 if (redir_open (buf
, inp
, out
, err
) == 0)
2926 /* Parse the command line for redirection specs and prepare the file
2927 descriptors for the 3 standard streams accordingly. */
2929 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2930 int *inp
, int *out
, int *err
)
2932 const char *s
= cmd_orig
;
2935 bool retval
= false;
2937 while (isspace (*s
))
2942 if (*s
== '"') /* could also support '..' quoting here */
2946 else if (*s
== quote
)
2949 else if (*s
== '\\')
2951 if (s
[1] == '"') /* escaped quote char */
2956 /* Process a single redirection candidate. */
2957 if (*s
== '<' || *s
== '>'
2958 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2959 || (*s
== '0' && s
[1] == '<'))
2961 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2975 #endif /* !__CYGWIN__ */
2977 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2978 EXEC_FILE is the file to run.
2979 ALLARGS is a string containing the arguments to the program.
2980 ENV is the environment vector to pass. Errors reported with error(). */
2983 windows_nat_target::create_inferior (const char *exec_file
,
2984 const std::string
&origallargs
,
2985 char **in_env
, int from_tty
)
2989 cygwin_buf_t real_path
[__PMAX
];
2990 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2991 cygwin_buf_t infcwd
[__PMAX
];
2993 cygwin_buf_t
*toexec
;
2994 cygwin_buf_t
*cygallargs
;
2996 char **old_env
= NULL
;
3000 int ostdin
, ostdout
, ostderr
;
3001 #else /* !__CYGWIN__ */
3002 char shell
[__PMAX
]; /* Path to shell */
3004 char *args
, *allargs_copy
;
3005 size_t args_len
, allargs_len
;
3006 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
3007 HANDLE tty
= INVALID_HANDLE_VALUE
;
3008 bool redirected
= false;
3015 #endif /* !__CYGWIN__ */
3016 const char *allargs
= origallargs
.c_str ();
3017 PROCESS_INFORMATION pi
;
3020 const char *inferior_io_terminal
= get_inferior_io_terminal ();
3023 error (_("No executable specified, use `target exec'."));
3025 const char *inferior_cwd
= get_inferior_cwd ();
3026 std::string expanded_infcwd
;
3027 if (inferior_cwd
!= NULL
)
3029 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
3030 /* Mirror slashes on inferior's cwd. */
3031 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
3033 inferior_cwd
= expanded_infcwd
.c_str ();
3036 memset (&si
, 0, sizeof (si
));
3037 si
.cb
= sizeof (si
);
3040 flags
|= CREATE_NEW_PROCESS_GROUP
;
3043 windows_set_console_info (&si
, &flags
);
3048 flags
|= DEBUG_ONLY_THIS_PROCESS
;
3049 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
3050 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
3051 error (_("Error starting executable: %d"), errno
);
3054 len
= mbstowcs (NULL
, allargs
, 0) + 1;
3055 if (len
== (size_t) -1)
3056 error (_("Error starting executable: %d"), errno
);
3057 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
3058 mbstowcs (cygallargs
, allargs
, len
);
3059 #else /* !__USEWIDE */
3060 cygallargs
= allargs
;
3066 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
3067 error (_("Error starting executable via shell: %d"), errno
);
3069 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
3070 + mbstowcs (NULL
, allargs
, 0) + 2;
3071 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
3072 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
3073 #else /* !__USEWIDE */
3074 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
3075 + strlen (allargs
) + 2);
3076 cygallargs
= (char *) alloca (len
);
3077 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
3078 #endif /* __USEWIDE */
3080 flags
|= DEBUG_PROCESS
;
3083 if (inferior_cwd
!= NULL
3084 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
3085 infcwd
, strlen (inferior_cwd
)) < 0)
3086 error (_("Error converting inferior cwd: %d"), errno
);
3089 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
3090 * sizeof (wchar_t));
3091 wcscpy (args
, toexec
);
3092 wcscat (args
, L
" ");
3093 wcscat (args
, cygallargs
);
3094 #else /* !__USEWIDE */
3095 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
3096 strcpy (args
, toexec
);
3098 strcat (args
, cygallargs
);
3099 #endif /* !__USEWIDE */
3101 #ifdef CW_CVT_ENV_TO_WINENV
3102 /* First try to create a direct Win32 copy of the POSIX environment. */
3103 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
3104 if (w32_env
!= (PWCHAR
) -1)
3105 flags
|= CREATE_UNICODE_ENVIRONMENT
;
3107 /* If that fails, fall back to old method tweaking GDB's environment. */
3108 #endif /* CW_CVT_ENV_TO_WINENV */
3110 /* Reset all Win32 environment variables to avoid leftover on next run. */
3111 clear_win32_environment (environ
);
3112 /* Prepare the environment vars for CreateProcess. */
3115 cygwin_internal (CW_SYNC_WINENV
);
3119 if (!inferior_io_terminal
)
3120 tty
= ostdin
= ostdout
= ostderr
= -1;
3123 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
3126 print_sys_errmsg (inferior_io_terminal
, errno
);
3127 ostdin
= ostdout
= ostderr
= -1;
3140 windows_init_thread_list ();
3141 ret
= CreateProcess (0,
3142 args
, /* command line */
3143 NULL
, /* Security */
3145 TRUE
, /* inherit handles */
3146 flags
, /* start flags */
3147 w32_env
, /* environment */
3148 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
3153 /* Just free the Win32 environment, if it could be created. */
3157 /* Reset all environment variables to avoid leftover on next run. */
3158 clear_win32_environment (in_env
);
3159 /* Restore normal GDB environment variables. */
3161 cygwin_internal (CW_SYNC_WINENV
);
3174 #else /* !__CYGWIN__ */
3175 allargs_len
= strlen (allargs
);
3176 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
3177 if (strpbrk (allargs_copy
, "<>") != NULL
)
3182 redirect_inferior_handles (allargs
, allargs_copy
,
3183 &fd_inp
, &fd_out
, &fd_err
);
3185 warning (_("Error in redirection: %s."), safe_strerror (errno
));
3188 allargs_len
= strlen (allargs_copy
);
3190 /* If not all the standard streams are redirected by the command
3191 line, use inferior_io_terminal for those which aren't. */
3192 if (inferior_io_terminal
3193 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
3195 SECURITY_ATTRIBUTES sa
;
3196 sa
.nLength
= sizeof(sa
);
3197 sa
.lpSecurityDescriptor
= 0;
3198 sa
.bInheritHandle
= TRUE
;
3199 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
3200 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
3201 if (tty
== INVALID_HANDLE_VALUE
)
3202 warning (_("Warning: Failed to open TTY %s, error %#x."),
3203 inferior_io_terminal
, (unsigned) GetLastError ());
3205 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
3208 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
3209 else if (tty
!= INVALID_HANDLE_VALUE
)
3212 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
3214 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
3215 else if (tty
!= INVALID_HANDLE_VALUE
)
3216 si
.hStdOutput
= tty
;
3218 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
3220 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
3221 else if (tty
!= INVALID_HANDLE_VALUE
)
3224 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
3225 si
.dwFlags
|= STARTF_USESTDHANDLES
;
3229 /* Build the command line, a space-separated list of tokens where
3230 the first token is the name of the module to be executed.
3231 To avoid ambiguities introduced by spaces in the module name,
3233 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
3234 args
= (char *) alloca (args_len
);
3235 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
3237 flags
|= DEBUG_ONLY_THIS_PROCESS
;
3239 /* CreateProcess takes the environment list as a null terminated set of
3240 strings (i.e. two nulls terminate the list). */
3242 /* Get total size for env strings. */
3243 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
3244 envlen
+= strlen (in_env
[i
]) + 1;
3246 envsize
= sizeof (in_env
[0]) * (i
+ 1);
3247 env
= (char **) alloca (envsize
);
3248 memcpy (env
, in_env
, envsize
);
3249 /* Windows programs expect the environment block to be sorted. */
3250 qsort (env
, i
, sizeof (char *), envvar_cmp
);
3252 w32env
= (char *) alloca (envlen
+ 1);
3254 /* Copy env strings into new buffer. */
3255 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
3257 strcpy (temp
, env
[i
]);
3258 temp
+= strlen (temp
) + 1;
3261 /* Final nil string to terminate new env. */
3264 windows_init_thread_list ();
3265 ret
= CreateProcessA (0,
3266 args
, /* command line */
3267 NULL
, /* Security */
3269 TRUE
, /* inherit handles */
3270 flags
, /* start flags */
3271 w32env
, /* environment */
3272 inferior_cwd
, /* current directory */
3275 if (tty
!= INVALID_HANDLE_VALUE
)
3283 #endif /* !__CYGWIN__ */
3286 error (_("Error creating process %s, (error %u)."),
3287 exec_file
, (unsigned) GetLastError ());
3291 if (IsWow64Process (pi
.hProcess
, &wow64
))
3292 wow64_process
= wow64
;
3295 CloseHandle (pi
.hThread
);
3296 CloseHandle (pi
.hProcess
);
3298 if (useshell
&& shell
[0] != '\0')
3303 do_initial_windows_stuff (this, pi
.dwProcessId
, 0);
3305 /* windows_continue (DBG_CONTINUE, -1, 0); */
3309 windows_nat_target::mourn_inferior ()
3311 (void) windows_continue (DBG_CONTINUE
, -1, 0);
3312 x86_cleanup_dregs();
3313 if (open_process_used
)
3315 CHECK (CloseHandle (current_process_handle
));
3316 open_process_used
= 0;
3318 siginfo_er
.ExceptionCode
= 0;
3319 inf_child_target::mourn_inferior ();
3322 /* Send a SIGINT to the process group. This acts just like the user typed a
3323 ^C on the controlling terminal. */
3326 windows_nat_target::interrupt ()
3328 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
3329 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
3330 registers_changed (); /* refresh register state */
3333 /* Helper for windows_xfer_partial that handles memory transfers.
3334 Arguments are like target_xfer_partial. */
3336 static enum target_xfer_status
3337 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3338 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
3342 DWORD lasterror
= 0;
3344 if (writebuf
!= NULL
)
3346 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
3347 pulongest (len
), core_addr_to_string (memaddr
)));
3348 success
= WriteProcessMemory (current_process_handle
,
3349 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
3352 lasterror
= GetLastError ();
3353 FlushInstructionCache (current_process_handle
,
3354 (LPCVOID
) (uintptr_t) memaddr
, len
);
3358 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
3359 pulongest (len
), core_addr_to_string (memaddr
)));
3360 success
= ReadProcessMemory (current_process_handle
,
3361 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
3364 lasterror
= GetLastError ();
3366 *xfered_len
= (ULONGEST
) done
;
3367 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
3368 return TARGET_XFER_OK
;
3370 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
3374 windows_nat_target::kill ()
3376 CHECK (TerminateProcess (current_process_handle
, 0));
3380 if (!windows_continue (DBG_CONTINUE
, -1, 1))
3382 if (!wait_for_debug_event (¤t_event
, INFINITE
))
3384 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
3388 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
3392 windows_nat_target::close ()
3394 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
3395 inferior_ptid
.pid ()));
3398 /* Convert pid to printable format. */
3400 windows_nat_target::pid_to_str (ptid_t ptid
)
3402 if (ptid
.lwp () != 0)
3403 return string_printf ("Thread %d.0x%lx", ptid
.pid (), ptid
.lwp ());
3405 return normal_pid_to_str (ptid
);
3408 static enum target_xfer_status
3409 windows_xfer_shared_libraries (struct target_ops
*ops
,
3410 enum target_object object
, const char *annex
,
3411 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3412 ULONGEST offset
, ULONGEST len
,
3413 ULONGEST
*xfered_len
)
3415 struct obstack obstack
;
3421 return TARGET_XFER_E_IO
;
3423 obstack_init (&obstack
);
3424 obstack_grow_str (&obstack
, "<library-list>\n");
3425 for (so
= solib_start
.next
; so
; so
= so
->next
)
3427 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
3429 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
3430 (uintptr_t) li
->load_addr
,
3432 target_gdbarch (), &obstack
);
3434 obstack_grow_str0 (&obstack
, "</library-list>\n");
3436 buf
= (const char *) obstack_finish (&obstack
);
3437 len_avail
= strlen (buf
);
3438 if (offset
>= len_avail
)
3442 if (len
> len_avail
- offset
)
3443 len
= len_avail
- offset
;
3444 memcpy (readbuf
, buf
+ offset
, len
);
3447 obstack_free (&obstack
, NULL
);
3448 *xfered_len
= (ULONGEST
) len
;
3449 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
3452 /* Helper for windows_nat_target::xfer_partial that handles signal info. */
3454 static enum target_xfer_status
3455 windows_xfer_siginfo (gdb_byte
*readbuf
, ULONGEST offset
, ULONGEST len
,
3456 ULONGEST
*xfered_len
)
3458 char *buf
= (char *) &siginfo_er
;
3459 size_t bufsize
= sizeof (siginfo_er
);
3462 EXCEPTION_RECORD32 er32
;
3465 buf
= (char *) &er32
;
3466 bufsize
= sizeof (er32
);
3468 er32
.ExceptionCode
= siginfo_er
.ExceptionCode
;
3469 er32
.ExceptionFlags
= siginfo_er
.ExceptionFlags
;
3470 er32
.ExceptionRecord
= (uintptr_t) siginfo_er
.ExceptionRecord
;
3471 er32
.ExceptionAddress
= (uintptr_t) siginfo_er
.ExceptionAddress
;
3472 er32
.NumberParameters
= siginfo_er
.NumberParameters
;
3474 for (i
= 0; i
< EXCEPTION_MAXIMUM_PARAMETERS
; i
++)
3475 er32
.ExceptionInformation
[i
] = siginfo_er
.ExceptionInformation
[i
];
3479 if (siginfo_er
.ExceptionCode
== 0)
3480 return TARGET_XFER_E_IO
;
3482 if (readbuf
== nullptr)
3483 return TARGET_XFER_E_IO
;
3485 if (offset
> bufsize
)
3486 return TARGET_XFER_E_IO
;
3488 if (offset
+ len
> bufsize
)
3489 len
= bufsize
- offset
;
3491 memcpy (readbuf
, buf
+ offset
, len
);
3494 return TARGET_XFER_OK
;
3497 enum target_xfer_status
3498 windows_nat_target::xfer_partial (enum target_object object
,
3499 const char *annex
, gdb_byte
*readbuf
,
3500 const gdb_byte
*writebuf
, ULONGEST offset
,
3501 ULONGEST len
, ULONGEST
*xfered_len
)
3505 case TARGET_OBJECT_MEMORY
:
3506 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
3508 case TARGET_OBJECT_LIBRARIES
:
3509 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
3510 writebuf
, offset
, len
, xfered_len
);
3512 case TARGET_OBJECT_SIGNAL_INFO
:
3513 return windows_xfer_siginfo (readbuf
, offset
, len
, xfered_len
);
3516 if (beneath () == NULL
)
3518 /* This can happen when requesting the transfer of unsupported
3519 objects before a program has been started (and therefore
3520 with the current_target having no target beneath). */
3521 return TARGET_XFER_E_IO
;
3523 return beneath ()->xfer_partial (object
, annex
,
3524 readbuf
, writebuf
, offset
, len
,
3529 /* Provide thread local base, i.e. Thread Information Block address.
3530 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
3533 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
3535 windows_thread_info
*th
;
3537 th
= thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
);
3542 *addr
= th
->thread_local_base
;
3548 windows_nat_target::get_ada_task_ptid (long lwp
, long thread
)
3550 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
3553 /* Implementation of the to_thread_name method. */
3556 windows_nat_target::thread_name (struct thread_info
*thr
)
3558 return thread_rec (thr
->ptid
, DONT_INVALIDATE_CONTEXT
)->name
.get ();
3562 void _initialize_windows_nat ();
3564 _initialize_windows_nat ()
3566 x86_dr_low
.set_control
= cygwin_set_dr7
;
3567 x86_dr_low
.set_addr
= cygwin_set_dr
;
3568 x86_dr_low
.get_addr
= cygwin_get_dr
;
3569 x86_dr_low
.get_status
= cygwin_get_dr6
;
3570 x86_dr_low
.get_control
= cygwin_get_dr7
;
3572 /* x86_dr_low.debug_register_length field is set by
3573 calling x86_set_debug_register_length function
3574 in processor windows specific native file. */
3576 add_inf_child_target (&the_windows_nat_target
);
3579 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3582 add_com ("signal-event", class_run
, signal_event_command
, _("\
3583 Signal a crashed process with event ID, to allow its debugging.\n\
3584 This command is needed in support of setting up GDB as JIT debugger on \
3585 MS-Windows. The command should be invoked from the GDB command line using \
3586 the '-ex' command-line option. The ID of the event that blocks the \
3587 crashed process will be supplied by the Windows JIT debugging mechanism."));
3590 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3591 Set use of shell to start subprocess."), _("\
3592 Show use of shell to start subprocess."), NULL
,
3594 NULL
, /* FIXME: i18n: */
3595 &setlist
, &showlist
);
3597 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3598 &cygwin_exceptions
, _("\
3599 Break when an exception is detected in the Cygwin DLL itself."), _("\
3600 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3602 NULL
, /* FIXME: i18n: */
3603 &setlist
, &showlist
);
3606 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3607 Set creation of new console when creating child process."), _("\
3608 Show creation of new console when creating child process."), NULL
,
3610 NULL
, /* FIXME: i18n: */
3611 &setlist
, &showlist
);
3613 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3614 Set creation of new group when creating child process."), _("\
3615 Show creation of new group when creating child process."), NULL
,
3617 NULL
, /* FIXME: i18n: */
3618 &setlist
, &showlist
);
3620 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3621 Set whether to display execution in child process."), _("\
3622 Show whether to display execution in child process."), NULL
,
3624 NULL
, /* FIXME: i18n: */
3625 &setlist
, &showlist
);
3627 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3628 Set whether to display kernel events in child process."), _("\
3629 Show whether to display kernel events in child process."), NULL
,
3631 NULL
, /* FIXME: i18n: */
3632 &setlist
, &showlist
);
3634 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3635 Set whether to display memory accesses in child process."), _("\
3636 Show whether to display memory accesses in child process."), NULL
,
3638 NULL
, /* FIXME: i18n: */
3639 &setlist
, &showlist
);
3641 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3642 &debug_exceptions
, _("\
3643 Set whether to display kernel exceptions in child process."), _("\
3644 Show whether to display kernel exceptions in child process."), NULL
,
3646 NULL
, /* FIXME: i18n: */
3647 &setlist
, &showlist
);
3649 init_w32_command_list ();
3651 add_cmd ("selector", class_info
, display_selectors
,
3652 _("Display selectors infos."),
3656 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3658 /* Pass the address ADDR to the inferior in the I'th debug register.
3659 Here we just store the address in dr array, the registers will be
3660 actually set up when windows_continue is called. */
3662 cygwin_set_dr (int i
, CORE_ADDR addr
)
3665 internal_error (__FILE__
, __LINE__
,
3666 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3668 debug_registers_changed
= 1;
3669 debug_registers_used
= 1;
3672 /* Pass the value VAL to the inferior in the DR7 debug control
3673 register. Here we just store the address in D_REGS, the watchpoint
3674 will be actually set up in windows_wait. */
3676 cygwin_set_dr7 (unsigned long val
)
3678 dr
[7] = (CORE_ADDR
) val
;
3679 debug_registers_changed
= 1;
3680 debug_registers_used
= 1;
3683 /* Get the value of debug register I from the inferior. */
3686 cygwin_get_dr (int i
)
3691 /* Get the value of the DR6 debug status register from the inferior.
3692 Here we just return the value stored in dr[6]
3693 by the last call to thread_rec for current_event.dwThreadId id. */
3694 static unsigned long
3695 cygwin_get_dr6 (void)
3697 return (unsigned long) dr
[6];
3700 /* Get the value of the DR7 debug status register from the inferior.
3701 Here we just return the value stored in dr[7] by the last call to
3702 thread_rec for current_event.dwThreadId id. */
3704 static unsigned long
3705 cygwin_get_dr7 (void)
3707 return (unsigned long) dr
[7];
3710 /* Determine if the thread referenced by "ptid" is alive
3711 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3712 it means that the thread has died. Otherwise it is assumed to be alive. */
3715 windows_nat_target::thread_alive (ptid_t ptid
)
3717 gdb_assert (ptid
.lwp () != 0);
3719 return (WaitForSingleObject (thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
)->h
, 0)
3723 void _initialize_check_for_gdb_ini ();
3725 _initialize_check_for_gdb_ini ()
3728 if (inhibit_gdbinit
)
3731 homedir
= getenv ("HOME");
3735 char *oldini
= (char *) alloca (strlen (homedir
) +
3736 sizeof ("gdb.ini") + 1);
3737 strcpy (oldini
, homedir
);
3738 p
= strchr (oldini
, '\0');
3739 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3741 strcpy (p
, "gdb.ini");
3742 if (access (oldini
, 0) == 0)
3744 int len
= strlen (oldini
);
3745 char *newini
= (char *) alloca (len
+ 2);
3747 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3748 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3749 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3754 /* Define dummy functions which always return error for the rare cases where
3755 these functions could not be found. */
3757 bad_DebugActiveProcessStop (DWORD w
)
3762 bad_DebugBreakProcess (HANDLE w
)
3767 bad_DebugSetProcessKillOnExit (BOOL w
)
3772 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3779 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3785 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3792 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3798 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3804 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3810 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3818 /* Load any functions which may not be available in ancient versions
3821 void _initialize_loadable ();
3823 _initialize_loadable ()
3827 #define GPA(m, func) \
3828 func = (func ## _ftype *) GetProcAddress (m, #func)
3830 hm
= LoadLibrary ("kernel32.dll");
3833 GPA (hm
, DebugActiveProcessStop
);
3834 GPA (hm
, DebugBreakProcess
);
3835 GPA (hm
, DebugSetProcessKillOnExit
);
3836 GPA (hm
, GetConsoleFontSize
);
3837 GPA (hm
, DebugActiveProcessStop
);
3838 GPA (hm
, GetCurrentConsoleFont
);
3840 GPA (hm
, Wow64SuspendThread
);
3841 GPA (hm
, Wow64GetThreadContext
);
3842 GPA (hm
, Wow64SetThreadContext
);
3843 GPA (hm
, Wow64GetThreadSelectorEntry
);
3847 /* Set variables to dummy versions of these processes if the function
3848 wasn't found in kernel32.dll. */
3849 if (!DebugBreakProcess
)
3850 DebugBreakProcess
= bad_DebugBreakProcess
;
3851 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3853 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3854 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3856 if (!GetConsoleFontSize
)
3857 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3858 if (!GetCurrentConsoleFont
)
3859 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3861 /* Load optional functions used for retrieving filename information
3862 associated with the currently debugged process or its dlls. */
3863 hm
= LoadLibrary ("psapi.dll");
3866 GPA (hm
, EnumProcessModules
);
3868 GPA (hm
, EnumProcessModulesEx
);
3870 GPA (hm
, GetModuleInformation
);
3871 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3872 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3875 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3877 /* Set variables to dummy versions of these processes if the function
3878 wasn't found in psapi.dll. */
3879 EnumProcessModules
= bad_EnumProcessModules
;
3880 GetModuleInformation
= bad_GetModuleInformation
;
3881 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3882 /* This will probably fail on Windows 9x/Me. Let the user know
3883 that we're missing some functionality. */
3885 cannot automatically find executable file or library to read symbols.\n\
3886 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3889 hm
= LoadLibrary ("advapi32.dll");
3892 GPA (hm
, OpenProcessToken
);
3893 GPA (hm
, LookupPrivilegeValueA
);
3894 GPA (hm
, AdjustTokenPrivileges
);
3895 /* Only need to set one of these since if OpenProcessToken fails nothing
3897 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3898 || !AdjustTokenPrivileges
)
3899 OpenProcessToken
= bad_OpenProcessToken
;