1 /* Target-vector operations for controlling windows child processes, for GDB.
3 Copyright (C) 1995-2019 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>
47 #include "buildsym-legacy.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"
73 #define AdjustTokenPrivileges dyn_AdjustTokenPrivileges
74 #define DebugActiveProcessStop dyn_DebugActiveProcessStop
75 #define DebugBreakProcess dyn_DebugBreakProcess
76 #define DebugSetProcessKillOnExit dyn_DebugSetProcessKillOnExit
77 #define EnumProcessModules dyn_EnumProcessModules
78 #define GetModuleInformation dyn_GetModuleInformation
79 #define LookupPrivilegeValueA dyn_LookupPrivilegeValueA
80 #define OpenProcessToken dyn_OpenProcessToken
81 #define GetConsoleFontSize dyn_GetConsoleFontSize
82 #define GetCurrentConsoleFont dyn_GetCurrentConsoleFont
84 typedef BOOL
WINAPI (AdjustTokenPrivileges_ftype
) (HANDLE
, BOOL
,
86 DWORD
, PTOKEN_PRIVILEGES
,
88 static AdjustTokenPrivileges_ftype
*AdjustTokenPrivileges
;
90 typedef BOOL
WINAPI (DebugActiveProcessStop_ftype
) (DWORD
);
91 static DebugActiveProcessStop_ftype
*DebugActiveProcessStop
;
93 typedef BOOL
WINAPI (DebugBreakProcess_ftype
) (HANDLE
);
94 static DebugBreakProcess_ftype
*DebugBreakProcess
;
96 typedef BOOL
WINAPI (DebugSetProcessKillOnExit_ftype
) (BOOL
);
97 static DebugSetProcessKillOnExit_ftype
*DebugSetProcessKillOnExit
;
99 typedef BOOL
WINAPI (EnumProcessModules_ftype
) (HANDLE
, HMODULE
*, DWORD
,
101 static EnumProcessModules_ftype
*EnumProcessModules
;
103 typedef BOOL
WINAPI (GetModuleInformation_ftype
) (HANDLE
, HMODULE
,
104 LPMODULEINFO
, DWORD
);
105 static GetModuleInformation_ftype
*GetModuleInformation
;
107 typedef BOOL
WINAPI (LookupPrivilegeValueA_ftype
) (LPCSTR
, LPCSTR
, PLUID
);
108 static LookupPrivilegeValueA_ftype
*LookupPrivilegeValueA
;
110 typedef BOOL
WINAPI (OpenProcessToken_ftype
) (HANDLE
, DWORD
, PHANDLE
);
111 static OpenProcessToken_ftype
*OpenProcessToken
;
113 typedef BOOL
WINAPI (GetCurrentConsoleFont_ftype
) (HANDLE
, BOOL
,
114 CONSOLE_FONT_INFO
*);
115 static GetCurrentConsoleFont_ftype
*GetCurrentConsoleFont
;
117 typedef COORD
WINAPI (GetConsoleFontSize_ftype
) (HANDLE
, DWORD
);
118 static GetConsoleFontSize_ftype
*GetConsoleFontSize
;
122 #undef GetModuleFileNameEx
125 # define __PMAX (MAX_PATH + 1)
126 typedef DWORD
WINAPI (GetModuleFileNameEx_ftype
) (HANDLE
, HMODULE
, LPSTR
, DWORD
);
127 static GetModuleFileNameEx_ftype
*GetModuleFileNameEx
;
128 # define STARTUPINFO STARTUPINFOA
129 # define CreateProcess CreateProcessA
130 # define GetModuleFileNameEx_name "GetModuleFileNameExA"
131 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
133 # define __PMAX PATH_MAX
134 /* The starting and ending address of the cygwin1.dll text segment. */
135 static CORE_ADDR cygwin_load_start
;
136 static CORE_ADDR cygwin_load_end
;
138 typedef wchar_t cygwin_buf_t
;
139 typedef DWORD
WINAPI (GetModuleFileNameEx_ftype
) (HANDLE
, HMODULE
,
141 static GetModuleFileNameEx_ftype
*GetModuleFileNameEx
;
142 # define STARTUPINFO STARTUPINFOW
143 # define CreateProcess CreateProcessW
144 # define GetModuleFileNameEx_name "GetModuleFileNameExW"
145 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExW
148 static int have_saved_context
; /* True if we've saved context from a
151 static CONTEXT saved_context
; /* Containes the saved context from a
155 /* If we're not using the old Cygwin header file set, define the
156 following which never should have been in the generic Win32 API
157 headers in the first place since they were our own invention... */
158 #ifndef _GNU_H_WINDOWS_H
161 FLAG_TRACE_BIT
= 0x100,
165 #ifndef CONTEXT_EXTENDED_REGISTERS
166 /* This macro is only defined on ia32. It only makes sense on this target,
167 so define it as zero if not already defined. */
168 #define CONTEXT_EXTENDED_REGISTERS 0
171 #define CONTEXT_DEBUGGER_DR CONTEXT_FULL | CONTEXT_FLOATING_POINT \
172 | CONTEXT_SEGMENTS | CONTEXT_DEBUG_REGISTERS \
173 | CONTEXT_EXTENDED_REGISTERS
175 static uintptr_t dr
[8];
176 static int debug_registers_changed
;
177 static int debug_registers_used
;
179 static int windows_initialization_done
;
180 #define DR6_CLEAR_VALUE 0xffff0ff0
182 /* The exception thrown by a program to tell the debugger the name of
183 a thread. The exception record contains an ID of a thread and a
184 name to give it. This exception has no documented name, but MSDN
185 dubs it "MS_VC_EXCEPTION" in one code example. */
186 #define MS_VC_EXCEPTION 0x406d1388
190 HANDLE_EXCEPTION_UNHANDLED
= 0,
191 HANDLE_EXCEPTION_HANDLED
,
192 HANDLE_EXCEPTION_IGNORED
193 } handle_exception_result
;
195 /* The string sent by cygwin when it processes a signal.
196 FIXME: This should be in a cygwin include file. */
197 #ifndef _CYGWIN_SIGNAL_STRING
198 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
201 #define CHECK(x) check (x, __FILE__,__LINE__)
202 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
203 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
204 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
205 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
207 static void cygwin_set_dr (int i
, CORE_ADDR addr
);
208 static void cygwin_set_dr7 (unsigned long val
);
209 static CORE_ADDR
cygwin_get_dr (int i
);
210 static unsigned long cygwin_get_dr6 (void);
211 static unsigned long cygwin_get_dr7 (void);
213 static enum gdb_signal last_sig
= GDB_SIGNAL_0
;
214 /* Set if a signal was received from the debugged process. */
216 /* Thread information structure used to track information that is
217 not available in gdb's thread structure. */
218 typedef struct windows_thread_info_struct
220 struct windows_thread_info_struct
*next
;
223 CORE_ADDR thread_local_base
;
232 static windows_thread_info thread_head
;
234 /* The process and thread handles for the above context. */
236 static DEBUG_EVENT current_event
; /* The current debug event from
238 static HANDLE current_process_handle
; /* Currently executing process */
239 static windows_thread_info
*current_thread
; /* Info on currently selected thread */
241 /* Counts of things. */
242 static int exception_count
= 0;
243 static int event_count
= 0;
244 static int saw_create
;
245 static int open_process_used
= 0;
248 static bool new_console
= false;
250 static bool cygwin_exceptions
= false;
252 static bool new_group
= true;
253 static bool debug_exec
= false; /* show execution */
254 static bool debug_events
= false; /* show events from kernel */
255 static bool debug_memory
= false; /* show target memory accesses */
256 static bool debug_exceptions
= false; /* show target exceptions */
257 static bool useshell
= false; /* use shell for subprocesses */
259 /* This vector maps GDB's idea of a register's number into an offset
260 in the windows exception context vector.
262 It also contains the bit mask needed to load the register in question.
264 The contents of this table can only be computed by the units
265 that provide CPU-specific support for Windows native debugging.
266 These units should set the table by calling
267 windows_set_context_register_offsets.
269 One day we could read a reg, we could inspect the context we
270 already have loaded, if it doesn't have the bit set that we need,
271 we read that set of registers in using GetThreadContext. If the
272 context already contains what we need, we just unpack it. Then to
273 write a register, first we have to ensure that the context contains
274 the other regs of the group, and then we copy the info in and set
277 static const int *mappings
;
279 /* The function to use in order to determine whether a register is
280 a segment register or not. */
281 static segment_register_p_ftype
*segment_register_p
;
283 /* See windows_nat_target::resume to understand why this is commented
286 /* This vector maps the target's idea of an exception (extracted
287 from the DEBUG_EVENT structure) to GDB's idea. */
289 struct xlate_exception
295 static const struct xlate_exception xlate
[] =
297 {EXCEPTION_ACCESS_VIOLATION
, GDB_SIGNAL_SEGV
},
298 {STATUS_STACK_OVERFLOW
, GDB_SIGNAL_SEGV
},
299 {EXCEPTION_BREAKPOINT
, GDB_SIGNAL_TRAP
},
300 {DBG_CONTROL_C
, GDB_SIGNAL_INT
},
301 {EXCEPTION_SINGLE_STEP
, GDB_SIGNAL_TRAP
},
302 {STATUS_FLOAT_DIVIDE_BY_ZERO
, GDB_SIGNAL_FPE
}
307 struct windows_nat_target final
: public x86_nat_target
<inf_child_target
>
309 void close () override
;
311 void attach (const char *, int) override
;
313 bool attach_no_wait () override
316 void detach (inferior
*, int) override
;
318 void resume (ptid_t
, int , enum gdb_signal
) override
;
320 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
322 void fetch_registers (struct regcache
*, int) override
;
323 void store_registers (struct regcache
*, int) override
;
325 enum target_xfer_status
xfer_partial (enum target_object object
,
328 const gdb_byte
*writebuf
,
329 ULONGEST offset
, ULONGEST len
,
330 ULONGEST
*xfered_len
) override
;
332 void files_info () override
;
334 void kill () override
;
336 void create_inferior (const char *, const std::string
&,
337 char **, int) override
;
339 void mourn_inferior () override
;
341 bool thread_alive (ptid_t ptid
) override
;
343 std::string
pid_to_str (ptid_t
) override
;
345 void interrupt () override
;
347 char *pid_to_exec_file (int pid
) override
;
349 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
351 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
353 const char *thread_name (struct thread_info
*) override
;
356 static windows_nat_target the_windows_nat_target
;
358 /* Set the MAPPINGS static global to OFFSETS.
359 See the description of MAPPINGS for more details. */
362 windows_set_context_register_offsets (const int *offsets
)
367 /* See windows-nat.h. */
370 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
372 segment_register_p
= fun
;
376 check (BOOL ok
, const char *file
, int line
)
379 printf_filtered ("error return %s:%d was %u\n", file
, line
,
380 (unsigned) GetLastError ());
383 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
384 then also retrieve the context for this thread. If GET_CONTEXT is
385 negative, then don't suspend the thread. */
386 static windows_thread_info
*
387 thread_rec (DWORD id
, int get_context
)
389 windows_thread_info
*th
;
391 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
394 if (!th
->suspended
&& get_context
)
396 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
398 if (SuspendThread (th
->h
) == (DWORD
) -1)
400 DWORD err
= GetLastError ();
402 /* We get Access Denied (5) when trying to suspend
403 threads that Windows started on behalf of the
404 debuggee, usually when those threads are just
406 We can get Invalid Handle (6) if the main thread
408 if (err
!= ERROR_INVALID_HANDLE
409 && err
!= ERROR_ACCESS_DENIED
)
410 warning (_("SuspendThread (tid=0x%x) failed."
412 (unsigned) id
, (unsigned) err
);
418 else if (get_context
< 0)
420 th
->reload_context
= 1;
428 /* Add a thread to the thread list.
430 PTID is the ptid of the thread to be added.
431 H is its Windows handle.
432 TLB is its thread local base.
433 MAIN_THREAD_P should be true if the thread to be added is
434 the main thread, false otherwise. */
436 static windows_thread_info
*
437 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
, bool main_thread_p
)
439 windows_thread_info
*th
;
442 gdb_assert (ptid
.tid () != 0);
446 if ((th
= thread_rec (id
, FALSE
)))
449 th
= XCNEW (windows_thread_info
);
452 th
->thread_local_base
= (CORE_ADDR
) (uintptr_t) tlb
;
453 th
->next
= thread_head
.next
;
454 thread_head
.next
= th
;
456 /* Add this new thread to the list of threads.
458 To be consistent with what's done on other platforms, we add
459 the main thread silently (in reality, this thread is really
460 more of a process to the user than a thread). */
462 add_thread_silent (ptid
);
466 /* Set the debug registers for the new thread if they are used. */
467 if (debug_registers_used
)
469 /* Only change the value of the debug registers. */
470 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
471 CHECK (GetThreadContext (th
->h
, &th
->context
));
472 th
->context
.Dr0
= dr
[0];
473 th
->context
.Dr1
= dr
[1];
474 th
->context
.Dr2
= dr
[2];
475 th
->context
.Dr3
= dr
[3];
476 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
477 th
->context
.Dr7
= dr
[7];
478 CHECK (SetThreadContext (th
->h
, &th
->context
));
479 th
->context
.ContextFlags
= 0;
484 /* Clear out any old thread list and reinitialize it to a
487 windows_init_thread_list (void)
489 windows_thread_info
*th
= &thread_head
;
491 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
493 while (th
->next
!= NULL
)
495 windows_thread_info
*here
= th
->next
;
496 th
->next
= here
->next
;
499 thread_head
.next
= NULL
;
502 /* Delete a thread from the list of threads.
504 PTID is the ptid of the thread to be deleted.
505 EXIT_CODE is the thread's exit code.
506 MAIN_THREAD_P should be true if the thread to be deleted is
507 the main thread, false otherwise. */
510 windows_delete_thread (ptid_t ptid
, DWORD exit_code
, bool main_thread_p
)
512 windows_thread_info
*th
;
515 gdb_assert (ptid
.tid () != 0);
519 /* Emit a notification about the thread being deleted.
521 Note that no notification was printed when the main thread
522 was created, and thus, unless in verbose mode, we should be
523 symetrical, and avoid that notification for the main thread
527 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
).c_str ());
528 else if (print_thread_events
&& !main_thread_p
)
529 printf_unfiltered (_("[%s exited with code %u]\n"),
530 target_pid_to_str (ptid
).c_str (),
531 (unsigned) exit_code
);
533 delete_thread (find_thread_ptid (ptid
));
535 for (th
= &thread_head
;
536 th
->next
!= NULL
&& th
->next
->id
!= id
;
540 if (th
->next
!= NULL
)
542 windows_thread_info
*here
= th
->next
;
543 th
->next
= here
->next
;
549 /* Fetches register number R from the given windows_thread_info,
550 and supplies its value to the given regcache.
552 This function assumes that R is non-negative. A failed assertion
553 is raised if that is not true.
555 This function assumes that TH->RELOAD_CONTEXT is not set, meaning
556 that the windows_thread_info has an up-to-date context. A failed
557 assertion is raised if that assumption is violated. */
560 windows_fetch_one_register (struct regcache
*regcache
,
561 windows_thread_info
*th
, int r
)
564 gdb_assert (!th
->reload_context
);
566 char *context_offset
= ((char *) &th
->context
) + mappings
[r
];
567 struct gdbarch
*gdbarch
= regcache
->arch ();
568 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
570 if (r
== I387_FISEG_REGNUM (tdep
))
572 long l
= *((long *) context_offset
) & 0xffff;
573 regcache
->raw_supply (r
, (char *) &l
);
575 else if (r
== I387_FOP_REGNUM (tdep
))
577 long l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
578 regcache
->raw_supply (r
, (char *) &l
);
580 else if (segment_register_p (r
))
582 /* GDB treats segment registers as 32bit registers, but they are
583 in fact only 16 bits long. Make sure we do not read extra
584 bits from our source buffer. */
585 long l
= *((long *) context_offset
) & 0xffff;
586 regcache
->raw_supply (r
, (char *) &l
);
589 regcache
->raw_supply (r
, context_offset
);
593 windows_nat_target::fetch_registers (struct regcache
*regcache
, int r
)
595 DWORD pid
= regcache
->ptid ().tid ();
596 windows_thread_info
*th
= thread_rec (pid
, TRUE
);
598 /* Check if TH exists. Windows sometimes uses a non-existent
599 thread id in its events. */
603 if (th
->reload_context
)
606 if (have_saved_context
)
608 /* Lie about where the program actually is stopped since
609 cygwin has informed us that we should consider the signal
610 to have occurred at another location which is stored in
612 memcpy (&th
->context
, &saved_context
,
613 __COPY_CONTEXT_SIZE
);
614 have_saved_context
= 0;
619 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
620 CHECK (GetThreadContext (th
->h
, &th
->context
));
621 /* Copy dr values from that thread.
622 But only if there were not modified since last stop.
624 if (!debug_registers_changed
)
626 dr
[0] = th
->context
.Dr0
;
627 dr
[1] = th
->context
.Dr1
;
628 dr
[2] = th
->context
.Dr2
;
629 dr
[3] = th
->context
.Dr3
;
630 dr
[6] = th
->context
.Dr6
;
631 dr
[7] = th
->context
.Dr7
;
634 th
->reload_context
= 0;
638 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch()); r
++)
639 windows_fetch_one_register (regcache
, th
, r
);
641 windows_fetch_one_register (regcache
, th
, r
);
644 /* Collect the register number R from the given regcache, and store
645 its value into the corresponding area of the given thread's context.
647 This function assumes that R is non-negative. A failed assertion
648 assertion is raised if that is not true. */
651 windows_store_one_register (const struct regcache
*regcache
,
652 windows_thread_info
*th
, int r
)
656 regcache
->raw_collect (r
, ((char *) &th
->context
) + mappings
[r
]);
659 /* Store a new register value into the context of the thread tied to
663 windows_nat_target::store_registers (struct regcache
*regcache
, int r
)
665 DWORD pid
= regcache
->ptid ().tid ();
666 windows_thread_info
*th
= thread_rec (pid
, TRUE
);
668 /* Check if TH exists. Windows sometimes uses a non-existent
669 thread id in its events. */
674 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch ()); r
++)
675 windows_store_one_register (regcache
, th
, r
);
677 windows_store_one_register (regcache
, th
, r
);
680 /* Encapsulate the information required in a call to
681 symbol_file_add_args. */
682 struct safe_symbol_file_add_args
686 section_addr_info
*addrs
;
689 struct ui_file
*err
, *out
;
693 /* Maintain a linked list of "so" information. */
694 struct lm_info_windows
: public lm_info_base
696 LPVOID load_addr
= 0;
699 static struct so_list solib_start
, *solib_end
;
701 static struct so_list
*
702 windows_make_so (const char *name
, LPVOID load_addr
)
709 WIN32_FIND_DATA w32_fd
;
710 HANDLE h
= FindFirstFile(name
, &w32_fd
);
712 if (h
== INVALID_HANDLE_VALUE
)
718 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
720 p
= strrchr (buf
, '\\');
723 SetCurrentDirectory (buf
);
724 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
725 SetCurrentDirectory (cwd
);
728 if (strcasecmp (buf
, "ntdll.dll") == 0)
730 GetSystemDirectory (buf
, sizeof (buf
));
731 strcat (buf
, "\\ntdll.dll");
734 cygwin_buf_t buf
[__PMAX
];
737 if (access (name
, F_OK
) != 0)
739 if (strcasecmp (name
, "ntdll.dll") == 0)
742 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
743 wcscat (buf
, L
"\\ntdll.dll");
747 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
748 strcat (buf
, "\\ntdll.dll");
753 so
= XCNEW (struct so_list
);
754 lm_info_windows
*li
= new lm_info_windows
;
756 li
->load_addr
= load_addr
;
757 strcpy (so
->so_original_name
, name
);
759 strcpy (so
->so_name
, buf
);
762 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
763 SO_NAME_MAX_PATH_SIZE
);
766 char *rname
= realpath (name
, NULL
);
767 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
769 strcpy (so
->so_name
, rname
);
773 error (_("dll path too long"));
775 /* Record cygwin1.dll .text start/end. */
776 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
777 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
779 asection
*text
= NULL
;
781 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386", -1));
786 if (bfd_check_format (abfd
.get (), bfd_object
))
787 text
= bfd_get_section_by_name (abfd
.get (), ".text");
792 /* The symbols in a dll are offset by 0x1000, which is the
793 offset from 0 of the first byte in an image - because of the
794 file header and the section alignment. */
795 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
797 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (text
);
805 get_image_name (HANDLE h
, void *address
, int unicode
)
808 static char buf
[__PMAX
];
810 static char buf
[(2 * __PMAX
) + 1];
812 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
818 /* Attempt to read the name of the dll that was detected.
819 This is documented to work only when actively debugging
820 a program. It will not work for attached processes. */
824 /* See if we could read the address of a string, and that the
825 address isn't null. */
826 if (!ReadProcessMemory (h
, address
, &address_ptr
,
827 sizeof (address_ptr
), &done
)
828 || done
!= sizeof (address_ptr
) || !address_ptr
)
831 /* Find the length of the string. */
832 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
833 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
837 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
840 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
841 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
844 wcstombs (buf
, unicode_address
, __PMAX
);
846 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
854 /* Handle a DLL load event, and return 1.
856 This function assumes that this event did not occur during inferior
857 initialization, where their event info may be incomplete (see
858 do_initial_windows_stuff and windows_add_all_dlls for more info
859 on how we handle DLL loading during that phase). */
864 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
867 /* Try getting the DLL name via the lpImageName field of the event.
868 Note that Microsoft documents this fields as strictly optional,
869 in the sense that it might be NULL. And the first DLL event in
870 particular is explicitly documented as "likely not pass[ed]"
871 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
872 dll_name
= get_image_name (current_process_handle
,
873 event
->lpImageName
, event
->fUnicode
);
877 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
878 solib_end
= solib_end
->next
;
880 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
882 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
883 host_address_to_string (li
->load_addr
)));
887 windows_free_so (struct so_list
*so
)
889 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
895 /* Handle a DLL unload event.
896 Return 1 if successful, or zero otherwise.
898 This function assumes that this event did not occur during inferior
899 initialization, where their event info may be incomplete (see
900 do_initial_windows_stuff and windows_add_all_dlls for more info
901 on how we handle DLL loading during that phase). */
906 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
909 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
911 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
913 if (li_next
->load_addr
== lpBaseOfDll
)
915 struct so_list
*sodel
= so
->next
;
917 so
->next
= sodel
->next
;
920 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
922 windows_free_so (sodel
);
927 /* We did not find any DLL that was previously loaded at this address,
928 so register a complaint. We do not report an error, because we have
929 observed that this may be happening under some circumstances. For
930 instance, running 32bit applications on x64 Windows causes us to receive
931 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
932 events are apparently caused by the WOW layer, the interface between
933 32bit and 64bit worlds). */
934 complaint (_("dll starting at %s not found."),
935 host_address_to_string (lpBaseOfDll
));
938 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
942 catch_errors (void (*func
) ())
948 catch (const gdb_exception
&ex
)
950 exception_print (gdb_stderr
, ex
);
954 /* Clear list of loaded DLLs. */
956 windows_clear_solib (void)
958 solib_start
.next
= NULL
;
959 solib_end
= &solib_start
;
963 signal_event_command (const char *args
, int from_tty
)
965 uintptr_t event_id
= 0;
966 char *endargs
= NULL
;
969 error (_("signal-event requires an argument (integer event id)"));
971 event_id
= strtoumax (args
, &endargs
, 10);
973 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
974 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
975 error (_("Failed to convert `%s' to event id"), args
);
977 SetEvent ((HANDLE
) event_id
);
978 CloseHandle ((HANDLE
) event_id
);
981 /* Handle DEBUG_STRING output from child process.
982 Cygwin prepends its messages with a "cygwin:". Interpret this as
983 a Cygwin signal. Otherwise just print the string as a warning. */
985 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
987 gdb::unique_xmalloc_ptr
<char> s
;
990 if (!target_read_string
991 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
993 || !s
|| !*(s
.get ()))
995 else if (!startswith (s
.get (), _CYGWIN_SIGNAL_STRING
))
998 if (!startswith (s
.get (), "cYg"))
1001 char *p
= strchr (s
.get (), '\0');
1003 if (p
> s
.get () && *--p
== '\n')
1005 warning (("%s"), s
.get ());
1011 /* Got a cygwin signal marker. A cygwin signal is followed by
1012 the signal number itself and then optionally followed by the
1013 thread id and address to saved context within the DLL. If
1014 these are supplied, then the given thread is assumed to have
1015 issued the signal and the context from the thread is assumed
1016 to be stored at the given address in the inferior. Tell gdb
1017 to treat this like a real signal. */
1019 int sig
= strtol (s
.get () + sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
1020 gdb_signal gotasig
= gdb_signal_from_host (sig
);
1022 ourstatus
->value
.sig
= gotasig
;
1028 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1029 retval
= strtoul (p
, &p
, 0);
1031 retval
= current_event
.dwThreadId
;
1032 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
1033 && ReadProcessMemory (current_process_handle
, x
,
1035 __COPY_CONTEXT_SIZE
, &n
)
1036 && n
== __COPY_CONTEXT_SIZE
)
1037 have_saved_context
= 1;
1046 display_selector (HANDLE thread
, DWORD sel
)
1049 if (GetThreadSelectorEntry (thread
, sel
, &info
))
1052 printf_filtered ("0x%03x: ", (unsigned) sel
);
1053 if (!info
.HighWord
.Bits
.Pres
)
1055 puts_filtered ("Segment not present\n");
1058 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1059 (info
.HighWord
.Bits
.BaseMid
<< 16)
1061 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1062 if (info
.HighWord
.Bits
.Granularity
)
1063 limit
= (limit
<< 12) | 0xfff;
1064 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1065 if (info
.HighWord
.Bits
.Default_Big
)
1066 puts_filtered(" 32-bit ");
1068 puts_filtered(" 16-bit ");
1069 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1072 puts_filtered ("Data (Read-Only, Exp-up");
1075 puts_filtered ("Data (Read/Write, Exp-up");
1078 puts_filtered ("Unused segment (");
1081 puts_filtered ("Data (Read/Write, Exp-down");
1084 puts_filtered ("Code (Exec-Only, N.Conf");
1087 puts_filtered ("Code (Exec/Read, N.Conf");
1090 puts_filtered ("Code (Exec-Only, Conf");
1093 puts_filtered ("Code (Exec/Read, Conf");
1096 printf_filtered ("Unknown type 0x%lx",
1097 (unsigned long) info
.HighWord
.Bits
.Type
);
1099 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1100 puts_filtered(", N.Acc");
1101 puts_filtered (")\n");
1102 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1103 puts_filtered("System selector ");
1104 printf_filtered ("Priviledge level = %ld. ",
1105 (unsigned long) info
.HighWord
.Bits
.Dpl
);
1106 if (info
.HighWord
.Bits
.Granularity
)
1107 puts_filtered ("Page granular.\n");
1109 puts_filtered ("Byte granular.\n");
1114 DWORD err
= GetLastError ();
1115 if (err
== ERROR_NOT_SUPPORTED
)
1116 printf_filtered ("Function not supported\n");
1118 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1124 display_selectors (const char * args
, int from_tty
)
1126 if (!current_thread
)
1128 puts_filtered ("Impossible to display selectors now.\n");
1134 puts_filtered ("Selector $cs\n");
1135 display_selector (current_thread
->h
,
1136 current_thread
->context
.SegCs
);
1137 puts_filtered ("Selector $ds\n");
1138 display_selector (current_thread
->h
,
1139 current_thread
->context
.SegDs
);
1140 puts_filtered ("Selector $es\n");
1141 display_selector (current_thread
->h
,
1142 current_thread
->context
.SegEs
);
1143 puts_filtered ("Selector $ss\n");
1144 display_selector (current_thread
->h
,
1145 current_thread
->context
.SegSs
);
1146 puts_filtered ("Selector $fs\n");
1147 display_selector (current_thread
->h
,
1148 current_thread
->context
.SegFs
);
1149 puts_filtered ("Selector $gs\n");
1150 display_selector (current_thread
->h
,
1151 current_thread
->context
.SegGs
);
1156 sel
= parse_and_eval_long (args
);
1157 printf_filtered ("Selector \"%s\"\n",args
);
1158 display_selector (current_thread
->h
, sel
);
1162 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1163 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1164 host_address_to_string (\
1165 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1167 static handle_exception_result
1168 handle_exception (struct target_waitstatus
*ourstatus
)
1170 EXCEPTION_RECORD
*rec
= ¤t_event
.u
.Exception
.ExceptionRecord
;
1171 DWORD code
= rec
->ExceptionCode
;
1172 handle_exception_result result
= HANDLE_EXCEPTION_HANDLED
;
1174 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1176 /* Record the context of the current thread. */
1177 thread_rec (current_event
.dwThreadId
, -1);
1181 case EXCEPTION_ACCESS_VIOLATION
:
1182 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1183 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1186 /* See if the access violation happened within the cygwin DLL
1187 itself. Cygwin uses a kind of exception handling to deal
1188 with passed-in invalid addresses. gdb should not treat
1189 these as real SEGVs since they will be silently handled by
1190 cygwin. A real SEGV will (theoretically) be caught by
1191 cygwin later in the process and will be sent as a
1192 cygwin-specific-signal. So, ignore SEGVs if they show up
1193 within the text segment of the DLL itself. */
1195 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1197 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1198 && addr
< cygwin_load_end
))
1199 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1200 && startswith (fn
, "KERNEL32!IsBad")))
1201 return HANDLE_EXCEPTION_UNHANDLED
;
1205 case STATUS_STACK_OVERFLOW
:
1206 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1207 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1209 case STATUS_FLOAT_DENORMAL_OPERAND
:
1210 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1211 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1213 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1214 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1215 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1217 case STATUS_FLOAT_INEXACT_RESULT
:
1218 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1219 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1221 case STATUS_FLOAT_INVALID_OPERATION
:
1222 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1223 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1225 case STATUS_FLOAT_OVERFLOW
:
1226 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1227 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1229 case STATUS_FLOAT_STACK_CHECK
:
1230 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1231 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1233 case STATUS_FLOAT_UNDERFLOW
:
1234 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1235 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1237 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1238 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1239 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1241 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1242 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1243 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1245 case STATUS_INTEGER_OVERFLOW
:
1246 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1247 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1249 case EXCEPTION_BREAKPOINT
:
1250 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1251 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1254 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1255 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1257 case DBG_CONTROL_BREAK
:
1258 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1259 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1261 case EXCEPTION_SINGLE_STEP
:
1262 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1263 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1265 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1266 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1267 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1269 case EXCEPTION_PRIV_INSTRUCTION
:
1270 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1271 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1273 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1274 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1275 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1277 case MS_VC_EXCEPTION
:
1278 if (rec
->NumberParameters
>= 3
1279 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1281 DWORD named_thread_id
;
1282 windows_thread_info
*named_thread
;
1283 CORE_ADDR thread_name_target
;
1285 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1287 thread_name_target
= rec
->ExceptionInformation
[1];
1288 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1290 if (named_thread_id
== (DWORD
) -1)
1291 named_thread_id
= current_event
.dwThreadId
;
1293 named_thread
= thread_rec (named_thread_id
, 0);
1294 if (named_thread
!= NULL
)
1296 int thread_name_len
;
1297 gdb::unique_xmalloc_ptr
<char> thread_name
;
1299 thread_name_len
= target_read_string (thread_name_target
,
1300 &thread_name
, 1025, NULL
);
1301 if (thread_name_len
> 0)
1303 thread_name
.get ()[thread_name_len
- 1] = '\0';
1304 xfree (named_thread
->name
);
1305 named_thread
->name
= thread_name
.release ();
1308 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1309 result
= HANDLE_EXCEPTION_IGNORED
;
1312 /* treat improperly formed exception as unknown */
1315 /* Treat unhandled first chance exceptions specially. */
1316 if (current_event
.u
.Exception
.dwFirstChance
)
1317 return HANDLE_EXCEPTION_UNHANDLED
;
1318 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1319 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1320 host_address_to_string (
1321 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1322 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1326 last_sig
= ourstatus
->value
.sig
;
1330 /* Resume thread specified by ID, or all artificially suspended
1331 threads, if we are continuing execution. KILLED non-zero means we
1332 have killed the inferior, so we should ignore weird errors due to
1333 threads shutting down. */
1335 windows_continue (DWORD continue_status
, int id
, int killed
)
1337 windows_thread_info
*th
;
1340 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1341 (unsigned) current_event
.dwProcessId
,
1342 (unsigned) current_event
.dwThreadId
,
1343 continue_status
== DBG_CONTINUE
?
1344 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1346 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1347 if ((id
== -1 || id
== (int) th
->id
)
1350 if (debug_registers_changed
)
1352 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1353 th
->context
.Dr0
= dr
[0];
1354 th
->context
.Dr1
= dr
[1];
1355 th
->context
.Dr2
= dr
[2];
1356 th
->context
.Dr3
= dr
[3];
1357 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1358 th
->context
.Dr7
= dr
[7];
1360 if (th
->context
.ContextFlags
)
1364 if (GetExitCodeThread (th
->h
, &ec
)
1365 && ec
== STILL_ACTIVE
)
1367 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1372 th
->context
.ContextFlags
= 0;
1374 if (th
->suspended
> 0)
1375 (void) ResumeThread (th
->h
);
1379 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1380 current_event
.dwThreadId
,
1384 error (_("Failed to resume program execution"
1385 " (ContinueDebugEvent failed, error %u)"),
1386 (unsigned int) GetLastError ());
1388 debug_registers_changed
= 0;
1392 /* Called in pathological case where Windows fails to send a
1393 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1395 fake_create_process (void)
1397 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1398 current_event
.dwProcessId
);
1399 if (current_process_handle
!= NULL
)
1400 open_process_used
= 1;
1403 error (_("OpenProcess call failed, GetLastError = %u"),
1404 (unsigned) GetLastError ());
1405 /* We can not debug anything in that case. */
1408 = windows_add_thread (ptid_t (current_event
.dwProcessId
, 0,
1409 current_event
.dwThreadId
),
1410 current_event
.u
.CreateThread
.hThread
,
1411 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1412 true /* main_thread_p */);
1413 return current_event
.dwThreadId
;
1417 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1419 windows_thread_info
*th
;
1420 DWORD continue_status
= DBG_CONTINUE
;
1422 /* A specific PTID means `step only this thread id'. */
1423 int resume_all
= ptid
== minus_one_ptid
;
1425 /* If we're continuing all threads, it's the current inferior that
1426 should be handled specially. */
1428 ptid
= inferior_ptid
;
1430 if (sig
!= GDB_SIGNAL_0
)
1432 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1434 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1436 else if (sig
== last_sig
)
1437 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1440 /* This code does not seem to work, because
1441 the kernel does probably not consider changes in the ExceptionRecord
1442 structure when passing the exception to the inferior.
1443 Note that this seems possible in the exception handler itself. */
1445 for (const xlate_exception
&x
: xlate
)
1448 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1450 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1453 if (continue_status
== DBG_CONTINUE
)
1455 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1459 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1463 last_sig
= GDB_SIGNAL_0
;
1465 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1466 ptid
.pid (), ptid
.tid (), step
, sig
));
1468 /* Get context for currently selected thread. */
1469 th
= thread_rec (inferior_ptid
.tid (), FALSE
);
1474 /* Single step by setting t bit. */
1475 struct regcache
*regcache
= get_current_regcache ();
1476 struct gdbarch
*gdbarch
= regcache
->arch ();
1477 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1478 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1481 if (th
->context
.ContextFlags
)
1483 if (debug_registers_changed
)
1485 th
->context
.Dr0
= dr
[0];
1486 th
->context
.Dr1
= dr
[1];
1487 th
->context
.Dr2
= dr
[2];
1488 th
->context
.Dr3
= dr
[3];
1489 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1490 th
->context
.Dr7
= dr
[7];
1492 CHECK (SetThreadContext (th
->h
, &th
->context
));
1493 th
->context
.ContextFlags
= 0;
1497 /* Allow continuing with the same signal that interrupted us.
1498 Otherwise complain. */
1501 windows_continue (continue_status
, -1, 0);
1503 windows_continue (continue_status
, ptid
.tid (), 0);
1506 /* Ctrl-C handler used when the inferior is not run in the same console. The
1507 handler is in charge of interrupting the inferior using DebugBreakProcess.
1508 Note that this function is not available prior to Windows XP. In this case
1509 we emit a warning. */
1511 ctrl_c_handler (DWORD event_type
)
1513 const int attach_flag
= current_inferior ()->attach_flag
;
1515 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1516 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1519 /* If the inferior and the debugger share the same console, do nothing as
1520 the inferior has also received the Ctrl-C event. */
1521 if (!new_console
&& !attach_flag
)
1524 if (!DebugBreakProcess (current_process_handle
))
1525 warning (_("Could not interrupt program. "
1526 "Press Ctrl-c in the program console."));
1528 /* Return true to tell that Ctrl-C has been handled. */
1532 /* Get the next event from the child. Returns a non-zero thread id if the event
1533 requires handling by WFI (or whatever). */
1535 get_windows_debug_event (struct target_ops
*ops
,
1536 int pid
, struct target_waitstatus
*ourstatus
)
1539 DWORD continue_status
, event_code
;
1540 windows_thread_info
*th
;
1541 static windows_thread_info dummy_thread_info
;
1542 DWORD thread_id
= 0;
1544 last_sig
= GDB_SIGNAL_0
;
1546 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1550 continue_status
= DBG_CONTINUE
;
1552 event_code
= current_event
.dwDebugEventCode
;
1553 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1555 have_saved_context
= 0;
1559 case CREATE_THREAD_DEBUG_EVENT
:
1560 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1561 (unsigned) current_event
.dwProcessId
,
1562 (unsigned) current_event
.dwThreadId
,
1563 "CREATE_THREAD_DEBUG_EVENT"));
1564 if (saw_create
!= 1)
1566 struct inferior
*inf
;
1567 inf
= find_inferior_pid (current_event
.dwProcessId
);
1568 if (!saw_create
&& inf
->attach_flag
)
1570 /* Kludge around a Windows bug where first event is a create
1571 thread event. Caused when attached process does not have
1573 thread_id
= fake_create_process ();
1579 /* Record the existence of this thread. */
1580 thread_id
= current_event
.dwThreadId
;
1581 th
= windows_add_thread
1582 (ptid_t (current_event
.dwProcessId
, 0, current_event
.dwThreadId
),
1583 current_event
.u
.CreateThread
.hThread
,
1584 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1585 false /* main_thread_p */);
1589 case EXIT_THREAD_DEBUG_EVENT
:
1590 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1591 (unsigned) current_event
.dwProcessId
,
1592 (unsigned) current_event
.dwThreadId
,
1593 "EXIT_THREAD_DEBUG_EVENT"));
1594 windows_delete_thread (ptid_t (current_event
.dwProcessId
, 0,
1595 current_event
.dwThreadId
),
1596 current_event
.u
.ExitThread
.dwExitCode
,
1597 false /* main_thread_p */);
1598 th
= &dummy_thread_info
;
1601 case CREATE_PROCESS_DEBUG_EVENT
:
1602 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1603 (unsigned) current_event
.dwProcessId
,
1604 (unsigned) current_event
.dwThreadId
,
1605 "CREATE_PROCESS_DEBUG_EVENT"));
1606 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1607 if (++saw_create
!= 1)
1610 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1611 /* Add the main thread. */
1612 th
= windows_add_thread
1613 (ptid_t (current_event
.dwProcessId
, 0,
1614 current_event
.dwThreadId
),
1615 current_event
.u
.CreateProcessInfo
.hThread
,
1616 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
,
1617 true /* main_thread_p */);
1618 thread_id
= current_event
.dwThreadId
;
1621 case EXIT_PROCESS_DEBUG_EVENT
:
1622 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1623 (unsigned) current_event
.dwProcessId
,
1624 (unsigned) current_event
.dwThreadId
,
1625 "EXIT_PROCESS_DEBUG_EVENT"));
1626 if (!windows_initialization_done
)
1628 target_terminal::ours ();
1629 target_mourn_inferior (inferior_ptid
);
1630 error (_("During startup program exited with code 0x%x."),
1631 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1633 else if (saw_create
== 1)
1635 windows_delete_thread (ptid_t (current_event
.dwProcessId
, 0,
1636 current_event
.dwThreadId
),
1637 0, true /* main_thread_p */);
1638 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1639 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1640 thread_id
= current_event
.dwThreadId
;
1644 case LOAD_DLL_DEBUG_EVENT
:
1645 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1646 (unsigned) current_event
.dwProcessId
,
1647 (unsigned) current_event
.dwThreadId
,
1648 "LOAD_DLL_DEBUG_EVENT"));
1649 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1650 if (saw_create
!= 1 || ! windows_initialization_done
)
1652 catch_errors (handle_load_dll
);
1653 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1654 ourstatus
->value
.integer
= 0;
1655 thread_id
= current_event
.dwThreadId
;
1658 case UNLOAD_DLL_DEBUG_EVENT
:
1659 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1660 (unsigned) current_event
.dwProcessId
,
1661 (unsigned) current_event
.dwThreadId
,
1662 "UNLOAD_DLL_DEBUG_EVENT"));
1663 if (saw_create
!= 1 || ! windows_initialization_done
)
1665 catch_errors (handle_unload_dll
);
1666 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1667 ourstatus
->value
.integer
= 0;
1668 thread_id
= current_event
.dwThreadId
;
1671 case EXCEPTION_DEBUG_EVENT
:
1672 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1673 (unsigned) current_event
.dwProcessId
,
1674 (unsigned) current_event
.dwThreadId
,
1675 "EXCEPTION_DEBUG_EVENT"));
1676 if (saw_create
!= 1)
1678 switch (handle_exception (ourstatus
))
1680 case HANDLE_EXCEPTION_UNHANDLED
:
1682 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1684 case HANDLE_EXCEPTION_HANDLED
:
1685 thread_id
= current_event
.dwThreadId
;
1687 case HANDLE_EXCEPTION_IGNORED
:
1688 continue_status
= DBG_CONTINUE
;
1693 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1694 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1695 (unsigned) current_event
.dwProcessId
,
1696 (unsigned) current_event
.dwThreadId
,
1697 "OUTPUT_DEBUG_STRING_EVENT"));
1698 if (saw_create
!= 1)
1700 thread_id
= handle_output_debug_string (ourstatus
);
1704 if (saw_create
!= 1)
1706 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1707 (unsigned) current_event
.dwProcessId
,
1708 (unsigned) current_event
.dwThreadId
);
1709 printf_unfiltered (" unknown event code %u\n",
1710 (unsigned) current_event
.dwDebugEventCode
);
1714 if (!thread_id
|| saw_create
!= 1)
1716 CHECK (windows_continue (continue_status
, -1, 0));
1720 inferior_ptid
= ptid_t (current_event
.dwProcessId
, 0, thread_id
);
1721 current_thread
= th
;
1722 if (!current_thread
)
1723 current_thread
= thread_rec (thread_id
, TRUE
);
1730 /* Wait for interesting events to occur in the target process. */
1732 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1737 /* We loop when we get a non-standard exception rather than return
1738 with a SPURIOUS because resume can try and step or modify things,
1739 which needs a current_thread->h. But some of these exceptions mark
1740 the birth or death of threads, which mean that the current thread
1741 isn't necessarily what you think it is. */
1747 /* If the user presses Ctrl-c while the debugger is waiting
1748 for an event, he expects the debugger to interrupt his program
1749 and to get the prompt back. There are two possible situations:
1751 - The debugger and the program do not share the console, in
1752 which case the Ctrl-c event only reached the debugger.
1753 In that case, the ctrl_c handler will take care of interrupting
1754 the inferior. Note that this case is working starting with
1755 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1758 - The debugger and the program share the same console, in which
1759 case both debugger and inferior will receive the Ctrl-c event.
1760 In that case the ctrl_c handler will ignore the event, as the
1761 Ctrl-c event generated inside the inferior will trigger the
1762 expected debug event.
1764 FIXME: brobecker/2008-05-20: If the inferior receives the
1765 signal first and the delay until GDB receives that signal
1766 is sufficiently long, GDB can sometimes receive the SIGINT
1767 after we have unblocked the CTRL+C handler. This would
1768 lead to the debugger stopping prematurely while handling
1769 the new-thread event that comes with the handling of the SIGINT
1770 inside the inferior, and then stop again immediately when
1771 the user tries to resume the execution in the inferior.
1772 This is a classic race that we should try to fix one day. */
1773 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1774 retval
= get_windows_debug_event (this, pid
, ourstatus
);
1775 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1778 return ptid_t (current_event
.dwProcessId
, 0, retval
);
1783 if (deprecated_ui_loop_hook
!= NULL
)
1784 detach
= deprecated_ui_loop_hook (0);
1792 /* Iterate over all DLLs currently mapped by our inferior, and
1793 add them to our list of solibs. */
1796 windows_add_all_dlls (void)
1798 HMODULE dummy_hmodule
;
1803 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
1804 sizeof (HMODULE
), &cb_needed
) == 0)
1810 hmodules
= (HMODULE
*) alloca (cb_needed
);
1811 if (EnumProcessModules (current_process_handle
, hmodules
,
1812 cb_needed
, &cb_needed
) == 0)
1815 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
1819 wchar_t dll_name
[__PMAX
];
1822 char dll_name
[__PMAX
];
1825 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
1826 &mi
, sizeof (mi
)) == 0)
1828 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
1829 dll_name
, sizeof (dll_name
)) == 0)
1832 wcstombs (name
, dll_name
, __PMAX
);
1837 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
1838 solib_end
= solib_end
->next
;
1843 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1846 struct inferior
*inf
;
1848 last_sig
= GDB_SIGNAL_0
;
1850 exception_count
= 0;
1851 open_process_used
= 0;
1852 debug_registers_changed
= 0;
1853 debug_registers_used
= 0;
1854 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1857 cygwin_load_start
= cygwin_load_end
= 0;
1859 current_event
.dwProcessId
= pid
;
1860 memset (¤t_event
, 0, sizeof (current_event
));
1861 if (!target_is_pushed (ops
))
1863 disable_breakpoints_in_shlibs ();
1864 windows_clear_solib ();
1865 clear_proceed_status (0);
1866 init_wait_for_inferior ();
1868 inf
= current_inferior ();
1869 inferior_appeared (inf
, pid
);
1870 inf
->attach_flag
= attaching
;
1872 /* Make the new process the current inferior, so terminal handling
1873 can rely on it. When attaching, we don't know about any thread
1874 id here, but that's OK --- nothing should be referencing the
1875 current thread until we report an event out of windows_wait. */
1876 inferior_ptid
= ptid_t (pid
);
1878 target_terminal::init ();
1879 target_terminal::inferior ();
1881 windows_initialization_done
= 0;
1885 struct target_waitstatus status
;
1887 ops
->wait (minus_one_ptid
, &status
, 0);
1889 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
1891 if (status
.kind
!= TARGET_WAITKIND_LOADED
1892 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
1895 ops
->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
1898 /* Now that the inferior has been started and all DLLs have been mapped,
1899 we can iterate over all DLLs and load them in.
1901 We avoid doing it any earlier because, on certain versions of Windows,
1902 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
1903 we have seen on Windows 8.1 that the ntdll.dll load event does not
1904 include the DLL name, preventing us from creating an associated SO.
1905 A possible explanation is that ntdll.dll might be mapped before
1906 the SO info gets created by the Windows system -- ntdll.dll is
1907 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
1908 do not seem to suffer from that problem.
1910 Rather than try to work around this sort of issue, it is much
1911 simpler to just ignore DLL load/unload events during the startup
1912 phase, and then process them all in one batch now. */
1913 windows_add_all_dlls ();
1915 windows_initialization_done
= 1;
1919 /* Try to set or remove a user privilege to the current process. Return -1
1920 if that fails, the previous setting of that privilege otherwise.
1922 This code is copied from the Cygwin source code and rearranged to allow
1923 dynamically loading of the needed symbols from advapi32 which is only
1924 available on NT/2K/XP. */
1926 set_process_privilege (const char *privilege
, BOOL enable
)
1928 HANDLE token_hdl
= NULL
;
1930 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1934 if (!OpenProcessToken (GetCurrentProcess (),
1935 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1939 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
1942 new_priv
.PrivilegeCount
= 1;
1943 new_priv
.Privileges
[0].Luid
= restore_priv
;
1944 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1946 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1947 sizeof orig_priv
, &orig_priv
, &size
))
1950 /* Disabled, otherwise every `attach' in an unprivileged user session
1951 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1952 windows_attach(). */
1953 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1954 be enabled. GetLastError () returns an correct error code, though. */
1955 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1959 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1963 CloseHandle (token_hdl
);
1968 /* Attach to process PID, then initialize for debugging it. */
1971 windows_nat_target::attach (const char *args
, int from_tty
)
1976 pid
= parse_pid_to_attach (args
);
1978 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1980 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1981 printf_unfiltered ("This can cause attach to "
1982 "fail on Windows NT/2K/XP\n");
1985 windows_init_thread_list ();
1986 ok
= DebugActiveProcess (pid
);
1992 /* Try fall back to Cygwin pid. */
1993 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1996 ok
= DebugActiveProcess (pid
);
2001 error (_("Can't attach to process."));
2003 DebugSetProcessKillOnExit (FALSE
);
2007 char *exec_file
= (char *) get_exec_file (0);
2010 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
2011 target_pid_to_str (ptid_t (pid
)).c_str ());
2013 printf_unfiltered ("Attaching to %s\n",
2014 target_pid_to_str (ptid_t (pid
)).c_str ());
2017 do_initial_windows_stuff (this, pid
, 1);
2018 target_terminal::ours ();
2022 windows_nat_target::detach (inferior
*inf
, int from_tty
)
2026 ptid_t ptid
= minus_one_ptid
;
2027 resume (ptid
, 0, GDB_SIGNAL_0
);
2029 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
2031 error (_("Can't detach process %u (error %u)"),
2032 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
2035 DebugSetProcessKillOnExit (FALSE
);
2037 if (detached
&& from_tty
)
2039 const char *exec_file
= get_exec_file (0);
2042 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
2043 (unsigned) current_event
.dwProcessId
);
2046 x86_cleanup_dregs ();
2047 inferior_ptid
= null_ptid
;
2048 detach_inferior (inf
);
2050 maybe_unpush_target ();
2053 /* Try to determine the executable filename.
2055 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2057 Upon success, the filename is stored inside EXE_NAME_RET, and
2058 this function returns nonzero.
2060 Otherwise, this function returns zero and the contents of
2061 EXE_NAME_RET is undefined. */
2064 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2071 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2072 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2075 /* We know the executable is always first in the list of modules,
2076 which we just fetched. So no need to fetch more. */
2080 /* Cygwin prefers that the path be in /x/y/z format, so extract
2081 the filename into a temporary buffer first, and then convert it
2082 to POSIX format into the destination buffer. */
2083 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2085 len
= GetModuleFileNameEx (current_process_handle
,
2086 dh_buf
, pathbuf
, exe_name_max_len
);
2088 error (_("Error getting executable filename: %u."),
2089 (unsigned) GetLastError ());
2090 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2091 exe_name_max_len
) < 0)
2092 error (_("Error converting executable filename to POSIX: %d."), errno
);
2095 len
= GetModuleFileNameEx (current_process_handle
,
2096 dh_buf
, exe_name_ret
, exe_name_max_len
);
2098 error (_("Error getting executable filename: %u."),
2099 (unsigned) GetLastError ());
2102 return 1; /* success */
2105 /* The pid_to_exec_file target_ops method for this platform. */
2108 windows_nat_target::pid_to_exec_file (int pid
)
2110 static char path
[__PMAX
];
2112 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2114 char procexe
[sizeof ("/proc/4294967295/exe")];
2116 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2117 nchars
= readlink (procexe
, path
, sizeof(path
));
2118 if (nchars
> 0 && nchars
< sizeof (path
))
2120 path
[nchars
] = '\0'; /* Got it */
2125 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2126 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2127 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2133 /* Print status information about what we're accessing. */
2136 windows_nat_target::files_info ()
2138 struct inferior
*inf
= current_inferior ();
2140 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2141 inf
->attach_flag
? "attached" : "child",
2142 target_pid_to_str (inferior_ptid
).c_str ());
2145 /* Modify CreateProcess parameters for use of a new separate console.
2147 *FLAGS: DWORD parameter for general process creation flags.
2148 *SI: STARTUPINFO structure, for which the console window size and
2149 console buffer size is filled in if GDB is running in a console.
2150 to create the new console.
2151 The size of the used font is not available on all versions of
2152 Windows OS. Furthermore, the current font might not be the default
2153 font, but this is still better than before.
2154 If the windows and buffer sizes are computed,
2155 SI->DWFLAGS is changed so that this information is used
2156 by CreateProcess function. */
2159 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2161 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2162 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2164 if (hconsole
!= INVALID_HANDLE_VALUE
)
2166 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2168 CONSOLE_FONT_INFO cfi
;
2170 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2171 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2172 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2173 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2174 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2176 si
->dwXSize
*= font_size
.X
;
2180 si
->dwYSize
*= font_size
.Y
;
2183 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2184 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2185 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2187 *flags
|= CREATE_NEW_CONSOLE
;
2191 /* Function called by qsort to sort environment strings. */
2194 envvar_cmp (const void *a
, const void *b
)
2196 const char **p
= (const char **) a
;
2197 const char **q
= (const char **) b
;
2198 return strcasecmp (*p
, *q
);
2204 clear_win32_environment (char **env
)
2208 wchar_t *copy
= NULL
, *equalpos
;
2210 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2212 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2213 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2214 mbstowcs (copy
, env
[i
], len
);
2215 equalpos
= wcschr (copy
, L
'=');
2218 SetEnvironmentVariableW (copy
, NULL
);
2226 /* Redirection of inferior I/O streams for native MS-Windows programs.
2227 Unlike on Unix, where this is handled by invoking the inferior via
2228 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2230 The official documentation of the cmd.exe redirection features is here:
2232 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2234 (That page talks about Windows XP, but there's no newer
2235 documentation, so we assume later versions of cmd.exe didn't change
2238 Caveat: the documentation on that page seems to include a few lies.
2239 For example, it describes strange constructs 1<&2 and 2<&1, which
2240 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2241 think the cmd.exe parser of the redirection symbols simply doesn't
2242 care about the < vs > distinction in these cases. Therefore, the
2243 supported features are explicitly documented below.
2245 The emulation below aims at supporting all the valid use cases
2246 supported by cmd.exe, which include:
2248 < FILE redirect standard input from FILE
2249 0< FILE redirect standard input from FILE
2250 <&N redirect standard input from file descriptor N
2251 0<&N redirect standard input from file descriptor N
2252 > FILE redirect standard output to FILE
2253 >> FILE append standard output to FILE
2254 1>> FILE append standard output to FILE
2255 >&N redirect standard output to file descriptor N
2256 1>&N redirect standard output to file descriptor N
2257 >>&N append standard output to file descriptor N
2258 1>>&N append standard output to file descriptor N
2259 2> FILE redirect standard error to FILE
2260 2>> FILE append standard error to FILE
2261 2>&N redirect standard error to file descriptor N
2262 2>>&N append standard error to file descriptor N
2264 Note that using N > 2 in the above construct is supported, but
2265 requires that the corresponding file descriptor be open by some
2266 means elsewhere or outside GDB. Also note that using ">&0" or
2267 "<&2" will generally fail, because the file descriptor redirected
2268 from is normally open in an incompatible mode (e.g., FD 0 is open
2269 for reading only). IOW, use of such tricks is not recommended;
2270 you are on your own.
2272 We do NOT support redirection of file descriptors above 2, as in
2273 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2274 that needs special handling in the startup code that MinGW
2275 doesn't have). Pipes are also not supported.
2277 As for invalid use cases, where the redirection contains some
2278 error, the emulation below will detect that and produce some
2279 error and/or failure. But the behavior in those cases is not
2280 bug-for-bug compatible with what cmd.exe does in those cases.
2281 That's because what cmd.exe does then is not well defined, and
2282 seems to be a side effect of the cmd.exe parsing of the command
2283 line more than anything else. For example, try redirecting to an
2284 invalid file name, as in "> foo:bar".
2286 There are also minor syntactic deviations from what cmd.exe does
2287 in some corner cases. For example, it doesn't support the likes
2288 of "> &foo" to mean redirect to file named literally "&foo"; we
2289 do support that here, because that, too, sounds like some issue
2290 with the cmd.exe parser. Another nicety is that we support
2291 redirection targets that use file names with forward slashes,
2292 something cmd.exe doesn't -- this comes in handy since GDB
2293 file-name completion can be used when typing the command line for
2296 /* Support routines for redirecting standard handles of the inferior. */
2298 /* Parse a single redirection spec, open/duplicate the specified
2299 file/fd, and assign the appropriate value to one of the 3 standard
2300 file descriptors. */
2302 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2304 int *fd
, ref_fd
= -2;
2306 const char *fname
= redir_string
+ 1;
2307 int rc
= *redir_string
;
2322 fd
= (rc
== '2') ? err
: out
;
2323 mode
= O_WRONLY
| O_CREAT
;
2336 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2338 /* A reference to a file descriptor. */
2340 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2341 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2343 /* Don't allow redirection when open modes are incompatible. */
2344 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2345 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2352 else if (ref_fd
== 1)
2354 else if (ref_fd
== 2)
2364 fname
++; /* skip the separator space */
2365 /* If the descriptor is already open, close it. This allows
2366 multiple specs of redirections for the same stream, which is
2367 somewhat nonsensical, but still valid and supported by cmd.exe.
2368 (But cmd.exe only opens a single file in this case, the one
2369 specified by the last redirection spec on the command line.) */
2374 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2378 else if (ref_fd
== -1)
2379 *fd
= -1; /* reset to default destination */
2382 *fd
= _dup (ref_fd
);
2386 /* _open just sets a flag for O_APPEND, which won't be passed to the
2387 inferior, so we need to actually move the file pointer. */
2388 if ((mode
& O_APPEND
) != 0)
2389 _lseek (*fd
, 0L, SEEK_END
);
2393 /* Canonicalize a single redirection spec and set up the corresponding
2394 file descriptor as specified. */
2396 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2398 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2400 const char *start
= s
;
2403 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2404 if ((*start
== '>' || *start
== '1' || *start
== '2')
2408 if (*s
== '>' && *start
!= '>')
2411 else if (*start
== '0' && *s
== '<')
2413 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2416 while (isspace (*s
)) /* skip whitespace before file name */
2418 *d
++ = ' '; /* separate file name with a single space */
2421 /* Copy the file name. */
2424 /* Remove quoting characters from the file name in buf[]. */
2425 if (*s
== '"') /* could support '..' quoting here */
2429 else if (*s
== quote
)
2437 else if (*s
== '\\')
2439 if (s
[1] == '"') /* could support '..' here */
2443 else if (isspace (*s
) && !quote
)
2447 if (d
- buf
>= sizeof (buf
) - 1)
2449 errno
= ENAMETOOLONG
;
2455 /* Windows doesn't allow redirection characters in file names, so we
2456 can bail out early if they use them, or if there's no target file
2457 name after the redirection symbol. */
2458 if (d
[-1] == '>' || d
[-1] == '<')
2463 if (redir_open (buf
, inp
, out
, err
) == 0)
2468 /* Parse the command line for redirection specs and prepare the file
2469 descriptors for the 3 standard streams accordingly. */
2471 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2472 int *inp
, int *out
, int *err
)
2474 const char *s
= cmd_orig
;
2477 bool retval
= false;
2479 while (isspace (*s
))
2484 if (*s
== '"') /* could also support '..' quoting here */
2488 else if (*s
== quote
)
2491 else if (*s
== '\\')
2493 if (s
[1] == '"') /* escaped quote char */
2498 /* Process a single redirection candidate. */
2499 if (*s
== '<' || *s
== '>'
2500 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2501 || (*s
== '0' && s
[1] == '<'))
2503 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2517 #endif /* !__CYGWIN__ */
2519 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2520 EXEC_FILE is the file to run.
2521 ALLARGS is a string containing the arguments to the program.
2522 ENV is the environment vector to pass. Errors reported with error(). */
2525 windows_nat_target::create_inferior (const char *exec_file
,
2526 const std::string
&origallargs
,
2527 char **in_env
, int from_tty
)
2531 cygwin_buf_t real_path
[__PMAX
];
2532 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2533 cygwin_buf_t infcwd
[__PMAX
];
2535 cygwin_buf_t
*toexec
;
2536 cygwin_buf_t
*cygallargs
;
2538 char **old_env
= NULL
;
2542 int ostdin
, ostdout
, ostderr
;
2543 #else /* !__CYGWIN__ */
2544 char shell
[__PMAX
]; /* Path to shell */
2546 char *args
, *allargs_copy
;
2547 size_t args_len
, allargs_len
;
2548 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2549 HANDLE tty
= INVALID_HANDLE_VALUE
;
2550 bool redirected
= false;
2557 #endif /* !__CYGWIN__ */
2558 const char *allargs
= origallargs
.c_str ();
2559 PROCESS_INFORMATION pi
;
2562 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2565 error (_("No executable specified, use `target exec'."));
2567 const char *inferior_cwd
= get_inferior_cwd ();
2568 std::string expanded_infcwd
;
2569 if (inferior_cwd
!= NULL
)
2571 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
2572 /* Mirror slashes on inferior's cwd. */
2573 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
2575 inferior_cwd
= expanded_infcwd
.c_str ();
2578 memset (&si
, 0, sizeof (si
));
2579 si
.cb
= sizeof (si
);
2582 flags
|= CREATE_NEW_PROCESS_GROUP
;
2585 windows_set_console_info (&si
, &flags
);
2590 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2591 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2592 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2593 error (_("Error starting executable: %d"), errno
);
2596 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2597 if (len
== (size_t) -1)
2598 error (_("Error starting executable: %d"), errno
);
2599 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2600 mbstowcs (cygallargs
, allargs
, len
);
2601 #else /* !__USEWIDE */
2602 cygallargs
= allargs
;
2608 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2609 error (_("Error starting executable via shell: %d"), errno
);
2611 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2612 + mbstowcs (NULL
, allargs
, 0) + 2;
2613 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2614 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2615 #else /* !__USEWIDE */
2616 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2617 + strlen (allargs
) + 2);
2618 cygallargs
= (char *) alloca (len
);
2619 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2620 #endif /* __USEWIDE */
2622 flags
|= DEBUG_PROCESS
;
2625 if (inferior_cwd
!= NULL
2626 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
2627 infcwd
, strlen (inferior_cwd
)) < 0)
2628 error (_("Error converting inferior cwd: %d"), errno
);
2631 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2632 * sizeof (wchar_t));
2633 wcscpy (args
, toexec
);
2634 wcscat (args
, L
" ");
2635 wcscat (args
, cygallargs
);
2636 #else /* !__USEWIDE */
2637 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2638 strcpy (args
, toexec
);
2640 strcat (args
, cygallargs
);
2641 #endif /* !__USEWIDE */
2643 #ifdef CW_CVT_ENV_TO_WINENV
2644 /* First try to create a direct Win32 copy of the POSIX environment. */
2645 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2646 if (w32_env
!= (PWCHAR
) -1)
2647 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2649 /* If that fails, fall back to old method tweaking GDB's environment. */
2650 #endif /* CW_CVT_ENV_TO_WINENV */
2652 /* Reset all Win32 environment variables to avoid leftover on next run. */
2653 clear_win32_environment (environ
);
2654 /* Prepare the environment vars for CreateProcess. */
2657 cygwin_internal (CW_SYNC_WINENV
);
2661 if (!inferior_io_terminal
)
2662 tty
= ostdin
= ostdout
= ostderr
= -1;
2665 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2668 print_sys_errmsg (inferior_io_terminal
, errno
);
2669 ostdin
= ostdout
= ostderr
= -1;
2682 windows_init_thread_list ();
2683 ret
= CreateProcess (0,
2684 args
, /* command line */
2685 NULL
, /* Security */
2687 TRUE
, /* inherit handles */
2688 flags
, /* start flags */
2689 w32_env
, /* environment */
2690 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
2695 /* Just free the Win32 environment, if it could be created. */
2699 /* Reset all environment variables to avoid leftover on next run. */
2700 clear_win32_environment (in_env
);
2701 /* Restore normal GDB environment variables. */
2703 cygwin_internal (CW_SYNC_WINENV
);
2716 #else /* !__CYGWIN__ */
2717 allargs_len
= strlen (allargs
);
2718 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
2719 if (strpbrk (allargs_copy
, "<>") != NULL
)
2724 redirect_inferior_handles (allargs
, allargs_copy
,
2725 &fd_inp
, &fd_out
, &fd_err
);
2727 warning (_("Error in redirection: %s."), strerror (errno
));
2730 allargs_len
= strlen (allargs_copy
);
2732 /* If not all the standard streams are redirected by the command
2733 line, use inferior_io_terminal for those which aren't. */
2734 if (inferior_io_terminal
2735 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
2737 SECURITY_ATTRIBUTES sa
;
2738 sa
.nLength
= sizeof(sa
);
2739 sa
.lpSecurityDescriptor
= 0;
2740 sa
.bInheritHandle
= TRUE
;
2741 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2742 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2743 if (tty
== INVALID_HANDLE_VALUE
)
2744 warning (_("Warning: Failed to open TTY %s, error %#x."),
2745 inferior_io_terminal
, (unsigned) GetLastError ());
2747 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
2750 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
2751 else if (tty
!= INVALID_HANDLE_VALUE
)
2754 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
2756 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
2757 else if (tty
!= INVALID_HANDLE_VALUE
)
2758 si
.hStdOutput
= tty
;
2760 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
2762 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
2763 else if (tty
!= INVALID_HANDLE_VALUE
)
2766 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
2767 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2771 /* Build the command line, a space-separated list of tokens where
2772 the first token is the name of the module to be executed.
2773 To avoid ambiguities introduced by spaces in the module name,
2775 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
2776 args
= (char *) alloca (args_len
);
2777 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
2779 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2781 /* CreateProcess takes the environment list as a null terminated set of
2782 strings (i.e. two nulls terminate the list). */
2784 /* Get total size for env strings. */
2785 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2786 envlen
+= strlen (in_env
[i
]) + 1;
2788 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2789 env
= (char **) alloca (envsize
);
2790 memcpy (env
, in_env
, envsize
);
2791 /* Windows programs expect the environment block to be sorted. */
2792 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2794 w32env
= (char *) alloca (envlen
+ 1);
2796 /* Copy env strings into new buffer. */
2797 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2799 strcpy (temp
, env
[i
]);
2800 temp
+= strlen (temp
) + 1;
2803 /* Final nil string to terminate new env. */
2806 windows_init_thread_list ();
2807 ret
= CreateProcessA (0,
2808 args
, /* command line */
2809 NULL
, /* Security */
2811 TRUE
, /* inherit handles */
2812 flags
, /* start flags */
2813 w32env
, /* environment */
2814 inferior_cwd
, /* current directory */
2817 if (tty
!= INVALID_HANDLE_VALUE
)
2825 #endif /* !__CYGWIN__ */
2828 error (_("Error creating process %s, (error %u)."),
2829 exec_file
, (unsigned) GetLastError ());
2831 CloseHandle (pi
.hThread
);
2832 CloseHandle (pi
.hProcess
);
2834 if (useshell
&& shell
[0] != '\0')
2839 do_initial_windows_stuff (this, pi
.dwProcessId
, 0);
2841 /* windows_continue (DBG_CONTINUE, -1, 0); */
2845 windows_nat_target::mourn_inferior ()
2847 (void) windows_continue (DBG_CONTINUE
, -1, 0);
2848 x86_cleanup_dregs();
2849 if (open_process_used
)
2851 CHECK (CloseHandle (current_process_handle
));
2852 open_process_used
= 0;
2854 inf_child_target::mourn_inferior ();
2857 /* Send a SIGINT to the process group. This acts just like the user typed a
2858 ^C on the controlling terminal. */
2861 windows_nat_target::interrupt ()
2863 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2864 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
2865 registers_changed (); /* refresh register state */
2868 /* Helper for windows_xfer_partial that handles memory transfers.
2869 Arguments are like target_xfer_partial. */
2871 static enum target_xfer_status
2872 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2873 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2877 DWORD lasterror
= 0;
2879 if (writebuf
!= NULL
)
2881 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
2882 pulongest (len
), core_addr_to_string (memaddr
)));
2883 success
= WriteProcessMemory (current_process_handle
,
2884 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
2887 lasterror
= GetLastError ();
2888 FlushInstructionCache (current_process_handle
,
2889 (LPCVOID
) (uintptr_t) memaddr
, len
);
2893 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
2894 pulongest (len
), core_addr_to_string (memaddr
)));
2895 success
= ReadProcessMemory (current_process_handle
,
2896 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
2899 lasterror
= GetLastError ();
2901 *xfered_len
= (ULONGEST
) done
;
2902 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
2903 return TARGET_XFER_OK
;
2905 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
2909 windows_nat_target::kill ()
2911 CHECK (TerminateProcess (current_process_handle
, 0));
2915 if (!windows_continue (DBG_CONTINUE
, -1, 1))
2917 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
2919 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2923 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
2927 windows_nat_target::close ()
2929 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2930 inferior_ptid
.pid ()));
2933 /* Convert pid to printable format. */
2935 windows_nat_target::pid_to_str (ptid_t ptid
)
2937 if (ptid
.tid () != 0)
2938 return string_printf ("Thread %d.0x%lx", ptid
.pid (), ptid
.tid ());
2940 return normal_pid_to_str (ptid
);
2943 static enum target_xfer_status
2944 windows_xfer_shared_libraries (struct target_ops
*ops
,
2945 enum target_object object
, const char *annex
,
2946 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2947 ULONGEST offset
, ULONGEST len
,
2948 ULONGEST
*xfered_len
)
2950 struct obstack obstack
;
2956 return TARGET_XFER_E_IO
;
2958 obstack_init (&obstack
);
2959 obstack_grow_str (&obstack
, "<library-list>\n");
2960 for (so
= solib_start
.next
; so
; so
= so
->next
)
2962 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
2964 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
2965 (uintptr_t) li
->load_addr
,
2966 target_gdbarch (), &obstack
);
2968 obstack_grow_str0 (&obstack
, "</library-list>\n");
2970 buf
= (const char *) obstack_finish (&obstack
);
2971 len_avail
= strlen (buf
);
2972 if (offset
>= len_avail
)
2976 if (len
> len_avail
- offset
)
2977 len
= len_avail
- offset
;
2978 memcpy (readbuf
, buf
+ offset
, len
);
2981 obstack_free (&obstack
, NULL
);
2982 *xfered_len
= (ULONGEST
) len
;
2983 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
2986 enum target_xfer_status
2987 windows_nat_target::xfer_partial (enum target_object object
,
2988 const char *annex
, gdb_byte
*readbuf
,
2989 const gdb_byte
*writebuf
, ULONGEST offset
,
2990 ULONGEST len
, ULONGEST
*xfered_len
)
2994 case TARGET_OBJECT_MEMORY
:
2995 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
2997 case TARGET_OBJECT_LIBRARIES
:
2998 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
2999 writebuf
, offset
, len
, xfered_len
);
3002 if (beneath () == NULL
)
3004 /* This can happen when requesting the transfer of unsupported
3005 objects before a program has been started (and therefore
3006 with the current_target having no target beneath). */
3007 return TARGET_XFER_E_IO
;
3009 return beneath ()->xfer_partial (object
, annex
,
3010 readbuf
, writebuf
, offset
, len
,
3015 /* Provide thread local base, i.e. Thread Information Block address.
3016 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
3019 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
3021 windows_thread_info
*th
;
3023 th
= thread_rec (ptid
.tid (), 0);
3028 *addr
= th
->thread_local_base
;
3034 windows_nat_target::get_ada_task_ptid (long lwp
, long thread
)
3036 return ptid_t (inferior_ptid
.pid (), 0, lwp
);
3039 /* Implementation of the to_thread_name method. */
3042 windows_nat_target::thread_name (struct thread_info
*thr
)
3044 return thread_rec (thr
->ptid
.tid (), 0)->name
;
3049 _initialize_windows_nat (void)
3051 x86_dr_low
.set_control
= cygwin_set_dr7
;
3052 x86_dr_low
.set_addr
= cygwin_set_dr
;
3053 x86_dr_low
.get_addr
= cygwin_get_dr
;
3054 x86_dr_low
.get_status
= cygwin_get_dr6
;
3055 x86_dr_low
.get_control
= cygwin_get_dr7
;
3057 /* x86_dr_low.debug_register_length field is set by
3058 calling x86_set_debug_register_length function
3059 in processor windows specific native file. */
3061 add_inf_child_target (&the_windows_nat_target
);
3064 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3067 add_com ("signal-event", class_run
, signal_event_command
, _("\
3068 Signal a crashed process with event ID, to allow its debugging.\n\
3069 This command is needed in support of setting up GDB as JIT debugger on \
3070 MS-Windows. The command should be invoked from the GDB command line using \
3071 the '-ex' command-line option. The ID of the event that blocks the \
3072 crashed process will be supplied by the Windows JIT debugging mechanism."));
3075 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3076 Set use of shell to start subprocess."), _("\
3077 Show use of shell to start subprocess."), NULL
,
3079 NULL
, /* FIXME: i18n: */
3080 &setlist
, &showlist
);
3082 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3083 &cygwin_exceptions
, _("\
3084 Break when an exception is detected in the Cygwin DLL itself."), _("\
3085 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3087 NULL
, /* FIXME: i18n: */
3088 &setlist
, &showlist
);
3091 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3092 Set creation of new console when creating child process."), _("\
3093 Show creation of new console when creating child process."), NULL
,
3095 NULL
, /* FIXME: i18n: */
3096 &setlist
, &showlist
);
3098 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3099 Set creation of new group when creating child process."), _("\
3100 Show creation of new group when creating child process."), NULL
,
3102 NULL
, /* FIXME: i18n: */
3103 &setlist
, &showlist
);
3105 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3106 Set whether to display execution in child process."), _("\
3107 Show whether to display execution in child process."), NULL
,
3109 NULL
, /* FIXME: i18n: */
3110 &setlist
, &showlist
);
3112 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3113 Set whether to display kernel events in child process."), _("\
3114 Show whether to display kernel events in child process."), NULL
,
3116 NULL
, /* FIXME: i18n: */
3117 &setlist
, &showlist
);
3119 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3120 Set whether to display memory accesses in child process."), _("\
3121 Show whether to display memory accesses in child process."), NULL
,
3123 NULL
, /* FIXME: i18n: */
3124 &setlist
, &showlist
);
3126 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3127 &debug_exceptions
, _("\
3128 Set whether to display kernel exceptions in child process."), _("\
3129 Show whether to display kernel exceptions in child process."), NULL
,
3131 NULL
, /* FIXME: i18n: */
3132 &setlist
, &showlist
);
3134 init_w32_command_list ();
3136 add_cmd ("selector", class_info
, display_selectors
,
3137 _("Display selectors infos."),
3141 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3143 /* Pass the address ADDR to the inferior in the I'th debug register.
3144 Here we just store the address in dr array, the registers will be
3145 actually set up when windows_continue is called. */
3147 cygwin_set_dr (int i
, CORE_ADDR addr
)
3150 internal_error (__FILE__
, __LINE__
,
3151 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3153 debug_registers_changed
= 1;
3154 debug_registers_used
= 1;
3157 /* Pass the value VAL to the inferior in the DR7 debug control
3158 register. Here we just store the address in D_REGS, the watchpoint
3159 will be actually set up in windows_wait. */
3161 cygwin_set_dr7 (unsigned long val
)
3163 dr
[7] = (CORE_ADDR
) val
;
3164 debug_registers_changed
= 1;
3165 debug_registers_used
= 1;
3168 /* Get the value of debug register I from the inferior. */
3171 cygwin_get_dr (int i
)
3176 /* Get the value of the DR6 debug status register from the inferior.
3177 Here we just return the value stored in dr[6]
3178 by the last call to thread_rec for current_event.dwThreadId id. */
3179 static unsigned long
3180 cygwin_get_dr6 (void)
3182 return (unsigned long) dr
[6];
3185 /* Get the value of the DR7 debug status register from the inferior.
3186 Here we just return the value stored in dr[7] by the last call to
3187 thread_rec for current_event.dwThreadId id. */
3189 static unsigned long
3190 cygwin_get_dr7 (void)
3192 return (unsigned long) dr
[7];
3195 /* Determine if the thread referenced by "ptid" is alive
3196 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3197 it means that the thread has died. Otherwise it is assumed to be alive. */
3200 windows_nat_target::thread_alive (ptid_t ptid
)
3204 gdb_assert (ptid
.tid () != 0);
3207 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) != WAIT_OBJECT_0
;
3211 _initialize_check_for_gdb_ini (void)
3214 if (inhibit_gdbinit
)
3217 homedir
= getenv ("HOME");
3221 char *oldini
= (char *) alloca (strlen (homedir
) +
3222 sizeof ("gdb.ini") + 1);
3223 strcpy (oldini
, homedir
);
3224 p
= strchr (oldini
, '\0');
3225 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3227 strcpy (p
, "gdb.ini");
3228 if (access (oldini
, 0) == 0)
3230 int len
= strlen (oldini
);
3231 char *newini
= (char *) alloca (len
+ 2);
3233 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3234 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3235 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3240 /* Define dummy functions which always return error for the rare cases where
3241 these functions could not be found. */
3243 bad_DebugActiveProcessStop (DWORD w
)
3248 bad_DebugBreakProcess (HANDLE w
)
3253 bad_DebugSetProcessKillOnExit (BOOL w
)
3258 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3265 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3271 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3278 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3284 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3290 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3296 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3304 /* Load any functions which may not be available in ancient versions
3308 _initialize_loadable (void)
3312 #define GPA(m, func) \
3313 func = (func ## _ftype *) GetProcAddress (m, #func)
3315 hm
= LoadLibrary ("kernel32.dll");
3318 GPA (hm
, DebugActiveProcessStop
);
3319 GPA (hm
, DebugBreakProcess
);
3320 GPA (hm
, DebugSetProcessKillOnExit
);
3321 GPA (hm
, GetConsoleFontSize
);
3322 GPA (hm
, DebugActiveProcessStop
);
3323 GPA (hm
, GetCurrentConsoleFont
);
3326 /* Set variables to dummy versions of these processes if the function
3327 wasn't found in kernel32.dll. */
3328 if (!DebugBreakProcess
)
3329 DebugBreakProcess
= bad_DebugBreakProcess
;
3330 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3332 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3333 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3335 if (!GetConsoleFontSize
)
3336 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3337 if (!GetCurrentConsoleFont
)
3338 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3340 /* Load optional functions used for retrieving filename information
3341 associated with the currently debugged process or its dlls. */
3342 hm
= LoadLibrary ("psapi.dll");
3345 GPA (hm
, EnumProcessModules
);
3346 GPA (hm
, GetModuleInformation
);
3347 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3348 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3351 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3353 /* Set variables to dummy versions of these processes if the function
3354 wasn't found in psapi.dll. */
3355 EnumProcessModules
= bad_EnumProcessModules
;
3356 GetModuleInformation
= bad_GetModuleInformation
;
3357 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3358 /* This will probably fail on Windows 9x/Me. Let the user know
3359 that we're missing some functionality. */
3361 cannot automatically find executable file or library to read symbols.\n\
3362 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3365 hm
= LoadLibrary ("advapi32.dll");
3368 GPA (hm
, OpenProcessToken
);
3369 GPA (hm
, LookupPrivilegeValueA
);
3370 GPA (hm
, AdjustTokenPrivileges
);
3371 /* Only need to set one of these since if OpenProcessToken fails nothing
3373 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3374 || !AdjustTokenPrivileges
)
3375 OpenProcessToken
= bad_OpenProcessToken
;