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 saw_create
;
251 static int open_process_used
= 0;
253 static bool wow64_process
= false;
254 static bool ignore_first_breakpoint
= false;
258 static bool new_console
= false;
260 static bool cygwin_exceptions
= false;
262 static bool new_group
= true;
263 static bool debug_exec
= false; /* show execution */
264 static bool debug_events
= false; /* show events from kernel */
265 static bool debug_memory
= false; /* show target memory accesses */
266 static bool debug_exceptions
= false; /* show target exceptions */
267 static bool useshell
= false; /* use shell for subprocesses */
269 /* This vector maps GDB's idea of a register's number into an offset
270 in the windows exception context vector.
272 It also contains the bit mask needed to load the register in question.
274 The contents of this table can only be computed by the units
275 that provide CPU-specific support for Windows native debugging.
276 These units should set the table by calling
277 windows_set_context_register_offsets.
279 One day we could read a reg, we could inspect the context we
280 already have loaded, if it doesn't have the bit set that we need,
281 we read that set of registers in using GetThreadContext. If the
282 context already contains what we need, we just unpack it. Then to
283 write a register, first we have to ensure that the context contains
284 the other regs of the group, and then we copy the info in and set
287 static const int *mappings
;
289 /* The function to use in order to determine whether a register is
290 a segment register or not. */
291 static segment_register_p_ftype
*segment_register_p
;
293 /* See windows_nat_target::resume to understand why this is commented
296 /* This vector maps the target's idea of an exception (extracted
297 from the DEBUG_EVENT structure) to GDB's idea. */
299 struct xlate_exception
305 static const struct xlate_exception xlate
[] =
307 {EXCEPTION_ACCESS_VIOLATION
, GDB_SIGNAL_SEGV
},
308 {STATUS_STACK_OVERFLOW
, GDB_SIGNAL_SEGV
},
309 {EXCEPTION_BREAKPOINT
, GDB_SIGNAL_TRAP
},
310 {DBG_CONTROL_C
, GDB_SIGNAL_INT
},
311 {EXCEPTION_SINGLE_STEP
, GDB_SIGNAL_TRAP
},
312 {STATUS_FLOAT_DIVIDE_BY_ZERO
, GDB_SIGNAL_FPE
}
317 struct windows_nat_target final
: public x86_nat_target
<inf_child_target
>
319 void close () override
;
321 void attach (const char *, int) override
;
323 bool attach_no_wait () override
326 void detach (inferior
*, int) override
;
328 void resume (ptid_t
, int , enum gdb_signal
) override
;
330 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
332 void fetch_registers (struct regcache
*, int) override
;
333 void store_registers (struct regcache
*, int) override
;
335 bool stopped_by_sw_breakpoint () override
337 return current_windows_thread
->stopped_at_software_breakpoint
;
340 bool supports_stopped_by_sw_breakpoint () override
345 enum target_xfer_status
xfer_partial (enum target_object object
,
348 const gdb_byte
*writebuf
,
349 ULONGEST offset
, ULONGEST len
,
350 ULONGEST
*xfered_len
) override
;
352 void files_info () override
;
354 void kill () override
;
356 void create_inferior (const char *, const std::string
&,
357 char **, int) override
;
359 void mourn_inferior () override
;
361 bool thread_alive (ptid_t ptid
) override
;
363 std::string
pid_to_str (ptid_t
) override
;
365 void interrupt () override
;
367 char *pid_to_exec_file (int pid
) override
;
369 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
371 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
373 const char *thread_name (struct thread_info
*) override
;
375 int get_windows_debug_event (int pid
, struct target_waitstatus
*ourstatus
);
378 static windows_nat_target the_windows_nat_target
;
380 /* Set the MAPPINGS static global to OFFSETS.
381 See the description of MAPPINGS for more details. */
384 windows_set_context_register_offsets (const int *offsets
)
389 /* Set the function that should be used by this module to determine
390 whether a given register is a segment register or not. */
393 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
395 segment_register_p
= fun
;
399 check (BOOL ok
, const char *file
, int line
)
402 printf_filtered ("error return %s:%d was %u\n", file
, line
,
403 (unsigned) GetLastError ());
406 /* See nat/windows-nat.h. */
408 windows_thread_info
*
409 windows_nat::thread_rec (ptid_t ptid
, thread_disposition_type disposition
)
411 for (windows_thread_info
*th
: thread_list
)
412 if (th
->tid
== ptid
.lwp ())
418 case DONT_INVALIDATE_CONTEXT
:
421 case INVALIDATE_CONTEXT
:
422 if (ptid
.lwp () != current_event
.dwThreadId
)
424 th
->reload_context
= true;
427 th
->reload_context
= true;
438 /* Add a thread to the thread list.
440 PTID is the ptid of the thread to be added.
441 H is its Windows handle.
442 TLB is its thread local base.
443 MAIN_THREAD_P should be true if the thread to be added is
444 the main thread, false otherwise. */
446 static windows_thread_info
*
447 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
, bool main_thread_p
)
449 windows_thread_info
*th
;
451 gdb_assert (ptid
.lwp () != 0);
453 if ((th
= thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
)))
456 CORE_ADDR base
= (CORE_ADDR
) (uintptr_t) tlb
;
458 /* For WOW64 processes, this is actually the pointer to the 64bit TIB,
459 and the 32bit TIB is exactly 2 pages after it. */
463 th
= new windows_thread_info (ptid
.lwp (), h
, base
);
464 thread_list
.push_back (th
);
466 /* Add this new thread to the list of threads.
468 To be consistent with what's done on other platforms, we add
469 the main thread silently (in reality, this thread is really
470 more of a process to the user than a thread). */
472 add_thread_silent (&the_windows_nat_target
, ptid
);
474 add_thread (&the_windows_nat_target
, ptid
);
476 /* Set the debug registers for the new thread if they are used. */
477 if (debug_registers_used
)
482 /* Only change the value of the debug registers. */
483 th
->wow64_context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
484 CHECK (Wow64GetThreadContext (th
->h
, &th
->wow64_context
));
485 th
->wow64_context
.Dr0
= dr
[0];
486 th
->wow64_context
.Dr1
= dr
[1];
487 th
->wow64_context
.Dr2
= dr
[2];
488 th
->wow64_context
.Dr3
= dr
[3];
489 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
490 th
->wow64_context
.Dr7
= dr
[7];
491 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
492 th
->wow64_context
.ContextFlags
= 0;
497 /* Only change the value of the debug registers. */
498 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
499 CHECK (GetThreadContext (th
->h
, &th
->context
));
500 th
->context
.Dr0
= dr
[0];
501 th
->context
.Dr1
= dr
[1];
502 th
->context
.Dr2
= dr
[2];
503 th
->context
.Dr3
= dr
[3];
504 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
505 th
->context
.Dr7
= dr
[7];
506 CHECK (SetThreadContext (th
->h
, &th
->context
));
507 th
->context
.ContextFlags
= 0;
513 /* Clear out any old thread list and reinitialize it to a
516 windows_init_thread_list (void)
518 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
521 for (windows_thread_info
*here
: thread_list
)
524 thread_list
.clear ();
527 /* Delete a thread from the list of threads.
529 PTID is the ptid of the thread to be deleted.
530 EXIT_CODE is the thread's exit code.
531 MAIN_THREAD_P should be true if the thread to be deleted is
532 the main thread, false otherwise. */
535 windows_delete_thread (ptid_t ptid
, DWORD exit_code
, bool main_thread_p
)
539 gdb_assert (ptid
.lwp () != 0);
543 /* Emit a notification about the thread being deleted.
545 Note that no notification was printed when the main thread
546 was created, and thus, unless in verbose mode, we should be
547 symmetrical, and avoid that notification for the main thread
551 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
).c_str ());
552 else if (print_thread_events
&& !main_thread_p
)
553 printf_unfiltered (_("[%s exited with code %u]\n"),
554 target_pid_to_str (ptid
).c_str (),
555 (unsigned) exit_code
);
557 delete_thread (find_thread_ptid (&the_windows_nat_target
, ptid
));
559 auto iter
= std::find_if (thread_list
.begin (), thread_list
.end (),
560 [=] (windows_thread_info
*th
)
562 return th
->tid
== id
;
565 if (iter
!= thread_list
.end ())
568 thread_list
.erase (iter
);
572 /* Fetches register number R from the given windows_thread_info,
573 and supplies its value to the given regcache.
575 This function assumes that R is non-negative. A failed assertion
576 is raised if that is not true.
578 This function assumes that TH->RELOAD_CONTEXT is not set, meaning
579 that the windows_thread_info has an up-to-date context. A failed
580 assertion is raised if that assumption is violated. */
583 windows_fetch_one_register (struct regcache
*regcache
,
584 windows_thread_info
*th
, int r
)
587 gdb_assert (!th
->reload_context
);
589 char *context_ptr
= (char *) &th
->context
;
592 context_ptr
= (char *) &th
->wow64_context
;
595 char *context_offset
= context_ptr
+ mappings
[r
];
596 struct gdbarch
*gdbarch
= regcache
->arch ();
597 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
599 gdb_assert (!gdbarch_read_pc_p (gdbarch
));
600 gdb_assert (gdbarch_pc_regnum (gdbarch
) >= 0);
601 gdb_assert (!gdbarch_write_pc_p (gdbarch
));
603 if (r
== I387_FISEG_REGNUM (tdep
))
605 long l
= *((long *) context_offset
) & 0xffff;
606 regcache
->raw_supply (r
, (char *) &l
);
608 else if (r
== I387_FOP_REGNUM (tdep
))
610 long l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
611 regcache
->raw_supply (r
, (char *) &l
);
613 else if (segment_register_p (r
))
615 /* GDB treats segment registers as 32bit registers, but they are
616 in fact only 16 bits long. Make sure we do not read extra
617 bits from our source buffer. */
618 long l
= *((long *) context_offset
) & 0xffff;
619 regcache
->raw_supply (r
, (char *) &l
);
623 if (th
->stopped_at_software_breakpoint
624 && r
== gdbarch_pc_regnum (gdbarch
))
626 int size
= register_size (gdbarch
, r
);
630 memcpy (&value
, context_offset
, size
);
631 value
-= gdbarch_decr_pc_after_break (gdbarch
);
632 memcpy (context_offset
, &value
, size
);
636 gdb_assert (size
== 8);
638 memcpy (&value
, context_offset
, size
);
639 value
-= gdbarch_decr_pc_after_break (gdbarch
);
640 memcpy (context_offset
, &value
, size
);
643 regcache
->raw_supply (r
, context_offset
);
648 windows_nat_target::fetch_registers (struct regcache
*regcache
, int r
)
650 windows_thread_info
*th
= thread_rec (regcache
->ptid (), INVALIDATE_CONTEXT
);
652 /* Check if TH exists. Windows sometimes uses a non-existent
653 thread id in its events. */
657 if (th
->reload_context
)
660 if (have_saved_context
)
662 /* Lie about where the program actually is stopped since
663 cygwin has informed us that we should consider the signal
664 to have occurred at another location which is stored in
666 memcpy (&th
->context
, &saved_context
,
667 __COPY_CONTEXT_SIZE
);
668 have_saved_context
= 0;
675 th
->wow64_context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
676 CHECK (Wow64GetThreadContext (th
->h
, &th
->wow64_context
));
677 /* Copy dr values from that thread.
678 But only if there were not modified since last stop.
680 if (!debug_registers_changed
)
682 dr
[0] = th
->wow64_context
.Dr0
;
683 dr
[1] = th
->wow64_context
.Dr1
;
684 dr
[2] = th
->wow64_context
.Dr2
;
685 dr
[3] = th
->wow64_context
.Dr3
;
686 dr
[6] = th
->wow64_context
.Dr6
;
687 dr
[7] = th
->wow64_context
.Dr7
;
693 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
694 CHECK (GetThreadContext (th
->h
, &th
->context
));
695 /* Copy dr values from that thread.
696 But only if there were not modified since last stop.
698 if (!debug_registers_changed
)
700 dr
[0] = th
->context
.Dr0
;
701 dr
[1] = th
->context
.Dr1
;
702 dr
[2] = th
->context
.Dr2
;
703 dr
[3] = th
->context
.Dr3
;
704 dr
[6] = th
->context
.Dr6
;
705 dr
[7] = th
->context
.Dr7
;
708 th
->reload_context
= false;
712 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch()); r
++)
713 windows_fetch_one_register (regcache
, th
, r
);
715 windows_fetch_one_register (regcache
, th
, r
);
718 /* Collect the register number R from the given regcache, and store
719 its value into the corresponding area of the given thread's context.
721 This function assumes that R is non-negative. A failed assertion
722 assertion is raised if that is not true. */
725 windows_store_one_register (const struct regcache
*regcache
,
726 windows_thread_info
*th
, int r
)
730 char *context_ptr
= (char *) &th
->context
;
733 context_ptr
= (char *) &th
->wow64_context
;
736 regcache
->raw_collect (r
, context_ptr
+ mappings
[r
]);
739 /* Store a new register value into the context of the thread tied to
743 windows_nat_target::store_registers (struct regcache
*regcache
, int r
)
745 windows_thread_info
*th
= thread_rec (regcache
->ptid (), INVALIDATE_CONTEXT
);
747 /* Check if TH exists. Windows sometimes uses a non-existent
748 thread id in its events. */
753 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch ()); r
++)
754 windows_store_one_register (regcache
, th
, r
);
756 windows_store_one_register (regcache
, th
, r
);
759 /* Maintain a linked list of "so" information. */
760 struct lm_info_windows
: public lm_info_base
762 LPVOID load_addr
= 0;
763 CORE_ADDR text_offset
= 0;
766 static struct so_list solib_start
, *solib_end
;
768 static struct so_list
*
769 windows_make_so (const char *name
, LPVOID load_addr
)
776 WIN32_FIND_DATA w32_fd
;
777 HANDLE h
= FindFirstFile(name
, &w32_fd
);
779 if (h
== INVALID_HANDLE_VALUE
)
785 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
787 p
= strrchr (buf
, '\\');
790 SetCurrentDirectory (buf
);
791 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
792 SetCurrentDirectory (cwd
);
795 if (strcasecmp (buf
, "ntdll.dll") == 0)
797 GetSystemDirectory (buf
, sizeof (buf
));
798 strcat (buf
, "\\ntdll.dll");
801 cygwin_buf_t buf
[__PMAX
];
804 if (access (name
, F_OK
) != 0)
806 if (strcasecmp (name
, "ntdll.dll") == 0)
809 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
810 wcscat (buf
, L
"\\ntdll.dll");
814 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
815 strcat (buf
, "\\ntdll.dll");
820 so
= XCNEW (struct so_list
);
821 lm_info_windows
*li
= new lm_info_windows
;
823 li
->load_addr
= load_addr
;
824 strcpy (so
->so_original_name
, name
);
826 strcpy (so
->so_name
, buf
);
829 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
830 SO_NAME_MAX_PATH_SIZE
);
833 char *rname
= realpath (name
, NULL
);
834 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
836 strcpy (so
->so_name
, rname
);
840 error (_("dll path too long"));
842 /* Record cygwin1.dll .text start/end. */
843 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
844 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
846 asection
*text
= NULL
;
848 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386", -1));
853 if (bfd_check_format (abfd
.get (), bfd_object
))
854 text
= bfd_get_section_by_name (abfd
.get (), ".text");
859 /* The symbols in a dll are offset by 0x1000, which is the
860 offset from 0 of the first byte in an image - because of the
861 file header and the section alignment. */
862 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
864 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (text
);
871 /* See nat/windows-nat.h. */
874 windows_nat::handle_load_dll ()
876 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
877 const char *dll_name
;
879 /* Try getting the DLL name via the lpImageName field of the event.
880 Note that Microsoft documents this fields as strictly optional,
881 in the sense that it might be NULL. And the first DLL event in
882 particular is explicitly documented as "likely not pass[ed]"
883 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
884 dll_name
= get_image_name (current_process_handle
,
885 event
->lpImageName
, event
->fUnicode
);
889 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
890 solib_end
= solib_end
->next
;
892 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
894 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
895 host_address_to_string (li
->load_addr
)));
899 windows_free_so (struct so_list
*so
)
901 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
907 /* See nat/windows-nat.h. */
910 windows_nat::handle_unload_dll ()
912 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
915 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
917 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
919 if (li_next
->load_addr
== lpBaseOfDll
)
921 struct so_list
*sodel
= so
->next
;
923 so
->next
= sodel
->next
;
926 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
928 windows_free_so (sodel
);
933 /* We did not find any DLL that was previously loaded at this address,
934 so register a complaint. We do not report an error, because we have
935 observed that this may be happening under some circumstances. For
936 instance, running 32bit applications on x64 Windows causes us to receive
937 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
938 events are apparently caused by the WOW layer, the interface between
939 32bit and 64bit worlds). */
940 complaint (_("dll starting at %s not found."),
941 host_address_to_string (lpBaseOfDll
));
944 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
948 catch_errors (void (*func
) ())
954 catch (const gdb_exception
&ex
)
956 exception_print (gdb_stderr
, ex
);
960 /* Clear list of loaded DLLs. */
962 windows_clear_solib (void)
966 for (so
= solib_start
.next
; so
; so
= solib_start
.next
)
968 solib_start
.next
= so
->next
;
969 windows_free_so (so
);
972 solib_end
= &solib_start
;
976 signal_event_command (const char *args
, int from_tty
)
978 uintptr_t event_id
= 0;
979 char *endargs
= NULL
;
982 error (_("signal-event requires an argument (integer event id)"));
984 event_id
= strtoumax (args
, &endargs
, 10);
986 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
987 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
988 error (_("Failed to convert `%s' to event id"), args
);
990 SetEvent ((HANDLE
) event_id
);
991 CloseHandle ((HANDLE
) event_id
);
994 /* See nat/windows-nat.h. */
997 windows_nat::handle_output_debug_string (struct target_waitstatus
*ourstatus
)
999 gdb::unique_xmalloc_ptr
<char> s
;
1002 if (!target_read_string
1003 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
1005 || !s
|| !*(s
.get ()))
1006 /* nothing to do */;
1007 else if (!startswith (s
.get (), _CYGWIN_SIGNAL_STRING
))
1010 if (!startswith (s
.get (), "cYg"))
1013 char *p
= strchr (s
.get (), '\0');
1015 if (p
> s
.get () && *--p
== '\n')
1017 warning (("%s"), s
.get ());
1023 /* Got a cygwin signal marker. A cygwin signal is followed by
1024 the signal number itself and then optionally followed by the
1025 thread id and address to saved context within the DLL. If
1026 these are supplied, then the given thread is assumed to have
1027 issued the signal and the context from the thread is assumed
1028 to be stored at the given address in the inferior. Tell gdb
1029 to treat this like a real signal. */
1031 int sig
= strtol (s
.get () + sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
1032 gdb_signal gotasig
= gdb_signal_from_host (sig
);
1034 ourstatus
->value
.sig
= gotasig
;
1040 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1041 retval
= strtoul (p
, &p
, 0);
1043 retval
= current_event
.dwThreadId
;
1044 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
1045 && ReadProcessMemory (current_process_handle
, x
,
1047 __COPY_CONTEXT_SIZE
, &n
)
1048 && n
== __COPY_CONTEXT_SIZE
)
1049 have_saved_context
= 1;
1058 display_selector (HANDLE thread
, DWORD sel
)
1064 ret
= Wow64GetThreadSelectorEntry (thread
, sel
, &info
);
1067 ret
= GetThreadSelectorEntry (thread
, sel
, &info
);
1071 printf_filtered ("0x%03x: ", (unsigned) sel
);
1072 if (!info
.HighWord
.Bits
.Pres
)
1074 puts_filtered ("Segment not present\n");
1077 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1078 (info
.HighWord
.Bits
.BaseMid
<< 16)
1080 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1081 if (info
.HighWord
.Bits
.Granularity
)
1082 limit
= (limit
<< 12) | 0xfff;
1083 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1084 if (info
.HighWord
.Bits
.Default_Big
)
1085 puts_filtered(" 32-bit ");
1087 puts_filtered(" 16-bit ");
1088 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1091 puts_filtered ("Data (Read-Only, Exp-up");
1094 puts_filtered ("Data (Read/Write, Exp-up");
1097 puts_filtered ("Unused segment (");
1100 puts_filtered ("Data (Read/Write, Exp-down");
1103 puts_filtered ("Code (Exec-Only, N.Conf");
1106 puts_filtered ("Code (Exec/Read, N.Conf");
1109 puts_filtered ("Code (Exec-Only, Conf");
1112 puts_filtered ("Code (Exec/Read, Conf");
1115 printf_filtered ("Unknown type 0x%lx",
1116 (unsigned long) info
.HighWord
.Bits
.Type
);
1118 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1119 puts_filtered(", N.Acc");
1120 puts_filtered (")\n");
1121 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1122 puts_filtered("System selector ");
1123 printf_filtered ("Priviledge level = %ld. ",
1124 (unsigned long) info
.HighWord
.Bits
.Dpl
);
1125 if (info
.HighWord
.Bits
.Granularity
)
1126 puts_filtered ("Page granular.\n");
1128 puts_filtered ("Byte granular.\n");
1133 DWORD err
= GetLastError ();
1134 if (err
== ERROR_NOT_SUPPORTED
)
1135 printf_filtered ("Function not supported\n");
1137 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1143 display_selectors (const char * args
, int from_tty
)
1145 if (!current_windows_thread
)
1147 puts_filtered ("Impossible to display selectors now.\n");
1155 puts_filtered ("Selector $cs\n");
1156 display_selector (current_windows_thread
->h
,
1157 current_windows_thread
->wow64_context
.SegCs
);
1158 puts_filtered ("Selector $ds\n");
1159 display_selector (current_windows_thread
->h
,
1160 current_windows_thread
->wow64_context
.SegDs
);
1161 puts_filtered ("Selector $es\n");
1162 display_selector (current_windows_thread
->h
,
1163 current_windows_thread
->wow64_context
.SegEs
);
1164 puts_filtered ("Selector $ss\n");
1165 display_selector (current_windows_thread
->h
,
1166 current_windows_thread
->wow64_context
.SegSs
);
1167 puts_filtered ("Selector $fs\n");
1168 display_selector (current_windows_thread
->h
,
1169 current_windows_thread
->wow64_context
.SegFs
);
1170 puts_filtered ("Selector $gs\n");
1171 display_selector (current_windows_thread
->h
,
1172 current_windows_thread
->wow64_context
.SegGs
);
1177 puts_filtered ("Selector $cs\n");
1178 display_selector (current_windows_thread
->h
,
1179 current_windows_thread
->context
.SegCs
);
1180 puts_filtered ("Selector $ds\n");
1181 display_selector (current_windows_thread
->h
,
1182 current_windows_thread
->context
.SegDs
);
1183 puts_filtered ("Selector $es\n");
1184 display_selector (current_windows_thread
->h
,
1185 current_windows_thread
->context
.SegEs
);
1186 puts_filtered ("Selector $ss\n");
1187 display_selector (current_windows_thread
->h
,
1188 current_windows_thread
->context
.SegSs
);
1189 puts_filtered ("Selector $fs\n");
1190 display_selector (current_windows_thread
->h
,
1191 current_windows_thread
->context
.SegFs
);
1192 puts_filtered ("Selector $gs\n");
1193 display_selector (current_windows_thread
->h
,
1194 current_windows_thread
->context
.SegGs
);
1200 sel
= parse_and_eval_long (args
);
1201 printf_filtered ("Selector \"%s\"\n",args
);
1202 display_selector (current_windows_thread
->h
, sel
);
1206 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1207 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1208 host_address_to_string (\
1209 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1211 static handle_exception_result
1212 handle_exception (struct target_waitstatus
*ourstatus
)
1214 EXCEPTION_RECORD
*rec
= ¤t_event
.u
.Exception
.ExceptionRecord
;
1215 DWORD code
= rec
->ExceptionCode
;
1216 handle_exception_result result
= HANDLE_EXCEPTION_HANDLED
;
1218 memcpy (&siginfo_er
, rec
, sizeof siginfo_er
);
1220 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1222 /* Record the context of the current thread. */
1223 thread_rec (ptid_t (current_event
.dwProcessId
, current_event
.dwThreadId
, 0),
1228 case EXCEPTION_ACCESS_VIOLATION
:
1229 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1230 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1233 /* See if the access violation happened within the cygwin DLL
1234 itself. Cygwin uses a kind of exception handling to deal
1235 with passed-in invalid addresses. gdb should not treat
1236 these as real SEGVs since they will be silently handled by
1237 cygwin. A real SEGV will (theoretically) be caught by
1238 cygwin later in the process and will be sent as a
1239 cygwin-specific-signal. So, ignore SEGVs if they show up
1240 within the text segment of the DLL itself. */
1242 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1244 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1245 && addr
< cygwin_load_end
))
1246 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1247 && startswith (fn
, "KERNEL32!IsBad")))
1248 return HANDLE_EXCEPTION_UNHANDLED
;
1252 case STATUS_STACK_OVERFLOW
:
1253 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1254 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1256 case STATUS_FLOAT_DENORMAL_OPERAND
:
1257 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1258 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1260 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1261 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1262 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1264 case STATUS_FLOAT_INEXACT_RESULT
:
1265 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1266 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1268 case STATUS_FLOAT_INVALID_OPERATION
:
1269 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1270 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1272 case STATUS_FLOAT_OVERFLOW
:
1273 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1274 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1276 case STATUS_FLOAT_STACK_CHECK
:
1277 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1278 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1280 case STATUS_FLOAT_UNDERFLOW
:
1281 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1282 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1284 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1285 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1286 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1288 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1289 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1290 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1292 case STATUS_INTEGER_OVERFLOW
:
1293 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1294 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1296 case EXCEPTION_BREAKPOINT
:
1298 if (ignore_first_breakpoint
)
1300 /* For WOW64 processes, there are always 2 breakpoint exceptions
1301 on startup, first a BREAKPOINT for the 64bit ntdll.dll,
1302 then a WX86_BREAKPOINT for the 32bit ntdll.dll.
1303 Here we only care about the WX86_BREAKPOINT's. */
1304 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1305 ignore_first_breakpoint
= false;
1309 case STATUS_WX86_BREAKPOINT
:
1310 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1311 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1314 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1315 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1317 case DBG_CONTROL_BREAK
:
1318 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1319 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1321 case EXCEPTION_SINGLE_STEP
:
1322 case STATUS_WX86_SINGLE_STEP
:
1323 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1324 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1326 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1327 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1328 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1330 case EXCEPTION_PRIV_INSTRUCTION
:
1331 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1332 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1334 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1335 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1336 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1338 case MS_VC_EXCEPTION
:
1339 if (rec
->NumberParameters
>= 3
1340 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1342 DWORD named_thread_id
;
1343 windows_thread_info
*named_thread
;
1344 CORE_ADDR thread_name_target
;
1346 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1348 thread_name_target
= rec
->ExceptionInformation
[1];
1349 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1351 if (named_thread_id
== (DWORD
) -1)
1352 named_thread_id
= current_event
.dwThreadId
;
1354 named_thread
= thread_rec (ptid_t (current_event
.dwProcessId
,
1355 named_thread_id
, 0),
1356 DONT_INVALIDATE_CONTEXT
);
1357 if (named_thread
!= NULL
)
1359 int thread_name_len
;
1360 gdb::unique_xmalloc_ptr
<char> thread_name
;
1362 thread_name_len
= target_read_string (thread_name_target
,
1363 &thread_name
, 1025, NULL
);
1364 if (thread_name_len
> 0)
1366 thread_name
.get ()[thread_name_len
- 1] = '\0';
1367 named_thread
->name
= std::move (thread_name
);
1370 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1371 result
= HANDLE_EXCEPTION_IGNORED
;
1374 /* treat improperly formed exception as unknown */
1377 /* Treat unhandled first chance exceptions specially. */
1378 if (current_event
.u
.Exception
.dwFirstChance
)
1379 return HANDLE_EXCEPTION_UNHANDLED
;
1380 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1381 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1382 host_address_to_string (
1383 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1384 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1387 last_sig
= ourstatus
->value
.sig
;
1391 /* Resume thread specified by ID, or all artificially suspended
1392 threads, if we are continuing execution. KILLED non-zero means we
1393 have killed the inferior, so we should ignore weird errors due to
1394 threads shutting down. */
1396 windows_continue (DWORD continue_status
, int id
, int killed
)
1400 desired_stop_thread_id
= id
;
1402 /* If there are pending stops, and we might plausibly hit one of
1403 them, we don't want to actually continue the inferior -- we just
1404 want to report the stop. In this case, we just pretend to
1405 continue. See the comment by the definition of "pending_stops"
1406 for details on why this is needed. */
1407 for (const auto &item
: pending_stops
)
1409 if (desired_stop_thread_id
== -1
1410 || desired_stop_thread_id
== item
.thread_id
)
1412 DEBUG_EVENTS (("windows_continue - pending stop anticipated, "
1413 "desired=0x%x, item=0x%x\n",
1414 desired_stop_thread_id
, item
.thread_id
));
1419 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1420 (unsigned) last_wait_event
.dwProcessId
,
1421 (unsigned) last_wait_event
.dwThreadId
,
1422 continue_status
== DBG_CONTINUE
?
1423 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1425 for (windows_thread_info
*th
: thread_list
)
1426 if (id
== -1 || id
== (int) th
->tid
)
1433 if (debug_registers_changed
)
1435 th
->wow64_context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1436 th
->wow64_context
.Dr0
= dr
[0];
1437 th
->wow64_context
.Dr1
= dr
[1];
1438 th
->wow64_context
.Dr2
= dr
[2];
1439 th
->wow64_context
.Dr3
= dr
[3];
1440 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1441 th
->wow64_context
.Dr7
= dr
[7];
1443 if (th
->wow64_context
.ContextFlags
)
1447 if (GetExitCodeThread (th
->h
, &ec
)
1448 && ec
== STILL_ACTIVE
)
1450 BOOL status
= Wow64SetThreadContext (th
->h
,
1451 &th
->wow64_context
);
1456 th
->wow64_context
.ContextFlags
= 0;
1462 if (debug_registers_changed
)
1464 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1465 th
->context
.Dr0
= dr
[0];
1466 th
->context
.Dr1
= dr
[1];
1467 th
->context
.Dr2
= dr
[2];
1468 th
->context
.Dr3
= dr
[3];
1469 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1470 th
->context
.Dr7
= dr
[7];
1472 if (th
->context
.ContextFlags
)
1476 if (GetExitCodeThread (th
->h
, &ec
)
1477 && ec
== STILL_ACTIVE
)
1479 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1484 th
->context
.ContextFlags
= 0;
1491 /* When single-stepping a specific thread, other threads must
1496 res
= ContinueDebugEvent (last_wait_event
.dwProcessId
,
1497 last_wait_event
.dwThreadId
,
1501 error (_("Failed to resume program execution"
1502 " (ContinueDebugEvent failed, error %u)"),
1503 (unsigned int) GetLastError ());
1505 debug_registers_changed
= 0;
1509 /* Called in pathological case where Windows fails to send a
1510 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1512 fake_create_process (void)
1514 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1515 current_event
.dwProcessId
);
1516 if (current_process_handle
!= NULL
)
1517 open_process_used
= 1;
1520 error (_("OpenProcess call failed, GetLastError = %u"),
1521 (unsigned) GetLastError ());
1522 /* We can not debug anything in that case. */
1524 current_windows_thread
1525 = windows_add_thread (ptid_t (current_event
.dwProcessId
,
1526 current_event
.dwThreadId
, 0),
1527 current_event
.u
.CreateThread
.hThread
,
1528 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1529 true /* main_thread_p */);
1530 return current_event
.dwThreadId
;
1534 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1536 windows_thread_info
*th
;
1537 DWORD continue_status
= DBG_CONTINUE
;
1539 /* A specific PTID means `step only this thread id'. */
1540 int resume_all
= ptid
== minus_one_ptid
;
1542 /* If we're continuing all threads, it's the current inferior that
1543 should be handled specially. */
1545 ptid
= inferior_ptid
;
1547 if (sig
!= GDB_SIGNAL_0
)
1549 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1551 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1553 else if (sig
== last_sig
)
1554 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1557 /* This code does not seem to work, because
1558 the kernel does probably not consider changes in the ExceptionRecord
1559 structure when passing the exception to the inferior.
1560 Note that this seems possible in the exception handler itself. */
1562 for (const xlate_exception
&x
: xlate
)
1565 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1567 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1570 if (continue_status
== DBG_CONTINUE
)
1572 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1576 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1580 last_sig
= GDB_SIGNAL_0
;
1582 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=0x%x, step=%d, sig=%d);\n",
1583 ptid
.pid (), (unsigned) ptid
.lwp (), step
, sig
));
1585 /* Get context for currently selected thread. */
1586 th
= thread_rec (inferior_ptid
, DONT_INVALIDATE_CONTEXT
);
1594 /* Single step by setting t bit. */
1595 struct regcache
*regcache
= get_current_regcache ();
1596 struct gdbarch
*gdbarch
= regcache
->arch ();
1597 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1598 th
->wow64_context
.EFlags
|= FLAG_TRACE_BIT
;
1601 if (th
->wow64_context
.ContextFlags
)
1603 if (debug_registers_changed
)
1605 th
->wow64_context
.Dr0
= dr
[0];
1606 th
->wow64_context
.Dr1
= dr
[1];
1607 th
->wow64_context
.Dr2
= dr
[2];
1608 th
->wow64_context
.Dr3
= dr
[3];
1609 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1610 th
->wow64_context
.Dr7
= dr
[7];
1612 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
1613 th
->wow64_context
.ContextFlags
= 0;
1621 /* Single step by setting t bit. */
1622 struct regcache
*regcache
= get_current_regcache ();
1623 struct gdbarch
*gdbarch
= regcache
->arch ();
1624 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1625 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1628 if (th
->context
.ContextFlags
)
1630 if (debug_registers_changed
)
1632 th
->context
.Dr0
= dr
[0];
1633 th
->context
.Dr1
= dr
[1];
1634 th
->context
.Dr2
= dr
[2];
1635 th
->context
.Dr3
= dr
[3];
1636 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1637 th
->context
.Dr7
= dr
[7];
1639 CHECK (SetThreadContext (th
->h
, &th
->context
));
1640 th
->context
.ContextFlags
= 0;
1645 /* Allow continuing with the same signal that interrupted us.
1646 Otherwise complain. */
1649 windows_continue (continue_status
, -1, 0);
1651 windows_continue (continue_status
, ptid
.lwp (), 0);
1654 /* Ctrl-C handler used when the inferior is not run in the same console. The
1655 handler is in charge of interrupting the inferior using DebugBreakProcess.
1656 Note that this function is not available prior to Windows XP. In this case
1657 we emit a warning. */
1659 ctrl_c_handler (DWORD event_type
)
1661 const int attach_flag
= current_inferior ()->attach_flag
;
1663 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1664 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1667 /* If the inferior and the debugger share the same console, do nothing as
1668 the inferior has also received the Ctrl-C event. */
1669 if (!new_console
&& !attach_flag
)
1672 if (!DebugBreakProcess (current_process_handle
))
1673 warning (_("Could not interrupt program. "
1674 "Press Ctrl-c in the program console."));
1676 /* Return true to tell that Ctrl-C has been handled. */
1680 /* A wrapper for WaitForDebugEvent that sets "last_wait_event"
1683 wait_for_debug_event (DEBUG_EVENT
*event
, DWORD timeout
)
1685 BOOL result
= WaitForDebugEvent (event
, timeout
);
1687 last_wait_event
= *event
;
1691 /* Get the next event from the child. Returns a non-zero thread id if the event
1692 requires handling by WFI (or whatever). */
1695 windows_nat_target::get_windows_debug_event (int pid
,
1696 struct target_waitstatus
*ourstatus
)
1699 DWORD continue_status
, event_code
;
1700 windows_thread_info
*th
;
1701 static windows_thread_info
dummy_thread_info (0, 0, 0);
1702 DWORD thread_id
= 0;
1704 /* If there is a relevant pending stop, report it now. See the
1705 comment by the definition of "pending_stops" for details on why
1707 for (auto iter
= pending_stops
.begin ();
1708 iter
!= pending_stops
.end ();
1711 if (desired_stop_thread_id
== -1
1712 || desired_stop_thread_id
== iter
->thread_id
)
1714 thread_id
= iter
->thread_id
;
1715 *ourstatus
= iter
->status
;
1716 current_event
= iter
->event
;
1718 inferior_ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1719 current_windows_thread
= thread_rec (inferior_ptid
,
1720 INVALIDATE_CONTEXT
);
1721 current_windows_thread
->reload_context
= 1;
1723 DEBUG_EVENTS (("get_windows_debug_event - "
1724 "pending stop found in 0x%x (desired=0x%x)\n",
1725 thread_id
, desired_stop_thread_id
));
1727 pending_stops
.erase (iter
);
1732 last_sig
= GDB_SIGNAL_0
;
1734 if (!(debug_event
= wait_for_debug_event (¤t_event
, 1000)))
1737 continue_status
= DBG_CONTINUE
;
1739 event_code
= current_event
.dwDebugEventCode
;
1740 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1742 have_saved_context
= 0;
1746 case CREATE_THREAD_DEBUG_EVENT
:
1747 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1748 (unsigned) current_event
.dwProcessId
,
1749 (unsigned) current_event
.dwThreadId
,
1750 "CREATE_THREAD_DEBUG_EVENT"));
1751 if (saw_create
!= 1)
1753 inferior
*inf
= find_inferior_pid (this, current_event
.dwProcessId
);
1754 if (!saw_create
&& inf
->attach_flag
)
1756 /* Kludge around a Windows bug where first event is a create
1757 thread event. Caused when attached process does not have
1759 thread_id
= fake_create_process ();
1765 /* Record the existence of this thread. */
1766 thread_id
= current_event
.dwThreadId
;
1767 th
= windows_add_thread
1768 (ptid_t (current_event
.dwProcessId
, current_event
.dwThreadId
, 0),
1769 current_event
.u
.CreateThread
.hThread
,
1770 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1771 false /* main_thread_p */);
1775 case EXIT_THREAD_DEBUG_EVENT
:
1776 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1777 (unsigned) current_event
.dwProcessId
,
1778 (unsigned) current_event
.dwThreadId
,
1779 "EXIT_THREAD_DEBUG_EVENT"));
1780 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1781 current_event
.dwThreadId
, 0),
1782 current_event
.u
.ExitThread
.dwExitCode
,
1783 false /* main_thread_p */);
1784 th
= &dummy_thread_info
;
1787 case CREATE_PROCESS_DEBUG_EVENT
:
1788 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1789 (unsigned) current_event
.dwProcessId
,
1790 (unsigned) current_event
.dwThreadId
,
1791 "CREATE_PROCESS_DEBUG_EVENT"));
1792 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1793 if (++saw_create
!= 1)
1796 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1797 /* Add the main thread. */
1798 th
= windows_add_thread
1799 (ptid_t (current_event
.dwProcessId
,
1800 current_event
.dwThreadId
, 0),
1801 current_event
.u
.CreateProcessInfo
.hThread
,
1802 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
,
1803 true /* main_thread_p */);
1804 thread_id
= current_event
.dwThreadId
;
1807 case EXIT_PROCESS_DEBUG_EVENT
:
1808 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1809 (unsigned) current_event
.dwProcessId
,
1810 (unsigned) current_event
.dwThreadId
,
1811 "EXIT_PROCESS_DEBUG_EVENT"));
1812 if (!windows_initialization_done
)
1814 target_terminal::ours ();
1815 target_mourn_inferior (inferior_ptid
);
1816 error (_("During startup program exited with code 0x%x."),
1817 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1819 else if (saw_create
== 1)
1821 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1822 current_event
.dwThreadId
, 0),
1823 0, true /* main_thread_p */);
1824 DWORD exit_status
= current_event
.u
.ExitProcess
.dwExitCode
;
1825 /* If the exit status looks like a fatal exception, but we
1826 don't recognize the exception's code, make the original
1827 exit status value available, to avoid losing
1830 = WIFSIGNALED (exit_status
) ? WTERMSIG (exit_status
) : -1;
1831 if (exit_signal
== -1)
1833 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1834 ourstatus
->value
.integer
= exit_status
;
1838 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1839 ourstatus
->value
.sig
= gdb_signal_from_host (exit_signal
);
1841 thread_id
= current_event
.dwThreadId
;
1845 case LOAD_DLL_DEBUG_EVENT
:
1846 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1847 (unsigned) current_event
.dwProcessId
,
1848 (unsigned) current_event
.dwThreadId
,
1849 "LOAD_DLL_DEBUG_EVENT"));
1850 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1851 if (saw_create
!= 1 || ! windows_initialization_done
)
1853 catch_errors (handle_load_dll
);
1854 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1855 ourstatus
->value
.integer
= 0;
1856 thread_id
= current_event
.dwThreadId
;
1859 case UNLOAD_DLL_DEBUG_EVENT
:
1860 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1861 (unsigned) current_event
.dwProcessId
,
1862 (unsigned) current_event
.dwThreadId
,
1863 "UNLOAD_DLL_DEBUG_EVENT"));
1864 if (saw_create
!= 1 || ! windows_initialization_done
)
1866 catch_errors (handle_unload_dll
);
1867 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1868 ourstatus
->value
.integer
= 0;
1869 thread_id
= current_event
.dwThreadId
;
1872 case EXCEPTION_DEBUG_EVENT
:
1873 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1874 (unsigned) current_event
.dwProcessId
,
1875 (unsigned) current_event
.dwThreadId
,
1876 "EXCEPTION_DEBUG_EVENT"));
1877 if (saw_create
!= 1)
1879 switch (handle_exception (ourstatus
))
1881 case HANDLE_EXCEPTION_UNHANDLED
:
1883 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1885 case HANDLE_EXCEPTION_HANDLED
:
1886 thread_id
= current_event
.dwThreadId
;
1888 case HANDLE_EXCEPTION_IGNORED
:
1889 continue_status
= DBG_CONTINUE
;
1894 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1895 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1896 (unsigned) current_event
.dwProcessId
,
1897 (unsigned) current_event
.dwThreadId
,
1898 "OUTPUT_DEBUG_STRING_EVENT"));
1899 if (saw_create
!= 1)
1901 thread_id
= handle_output_debug_string (ourstatus
);
1905 if (saw_create
!= 1)
1907 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1908 (unsigned) current_event
.dwProcessId
,
1909 (unsigned) current_event
.dwThreadId
);
1910 printf_unfiltered (" unknown event code %u\n",
1911 (unsigned) current_event
.dwDebugEventCode
);
1915 if (!thread_id
|| saw_create
!= 1)
1917 CHECK (windows_continue (continue_status
, desired_stop_thread_id
, 0));
1919 else if (desired_stop_thread_id
!= -1 && desired_stop_thread_id
!= thread_id
)
1921 /* Pending stop. See the comment by the definition of
1922 "pending_stops" for details on why this is needed. */
1923 DEBUG_EVENTS (("get_windows_debug_event - "
1924 "unexpected stop in 0x%x (expecting 0x%x)\n",
1925 thread_id
, desired_stop_thread_id
));
1927 if (current_event
.dwDebugEventCode
== EXCEPTION_DEBUG_EVENT
1928 && (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1929 == EXCEPTION_BREAKPOINT
)
1930 && windows_initialization_done
)
1932 ptid_t ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1933 th
= thread_rec (ptid
, INVALIDATE_CONTEXT
);
1934 th
->stopped_at_software_breakpoint
= true;
1936 pending_stops
.push_back ({thread_id
, *ourstatus
, current_event
});
1938 CHECK (windows_continue (continue_status
, desired_stop_thread_id
, 0));
1942 inferior_ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1943 current_windows_thread
= th
;
1944 if (!current_windows_thread
)
1945 current_windows_thread
= thread_rec (inferior_ptid
,
1946 INVALIDATE_CONTEXT
);
1953 /* Wait for interesting events to occur in the target process. */
1955 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1960 /* We loop when we get a non-standard exception rather than return
1961 with a SPURIOUS because resume can try and step or modify things,
1962 which needs a current_thread->h. But some of these exceptions mark
1963 the birth or death of threads, which mean that the current thread
1964 isn't necessarily what you think it is. */
1970 /* If the user presses Ctrl-c while the debugger is waiting
1971 for an event, he expects the debugger to interrupt his program
1972 and to get the prompt back. There are two possible situations:
1974 - The debugger and the program do not share the console, in
1975 which case the Ctrl-c event only reached the debugger.
1976 In that case, the ctrl_c handler will take care of interrupting
1977 the inferior. Note that this case is working starting with
1978 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1981 - The debugger and the program share the same console, in which
1982 case both debugger and inferior will receive the Ctrl-c event.
1983 In that case the ctrl_c handler will ignore the event, as the
1984 Ctrl-c event generated inside the inferior will trigger the
1985 expected debug event.
1987 FIXME: brobecker/2008-05-20: If the inferior receives the
1988 signal first and the delay until GDB receives that signal
1989 is sufficiently long, GDB can sometimes receive the SIGINT
1990 after we have unblocked the CTRL+C handler. This would
1991 lead to the debugger stopping prematurely while handling
1992 the new-thread event that comes with the handling of the SIGINT
1993 inside the inferior, and then stop again immediately when
1994 the user tries to resume the execution in the inferior.
1995 This is a classic race that we should try to fix one day. */
1996 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1997 retval
= get_windows_debug_event (pid
, ourstatus
);
1998 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
2002 ptid_t result
= ptid_t (current_event
.dwProcessId
, retval
, 0);
2004 if (current_windows_thread
!= nullptr)
2006 current_windows_thread
->stopped_at_software_breakpoint
= false;
2007 if (current_event
.dwDebugEventCode
== EXCEPTION_DEBUG_EVENT
2008 && (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
2009 == EXCEPTION_BREAKPOINT
)
2010 && windows_initialization_done
)
2011 current_windows_thread
->stopped_at_software_breakpoint
= true;
2020 if (deprecated_ui_loop_hook
!= NULL
)
2021 detach
= deprecated_ui_loop_hook (0);
2029 /* Iterate over all DLLs currently mapped by our inferior, and
2030 add them to our list of solibs. */
2033 windows_add_all_dlls (void)
2035 HMODULE dummy_hmodule
;
2043 if (EnumProcessModulesEx (current_process_handle
, &dummy_hmodule
,
2044 sizeof (HMODULE
), &cb_needed
,
2045 LIST_MODULES_32BIT
) == 0)
2051 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
2052 sizeof (HMODULE
), &cb_needed
) == 0)
2059 hmodules
= (HMODULE
*) alloca (cb_needed
);
2063 if (EnumProcessModulesEx (current_process_handle
, hmodules
,
2064 cb_needed
, &cb_needed
,
2065 LIST_MODULES_32BIT
) == 0)
2071 if (EnumProcessModules (current_process_handle
, hmodules
,
2072 cb_needed
, &cb_needed
) == 0)
2076 char system_dir
[__PMAX
];
2077 char syswow_dir
[__PMAX
];
2078 size_t system_dir_len
= 0;
2079 bool convert_syswow_dir
= false;
2084 /* This fails on 32bit Windows because it has no SysWOW64 directory,
2085 and in this case a path conversion isn't necessary. */
2086 UINT len
= GetSystemWow64DirectoryA (syswow_dir
, sizeof (syswow_dir
));
2089 /* Check that we have passed a large enough buffer. */
2090 gdb_assert (len
< sizeof (syswow_dir
));
2092 len
= GetSystemDirectoryA (system_dir
, sizeof (system_dir
));
2094 gdb_assert (len
!= 0);
2095 /* Check that we have passed a large enough buffer. */
2096 gdb_assert (len
< sizeof (system_dir
));
2098 strcat (system_dir
, "\\");
2099 strcat (syswow_dir
, "\\");
2100 system_dir_len
= strlen (system_dir
);
2102 convert_syswow_dir
= true;
2106 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
2110 wchar_t dll_name
[__PMAX
];
2111 char dll_name_mb
[__PMAX
];
2113 char dll_name
[__PMAX
];
2116 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
2117 &mi
, sizeof (mi
)) == 0)
2119 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
2120 dll_name
, sizeof (dll_name
)) == 0)
2123 wcstombs (dll_name_mb
, dll_name
, __PMAX
);
2128 /* Convert the DLL path of 32bit processes returned by
2129 GetModuleFileNameEx from the 64bit system directory to the
2130 32bit syswow64 directory if necessary. */
2131 std::string syswow_dll_path
;
2132 if (convert_syswow_dir
2133 && strncasecmp (name
, system_dir
, system_dir_len
) == 0
2134 && strchr (name
+ system_dir_len
, '\\') == nullptr)
2136 syswow_dll_path
= syswow_dir
;
2137 syswow_dll_path
+= name
+ system_dir_len
;
2138 name
= syswow_dll_path
.c_str();
2141 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
2142 solib_end
= solib_end
->next
;
2147 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
2150 struct inferior
*inf
;
2152 last_sig
= GDB_SIGNAL_0
;
2153 open_process_used
= 0;
2154 debug_registers_changed
= 0;
2155 debug_registers_used
= 0;
2156 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
2159 cygwin_load_start
= cygwin_load_end
= 0;
2161 current_event
.dwProcessId
= pid
;
2162 memset (¤t_event
, 0, sizeof (current_event
));
2163 if (!target_is_pushed (ops
))
2165 disable_breakpoints_in_shlibs ();
2166 windows_clear_solib ();
2167 clear_proceed_status (0);
2168 init_wait_for_inferior ();
2171 ignore_first_breakpoint
= !attaching
&& wow64_process
;
2175 windows_set_context_register_offsets (amd64_mappings
);
2176 windows_set_segment_register_p (amd64_windows_segment_register_p
);
2181 windows_set_context_register_offsets (i386_mappings
);
2182 windows_set_segment_register_p (i386_windows_segment_register_p
);
2185 inf
= current_inferior ();
2186 inferior_appeared (inf
, pid
);
2187 inf
->attach_flag
= attaching
;
2189 /* Make the new process the current inferior, so terminal handling
2190 can rely on it. When attaching, we don't know about any thread
2191 id here, but that's OK --- nothing should be referencing the
2192 current thread until we report an event out of windows_wait. */
2193 inferior_ptid
= ptid_t (pid
);
2195 target_terminal::init ();
2196 target_terminal::inferior ();
2198 windows_initialization_done
= 0;
2202 struct target_waitstatus status
;
2204 ops
->wait (minus_one_ptid
, &status
, 0);
2206 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
2208 if (status
.kind
!= TARGET_WAITKIND_LOADED
2209 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
2212 ops
->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
2215 /* Now that the inferior has been started and all DLLs have been mapped,
2216 we can iterate over all DLLs and load them in.
2218 We avoid doing it any earlier because, on certain versions of Windows,
2219 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
2220 we have seen on Windows 8.1 that the ntdll.dll load event does not
2221 include the DLL name, preventing us from creating an associated SO.
2222 A possible explanation is that ntdll.dll might be mapped before
2223 the SO info gets created by the Windows system -- ntdll.dll is
2224 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
2225 do not seem to suffer from that problem.
2227 Rather than try to work around this sort of issue, it is much
2228 simpler to just ignore DLL load/unload events during the startup
2229 phase, and then process them all in one batch now. */
2230 windows_add_all_dlls ();
2232 windows_initialization_done
= 1;
2236 /* Try to set or remove a user privilege to the current process. Return -1
2237 if that fails, the previous setting of that privilege otherwise.
2239 This code is copied from the Cygwin source code and rearranged to allow
2240 dynamically loading of the needed symbols from advapi32 which is only
2241 available on NT/2K/XP. */
2243 set_process_privilege (const char *privilege
, BOOL enable
)
2245 HANDLE token_hdl
= NULL
;
2247 TOKEN_PRIVILEGES new_priv
, orig_priv
;
2251 if (!OpenProcessToken (GetCurrentProcess (),
2252 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
2256 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
2259 new_priv
.PrivilegeCount
= 1;
2260 new_priv
.Privileges
[0].Luid
= restore_priv
;
2261 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
2263 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
2264 sizeof orig_priv
, &orig_priv
, &size
))
2267 /* Disabled, otherwise every `attach' in an unprivileged user session
2268 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
2269 windows_attach(). */
2270 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
2271 be enabled. GetLastError () returns an correct error code, though. */
2272 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
2276 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
2280 CloseHandle (token_hdl
);
2285 /* Attach to process PID, then initialize for debugging it. */
2288 windows_nat_target::attach (const char *args
, int from_tty
)
2293 pid
= parse_pid_to_attach (args
);
2295 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
2297 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
2298 printf_unfiltered ("This can cause attach to "
2299 "fail on Windows NT/2K/XP\n");
2302 windows_init_thread_list ();
2303 ok
= DebugActiveProcess (pid
);
2309 /* Try fall back to Cygwin pid. */
2310 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
2313 ok
= DebugActiveProcess (pid
);
2318 error (_("Can't attach to process %u (error %u)"),
2319 (unsigned) pid
, (unsigned) GetLastError ());
2321 DebugSetProcessKillOnExit (FALSE
);
2325 const char *exec_file
= get_exec_file (0);
2328 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
2329 target_pid_to_str (ptid_t (pid
)).c_str ());
2331 printf_unfiltered ("Attaching to %s\n",
2332 target_pid_to_str (ptid_t (pid
)).c_str ());
2336 HANDLE h
= OpenProcess (PROCESS_QUERY_INFORMATION
, FALSE
, pid
);
2340 if (IsWow64Process (h
, &wow64
))
2341 wow64_process
= wow64
;
2346 do_initial_windows_stuff (this, pid
, 1);
2347 target_terminal::ours ();
2351 windows_nat_target::detach (inferior
*inf
, int from_tty
)
2355 ptid_t ptid
= minus_one_ptid
;
2356 resume (ptid
, 0, GDB_SIGNAL_0
);
2358 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
2360 error (_("Can't detach process %u (error %u)"),
2361 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
2364 DebugSetProcessKillOnExit (FALSE
);
2366 if (detached
&& from_tty
)
2368 const char *exec_file
= get_exec_file (0);
2371 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
2372 (unsigned) current_event
.dwProcessId
);
2375 x86_cleanup_dregs ();
2376 inferior_ptid
= null_ptid
;
2377 detach_inferior (inf
);
2379 maybe_unpush_target ();
2382 /* Try to determine the executable filename.
2384 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2386 Upon success, the filename is stored inside EXE_NAME_RET, and
2387 this function returns nonzero.
2389 Otherwise, this function returns zero and the contents of
2390 EXE_NAME_RET is undefined. */
2393 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2403 if (!EnumProcessModulesEx (current_process_handle
, &dh_buf
,
2404 sizeof (HMODULE
), &cbNeeded
,
2405 LIST_MODULES_32BIT
) || !cbNeeded
)
2411 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2412 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2416 /* We know the executable is always first in the list of modules,
2417 which we just fetched. So no need to fetch more. */
2421 /* Cygwin prefers that the path be in /x/y/z format, so extract
2422 the filename into a temporary buffer first, and then convert it
2423 to POSIX format into the destination buffer. */
2424 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2426 len
= GetModuleFileNameEx (current_process_handle
,
2427 dh_buf
, pathbuf
, exe_name_max_len
);
2429 error (_("Error getting executable filename: %u."),
2430 (unsigned) GetLastError ());
2431 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2432 exe_name_max_len
) < 0)
2433 error (_("Error converting executable filename to POSIX: %d."), errno
);
2436 len
= GetModuleFileNameEx (current_process_handle
,
2437 dh_buf
, exe_name_ret
, exe_name_max_len
);
2439 error (_("Error getting executable filename: %u."),
2440 (unsigned) GetLastError ());
2443 return 1; /* success */
2446 /* The pid_to_exec_file target_ops method for this platform. */
2449 windows_nat_target::pid_to_exec_file (int pid
)
2451 static char path
[__PMAX
];
2453 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2455 char procexe
[sizeof ("/proc/4294967295/exe")];
2457 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2458 nchars
= readlink (procexe
, path
, sizeof(path
));
2459 if (nchars
> 0 && nchars
< sizeof (path
))
2461 path
[nchars
] = '\0'; /* Got it */
2466 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2467 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2468 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2474 /* Print status information about what we're accessing. */
2477 windows_nat_target::files_info ()
2479 struct inferior
*inf
= current_inferior ();
2481 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2482 inf
->attach_flag
? "attached" : "child",
2483 target_pid_to_str (inferior_ptid
).c_str ());
2486 /* Modify CreateProcess parameters for use of a new separate console.
2488 *FLAGS: DWORD parameter for general process creation flags.
2489 *SI: STARTUPINFO structure, for which the console window size and
2490 console buffer size is filled in if GDB is running in a console.
2491 to create the new console.
2492 The size of the used font is not available on all versions of
2493 Windows OS. Furthermore, the current font might not be the default
2494 font, but this is still better than before.
2495 If the windows and buffer sizes are computed,
2496 SI->DWFLAGS is changed so that this information is used
2497 by CreateProcess function. */
2500 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2502 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2503 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2505 if (hconsole
!= INVALID_HANDLE_VALUE
)
2507 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2509 CONSOLE_FONT_INFO cfi
;
2511 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2512 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2513 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2514 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2515 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2517 si
->dwXSize
*= font_size
.X
;
2521 si
->dwYSize
*= font_size
.Y
;
2524 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2525 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2526 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2528 *flags
|= CREATE_NEW_CONSOLE
;
2532 /* Function called by qsort to sort environment strings. */
2535 envvar_cmp (const void *a
, const void *b
)
2537 const char **p
= (const char **) a
;
2538 const char **q
= (const char **) b
;
2539 return strcasecmp (*p
, *q
);
2545 clear_win32_environment (char **env
)
2549 wchar_t *copy
= NULL
, *equalpos
;
2551 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2553 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2554 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2555 mbstowcs (copy
, env
[i
], len
);
2556 equalpos
= wcschr (copy
, L
'=');
2559 SetEnvironmentVariableW (copy
, NULL
);
2567 /* Redirection of inferior I/O streams for native MS-Windows programs.
2568 Unlike on Unix, where this is handled by invoking the inferior via
2569 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2571 The official documentation of the cmd.exe redirection features is here:
2573 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2575 (That page talks about Windows XP, but there's no newer
2576 documentation, so we assume later versions of cmd.exe didn't change
2579 Caveat: the documentation on that page seems to include a few lies.
2580 For example, it describes strange constructs 1<&2 and 2<&1, which
2581 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2582 think the cmd.exe parser of the redirection symbols simply doesn't
2583 care about the < vs > distinction in these cases. Therefore, the
2584 supported features are explicitly documented below.
2586 The emulation below aims at supporting all the valid use cases
2587 supported by cmd.exe, which include:
2589 < FILE redirect standard input from FILE
2590 0< FILE redirect standard input from FILE
2591 <&N redirect standard input from file descriptor N
2592 0<&N redirect standard input from file descriptor N
2593 > FILE redirect standard output to FILE
2594 >> FILE append standard output to FILE
2595 1>> FILE append standard output to FILE
2596 >&N redirect standard output to file descriptor N
2597 1>&N redirect standard output to file descriptor N
2598 >>&N append standard output to file descriptor N
2599 1>>&N append standard output to file descriptor N
2600 2> FILE redirect standard error to FILE
2601 2>> FILE append standard error to FILE
2602 2>&N redirect standard error to file descriptor N
2603 2>>&N append standard error to file descriptor N
2605 Note that using N > 2 in the above construct is supported, but
2606 requires that the corresponding file descriptor be open by some
2607 means elsewhere or outside GDB. Also note that using ">&0" or
2608 "<&2" will generally fail, because the file descriptor redirected
2609 from is normally open in an incompatible mode (e.g., FD 0 is open
2610 for reading only). IOW, use of such tricks is not recommended;
2611 you are on your own.
2613 We do NOT support redirection of file descriptors above 2, as in
2614 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2615 that needs special handling in the startup code that MinGW
2616 doesn't have). Pipes are also not supported.
2618 As for invalid use cases, where the redirection contains some
2619 error, the emulation below will detect that and produce some
2620 error and/or failure. But the behavior in those cases is not
2621 bug-for-bug compatible with what cmd.exe does in those cases.
2622 That's because what cmd.exe does then is not well defined, and
2623 seems to be a side effect of the cmd.exe parsing of the command
2624 line more than anything else. For example, try redirecting to an
2625 invalid file name, as in "> foo:bar".
2627 There are also minor syntactic deviations from what cmd.exe does
2628 in some corner cases. For example, it doesn't support the likes
2629 of "> &foo" to mean redirect to file named literally "&foo"; we
2630 do support that here, because that, too, sounds like some issue
2631 with the cmd.exe parser. Another nicety is that we support
2632 redirection targets that use file names with forward slashes,
2633 something cmd.exe doesn't -- this comes in handy since GDB
2634 file-name completion can be used when typing the command line for
2637 /* Support routines for redirecting standard handles of the inferior. */
2639 /* Parse a single redirection spec, open/duplicate the specified
2640 file/fd, and assign the appropriate value to one of the 3 standard
2641 file descriptors. */
2643 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2645 int *fd
, ref_fd
= -2;
2647 const char *fname
= redir_string
+ 1;
2648 int rc
= *redir_string
;
2663 fd
= (rc
== '2') ? err
: out
;
2664 mode
= O_WRONLY
| O_CREAT
;
2677 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2679 /* A reference to a file descriptor. */
2681 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2682 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2684 /* Don't allow redirection when open modes are incompatible. */
2685 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2686 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2693 else if (ref_fd
== 1)
2695 else if (ref_fd
== 2)
2705 fname
++; /* skip the separator space */
2706 /* If the descriptor is already open, close it. This allows
2707 multiple specs of redirections for the same stream, which is
2708 somewhat nonsensical, but still valid and supported by cmd.exe.
2709 (But cmd.exe only opens a single file in this case, the one
2710 specified by the last redirection spec on the command line.) */
2715 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2719 else if (ref_fd
== -1)
2720 *fd
= -1; /* reset to default destination */
2723 *fd
= _dup (ref_fd
);
2727 /* _open just sets a flag for O_APPEND, which won't be passed to the
2728 inferior, so we need to actually move the file pointer. */
2729 if ((mode
& O_APPEND
) != 0)
2730 _lseek (*fd
, 0L, SEEK_END
);
2734 /* Canonicalize a single redirection spec and set up the corresponding
2735 file descriptor as specified. */
2737 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2739 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2741 const char *start
= s
;
2744 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2745 if ((*start
== '>' || *start
== '1' || *start
== '2')
2749 if (*s
== '>' && *start
!= '>')
2752 else if (*start
== '0' && *s
== '<')
2754 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2757 while (isspace (*s
)) /* skip whitespace before file name */
2759 *d
++ = ' '; /* separate file name with a single space */
2762 /* Copy the file name. */
2765 /* Remove quoting characters from the file name in buf[]. */
2766 if (*s
== '"') /* could support '..' quoting here */
2770 else if (*s
== quote
)
2778 else if (*s
== '\\')
2780 if (s
[1] == '"') /* could support '..' here */
2784 else if (isspace (*s
) && !quote
)
2788 if (d
- buf
>= sizeof (buf
) - 1)
2790 errno
= ENAMETOOLONG
;
2796 /* Windows doesn't allow redirection characters in file names, so we
2797 can bail out early if they use them, or if there's no target file
2798 name after the redirection symbol. */
2799 if (d
[-1] == '>' || d
[-1] == '<')
2804 if (redir_open (buf
, inp
, out
, err
) == 0)
2809 /* Parse the command line for redirection specs and prepare the file
2810 descriptors for the 3 standard streams accordingly. */
2812 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2813 int *inp
, int *out
, int *err
)
2815 const char *s
= cmd_orig
;
2818 bool retval
= false;
2820 while (isspace (*s
))
2825 if (*s
== '"') /* could also support '..' quoting here */
2829 else if (*s
== quote
)
2832 else if (*s
== '\\')
2834 if (s
[1] == '"') /* escaped quote char */
2839 /* Process a single redirection candidate. */
2840 if (*s
== '<' || *s
== '>'
2841 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2842 || (*s
== '0' && s
[1] == '<'))
2844 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2858 #endif /* !__CYGWIN__ */
2860 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2861 EXEC_FILE is the file to run.
2862 ALLARGS is a string containing the arguments to the program.
2863 ENV is the environment vector to pass. Errors reported with error(). */
2866 windows_nat_target::create_inferior (const char *exec_file
,
2867 const std::string
&origallargs
,
2868 char **in_env
, int from_tty
)
2872 cygwin_buf_t real_path
[__PMAX
];
2873 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2874 cygwin_buf_t infcwd
[__PMAX
];
2876 cygwin_buf_t
*toexec
;
2877 cygwin_buf_t
*cygallargs
;
2879 char **old_env
= NULL
;
2883 int ostdin
, ostdout
, ostderr
;
2884 #else /* !__CYGWIN__ */
2885 char shell
[__PMAX
]; /* Path to shell */
2887 char *args
, *allargs_copy
;
2888 size_t args_len
, allargs_len
;
2889 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2890 HANDLE tty
= INVALID_HANDLE_VALUE
;
2891 bool redirected
= false;
2898 #endif /* !__CYGWIN__ */
2899 const char *allargs
= origallargs
.c_str ();
2900 PROCESS_INFORMATION pi
;
2903 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2906 error (_("No executable specified, use `target exec'."));
2908 const char *inferior_cwd
= get_inferior_cwd ();
2909 std::string expanded_infcwd
;
2910 if (inferior_cwd
!= NULL
)
2912 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
2913 /* Mirror slashes on inferior's cwd. */
2914 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
2916 inferior_cwd
= expanded_infcwd
.c_str ();
2919 memset (&si
, 0, sizeof (si
));
2920 si
.cb
= sizeof (si
);
2923 flags
|= CREATE_NEW_PROCESS_GROUP
;
2926 windows_set_console_info (&si
, &flags
);
2931 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2932 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2933 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2934 error (_("Error starting executable: %d"), errno
);
2937 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2938 if (len
== (size_t) -1)
2939 error (_("Error starting executable: %d"), errno
);
2940 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2941 mbstowcs (cygallargs
, allargs
, len
);
2942 #else /* !__USEWIDE */
2943 cygallargs
= allargs
;
2949 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2950 error (_("Error starting executable via shell: %d"), errno
);
2952 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2953 + mbstowcs (NULL
, allargs
, 0) + 2;
2954 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2955 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2956 #else /* !__USEWIDE */
2957 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2958 + strlen (allargs
) + 2);
2959 cygallargs
= (char *) alloca (len
);
2960 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2961 #endif /* __USEWIDE */
2963 flags
|= DEBUG_PROCESS
;
2966 if (inferior_cwd
!= NULL
2967 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
2968 infcwd
, strlen (inferior_cwd
)) < 0)
2969 error (_("Error converting inferior cwd: %d"), errno
);
2972 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2973 * sizeof (wchar_t));
2974 wcscpy (args
, toexec
);
2975 wcscat (args
, L
" ");
2976 wcscat (args
, cygallargs
);
2977 #else /* !__USEWIDE */
2978 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2979 strcpy (args
, toexec
);
2981 strcat (args
, cygallargs
);
2982 #endif /* !__USEWIDE */
2984 #ifdef CW_CVT_ENV_TO_WINENV
2985 /* First try to create a direct Win32 copy of the POSIX environment. */
2986 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2987 if (w32_env
!= (PWCHAR
) -1)
2988 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2990 /* If that fails, fall back to old method tweaking GDB's environment. */
2991 #endif /* CW_CVT_ENV_TO_WINENV */
2993 /* Reset all Win32 environment variables to avoid leftover on next run. */
2994 clear_win32_environment (environ
);
2995 /* Prepare the environment vars for CreateProcess. */
2998 cygwin_internal (CW_SYNC_WINENV
);
3002 if (!inferior_io_terminal
)
3003 tty
= ostdin
= ostdout
= ostderr
= -1;
3006 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
3009 print_sys_errmsg (inferior_io_terminal
, errno
);
3010 ostdin
= ostdout
= ostderr
= -1;
3023 windows_init_thread_list ();
3024 ret
= CreateProcess (0,
3025 args
, /* command line */
3026 NULL
, /* Security */
3028 TRUE
, /* inherit handles */
3029 flags
, /* start flags */
3030 w32_env
, /* environment */
3031 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
3036 /* Just free the Win32 environment, if it could be created. */
3040 /* Reset all environment variables to avoid leftover on next run. */
3041 clear_win32_environment (in_env
);
3042 /* Restore normal GDB environment variables. */
3044 cygwin_internal (CW_SYNC_WINENV
);
3057 #else /* !__CYGWIN__ */
3058 allargs_len
= strlen (allargs
);
3059 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
3060 if (strpbrk (allargs_copy
, "<>") != NULL
)
3065 redirect_inferior_handles (allargs
, allargs_copy
,
3066 &fd_inp
, &fd_out
, &fd_err
);
3068 warning (_("Error in redirection: %s."), safe_strerror (errno
));
3071 allargs_len
= strlen (allargs_copy
);
3073 /* If not all the standard streams are redirected by the command
3074 line, use inferior_io_terminal for those which aren't. */
3075 if (inferior_io_terminal
3076 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
3078 SECURITY_ATTRIBUTES sa
;
3079 sa
.nLength
= sizeof(sa
);
3080 sa
.lpSecurityDescriptor
= 0;
3081 sa
.bInheritHandle
= TRUE
;
3082 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
3083 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
3084 if (tty
== INVALID_HANDLE_VALUE
)
3085 warning (_("Warning: Failed to open TTY %s, error %#x."),
3086 inferior_io_terminal
, (unsigned) GetLastError ());
3088 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
3091 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
3092 else if (tty
!= INVALID_HANDLE_VALUE
)
3095 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
3097 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
3098 else if (tty
!= INVALID_HANDLE_VALUE
)
3099 si
.hStdOutput
= tty
;
3101 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
3103 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
3104 else if (tty
!= INVALID_HANDLE_VALUE
)
3107 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
3108 si
.dwFlags
|= STARTF_USESTDHANDLES
;
3112 /* Build the command line, a space-separated list of tokens where
3113 the first token is the name of the module to be executed.
3114 To avoid ambiguities introduced by spaces in the module name,
3116 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
3117 args
= (char *) alloca (args_len
);
3118 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
3120 flags
|= DEBUG_ONLY_THIS_PROCESS
;
3122 /* CreateProcess takes the environment list as a null terminated set of
3123 strings (i.e. two nulls terminate the list). */
3125 /* Get total size for env strings. */
3126 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
3127 envlen
+= strlen (in_env
[i
]) + 1;
3129 envsize
= sizeof (in_env
[0]) * (i
+ 1);
3130 env
= (char **) alloca (envsize
);
3131 memcpy (env
, in_env
, envsize
);
3132 /* Windows programs expect the environment block to be sorted. */
3133 qsort (env
, i
, sizeof (char *), envvar_cmp
);
3135 w32env
= (char *) alloca (envlen
+ 1);
3137 /* Copy env strings into new buffer. */
3138 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
3140 strcpy (temp
, env
[i
]);
3141 temp
+= strlen (temp
) + 1;
3144 /* Final nil string to terminate new env. */
3147 windows_init_thread_list ();
3148 ret
= CreateProcessA (0,
3149 args
, /* command line */
3150 NULL
, /* Security */
3152 TRUE
, /* inherit handles */
3153 flags
, /* start flags */
3154 w32env
, /* environment */
3155 inferior_cwd
, /* current directory */
3158 if (tty
!= INVALID_HANDLE_VALUE
)
3166 #endif /* !__CYGWIN__ */
3169 error (_("Error creating process %s, (error %u)."),
3170 exec_file
, (unsigned) GetLastError ());
3174 if (IsWow64Process (pi
.hProcess
, &wow64
))
3175 wow64_process
= wow64
;
3178 CloseHandle (pi
.hThread
);
3179 CloseHandle (pi
.hProcess
);
3181 if (useshell
&& shell
[0] != '\0')
3186 do_initial_windows_stuff (this, pi
.dwProcessId
, 0);
3188 /* windows_continue (DBG_CONTINUE, -1, 0); */
3192 windows_nat_target::mourn_inferior ()
3194 (void) windows_continue (DBG_CONTINUE
, -1, 0);
3195 x86_cleanup_dregs();
3196 if (open_process_used
)
3198 CHECK (CloseHandle (current_process_handle
));
3199 open_process_used
= 0;
3201 siginfo_er
.ExceptionCode
= 0;
3202 inf_child_target::mourn_inferior ();
3205 /* Send a SIGINT to the process group. This acts just like the user typed a
3206 ^C on the controlling terminal. */
3209 windows_nat_target::interrupt ()
3211 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
3212 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
3213 registers_changed (); /* refresh register state */
3216 /* Helper for windows_xfer_partial that handles memory transfers.
3217 Arguments are like target_xfer_partial. */
3219 static enum target_xfer_status
3220 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3221 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
3225 DWORD lasterror
= 0;
3227 if (writebuf
!= NULL
)
3229 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
3230 pulongest (len
), core_addr_to_string (memaddr
)));
3231 success
= WriteProcessMemory (current_process_handle
,
3232 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
3235 lasterror
= GetLastError ();
3236 FlushInstructionCache (current_process_handle
,
3237 (LPCVOID
) (uintptr_t) memaddr
, len
);
3241 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
3242 pulongest (len
), core_addr_to_string (memaddr
)));
3243 success
= ReadProcessMemory (current_process_handle
,
3244 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
3247 lasterror
= GetLastError ();
3249 *xfered_len
= (ULONGEST
) done
;
3250 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
3251 return TARGET_XFER_OK
;
3253 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
3257 windows_nat_target::kill ()
3259 CHECK (TerminateProcess (current_process_handle
, 0));
3263 if (!windows_continue (DBG_CONTINUE
, -1, 1))
3265 if (!wait_for_debug_event (¤t_event
, INFINITE
))
3267 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
3271 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
3275 windows_nat_target::close ()
3277 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
3278 inferior_ptid
.pid ()));
3281 /* Convert pid to printable format. */
3283 windows_nat_target::pid_to_str (ptid_t ptid
)
3285 if (ptid
.lwp () != 0)
3286 return string_printf ("Thread %d.0x%lx", ptid
.pid (), ptid
.lwp ());
3288 return normal_pid_to_str (ptid
);
3291 static enum target_xfer_status
3292 windows_xfer_shared_libraries (struct target_ops
*ops
,
3293 enum target_object object
, const char *annex
,
3294 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3295 ULONGEST offset
, ULONGEST len
,
3296 ULONGEST
*xfered_len
)
3298 struct obstack obstack
;
3304 return TARGET_XFER_E_IO
;
3306 obstack_init (&obstack
);
3307 obstack_grow_str (&obstack
, "<library-list>\n");
3308 for (so
= solib_start
.next
; so
; so
= so
->next
)
3310 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
3312 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
3313 (uintptr_t) li
->load_addr
,
3315 target_gdbarch (), &obstack
);
3317 obstack_grow_str0 (&obstack
, "</library-list>\n");
3319 buf
= (const char *) obstack_finish (&obstack
);
3320 len_avail
= strlen (buf
);
3321 if (offset
>= len_avail
)
3325 if (len
> len_avail
- offset
)
3326 len
= len_avail
- offset
;
3327 memcpy (readbuf
, buf
+ offset
, len
);
3330 obstack_free (&obstack
, NULL
);
3331 *xfered_len
= (ULONGEST
) len
;
3332 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
3335 /* Helper for windows_nat_target::xfer_partial that handles signal info. */
3337 static enum target_xfer_status
3338 windows_xfer_siginfo (gdb_byte
*readbuf
, ULONGEST offset
, ULONGEST len
,
3339 ULONGEST
*xfered_len
)
3341 char *buf
= (char *) &siginfo_er
;
3342 size_t bufsize
= sizeof (siginfo_er
);
3345 EXCEPTION_RECORD32 er32
;
3348 buf
= (char *) &er32
;
3349 bufsize
= sizeof (er32
);
3351 er32
.ExceptionCode
= siginfo_er
.ExceptionCode
;
3352 er32
.ExceptionFlags
= siginfo_er
.ExceptionFlags
;
3353 er32
.ExceptionRecord
= (uintptr_t) siginfo_er
.ExceptionRecord
;
3354 er32
.ExceptionAddress
= (uintptr_t) siginfo_er
.ExceptionAddress
;
3355 er32
.NumberParameters
= siginfo_er
.NumberParameters
;
3357 for (i
= 0; i
< EXCEPTION_MAXIMUM_PARAMETERS
; i
++)
3358 er32
.ExceptionInformation
[i
] = siginfo_er
.ExceptionInformation
[i
];
3362 if (siginfo_er
.ExceptionCode
== 0)
3363 return TARGET_XFER_E_IO
;
3365 if (readbuf
== nullptr)
3366 return TARGET_XFER_E_IO
;
3368 if (offset
> bufsize
)
3369 return TARGET_XFER_E_IO
;
3371 if (offset
+ len
> bufsize
)
3372 len
= bufsize
- offset
;
3374 memcpy (readbuf
, buf
+ offset
, len
);
3377 return TARGET_XFER_OK
;
3380 enum target_xfer_status
3381 windows_nat_target::xfer_partial (enum target_object object
,
3382 const char *annex
, gdb_byte
*readbuf
,
3383 const gdb_byte
*writebuf
, ULONGEST offset
,
3384 ULONGEST len
, ULONGEST
*xfered_len
)
3388 case TARGET_OBJECT_MEMORY
:
3389 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
3391 case TARGET_OBJECT_LIBRARIES
:
3392 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
3393 writebuf
, offset
, len
, xfered_len
);
3395 case TARGET_OBJECT_SIGNAL_INFO
:
3396 return windows_xfer_siginfo (readbuf
, offset
, len
, xfered_len
);
3399 if (beneath () == NULL
)
3401 /* This can happen when requesting the transfer of unsupported
3402 objects before a program has been started (and therefore
3403 with the current_target having no target beneath). */
3404 return TARGET_XFER_E_IO
;
3406 return beneath ()->xfer_partial (object
, annex
,
3407 readbuf
, writebuf
, offset
, len
,
3412 /* Provide thread local base, i.e. Thread Information Block address.
3413 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
3416 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
3418 windows_thread_info
*th
;
3420 th
= thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
);
3425 *addr
= th
->thread_local_base
;
3431 windows_nat_target::get_ada_task_ptid (long lwp
, long thread
)
3433 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
3436 /* Implementation of the to_thread_name method. */
3439 windows_nat_target::thread_name (struct thread_info
*thr
)
3441 return thread_rec (thr
->ptid
, DONT_INVALIDATE_CONTEXT
)->name
.get ();
3445 void _initialize_windows_nat ();
3447 _initialize_windows_nat ()
3449 x86_dr_low
.set_control
= cygwin_set_dr7
;
3450 x86_dr_low
.set_addr
= cygwin_set_dr
;
3451 x86_dr_low
.get_addr
= cygwin_get_dr
;
3452 x86_dr_low
.get_status
= cygwin_get_dr6
;
3453 x86_dr_low
.get_control
= cygwin_get_dr7
;
3455 /* x86_dr_low.debug_register_length field is set by
3456 calling x86_set_debug_register_length function
3457 in processor windows specific native file. */
3459 add_inf_child_target (&the_windows_nat_target
);
3462 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3465 add_com ("signal-event", class_run
, signal_event_command
, _("\
3466 Signal a crashed process with event ID, to allow its debugging.\n\
3467 This command is needed in support of setting up GDB as JIT debugger on \
3468 MS-Windows. The command should be invoked from the GDB command line using \
3469 the '-ex' command-line option. The ID of the event that blocks the \
3470 crashed process will be supplied by the Windows JIT debugging mechanism."));
3473 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3474 Set use of shell to start subprocess."), _("\
3475 Show use of shell to start subprocess."), NULL
,
3477 NULL
, /* FIXME: i18n: */
3478 &setlist
, &showlist
);
3480 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3481 &cygwin_exceptions
, _("\
3482 Break when an exception is detected in the Cygwin DLL itself."), _("\
3483 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3485 NULL
, /* FIXME: i18n: */
3486 &setlist
, &showlist
);
3489 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3490 Set creation of new console when creating child process."), _("\
3491 Show creation of new console when creating child process."), NULL
,
3493 NULL
, /* FIXME: i18n: */
3494 &setlist
, &showlist
);
3496 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3497 Set creation of new group when creating child process."), _("\
3498 Show creation of new group when creating child process."), NULL
,
3500 NULL
, /* FIXME: i18n: */
3501 &setlist
, &showlist
);
3503 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3504 Set whether to display execution in child process."), _("\
3505 Show whether to display execution in child process."), NULL
,
3507 NULL
, /* FIXME: i18n: */
3508 &setlist
, &showlist
);
3510 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3511 Set whether to display kernel events in child process."), _("\
3512 Show whether to display kernel events in child process."), NULL
,
3514 NULL
, /* FIXME: i18n: */
3515 &setlist
, &showlist
);
3517 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3518 Set whether to display memory accesses in child process."), _("\
3519 Show whether to display memory accesses in child process."), NULL
,
3521 NULL
, /* FIXME: i18n: */
3522 &setlist
, &showlist
);
3524 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3525 &debug_exceptions
, _("\
3526 Set whether to display kernel exceptions in child process."), _("\
3527 Show whether to display kernel exceptions in child process."), NULL
,
3529 NULL
, /* FIXME: i18n: */
3530 &setlist
, &showlist
);
3532 init_w32_command_list ();
3534 add_cmd ("selector", class_info
, display_selectors
,
3535 _("Display selectors infos."),
3539 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3541 /* Pass the address ADDR to the inferior in the I'th debug register.
3542 Here we just store the address in dr array, the registers will be
3543 actually set up when windows_continue is called. */
3545 cygwin_set_dr (int i
, CORE_ADDR addr
)
3548 internal_error (__FILE__
, __LINE__
,
3549 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3551 debug_registers_changed
= 1;
3552 debug_registers_used
= 1;
3555 /* Pass the value VAL to the inferior in the DR7 debug control
3556 register. Here we just store the address in D_REGS, the watchpoint
3557 will be actually set up in windows_wait. */
3559 cygwin_set_dr7 (unsigned long val
)
3561 dr
[7] = (CORE_ADDR
) val
;
3562 debug_registers_changed
= 1;
3563 debug_registers_used
= 1;
3566 /* Get the value of debug register I from the inferior. */
3569 cygwin_get_dr (int i
)
3574 /* Get the value of the DR6 debug status register from the inferior.
3575 Here we just return the value stored in dr[6]
3576 by the last call to thread_rec for current_event.dwThreadId id. */
3577 static unsigned long
3578 cygwin_get_dr6 (void)
3580 return (unsigned long) dr
[6];
3583 /* Get the value of the DR7 debug status register from the inferior.
3584 Here we just return the value stored in dr[7] by the last call to
3585 thread_rec for current_event.dwThreadId id. */
3587 static unsigned long
3588 cygwin_get_dr7 (void)
3590 return (unsigned long) dr
[7];
3593 /* Determine if the thread referenced by "ptid" is alive
3594 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3595 it means that the thread has died. Otherwise it is assumed to be alive. */
3598 windows_nat_target::thread_alive (ptid_t ptid
)
3600 gdb_assert (ptid
.lwp () != 0);
3602 return (WaitForSingleObject (thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
)->h
, 0)
3606 void _initialize_check_for_gdb_ini ();
3608 _initialize_check_for_gdb_ini ()
3611 if (inhibit_gdbinit
)
3614 homedir
= getenv ("HOME");
3618 char *oldini
= (char *) alloca (strlen (homedir
) +
3619 sizeof ("gdb.ini") + 1);
3620 strcpy (oldini
, homedir
);
3621 p
= strchr (oldini
, '\0');
3622 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3624 strcpy (p
, "gdb.ini");
3625 if (access (oldini
, 0) == 0)
3627 int len
= strlen (oldini
);
3628 char *newini
= (char *) alloca (len
+ 2);
3630 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3631 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3632 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3637 /* Define dummy functions which always return error for the rare cases where
3638 these functions could not be found. */
3640 bad_DebugActiveProcessStop (DWORD w
)
3645 bad_DebugBreakProcess (HANDLE w
)
3650 bad_DebugSetProcessKillOnExit (BOOL w
)
3655 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3662 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3668 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3675 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3681 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3687 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3693 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3701 /* Load any functions which may not be available in ancient versions
3704 void _initialize_loadable ();
3706 _initialize_loadable ()
3710 #define GPA(m, func) \
3711 func = (func ## _ftype *) GetProcAddress (m, #func)
3713 hm
= LoadLibrary ("kernel32.dll");
3716 GPA (hm
, DebugActiveProcessStop
);
3717 GPA (hm
, DebugBreakProcess
);
3718 GPA (hm
, DebugSetProcessKillOnExit
);
3719 GPA (hm
, GetConsoleFontSize
);
3720 GPA (hm
, DebugActiveProcessStop
);
3721 GPA (hm
, GetCurrentConsoleFont
);
3723 GPA (hm
, Wow64SuspendThread
);
3724 GPA (hm
, Wow64GetThreadContext
);
3725 GPA (hm
, Wow64SetThreadContext
);
3726 GPA (hm
, Wow64GetThreadSelectorEntry
);
3730 /* Set variables to dummy versions of these processes if the function
3731 wasn't found in kernel32.dll. */
3732 if (!DebugBreakProcess
)
3733 DebugBreakProcess
= bad_DebugBreakProcess
;
3734 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3736 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3737 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3739 if (!GetConsoleFontSize
)
3740 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3741 if (!GetCurrentConsoleFont
)
3742 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3744 /* Load optional functions used for retrieving filename information
3745 associated with the currently debugged process or its dlls. */
3746 hm
= LoadLibrary ("psapi.dll");
3749 GPA (hm
, EnumProcessModules
);
3751 GPA (hm
, EnumProcessModulesEx
);
3753 GPA (hm
, GetModuleInformation
);
3754 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3755 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3758 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3760 /* Set variables to dummy versions of these processes if the function
3761 wasn't found in psapi.dll. */
3762 EnumProcessModules
= bad_EnumProcessModules
;
3763 GetModuleInformation
= bad_GetModuleInformation
;
3764 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3765 /* This will probably fail on Windows 9x/Me. Let the user know
3766 that we're missing some functionality. */
3768 cannot automatically find executable file or library to read symbols.\n\
3769 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3772 hm
= LoadLibrary ("advapi32.dll");
3775 GPA (hm
, OpenProcessToken
);
3776 GPA (hm
, LookupPrivilegeValueA
);
3777 GPA (hm
, AdjustTokenPrivileges
);
3778 /* Only need to set one of these since if OpenProcessToken fails nothing
3780 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3781 || !AdjustTokenPrivileges
)
3782 OpenProcessToken
= bad_OpenProcessToken
;