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
);
924 /* Handle a DLL load event, and return 1.
926 This function assumes that this event did not occur during inferior
927 initialization, where their event info may be incomplete (see
928 do_initial_windows_stuff and windows_add_all_dlls for more info
929 on how we handle DLL loading during that phase). */
934 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
935 const char *dll_name
;
937 /* Try getting the DLL name via the lpImageName field of the event.
938 Note that Microsoft documents this fields as strictly optional,
939 in the sense that it might be NULL. And the first DLL event in
940 particular is explicitly documented as "likely not pass[ed]"
941 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
942 dll_name
= get_image_name (current_process_handle
,
943 event
->lpImageName
, event
->fUnicode
);
947 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
948 solib_end
= solib_end
->next
;
950 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
952 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
953 host_address_to_string (li
->load_addr
)));
957 windows_free_so (struct so_list
*so
)
959 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
965 /* Handle a DLL unload event.
966 Return 1 if successful, or zero otherwise.
968 This function assumes that this event did not occur during inferior
969 initialization, where their event info may be incomplete (see
970 do_initial_windows_stuff and windows_add_all_dlls for more info
971 on how we handle DLL loading during that phase). */
976 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
979 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
981 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
983 if (li_next
->load_addr
== lpBaseOfDll
)
985 struct so_list
*sodel
= so
->next
;
987 so
->next
= sodel
->next
;
990 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
992 windows_free_so (sodel
);
997 /* We did not find any DLL that was previously loaded at this address,
998 so register a complaint. We do not report an error, because we have
999 observed that this may be happening under some circumstances. For
1000 instance, running 32bit applications on x64 Windows causes us to receive
1001 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
1002 events are apparently caused by the WOW layer, the interface between
1003 32bit and 64bit worlds). */
1004 complaint (_("dll starting at %s not found."),
1005 host_address_to_string (lpBaseOfDll
));
1008 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
1012 catch_errors (void (*func
) ())
1018 catch (const gdb_exception
&ex
)
1020 exception_print (gdb_stderr
, ex
);
1024 /* Clear list of loaded DLLs. */
1026 windows_clear_solib (void)
1030 for (so
= solib_start
.next
; so
; so
= solib_start
.next
)
1032 solib_start
.next
= so
->next
;
1033 windows_free_so (so
);
1036 solib_end
= &solib_start
;
1040 signal_event_command (const char *args
, int from_tty
)
1042 uintptr_t event_id
= 0;
1043 char *endargs
= NULL
;
1046 error (_("signal-event requires an argument (integer event id)"));
1048 event_id
= strtoumax (args
, &endargs
, 10);
1050 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
1051 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
1052 error (_("Failed to convert `%s' to event id"), args
);
1054 SetEvent ((HANDLE
) event_id
);
1055 CloseHandle ((HANDLE
) event_id
);
1058 /* Handle DEBUG_STRING output from child process.
1059 Cygwin prepends its messages with a "cygwin:". Interpret this as
1060 a Cygwin signal. Otherwise just print the string as a warning. */
1062 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
1064 gdb::unique_xmalloc_ptr
<char> s
;
1067 if (!target_read_string
1068 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
1070 || !s
|| !*(s
.get ()))
1071 /* nothing to do */;
1072 else if (!startswith (s
.get (), _CYGWIN_SIGNAL_STRING
))
1075 if (!startswith (s
.get (), "cYg"))
1078 char *p
= strchr (s
.get (), '\0');
1080 if (p
> s
.get () && *--p
== '\n')
1082 warning (("%s"), s
.get ());
1088 /* Got a cygwin signal marker. A cygwin signal is followed by
1089 the signal number itself and then optionally followed by the
1090 thread id and address to saved context within the DLL. If
1091 these are supplied, then the given thread is assumed to have
1092 issued the signal and the context from the thread is assumed
1093 to be stored at the given address in the inferior. Tell gdb
1094 to treat this like a real signal. */
1096 int sig
= strtol (s
.get () + sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
1097 gdb_signal gotasig
= gdb_signal_from_host (sig
);
1099 ourstatus
->value
.sig
= gotasig
;
1105 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1106 retval
= strtoul (p
, &p
, 0);
1108 retval
= current_event
.dwThreadId
;
1109 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
1110 && ReadProcessMemory (current_process_handle
, x
,
1112 __COPY_CONTEXT_SIZE
, &n
)
1113 && n
== __COPY_CONTEXT_SIZE
)
1114 have_saved_context
= 1;
1123 display_selector (HANDLE thread
, DWORD sel
)
1129 ret
= Wow64GetThreadSelectorEntry (thread
, sel
, &info
);
1132 ret
= GetThreadSelectorEntry (thread
, sel
, &info
);
1136 printf_filtered ("0x%03x: ", (unsigned) sel
);
1137 if (!info
.HighWord
.Bits
.Pres
)
1139 puts_filtered ("Segment not present\n");
1142 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1143 (info
.HighWord
.Bits
.BaseMid
<< 16)
1145 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1146 if (info
.HighWord
.Bits
.Granularity
)
1147 limit
= (limit
<< 12) | 0xfff;
1148 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1149 if (info
.HighWord
.Bits
.Default_Big
)
1150 puts_filtered(" 32-bit ");
1152 puts_filtered(" 16-bit ");
1153 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1156 puts_filtered ("Data (Read-Only, Exp-up");
1159 puts_filtered ("Data (Read/Write, Exp-up");
1162 puts_filtered ("Unused segment (");
1165 puts_filtered ("Data (Read/Write, Exp-down");
1168 puts_filtered ("Code (Exec-Only, N.Conf");
1171 puts_filtered ("Code (Exec/Read, N.Conf");
1174 puts_filtered ("Code (Exec-Only, Conf");
1177 puts_filtered ("Code (Exec/Read, Conf");
1180 printf_filtered ("Unknown type 0x%lx",
1181 (unsigned long) info
.HighWord
.Bits
.Type
);
1183 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1184 puts_filtered(", N.Acc");
1185 puts_filtered (")\n");
1186 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1187 puts_filtered("System selector ");
1188 printf_filtered ("Priviledge level = %ld. ",
1189 (unsigned long) info
.HighWord
.Bits
.Dpl
);
1190 if (info
.HighWord
.Bits
.Granularity
)
1191 puts_filtered ("Page granular.\n");
1193 puts_filtered ("Byte granular.\n");
1198 DWORD err
= GetLastError ();
1199 if (err
== ERROR_NOT_SUPPORTED
)
1200 printf_filtered ("Function not supported\n");
1202 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1208 display_selectors (const char * args
, int from_tty
)
1210 if (!current_thread
)
1212 puts_filtered ("Impossible to display selectors now.\n");
1220 puts_filtered ("Selector $cs\n");
1221 display_selector (current_thread
->h
,
1222 current_thread
->wow64_context
.SegCs
);
1223 puts_filtered ("Selector $ds\n");
1224 display_selector (current_thread
->h
,
1225 current_thread
->wow64_context
.SegDs
);
1226 puts_filtered ("Selector $es\n");
1227 display_selector (current_thread
->h
,
1228 current_thread
->wow64_context
.SegEs
);
1229 puts_filtered ("Selector $ss\n");
1230 display_selector (current_thread
->h
,
1231 current_thread
->wow64_context
.SegSs
);
1232 puts_filtered ("Selector $fs\n");
1233 display_selector (current_thread
->h
,
1234 current_thread
->wow64_context
.SegFs
);
1235 puts_filtered ("Selector $gs\n");
1236 display_selector (current_thread
->h
,
1237 current_thread
->wow64_context
.SegGs
);
1242 puts_filtered ("Selector $cs\n");
1243 display_selector (current_thread
->h
,
1244 current_thread
->context
.SegCs
);
1245 puts_filtered ("Selector $ds\n");
1246 display_selector (current_thread
->h
,
1247 current_thread
->context
.SegDs
);
1248 puts_filtered ("Selector $es\n");
1249 display_selector (current_thread
->h
,
1250 current_thread
->context
.SegEs
);
1251 puts_filtered ("Selector $ss\n");
1252 display_selector (current_thread
->h
,
1253 current_thread
->context
.SegSs
);
1254 puts_filtered ("Selector $fs\n");
1255 display_selector (current_thread
->h
,
1256 current_thread
->context
.SegFs
);
1257 puts_filtered ("Selector $gs\n");
1258 display_selector (current_thread
->h
,
1259 current_thread
->context
.SegGs
);
1265 sel
= parse_and_eval_long (args
);
1266 printf_filtered ("Selector \"%s\"\n",args
);
1267 display_selector (current_thread
->h
, sel
);
1271 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1272 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1273 host_address_to_string (\
1274 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1276 static handle_exception_result
1277 handle_exception (struct target_waitstatus
*ourstatus
)
1279 EXCEPTION_RECORD
*rec
= ¤t_event
.u
.Exception
.ExceptionRecord
;
1280 DWORD code
= rec
->ExceptionCode
;
1281 handle_exception_result result
= HANDLE_EXCEPTION_HANDLED
;
1283 memcpy (&siginfo_er
, rec
, sizeof siginfo_er
);
1285 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1287 /* Record the context of the current thread. */
1288 thread_rec (ptid_t (current_event
.dwProcessId
, current_event
.dwThreadId
, 0),
1293 case EXCEPTION_ACCESS_VIOLATION
:
1294 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1295 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1298 /* See if the access violation happened within the cygwin DLL
1299 itself. Cygwin uses a kind of exception handling to deal
1300 with passed-in invalid addresses. gdb should not treat
1301 these as real SEGVs since they will be silently handled by
1302 cygwin. A real SEGV will (theoretically) be caught by
1303 cygwin later in the process and will be sent as a
1304 cygwin-specific-signal. So, ignore SEGVs if they show up
1305 within the text segment of the DLL itself. */
1307 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1309 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1310 && addr
< cygwin_load_end
))
1311 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1312 && startswith (fn
, "KERNEL32!IsBad")))
1313 return HANDLE_EXCEPTION_UNHANDLED
;
1317 case STATUS_STACK_OVERFLOW
:
1318 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1319 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1321 case STATUS_FLOAT_DENORMAL_OPERAND
:
1322 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1323 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1325 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1326 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1327 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1329 case STATUS_FLOAT_INEXACT_RESULT
:
1330 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1331 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1333 case STATUS_FLOAT_INVALID_OPERATION
:
1334 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1335 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1337 case STATUS_FLOAT_OVERFLOW
:
1338 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1339 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1341 case STATUS_FLOAT_STACK_CHECK
:
1342 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1343 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1345 case STATUS_FLOAT_UNDERFLOW
:
1346 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1347 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1349 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1350 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1351 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1353 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1354 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1355 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1357 case STATUS_INTEGER_OVERFLOW
:
1358 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1359 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1361 case EXCEPTION_BREAKPOINT
:
1363 if (ignore_first_breakpoint
)
1365 /* For WOW64 processes, there are always 2 breakpoint exceptions
1366 on startup, first a BREAKPOINT for the 64bit ntdll.dll,
1367 then a WX86_BREAKPOINT for the 32bit ntdll.dll.
1368 Here we only care about the WX86_BREAKPOINT's. */
1369 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1370 ignore_first_breakpoint
= false;
1374 case STATUS_WX86_BREAKPOINT
:
1375 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1376 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1379 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1380 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1382 case DBG_CONTROL_BREAK
:
1383 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1384 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1386 case EXCEPTION_SINGLE_STEP
:
1387 case STATUS_WX86_SINGLE_STEP
:
1388 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1389 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1391 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1392 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1393 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1395 case EXCEPTION_PRIV_INSTRUCTION
:
1396 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1397 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1399 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1400 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1401 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1403 case MS_VC_EXCEPTION
:
1404 if (rec
->NumberParameters
>= 3
1405 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1407 DWORD named_thread_id
;
1408 windows_thread_info
*named_thread
;
1409 CORE_ADDR thread_name_target
;
1411 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1413 thread_name_target
= rec
->ExceptionInformation
[1];
1414 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1416 if (named_thread_id
== (DWORD
) -1)
1417 named_thread_id
= current_event
.dwThreadId
;
1419 named_thread
= thread_rec (ptid_t (current_event
.dwProcessId
,
1420 named_thread_id
, 0),
1421 DONT_INVALIDATE_CONTEXT
);
1422 if (named_thread
!= NULL
)
1424 int thread_name_len
;
1425 gdb::unique_xmalloc_ptr
<char> thread_name
;
1427 thread_name_len
= target_read_string (thread_name_target
,
1428 &thread_name
, 1025, NULL
);
1429 if (thread_name_len
> 0)
1431 thread_name
.get ()[thread_name_len
- 1] = '\0';
1432 named_thread
->name
= std::move (thread_name
);
1435 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1436 result
= HANDLE_EXCEPTION_IGNORED
;
1439 /* treat improperly formed exception as unknown */
1442 /* Treat unhandled first chance exceptions specially. */
1443 if (current_event
.u
.Exception
.dwFirstChance
)
1444 return HANDLE_EXCEPTION_UNHANDLED
;
1445 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1446 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1447 host_address_to_string (
1448 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1449 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1453 last_sig
= ourstatus
->value
.sig
;
1457 /* Resume thread specified by ID, or all artificially suspended
1458 threads, if we are continuing execution. KILLED non-zero means we
1459 have killed the inferior, so we should ignore weird errors due to
1460 threads shutting down. */
1462 windows_continue (DWORD continue_status
, int id
, int killed
)
1466 desired_stop_thread_id
= id
;
1468 /* If there are pending stops, and we might plausibly hit one of
1469 them, we don't want to actually continue the inferior -- we just
1470 want to report the stop. In this case, we just pretend to
1471 continue. See the comment by the definition of "pending_stops"
1472 for details on why this is needed. */
1473 for (const auto &item
: pending_stops
)
1475 if (desired_stop_thread_id
== -1
1476 || desired_stop_thread_id
== item
.thread_id
)
1478 DEBUG_EVENTS (("windows_continue - pending stop anticipated, "
1479 "desired=0x%x, item=0x%x\n",
1480 desired_stop_thread_id
, item
.thread_id
));
1485 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1486 (unsigned) last_wait_event
.dwProcessId
,
1487 (unsigned) last_wait_event
.dwThreadId
,
1488 continue_status
== DBG_CONTINUE
?
1489 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1491 for (windows_thread_info
*th
: thread_list
)
1492 if (id
== -1 || id
== (int) th
->tid
)
1499 if (debug_registers_changed
)
1501 th
->wow64_context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1502 th
->wow64_context
.Dr0
= dr
[0];
1503 th
->wow64_context
.Dr1
= dr
[1];
1504 th
->wow64_context
.Dr2
= dr
[2];
1505 th
->wow64_context
.Dr3
= dr
[3];
1506 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1507 th
->wow64_context
.Dr7
= dr
[7];
1509 if (th
->wow64_context
.ContextFlags
)
1513 if (GetExitCodeThread (th
->h
, &ec
)
1514 && ec
== STILL_ACTIVE
)
1516 BOOL status
= Wow64SetThreadContext (th
->h
,
1517 &th
->wow64_context
);
1522 th
->wow64_context
.ContextFlags
= 0;
1528 if (debug_registers_changed
)
1530 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1531 th
->context
.Dr0
= dr
[0];
1532 th
->context
.Dr1
= dr
[1];
1533 th
->context
.Dr2
= dr
[2];
1534 th
->context
.Dr3
= dr
[3];
1535 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1536 th
->context
.Dr7
= dr
[7];
1538 if (th
->context
.ContextFlags
)
1542 if (GetExitCodeThread (th
->h
, &ec
)
1543 && ec
== STILL_ACTIVE
)
1545 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1550 th
->context
.ContextFlags
= 0;
1557 /* When single-stepping a specific thread, other threads must
1562 res
= ContinueDebugEvent (last_wait_event
.dwProcessId
,
1563 last_wait_event
.dwThreadId
,
1567 error (_("Failed to resume program execution"
1568 " (ContinueDebugEvent failed, error %u)"),
1569 (unsigned int) GetLastError ());
1571 debug_registers_changed
= 0;
1575 /* Called in pathological case where Windows fails to send a
1576 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1578 fake_create_process (void)
1580 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1581 current_event
.dwProcessId
);
1582 if (current_process_handle
!= NULL
)
1583 open_process_used
= 1;
1586 error (_("OpenProcess call failed, GetLastError = %u"),
1587 (unsigned) GetLastError ());
1588 /* We can not debug anything in that case. */
1591 = windows_add_thread (ptid_t (current_event
.dwProcessId
,
1592 current_event
.dwThreadId
, 0),
1593 current_event
.u
.CreateThread
.hThread
,
1594 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1595 true /* main_thread_p */);
1596 return current_event
.dwThreadId
;
1600 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1602 windows_thread_info
*th
;
1603 DWORD continue_status
= DBG_CONTINUE
;
1605 /* A specific PTID means `step only this thread id'. */
1606 int resume_all
= ptid
== minus_one_ptid
;
1608 /* If we're continuing all threads, it's the current inferior that
1609 should be handled specially. */
1611 ptid
= inferior_ptid
;
1613 if (sig
!= GDB_SIGNAL_0
)
1615 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1617 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1619 else if (sig
== last_sig
)
1620 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1623 /* This code does not seem to work, because
1624 the kernel does probably not consider changes in the ExceptionRecord
1625 structure when passing the exception to the inferior.
1626 Note that this seems possible in the exception handler itself. */
1628 for (const xlate_exception
&x
: xlate
)
1631 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1633 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1636 if (continue_status
== DBG_CONTINUE
)
1638 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1642 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1646 last_sig
= GDB_SIGNAL_0
;
1648 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=0x%x, step=%d, sig=%d);\n",
1649 ptid
.pid (), (unsigned) ptid
.lwp (), step
, sig
));
1651 /* Get context for currently selected thread. */
1652 th
= thread_rec (inferior_ptid
, DONT_INVALIDATE_CONTEXT
);
1660 /* Single step by setting t bit. */
1661 struct regcache
*regcache
= get_current_regcache ();
1662 struct gdbarch
*gdbarch
= regcache
->arch ();
1663 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1664 th
->wow64_context
.EFlags
|= FLAG_TRACE_BIT
;
1667 if (th
->wow64_context
.ContextFlags
)
1669 if (debug_registers_changed
)
1671 th
->wow64_context
.Dr0
= dr
[0];
1672 th
->wow64_context
.Dr1
= dr
[1];
1673 th
->wow64_context
.Dr2
= dr
[2];
1674 th
->wow64_context
.Dr3
= dr
[3];
1675 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1676 th
->wow64_context
.Dr7
= dr
[7];
1678 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
1679 th
->wow64_context
.ContextFlags
= 0;
1687 /* Single step by setting t bit. */
1688 struct regcache
*regcache
= get_current_regcache ();
1689 struct gdbarch
*gdbarch
= regcache
->arch ();
1690 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1691 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1694 if (th
->context
.ContextFlags
)
1696 if (debug_registers_changed
)
1698 th
->context
.Dr0
= dr
[0];
1699 th
->context
.Dr1
= dr
[1];
1700 th
->context
.Dr2
= dr
[2];
1701 th
->context
.Dr3
= dr
[3];
1702 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1703 th
->context
.Dr7
= dr
[7];
1705 CHECK (SetThreadContext (th
->h
, &th
->context
));
1706 th
->context
.ContextFlags
= 0;
1711 /* Allow continuing with the same signal that interrupted us.
1712 Otherwise complain. */
1715 windows_continue (continue_status
, -1, 0);
1717 windows_continue (continue_status
, ptid
.lwp (), 0);
1720 /* Ctrl-C handler used when the inferior is not run in the same console. The
1721 handler is in charge of interrupting the inferior using DebugBreakProcess.
1722 Note that this function is not available prior to Windows XP. In this case
1723 we emit a warning. */
1725 ctrl_c_handler (DWORD event_type
)
1727 const int attach_flag
= current_inferior ()->attach_flag
;
1729 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1730 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1733 /* If the inferior and the debugger share the same console, do nothing as
1734 the inferior has also received the Ctrl-C event. */
1735 if (!new_console
&& !attach_flag
)
1738 if (!DebugBreakProcess (current_process_handle
))
1739 warning (_("Could not interrupt program. "
1740 "Press Ctrl-c in the program console."));
1742 /* Return true to tell that Ctrl-C has been handled. */
1746 /* A wrapper for WaitForDebugEvent that sets "last_wait_event"
1749 wait_for_debug_event (DEBUG_EVENT
*event
, DWORD timeout
)
1751 BOOL result
= WaitForDebugEvent (event
, timeout
);
1753 last_wait_event
= *event
;
1757 /* Get the next event from the child. Returns a non-zero thread id if the event
1758 requires handling by WFI (or whatever). */
1761 windows_nat_target::get_windows_debug_event (int pid
,
1762 struct target_waitstatus
*ourstatus
)
1765 DWORD continue_status
, event_code
;
1766 windows_thread_info
*th
;
1767 static windows_thread_info
dummy_thread_info (0, 0, 0);
1768 DWORD thread_id
= 0;
1770 /* If there is a relevant pending stop, report it now. See the
1771 comment by the definition of "pending_stops" for details on why
1773 for (auto iter
= pending_stops
.begin ();
1774 iter
!= pending_stops
.end ();
1777 if (desired_stop_thread_id
== -1
1778 || desired_stop_thread_id
== iter
->thread_id
)
1780 thread_id
= iter
->thread_id
;
1781 *ourstatus
= iter
->status
;
1782 current_event
= iter
->event
;
1784 inferior_ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1785 current_thread
= thread_rec (inferior_ptid
, INVALIDATE_CONTEXT
);
1786 current_thread
->reload_context
= 1;
1788 DEBUG_EVENTS (("get_windows_debug_event - "
1789 "pending stop found in 0x%x (desired=0x%x)\n",
1790 thread_id
, desired_stop_thread_id
));
1792 pending_stops
.erase (iter
);
1797 last_sig
= GDB_SIGNAL_0
;
1799 if (!(debug_event
= wait_for_debug_event (¤t_event
, 1000)))
1803 continue_status
= DBG_CONTINUE
;
1805 event_code
= current_event
.dwDebugEventCode
;
1806 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1808 have_saved_context
= 0;
1812 case CREATE_THREAD_DEBUG_EVENT
:
1813 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1814 (unsigned) current_event
.dwProcessId
,
1815 (unsigned) current_event
.dwThreadId
,
1816 "CREATE_THREAD_DEBUG_EVENT"));
1817 if (saw_create
!= 1)
1819 inferior
*inf
= find_inferior_pid (this, current_event
.dwProcessId
);
1820 if (!saw_create
&& inf
->attach_flag
)
1822 /* Kludge around a Windows bug where first event is a create
1823 thread event. Caused when attached process does not have
1825 thread_id
= fake_create_process ();
1831 /* Record the existence of this thread. */
1832 thread_id
= current_event
.dwThreadId
;
1833 th
= windows_add_thread
1834 (ptid_t (current_event
.dwProcessId
, current_event
.dwThreadId
, 0),
1835 current_event
.u
.CreateThread
.hThread
,
1836 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1837 false /* main_thread_p */);
1841 case EXIT_THREAD_DEBUG_EVENT
:
1842 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1843 (unsigned) current_event
.dwProcessId
,
1844 (unsigned) current_event
.dwThreadId
,
1845 "EXIT_THREAD_DEBUG_EVENT"));
1846 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1847 current_event
.dwThreadId
, 0),
1848 current_event
.u
.ExitThread
.dwExitCode
,
1849 false /* main_thread_p */);
1850 th
= &dummy_thread_info
;
1853 case CREATE_PROCESS_DEBUG_EVENT
:
1854 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1855 (unsigned) current_event
.dwProcessId
,
1856 (unsigned) current_event
.dwThreadId
,
1857 "CREATE_PROCESS_DEBUG_EVENT"));
1858 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1859 if (++saw_create
!= 1)
1862 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1863 /* Add the main thread. */
1864 th
= windows_add_thread
1865 (ptid_t (current_event
.dwProcessId
,
1866 current_event
.dwThreadId
, 0),
1867 current_event
.u
.CreateProcessInfo
.hThread
,
1868 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
,
1869 true /* main_thread_p */);
1870 thread_id
= current_event
.dwThreadId
;
1873 case EXIT_PROCESS_DEBUG_EVENT
:
1874 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1875 (unsigned) current_event
.dwProcessId
,
1876 (unsigned) current_event
.dwThreadId
,
1877 "EXIT_PROCESS_DEBUG_EVENT"));
1878 if (!windows_initialization_done
)
1880 target_terminal::ours ();
1881 target_mourn_inferior (inferior_ptid
);
1882 error (_("During startup program exited with code 0x%x."),
1883 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1885 else if (saw_create
== 1)
1887 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1888 current_event
.dwThreadId
, 0),
1889 0, true /* main_thread_p */);
1890 DWORD exit_status
= current_event
.u
.ExitProcess
.dwExitCode
;
1891 /* If the exit status looks like a fatal exception, but we
1892 don't recognize the exception's code, make the original
1893 exit status value available, to avoid losing
1896 = WIFSIGNALED (exit_status
) ? WTERMSIG (exit_status
) : -1;
1897 if (exit_signal
== -1)
1899 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1900 ourstatus
->value
.integer
= exit_status
;
1904 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1905 ourstatus
->value
.sig
= gdb_signal_from_host (exit_signal
);
1907 thread_id
= current_event
.dwThreadId
;
1911 case LOAD_DLL_DEBUG_EVENT
:
1912 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1913 (unsigned) current_event
.dwProcessId
,
1914 (unsigned) current_event
.dwThreadId
,
1915 "LOAD_DLL_DEBUG_EVENT"));
1916 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1917 if (saw_create
!= 1 || ! windows_initialization_done
)
1919 catch_errors (handle_load_dll
);
1920 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1921 ourstatus
->value
.integer
= 0;
1922 thread_id
= current_event
.dwThreadId
;
1925 case UNLOAD_DLL_DEBUG_EVENT
:
1926 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1927 (unsigned) current_event
.dwProcessId
,
1928 (unsigned) current_event
.dwThreadId
,
1929 "UNLOAD_DLL_DEBUG_EVENT"));
1930 if (saw_create
!= 1 || ! windows_initialization_done
)
1932 catch_errors (handle_unload_dll
);
1933 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1934 ourstatus
->value
.integer
= 0;
1935 thread_id
= current_event
.dwThreadId
;
1938 case EXCEPTION_DEBUG_EVENT
:
1939 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1940 (unsigned) current_event
.dwProcessId
,
1941 (unsigned) current_event
.dwThreadId
,
1942 "EXCEPTION_DEBUG_EVENT"));
1943 if (saw_create
!= 1)
1945 switch (handle_exception (ourstatus
))
1947 case HANDLE_EXCEPTION_UNHANDLED
:
1949 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1951 case HANDLE_EXCEPTION_HANDLED
:
1952 thread_id
= current_event
.dwThreadId
;
1954 case HANDLE_EXCEPTION_IGNORED
:
1955 continue_status
= DBG_CONTINUE
;
1960 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1961 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1962 (unsigned) current_event
.dwProcessId
,
1963 (unsigned) current_event
.dwThreadId
,
1964 "OUTPUT_DEBUG_STRING_EVENT"));
1965 if (saw_create
!= 1)
1967 thread_id
= handle_output_debug_string (ourstatus
);
1971 if (saw_create
!= 1)
1973 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1974 (unsigned) current_event
.dwProcessId
,
1975 (unsigned) current_event
.dwThreadId
);
1976 printf_unfiltered (" unknown event code %u\n",
1977 (unsigned) current_event
.dwDebugEventCode
);
1981 if (!thread_id
|| saw_create
!= 1)
1983 CHECK (windows_continue (continue_status
, desired_stop_thread_id
, 0));
1985 else if (desired_stop_thread_id
!= -1 && desired_stop_thread_id
!= thread_id
)
1987 /* Pending stop. See the comment by the definition of
1988 "pending_stops" for details on why this is needed. */
1989 DEBUG_EVENTS (("get_windows_debug_event - "
1990 "unexpected stop in 0x%x (expecting 0x%x)\n",
1991 thread_id
, desired_stop_thread_id
));
1993 if (current_event
.dwDebugEventCode
== EXCEPTION_DEBUG_EVENT
1994 && (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1995 == EXCEPTION_BREAKPOINT
)
1996 && windows_initialization_done
)
1998 ptid_t ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1999 th
= thread_rec (ptid
, INVALIDATE_CONTEXT
);
2000 th
->stopped_at_software_breakpoint
= true;
2002 pending_stops
.push_back ({thread_id
, *ourstatus
, current_event
});
2004 CHECK (windows_continue (continue_status
, desired_stop_thread_id
, 0));
2008 inferior_ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
2009 current_thread
= th
;
2010 if (!current_thread
)
2011 current_thread
= thread_rec (inferior_ptid
, INVALIDATE_CONTEXT
);
2018 /* Wait for interesting events to occur in the target process. */
2020 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
2025 /* We loop when we get a non-standard exception rather than return
2026 with a SPURIOUS because resume can try and step or modify things,
2027 which needs a current_thread->h. But some of these exceptions mark
2028 the birth or death of threads, which mean that the current thread
2029 isn't necessarily what you think it is. */
2035 /* If the user presses Ctrl-c while the debugger is waiting
2036 for an event, he expects the debugger to interrupt his program
2037 and to get the prompt back. There are two possible situations:
2039 - The debugger and the program do not share the console, in
2040 which case the Ctrl-c event only reached the debugger.
2041 In that case, the ctrl_c handler will take care of interrupting
2042 the inferior. Note that this case is working starting with
2043 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
2046 - The debugger and the program share the same console, in which
2047 case both debugger and inferior will receive the Ctrl-c event.
2048 In that case the ctrl_c handler will ignore the event, as the
2049 Ctrl-c event generated inside the inferior will trigger the
2050 expected debug event.
2052 FIXME: brobecker/2008-05-20: If the inferior receives the
2053 signal first and the delay until GDB receives that signal
2054 is sufficiently long, GDB can sometimes receive the SIGINT
2055 after we have unblocked the CTRL+C handler. This would
2056 lead to the debugger stopping prematurely while handling
2057 the new-thread event that comes with the handling of the SIGINT
2058 inside the inferior, and then stop again immediately when
2059 the user tries to resume the execution in the inferior.
2060 This is a classic race that we should try to fix one day. */
2061 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
2062 retval
= get_windows_debug_event (pid
, ourstatus
);
2063 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
2067 ptid_t result
= ptid_t (current_event
.dwProcessId
, retval
, 0);
2069 if (current_thread
!= nullptr)
2071 current_thread
->stopped_at_software_breakpoint
= false;
2072 if (current_event
.dwDebugEventCode
== EXCEPTION_DEBUG_EVENT
2073 && (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
2074 == EXCEPTION_BREAKPOINT
)
2075 && windows_initialization_done
)
2076 current_thread
->stopped_at_software_breakpoint
= true;
2085 if (deprecated_ui_loop_hook
!= NULL
)
2086 detach
= deprecated_ui_loop_hook (0);
2094 /* Iterate over all DLLs currently mapped by our inferior, and
2095 add them to our list of solibs. */
2098 windows_add_all_dlls (void)
2100 HMODULE dummy_hmodule
;
2108 if (EnumProcessModulesEx (current_process_handle
, &dummy_hmodule
,
2109 sizeof (HMODULE
), &cb_needed
,
2110 LIST_MODULES_32BIT
) == 0)
2116 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
2117 sizeof (HMODULE
), &cb_needed
) == 0)
2124 hmodules
= (HMODULE
*) alloca (cb_needed
);
2128 if (EnumProcessModulesEx (current_process_handle
, hmodules
,
2129 cb_needed
, &cb_needed
,
2130 LIST_MODULES_32BIT
) == 0)
2136 if (EnumProcessModules (current_process_handle
, hmodules
,
2137 cb_needed
, &cb_needed
) == 0)
2141 char system_dir
[__PMAX
];
2142 char syswow_dir
[__PMAX
];
2143 size_t system_dir_len
= 0;
2144 bool convert_syswow_dir
= false;
2149 /* This fails on 32bit Windows because it has no SysWOW64 directory,
2150 and in this case a path conversion isn't necessary. */
2151 UINT len
= GetSystemWow64DirectoryA (syswow_dir
, sizeof (syswow_dir
));
2154 /* Check that we have passed a large enough buffer. */
2155 gdb_assert (len
< sizeof (syswow_dir
));
2157 len
= GetSystemDirectoryA (system_dir
, sizeof (system_dir
));
2159 gdb_assert (len
!= 0);
2160 /* Check that we have passed a large enough buffer. */
2161 gdb_assert (len
< sizeof (system_dir
));
2163 strcat (system_dir
, "\\");
2164 strcat (syswow_dir
, "\\");
2165 system_dir_len
= strlen (system_dir
);
2167 convert_syswow_dir
= true;
2171 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
2175 wchar_t dll_name
[__PMAX
];
2176 char dll_name_mb
[__PMAX
];
2178 char dll_name
[__PMAX
];
2181 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
2182 &mi
, sizeof (mi
)) == 0)
2184 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
2185 dll_name
, sizeof (dll_name
)) == 0)
2188 wcstombs (dll_name_mb
, dll_name
, __PMAX
);
2193 /* Convert the DLL path of 32bit processes returned by
2194 GetModuleFileNameEx from the 64bit system directory to the
2195 32bit syswow64 directory if necessary. */
2196 std::string syswow_dll_path
;
2197 if (convert_syswow_dir
2198 && strncasecmp (name
, system_dir
, system_dir_len
) == 0
2199 && strchr (name
+ system_dir_len
, '\\') == nullptr)
2201 syswow_dll_path
= syswow_dir
;
2202 syswow_dll_path
+= name
+ system_dir_len
;
2203 name
= syswow_dll_path
.c_str();
2206 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
2207 solib_end
= solib_end
->next
;
2212 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
2215 struct inferior
*inf
;
2217 last_sig
= GDB_SIGNAL_0
;
2219 exception_count
= 0;
2220 open_process_used
= 0;
2221 debug_registers_changed
= 0;
2222 debug_registers_used
= 0;
2223 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
2226 cygwin_load_start
= cygwin_load_end
= 0;
2228 current_event
.dwProcessId
= pid
;
2229 memset (¤t_event
, 0, sizeof (current_event
));
2230 if (!target_is_pushed (ops
))
2232 disable_breakpoints_in_shlibs ();
2233 windows_clear_solib ();
2234 clear_proceed_status (0);
2235 init_wait_for_inferior ();
2238 ignore_first_breakpoint
= !attaching
&& wow64_process
;
2242 windows_set_context_register_offsets (amd64_mappings
);
2243 windows_set_segment_register_p (amd64_windows_segment_register_p
);
2248 windows_set_context_register_offsets (i386_mappings
);
2249 windows_set_segment_register_p (i386_windows_segment_register_p
);
2252 inf
= current_inferior ();
2253 inferior_appeared (inf
, pid
);
2254 inf
->attach_flag
= attaching
;
2256 /* Make the new process the current inferior, so terminal handling
2257 can rely on it. When attaching, we don't know about any thread
2258 id here, but that's OK --- nothing should be referencing the
2259 current thread until we report an event out of windows_wait. */
2260 inferior_ptid
= ptid_t (pid
);
2262 target_terminal::init ();
2263 target_terminal::inferior ();
2265 windows_initialization_done
= 0;
2269 struct target_waitstatus status
;
2271 ops
->wait (minus_one_ptid
, &status
, 0);
2273 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
2275 if (status
.kind
!= TARGET_WAITKIND_LOADED
2276 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
2279 ops
->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
2282 /* Now that the inferior has been started and all DLLs have been mapped,
2283 we can iterate over all DLLs and load them in.
2285 We avoid doing it any earlier because, on certain versions of Windows,
2286 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
2287 we have seen on Windows 8.1 that the ntdll.dll load event does not
2288 include the DLL name, preventing us from creating an associated SO.
2289 A possible explanation is that ntdll.dll might be mapped before
2290 the SO info gets created by the Windows system -- ntdll.dll is
2291 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
2292 do not seem to suffer from that problem.
2294 Rather than try to work around this sort of issue, it is much
2295 simpler to just ignore DLL load/unload events during the startup
2296 phase, and then process them all in one batch now. */
2297 windows_add_all_dlls ();
2299 windows_initialization_done
= 1;
2303 /* Try to set or remove a user privilege to the current process. Return -1
2304 if that fails, the previous setting of that privilege otherwise.
2306 This code is copied from the Cygwin source code and rearranged to allow
2307 dynamically loading of the needed symbols from advapi32 which is only
2308 available on NT/2K/XP. */
2310 set_process_privilege (const char *privilege
, BOOL enable
)
2312 HANDLE token_hdl
= NULL
;
2314 TOKEN_PRIVILEGES new_priv
, orig_priv
;
2318 if (!OpenProcessToken (GetCurrentProcess (),
2319 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
2323 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
2326 new_priv
.PrivilegeCount
= 1;
2327 new_priv
.Privileges
[0].Luid
= restore_priv
;
2328 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
2330 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
2331 sizeof orig_priv
, &orig_priv
, &size
))
2334 /* Disabled, otherwise every `attach' in an unprivileged user session
2335 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
2336 windows_attach(). */
2337 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
2338 be enabled. GetLastError () returns an correct error code, though. */
2339 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
2343 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
2347 CloseHandle (token_hdl
);
2352 /* Attach to process PID, then initialize for debugging it. */
2355 windows_nat_target::attach (const char *args
, int from_tty
)
2360 pid
= parse_pid_to_attach (args
);
2362 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
2364 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
2365 printf_unfiltered ("This can cause attach to "
2366 "fail on Windows NT/2K/XP\n");
2369 windows_init_thread_list ();
2370 ok
= DebugActiveProcess (pid
);
2376 /* Try fall back to Cygwin pid. */
2377 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
2380 ok
= DebugActiveProcess (pid
);
2385 error (_("Can't attach to process %u (error %u)"),
2386 (unsigned) pid
, (unsigned) GetLastError ());
2388 DebugSetProcessKillOnExit (FALSE
);
2392 const char *exec_file
= get_exec_file (0);
2395 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
2396 target_pid_to_str (ptid_t (pid
)).c_str ());
2398 printf_unfiltered ("Attaching to %s\n",
2399 target_pid_to_str (ptid_t (pid
)).c_str ());
2403 HANDLE h
= OpenProcess (PROCESS_QUERY_INFORMATION
, FALSE
, pid
);
2407 if (IsWow64Process (h
, &wow64
))
2408 wow64_process
= wow64
;
2413 do_initial_windows_stuff (this, pid
, 1);
2414 target_terminal::ours ();
2418 windows_nat_target::detach (inferior
*inf
, int from_tty
)
2422 ptid_t ptid
= minus_one_ptid
;
2423 resume (ptid
, 0, GDB_SIGNAL_0
);
2425 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
2427 error (_("Can't detach process %u (error %u)"),
2428 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
2431 DebugSetProcessKillOnExit (FALSE
);
2433 if (detached
&& from_tty
)
2435 const char *exec_file
= get_exec_file (0);
2438 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
2439 (unsigned) current_event
.dwProcessId
);
2442 x86_cleanup_dregs ();
2443 inferior_ptid
= null_ptid
;
2444 detach_inferior (inf
);
2446 maybe_unpush_target ();
2449 /* Try to determine the executable filename.
2451 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2453 Upon success, the filename is stored inside EXE_NAME_RET, and
2454 this function returns nonzero.
2456 Otherwise, this function returns zero and the contents of
2457 EXE_NAME_RET is undefined. */
2460 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2470 if (!EnumProcessModulesEx (current_process_handle
, &dh_buf
,
2471 sizeof (HMODULE
), &cbNeeded
,
2472 LIST_MODULES_32BIT
) || !cbNeeded
)
2478 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2479 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2483 /* We know the executable is always first in the list of modules,
2484 which we just fetched. So no need to fetch more. */
2488 /* Cygwin prefers that the path be in /x/y/z format, so extract
2489 the filename into a temporary buffer first, and then convert it
2490 to POSIX format into the destination buffer. */
2491 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2493 len
= GetModuleFileNameEx (current_process_handle
,
2494 dh_buf
, pathbuf
, exe_name_max_len
);
2496 error (_("Error getting executable filename: %u."),
2497 (unsigned) GetLastError ());
2498 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2499 exe_name_max_len
) < 0)
2500 error (_("Error converting executable filename to POSIX: %d."), errno
);
2503 len
= GetModuleFileNameEx (current_process_handle
,
2504 dh_buf
, exe_name_ret
, exe_name_max_len
);
2506 error (_("Error getting executable filename: %u."),
2507 (unsigned) GetLastError ());
2510 return 1; /* success */
2513 /* The pid_to_exec_file target_ops method for this platform. */
2516 windows_nat_target::pid_to_exec_file (int pid
)
2518 static char path
[__PMAX
];
2520 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2522 char procexe
[sizeof ("/proc/4294967295/exe")];
2524 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2525 nchars
= readlink (procexe
, path
, sizeof(path
));
2526 if (nchars
> 0 && nchars
< sizeof (path
))
2528 path
[nchars
] = '\0'; /* Got it */
2533 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2534 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2535 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2541 /* Print status information about what we're accessing. */
2544 windows_nat_target::files_info ()
2546 struct inferior
*inf
= current_inferior ();
2548 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2549 inf
->attach_flag
? "attached" : "child",
2550 target_pid_to_str (inferior_ptid
).c_str ());
2553 /* Modify CreateProcess parameters for use of a new separate console.
2555 *FLAGS: DWORD parameter for general process creation flags.
2556 *SI: STARTUPINFO structure, for which the console window size and
2557 console buffer size is filled in if GDB is running in a console.
2558 to create the new console.
2559 The size of the used font is not available on all versions of
2560 Windows OS. Furthermore, the current font might not be the default
2561 font, but this is still better than before.
2562 If the windows and buffer sizes are computed,
2563 SI->DWFLAGS is changed so that this information is used
2564 by CreateProcess function. */
2567 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2569 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2570 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2572 if (hconsole
!= INVALID_HANDLE_VALUE
)
2574 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2576 CONSOLE_FONT_INFO cfi
;
2578 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2579 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2580 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2581 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2582 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2584 si
->dwXSize
*= font_size
.X
;
2588 si
->dwYSize
*= font_size
.Y
;
2591 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2592 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2593 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2595 *flags
|= CREATE_NEW_CONSOLE
;
2599 /* Function called by qsort to sort environment strings. */
2602 envvar_cmp (const void *a
, const void *b
)
2604 const char **p
= (const char **) a
;
2605 const char **q
= (const char **) b
;
2606 return strcasecmp (*p
, *q
);
2612 clear_win32_environment (char **env
)
2616 wchar_t *copy
= NULL
, *equalpos
;
2618 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2620 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2621 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2622 mbstowcs (copy
, env
[i
], len
);
2623 equalpos
= wcschr (copy
, L
'=');
2626 SetEnvironmentVariableW (copy
, NULL
);
2634 /* Redirection of inferior I/O streams for native MS-Windows programs.
2635 Unlike on Unix, where this is handled by invoking the inferior via
2636 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2638 The official documentation of the cmd.exe redirection features is here:
2640 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2642 (That page talks about Windows XP, but there's no newer
2643 documentation, so we assume later versions of cmd.exe didn't change
2646 Caveat: the documentation on that page seems to include a few lies.
2647 For example, it describes strange constructs 1<&2 and 2<&1, which
2648 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2649 think the cmd.exe parser of the redirection symbols simply doesn't
2650 care about the < vs > distinction in these cases. Therefore, the
2651 supported features are explicitly documented below.
2653 The emulation below aims at supporting all the valid use cases
2654 supported by cmd.exe, which include:
2656 < FILE redirect standard input from FILE
2657 0< FILE redirect standard input from FILE
2658 <&N redirect standard input from file descriptor N
2659 0<&N redirect standard input from file descriptor N
2660 > FILE redirect standard output to FILE
2661 >> FILE append standard output to FILE
2662 1>> FILE append standard output to FILE
2663 >&N redirect standard output to file descriptor N
2664 1>&N redirect standard output to file descriptor N
2665 >>&N append standard output to file descriptor N
2666 1>>&N append standard output to file descriptor N
2667 2> FILE redirect standard error to FILE
2668 2>> FILE append standard error to FILE
2669 2>&N redirect standard error to file descriptor N
2670 2>>&N append standard error to file descriptor N
2672 Note that using N > 2 in the above construct is supported, but
2673 requires that the corresponding file descriptor be open by some
2674 means elsewhere or outside GDB. Also note that using ">&0" or
2675 "<&2" will generally fail, because the file descriptor redirected
2676 from is normally open in an incompatible mode (e.g., FD 0 is open
2677 for reading only). IOW, use of such tricks is not recommended;
2678 you are on your own.
2680 We do NOT support redirection of file descriptors above 2, as in
2681 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2682 that needs special handling in the startup code that MinGW
2683 doesn't have). Pipes are also not supported.
2685 As for invalid use cases, where the redirection contains some
2686 error, the emulation below will detect that and produce some
2687 error and/or failure. But the behavior in those cases is not
2688 bug-for-bug compatible with what cmd.exe does in those cases.
2689 That's because what cmd.exe does then is not well defined, and
2690 seems to be a side effect of the cmd.exe parsing of the command
2691 line more than anything else. For example, try redirecting to an
2692 invalid file name, as in "> foo:bar".
2694 There are also minor syntactic deviations from what cmd.exe does
2695 in some corner cases. For example, it doesn't support the likes
2696 of "> &foo" to mean redirect to file named literally "&foo"; we
2697 do support that here, because that, too, sounds like some issue
2698 with the cmd.exe parser. Another nicety is that we support
2699 redirection targets that use file names with forward slashes,
2700 something cmd.exe doesn't -- this comes in handy since GDB
2701 file-name completion can be used when typing the command line for
2704 /* Support routines for redirecting standard handles of the inferior. */
2706 /* Parse a single redirection spec, open/duplicate the specified
2707 file/fd, and assign the appropriate value to one of the 3 standard
2708 file descriptors. */
2710 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2712 int *fd
, ref_fd
= -2;
2714 const char *fname
= redir_string
+ 1;
2715 int rc
= *redir_string
;
2730 fd
= (rc
== '2') ? err
: out
;
2731 mode
= O_WRONLY
| O_CREAT
;
2744 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2746 /* A reference to a file descriptor. */
2748 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2749 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2751 /* Don't allow redirection when open modes are incompatible. */
2752 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2753 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2760 else if (ref_fd
== 1)
2762 else if (ref_fd
== 2)
2772 fname
++; /* skip the separator space */
2773 /* If the descriptor is already open, close it. This allows
2774 multiple specs of redirections for the same stream, which is
2775 somewhat nonsensical, but still valid and supported by cmd.exe.
2776 (But cmd.exe only opens a single file in this case, the one
2777 specified by the last redirection spec on the command line.) */
2782 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2786 else if (ref_fd
== -1)
2787 *fd
= -1; /* reset to default destination */
2790 *fd
= _dup (ref_fd
);
2794 /* _open just sets a flag for O_APPEND, which won't be passed to the
2795 inferior, so we need to actually move the file pointer. */
2796 if ((mode
& O_APPEND
) != 0)
2797 _lseek (*fd
, 0L, SEEK_END
);
2801 /* Canonicalize a single redirection spec and set up the corresponding
2802 file descriptor as specified. */
2804 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2806 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2808 const char *start
= s
;
2811 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2812 if ((*start
== '>' || *start
== '1' || *start
== '2')
2816 if (*s
== '>' && *start
!= '>')
2819 else if (*start
== '0' && *s
== '<')
2821 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2824 while (isspace (*s
)) /* skip whitespace before file name */
2826 *d
++ = ' '; /* separate file name with a single space */
2829 /* Copy the file name. */
2832 /* Remove quoting characters from the file name in buf[]. */
2833 if (*s
== '"') /* could support '..' quoting here */
2837 else if (*s
== quote
)
2845 else if (*s
== '\\')
2847 if (s
[1] == '"') /* could support '..' here */
2851 else if (isspace (*s
) && !quote
)
2855 if (d
- buf
>= sizeof (buf
) - 1)
2857 errno
= ENAMETOOLONG
;
2863 /* Windows doesn't allow redirection characters in file names, so we
2864 can bail out early if they use them, or if there's no target file
2865 name after the redirection symbol. */
2866 if (d
[-1] == '>' || d
[-1] == '<')
2871 if (redir_open (buf
, inp
, out
, err
) == 0)
2876 /* Parse the command line for redirection specs and prepare the file
2877 descriptors for the 3 standard streams accordingly. */
2879 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2880 int *inp
, int *out
, int *err
)
2882 const char *s
= cmd_orig
;
2885 bool retval
= false;
2887 while (isspace (*s
))
2892 if (*s
== '"') /* could also support '..' quoting here */
2896 else if (*s
== quote
)
2899 else if (*s
== '\\')
2901 if (s
[1] == '"') /* escaped quote char */
2906 /* Process a single redirection candidate. */
2907 if (*s
== '<' || *s
== '>'
2908 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2909 || (*s
== '0' && s
[1] == '<'))
2911 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2925 #endif /* !__CYGWIN__ */
2927 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2928 EXEC_FILE is the file to run.
2929 ALLARGS is a string containing the arguments to the program.
2930 ENV is the environment vector to pass. Errors reported with error(). */
2933 windows_nat_target::create_inferior (const char *exec_file
,
2934 const std::string
&origallargs
,
2935 char **in_env
, int from_tty
)
2939 cygwin_buf_t real_path
[__PMAX
];
2940 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2941 cygwin_buf_t infcwd
[__PMAX
];
2943 cygwin_buf_t
*toexec
;
2944 cygwin_buf_t
*cygallargs
;
2946 char **old_env
= NULL
;
2950 int ostdin
, ostdout
, ostderr
;
2951 #else /* !__CYGWIN__ */
2952 char shell
[__PMAX
]; /* Path to shell */
2954 char *args
, *allargs_copy
;
2955 size_t args_len
, allargs_len
;
2956 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2957 HANDLE tty
= INVALID_HANDLE_VALUE
;
2958 bool redirected
= false;
2965 #endif /* !__CYGWIN__ */
2966 const char *allargs
= origallargs
.c_str ();
2967 PROCESS_INFORMATION pi
;
2970 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2973 error (_("No executable specified, use `target exec'."));
2975 const char *inferior_cwd
= get_inferior_cwd ();
2976 std::string expanded_infcwd
;
2977 if (inferior_cwd
!= NULL
)
2979 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
2980 /* Mirror slashes on inferior's cwd. */
2981 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
2983 inferior_cwd
= expanded_infcwd
.c_str ();
2986 memset (&si
, 0, sizeof (si
));
2987 si
.cb
= sizeof (si
);
2990 flags
|= CREATE_NEW_PROCESS_GROUP
;
2993 windows_set_console_info (&si
, &flags
);
2998 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2999 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
3000 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
3001 error (_("Error starting executable: %d"), errno
);
3004 len
= mbstowcs (NULL
, allargs
, 0) + 1;
3005 if (len
== (size_t) -1)
3006 error (_("Error starting executable: %d"), errno
);
3007 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
3008 mbstowcs (cygallargs
, allargs
, len
);
3009 #else /* !__USEWIDE */
3010 cygallargs
= allargs
;
3016 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
3017 error (_("Error starting executable via shell: %d"), errno
);
3019 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
3020 + mbstowcs (NULL
, allargs
, 0) + 2;
3021 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
3022 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
3023 #else /* !__USEWIDE */
3024 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
3025 + strlen (allargs
) + 2);
3026 cygallargs
= (char *) alloca (len
);
3027 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
3028 #endif /* __USEWIDE */
3030 flags
|= DEBUG_PROCESS
;
3033 if (inferior_cwd
!= NULL
3034 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
3035 infcwd
, strlen (inferior_cwd
)) < 0)
3036 error (_("Error converting inferior cwd: %d"), errno
);
3039 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
3040 * sizeof (wchar_t));
3041 wcscpy (args
, toexec
);
3042 wcscat (args
, L
" ");
3043 wcscat (args
, cygallargs
);
3044 #else /* !__USEWIDE */
3045 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
3046 strcpy (args
, toexec
);
3048 strcat (args
, cygallargs
);
3049 #endif /* !__USEWIDE */
3051 #ifdef CW_CVT_ENV_TO_WINENV
3052 /* First try to create a direct Win32 copy of the POSIX environment. */
3053 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
3054 if (w32_env
!= (PWCHAR
) -1)
3055 flags
|= CREATE_UNICODE_ENVIRONMENT
;
3057 /* If that fails, fall back to old method tweaking GDB's environment. */
3058 #endif /* CW_CVT_ENV_TO_WINENV */
3060 /* Reset all Win32 environment variables to avoid leftover on next run. */
3061 clear_win32_environment (environ
);
3062 /* Prepare the environment vars for CreateProcess. */
3065 cygwin_internal (CW_SYNC_WINENV
);
3069 if (!inferior_io_terminal
)
3070 tty
= ostdin
= ostdout
= ostderr
= -1;
3073 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
3076 print_sys_errmsg (inferior_io_terminal
, errno
);
3077 ostdin
= ostdout
= ostderr
= -1;
3090 windows_init_thread_list ();
3091 ret
= CreateProcess (0,
3092 args
, /* command line */
3093 NULL
, /* Security */
3095 TRUE
, /* inherit handles */
3096 flags
, /* start flags */
3097 w32_env
, /* environment */
3098 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
3103 /* Just free the Win32 environment, if it could be created. */
3107 /* Reset all environment variables to avoid leftover on next run. */
3108 clear_win32_environment (in_env
);
3109 /* Restore normal GDB environment variables. */
3111 cygwin_internal (CW_SYNC_WINENV
);
3124 #else /* !__CYGWIN__ */
3125 allargs_len
= strlen (allargs
);
3126 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
3127 if (strpbrk (allargs_copy
, "<>") != NULL
)
3132 redirect_inferior_handles (allargs
, allargs_copy
,
3133 &fd_inp
, &fd_out
, &fd_err
);
3135 warning (_("Error in redirection: %s."), safe_strerror (errno
));
3138 allargs_len
= strlen (allargs_copy
);
3140 /* If not all the standard streams are redirected by the command
3141 line, use inferior_io_terminal for those which aren't. */
3142 if (inferior_io_terminal
3143 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
3145 SECURITY_ATTRIBUTES sa
;
3146 sa
.nLength
= sizeof(sa
);
3147 sa
.lpSecurityDescriptor
= 0;
3148 sa
.bInheritHandle
= TRUE
;
3149 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
3150 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
3151 if (tty
== INVALID_HANDLE_VALUE
)
3152 warning (_("Warning: Failed to open TTY %s, error %#x."),
3153 inferior_io_terminal
, (unsigned) GetLastError ());
3155 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
3158 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
3159 else if (tty
!= INVALID_HANDLE_VALUE
)
3162 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
3164 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
3165 else if (tty
!= INVALID_HANDLE_VALUE
)
3166 si
.hStdOutput
= tty
;
3168 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
3170 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
3171 else if (tty
!= INVALID_HANDLE_VALUE
)
3174 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
3175 si
.dwFlags
|= STARTF_USESTDHANDLES
;
3179 /* Build the command line, a space-separated list of tokens where
3180 the first token is the name of the module to be executed.
3181 To avoid ambiguities introduced by spaces in the module name,
3183 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
3184 args
= (char *) alloca (args_len
);
3185 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
3187 flags
|= DEBUG_ONLY_THIS_PROCESS
;
3189 /* CreateProcess takes the environment list as a null terminated set of
3190 strings (i.e. two nulls terminate the list). */
3192 /* Get total size for env strings. */
3193 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
3194 envlen
+= strlen (in_env
[i
]) + 1;
3196 envsize
= sizeof (in_env
[0]) * (i
+ 1);
3197 env
= (char **) alloca (envsize
);
3198 memcpy (env
, in_env
, envsize
);
3199 /* Windows programs expect the environment block to be sorted. */
3200 qsort (env
, i
, sizeof (char *), envvar_cmp
);
3202 w32env
= (char *) alloca (envlen
+ 1);
3204 /* Copy env strings into new buffer. */
3205 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
3207 strcpy (temp
, env
[i
]);
3208 temp
+= strlen (temp
) + 1;
3211 /* Final nil string to terminate new env. */
3214 windows_init_thread_list ();
3215 ret
= CreateProcessA (0,
3216 args
, /* command line */
3217 NULL
, /* Security */
3219 TRUE
, /* inherit handles */
3220 flags
, /* start flags */
3221 w32env
, /* environment */
3222 inferior_cwd
, /* current directory */
3225 if (tty
!= INVALID_HANDLE_VALUE
)
3233 #endif /* !__CYGWIN__ */
3236 error (_("Error creating process %s, (error %u)."),
3237 exec_file
, (unsigned) GetLastError ());
3241 if (IsWow64Process (pi
.hProcess
, &wow64
))
3242 wow64_process
= wow64
;
3245 CloseHandle (pi
.hThread
);
3246 CloseHandle (pi
.hProcess
);
3248 if (useshell
&& shell
[0] != '\0')
3253 do_initial_windows_stuff (this, pi
.dwProcessId
, 0);
3255 /* windows_continue (DBG_CONTINUE, -1, 0); */
3259 windows_nat_target::mourn_inferior ()
3261 (void) windows_continue (DBG_CONTINUE
, -1, 0);
3262 x86_cleanup_dregs();
3263 if (open_process_used
)
3265 CHECK (CloseHandle (current_process_handle
));
3266 open_process_used
= 0;
3268 siginfo_er
.ExceptionCode
= 0;
3269 inf_child_target::mourn_inferior ();
3272 /* Send a SIGINT to the process group. This acts just like the user typed a
3273 ^C on the controlling terminal. */
3276 windows_nat_target::interrupt ()
3278 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
3279 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
3280 registers_changed (); /* refresh register state */
3283 /* Helper for windows_xfer_partial that handles memory transfers.
3284 Arguments are like target_xfer_partial. */
3286 static enum target_xfer_status
3287 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3288 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
3292 DWORD lasterror
= 0;
3294 if (writebuf
!= NULL
)
3296 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
3297 pulongest (len
), core_addr_to_string (memaddr
)));
3298 success
= WriteProcessMemory (current_process_handle
,
3299 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
3302 lasterror
= GetLastError ();
3303 FlushInstructionCache (current_process_handle
,
3304 (LPCVOID
) (uintptr_t) memaddr
, len
);
3308 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
3309 pulongest (len
), core_addr_to_string (memaddr
)));
3310 success
= ReadProcessMemory (current_process_handle
,
3311 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
3314 lasterror
= GetLastError ();
3316 *xfered_len
= (ULONGEST
) done
;
3317 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
3318 return TARGET_XFER_OK
;
3320 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
3324 windows_nat_target::kill ()
3326 CHECK (TerminateProcess (current_process_handle
, 0));
3330 if (!windows_continue (DBG_CONTINUE
, -1, 1))
3332 if (!wait_for_debug_event (¤t_event
, INFINITE
))
3334 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
3338 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
3342 windows_nat_target::close ()
3344 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
3345 inferior_ptid
.pid ()));
3348 /* Convert pid to printable format. */
3350 windows_nat_target::pid_to_str (ptid_t ptid
)
3352 if (ptid
.lwp () != 0)
3353 return string_printf ("Thread %d.0x%lx", ptid
.pid (), ptid
.lwp ());
3355 return normal_pid_to_str (ptid
);
3358 static enum target_xfer_status
3359 windows_xfer_shared_libraries (struct target_ops
*ops
,
3360 enum target_object object
, const char *annex
,
3361 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3362 ULONGEST offset
, ULONGEST len
,
3363 ULONGEST
*xfered_len
)
3365 struct obstack obstack
;
3371 return TARGET_XFER_E_IO
;
3373 obstack_init (&obstack
);
3374 obstack_grow_str (&obstack
, "<library-list>\n");
3375 for (so
= solib_start
.next
; so
; so
= so
->next
)
3377 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
3379 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
3380 (uintptr_t) li
->load_addr
,
3382 target_gdbarch (), &obstack
);
3384 obstack_grow_str0 (&obstack
, "</library-list>\n");
3386 buf
= (const char *) obstack_finish (&obstack
);
3387 len_avail
= strlen (buf
);
3388 if (offset
>= len_avail
)
3392 if (len
> len_avail
- offset
)
3393 len
= len_avail
- offset
;
3394 memcpy (readbuf
, buf
+ offset
, len
);
3397 obstack_free (&obstack
, NULL
);
3398 *xfered_len
= (ULONGEST
) len
;
3399 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
3402 /* Helper for windows_nat_target::xfer_partial that handles signal info. */
3404 static enum target_xfer_status
3405 windows_xfer_siginfo (gdb_byte
*readbuf
, ULONGEST offset
, ULONGEST len
,
3406 ULONGEST
*xfered_len
)
3408 char *buf
= (char *) &siginfo_er
;
3409 size_t bufsize
= sizeof (siginfo_er
);
3412 EXCEPTION_RECORD32 er32
;
3415 buf
= (char *) &er32
;
3416 bufsize
= sizeof (er32
);
3418 er32
.ExceptionCode
= siginfo_er
.ExceptionCode
;
3419 er32
.ExceptionFlags
= siginfo_er
.ExceptionFlags
;
3420 er32
.ExceptionRecord
= (uintptr_t) siginfo_er
.ExceptionRecord
;
3421 er32
.ExceptionAddress
= (uintptr_t) siginfo_er
.ExceptionAddress
;
3422 er32
.NumberParameters
= siginfo_er
.NumberParameters
;
3424 for (i
= 0; i
< EXCEPTION_MAXIMUM_PARAMETERS
; i
++)
3425 er32
.ExceptionInformation
[i
] = siginfo_er
.ExceptionInformation
[i
];
3429 if (siginfo_er
.ExceptionCode
== 0)
3430 return TARGET_XFER_E_IO
;
3432 if (readbuf
== nullptr)
3433 return TARGET_XFER_E_IO
;
3435 if (offset
> bufsize
)
3436 return TARGET_XFER_E_IO
;
3438 if (offset
+ len
> bufsize
)
3439 len
= bufsize
- offset
;
3441 memcpy (readbuf
, buf
+ offset
, len
);
3444 return TARGET_XFER_OK
;
3447 enum target_xfer_status
3448 windows_nat_target::xfer_partial (enum target_object object
,
3449 const char *annex
, gdb_byte
*readbuf
,
3450 const gdb_byte
*writebuf
, ULONGEST offset
,
3451 ULONGEST len
, ULONGEST
*xfered_len
)
3455 case TARGET_OBJECT_MEMORY
:
3456 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
3458 case TARGET_OBJECT_LIBRARIES
:
3459 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
3460 writebuf
, offset
, len
, xfered_len
);
3462 case TARGET_OBJECT_SIGNAL_INFO
:
3463 return windows_xfer_siginfo (readbuf
, offset
, len
, xfered_len
);
3466 if (beneath () == NULL
)
3468 /* This can happen when requesting the transfer of unsupported
3469 objects before a program has been started (and therefore
3470 with the current_target having no target beneath). */
3471 return TARGET_XFER_E_IO
;
3473 return beneath ()->xfer_partial (object
, annex
,
3474 readbuf
, writebuf
, offset
, len
,
3479 /* Provide thread local base, i.e. Thread Information Block address.
3480 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
3483 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
3485 windows_thread_info
*th
;
3487 th
= thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
);
3492 *addr
= th
->thread_local_base
;
3498 windows_nat_target::get_ada_task_ptid (long lwp
, long thread
)
3500 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
3503 /* Implementation of the to_thread_name method. */
3506 windows_nat_target::thread_name (struct thread_info
*thr
)
3508 return thread_rec (thr
->ptid
, DONT_INVALIDATE_CONTEXT
)->name
.get ();
3512 void _initialize_windows_nat ();
3514 _initialize_windows_nat ()
3516 x86_dr_low
.set_control
= cygwin_set_dr7
;
3517 x86_dr_low
.set_addr
= cygwin_set_dr
;
3518 x86_dr_low
.get_addr
= cygwin_get_dr
;
3519 x86_dr_low
.get_status
= cygwin_get_dr6
;
3520 x86_dr_low
.get_control
= cygwin_get_dr7
;
3522 /* x86_dr_low.debug_register_length field is set by
3523 calling x86_set_debug_register_length function
3524 in processor windows specific native file. */
3526 add_inf_child_target (&the_windows_nat_target
);
3529 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3532 add_com ("signal-event", class_run
, signal_event_command
, _("\
3533 Signal a crashed process with event ID, to allow its debugging.\n\
3534 This command is needed in support of setting up GDB as JIT debugger on \
3535 MS-Windows. The command should be invoked from the GDB command line using \
3536 the '-ex' command-line option. The ID of the event that blocks the \
3537 crashed process will be supplied by the Windows JIT debugging mechanism."));
3540 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3541 Set use of shell to start subprocess."), _("\
3542 Show use of shell to start subprocess."), NULL
,
3544 NULL
, /* FIXME: i18n: */
3545 &setlist
, &showlist
);
3547 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3548 &cygwin_exceptions
, _("\
3549 Break when an exception is detected in the Cygwin DLL itself."), _("\
3550 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3552 NULL
, /* FIXME: i18n: */
3553 &setlist
, &showlist
);
3556 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3557 Set creation of new console when creating child process."), _("\
3558 Show creation of new console when creating child process."), NULL
,
3560 NULL
, /* FIXME: i18n: */
3561 &setlist
, &showlist
);
3563 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3564 Set creation of new group when creating child process."), _("\
3565 Show creation of new group when creating child process."), NULL
,
3567 NULL
, /* FIXME: i18n: */
3568 &setlist
, &showlist
);
3570 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3571 Set whether to display execution in child process."), _("\
3572 Show whether to display execution in child process."), NULL
,
3574 NULL
, /* FIXME: i18n: */
3575 &setlist
, &showlist
);
3577 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3578 Set whether to display kernel events in child process."), _("\
3579 Show whether to display kernel events in child process."), NULL
,
3581 NULL
, /* FIXME: i18n: */
3582 &setlist
, &showlist
);
3584 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3585 Set whether to display memory accesses in child process."), _("\
3586 Show whether to display memory accesses in child process."), NULL
,
3588 NULL
, /* FIXME: i18n: */
3589 &setlist
, &showlist
);
3591 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3592 &debug_exceptions
, _("\
3593 Set whether to display kernel exceptions in child process."), _("\
3594 Show whether to display kernel exceptions in child process."), NULL
,
3596 NULL
, /* FIXME: i18n: */
3597 &setlist
, &showlist
);
3599 init_w32_command_list ();
3601 add_cmd ("selector", class_info
, display_selectors
,
3602 _("Display selectors infos."),
3606 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3608 /* Pass the address ADDR to the inferior in the I'th debug register.
3609 Here we just store the address in dr array, the registers will be
3610 actually set up when windows_continue is called. */
3612 cygwin_set_dr (int i
, CORE_ADDR addr
)
3615 internal_error (__FILE__
, __LINE__
,
3616 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3618 debug_registers_changed
= 1;
3619 debug_registers_used
= 1;
3622 /* Pass the value VAL to the inferior in the DR7 debug control
3623 register. Here we just store the address in D_REGS, the watchpoint
3624 will be actually set up in windows_wait. */
3626 cygwin_set_dr7 (unsigned long val
)
3628 dr
[7] = (CORE_ADDR
) val
;
3629 debug_registers_changed
= 1;
3630 debug_registers_used
= 1;
3633 /* Get the value of debug register I from the inferior. */
3636 cygwin_get_dr (int i
)
3641 /* Get the value of the DR6 debug status register from the inferior.
3642 Here we just return the value stored in dr[6]
3643 by the last call to thread_rec for current_event.dwThreadId id. */
3644 static unsigned long
3645 cygwin_get_dr6 (void)
3647 return (unsigned long) dr
[6];
3650 /* Get the value of the DR7 debug status register from the inferior.
3651 Here we just return the value stored in dr[7] by the last call to
3652 thread_rec for current_event.dwThreadId id. */
3654 static unsigned long
3655 cygwin_get_dr7 (void)
3657 return (unsigned long) dr
[7];
3660 /* Determine if the thread referenced by "ptid" is alive
3661 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3662 it means that the thread has died. Otherwise it is assumed to be alive. */
3665 windows_nat_target::thread_alive (ptid_t ptid
)
3667 gdb_assert (ptid
.lwp () != 0);
3669 return (WaitForSingleObject (thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
)->h
, 0)
3673 void _initialize_check_for_gdb_ini ();
3675 _initialize_check_for_gdb_ini ()
3678 if (inhibit_gdbinit
)
3681 homedir
= getenv ("HOME");
3685 char *oldini
= (char *) alloca (strlen (homedir
) +
3686 sizeof ("gdb.ini") + 1);
3687 strcpy (oldini
, homedir
);
3688 p
= strchr (oldini
, '\0');
3689 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3691 strcpy (p
, "gdb.ini");
3692 if (access (oldini
, 0) == 0)
3694 int len
= strlen (oldini
);
3695 char *newini
= (char *) alloca (len
+ 2);
3697 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3698 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3699 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3704 /* Define dummy functions which always return error for the rare cases where
3705 these functions could not be found. */
3707 bad_DebugActiveProcessStop (DWORD w
)
3712 bad_DebugBreakProcess (HANDLE w
)
3717 bad_DebugSetProcessKillOnExit (BOOL w
)
3722 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3729 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3735 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3742 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3748 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3754 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3760 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3768 /* Load any functions which may not be available in ancient versions
3771 void _initialize_loadable ();
3773 _initialize_loadable ()
3777 #define GPA(m, func) \
3778 func = (func ## _ftype *) GetProcAddress (m, #func)
3780 hm
= LoadLibrary ("kernel32.dll");
3783 GPA (hm
, DebugActiveProcessStop
);
3784 GPA (hm
, DebugBreakProcess
);
3785 GPA (hm
, DebugSetProcessKillOnExit
);
3786 GPA (hm
, GetConsoleFontSize
);
3787 GPA (hm
, DebugActiveProcessStop
);
3788 GPA (hm
, GetCurrentConsoleFont
);
3790 GPA (hm
, Wow64SuspendThread
);
3791 GPA (hm
, Wow64GetThreadContext
);
3792 GPA (hm
, Wow64SetThreadContext
);
3793 GPA (hm
, Wow64GetThreadSelectorEntry
);
3797 /* Set variables to dummy versions of these processes if the function
3798 wasn't found in kernel32.dll. */
3799 if (!DebugBreakProcess
)
3800 DebugBreakProcess
= bad_DebugBreakProcess
;
3801 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3803 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3804 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3806 if (!GetConsoleFontSize
)
3807 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3808 if (!GetCurrentConsoleFont
)
3809 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3811 /* Load optional functions used for retrieving filename information
3812 associated with the currently debugged process or its dlls. */
3813 hm
= LoadLibrary ("psapi.dll");
3816 GPA (hm
, EnumProcessModules
);
3818 GPA (hm
, EnumProcessModulesEx
);
3820 GPA (hm
, GetModuleInformation
);
3821 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3822 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3825 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3827 /* Set variables to dummy versions of these processes if the function
3828 wasn't found in psapi.dll. */
3829 EnumProcessModules
= bad_EnumProcessModules
;
3830 GetModuleInformation
= bad_GetModuleInformation
;
3831 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3832 /* This will probably fail on Windows 9x/Me. Let the user know
3833 that we're missing some functionality. */
3835 cannot automatically find executable file or library to read symbols.\n\
3836 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3839 hm
= LoadLibrary ("advapi32.dll");
3842 GPA (hm
, OpenProcessToken
);
3843 GPA (hm
, LookupPrivilegeValueA
);
3844 GPA (hm
, AdjustTokenPrivileges
);
3845 /* Only need to set one of these since if OpenProcessToken fails nothing
3847 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3848 || !AdjustTokenPrivileges
)
3849 OpenProcessToken
= bad_OpenProcessToken
;