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 std::vector
<windows_thread_info
*> thread_list
;
249 /* Counts of things. */
250 static int exception_count
= 0;
251 static int event_count
= 0;
252 static int saw_create
;
253 static int open_process_used
= 0;
255 static bool wow64_process
= false;
256 static bool ignore_first_breakpoint
= false;
260 static bool new_console
= false;
262 static bool cygwin_exceptions
= false;
264 static bool new_group
= true;
265 static bool debug_exec
= false; /* show execution */
266 static bool debug_events
= false; /* show events from kernel */
267 static bool debug_memory
= false; /* show target memory accesses */
268 static bool debug_exceptions
= false; /* show target exceptions */
269 static bool useshell
= false; /* use shell for subprocesses */
271 /* This vector maps GDB's idea of a register's number into an offset
272 in the windows exception context vector.
274 It also contains the bit mask needed to load the register in question.
276 The contents of this table can only be computed by the units
277 that provide CPU-specific support for Windows native debugging.
278 These units should set the table by calling
279 windows_set_context_register_offsets.
281 One day we could read a reg, we could inspect the context we
282 already have loaded, if it doesn't have the bit set that we need,
283 we read that set of registers in using GetThreadContext. If the
284 context already contains what we need, we just unpack it. Then to
285 write a register, first we have to ensure that the context contains
286 the other regs of the group, and then we copy the info in and set
289 static const int *mappings
;
291 /* The function to use in order to determine whether a register is
292 a segment register or not. */
293 static segment_register_p_ftype
*segment_register_p
;
295 /* See windows_nat_target::resume to understand why this is commented
298 /* This vector maps the target's idea of an exception (extracted
299 from the DEBUG_EVENT structure) to GDB's idea. */
301 struct xlate_exception
307 static const struct xlate_exception xlate
[] =
309 {EXCEPTION_ACCESS_VIOLATION
, GDB_SIGNAL_SEGV
},
310 {STATUS_STACK_OVERFLOW
, GDB_SIGNAL_SEGV
},
311 {EXCEPTION_BREAKPOINT
, GDB_SIGNAL_TRAP
},
312 {DBG_CONTROL_C
, GDB_SIGNAL_INT
},
313 {EXCEPTION_SINGLE_STEP
, GDB_SIGNAL_TRAP
},
314 {STATUS_FLOAT_DIVIDE_BY_ZERO
, GDB_SIGNAL_FPE
}
319 struct windows_nat_target final
: public x86_nat_target
<inf_child_target
>
321 void close () override
;
323 void attach (const char *, int) override
;
325 bool attach_no_wait () override
328 void detach (inferior
*, int) override
;
330 void resume (ptid_t
, int , enum gdb_signal
) override
;
332 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
334 void fetch_registers (struct regcache
*, int) override
;
335 void store_registers (struct regcache
*, int) override
;
337 bool stopped_by_sw_breakpoint () override
339 return current_windows_thread
->stopped_at_software_breakpoint
;
342 bool supports_stopped_by_sw_breakpoint () override
347 enum target_xfer_status
xfer_partial (enum target_object object
,
350 const gdb_byte
*writebuf
,
351 ULONGEST offset
, ULONGEST len
,
352 ULONGEST
*xfered_len
) override
;
354 void files_info () override
;
356 void kill () override
;
358 void create_inferior (const char *, const std::string
&,
359 char **, int) override
;
361 void mourn_inferior () override
;
363 bool thread_alive (ptid_t ptid
) override
;
365 std::string
pid_to_str (ptid_t
) override
;
367 void interrupt () override
;
369 char *pid_to_exec_file (int pid
) override
;
371 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
373 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
375 const char *thread_name (struct thread_info
*) override
;
377 int get_windows_debug_event (int pid
, struct target_waitstatus
*ourstatus
);
380 static windows_nat_target the_windows_nat_target
;
382 /* Set the MAPPINGS static global to OFFSETS.
383 See the description of MAPPINGS for more details. */
386 windows_set_context_register_offsets (const int *offsets
)
391 /* Set the function that should be used by this module to determine
392 whether a given register is a segment register or not. */
395 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
397 segment_register_p
= fun
;
401 check (BOOL ok
, const char *file
, int line
)
404 printf_filtered ("error return %s:%d was %u\n", file
, line
,
405 (unsigned) GetLastError ());
408 /* See nat/windows-nat.h. */
410 windows_thread_info
*
411 windows_nat::thread_rec (ptid_t ptid
, thread_disposition_type disposition
)
413 for (windows_thread_info
*th
: thread_list
)
414 if (th
->tid
== ptid
.lwp ())
420 case DONT_INVALIDATE_CONTEXT
:
423 case INVALIDATE_CONTEXT
:
424 if (ptid
.lwp () != current_event
.dwThreadId
)
426 th
->reload_context
= true;
429 th
->reload_context
= true;
440 /* Add a thread to the thread list.
442 PTID is the ptid of the thread to be added.
443 H is its Windows handle.
444 TLB is its thread local base.
445 MAIN_THREAD_P should be true if the thread to be added is
446 the main thread, false otherwise. */
448 static windows_thread_info
*
449 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
, bool main_thread_p
)
451 windows_thread_info
*th
;
453 gdb_assert (ptid
.lwp () != 0);
455 if ((th
= thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
)))
458 CORE_ADDR base
= (CORE_ADDR
) (uintptr_t) tlb
;
460 /* For WOW64 processes, this is actually the pointer to the 64bit TIB,
461 and the 32bit TIB is exactly 2 pages after it. */
465 th
= new windows_thread_info (ptid
.lwp (), h
, base
);
466 thread_list
.push_back (th
);
468 /* Add this new thread to the list of threads.
470 To be consistent with what's done on other platforms, we add
471 the main thread silently (in reality, this thread is really
472 more of a process to the user than a thread). */
474 add_thread_silent (&the_windows_nat_target
, ptid
);
476 add_thread (&the_windows_nat_target
, ptid
);
478 /* Set the debug registers for the new thread if they are used. */
479 if (debug_registers_used
)
484 /* Only change the value of the debug registers. */
485 th
->wow64_context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
486 CHECK (Wow64GetThreadContext (th
->h
, &th
->wow64_context
));
487 th
->wow64_context
.Dr0
= dr
[0];
488 th
->wow64_context
.Dr1
= dr
[1];
489 th
->wow64_context
.Dr2
= dr
[2];
490 th
->wow64_context
.Dr3
= dr
[3];
491 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
492 th
->wow64_context
.Dr7
= dr
[7];
493 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
494 th
->wow64_context
.ContextFlags
= 0;
499 /* Only change the value of the debug registers. */
500 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
501 CHECK (GetThreadContext (th
->h
, &th
->context
));
502 th
->context
.Dr0
= dr
[0];
503 th
->context
.Dr1
= dr
[1];
504 th
->context
.Dr2
= dr
[2];
505 th
->context
.Dr3
= dr
[3];
506 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
507 th
->context
.Dr7
= dr
[7];
508 CHECK (SetThreadContext (th
->h
, &th
->context
));
509 th
->context
.ContextFlags
= 0;
515 /* Clear out any old thread list and reinitialize it to a
518 windows_init_thread_list (void)
520 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
523 for (windows_thread_info
*here
: thread_list
)
526 thread_list
.clear ();
529 /* Delete a thread from the list of threads.
531 PTID is the ptid of the thread to be deleted.
532 EXIT_CODE is the thread's exit code.
533 MAIN_THREAD_P should be true if the thread to be deleted is
534 the main thread, false otherwise. */
537 windows_delete_thread (ptid_t ptid
, DWORD exit_code
, bool main_thread_p
)
541 gdb_assert (ptid
.lwp () != 0);
545 /* Emit a notification about the thread being deleted.
547 Note that no notification was printed when the main thread
548 was created, and thus, unless in verbose mode, we should be
549 symmetrical, and avoid that notification for the main thread
553 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
).c_str ());
554 else if (print_thread_events
&& !main_thread_p
)
555 printf_unfiltered (_("[%s exited with code %u]\n"),
556 target_pid_to_str (ptid
).c_str (),
557 (unsigned) exit_code
);
559 delete_thread (find_thread_ptid (&the_windows_nat_target
, ptid
));
561 auto iter
= std::find_if (thread_list
.begin (), thread_list
.end (),
562 [=] (windows_thread_info
*th
)
564 return th
->tid
== id
;
567 if (iter
!= thread_list
.end ())
570 thread_list
.erase (iter
);
574 /* Fetches register number R from the given windows_thread_info,
575 and supplies its value to the given regcache.
577 This function assumes that R is non-negative. A failed assertion
578 is raised if that is not true.
580 This function assumes that TH->RELOAD_CONTEXT is not set, meaning
581 that the windows_thread_info has an up-to-date context. A failed
582 assertion is raised if that assumption is violated. */
585 windows_fetch_one_register (struct regcache
*regcache
,
586 windows_thread_info
*th
, int r
)
589 gdb_assert (!th
->reload_context
);
591 char *context_ptr
= (char *) &th
->context
;
594 context_ptr
= (char *) &th
->wow64_context
;
597 char *context_offset
= context_ptr
+ mappings
[r
];
598 struct gdbarch
*gdbarch
= regcache
->arch ();
599 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
601 gdb_assert (!gdbarch_read_pc_p (gdbarch
));
602 gdb_assert (gdbarch_pc_regnum (gdbarch
) >= 0);
603 gdb_assert (!gdbarch_write_pc_p (gdbarch
));
605 if (r
== I387_FISEG_REGNUM (tdep
))
607 long l
= *((long *) context_offset
) & 0xffff;
608 regcache
->raw_supply (r
, (char *) &l
);
610 else if (r
== I387_FOP_REGNUM (tdep
))
612 long l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
613 regcache
->raw_supply (r
, (char *) &l
);
615 else if (segment_register_p (r
))
617 /* GDB treats segment registers as 32bit registers, but they are
618 in fact only 16 bits long. Make sure we do not read extra
619 bits from our source buffer. */
620 long l
= *((long *) context_offset
) & 0xffff;
621 regcache
->raw_supply (r
, (char *) &l
);
625 if (th
->stopped_at_software_breakpoint
626 && r
== gdbarch_pc_regnum (gdbarch
))
628 int size
= register_size (gdbarch
, r
);
632 memcpy (&value
, context_offset
, size
);
633 value
-= gdbarch_decr_pc_after_break (gdbarch
);
634 memcpy (context_offset
, &value
, size
);
638 gdb_assert (size
== 8);
640 memcpy (&value
, context_offset
, size
);
641 value
-= gdbarch_decr_pc_after_break (gdbarch
);
642 memcpy (context_offset
, &value
, size
);
645 regcache
->raw_supply (r
, context_offset
);
650 windows_nat_target::fetch_registers (struct regcache
*regcache
, int r
)
652 windows_thread_info
*th
= thread_rec (regcache
->ptid (), INVALIDATE_CONTEXT
);
654 /* Check if TH exists. Windows sometimes uses a non-existent
655 thread id in its events. */
659 if (th
->reload_context
)
662 if (have_saved_context
)
664 /* Lie about where the program actually is stopped since
665 cygwin has informed us that we should consider the signal
666 to have occurred at another location which is stored in
668 memcpy (&th
->context
, &saved_context
,
669 __COPY_CONTEXT_SIZE
);
670 have_saved_context
= 0;
677 th
->wow64_context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
678 CHECK (Wow64GetThreadContext (th
->h
, &th
->wow64_context
));
679 /* Copy dr values from that thread.
680 But only if there were not modified since last stop.
682 if (!debug_registers_changed
)
684 dr
[0] = th
->wow64_context
.Dr0
;
685 dr
[1] = th
->wow64_context
.Dr1
;
686 dr
[2] = th
->wow64_context
.Dr2
;
687 dr
[3] = th
->wow64_context
.Dr3
;
688 dr
[6] = th
->wow64_context
.Dr6
;
689 dr
[7] = th
->wow64_context
.Dr7
;
695 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
696 CHECK (GetThreadContext (th
->h
, &th
->context
));
697 /* Copy dr values from that thread.
698 But only if there were not modified since last stop.
700 if (!debug_registers_changed
)
702 dr
[0] = th
->context
.Dr0
;
703 dr
[1] = th
->context
.Dr1
;
704 dr
[2] = th
->context
.Dr2
;
705 dr
[3] = th
->context
.Dr3
;
706 dr
[6] = th
->context
.Dr6
;
707 dr
[7] = th
->context
.Dr7
;
710 th
->reload_context
= false;
714 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch()); r
++)
715 windows_fetch_one_register (regcache
, th
, r
);
717 windows_fetch_one_register (regcache
, th
, r
);
720 /* Collect the register number R from the given regcache, and store
721 its value into the corresponding area of the given thread's context.
723 This function assumes that R is non-negative. A failed assertion
724 assertion is raised if that is not true. */
727 windows_store_one_register (const struct regcache
*regcache
,
728 windows_thread_info
*th
, int r
)
732 char *context_ptr
= (char *) &th
->context
;
735 context_ptr
= (char *) &th
->wow64_context
;
738 regcache
->raw_collect (r
, context_ptr
+ mappings
[r
]);
741 /* Store a new register value into the context of the thread tied to
745 windows_nat_target::store_registers (struct regcache
*regcache
, int r
)
747 windows_thread_info
*th
= thread_rec (regcache
->ptid (), INVALIDATE_CONTEXT
);
749 /* Check if TH exists. Windows sometimes uses a non-existent
750 thread id in its events. */
755 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch ()); r
++)
756 windows_store_one_register (regcache
, th
, r
);
758 windows_store_one_register (regcache
, th
, r
);
761 /* Maintain a linked list of "so" information. */
762 struct lm_info_windows
: public lm_info_base
764 LPVOID load_addr
= 0;
765 CORE_ADDR text_offset
= 0;
768 static struct so_list solib_start
, *solib_end
;
770 static struct so_list
*
771 windows_make_so (const char *name
, LPVOID load_addr
)
778 WIN32_FIND_DATA w32_fd
;
779 HANDLE h
= FindFirstFile(name
, &w32_fd
);
781 if (h
== INVALID_HANDLE_VALUE
)
787 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
789 p
= strrchr (buf
, '\\');
792 SetCurrentDirectory (buf
);
793 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
794 SetCurrentDirectory (cwd
);
797 if (strcasecmp (buf
, "ntdll.dll") == 0)
799 GetSystemDirectory (buf
, sizeof (buf
));
800 strcat (buf
, "\\ntdll.dll");
803 cygwin_buf_t buf
[__PMAX
];
806 if (access (name
, F_OK
) != 0)
808 if (strcasecmp (name
, "ntdll.dll") == 0)
811 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
812 wcscat (buf
, L
"\\ntdll.dll");
816 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
817 strcat (buf
, "\\ntdll.dll");
822 so
= XCNEW (struct so_list
);
823 lm_info_windows
*li
= new lm_info_windows
;
825 li
->load_addr
= load_addr
;
826 strcpy (so
->so_original_name
, name
);
828 strcpy (so
->so_name
, buf
);
831 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
832 SO_NAME_MAX_PATH_SIZE
);
835 char *rname
= realpath (name
, NULL
);
836 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
838 strcpy (so
->so_name
, rname
);
842 error (_("dll path too long"));
844 /* Record cygwin1.dll .text start/end. */
845 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
846 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
848 asection
*text
= NULL
;
850 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386", -1));
855 if (bfd_check_format (abfd
.get (), bfd_object
))
856 text
= bfd_get_section_by_name (abfd
.get (), ".text");
861 /* The symbols in a dll are offset by 0x1000, which is the
862 offset from 0 of the first byte in an image - because of the
863 file header and the section alignment. */
864 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
866 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (text
);
873 /* Handle a DLL load event, and return 1.
875 This function assumes that this event did not occur during inferior
876 initialization, where their event info may be incomplete (see
877 do_initial_windows_stuff and windows_add_all_dlls for more info
878 on how we handle DLL loading during that phase). */
883 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
884 const char *dll_name
;
886 /* Try getting the DLL name via the lpImageName field of the event.
887 Note that Microsoft documents this fields as strictly optional,
888 in the sense that it might be NULL. And the first DLL event in
889 particular is explicitly documented as "likely not pass[ed]"
890 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
891 dll_name
= get_image_name (current_process_handle
,
892 event
->lpImageName
, event
->fUnicode
);
896 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
897 solib_end
= solib_end
->next
;
899 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
901 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
902 host_address_to_string (li
->load_addr
)));
906 windows_free_so (struct so_list
*so
)
908 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
914 /* Handle a DLL unload event.
915 Return 1 if successful, or zero otherwise.
917 This function assumes that this event did not occur during inferior
918 initialization, where their event info may be incomplete (see
919 do_initial_windows_stuff and windows_add_all_dlls for more info
920 on how we handle DLL loading during that phase). */
925 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
928 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
930 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
932 if (li_next
->load_addr
== lpBaseOfDll
)
934 struct so_list
*sodel
= so
->next
;
936 so
->next
= sodel
->next
;
939 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
941 windows_free_so (sodel
);
946 /* We did not find any DLL that was previously loaded at this address,
947 so register a complaint. We do not report an error, because we have
948 observed that this may be happening under some circumstances. For
949 instance, running 32bit applications on x64 Windows causes us to receive
950 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
951 events are apparently caused by the WOW layer, the interface between
952 32bit and 64bit worlds). */
953 complaint (_("dll starting at %s not found."),
954 host_address_to_string (lpBaseOfDll
));
957 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
961 catch_errors (void (*func
) ())
967 catch (const gdb_exception
&ex
)
969 exception_print (gdb_stderr
, ex
);
973 /* Clear list of loaded DLLs. */
975 windows_clear_solib (void)
979 for (so
= solib_start
.next
; so
; so
= solib_start
.next
)
981 solib_start
.next
= so
->next
;
982 windows_free_so (so
);
985 solib_end
= &solib_start
;
989 signal_event_command (const char *args
, int from_tty
)
991 uintptr_t event_id
= 0;
992 char *endargs
= NULL
;
995 error (_("signal-event requires an argument (integer event id)"));
997 event_id
= strtoumax (args
, &endargs
, 10);
999 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
1000 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
1001 error (_("Failed to convert `%s' to event id"), args
);
1003 SetEvent ((HANDLE
) event_id
);
1004 CloseHandle ((HANDLE
) event_id
);
1007 /* Handle DEBUG_STRING output from child process.
1008 Cygwin prepends its messages with a "cygwin:". Interpret this as
1009 a Cygwin signal. Otherwise just print the string as a warning. */
1011 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
1013 gdb::unique_xmalloc_ptr
<char> s
;
1016 if (!target_read_string
1017 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
1019 || !s
|| !*(s
.get ()))
1020 /* nothing to do */;
1021 else if (!startswith (s
.get (), _CYGWIN_SIGNAL_STRING
))
1024 if (!startswith (s
.get (), "cYg"))
1027 char *p
= strchr (s
.get (), '\0');
1029 if (p
> s
.get () && *--p
== '\n')
1031 warning (("%s"), s
.get ());
1037 /* Got a cygwin signal marker. A cygwin signal is followed by
1038 the signal number itself and then optionally followed by the
1039 thread id and address to saved context within the DLL. If
1040 these are supplied, then the given thread is assumed to have
1041 issued the signal and the context from the thread is assumed
1042 to be stored at the given address in the inferior. Tell gdb
1043 to treat this like a real signal. */
1045 int sig
= strtol (s
.get () + sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
1046 gdb_signal gotasig
= gdb_signal_from_host (sig
);
1048 ourstatus
->value
.sig
= gotasig
;
1054 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1055 retval
= strtoul (p
, &p
, 0);
1057 retval
= current_event
.dwThreadId
;
1058 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
1059 && ReadProcessMemory (current_process_handle
, x
,
1061 __COPY_CONTEXT_SIZE
, &n
)
1062 && n
== __COPY_CONTEXT_SIZE
)
1063 have_saved_context
= 1;
1072 display_selector (HANDLE thread
, DWORD sel
)
1078 ret
= Wow64GetThreadSelectorEntry (thread
, sel
, &info
);
1081 ret
= GetThreadSelectorEntry (thread
, sel
, &info
);
1085 printf_filtered ("0x%03x: ", (unsigned) sel
);
1086 if (!info
.HighWord
.Bits
.Pres
)
1088 puts_filtered ("Segment not present\n");
1091 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1092 (info
.HighWord
.Bits
.BaseMid
<< 16)
1094 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1095 if (info
.HighWord
.Bits
.Granularity
)
1096 limit
= (limit
<< 12) | 0xfff;
1097 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1098 if (info
.HighWord
.Bits
.Default_Big
)
1099 puts_filtered(" 32-bit ");
1101 puts_filtered(" 16-bit ");
1102 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1105 puts_filtered ("Data (Read-Only, Exp-up");
1108 puts_filtered ("Data (Read/Write, Exp-up");
1111 puts_filtered ("Unused segment (");
1114 puts_filtered ("Data (Read/Write, Exp-down");
1117 puts_filtered ("Code (Exec-Only, N.Conf");
1120 puts_filtered ("Code (Exec/Read, N.Conf");
1123 puts_filtered ("Code (Exec-Only, Conf");
1126 puts_filtered ("Code (Exec/Read, Conf");
1129 printf_filtered ("Unknown type 0x%lx",
1130 (unsigned long) info
.HighWord
.Bits
.Type
);
1132 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1133 puts_filtered(", N.Acc");
1134 puts_filtered (")\n");
1135 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1136 puts_filtered("System selector ");
1137 printf_filtered ("Priviledge level = %ld. ",
1138 (unsigned long) info
.HighWord
.Bits
.Dpl
);
1139 if (info
.HighWord
.Bits
.Granularity
)
1140 puts_filtered ("Page granular.\n");
1142 puts_filtered ("Byte granular.\n");
1147 DWORD err
= GetLastError ();
1148 if (err
== ERROR_NOT_SUPPORTED
)
1149 printf_filtered ("Function not supported\n");
1151 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1157 display_selectors (const char * args
, int from_tty
)
1159 if (!current_windows_thread
)
1161 puts_filtered ("Impossible to display selectors now.\n");
1169 puts_filtered ("Selector $cs\n");
1170 display_selector (current_windows_thread
->h
,
1171 current_windows_thread
->wow64_context
.SegCs
);
1172 puts_filtered ("Selector $ds\n");
1173 display_selector (current_windows_thread
->h
,
1174 current_windows_thread
->wow64_context
.SegDs
);
1175 puts_filtered ("Selector $es\n");
1176 display_selector (current_windows_thread
->h
,
1177 current_windows_thread
->wow64_context
.SegEs
);
1178 puts_filtered ("Selector $ss\n");
1179 display_selector (current_windows_thread
->h
,
1180 current_windows_thread
->wow64_context
.SegSs
);
1181 puts_filtered ("Selector $fs\n");
1182 display_selector (current_windows_thread
->h
,
1183 current_windows_thread
->wow64_context
.SegFs
);
1184 puts_filtered ("Selector $gs\n");
1185 display_selector (current_windows_thread
->h
,
1186 current_windows_thread
->wow64_context
.SegGs
);
1191 puts_filtered ("Selector $cs\n");
1192 display_selector (current_windows_thread
->h
,
1193 current_windows_thread
->context
.SegCs
);
1194 puts_filtered ("Selector $ds\n");
1195 display_selector (current_windows_thread
->h
,
1196 current_windows_thread
->context
.SegDs
);
1197 puts_filtered ("Selector $es\n");
1198 display_selector (current_windows_thread
->h
,
1199 current_windows_thread
->context
.SegEs
);
1200 puts_filtered ("Selector $ss\n");
1201 display_selector (current_windows_thread
->h
,
1202 current_windows_thread
->context
.SegSs
);
1203 puts_filtered ("Selector $fs\n");
1204 display_selector (current_windows_thread
->h
,
1205 current_windows_thread
->context
.SegFs
);
1206 puts_filtered ("Selector $gs\n");
1207 display_selector (current_windows_thread
->h
,
1208 current_windows_thread
->context
.SegGs
);
1214 sel
= parse_and_eval_long (args
);
1215 printf_filtered ("Selector \"%s\"\n",args
);
1216 display_selector (current_windows_thread
->h
, sel
);
1220 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1221 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1222 host_address_to_string (\
1223 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1225 static handle_exception_result
1226 handle_exception (struct target_waitstatus
*ourstatus
)
1228 EXCEPTION_RECORD
*rec
= ¤t_event
.u
.Exception
.ExceptionRecord
;
1229 DWORD code
= rec
->ExceptionCode
;
1230 handle_exception_result result
= HANDLE_EXCEPTION_HANDLED
;
1232 memcpy (&siginfo_er
, rec
, sizeof siginfo_er
);
1234 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1236 /* Record the context of the current thread. */
1237 thread_rec (ptid_t (current_event
.dwProcessId
, current_event
.dwThreadId
, 0),
1242 case EXCEPTION_ACCESS_VIOLATION
:
1243 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1244 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1247 /* See if the access violation happened within the cygwin DLL
1248 itself. Cygwin uses a kind of exception handling to deal
1249 with passed-in invalid addresses. gdb should not treat
1250 these as real SEGVs since they will be silently handled by
1251 cygwin. A real SEGV will (theoretically) be caught by
1252 cygwin later in the process and will be sent as a
1253 cygwin-specific-signal. So, ignore SEGVs if they show up
1254 within the text segment of the DLL itself. */
1256 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1258 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1259 && addr
< cygwin_load_end
))
1260 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1261 && startswith (fn
, "KERNEL32!IsBad")))
1262 return HANDLE_EXCEPTION_UNHANDLED
;
1266 case STATUS_STACK_OVERFLOW
:
1267 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1268 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1270 case STATUS_FLOAT_DENORMAL_OPERAND
:
1271 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1272 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1274 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1275 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1276 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1278 case STATUS_FLOAT_INEXACT_RESULT
:
1279 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1280 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1282 case STATUS_FLOAT_INVALID_OPERATION
:
1283 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1284 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1286 case STATUS_FLOAT_OVERFLOW
:
1287 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1288 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1290 case STATUS_FLOAT_STACK_CHECK
:
1291 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1292 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1294 case STATUS_FLOAT_UNDERFLOW
:
1295 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1296 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1298 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1299 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1300 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1302 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1303 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1304 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1306 case STATUS_INTEGER_OVERFLOW
:
1307 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1308 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1310 case EXCEPTION_BREAKPOINT
:
1312 if (ignore_first_breakpoint
)
1314 /* For WOW64 processes, there are always 2 breakpoint exceptions
1315 on startup, first a BREAKPOINT for the 64bit ntdll.dll,
1316 then a WX86_BREAKPOINT for the 32bit ntdll.dll.
1317 Here we only care about the WX86_BREAKPOINT's. */
1318 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1319 ignore_first_breakpoint
= false;
1323 case STATUS_WX86_BREAKPOINT
:
1324 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1325 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1328 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1329 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1331 case DBG_CONTROL_BREAK
:
1332 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1333 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1335 case EXCEPTION_SINGLE_STEP
:
1336 case STATUS_WX86_SINGLE_STEP
:
1337 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1338 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1340 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1341 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1342 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1344 case EXCEPTION_PRIV_INSTRUCTION
:
1345 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1346 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1348 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1349 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1350 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1352 case MS_VC_EXCEPTION
:
1353 if (rec
->NumberParameters
>= 3
1354 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1356 DWORD named_thread_id
;
1357 windows_thread_info
*named_thread
;
1358 CORE_ADDR thread_name_target
;
1360 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1362 thread_name_target
= rec
->ExceptionInformation
[1];
1363 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1365 if (named_thread_id
== (DWORD
) -1)
1366 named_thread_id
= current_event
.dwThreadId
;
1368 named_thread
= thread_rec (ptid_t (current_event
.dwProcessId
,
1369 named_thread_id
, 0),
1370 DONT_INVALIDATE_CONTEXT
);
1371 if (named_thread
!= NULL
)
1373 int thread_name_len
;
1374 gdb::unique_xmalloc_ptr
<char> thread_name
;
1376 thread_name_len
= target_read_string (thread_name_target
,
1377 &thread_name
, 1025, NULL
);
1378 if (thread_name_len
> 0)
1380 thread_name
.get ()[thread_name_len
- 1] = '\0';
1381 named_thread
->name
= std::move (thread_name
);
1384 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1385 result
= HANDLE_EXCEPTION_IGNORED
;
1388 /* treat improperly formed exception as unknown */
1391 /* Treat unhandled first chance exceptions specially. */
1392 if (current_event
.u
.Exception
.dwFirstChance
)
1393 return HANDLE_EXCEPTION_UNHANDLED
;
1394 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1395 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1396 host_address_to_string (
1397 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1398 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1402 last_sig
= ourstatus
->value
.sig
;
1406 /* Resume thread specified by ID, or all artificially suspended
1407 threads, if we are continuing execution. KILLED non-zero means we
1408 have killed the inferior, so we should ignore weird errors due to
1409 threads shutting down. */
1411 windows_continue (DWORD continue_status
, int id
, int killed
)
1415 desired_stop_thread_id
= id
;
1417 /* If there are pending stops, and we might plausibly hit one of
1418 them, we don't want to actually continue the inferior -- we just
1419 want to report the stop. In this case, we just pretend to
1420 continue. See the comment by the definition of "pending_stops"
1421 for details on why this is needed. */
1422 for (const auto &item
: pending_stops
)
1424 if (desired_stop_thread_id
== -1
1425 || desired_stop_thread_id
== item
.thread_id
)
1427 DEBUG_EVENTS (("windows_continue - pending stop anticipated, "
1428 "desired=0x%x, item=0x%x\n",
1429 desired_stop_thread_id
, item
.thread_id
));
1434 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1435 (unsigned) last_wait_event
.dwProcessId
,
1436 (unsigned) last_wait_event
.dwThreadId
,
1437 continue_status
== DBG_CONTINUE
?
1438 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1440 for (windows_thread_info
*th
: thread_list
)
1441 if (id
== -1 || id
== (int) th
->tid
)
1448 if (debug_registers_changed
)
1450 th
->wow64_context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1451 th
->wow64_context
.Dr0
= dr
[0];
1452 th
->wow64_context
.Dr1
= dr
[1];
1453 th
->wow64_context
.Dr2
= dr
[2];
1454 th
->wow64_context
.Dr3
= dr
[3];
1455 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1456 th
->wow64_context
.Dr7
= dr
[7];
1458 if (th
->wow64_context
.ContextFlags
)
1462 if (GetExitCodeThread (th
->h
, &ec
)
1463 && ec
== STILL_ACTIVE
)
1465 BOOL status
= Wow64SetThreadContext (th
->h
,
1466 &th
->wow64_context
);
1471 th
->wow64_context
.ContextFlags
= 0;
1477 if (debug_registers_changed
)
1479 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1480 th
->context
.Dr0
= dr
[0];
1481 th
->context
.Dr1
= dr
[1];
1482 th
->context
.Dr2
= dr
[2];
1483 th
->context
.Dr3
= dr
[3];
1484 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1485 th
->context
.Dr7
= dr
[7];
1487 if (th
->context
.ContextFlags
)
1491 if (GetExitCodeThread (th
->h
, &ec
)
1492 && ec
== STILL_ACTIVE
)
1494 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1499 th
->context
.ContextFlags
= 0;
1506 /* When single-stepping a specific thread, other threads must
1511 res
= ContinueDebugEvent (last_wait_event
.dwProcessId
,
1512 last_wait_event
.dwThreadId
,
1516 error (_("Failed to resume program execution"
1517 " (ContinueDebugEvent failed, error %u)"),
1518 (unsigned int) GetLastError ());
1520 debug_registers_changed
= 0;
1524 /* Called in pathological case where Windows fails to send a
1525 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1527 fake_create_process (void)
1529 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1530 current_event
.dwProcessId
);
1531 if (current_process_handle
!= NULL
)
1532 open_process_used
= 1;
1535 error (_("OpenProcess call failed, GetLastError = %u"),
1536 (unsigned) GetLastError ());
1537 /* We can not debug anything in that case. */
1539 current_windows_thread
1540 = windows_add_thread (ptid_t (current_event
.dwProcessId
,
1541 current_event
.dwThreadId
, 0),
1542 current_event
.u
.CreateThread
.hThread
,
1543 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1544 true /* main_thread_p */);
1545 return current_event
.dwThreadId
;
1549 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1551 windows_thread_info
*th
;
1552 DWORD continue_status
= DBG_CONTINUE
;
1554 /* A specific PTID means `step only this thread id'. */
1555 int resume_all
= ptid
== minus_one_ptid
;
1557 /* If we're continuing all threads, it's the current inferior that
1558 should be handled specially. */
1560 ptid
= inferior_ptid
;
1562 if (sig
!= GDB_SIGNAL_0
)
1564 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1566 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1568 else if (sig
== last_sig
)
1569 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1572 /* This code does not seem to work, because
1573 the kernel does probably not consider changes in the ExceptionRecord
1574 structure when passing the exception to the inferior.
1575 Note that this seems possible in the exception handler itself. */
1577 for (const xlate_exception
&x
: xlate
)
1580 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1582 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1585 if (continue_status
== DBG_CONTINUE
)
1587 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1591 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1595 last_sig
= GDB_SIGNAL_0
;
1597 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=0x%x, step=%d, sig=%d);\n",
1598 ptid
.pid (), (unsigned) ptid
.lwp (), step
, sig
));
1600 /* Get context for currently selected thread. */
1601 th
= thread_rec (inferior_ptid
, DONT_INVALIDATE_CONTEXT
);
1609 /* Single step by setting t bit. */
1610 struct regcache
*regcache
= get_current_regcache ();
1611 struct gdbarch
*gdbarch
= regcache
->arch ();
1612 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1613 th
->wow64_context
.EFlags
|= FLAG_TRACE_BIT
;
1616 if (th
->wow64_context
.ContextFlags
)
1618 if (debug_registers_changed
)
1620 th
->wow64_context
.Dr0
= dr
[0];
1621 th
->wow64_context
.Dr1
= dr
[1];
1622 th
->wow64_context
.Dr2
= dr
[2];
1623 th
->wow64_context
.Dr3
= dr
[3];
1624 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1625 th
->wow64_context
.Dr7
= dr
[7];
1627 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
1628 th
->wow64_context
.ContextFlags
= 0;
1636 /* Single step by setting t bit. */
1637 struct regcache
*regcache
= get_current_regcache ();
1638 struct gdbarch
*gdbarch
= regcache
->arch ();
1639 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1640 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1643 if (th
->context
.ContextFlags
)
1645 if (debug_registers_changed
)
1647 th
->context
.Dr0
= dr
[0];
1648 th
->context
.Dr1
= dr
[1];
1649 th
->context
.Dr2
= dr
[2];
1650 th
->context
.Dr3
= dr
[3];
1651 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1652 th
->context
.Dr7
= dr
[7];
1654 CHECK (SetThreadContext (th
->h
, &th
->context
));
1655 th
->context
.ContextFlags
= 0;
1660 /* Allow continuing with the same signal that interrupted us.
1661 Otherwise complain. */
1664 windows_continue (continue_status
, -1, 0);
1666 windows_continue (continue_status
, ptid
.lwp (), 0);
1669 /* Ctrl-C handler used when the inferior is not run in the same console. The
1670 handler is in charge of interrupting the inferior using DebugBreakProcess.
1671 Note that this function is not available prior to Windows XP. In this case
1672 we emit a warning. */
1674 ctrl_c_handler (DWORD event_type
)
1676 const int attach_flag
= current_inferior ()->attach_flag
;
1678 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1679 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1682 /* If the inferior and the debugger share the same console, do nothing as
1683 the inferior has also received the Ctrl-C event. */
1684 if (!new_console
&& !attach_flag
)
1687 if (!DebugBreakProcess (current_process_handle
))
1688 warning (_("Could not interrupt program. "
1689 "Press Ctrl-c in the program console."));
1691 /* Return true to tell that Ctrl-C has been handled. */
1695 /* A wrapper for WaitForDebugEvent that sets "last_wait_event"
1698 wait_for_debug_event (DEBUG_EVENT
*event
, DWORD timeout
)
1700 BOOL result
= WaitForDebugEvent (event
, timeout
);
1702 last_wait_event
= *event
;
1706 /* Get the next event from the child. Returns a non-zero thread id if the event
1707 requires handling by WFI (or whatever). */
1710 windows_nat_target::get_windows_debug_event (int pid
,
1711 struct target_waitstatus
*ourstatus
)
1714 DWORD continue_status
, event_code
;
1715 windows_thread_info
*th
;
1716 static windows_thread_info
dummy_thread_info (0, 0, 0);
1717 DWORD thread_id
= 0;
1719 /* If there is a relevant pending stop, report it now. See the
1720 comment by the definition of "pending_stops" for details on why
1722 for (auto iter
= pending_stops
.begin ();
1723 iter
!= pending_stops
.end ();
1726 if (desired_stop_thread_id
== -1
1727 || desired_stop_thread_id
== iter
->thread_id
)
1729 thread_id
= iter
->thread_id
;
1730 *ourstatus
= iter
->status
;
1731 current_event
= iter
->event
;
1733 inferior_ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1734 current_windows_thread
= thread_rec (inferior_ptid
,
1735 INVALIDATE_CONTEXT
);
1736 current_windows_thread
->reload_context
= 1;
1738 DEBUG_EVENTS (("get_windows_debug_event - "
1739 "pending stop found in 0x%x (desired=0x%x)\n",
1740 thread_id
, desired_stop_thread_id
));
1742 pending_stops
.erase (iter
);
1747 last_sig
= GDB_SIGNAL_0
;
1749 if (!(debug_event
= wait_for_debug_event (¤t_event
, 1000)))
1753 continue_status
= DBG_CONTINUE
;
1755 event_code
= current_event
.dwDebugEventCode
;
1756 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1758 have_saved_context
= 0;
1762 case CREATE_THREAD_DEBUG_EVENT
:
1763 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1764 (unsigned) current_event
.dwProcessId
,
1765 (unsigned) current_event
.dwThreadId
,
1766 "CREATE_THREAD_DEBUG_EVENT"));
1767 if (saw_create
!= 1)
1769 inferior
*inf
= find_inferior_pid (this, current_event
.dwProcessId
);
1770 if (!saw_create
&& inf
->attach_flag
)
1772 /* Kludge around a Windows bug where first event is a create
1773 thread event. Caused when attached process does not have
1775 thread_id
= fake_create_process ();
1781 /* Record the existence of this thread. */
1782 thread_id
= current_event
.dwThreadId
;
1783 th
= windows_add_thread
1784 (ptid_t (current_event
.dwProcessId
, current_event
.dwThreadId
, 0),
1785 current_event
.u
.CreateThread
.hThread
,
1786 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1787 false /* main_thread_p */);
1791 case EXIT_THREAD_DEBUG_EVENT
:
1792 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1793 (unsigned) current_event
.dwProcessId
,
1794 (unsigned) current_event
.dwThreadId
,
1795 "EXIT_THREAD_DEBUG_EVENT"));
1796 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1797 current_event
.dwThreadId
, 0),
1798 current_event
.u
.ExitThread
.dwExitCode
,
1799 false /* main_thread_p */);
1800 th
= &dummy_thread_info
;
1803 case CREATE_PROCESS_DEBUG_EVENT
:
1804 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1805 (unsigned) current_event
.dwProcessId
,
1806 (unsigned) current_event
.dwThreadId
,
1807 "CREATE_PROCESS_DEBUG_EVENT"));
1808 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1809 if (++saw_create
!= 1)
1812 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1813 /* Add the main thread. */
1814 th
= windows_add_thread
1815 (ptid_t (current_event
.dwProcessId
,
1816 current_event
.dwThreadId
, 0),
1817 current_event
.u
.CreateProcessInfo
.hThread
,
1818 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
,
1819 true /* main_thread_p */);
1820 thread_id
= current_event
.dwThreadId
;
1823 case EXIT_PROCESS_DEBUG_EVENT
:
1824 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1825 (unsigned) current_event
.dwProcessId
,
1826 (unsigned) current_event
.dwThreadId
,
1827 "EXIT_PROCESS_DEBUG_EVENT"));
1828 if (!windows_initialization_done
)
1830 target_terminal::ours ();
1831 target_mourn_inferior (inferior_ptid
);
1832 error (_("During startup program exited with code 0x%x."),
1833 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1835 else if (saw_create
== 1)
1837 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1838 current_event
.dwThreadId
, 0),
1839 0, true /* main_thread_p */);
1840 DWORD exit_status
= current_event
.u
.ExitProcess
.dwExitCode
;
1841 /* If the exit status looks like a fatal exception, but we
1842 don't recognize the exception's code, make the original
1843 exit status value available, to avoid losing
1846 = WIFSIGNALED (exit_status
) ? WTERMSIG (exit_status
) : -1;
1847 if (exit_signal
== -1)
1849 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1850 ourstatus
->value
.integer
= exit_status
;
1854 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1855 ourstatus
->value
.sig
= gdb_signal_from_host (exit_signal
);
1857 thread_id
= current_event
.dwThreadId
;
1861 case LOAD_DLL_DEBUG_EVENT
:
1862 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1863 (unsigned) current_event
.dwProcessId
,
1864 (unsigned) current_event
.dwThreadId
,
1865 "LOAD_DLL_DEBUG_EVENT"));
1866 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1867 if (saw_create
!= 1 || ! windows_initialization_done
)
1869 catch_errors (handle_load_dll
);
1870 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1871 ourstatus
->value
.integer
= 0;
1872 thread_id
= current_event
.dwThreadId
;
1875 case UNLOAD_DLL_DEBUG_EVENT
:
1876 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1877 (unsigned) current_event
.dwProcessId
,
1878 (unsigned) current_event
.dwThreadId
,
1879 "UNLOAD_DLL_DEBUG_EVENT"));
1880 if (saw_create
!= 1 || ! windows_initialization_done
)
1882 catch_errors (handle_unload_dll
);
1883 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1884 ourstatus
->value
.integer
= 0;
1885 thread_id
= current_event
.dwThreadId
;
1888 case EXCEPTION_DEBUG_EVENT
:
1889 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1890 (unsigned) current_event
.dwProcessId
,
1891 (unsigned) current_event
.dwThreadId
,
1892 "EXCEPTION_DEBUG_EVENT"));
1893 if (saw_create
!= 1)
1895 switch (handle_exception (ourstatus
))
1897 case HANDLE_EXCEPTION_UNHANDLED
:
1899 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1901 case HANDLE_EXCEPTION_HANDLED
:
1902 thread_id
= current_event
.dwThreadId
;
1904 case HANDLE_EXCEPTION_IGNORED
:
1905 continue_status
= DBG_CONTINUE
;
1910 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1911 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1912 (unsigned) current_event
.dwProcessId
,
1913 (unsigned) current_event
.dwThreadId
,
1914 "OUTPUT_DEBUG_STRING_EVENT"));
1915 if (saw_create
!= 1)
1917 thread_id
= handle_output_debug_string (ourstatus
);
1921 if (saw_create
!= 1)
1923 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1924 (unsigned) current_event
.dwProcessId
,
1925 (unsigned) current_event
.dwThreadId
);
1926 printf_unfiltered (" unknown event code %u\n",
1927 (unsigned) current_event
.dwDebugEventCode
);
1931 if (!thread_id
|| saw_create
!= 1)
1933 CHECK (windows_continue (continue_status
, desired_stop_thread_id
, 0));
1935 else if (desired_stop_thread_id
!= -1 && desired_stop_thread_id
!= thread_id
)
1937 /* Pending stop. See the comment by the definition of
1938 "pending_stops" for details on why this is needed. */
1939 DEBUG_EVENTS (("get_windows_debug_event - "
1940 "unexpected stop in 0x%x (expecting 0x%x)\n",
1941 thread_id
, desired_stop_thread_id
));
1943 if (current_event
.dwDebugEventCode
== EXCEPTION_DEBUG_EVENT
1944 && (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1945 == EXCEPTION_BREAKPOINT
)
1946 && windows_initialization_done
)
1948 ptid_t ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1949 th
= thread_rec (ptid
, INVALIDATE_CONTEXT
);
1950 th
->stopped_at_software_breakpoint
= true;
1952 pending_stops
.push_back ({thread_id
, *ourstatus
, current_event
});
1954 CHECK (windows_continue (continue_status
, desired_stop_thread_id
, 0));
1958 inferior_ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1959 current_windows_thread
= th
;
1960 if (!current_windows_thread
)
1961 current_windows_thread
= thread_rec (inferior_ptid
,
1962 INVALIDATE_CONTEXT
);
1969 /* Wait for interesting events to occur in the target process. */
1971 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1976 /* We loop when we get a non-standard exception rather than return
1977 with a SPURIOUS because resume can try and step or modify things,
1978 which needs a current_thread->h. But some of these exceptions mark
1979 the birth or death of threads, which mean that the current thread
1980 isn't necessarily what you think it is. */
1986 /* If the user presses Ctrl-c while the debugger is waiting
1987 for an event, he expects the debugger to interrupt his program
1988 and to get the prompt back. There are two possible situations:
1990 - The debugger and the program do not share the console, in
1991 which case the Ctrl-c event only reached the debugger.
1992 In that case, the ctrl_c handler will take care of interrupting
1993 the inferior. Note that this case is working starting with
1994 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1997 - The debugger and the program share the same console, in which
1998 case both debugger and inferior will receive the Ctrl-c event.
1999 In that case the ctrl_c handler will ignore the event, as the
2000 Ctrl-c event generated inside the inferior will trigger the
2001 expected debug event.
2003 FIXME: brobecker/2008-05-20: If the inferior receives the
2004 signal first and the delay until GDB receives that signal
2005 is sufficiently long, GDB can sometimes receive the SIGINT
2006 after we have unblocked the CTRL+C handler. This would
2007 lead to the debugger stopping prematurely while handling
2008 the new-thread event that comes with the handling of the SIGINT
2009 inside the inferior, and then stop again immediately when
2010 the user tries to resume the execution in the inferior.
2011 This is a classic race that we should try to fix one day. */
2012 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
2013 retval
= get_windows_debug_event (pid
, ourstatus
);
2014 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
2018 ptid_t result
= ptid_t (current_event
.dwProcessId
, retval
, 0);
2020 if (current_windows_thread
!= nullptr)
2022 current_windows_thread
->stopped_at_software_breakpoint
= false;
2023 if (current_event
.dwDebugEventCode
== EXCEPTION_DEBUG_EVENT
2024 && (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
2025 == EXCEPTION_BREAKPOINT
)
2026 && windows_initialization_done
)
2027 current_windows_thread
->stopped_at_software_breakpoint
= true;
2036 if (deprecated_ui_loop_hook
!= NULL
)
2037 detach
= deprecated_ui_loop_hook (0);
2045 /* Iterate over all DLLs currently mapped by our inferior, and
2046 add them to our list of solibs. */
2049 windows_add_all_dlls (void)
2051 HMODULE dummy_hmodule
;
2059 if (EnumProcessModulesEx (current_process_handle
, &dummy_hmodule
,
2060 sizeof (HMODULE
), &cb_needed
,
2061 LIST_MODULES_32BIT
) == 0)
2067 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
2068 sizeof (HMODULE
), &cb_needed
) == 0)
2075 hmodules
= (HMODULE
*) alloca (cb_needed
);
2079 if (EnumProcessModulesEx (current_process_handle
, hmodules
,
2080 cb_needed
, &cb_needed
,
2081 LIST_MODULES_32BIT
) == 0)
2087 if (EnumProcessModules (current_process_handle
, hmodules
,
2088 cb_needed
, &cb_needed
) == 0)
2092 char system_dir
[__PMAX
];
2093 char syswow_dir
[__PMAX
];
2094 size_t system_dir_len
= 0;
2095 bool convert_syswow_dir
= false;
2100 /* This fails on 32bit Windows because it has no SysWOW64 directory,
2101 and in this case a path conversion isn't necessary. */
2102 UINT len
= GetSystemWow64DirectoryA (syswow_dir
, sizeof (syswow_dir
));
2105 /* Check that we have passed a large enough buffer. */
2106 gdb_assert (len
< sizeof (syswow_dir
));
2108 len
= GetSystemDirectoryA (system_dir
, sizeof (system_dir
));
2110 gdb_assert (len
!= 0);
2111 /* Check that we have passed a large enough buffer. */
2112 gdb_assert (len
< sizeof (system_dir
));
2114 strcat (system_dir
, "\\");
2115 strcat (syswow_dir
, "\\");
2116 system_dir_len
= strlen (system_dir
);
2118 convert_syswow_dir
= true;
2122 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
2126 wchar_t dll_name
[__PMAX
];
2127 char dll_name_mb
[__PMAX
];
2129 char dll_name
[__PMAX
];
2132 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
2133 &mi
, sizeof (mi
)) == 0)
2135 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
2136 dll_name
, sizeof (dll_name
)) == 0)
2139 wcstombs (dll_name_mb
, dll_name
, __PMAX
);
2144 /* Convert the DLL path of 32bit processes returned by
2145 GetModuleFileNameEx from the 64bit system directory to the
2146 32bit syswow64 directory if necessary. */
2147 std::string syswow_dll_path
;
2148 if (convert_syswow_dir
2149 && strncasecmp (name
, system_dir
, system_dir_len
) == 0
2150 && strchr (name
+ system_dir_len
, '\\') == nullptr)
2152 syswow_dll_path
= syswow_dir
;
2153 syswow_dll_path
+= name
+ system_dir_len
;
2154 name
= syswow_dll_path
.c_str();
2157 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
2158 solib_end
= solib_end
->next
;
2163 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
2166 struct inferior
*inf
;
2168 last_sig
= GDB_SIGNAL_0
;
2170 exception_count
= 0;
2171 open_process_used
= 0;
2172 debug_registers_changed
= 0;
2173 debug_registers_used
= 0;
2174 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
2177 cygwin_load_start
= cygwin_load_end
= 0;
2179 current_event
.dwProcessId
= pid
;
2180 memset (¤t_event
, 0, sizeof (current_event
));
2181 if (!target_is_pushed (ops
))
2183 disable_breakpoints_in_shlibs ();
2184 windows_clear_solib ();
2185 clear_proceed_status (0);
2186 init_wait_for_inferior ();
2189 ignore_first_breakpoint
= !attaching
&& wow64_process
;
2193 windows_set_context_register_offsets (amd64_mappings
);
2194 windows_set_segment_register_p (amd64_windows_segment_register_p
);
2199 windows_set_context_register_offsets (i386_mappings
);
2200 windows_set_segment_register_p (i386_windows_segment_register_p
);
2203 inf
= current_inferior ();
2204 inferior_appeared (inf
, pid
);
2205 inf
->attach_flag
= attaching
;
2207 /* Make the new process the current inferior, so terminal handling
2208 can rely on it. When attaching, we don't know about any thread
2209 id here, but that's OK --- nothing should be referencing the
2210 current thread until we report an event out of windows_wait. */
2211 inferior_ptid
= ptid_t (pid
);
2213 target_terminal::init ();
2214 target_terminal::inferior ();
2216 windows_initialization_done
= 0;
2220 struct target_waitstatus status
;
2222 ops
->wait (minus_one_ptid
, &status
, 0);
2224 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
2226 if (status
.kind
!= TARGET_WAITKIND_LOADED
2227 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
2230 ops
->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
2233 /* Now that the inferior has been started and all DLLs have been mapped,
2234 we can iterate over all DLLs and load them in.
2236 We avoid doing it any earlier because, on certain versions of Windows,
2237 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
2238 we have seen on Windows 8.1 that the ntdll.dll load event does not
2239 include the DLL name, preventing us from creating an associated SO.
2240 A possible explanation is that ntdll.dll might be mapped before
2241 the SO info gets created by the Windows system -- ntdll.dll is
2242 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
2243 do not seem to suffer from that problem.
2245 Rather than try to work around this sort of issue, it is much
2246 simpler to just ignore DLL load/unload events during the startup
2247 phase, and then process them all in one batch now. */
2248 windows_add_all_dlls ();
2250 windows_initialization_done
= 1;
2254 /* Try to set or remove a user privilege to the current process. Return -1
2255 if that fails, the previous setting of that privilege otherwise.
2257 This code is copied from the Cygwin source code and rearranged to allow
2258 dynamically loading of the needed symbols from advapi32 which is only
2259 available on NT/2K/XP. */
2261 set_process_privilege (const char *privilege
, BOOL enable
)
2263 HANDLE token_hdl
= NULL
;
2265 TOKEN_PRIVILEGES new_priv
, orig_priv
;
2269 if (!OpenProcessToken (GetCurrentProcess (),
2270 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
2274 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
2277 new_priv
.PrivilegeCount
= 1;
2278 new_priv
.Privileges
[0].Luid
= restore_priv
;
2279 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
2281 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
2282 sizeof orig_priv
, &orig_priv
, &size
))
2285 /* Disabled, otherwise every `attach' in an unprivileged user session
2286 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
2287 windows_attach(). */
2288 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
2289 be enabled. GetLastError () returns an correct error code, though. */
2290 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
2294 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
2298 CloseHandle (token_hdl
);
2303 /* Attach to process PID, then initialize for debugging it. */
2306 windows_nat_target::attach (const char *args
, int from_tty
)
2311 pid
= parse_pid_to_attach (args
);
2313 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
2315 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
2316 printf_unfiltered ("This can cause attach to "
2317 "fail on Windows NT/2K/XP\n");
2320 windows_init_thread_list ();
2321 ok
= DebugActiveProcess (pid
);
2327 /* Try fall back to Cygwin pid. */
2328 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
2331 ok
= DebugActiveProcess (pid
);
2336 error (_("Can't attach to process %u (error %u)"),
2337 (unsigned) pid
, (unsigned) GetLastError ());
2339 DebugSetProcessKillOnExit (FALSE
);
2343 const char *exec_file
= get_exec_file (0);
2346 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
2347 target_pid_to_str (ptid_t (pid
)).c_str ());
2349 printf_unfiltered ("Attaching to %s\n",
2350 target_pid_to_str (ptid_t (pid
)).c_str ());
2354 HANDLE h
= OpenProcess (PROCESS_QUERY_INFORMATION
, FALSE
, pid
);
2358 if (IsWow64Process (h
, &wow64
))
2359 wow64_process
= wow64
;
2364 do_initial_windows_stuff (this, pid
, 1);
2365 target_terminal::ours ();
2369 windows_nat_target::detach (inferior
*inf
, int from_tty
)
2373 ptid_t ptid
= minus_one_ptid
;
2374 resume (ptid
, 0, GDB_SIGNAL_0
);
2376 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
2378 error (_("Can't detach process %u (error %u)"),
2379 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
2382 DebugSetProcessKillOnExit (FALSE
);
2384 if (detached
&& from_tty
)
2386 const char *exec_file
= get_exec_file (0);
2389 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
2390 (unsigned) current_event
.dwProcessId
);
2393 x86_cleanup_dregs ();
2394 inferior_ptid
= null_ptid
;
2395 detach_inferior (inf
);
2397 maybe_unpush_target ();
2400 /* Try to determine the executable filename.
2402 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2404 Upon success, the filename is stored inside EXE_NAME_RET, and
2405 this function returns nonzero.
2407 Otherwise, this function returns zero and the contents of
2408 EXE_NAME_RET is undefined. */
2411 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2421 if (!EnumProcessModulesEx (current_process_handle
, &dh_buf
,
2422 sizeof (HMODULE
), &cbNeeded
,
2423 LIST_MODULES_32BIT
) || !cbNeeded
)
2429 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2430 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2434 /* We know the executable is always first in the list of modules,
2435 which we just fetched. So no need to fetch more. */
2439 /* Cygwin prefers that the path be in /x/y/z format, so extract
2440 the filename into a temporary buffer first, and then convert it
2441 to POSIX format into the destination buffer. */
2442 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2444 len
= GetModuleFileNameEx (current_process_handle
,
2445 dh_buf
, pathbuf
, exe_name_max_len
);
2447 error (_("Error getting executable filename: %u."),
2448 (unsigned) GetLastError ());
2449 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2450 exe_name_max_len
) < 0)
2451 error (_("Error converting executable filename to POSIX: %d."), errno
);
2454 len
= GetModuleFileNameEx (current_process_handle
,
2455 dh_buf
, exe_name_ret
, exe_name_max_len
);
2457 error (_("Error getting executable filename: %u."),
2458 (unsigned) GetLastError ());
2461 return 1; /* success */
2464 /* The pid_to_exec_file target_ops method for this platform. */
2467 windows_nat_target::pid_to_exec_file (int pid
)
2469 static char path
[__PMAX
];
2471 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2473 char procexe
[sizeof ("/proc/4294967295/exe")];
2475 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2476 nchars
= readlink (procexe
, path
, sizeof(path
));
2477 if (nchars
> 0 && nchars
< sizeof (path
))
2479 path
[nchars
] = '\0'; /* Got it */
2484 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2485 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2486 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2492 /* Print status information about what we're accessing. */
2495 windows_nat_target::files_info ()
2497 struct inferior
*inf
= current_inferior ();
2499 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2500 inf
->attach_flag
? "attached" : "child",
2501 target_pid_to_str (inferior_ptid
).c_str ());
2504 /* Modify CreateProcess parameters for use of a new separate console.
2506 *FLAGS: DWORD parameter for general process creation flags.
2507 *SI: STARTUPINFO structure, for which the console window size and
2508 console buffer size is filled in if GDB is running in a console.
2509 to create the new console.
2510 The size of the used font is not available on all versions of
2511 Windows OS. Furthermore, the current font might not be the default
2512 font, but this is still better than before.
2513 If the windows and buffer sizes are computed,
2514 SI->DWFLAGS is changed so that this information is used
2515 by CreateProcess function. */
2518 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2520 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2521 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2523 if (hconsole
!= INVALID_HANDLE_VALUE
)
2525 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2527 CONSOLE_FONT_INFO cfi
;
2529 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2530 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2531 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2532 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2533 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2535 si
->dwXSize
*= font_size
.X
;
2539 si
->dwYSize
*= font_size
.Y
;
2542 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2543 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2544 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2546 *flags
|= CREATE_NEW_CONSOLE
;
2550 /* Function called by qsort to sort environment strings. */
2553 envvar_cmp (const void *a
, const void *b
)
2555 const char **p
= (const char **) a
;
2556 const char **q
= (const char **) b
;
2557 return strcasecmp (*p
, *q
);
2563 clear_win32_environment (char **env
)
2567 wchar_t *copy
= NULL
, *equalpos
;
2569 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2571 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2572 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2573 mbstowcs (copy
, env
[i
], len
);
2574 equalpos
= wcschr (copy
, L
'=');
2577 SetEnvironmentVariableW (copy
, NULL
);
2585 /* Redirection of inferior I/O streams for native MS-Windows programs.
2586 Unlike on Unix, where this is handled by invoking the inferior via
2587 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2589 The official documentation of the cmd.exe redirection features is here:
2591 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2593 (That page talks about Windows XP, but there's no newer
2594 documentation, so we assume later versions of cmd.exe didn't change
2597 Caveat: the documentation on that page seems to include a few lies.
2598 For example, it describes strange constructs 1<&2 and 2<&1, which
2599 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2600 think the cmd.exe parser of the redirection symbols simply doesn't
2601 care about the < vs > distinction in these cases. Therefore, the
2602 supported features are explicitly documented below.
2604 The emulation below aims at supporting all the valid use cases
2605 supported by cmd.exe, which include:
2607 < FILE redirect standard input from FILE
2608 0< FILE redirect standard input from FILE
2609 <&N redirect standard input from file descriptor N
2610 0<&N redirect standard input from file descriptor N
2611 > FILE redirect standard output to FILE
2612 >> FILE append standard output to FILE
2613 1>> FILE append standard output to FILE
2614 >&N redirect standard output to file descriptor N
2615 1>&N redirect standard output to file descriptor N
2616 >>&N append standard output to file descriptor N
2617 1>>&N append standard output to file descriptor N
2618 2> FILE redirect standard error to FILE
2619 2>> FILE append standard error to FILE
2620 2>&N redirect standard error to file descriptor N
2621 2>>&N append standard error to file descriptor N
2623 Note that using N > 2 in the above construct is supported, but
2624 requires that the corresponding file descriptor be open by some
2625 means elsewhere or outside GDB. Also note that using ">&0" or
2626 "<&2" will generally fail, because the file descriptor redirected
2627 from is normally open in an incompatible mode (e.g., FD 0 is open
2628 for reading only). IOW, use of such tricks is not recommended;
2629 you are on your own.
2631 We do NOT support redirection of file descriptors above 2, as in
2632 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2633 that needs special handling in the startup code that MinGW
2634 doesn't have). Pipes are also not supported.
2636 As for invalid use cases, where the redirection contains some
2637 error, the emulation below will detect that and produce some
2638 error and/or failure. But the behavior in those cases is not
2639 bug-for-bug compatible with what cmd.exe does in those cases.
2640 That's because what cmd.exe does then is not well defined, and
2641 seems to be a side effect of the cmd.exe parsing of the command
2642 line more than anything else. For example, try redirecting to an
2643 invalid file name, as in "> foo:bar".
2645 There are also minor syntactic deviations from what cmd.exe does
2646 in some corner cases. For example, it doesn't support the likes
2647 of "> &foo" to mean redirect to file named literally "&foo"; we
2648 do support that here, because that, too, sounds like some issue
2649 with the cmd.exe parser. Another nicety is that we support
2650 redirection targets that use file names with forward slashes,
2651 something cmd.exe doesn't -- this comes in handy since GDB
2652 file-name completion can be used when typing the command line for
2655 /* Support routines for redirecting standard handles of the inferior. */
2657 /* Parse a single redirection spec, open/duplicate the specified
2658 file/fd, and assign the appropriate value to one of the 3 standard
2659 file descriptors. */
2661 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2663 int *fd
, ref_fd
= -2;
2665 const char *fname
= redir_string
+ 1;
2666 int rc
= *redir_string
;
2681 fd
= (rc
== '2') ? err
: out
;
2682 mode
= O_WRONLY
| O_CREAT
;
2695 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2697 /* A reference to a file descriptor. */
2699 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2700 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2702 /* Don't allow redirection when open modes are incompatible. */
2703 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2704 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2711 else if (ref_fd
== 1)
2713 else if (ref_fd
== 2)
2723 fname
++; /* skip the separator space */
2724 /* If the descriptor is already open, close it. This allows
2725 multiple specs of redirections for the same stream, which is
2726 somewhat nonsensical, but still valid and supported by cmd.exe.
2727 (But cmd.exe only opens a single file in this case, the one
2728 specified by the last redirection spec on the command line.) */
2733 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2737 else if (ref_fd
== -1)
2738 *fd
= -1; /* reset to default destination */
2741 *fd
= _dup (ref_fd
);
2745 /* _open just sets a flag for O_APPEND, which won't be passed to the
2746 inferior, so we need to actually move the file pointer. */
2747 if ((mode
& O_APPEND
) != 0)
2748 _lseek (*fd
, 0L, SEEK_END
);
2752 /* Canonicalize a single redirection spec and set up the corresponding
2753 file descriptor as specified. */
2755 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2757 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2759 const char *start
= s
;
2762 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2763 if ((*start
== '>' || *start
== '1' || *start
== '2')
2767 if (*s
== '>' && *start
!= '>')
2770 else if (*start
== '0' && *s
== '<')
2772 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2775 while (isspace (*s
)) /* skip whitespace before file name */
2777 *d
++ = ' '; /* separate file name with a single space */
2780 /* Copy the file name. */
2783 /* Remove quoting characters from the file name in buf[]. */
2784 if (*s
== '"') /* could support '..' quoting here */
2788 else if (*s
== quote
)
2796 else if (*s
== '\\')
2798 if (s
[1] == '"') /* could support '..' here */
2802 else if (isspace (*s
) && !quote
)
2806 if (d
- buf
>= sizeof (buf
) - 1)
2808 errno
= ENAMETOOLONG
;
2814 /* Windows doesn't allow redirection characters in file names, so we
2815 can bail out early if they use them, or if there's no target file
2816 name after the redirection symbol. */
2817 if (d
[-1] == '>' || d
[-1] == '<')
2822 if (redir_open (buf
, inp
, out
, err
) == 0)
2827 /* Parse the command line for redirection specs and prepare the file
2828 descriptors for the 3 standard streams accordingly. */
2830 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2831 int *inp
, int *out
, int *err
)
2833 const char *s
= cmd_orig
;
2836 bool retval
= false;
2838 while (isspace (*s
))
2843 if (*s
== '"') /* could also support '..' quoting here */
2847 else if (*s
== quote
)
2850 else if (*s
== '\\')
2852 if (s
[1] == '"') /* escaped quote char */
2857 /* Process a single redirection candidate. */
2858 if (*s
== '<' || *s
== '>'
2859 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2860 || (*s
== '0' && s
[1] == '<'))
2862 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2876 #endif /* !__CYGWIN__ */
2878 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2879 EXEC_FILE is the file to run.
2880 ALLARGS is a string containing the arguments to the program.
2881 ENV is the environment vector to pass. Errors reported with error(). */
2884 windows_nat_target::create_inferior (const char *exec_file
,
2885 const std::string
&origallargs
,
2886 char **in_env
, int from_tty
)
2890 cygwin_buf_t real_path
[__PMAX
];
2891 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2892 cygwin_buf_t infcwd
[__PMAX
];
2894 cygwin_buf_t
*toexec
;
2895 cygwin_buf_t
*cygallargs
;
2897 char **old_env
= NULL
;
2901 int ostdin
, ostdout
, ostderr
;
2902 #else /* !__CYGWIN__ */
2903 char shell
[__PMAX
]; /* Path to shell */
2905 char *args
, *allargs_copy
;
2906 size_t args_len
, allargs_len
;
2907 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2908 HANDLE tty
= INVALID_HANDLE_VALUE
;
2909 bool redirected
= false;
2916 #endif /* !__CYGWIN__ */
2917 const char *allargs
= origallargs
.c_str ();
2918 PROCESS_INFORMATION pi
;
2921 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2924 error (_("No executable specified, use `target exec'."));
2926 const char *inferior_cwd
= get_inferior_cwd ();
2927 std::string expanded_infcwd
;
2928 if (inferior_cwd
!= NULL
)
2930 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
2931 /* Mirror slashes on inferior's cwd. */
2932 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
2934 inferior_cwd
= expanded_infcwd
.c_str ();
2937 memset (&si
, 0, sizeof (si
));
2938 si
.cb
= sizeof (si
);
2941 flags
|= CREATE_NEW_PROCESS_GROUP
;
2944 windows_set_console_info (&si
, &flags
);
2949 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2950 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2951 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2952 error (_("Error starting executable: %d"), errno
);
2955 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2956 if (len
== (size_t) -1)
2957 error (_("Error starting executable: %d"), errno
);
2958 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2959 mbstowcs (cygallargs
, allargs
, len
);
2960 #else /* !__USEWIDE */
2961 cygallargs
= allargs
;
2967 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2968 error (_("Error starting executable via shell: %d"), errno
);
2970 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2971 + mbstowcs (NULL
, allargs
, 0) + 2;
2972 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2973 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2974 #else /* !__USEWIDE */
2975 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2976 + strlen (allargs
) + 2);
2977 cygallargs
= (char *) alloca (len
);
2978 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2979 #endif /* __USEWIDE */
2981 flags
|= DEBUG_PROCESS
;
2984 if (inferior_cwd
!= NULL
2985 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
2986 infcwd
, strlen (inferior_cwd
)) < 0)
2987 error (_("Error converting inferior cwd: %d"), errno
);
2990 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2991 * sizeof (wchar_t));
2992 wcscpy (args
, toexec
);
2993 wcscat (args
, L
" ");
2994 wcscat (args
, cygallargs
);
2995 #else /* !__USEWIDE */
2996 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2997 strcpy (args
, toexec
);
2999 strcat (args
, cygallargs
);
3000 #endif /* !__USEWIDE */
3002 #ifdef CW_CVT_ENV_TO_WINENV
3003 /* First try to create a direct Win32 copy of the POSIX environment. */
3004 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
3005 if (w32_env
!= (PWCHAR
) -1)
3006 flags
|= CREATE_UNICODE_ENVIRONMENT
;
3008 /* If that fails, fall back to old method tweaking GDB's environment. */
3009 #endif /* CW_CVT_ENV_TO_WINENV */
3011 /* Reset all Win32 environment variables to avoid leftover on next run. */
3012 clear_win32_environment (environ
);
3013 /* Prepare the environment vars for CreateProcess. */
3016 cygwin_internal (CW_SYNC_WINENV
);
3020 if (!inferior_io_terminal
)
3021 tty
= ostdin
= ostdout
= ostderr
= -1;
3024 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
3027 print_sys_errmsg (inferior_io_terminal
, errno
);
3028 ostdin
= ostdout
= ostderr
= -1;
3041 windows_init_thread_list ();
3042 ret
= CreateProcess (0,
3043 args
, /* command line */
3044 NULL
, /* Security */
3046 TRUE
, /* inherit handles */
3047 flags
, /* start flags */
3048 w32_env
, /* environment */
3049 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
3054 /* Just free the Win32 environment, if it could be created. */
3058 /* Reset all environment variables to avoid leftover on next run. */
3059 clear_win32_environment (in_env
);
3060 /* Restore normal GDB environment variables. */
3062 cygwin_internal (CW_SYNC_WINENV
);
3075 #else /* !__CYGWIN__ */
3076 allargs_len
= strlen (allargs
);
3077 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
3078 if (strpbrk (allargs_copy
, "<>") != NULL
)
3083 redirect_inferior_handles (allargs
, allargs_copy
,
3084 &fd_inp
, &fd_out
, &fd_err
);
3086 warning (_("Error in redirection: %s."), safe_strerror (errno
));
3089 allargs_len
= strlen (allargs_copy
);
3091 /* If not all the standard streams are redirected by the command
3092 line, use inferior_io_terminal for those which aren't. */
3093 if (inferior_io_terminal
3094 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
3096 SECURITY_ATTRIBUTES sa
;
3097 sa
.nLength
= sizeof(sa
);
3098 sa
.lpSecurityDescriptor
= 0;
3099 sa
.bInheritHandle
= TRUE
;
3100 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
3101 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
3102 if (tty
== INVALID_HANDLE_VALUE
)
3103 warning (_("Warning: Failed to open TTY %s, error %#x."),
3104 inferior_io_terminal
, (unsigned) GetLastError ());
3106 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
3109 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
3110 else if (tty
!= INVALID_HANDLE_VALUE
)
3113 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
3115 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
3116 else if (tty
!= INVALID_HANDLE_VALUE
)
3117 si
.hStdOutput
= tty
;
3119 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
3121 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
3122 else if (tty
!= INVALID_HANDLE_VALUE
)
3125 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
3126 si
.dwFlags
|= STARTF_USESTDHANDLES
;
3130 /* Build the command line, a space-separated list of tokens where
3131 the first token is the name of the module to be executed.
3132 To avoid ambiguities introduced by spaces in the module name,
3134 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
3135 args
= (char *) alloca (args_len
);
3136 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
3138 flags
|= DEBUG_ONLY_THIS_PROCESS
;
3140 /* CreateProcess takes the environment list as a null terminated set of
3141 strings (i.e. two nulls terminate the list). */
3143 /* Get total size for env strings. */
3144 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
3145 envlen
+= strlen (in_env
[i
]) + 1;
3147 envsize
= sizeof (in_env
[0]) * (i
+ 1);
3148 env
= (char **) alloca (envsize
);
3149 memcpy (env
, in_env
, envsize
);
3150 /* Windows programs expect the environment block to be sorted. */
3151 qsort (env
, i
, sizeof (char *), envvar_cmp
);
3153 w32env
= (char *) alloca (envlen
+ 1);
3155 /* Copy env strings into new buffer. */
3156 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
3158 strcpy (temp
, env
[i
]);
3159 temp
+= strlen (temp
) + 1;
3162 /* Final nil string to terminate new env. */
3165 windows_init_thread_list ();
3166 ret
= CreateProcessA (0,
3167 args
, /* command line */
3168 NULL
, /* Security */
3170 TRUE
, /* inherit handles */
3171 flags
, /* start flags */
3172 w32env
, /* environment */
3173 inferior_cwd
, /* current directory */
3176 if (tty
!= INVALID_HANDLE_VALUE
)
3184 #endif /* !__CYGWIN__ */
3187 error (_("Error creating process %s, (error %u)."),
3188 exec_file
, (unsigned) GetLastError ());
3192 if (IsWow64Process (pi
.hProcess
, &wow64
))
3193 wow64_process
= wow64
;
3196 CloseHandle (pi
.hThread
);
3197 CloseHandle (pi
.hProcess
);
3199 if (useshell
&& shell
[0] != '\0')
3204 do_initial_windows_stuff (this, pi
.dwProcessId
, 0);
3206 /* windows_continue (DBG_CONTINUE, -1, 0); */
3210 windows_nat_target::mourn_inferior ()
3212 (void) windows_continue (DBG_CONTINUE
, -1, 0);
3213 x86_cleanup_dregs();
3214 if (open_process_used
)
3216 CHECK (CloseHandle (current_process_handle
));
3217 open_process_used
= 0;
3219 siginfo_er
.ExceptionCode
= 0;
3220 inf_child_target::mourn_inferior ();
3223 /* Send a SIGINT to the process group. This acts just like the user typed a
3224 ^C on the controlling terminal. */
3227 windows_nat_target::interrupt ()
3229 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
3230 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
3231 registers_changed (); /* refresh register state */
3234 /* Helper for windows_xfer_partial that handles memory transfers.
3235 Arguments are like target_xfer_partial. */
3237 static enum target_xfer_status
3238 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3239 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
3243 DWORD lasterror
= 0;
3245 if (writebuf
!= NULL
)
3247 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
3248 pulongest (len
), core_addr_to_string (memaddr
)));
3249 success
= WriteProcessMemory (current_process_handle
,
3250 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
3253 lasterror
= GetLastError ();
3254 FlushInstructionCache (current_process_handle
,
3255 (LPCVOID
) (uintptr_t) memaddr
, len
);
3259 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
3260 pulongest (len
), core_addr_to_string (memaddr
)));
3261 success
= ReadProcessMemory (current_process_handle
,
3262 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
3265 lasterror
= GetLastError ();
3267 *xfered_len
= (ULONGEST
) done
;
3268 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
3269 return TARGET_XFER_OK
;
3271 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
3275 windows_nat_target::kill ()
3277 CHECK (TerminateProcess (current_process_handle
, 0));
3281 if (!windows_continue (DBG_CONTINUE
, -1, 1))
3283 if (!wait_for_debug_event (¤t_event
, INFINITE
))
3285 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
3289 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
3293 windows_nat_target::close ()
3295 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
3296 inferior_ptid
.pid ()));
3299 /* Convert pid to printable format. */
3301 windows_nat_target::pid_to_str (ptid_t ptid
)
3303 if (ptid
.lwp () != 0)
3304 return string_printf ("Thread %d.0x%lx", ptid
.pid (), ptid
.lwp ());
3306 return normal_pid_to_str (ptid
);
3309 static enum target_xfer_status
3310 windows_xfer_shared_libraries (struct target_ops
*ops
,
3311 enum target_object object
, const char *annex
,
3312 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3313 ULONGEST offset
, ULONGEST len
,
3314 ULONGEST
*xfered_len
)
3316 struct obstack obstack
;
3322 return TARGET_XFER_E_IO
;
3324 obstack_init (&obstack
);
3325 obstack_grow_str (&obstack
, "<library-list>\n");
3326 for (so
= solib_start
.next
; so
; so
= so
->next
)
3328 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
3330 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
3331 (uintptr_t) li
->load_addr
,
3333 target_gdbarch (), &obstack
);
3335 obstack_grow_str0 (&obstack
, "</library-list>\n");
3337 buf
= (const char *) obstack_finish (&obstack
);
3338 len_avail
= strlen (buf
);
3339 if (offset
>= len_avail
)
3343 if (len
> len_avail
- offset
)
3344 len
= len_avail
- offset
;
3345 memcpy (readbuf
, buf
+ offset
, len
);
3348 obstack_free (&obstack
, NULL
);
3349 *xfered_len
= (ULONGEST
) len
;
3350 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
3353 /* Helper for windows_nat_target::xfer_partial that handles signal info. */
3355 static enum target_xfer_status
3356 windows_xfer_siginfo (gdb_byte
*readbuf
, ULONGEST offset
, ULONGEST len
,
3357 ULONGEST
*xfered_len
)
3359 char *buf
= (char *) &siginfo_er
;
3360 size_t bufsize
= sizeof (siginfo_er
);
3363 EXCEPTION_RECORD32 er32
;
3366 buf
= (char *) &er32
;
3367 bufsize
= sizeof (er32
);
3369 er32
.ExceptionCode
= siginfo_er
.ExceptionCode
;
3370 er32
.ExceptionFlags
= siginfo_er
.ExceptionFlags
;
3371 er32
.ExceptionRecord
= (uintptr_t) siginfo_er
.ExceptionRecord
;
3372 er32
.ExceptionAddress
= (uintptr_t) siginfo_er
.ExceptionAddress
;
3373 er32
.NumberParameters
= siginfo_er
.NumberParameters
;
3375 for (i
= 0; i
< EXCEPTION_MAXIMUM_PARAMETERS
; i
++)
3376 er32
.ExceptionInformation
[i
] = siginfo_er
.ExceptionInformation
[i
];
3380 if (siginfo_er
.ExceptionCode
== 0)
3381 return TARGET_XFER_E_IO
;
3383 if (readbuf
== nullptr)
3384 return TARGET_XFER_E_IO
;
3386 if (offset
> bufsize
)
3387 return TARGET_XFER_E_IO
;
3389 if (offset
+ len
> bufsize
)
3390 len
= bufsize
- offset
;
3392 memcpy (readbuf
, buf
+ offset
, len
);
3395 return TARGET_XFER_OK
;
3398 enum target_xfer_status
3399 windows_nat_target::xfer_partial (enum target_object object
,
3400 const char *annex
, gdb_byte
*readbuf
,
3401 const gdb_byte
*writebuf
, ULONGEST offset
,
3402 ULONGEST len
, ULONGEST
*xfered_len
)
3406 case TARGET_OBJECT_MEMORY
:
3407 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
3409 case TARGET_OBJECT_LIBRARIES
:
3410 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
3411 writebuf
, offset
, len
, xfered_len
);
3413 case TARGET_OBJECT_SIGNAL_INFO
:
3414 return windows_xfer_siginfo (readbuf
, offset
, len
, xfered_len
);
3417 if (beneath () == NULL
)
3419 /* This can happen when requesting the transfer of unsupported
3420 objects before a program has been started (and therefore
3421 with the current_target having no target beneath). */
3422 return TARGET_XFER_E_IO
;
3424 return beneath ()->xfer_partial (object
, annex
,
3425 readbuf
, writebuf
, offset
, len
,
3430 /* Provide thread local base, i.e. Thread Information Block address.
3431 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
3434 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
3436 windows_thread_info
*th
;
3438 th
= thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
);
3443 *addr
= th
->thread_local_base
;
3449 windows_nat_target::get_ada_task_ptid (long lwp
, long thread
)
3451 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
3454 /* Implementation of the to_thread_name method. */
3457 windows_nat_target::thread_name (struct thread_info
*thr
)
3459 return thread_rec (thr
->ptid
, DONT_INVALIDATE_CONTEXT
)->name
.get ();
3463 void _initialize_windows_nat ();
3465 _initialize_windows_nat ()
3467 x86_dr_low
.set_control
= cygwin_set_dr7
;
3468 x86_dr_low
.set_addr
= cygwin_set_dr
;
3469 x86_dr_low
.get_addr
= cygwin_get_dr
;
3470 x86_dr_low
.get_status
= cygwin_get_dr6
;
3471 x86_dr_low
.get_control
= cygwin_get_dr7
;
3473 /* x86_dr_low.debug_register_length field is set by
3474 calling x86_set_debug_register_length function
3475 in processor windows specific native file. */
3477 add_inf_child_target (&the_windows_nat_target
);
3480 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3483 add_com ("signal-event", class_run
, signal_event_command
, _("\
3484 Signal a crashed process with event ID, to allow its debugging.\n\
3485 This command is needed in support of setting up GDB as JIT debugger on \
3486 MS-Windows. The command should be invoked from the GDB command line using \
3487 the '-ex' command-line option. The ID of the event that blocks the \
3488 crashed process will be supplied by the Windows JIT debugging mechanism."));
3491 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3492 Set use of shell to start subprocess."), _("\
3493 Show use of shell to start subprocess."), NULL
,
3495 NULL
, /* FIXME: i18n: */
3496 &setlist
, &showlist
);
3498 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3499 &cygwin_exceptions
, _("\
3500 Break when an exception is detected in the Cygwin DLL itself."), _("\
3501 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3503 NULL
, /* FIXME: i18n: */
3504 &setlist
, &showlist
);
3507 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3508 Set creation of new console when creating child process."), _("\
3509 Show creation of new console when creating child process."), NULL
,
3511 NULL
, /* FIXME: i18n: */
3512 &setlist
, &showlist
);
3514 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3515 Set creation of new group when creating child process."), _("\
3516 Show creation of new group when creating child process."), NULL
,
3518 NULL
, /* FIXME: i18n: */
3519 &setlist
, &showlist
);
3521 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3522 Set whether to display execution in child process."), _("\
3523 Show whether to display execution in child process."), NULL
,
3525 NULL
, /* FIXME: i18n: */
3526 &setlist
, &showlist
);
3528 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3529 Set whether to display kernel events in child process."), _("\
3530 Show whether to display kernel events in child process."), NULL
,
3532 NULL
, /* FIXME: i18n: */
3533 &setlist
, &showlist
);
3535 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3536 Set whether to display memory accesses in child process."), _("\
3537 Show whether to display memory accesses in child process."), NULL
,
3539 NULL
, /* FIXME: i18n: */
3540 &setlist
, &showlist
);
3542 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3543 &debug_exceptions
, _("\
3544 Set whether to display kernel exceptions in child process."), _("\
3545 Show whether to display kernel exceptions in child process."), NULL
,
3547 NULL
, /* FIXME: i18n: */
3548 &setlist
, &showlist
);
3550 init_w32_command_list ();
3552 add_cmd ("selector", class_info
, display_selectors
,
3553 _("Display selectors infos."),
3557 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3559 /* Pass the address ADDR to the inferior in the I'th debug register.
3560 Here we just store the address in dr array, the registers will be
3561 actually set up when windows_continue is called. */
3563 cygwin_set_dr (int i
, CORE_ADDR addr
)
3566 internal_error (__FILE__
, __LINE__
,
3567 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3569 debug_registers_changed
= 1;
3570 debug_registers_used
= 1;
3573 /* Pass the value VAL to the inferior in the DR7 debug control
3574 register. Here we just store the address in D_REGS, the watchpoint
3575 will be actually set up in windows_wait. */
3577 cygwin_set_dr7 (unsigned long val
)
3579 dr
[7] = (CORE_ADDR
) val
;
3580 debug_registers_changed
= 1;
3581 debug_registers_used
= 1;
3584 /* Get the value of debug register I from the inferior. */
3587 cygwin_get_dr (int i
)
3592 /* Get the value of the DR6 debug status register from the inferior.
3593 Here we just return the value stored in dr[6]
3594 by the last call to thread_rec for current_event.dwThreadId id. */
3595 static unsigned long
3596 cygwin_get_dr6 (void)
3598 return (unsigned long) dr
[6];
3601 /* Get the value of the DR7 debug status register from the inferior.
3602 Here we just return the value stored in dr[7] by the last call to
3603 thread_rec for current_event.dwThreadId id. */
3605 static unsigned long
3606 cygwin_get_dr7 (void)
3608 return (unsigned long) dr
[7];
3611 /* Determine if the thread referenced by "ptid" is alive
3612 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3613 it means that the thread has died. Otherwise it is assumed to be alive. */
3616 windows_nat_target::thread_alive (ptid_t ptid
)
3618 gdb_assert (ptid
.lwp () != 0);
3620 return (WaitForSingleObject (thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
)->h
, 0)
3624 void _initialize_check_for_gdb_ini ();
3626 _initialize_check_for_gdb_ini ()
3629 if (inhibit_gdbinit
)
3632 homedir
= getenv ("HOME");
3636 char *oldini
= (char *) alloca (strlen (homedir
) +
3637 sizeof ("gdb.ini") + 1);
3638 strcpy (oldini
, homedir
);
3639 p
= strchr (oldini
, '\0');
3640 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3642 strcpy (p
, "gdb.ini");
3643 if (access (oldini
, 0) == 0)
3645 int len
= strlen (oldini
);
3646 char *newini
= (char *) alloca (len
+ 2);
3648 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3649 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3650 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3655 /* Define dummy functions which always return error for the rare cases where
3656 these functions could not be found. */
3658 bad_DebugActiveProcessStop (DWORD w
)
3663 bad_DebugBreakProcess (HANDLE w
)
3668 bad_DebugSetProcessKillOnExit (BOOL w
)
3673 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3680 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3686 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3693 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3699 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3705 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3711 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3719 /* Load any functions which may not be available in ancient versions
3722 void _initialize_loadable ();
3724 _initialize_loadable ()
3728 #define GPA(m, func) \
3729 func = (func ## _ftype *) GetProcAddress (m, #func)
3731 hm
= LoadLibrary ("kernel32.dll");
3734 GPA (hm
, DebugActiveProcessStop
);
3735 GPA (hm
, DebugBreakProcess
);
3736 GPA (hm
, DebugSetProcessKillOnExit
);
3737 GPA (hm
, GetConsoleFontSize
);
3738 GPA (hm
, DebugActiveProcessStop
);
3739 GPA (hm
, GetCurrentConsoleFont
);
3741 GPA (hm
, Wow64SuspendThread
);
3742 GPA (hm
, Wow64GetThreadContext
);
3743 GPA (hm
, Wow64SetThreadContext
);
3744 GPA (hm
, Wow64GetThreadSelectorEntry
);
3748 /* Set variables to dummy versions of these processes if the function
3749 wasn't found in kernel32.dll. */
3750 if (!DebugBreakProcess
)
3751 DebugBreakProcess
= bad_DebugBreakProcess
;
3752 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3754 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3755 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3757 if (!GetConsoleFontSize
)
3758 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3759 if (!GetCurrentConsoleFont
)
3760 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3762 /* Load optional functions used for retrieving filename information
3763 associated with the currently debugged process or its dlls. */
3764 hm
= LoadLibrary ("psapi.dll");
3767 GPA (hm
, EnumProcessModules
);
3769 GPA (hm
, EnumProcessModulesEx
);
3771 GPA (hm
, GetModuleInformation
);
3772 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3773 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3776 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3778 /* Set variables to dummy versions of these processes if the function
3779 wasn't found in psapi.dll. */
3780 EnumProcessModules
= bad_EnumProcessModules
;
3781 GetModuleInformation
= bad_GetModuleInformation
;
3782 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3783 /* This will probably fail on Windows 9x/Me. Let the user know
3784 that we're missing some functionality. */
3786 cannot automatically find executable file or library to read symbols.\n\
3787 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3790 hm
= LoadLibrary ("advapi32.dll");
3793 GPA (hm
, OpenProcessToken
);
3794 GPA (hm
, LookupPrivilegeValueA
);
3795 GPA (hm
, AdjustTokenPrivileges
);
3796 /* Only need to set one of these since if OpenProcessToken fails nothing
3798 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3799 || !AdjustTokenPrivileges
)
3800 OpenProcessToken
= bad_OpenProcessToken
;