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 "common/gdb_tilde_expand.h"
71 #include "common/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 */
240 static DWORD main_thread_id
; /* Thread ID of the main thread */
242 /* Counts of things. */
243 static int exception_count
= 0;
244 static int event_count
= 0;
245 static int saw_create
;
246 static int open_process_used
= 0;
249 static int new_console
= 0;
251 static int cygwin_exceptions
= 0;
253 static int new_group
= 1;
254 static int debug_exec
= 0; /* show execution */
255 static int debug_events
= 0; /* show events from kernel */
256 static int debug_memory
= 0; /* show target memory accesses */
257 static int debug_exceptions
= 0; /* show target exceptions */
258 static int useshell
= 0; /* use shell for subprocesses */
260 /* This vector maps GDB's idea of a register's number into an offset
261 in the windows exception context vector.
263 It also contains the bit mask needed to load the register in question.
265 The contents of this table can only be computed by the units
266 that provide CPU-specific support for Windows native debugging.
267 These units should set the table by calling
268 windows_set_context_register_offsets.
270 One day we could read a reg, we could inspect the context we
271 already have loaded, if it doesn't have the bit set that we need,
272 we read that set of registers in using GetThreadContext. If the
273 context already contains what we need, we just unpack it. Then to
274 write a register, first we have to ensure that the context contains
275 the other regs of the group, and then we copy the info in and set
278 static const int *mappings
;
280 /* The function to use in order to determine whether a register is
281 a segment register or not. */
282 static segment_register_p_ftype
*segment_register_p
;
284 /* See windows_nat_target::resume to understand why this is commented
287 /* This vector maps the target's idea of an exception (extracted
288 from the DEBUG_EVENT structure) to GDB's idea. */
290 struct xlate_exception
296 static const struct xlate_exception xlate
[] =
298 {EXCEPTION_ACCESS_VIOLATION
, GDB_SIGNAL_SEGV
},
299 {STATUS_STACK_OVERFLOW
, GDB_SIGNAL_SEGV
},
300 {EXCEPTION_BREAKPOINT
, GDB_SIGNAL_TRAP
},
301 {DBG_CONTROL_C
, GDB_SIGNAL_INT
},
302 {EXCEPTION_SINGLE_STEP
, GDB_SIGNAL_TRAP
},
303 {STATUS_FLOAT_DIVIDE_BY_ZERO
, GDB_SIGNAL_FPE
}
308 struct windows_nat_target final
: public x86_nat_target
<inf_child_target
>
310 void close () override
;
312 void attach (const char *, int) override
;
314 bool attach_no_wait () override
317 void detach (inferior
*, int) override
;
319 void resume (ptid_t
, int , enum gdb_signal
) override
;
321 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
323 void fetch_registers (struct regcache
*, int) override
;
324 void store_registers (struct regcache
*, int) override
;
326 enum target_xfer_status
xfer_partial (enum target_object object
,
329 const gdb_byte
*writebuf
,
330 ULONGEST offset
, ULONGEST len
,
331 ULONGEST
*xfered_len
) override
;
333 void files_info () override
;
335 void kill () override
;
337 void create_inferior (const char *, const std::string
&,
338 char **, int) override
;
340 void mourn_inferior () override
;
342 bool thread_alive (ptid_t ptid
) override
;
344 const char *pid_to_str (ptid_t
) override
;
346 void interrupt () override
;
348 char *pid_to_exec_file (int pid
) override
;
350 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
352 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
354 const char *thread_name (struct thread_info
*) override
;
357 static windows_nat_target the_windows_nat_target
;
359 /* Set the MAPPINGS static global to OFFSETS.
360 See the description of MAPPINGS for more details. */
363 windows_set_context_register_offsets (const int *offsets
)
368 /* See windows-nat.h. */
371 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
373 segment_register_p
= fun
;
377 check (BOOL ok
, const char *file
, int line
)
380 printf_filtered ("error return %s:%d was %u\n", file
, line
,
381 (unsigned) GetLastError ());
384 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
385 then also retrieve the context for this thread. If GET_CONTEXT is
386 negative, then don't suspend the thread. */
387 static windows_thread_info
*
388 thread_rec (DWORD id
, int get_context
)
390 windows_thread_info
*th
;
392 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
395 if (!th
->suspended
&& get_context
)
397 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
399 if (SuspendThread (th
->h
) == (DWORD
) -1)
401 DWORD err
= GetLastError ();
403 /* We get Access Denied (5) when trying to suspend
404 threads that Windows started on behalf of the
405 debuggee, usually when those threads are just
407 We can get Invalid Handle (6) if the main thread
409 if (err
!= ERROR_INVALID_HANDLE
410 && err
!= ERROR_ACCESS_DENIED
)
411 warning (_("SuspendThread (tid=0x%x) failed."
413 (unsigned) id
, (unsigned) err
);
419 else if (get_context
< 0)
421 th
->reload_context
= 1;
429 /* Add a thread to the thread list.
431 PTID is the ptid of the thread to be added.
432 H is its Windows handle.
433 TLB is its thread local base.
434 MAIN_THREAD_P should be true if the thread to be added is
435 the main thread, false otherwise. */
437 static windows_thread_info
*
438 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
, bool main_thread_p
)
440 windows_thread_info
*th
;
443 gdb_assert (ptid
.tid () != 0);
447 if ((th
= thread_rec (id
, FALSE
)))
450 th
= XCNEW (windows_thread_info
);
453 th
->thread_local_base
= (CORE_ADDR
) (uintptr_t) tlb
;
454 th
->next
= thread_head
.next
;
455 thread_head
.next
= th
;
457 /* Add this new thread to the list of threads.
459 To be consistent with what's done on other platforms, we add
460 the main thread silently (in reality, this thread is really
461 more of a process to the user than a thread). */
463 add_thread_silent (ptid
);
467 /* Set the debug registers for the new thread if they are used. */
468 if (debug_registers_used
)
470 /* Only change the value of the debug registers. */
471 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
472 CHECK (GetThreadContext (th
->h
, &th
->context
));
473 th
->context
.Dr0
= dr
[0];
474 th
->context
.Dr1
= dr
[1];
475 th
->context
.Dr2
= dr
[2];
476 th
->context
.Dr3
= dr
[3];
477 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
478 th
->context
.Dr7
= dr
[7];
479 CHECK (SetThreadContext (th
->h
, &th
->context
));
480 th
->context
.ContextFlags
= 0;
485 /* Clear out any old thread list and reinitialize it to a
488 windows_init_thread_list (void)
490 windows_thread_info
*th
= &thread_head
;
492 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
494 while (th
->next
!= NULL
)
496 windows_thread_info
*here
= th
->next
;
497 th
->next
= here
->next
;
500 thread_head
.next
= NULL
;
503 /* Delete a thread from the list of threads.
505 PTID is the ptid of the thread to be deleted.
506 EXIT_CODE is the thread's exit code.
507 MAIN_THREAD_P should be true if the thread to be deleted is
508 the main thread, false otherwise. */
511 windows_delete_thread (ptid_t ptid
, DWORD exit_code
, bool main_thread_p
)
513 windows_thread_info
*th
;
516 gdb_assert (ptid
.tid () != 0);
520 /* Emit a notification about the thread being deleted.
522 Note that no notification was printed when the main thread
523 was created, and thus, unless in verbose mode, we should be
524 symetrical, and avoid that notification for the main thread
528 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
));
529 else if (print_thread_events
&& !main_thread_p
)
530 printf_unfiltered (_("[%s exited with code %u]\n"),
531 target_pid_to_str (ptid
), (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
;
782 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386", -1));
787 if (bfd_check_format (abfd
.get (), bfd_object
))
788 text
= bfd_get_section_by_name (abfd
.get (), ".text");
793 /* The symbols in a dll are offset by 0x1000, which is the
794 offset from 0 of the first byte in an image - because of the
795 file header and the section alignment. */
796 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
798 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (abfd
.get (),
807 get_image_name (HANDLE h
, void *address
, int unicode
)
810 static char buf
[__PMAX
];
812 static char buf
[(2 * __PMAX
) + 1];
814 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
820 /* Attempt to read the name of the dll that was detected.
821 This is documented to work only when actively debugging
822 a program. It will not work for attached processes. */
826 /* See if we could read the address of a string, and that the
827 address isn't null. */
828 if (!ReadProcessMemory (h
, address
, &address_ptr
,
829 sizeof (address_ptr
), &done
)
830 || done
!= sizeof (address_ptr
) || !address_ptr
)
833 /* Find the length of the string. */
834 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
835 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
839 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
842 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
843 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
846 wcstombs (buf
, unicode_address
, __PMAX
);
848 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
856 /* Handle a DLL load event, and return 1.
858 This function assumes that this event did not occur during inferior
859 initialization, where their event info may be incomplete (see
860 do_initial_windows_stuff and windows_add_all_dlls for more info
861 on how we handle DLL loading during that phase). */
866 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
869 /* Try getting the DLL name via the lpImageName field of the event.
870 Note that Microsoft documents this fields as strictly optional,
871 in the sense that it might be NULL. And the first DLL event in
872 particular is explicitly documented as "likely not pass[ed]"
873 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
874 dll_name
= get_image_name (current_process_handle
,
875 event
->lpImageName
, event
->fUnicode
);
879 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
880 solib_end
= solib_end
->next
;
882 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
884 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
885 host_address_to_string (li
->load_addr
)));
889 windows_free_so (struct so_list
*so
)
891 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
897 /* Handle a DLL unload event.
898 Return 1 if successful, or zero otherwise.
900 This function assumes that this event did not occur during inferior
901 initialization, where their event info may be incomplete (see
902 do_initial_windows_stuff and windows_add_all_dlls for more info
903 on how we handle DLL loading during that phase). */
908 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
911 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
913 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
915 if (li_next
->load_addr
== lpBaseOfDll
)
917 struct so_list
*sodel
= so
->next
;
919 so
->next
= sodel
->next
;
922 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
924 windows_free_so (sodel
);
929 /* We did not find any DLL that was previously loaded at this address,
930 so register a complaint. We do not report an error, because we have
931 observed that this may be happening under some circumstances. For
932 instance, running 32bit applications on x64 Windows causes us to receive
933 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
934 events are apparently caused by the WOW layer, the interface between
935 32bit and 64bit worlds). */
936 complaint (_("dll starting at %s not found."),
937 host_address_to_string (lpBaseOfDll
));
940 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
944 catch_errors (void (*func
) ())
950 CATCH (ex
, RETURN_MASK_ALL
)
952 exception_print (gdb_stderr
, ex
);
957 /* Clear list of loaded DLLs. */
959 windows_clear_solib (void)
961 solib_start
.next
= NULL
;
962 solib_end
= &solib_start
;
966 signal_event_command (const char *args
, int from_tty
)
968 uintptr_t event_id
= 0;
969 char *endargs
= NULL
;
972 error (_("signal-event requires an argument (integer event id)"));
974 event_id
= strtoumax (args
, &endargs
, 10);
976 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
977 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
978 error (_("Failed to convert `%s' to event id"), args
);
980 SetEvent ((HANDLE
) event_id
);
981 CloseHandle ((HANDLE
) event_id
);
984 /* Handle DEBUG_STRING output from child process.
985 Cygwin prepends its messages with a "cygwin:". Interpret this as
986 a Cygwin signal. Otherwise just print the string as a warning. */
988 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
990 gdb::unique_xmalloc_ptr
<char> s
;
993 if (!target_read_string
994 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
996 || !s
|| !*(s
.get ()))
998 else if (!startswith (s
.get (), _CYGWIN_SIGNAL_STRING
))
1001 if (!startswith (s
.get (), "cYg"))
1004 char *p
= strchr (s
.get (), '\0');
1006 if (p
> s
.get () && *--p
== '\n')
1008 warning (("%s"), s
.get ());
1014 /* Got a cygwin signal marker. A cygwin signal is followed by
1015 the signal number itself and then optionally followed by the
1016 thread id and address to saved context within the DLL. If
1017 these are supplied, then the given thread is assumed to have
1018 issued the signal and the context from the thread is assumed
1019 to be stored at the given address in the inferior. Tell gdb
1020 to treat this like a real signal. */
1022 int sig
= strtol (s
.get () + sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
1023 gdb_signal gotasig
= gdb_signal_from_host (sig
);
1025 ourstatus
->value
.sig
= gotasig
;
1031 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1032 retval
= strtoul (p
, &p
, 0);
1034 retval
= main_thread_id
;
1035 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
1036 && ReadProcessMemory (current_process_handle
, x
,
1038 __COPY_CONTEXT_SIZE
, &n
)
1039 && n
== __COPY_CONTEXT_SIZE
)
1040 have_saved_context
= 1;
1049 display_selector (HANDLE thread
, DWORD sel
)
1052 if (GetThreadSelectorEntry (thread
, sel
, &info
))
1055 printf_filtered ("0x%03x: ", (unsigned) sel
);
1056 if (!info
.HighWord
.Bits
.Pres
)
1058 puts_filtered ("Segment not present\n");
1061 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1062 (info
.HighWord
.Bits
.BaseMid
<< 16)
1064 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1065 if (info
.HighWord
.Bits
.Granularity
)
1066 limit
= (limit
<< 12) | 0xfff;
1067 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1068 if (info
.HighWord
.Bits
.Default_Big
)
1069 puts_filtered(" 32-bit ");
1071 puts_filtered(" 16-bit ");
1072 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1075 puts_filtered ("Data (Read-Only, Exp-up");
1078 puts_filtered ("Data (Read/Write, Exp-up");
1081 puts_filtered ("Unused segment (");
1084 puts_filtered ("Data (Read/Write, Exp-down");
1087 puts_filtered ("Code (Exec-Only, N.Conf");
1090 puts_filtered ("Code (Exec/Read, N.Conf");
1093 puts_filtered ("Code (Exec-Only, Conf");
1096 puts_filtered ("Code (Exec/Read, Conf");
1099 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
1101 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1102 puts_filtered(", N.Acc");
1103 puts_filtered (")\n");
1104 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1105 puts_filtered("System selector ");
1106 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
1107 if (info
.HighWord
.Bits
.Granularity
)
1108 puts_filtered ("Page granular.\n");
1110 puts_filtered ("Byte granular.\n");
1115 DWORD err
= GetLastError ();
1116 if (err
== ERROR_NOT_SUPPORTED
)
1117 printf_filtered ("Function not supported\n");
1119 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1125 display_selectors (const char * args
, int from_tty
)
1127 if (!current_thread
)
1129 puts_filtered ("Impossible to display selectors now.\n");
1135 puts_filtered ("Selector $cs\n");
1136 display_selector (current_thread
->h
,
1137 current_thread
->context
.SegCs
);
1138 puts_filtered ("Selector $ds\n");
1139 display_selector (current_thread
->h
,
1140 current_thread
->context
.SegDs
);
1141 puts_filtered ("Selector $es\n");
1142 display_selector (current_thread
->h
,
1143 current_thread
->context
.SegEs
);
1144 puts_filtered ("Selector $ss\n");
1145 display_selector (current_thread
->h
,
1146 current_thread
->context
.SegSs
);
1147 puts_filtered ("Selector $fs\n");
1148 display_selector (current_thread
->h
,
1149 current_thread
->context
.SegFs
);
1150 puts_filtered ("Selector $gs\n");
1151 display_selector (current_thread
->h
,
1152 current_thread
->context
.SegGs
);
1157 sel
= parse_and_eval_long (args
);
1158 printf_filtered ("Selector \"%s\"\n",args
);
1159 display_selector (current_thread
->h
, sel
);
1163 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1164 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1165 host_address_to_string (\
1166 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1168 static handle_exception_result
1169 handle_exception (struct target_waitstatus
*ourstatus
)
1171 EXCEPTION_RECORD
*rec
= ¤t_event
.u
.Exception
.ExceptionRecord
;
1172 DWORD code
= rec
->ExceptionCode
;
1173 handle_exception_result result
= HANDLE_EXCEPTION_HANDLED
;
1175 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1177 /* Record the context of the current thread. */
1178 thread_rec (current_event
.dwThreadId
, -1);
1182 case EXCEPTION_ACCESS_VIOLATION
:
1183 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1184 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1187 /* See if the access violation happened within the cygwin DLL
1188 itself. Cygwin uses a kind of exception handling to deal
1189 with passed-in invalid addresses. gdb should not treat
1190 these as real SEGVs since they will be silently handled by
1191 cygwin. A real SEGV will (theoretically) be caught by
1192 cygwin later in the process and will be sent as a
1193 cygwin-specific-signal. So, ignore SEGVs if they show up
1194 within the text segment of the DLL itself. */
1196 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1198 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1199 && addr
< cygwin_load_end
))
1200 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1201 && startswith (fn
, "KERNEL32!IsBad")))
1202 return HANDLE_EXCEPTION_UNHANDLED
;
1206 case STATUS_STACK_OVERFLOW
:
1207 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1208 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1210 case STATUS_FLOAT_DENORMAL_OPERAND
:
1211 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1212 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1214 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1215 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1216 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1218 case STATUS_FLOAT_INEXACT_RESULT
:
1219 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1220 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1222 case STATUS_FLOAT_INVALID_OPERATION
:
1223 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1224 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1226 case STATUS_FLOAT_OVERFLOW
:
1227 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1228 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1230 case STATUS_FLOAT_STACK_CHECK
:
1231 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1232 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1234 case STATUS_FLOAT_UNDERFLOW
:
1235 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1236 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1238 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1239 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1240 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1242 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1243 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1244 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1246 case STATUS_INTEGER_OVERFLOW
:
1247 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1248 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1250 case EXCEPTION_BREAKPOINT
:
1251 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1252 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1255 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1256 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1258 case DBG_CONTROL_BREAK
:
1259 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1260 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1262 case EXCEPTION_SINGLE_STEP
:
1263 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1264 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1266 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1267 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1268 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1270 case EXCEPTION_PRIV_INSTRUCTION
:
1271 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1272 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1274 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1275 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1276 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1278 case MS_VC_EXCEPTION
:
1279 if (rec
->NumberParameters
>= 3
1280 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1282 DWORD named_thread_id
;
1283 windows_thread_info
*named_thread
;
1284 CORE_ADDR thread_name_target
;
1286 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1288 thread_name_target
= rec
->ExceptionInformation
[1];
1289 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1291 if (named_thread_id
== (DWORD
) -1)
1292 named_thread_id
= current_event
.dwThreadId
;
1294 named_thread
= thread_rec (named_thread_id
, 0);
1295 if (named_thread
!= NULL
)
1297 int thread_name_len
;
1298 gdb::unique_xmalloc_ptr
<char> thread_name
;
1300 thread_name_len
= target_read_string (thread_name_target
,
1301 &thread_name
, 1025, NULL
);
1302 if (thread_name_len
> 0)
1304 thread_name
.get ()[thread_name_len
- 1] = '\0';
1305 xfree (named_thread
->name
);
1306 named_thread
->name
= thread_name
.release ();
1309 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1310 result
= HANDLE_EXCEPTION_IGNORED
;
1313 /* treat improperly formed exception as unknown */
1316 /* Treat unhandled first chance exceptions specially. */
1317 if (current_event
.u
.Exception
.dwFirstChance
)
1318 return HANDLE_EXCEPTION_UNHANDLED
;
1319 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1320 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1321 host_address_to_string (
1322 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1323 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1327 last_sig
= ourstatus
->value
.sig
;
1331 /* Resume thread specified by ID, or all artificially suspended
1332 threads, if we are continuing execution. KILLED non-zero means we
1333 have killed the inferior, so we should ignore weird errors due to
1334 threads shutting down. */
1336 windows_continue (DWORD continue_status
, int id
, int killed
)
1338 windows_thread_info
*th
;
1341 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1342 (unsigned) current_event
.dwProcessId
,
1343 (unsigned) current_event
.dwThreadId
,
1344 continue_status
== DBG_CONTINUE
?
1345 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1347 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1348 if ((id
== -1 || id
== (int) th
->id
)
1351 if (debug_registers_changed
)
1353 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1354 th
->context
.Dr0
= dr
[0];
1355 th
->context
.Dr1
= dr
[1];
1356 th
->context
.Dr2
= dr
[2];
1357 th
->context
.Dr3
= dr
[3];
1358 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1359 th
->context
.Dr7
= dr
[7];
1361 if (th
->context
.ContextFlags
)
1365 if (GetExitCodeThread (th
->h
, &ec
)
1366 && ec
== STILL_ACTIVE
)
1368 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1373 th
->context
.ContextFlags
= 0;
1375 if (th
->suspended
> 0)
1376 (void) ResumeThread (th
->h
);
1380 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1381 current_event
.dwThreadId
,
1385 error (_("Failed to resume program execution"
1386 " (ContinueDebugEvent failed, error %u)"),
1387 (unsigned int) GetLastError ());
1389 debug_registers_changed
= 0;
1393 /* Called in pathological case where Windows fails to send a
1394 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1396 fake_create_process (void)
1398 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1399 current_event
.dwProcessId
);
1400 if (current_process_handle
!= NULL
)
1401 open_process_used
= 1;
1404 error (_("OpenProcess call failed, GetLastError = %u"),
1405 (unsigned) GetLastError ());
1406 /* We can not debug anything in that case. */
1408 main_thread_id
= current_event
.dwThreadId
;
1410 = windows_add_thread (ptid_t (current_event
.dwProcessId
, 0,
1411 current_event
.dwThreadId
),
1412 current_event
.u
.CreateThread
.hThread
,
1413 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1414 true /* main_thread_p */);
1415 return main_thread_id
;
1419 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1421 windows_thread_info
*th
;
1422 DWORD continue_status
= DBG_CONTINUE
;
1424 /* A specific PTID means `step only this thread id'. */
1425 int resume_all
= ptid
== minus_one_ptid
;
1427 /* If we're continuing all threads, it's the current inferior that
1428 should be handled specially. */
1430 ptid
= inferior_ptid
;
1432 if (sig
!= GDB_SIGNAL_0
)
1434 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1436 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1438 else if (sig
== last_sig
)
1439 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1442 /* This code does not seem to work, because
1443 the kernel does probably not consider changes in the ExceptionRecord
1444 structure when passing the exception to the inferior.
1445 Note that this seems possible in the exception handler itself. */
1447 for (const xlate_exception
&x
: xlate
)
1450 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1452 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1455 if (continue_status
== DBG_CONTINUE
)
1457 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1461 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1465 last_sig
= GDB_SIGNAL_0
;
1467 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1468 ptid
.pid (), ptid
.tid (), step
, sig
));
1470 /* Get context for currently selected thread. */
1471 th
= thread_rec (inferior_ptid
.tid (), FALSE
);
1476 /* Single step by setting t bit. */
1477 struct regcache
*regcache
= get_current_regcache ();
1478 struct gdbarch
*gdbarch
= regcache
->arch ();
1479 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1480 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1483 if (th
->context
.ContextFlags
)
1485 if (debug_registers_changed
)
1487 th
->context
.Dr0
= dr
[0];
1488 th
->context
.Dr1
= dr
[1];
1489 th
->context
.Dr2
= dr
[2];
1490 th
->context
.Dr3
= dr
[3];
1491 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1492 th
->context
.Dr7
= dr
[7];
1494 CHECK (SetThreadContext (th
->h
, &th
->context
));
1495 th
->context
.ContextFlags
= 0;
1499 /* Allow continuing with the same signal that interrupted us.
1500 Otherwise complain. */
1503 windows_continue (continue_status
, -1, 0);
1505 windows_continue (continue_status
, ptid
.tid (), 0);
1508 /* Ctrl-C handler used when the inferior is not run in the same console. The
1509 handler is in charge of interrupting the inferior using DebugBreakProcess.
1510 Note that this function is not available prior to Windows XP. In this case
1511 we emit a warning. */
1513 ctrl_c_handler (DWORD event_type
)
1515 const int attach_flag
= current_inferior ()->attach_flag
;
1517 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1518 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1521 /* If the inferior and the debugger share the same console, do nothing as
1522 the inferior has also received the Ctrl-C event. */
1523 if (!new_console
&& !attach_flag
)
1526 if (!DebugBreakProcess (current_process_handle
))
1527 warning (_("Could not interrupt program. "
1528 "Press Ctrl-c in the program console."));
1530 /* Return true to tell that Ctrl-C has been handled. */
1534 /* Get the next event from the child. Returns a non-zero thread id if the event
1535 requires handling by WFI (or whatever). */
1537 get_windows_debug_event (struct target_ops
*ops
,
1538 int pid
, struct target_waitstatus
*ourstatus
)
1541 DWORD continue_status
, event_code
;
1542 windows_thread_info
*th
;
1543 static windows_thread_info dummy_thread_info
;
1544 DWORD thread_id
= 0;
1546 last_sig
= GDB_SIGNAL_0
;
1548 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1552 continue_status
= DBG_CONTINUE
;
1554 event_code
= current_event
.dwDebugEventCode
;
1555 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1557 have_saved_context
= 0;
1561 case CREATE_THREAD_DEBUG_EVENT
:
1562 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1563 (unsigned) current_event
.dwProcessId
,
1564 (unsigned) current_event
.dwThreadId
,
1565 "CREATE_THREAD_DEBUG_EVENT"));
1566 if (saw_create
!= 1)
1568 struct inferior
*inf
;
1569 inf
= find_inferior_pid (current_event
.dwProcessId
);
1570 if (!saw_create
&& inf
->attach_flag
)
1572 /* Kludge around a Windows bug where first event is a create
1573 thread event. Caused when attached process does not have
1575 thread_id
= fake_create_process ();
1581 /* Record the existence of this thread. */
1582 thread_id
= current_event
.dwThreadId
;
1583 th
= windows_add_thread
1584 (ptid_t (current_event
.dwProcessId
, 0, current_event
.dwThreadId
),
1585 current_event
.u
.CreateThread
.hThread
,
1586 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1587 false /* main_thread_p */);
1591 case EXIT_THREAD_DEBUG_EVENT
:
1592 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1593 (unsigned) current_event
.dwProcessId
,
1594 (unsigned) current_event
.dwThreadId
,
1595 "EXIT_THREAD_DEBUG_EVENT"));
1596 windows_delete_thread (ptid_t (current_event
.dwProcessId
, 0,
1597 current_event
.dwThreadId
),
1598 current_event
.u
.ExitThread
.dwExitCode
,
1599 false /* main_thread_p */);
1600 th
= &dummy_thread_info
;
1603 case CREATE_PROCESS_DEBUG_EVENT
:
1604 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1605 (unsigned) current_event
.dwProcessId
,
1606 (unsigned) current_event
.dwThreadId
,
1607 "CREATE_PROCESS_DEBUG_EVENT"));
1608 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1609 if (++saw_create
!= 1)
1612 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1613 main_thread_id
= current_event
.dwThreadId
;
1614 /* Add the main thread. */
1615 th
= windows_add_thread
1616 (ptid_t (current_event
.dwProcessId
, 0,
1617 current_event
.dwThreadId
),
1618 current_event
.u
.CreateProcessInfo
.hThread
,
1619 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
,
1620 true /* main_thread_p */);
1621 thread_id
= current_event
.dwThreadId
;
1624 case EXIT_PROCESS_DEBUG_EVENT
:
1625 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1626 (unsigned) current_event
.dwProcessId
,
1627 (unsigned) current_event
.dwThreadId
,
1628 "EXIT_PROCESS_DEBUG_EVENT"));
1629 if (!windows_initialization_done
)
1631 target_terminal::ours ();
1632 target_mourn_inferior (inferior_ptid
);
1633 error (_("During startup program exited with code 0x%x."),
1634 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1636 else if (saw_create
== 1)
1638 windows_delete_thread (ptid_t (current_event
.dwProcessId
, 0,
1640 0, true /* main_thread_p */);
1641 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1642 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1643 thread_id
= main_thread_id
;
1647 case LOAD_DLL_DEBUG_EVENT
:
1648 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1649 (unsigned) current_event
.dwProcessId
,
1650 (unsigned) current_event
.dwThreadId
,
1651 "LOAD_DLL_DEBUG_EVENT"));
1652 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1653 if (saw_create
!= 1 || ! windows_initialization_done
)
1655 catch_errors (handle_load_dll
);
1656 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1657 ourstatus
->value
.integer
= 0;
1658 thread_id
= main_thread_id
;
1661 case UNLOAD_DLL_DEBUG_EVENT
:
1662 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1663 (unsigned) current_event
.dwProcessId
,
1664 (unsigned) current_event
.dwThreadId
,
1665 "UNLOAD_DLL_DEBUG_EVENT"));
1666 if (saw_create
!= 1 || ! windows_initialization_done
)
1668 catch_errors (handle_unload_dll
);
1669 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1670 ourstatus
->value
.integer
= 0;
1671 thread_id
= main_thread_id
;
1674 case EXCEPTION_DEBUG_EVENT
:
1675 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1676 (unsigned) current_event
.dwProcessId
,
1677 (unsigned) current_event
.dwThreadId
,
1678 "EXCEPTION_DEBUG_EVENT"));
1679 if (saw_create
!= 1)
1681 switch (handle_exception (ourstatus
))
1683 case HANDLE_EXCEPTION_UNHANDLED
:
1685 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1687 case HANDLE_EXCEPTION_HANDLED
:
1688 thread_id
= current_event
.dwThreadId
;
1690 case HANDLE_EXCEPTION_IGNORED
:
1691 continue_status
= DBG_CONTINUE
;
1696 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1697 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1698 (unsigned) current_event
.dwProcessId
,
1699 (unsigned) current_event
.dwThreadId
,
1700 "OUTPUT_DEBUG_STRING_EVENT"));
1701 if (saw_create
!= 1)
1703 thread_id
= handle_output_debug_string (ourstatus
);
1707 if (saw_create
!= 1)
1709 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1710 (unsigned) current_event
.dwProcessId
,
1711 (unsigned) current_event
.dwThreadId
);
1712 printf_unfiltered (" unknown event code %u\n",
1713 (unsigned) current_event
.dwDebugEventCode
);
1717 if (!thread_id
|| saw_create
!= 1)
1719 CHECK (windows_continue (continue_status
, -1, 0));
1723 inferior_ptid
= ptid_t (current_event
.dwProcessId
, 0, thread_id
);
1724 current_thread
= th
;
1725 if (!current_thread
)
1726 current_thread
= thread_rec (thread_id
, TRUE
);
1733 /* Wait for interesting events to occur in the target process. */
1735 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1740 /* We loop when we get a non-standard exception rather than return
1741 with a SPURIOUS because resume can try and step or modify things,
1742 which needs a current_thread->h. But some of these exceptions mark
1743 the birth or death of threads, which mean that the current thread
1744 isn't necessarily what you think it is. */
1750 /* If the user presses Ctrl-c while the debugger is waiting
1751 for an event, he expects the debugger to interrupt his program
1752 and to get the prompt back. There are two possible situations:
1754 - The debugger and the program do not share the console, in
1755 which case the Ctrl-c event only reached the debugger.
1756 In that case, the ctrl_c handler will take care of interrupting
1757 the inferior. Note that this case is working starting with
1758 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1761 - The debugger and the program share the same console, in which
1762 case both debugger and inferior will receive the Ctrl-c event.
1763 In that case the ctrl_c handler will ignore the event, as the
1764 Ctrl-c event generated inside the inferior will trigger the
1765 expected debug event.
1767 FIXME: brobecker/2008-05-20: If the inferior receives the
1768 signal first and the delay until GDB receives that signal
1769 is sufficiently long, GDB can sometimes receive the SIGINT
1770 after we have unblocked the CTRL+C handler. This would
1771 lead to the debugger stopping prematurely while handling
1772 the new-thread event that comes with the handling of the SIGINT
1773 inside the inferior, and then stop again immediately when
1774 the user tries to resume the execution in the inferior.
1775 This is a classic race that we should try to fix one day. */
1776 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1777 retval
= get_windows_debug_event (this, pid
, ourstatus
);
1778 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1781 return ptid_t (current_event
.dwProcessId
, 0, retval
);
1786 if (deprecated_ui_loop_hook
!= NULL
)
1787 detach
= deprecated_ui_loop_hook (0);
1795 /* Iterate over all DLLs currently mapped by our inferior, and
1796 add them to our list of solibs. */
1799 windows_add_all_dlls (void)
1801 HMODULE dummy_hmodule
;
1806 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
1807 sizeof (HMODULE
), &cb_needed
) == 0)
1813 hmodules
= (HMODULE
*) alloca (cb_needed
);
1814 if (EnumProcessModules (current_process_handle
, hmodules
,
1815 cb_needed
, &cb_needed
) == 0)
1818 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
1822 wchar_t dll_name
[__PMAX
];
1825 char dll_name
[__PMAX
];
1828 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
1829 &mi
, sizeof (mi
)) == 0)
1831 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
1832 dll_name
, sizeof (dll_name
)) == 0)
1835 wcstombs (name
, dll_name
, __PMAX
);
1840 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
1841 solib_end
= solib_end
->next
;
1846 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1849 struct inferior
*inf
;
1851 last_sig
= GDB_SIGNAL_0
;
1853 exception_count
= 0;
1854 open_process_used
= 0;
1855 debug_registers_changed
= 0;
1856 debug_registers_used
= 0;
1857 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1860 cygwin_load_start
= cygwin_load_end
= 0;
1862 current_event
.dwProcessId
= pid
;
1863 memset (¤t_event
, 0, sizeof (current_event
));
1864 if (!target_is_pushed (ops
))
1866 disable_breakpoints_in_shlibs ();
1867 windows_clear_solib ();
1868 clear_proceed_status (0);
1869 init_wait_for_inferior ();
1871 inf
= current_inferior ();
1872 inferior_appeared (inf
, pid
);
1873 inf
->attach_flag
= attaching
;
1875 /* Make the new process the current inferior, so terminal handling
1876 can rely on it. When attaching, we don't know about any thread
1877 id here, but that's OK --- nothing should be referencing the
1878 current thread until we report an event out of windows_wait. */
1879 inferior_ptid
= ptid_t (pid
);
1881 target_terminal::init ();
1882 target_terminal::inferior ();
1884 windows_initialization_done
= 0;
1888 struct target_waitstatus status
;
1890 ops
->wait (minus_one_ptid
, &status
, 0);
1892 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
1894 if (status
.kind
!= TARGET_WAITKIND_LOADED
1895 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
1898 ops
->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
1901 /* Now that the inferior has been started and all DLLs have been mapped,
1902 we can iterate over all DLLs and load them in.
1904 We avoid doing it any earlier because, on certain versions of Windows,
1905 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
1906 we have seen on Windows 8.1 that the ntdll.dll load event does not
1907 include the DLL name, preventing us from creating an associated SO.
1908 A possible explanation is that ntdll.dll might be mapped before
1909 the SO info gets created by the Windows system -- ntdll.dll is
1910 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
1911 do not seem to suffer from that problem.
1913 Rather than try to work around this sort of issue, it is much
1914 simpler to just ignore DLL load/unload events during the startup
1915 phase, and then process them all in one batch now. */
1916 windows_add_all_dlls ();
1918 windows_initialization_done
= 1;
1922 /* Try to set or remove a user privilege to the current process. Return -1
1923 if that fails, the previous setting of that privilege otherwise.
1925 This code is copied from the Cygwin source code and rearranged to allow
1926 dynamically loading of the needed symbols from advapi32 which is only
1927 available on NT/2K/XP. */
1929 set_process_privilege (const char *privilege
, BOOL enable
)
1931 HANDLE token_hdl
= NULL
;
1933 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1937 if (!OpenProcessToken (GetCurrentProcess (),
1938 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1942 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
1945 new_priv
.PrivilegeCount
= 1;
1946 new_priv
.Privileges
[0].Luid
= restore_priv
;
1947 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1949 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1950 sizeof orig_priv
, &orig_priv
, &size
))
1953 /* Disabled, otherwise every `attach' in an unprivileged user session
1954 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1955 windows_attach(). */
1956 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1957 be enabled. GetLastError () returns an correct error code, though. */
1958 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1962 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1966 CloseHandle (token_hdl
);
1971 /* Attach to process PID, then initialize for debugging it. */
1974 windows_nat_target::attach (const char *args
, int from_tty
)
1979 pid
= parse_pid_to_attach (args
);
1981 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1983 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1984 printf_unfiltered ("This can cause attach to "
1985 "fail on Windows NT/2K/XP\n");
1988 windows_init_thread_list ();
1989 ok
= DebugActiveProcess (pid
);
1995 /* Try fall back to Cygwin pid. */
1996 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1999 ok
= DebugActiveProcess (pid
);
2004 error (_("Can't attach to process."));
2006 DebugSetProcessKillOnExit (FALSE
);
2010 char *exec_file
= (char *) get_exec_file (0);
2013 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
2014 target_pid_to_str (ptid_t (pid
)));
2016 printf_unfiltered ("Attaching to %s\n",
2017 target_pid_to_str (ptid_t (pid
)));
2020 do_initial_windows_stuff (this, pid
, 1);
2021 target_terminal::ours ();
2025 windows_nat_target::detach (inferior
*inf
, int from_tty
)
2029 ptid_t ptid
= minus_one_ptid
;
2030 resume (ptid
, 0, GDB_SIGNAL_0
);
2032 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
2034 error (_("Can't detach process %u (error %u)"),
2035 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
2038 DebugSetProcessKillOnExit (FALSE
);
2040 if (detached
&& from_tty
)
2042 const char *exec_file
= get_exec_file (0);
2045 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
2046 (unsigned) current_event
.dwProcessId
);
2049 x86_cleanup_dregs ();
2050 inferior_ptid
= null_ptid
;
2051 detach_inferior (inf
);
2053 maybe_unpush_target ();
2056 /* Try to determine the executable filename.
2058 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2060 Upon success, the filename is stored inside EXE_NAME_RET, and
2061 this function returns nonzero.
2063 Otherwise, this function returns zero and the contents of
2064 EXE_NAME_RET is undefined. */
2067 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2074 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2075 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2078 /* We know the executable is always first in the list of modules,
2079 which we just fetched. So no need to fetch more. */
2083 /* Cygwin prefers that the path be in /x/y/z format, so extract
2084 the filename into a temporary buffer first, and then convert it
2085 to POSIX format into the destination buffer. */
2086 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2088 len
= GetModuleFileNameEx (current_process_handle
,
2089 dh_buf
, pathbuf
, exe_name_max_len
);
2091 error (_("Error getting executable filename: %u."),
2092 (unsigned) GetLastError ());
2093 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2094 exe_name_max_len
) < 0)
2095 error (_("Error converting executable filename to POSIX: %d."), errno
);
2098 len
= GetModuleFileNameEx (current_process_handle
,
2099 dh_buf
, exe_name_ret
, exe_name_max_len
);
2101 error (_("Error getting executable filename: %u."),
2102 (unsigned) GetLastError ());
2105 return 1; /* success */
2108 /* The pid_to_exec_file target_ops method for this platform. */
2111 windows_nat_target::pid_to_exec_file (int pid
)
2113 static char path
[__PMAX
];
2115 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2117 char procexe
[sizeof ("/proc/4294967295/exe")];
2119 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2120 nchars
= readlink (procexe
, path
, sizeof(path
));
2121 if (nchars
> 0 && nchars
< sizeof (path
))
2123 path
[nchars
] = '\0'; /* Got it */
2128 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2129 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2130 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2136 /* Print status information about what we're accessing. */
2139 windows_nat_target::files_info ()
2141 struct inferior
*inf
= current_inferior ();
2143 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2144 inf
->attach_flag
? "attached" : "child",
2145 target_pid_to_str (inferior_ptid
));
2148 /* Modify CreateProcess parameters for use of a new separate console.
2150 *FLAGS: DWORD parameter for general process creation flags.
2151 *SI: STARTUPINFO structure, for which the console window size and
2152 console buffer size is filled in if GDB is running in a console.
2153 to create the new console.
2154 The size of the used font is not available on all versions of
2155 Windows OS. Furthermore, the current font might not be the default
2156 font, but this is still better than before.
2157 If the windows and buffer sizes are computed,
2158 SI->DWFLAGS is changed so that this information is used
2159 by CreateProcess function. */
2162 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2164 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2165 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2167 if (hconsole
!= INVALID_HANDLE_VALUE
)
2169 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2171 CONSOLE_FONT_INFO cfi
;
2173 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2174 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2175 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2176 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2177 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2179 si
->dwXSize
*= font_size
.X
;
2183 si
->dwYSize
*= font_size
.Y
;
2186 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2187 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2188 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2190 *flags
|= CREATE_NEW_CONSOLE
;
2194 /* Function called by qsort to sort environment strings. */
2197 envvar_cmp (const void *a
, const void *b
)
2199 const char **p
= (const char **) a
;
2200 const char **q
= (const char **) b
;
2201 return strcasecmp (*p
, *q
);
2207 clear_win32_environment (char **env
)
2211 wchar_t *copy
= NULL
, *equalpos
;
2213 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2215 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2216 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2217 mbstowcs (copy
, env
[i
], len
);
2218 equalpos
= wcschr (copy
, L
'=');
2221 SetEnvironmentVariableW (copy
, NULL
);
2229 /* Redirection of inferior I/O streams for native MS-Windows programs.
2230 Unlike on Unix, where this is handled by invoking the inferior via
2231 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2233 The official documentation of the cmd.exe redirection features is here:
2235 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2237 (That page talks about Windows XP, but there's no newer
2238 documentation, so we assume later versions of cmd.exe didn't change
2241 Caveat: the documentation on that page seems to include a few lies.
2242 For example, it describes strange constructs 1<&2 and 2<&1, which
2243 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2244 think the cmd.exe parser of the redirection symbols simply doesn't
2245 care about the < vs > distinction in these cases. Therefore, the
2246 supported features are explicitly documented below.
2248 The emulation below aims at supporting all the valid use cases
2249 supported by cmd.exe, which include:
2251 < FILE redirect standard input from FILE
2252 0< FILE redirect standard input from FILE
2253 <&N redirect standard input from file descriptor N
2254 0<&N redirect standard input from file descriptor N
2255 > FILE redirect standard output to FILE
2256 >> FILE append standard output to FILE
2257 1>> FILE append standard output to FILE
2258 >&N redirect standard output to file descriptor N
2259 1>&N redirect standard output to file descriptor N
2260 >>&N append standard output to file descriptor N
2261 1>>&N append standard output to file descriptor N
2262 2> FILE redirect standard error to FILE
2263 2>> FILE append standard error to FILE
2264 2>&N redirect standard error to file descriptor N
2265 2>>&N append standard error to file descriptor N
2267 Note that using N > 2 in the above construct is supported, but
2268 requires that the corresponding file descriptor be open by some
2269 means elsewhere or outside GDB. Also note that using ">&0" or
2270 "<&2" will generally fail, because the file descriptor redirected
2271 from is normally open in an incompatible mode (e.g., FD 0 is open
2272 for reading only). IOW, use of such tricks is not recommended;
2273 you are on your own.
2275 We do NOT support redirection of file descriptors above 2, as in
2276 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2277 that needs special handling in the startup code that MinGW
2278 doesn't have). Pipes are also not supported.
2280 As for invalid use cases, where the redirection contains some
2281 error, the emulation below will detect that and produce some
2282 error and/or failure. But the behavior in those cases is not
2283 bug-for-bug compatible with what cmd.exe does in those cases.
2284 That's because what cmd.exe does then is not well defined, and
2285 seems to be a side effect of the cmd.exe parsing of the command
2286 line more than anything else. For example, try redirecting to an
2287 invalid file name, as in "> foo:bar".
2289 There are also minor syntactic deviations from what cmd.exe does
2290 in some corner cases. For example, it doesn't support the likes
2291 of "> &foo" to mean redirect to file named literally "&foo"; we
2292 do support that here, because that, too, sounds like some issue
2293 with the cmd.exe parser. Another nicety is that we support
2294 redirection targets that use file names with forward slashes,
2295 something cmd.exe doesn't -- this comes in handy since GDB
2296 file-name completion can be used when typing the command line for
2299 /* Support routines for redirecting standard handles of the inferior. */
2301 /* Parse a single redirection spec, open/duplicate the specified
2302 file/fd, and assign the appropriate value to one of the 3 standard
2303 file descriptors. */
2305 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2307 int *fd
, ref_fd
= -2;
2309 const char *fname
= redir_string
+ 1;
2310 int rc
= *redir_string
;
2325 fd
= (rc
== '2') ? err
: out
;
2326 mode
= O_WRONLY
| O_CREAT
;
2339 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2341 /* A reference to a file descriptor. */
2343 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2344 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2346 /* Don't allow redirection when open modes are incompatible. */
2347 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2348 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2355 else if (ref_fd
== 1)
2357 else if (ref_fd
== 2)
2367 fname
++; /* skip the separator space */
2368 /* If the descriptor is already open, close it. This allows
2369 multiple specs of redirections for the same stream, which is
2370 somewhat nonsensical, but still valid and supported by cmd.exe.
2371 (But cmd.exe only opens a single file in this case, the one
2372 specified by the last redirection spec on the command line.) */
2377 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2381 else if (ref_fd
== -1)
2382 *fd
= -1; /* reset to default destination */
2385 *fd
= _dup (ref_fd
);
2389 /* _open just sets a flag for O_APPEND, which won't be passed to the
2390 inferior, so we need to actually move the file pointer. */
2391 if ((mode
& O_APPEND
) != 0)
2392 _lseek (*fd
, 0L, SEEK_END
);
2396 /* Canonicalize a single redirection spec and set up the corresponding
2397 file descriptor as specified. */
2399 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2401 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2403 const char *start
= s
;
2406 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2407 if ((*start
== '>' || *start
== '1' || *start
== '2')
2411 if (*s
== '>' && *start
!= '>')
2414 else if (*start
== '0' && *s
== '<')
2416 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2419 while (isspace (*s
)) /* skip whitespace before file name */
2421 *d
++ = ' '; /* separate file name with a single space */
2424 /* Copy the file name. */
2427 /* Remove quoting characters from the file name in buf[]. */
2428 if (*s
== '"') /* could support '..' quoting here */
2432 else if (*s
== quote
)
2440 else if (*s
== '\\')
2442 if (s
[1] == '"') /* could support '..' here */
2446 else if (isspace (*s
) && !quote
)
2450 if (d
- buf
>= sizeof (buf
) - 1)
2452 errno
= ENAMETOOLONG
;
2458 /* Windows doesn't allow redirection characters in file names, so we
2459 can bail out early if they use them, or if there's no target file
2460 name after the redirection symbol. */
2461 if (d
[-1] == '>' || d
[-1] == '<')
2466 if (redir_open (buf
, inp
, out
, err
) == 0)
2471 /* Parse the command line for redirection specs and prepare the file
2472 descriptors for the 3 standard streams accordingly. */
2474 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2475 int *inp
, int *out
, int *err
)
2477 const char *s
= cmd_orig
;
2480 bool retval
= false;
2482 while (isspace (*s
))
2487 if (*s
== '"') /* could also support '..' quoting here */
2491 else if (*s
== quote
)
2494 else if (*s
== '\\')
2496 if (s
[1] == '"') /* escaped quote char */
2501 /* Process a single redirection candidate. */
2502 if (*s
== '<' || *s
== '>'
2503 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2504 || (*s
== '0' && s
[1] == '<'))
2506 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2520 #endif /* !__CYGWIN__ */
2522 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2523 EXEC_FILE is the file to run.
2524 ALLARGS is a string containing the arguments to the program.
2525 ENV is the environment vector to pass. Errors reported with error(). */
2528 windows_nat_target::create_inferior (const char *exec_file
,
2529 const std::string
&origallargs
,
2530 char **in_env
, int from_tty
)
2534 cygwin_buf_t real_path
[__PMAX
];
2535 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2536 cygwin_buf_t infcwd
[__PMAX
];
2538 cygwin_buf_t
*toexec
;
2539 cygwin_buf_t
*cygallargs
;
2541 char **old_env
= NULL
;
2545 int ostdin
, ostdout
, ostderr
;
2546 #else /* !__CYGWIN__ */
2547 char shell
[__PMAX
]; /* Path to shell */
2549 char *args
, *allargs_copy
;
2550 size_t args_len
, allargs_len
;
2551 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2552 HANDLE tty
= INVALID_HANDLE_VALUE
;
2553 bool redirected
= false;
2560 #endif /* !__CYGWIN__ */
2561 const char *allargs
= origallargs
.c_str ();
2562 PROCESS_INFORMATION pi
;
2565 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2568 error (_("No executable specified, use `target exec'."));
2570 const char *inferior_cwd
= get_inferior_cwd ();
2571 std::string expanded_infcwd
;
2572 if (inferior_cwd
!= NULL
)
2574 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
2575 /* Mirror slashes on inferior's cwd. */
2576 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
2578 inferior_cwd
= expanded_infcwd
.c_str ();
2581 memset (&si
, 0, sizeof (si
));
2582 si
.cb
= sizeof (si
);
2585 flags
|= CREATE_NEW_PROCESS_GROUP
;
2588 windows_set_console_info (&si
, &flags
);
2593 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2594 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2595 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2596 error (_("Error starting executable: %d"), errno
);
2599 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2600 if (len
== (size_t) -1)
2601 error (_("Error starting executable: %d"), errno
);
2602 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2603 mbstowcs (cygallargs
, allargs
, len
);
2604 #else /* !__USEWIDE */
2605 cygallargs
= allargs
;
2611 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2612 error (_("Error starting executable via shell: %d"), errno
);
2614 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2615 + mbstowcs (NULL
, allargs
, 0) + 2;
2616 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2617 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2618 #else /* !__USEWIDE */
2619 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2620 + strlen (allargs
) + 2);
2621 cygallargs
= (char *) alloca (len
);
2622 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2623 #endif /* __USEWIDE */
2625 flags
|= DEBUG_PROCESS
;
2628 if (inferior_cwd
!= NULL
2629 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
2630 infcwd
, strlen (inferior_cwd
)) < 0)
2631 error (_("Error converting inferior cwd: %d"), errno
);
2634 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2635 * sizeof (wchar_t));
2636 wcscpy (args
, toexec
);
2637 wcscat (args
, L
" ");
2638 wcscat (args
, cygallargs
);
2639 #else /* !__USEWIDE */
2640 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2641 strcpy (args
, toexec
);
2643 strcat (args
, cygallargs
);
2644 #endif /* !__USEWIDE */
2646 #ifdef CW_CVT_ENV_TO_WINENV
2647 /* First try to create a direct Win32 copy of the POSIX environment. */
2648 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2649 if (w32_env
!= (PWCHAR
) -1)
2650 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2652 /* If that fails, fall back to old method tweaking GDB's environment. */
2653 #endif /* CW_CVT_ENV_TO_WINENV */
2655 /* Reset all Win32 environment variables to avoid leftover on next run. */
2656 clear_win32_environment (environ
);
2657 /* Prepare the environment vars for CreateProcess. */
2660 cygwin_internal (CW_SYNC_WINENV
);
2664 if (!inferior_io_terminal
)
2665 tty
= ostdin
= ostdout
= ostderr
= -1;
2668 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2671 print_sys_errmsg (inferior_io_terminal
, errno
);
2672 ostdin
= ostdout
= ostderr
= -1;
2685 windows_init_thread_list ();
2686 ret
= CreateProcess (0,
2687 args
, /* command line */
2688 NULL
, /* Security */
2690 TRUE
, /* inherit handles */
2691 flags
, /* start flags */
2692 w32_env
, /* environment */
2693 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
2698 /* Just free the Win32 environment, if it could be created. */
2702 /* Reset all environment variables to avoid leftover on next run. */
2703 clear_win32_environment (in_env
);
2704 /* Restore normal GDB environment variables. */
2706 cygwin_internal (CW_SYNC_WINENV
);
2719 #else /* !__CYGWIN__ */
2720 allargs_len
= strlen (allargs
);
2721 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
2722 if (strpbrk (allargs_copy
, "<>") != NULL
)
2727 redirect_inferior_handles (allargs
, allargs_copy
,
2728 &fd_inp
, &fd_out
, &fd_err
);
2730 warning (_("Error in redirection: %s."), strerror (errno
));
2733 allargs_len
= strlen (allargs_copy
);
2735 /* If not all the standard streams are redirected by the command
2736 line, use inferior_io_terminal for those which aren't. */
2737 if (inferior_io_terminal
2738 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
2740 SECURITY_ATTRIBUTES sa
;
2741 sa
.nLength
= sizeof(sa
);
2742 sa
.lpSecurityDescriptor
= 0;
2743 sa
.bInheritHandle
= TRUE
;
2744 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2745 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2746 if (tty
== INVALID_HANDLE_VALUE
)
2747 warning (_("Warning: Failed to open TTY %s, error %#x."),
2748 inferior_io_terminal
, (unsigned) GetLastError ());
2750 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
2753 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
2754 else if (tty
!= INVALID_HANDLE_VALUE
)
2757 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
2759 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
2760 else if (tty
!= INVALID_HANDLE_VALUE
)
2761 si
.hStdOutput
= tty
;
2763 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
2765 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
2766 else if (tty
!= INVALID_HANDLE_VALUE
)
2769 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
2770 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2774 /* Build the command line, a space-separated list of tokens where
2775 the first token is the name of the module to be executed.
2776 To avoid ambiguities introduced by spaces in the module name,
2778 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
2779 args
= (char *) alloca (args_len
);
2780 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
2782 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2784 /* CreateProcess takes the environment list as a null terminated set of
2785 strings (i.e. two nulls terminate the list). */
2787 /* Get total size for env strings. */
2788 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2789 envlen
+= strlen (in_env
[i
]) + 1;
2791 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2792 env
= (char **) alloca (envsize
);
2793 memcpy (env
, in_env
, envsize
);
2794 /* Windows programs expect the environment block to be sorted. */
2795 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2797 w32env
= (char *) alloca (envlen
+ 1);
2799 /* Copy env strings into new buffer. */
2800 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2802 strcpy (temp
, env
[i
]);
2803 temp
+= strlen (temp
) + 1;
2806 /* Final nil string to terminate new env. */
2809 windows_init_thread_list ();
2810 ret
= CreateProcessA (0,
2811 args
, /* command line */
2812 NULL
, /* Security */
2814 TRUE
, /* inherit handles */
2815 flags
, /* start flags */
2816 w32env
, /* environment */
2817 inferior_cwd
, /* current directory */
2820 if (tty
!= INVALID_HANDLE_VALUE
)
2828 #endif /* !__CYGWIN__ */
2831 error (_("Error creating process %s, (error %u)."),
2832 exec_file
, (unsigned) GetLastError ());
2834 CloseHandle (pi
.hThread
);
2835 CloseHandle (pi
.hProcess
);
2837 if (useshell
&& shell
[0] != '\0')
2842 do_initial_windows_stuff (this, pi
.dwProcessId
, 0);
2844 /* windows_continue (DBG_CONTINUE, -1, 0); */
2848 windows_nat_target::mourn_inferior ()
2850 (void) windows_continue (DBG_CONTINUE
, -1, 0);
2851 x86_cleanup_dregs();
2852 if (open_process_used
)
2854 CHECK (CloseHandle (current_process_handle
));
2855 open_process_used
= 0;
2857 inf_child_target::mourn_inferior ();
2860 /* Send a SIGINT to the process group. This acts just like the user typed a
2861 ^C on the controlling terminal. */
2864 windows_nat_target::interrupt ()
2866 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2867 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
2868 registers_changed (); /* refresh register state */
2871 /* Helper for windows_xfer_partial that handles memory transfers.
2872 Arguments are like target_xfer_partial. */
2874 static enum target_xfer_status
2875 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2876 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2880 DWORD lasterror
= 0;
2882 if (writebuf
!= NULL
)
2884 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
2885 pulongest (len
), core_addr_to_string (memaddr
)));
2886 success
= WriteProcessMemory (current_process_handle
,
2887 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
2890 lasterror
= GetLastError ();
2891 FlushInstructionCache (current_process_handle
,
2892 (LPCVOID
) (uintptr_t) memaddr
, len
);
2896 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
2897 pulongest (len
), core_addr_to_string (memaddr
)));
2898 success
= ReadProcessMemory (current_process_handle
,
2899 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
2902 lasterror
= GetLastError ();
2904 *xfered_len
= (ULONGEST
) done
;
2905 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
2906 return TARGET_XFER_OK
;
2908 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
2912 windows_nat_target::kill ()
2914 CHECK (TerminateProcess (current_process_handle
, 0));
2918 if (!windows_continue (DBG_CONTINUE
, -1, 1))
2920 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
2922 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2926 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
2930 windows_nat_target::close ()
2932 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2933 inferior_ptid
.pid ()));
2936 /* Convert pid to printable format. */
2938 windows_nat_target::pid_to_str (ptid_t ptid
)
2940 static char buf
[80];
2942 if (ptid
.tid () != 0)
2944 snprintf (buf
, sizeof (buf
), "Thread %d.0x%lx",
2945 ptid
.pid (), ptid
.tid ());
2949 return normal_pid_to_str (ptid
);
2952 static enum target_xfer_status
2953 windows_xfer_shared_libraries (struct target_ops
*ops
,
2954 enum target_object object
, const char *annex
,
2955 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2956 ULONGEST offset
, ULONGEST len
,
2957 ULONGEST
*xfered_len
)
2959 struct obstack obstack
;
2965 return TARGET_XFER_E_IO
;
2967 obstack_init (&obstack
);
2968 obstack_grow_str (&obstack
, "<library-list>\n");
2969 for (so
= solib_start
.next
; so
; so
= so
->next
)
2971 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
2973 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
2974 (uintptr_t) li
->load_addr
,
2975 target_gdbarch (), &obstack
);
2977 obstack_grow_str0 (&obstack
, "</library-list>\n");
2979 buf
= (const char *) obstack_finish (&obstack
);
2980 len_avail
= strlen (buf
);
2981 if (offset
>= len_avail
)
2985 if (len
> len_avail
- offset
)
2986 len
= len_avail
- offset
;
2987 memcpy (readbuf
, buf
+ offset
, len
);
2990 obstack_free (&obstack
, NULL
);
2991 *xfered_len
= (ULONGEST
) len
;
2992 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
2995 enum target_xfer_status
2996 windows_nat_target::xfer_partial (enum target_object object
,
2997 const char *annex
, gdb_byte
*readbuf
,
2998 const gdb_byte
*writebuf
, ULONGEST offset
,
2999 ULONGEST len
, ULONGEST
*xfered_len
)
3003 case TARGET_OBJECT_MEMORY
:
3004 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
3006 case TARGET_OBJECT_LIBRARIES
:
3007 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
3008 writebuf
, offset
, len
, xfered_len
);
3011 if (beneath () == NULL
)
3013 /* This can happen when requesting the transfer of unsupported
3014 objects before a program has been started (and therefore
3015 with the current_target having no target beneath). */
3016 return TARGET_XFER_E_IO
;
3018 return beneath ()->xfer_partial (object
, annex
,
3019 readbuf
, writebuf
, offset
, len
,
3024 /* Provide thread local base, i.e. Thread Information Block address.
3025 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
3028 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
3030 windows_thread_info
*th
;
3032 th
= thread_rec (ptid
.tid (), 0);
3037 *addr
= th
->thread_local_base
;
3043 windows_nat_target::get_ada_task_ptid (long lwp
, long thread
)
3045 return ptid_t (inferior_ptid
.pid (), 0, lwp
);
3048 /* Implementation of the to_thread_name method. */
3051 windows_nat_target::thread_name (struct thread_info
*thr
)
3053 return thread_rec (thr
->ptid
.tid (), 0)->name
;
3058 _initialize_windows_nat (void)
3060 x86_dr_low
.set_control
= cygwin_set_dr7
;
3061 x86_dr_low
.set_addr
= cygwin_set_dr
;
3062 x86_dr_low
.get_addr
= cygwin_get_dr
;
3063 x86_dr_low
.get_status
= cygwin_get_dr6
;
3064 x86_dr_low
.get_control
= cygwin_get_dr7
;
3066 /* x86_dr_low.debug_register_length field is set by
3067 calling x86_set_debug_register_length function
3068 in processor windows specific native file. */
3070 add_inf_child_target (&the_windows_nat_target
);
3073 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3076 add_com ("signal-event", class_run
, signal_event_command
, _("\
3077 Signal a crashed process with event ID, to allow its debugging.\n\
3078 This command is needed in support of setting up GDB as JIT debugger on \
3079 MS-Windows. The command should be invoked from the GDB command line using \
3080 the '-ex' command-line option. The ID of the event that blocks the \
3081 crashed process will be supplied by the Windows JIT debugging mechanism."));
3084 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3085 Set use of shell to start subprocess."), _("\
3086 Show use of shell to start subprocess."), NULL
,
3088 NULL
, /* FIXME: i18n: */
3089 &setlist
, &showlist
);
3091 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3092 &cygwin_exceptions
, _("\
3093 Break when an exception is detected in the Cygwin DLL itself."), _("\
3094 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3096 NULL
, /* FIXME: i18n: */
3097 &setlist
, &showlist
);
3100 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3101 Set creation of new console when creating child process."), _("\
3102 Show creation of new console when creating child process."), NULL
,
3104 NULL
, /* FIXME: i18n: */
3105 &setlist
, &showlist
);
3107 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3108 Set creation of new group when creating child process."), _("\
3109 Show creation of new group when creating child process."), NULL
,
3111 NULL
, /* FIXME: i18n: */
3112 &setlist
, &showlist
);
3114 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3115 Set whether to display execution in child process."), _("\
3116 Show whether to display execution in child process."), NULL
,
3118 NULL
, /* FIXME: i18n: */
3119 &setlist
, &showlist
);
3121 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3122 Set whether to display kernel events in child process."), _("\
3123 Show whether to display kernel events in child process."), NULL
,
3125 NULL
, /* FIXME: i18n: */
3126 &setlist
, &showlist
);
3128 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3129 Set whether to display memory accesses in child process."), _("\
3130 Show whether to display memory accesses in child process."), NULL
,
3132 NULL
, /* FIXME: i18n: */
3133 &setlist
, &showlist
);
3135 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3136 &debug_exceptions
, _("\
3137 Set whether to display kernel exceptions in child process."), _("\
3138 Show whether to display kernel exceptions in child process."), NULL
,
3140 NULL
, /* FIXME: i18n: */
3141 &setlist
, &showlist
);
3143 init_w32_command_list ();
3145 add_cmd ("selector", class_info
, display_selectors
,
3146 _("Display selectors infos."),
3150 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3152 /* Pass the address ADDR to the inferior in the I'th debug register.
3153 Here we just store the address in dr array, the registers will be
3154 actually set up when windows_continue is called. */
3156 cygwin_set_dr (int i
, CORE_ADDR addr
)
3159 internal_error (__FILE__
, __LINE__
,
3160 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3162 debug_registers_changed
= 1;
3163 debug_registers_used
= 1;
3166 /* Pass the value VAL to the inferior in the DR7 debug control
3167 register. Here we just store the address in D_REGS, the watchpoint
3168 will be actually set up in windows_wait. */
3170 cygwin_set_dr7 (unsigned long val
)
3172 dr
[7] = (CORE_ADDR
) val
;
3173 debug_registers_changed
= 1;
3174 debug_registers_used
= 1;
3177 /* Get the value of debug register I from the inferior. */
3180 cygwin_get_dr (int i
)
3185 /* Get the value of the DR6 debug status register from the inferior.
3186 Here we just return the value stored in dr[6]
3187 by the last call to thread_rec for current_event.dwThreadId id. */
3188 static unsigned long
3189 cygwin_get_dr6 (void)
3191 return (unsigned long) dr
[6];
3194 /* Get the value of the DR7 debug status register from the inferior.
3195 Here we just return the value stored in dr[7] by the last call to
3196 thread_rec for current_event.dwThreadId id. */
3198 static unsigned long
3199 cygwin_get_dr7 (void)
3201 return (unsigned long) dr
[7];
3204 /* Determine if the thread referenced by "ptid" is alive
3205 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3206 it means that the thread has died. Otherwise it is assumed to be alive. */
3209 windows_nat_target::thread_alive (ptid_t ptid
)
3213 gdb_assert (ptid
.tid () != 0);
3216 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) != WAIT_OBJECT_0
;
3220 _initialize_check_for_gdb_ini (void)
3223 if (inhibit_gdbinit
)
3226 homedir
= getenv ("HOME");
3230 char *oldini
= (char *) alloca (strlen (homedir
) +
3231 sizeof ("gdb.ini") + 1);
3232 strcpy (oldini
, homedir
);
3233 p
= strchr (oldini
, '\0');
3234 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3236 strcpy (p
, "gdb.ini");
3237 if (access (oldini
, 0) == 0)
3239 int len
= strlen (oldini
);
3240 char *newini
= (char *) alloca (len
+ 2);
3242 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3243 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3244 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3249 /* Define dummy functions which always return error for the rare cases where
3250 these functions could not be found. */
3252 bad_DebugActiveProcessStop (DWORD w
)
3257 bad_DebugBreakProcess (HANDLE w
)
3262 bad_DebugSetProcessKillOnExit (BOOL w
)
3267 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3274 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3280 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3287 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3293 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3299 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3305 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3313 /* Load any functions which may not be available in ancient versions
3317 _initialize_loadable (void)
3321 #define GPA(m, func) \
3322 func = (func ## _ftype *) GetProcAddress (m, #func)
3324 hm
= LoadLibrary ("kernel32.dll");
3327 GPA (hm
, DebugActiveProcessStop
);
3328 GPA (hm
, DebugBreakProcess
);
3329 GPA (hm
, DebugSetProcessKillOnExit
);
3330 GPA (hm
, GetConsoleFontSize
);
3331 GPA (hm
, DebugActiveProcessStop
);
3332 GPA (hm
, GetCurrentConsoleFont
);
3335 /* Set variables to dummy versions of these processes if the function
3336 wasn't found in kernel32.dll. */
3337 if (!DebugBreakProcess
)
3338 DebugBreakProcess
= bad_DebugBreakProcess
;
3339 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3341 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3342 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3344 if (!GetConsoleFontSize
)
3345 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3346 if (!GetCurrentConsoleFont
)
3347 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3349 /* Load optional functions used for retrieving filename information
3350 associated with the currently debugged process or its dlls. */
3351 hm
= LoadLibrary ("psapi.dll");
3354 GPA (hm
, EnumProcessModules
);
3355 GPA (hm
, GetModuleInformation
);
3356 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3357 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3360 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3362 /* Set variables to dummy versions of these processes if the function
3363 wasn't found in psapi.dll. */
3364 EnumProcessModules
= bad_EnumProcessModules
;
3365 GetModuleInformation
= bad_GetModuleInformation
;
3366 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3367 /* This will probably fail on Windows 9x/Me. Let the user know
3368 that we're missing some functionality. */
3370 cannot automatically find executable file or library to read symbols.\n\
3371 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3374 hm
= LoadLibrary ("advapi32.dll");
3377 GPA (hm
, OpenProcessToken
);
3378 GPA (hm
, LookupPrivilegeValueA
);
3379 GPA (hm
, AdjustTokenPrivileges
);
3380 /* Only need to set one of these since if OpenProcessToken fails nothing
3382 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3383 || !AdjustTokenPrivileges
)
3384 OpenProcessToken
= bad_OpenProcessToken
;