1 /* Target-vector operations for controlling windows child processes, for GDB.
3 Copyright (C) 1995-2020 Free Software Foundation, Inc.
5 Contributed by Cygnus Solutions, A Red Hat Company.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 /* Originally by Steve Chamberlain, sac@cygnus.com */
25 #include "frame.h" /* required by inferior.h */
31 #include "completer.h"
35 #include <sys/types.h>
42 #include <sys/cygwin.h>
43 #include <cygwin/version.h>
47 #include "filenames.h"
51 #include "gdb_obstack.h"
52 #include "gdbthread.h"
58 #include "xml-support.h"
61 #include "i386-tdep.h"
62 #include "i387-tdep.h"
64 #include "windows-tdep.h"
65 #include "windows-nat.h"
67 #include "complaints.h"
68 #include "inf-child.h"
69 #include "gdbsupport/gdb_tilde_expand.h"
70 #include "gdbsupport/pathstuff.h"
72 #define AdjustTokenPrivileges dyn_AdjustTokenPrivileges
73 #define DebugActiveProcessStop dyn_DebugActiveProcessStop
74 #define DebugBreakProcess dyn_DebugBreakProcess
75 #define DebugSetProcessKillOnExit dyn_DebugSetProcessKillOnExit
76 #define EnumProcessModules dyn_EnumProcessModules
77 #define GetModuleInformation dyn_GetModuleInformation
78 #define LookupPrivilegeValueA dyn_LookupPrivilegeValueA
79 #define OpenProcessToken dyn_OpenProcessToken
80 #define GetConsoleFontSize dyn_GetConsoleFontSize
81 #define GetCurrentConsoleFont dyn_GetCurrentConsoleFont
83 typedef BOOL
WINAPI (AdjustTokenPrivileges_ftype
) (HANDLE
, BOOL
,
85 DWORD
, PTOKEN_PRIVILEGES
,
87 static AdjustTokenPrivileges_ftype
*AdjustTokenPrivileges
;
89 typedef BOOL
WINAPI (DebugActiveProcessStop_ftype
) (DWORD
);
90 static DebugActiveProcessStop_ftype
*DebugActiveProcessStop
;
92 typedef BOOL
WINAPI (DebugBreakProcess_ftype
) (HANDLE
);
93 static DebugBreakProcess_ftype
*DebugBreakProcess
;
95 typedef BOOL
WINAPI (DebugSetProcessKillOnExit_ftype
) (BOOL
);
96 static DebugSetProcessKillOnExit_ftype
*DebugSetProcessKillOnExit
;
98 typedef BOOL
WINAPI (EnumProcessModules_ftype
) (HANDLE
, HMODULE
*, DWORD
,
100 static EnumProcessModules_ftype
*EnumProcessModules
;
102 typedef BOOL
WINAPI (GetModuleInformation_ftype
) (HANDLE
, HMODULE
,
103 LPMODULEINFO
, DWORD
);
104 static GetModuleInformation_ftype
*GetModuleInformation
;
106 typedef BOOL
WINAPI (LookupPrivilegeValueA_ftype
) (LPCSTR
, LPCSTR
, PLUID
);
107 static LookupPrivilegeValueA_ftype
*LookupPrivilegeValueA
;
109 typedef BOOL
WINAPI (OpenProcessToken_ftype
) (HANDLE
, DWORD
, PHANDLE
);
110 static OpenProcessToken_ftype
*OpenProcessToken
;
112 typedef BOOL
WINAPI (GetCurrentConsoleFont_ftype
) (HANDLE
, BOOL
,
113 CONSOLE_FONT_INFO
*);
114 static GetCurrentConsoleFont_ftype
*GetCurrentConsoleFont
;
116 typedef COORD
WINAPI (GetConsoleFontSize_ftype
) (HANDLE
, DWORD
);
117 static GetConsoleFontSize_ftype
*GetConsoleFontSize
;
121 #undef GetModuleFileNameEx
124 # define __PMAX (MAX_PATH + 1)
125 typedef DWORD
WINAPI (GetModuleFileNameEx_ftype
) (HANDLE
, HMODULE
, LPSTR
, DWORD
);
126 static GetModuleFileNameEx_ftype
*GetModuleFileNameEx
;
127 # define STARTUPINFO STARTUPINFOA
128 # define CreateProcess CreateProcessA
129 # define GetModuleFileNameEx_name "GetModuleFileNameExA"
130 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
132 # define __PMAX PATH_MAX
133 /* The starting and ending address of the cygwin1.dll text segment. */
134 static CORE_ADDR cygwin_load_start
;
135 static CORE_ADDR cygwin_load_end
;
137 typedef wchar_t cygwin_buf_t
;
138 typedef DWORD
WINAPI (GetModuleFileNameEx_ftype
) (HANDLE
, HMODULE
,
140 static GetModuleFileNameEx_ftype
*GetModuleFileNameEx
;
141 # define STARTUPINFO STARTUPINFOW
142 # define CreateProcess CreateProcessW
143 # define GetModuleFileNameEx_name "GetModuleFileNameExW"
144 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExW
147 static int have_saved_context
; /* True if we've saved context from a
150 static CONTEXT saved_context
; /* Contains the saved context from a
154 /* If we're not using the old Cygwin header file set, define the
155 following which never should have been in the generic Win32 API
156 headers in the first place since they were our own invention... */
157 #ifndef _GNU_H_WINDOWS_H
160 FLAG_TRACE_BIT
= 0x100,
164 #ifndef CONTEXT_EXTENDED_REGISTERS
165 /* This macro is only defined on ia32. It only makes sense on this target,
166 so define it as zero if not already defined. */
167 #define CONTEXT_EXTENDED_REGISTERS 0
170 #define CONTEXT_DEBUGGER_DR CONTEXT_FULL | CONTEXT_FLOATING_POINT \
171 | CONTEXT_SEGMENTS | CONTEXT_DEBUG_REGISTERS \
172 | CONTEXT_EXTENDED_REGISTERS
174 static uintptr_t dr
[8];
175 static int debug_registers_changed
;
176 static int debug_registers_used
;
178 static int windows_initialization_done
;
179 #define DR6_CLEAR_VALUE 0xffff0ff0
181 /* The exception thrown by a program to tell the debugger the name of
182 a thread. The exception record contains an ID of a thread and a
183 name to give it. This exception has no documented name, but MSDN
184 dubs it "MS_VC_EXCEPTION" in one code example. */
185 #define MS_VC_EXCEPTION 0x406d1388
189 HANDLE_EXCEPTION_UNHANDLED
= 0,
190 HANDLE_EXCEPTION_HANDLED
,
191 HANDLE_EXCEPTION_IGNORED
192 } handle_exception_result
;
194 /* The string sent by cygwin when it processes a signal.
195 FIXME: This should be in a cygwin include file. */
196 #ifndef _CYGWIN_SIGNAL_STRING
197 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
200 #define CHECK(x) check (x, __FILE__,__LINE__)
201 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
202 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
203 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
204 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
206 static void cygwin_set_dr (int i
, CORE_ADDR addr
);
207 static void cygwin_set_dr7 (unsigned long val
);
208 static CORE_ADDR
cygwin_get_dr (int i
);
209 static unsigned long cygwin_get_dr6 (void);
210 static unsigned long cygwin_get_dr7 (void);
212 static enum gdb_signal last_sig
= GDB_SIGNAL_0
;
213 /* Set if a signal was received from the debugged process. */
215 /* Thread information structure used to track information that is
216 not available in gdb's thread structure. */
217 typedef struct windows_thread_info_struct
219 struct windows_thread_info_struct
*next
;
222 CORE_ADDR thread_local_base
;
230 static windows_thread_info thread_head
;
232 /* The process and thread handles for the above context. */
234 static DEBUG_EVENT current_event
; /* The current debug event from
236 static HANDLE current_process_handle
; /* Currently executing process */
237 static windows_thread_info
*current_thread
; /* Info on currently selected thread */
239 /* Counts of things. */
240 static int exception_count
= 0;
241 static int event_count
= 0;
242 static int saw_create
;
243 static int open_process_used
= 0;
246 static bool new_console
= false;
248 static bool cygwin_exceptions
= false;
250 static bool new_group
= true;
251 static bool debug_exec
= false; /* show execution */
252 static bool debug_events
= false; /* show events from kernel */
253 static bool debug_memory
= false; /* show target memory accesses */
254 static bool debug_exceptions
= false; /* show target exceptions */
255 static bool useshell
= false; /* use shell for subprocesses */
257 /* This vector maps GDB's idea of a register's number into an offset
258 in the windows exception context vector.
260 It also contains the bit mask needed to load the register in question.
262 The contents of this table can only be computed by the units
263 that provide CPU-specific support for Windows native debugging.
264 These units should set the table by calling
265 windows_set_context_register_offsets.
267 One day we could read a reg, we could inspect the context we
268 already have loaded, if it doesn't have the bit set that we need,
269 we read that set of registers in using GetThreadContext. If the
270 context already contains what we need, we just unpack it. Then to
271 write a register, first we have to ensure that the context contains
272 the other regs of the group, and then we copy the info in and set
275 static const int *mappings
;
277 /* The function to use in order to determine whether a register is
278 a segment register or not. */
279 static segment_register_p_ftype
*segment_register_p
;
281 /* See windows_nat_target::resume to understand why this is commented
284 /* This vector maps the target's idea of an exception (extracted
285 from the DEBUG_EVENT structure) to GDB's idea. */
287 struct xlate_exception
293 static const struct xlate_exception xlate
[] =
295 {EXCEPTION_ACCESS_VIOLATION
, GDB_SIGNAL_SEGV
},
296 {STATUS_STACK_OVERFLOW
, GDB_SIGNAL_SEGV
},
297 {EXCEPTION_BREAKPOINT
, GDB_SIGNAL_TRAP
},
298 {DBG_CONTROL_C
, GDB_SIGNAL_INT
},
299 {EXCEPTION_SINGLE_STEP
, GDB_SIGNAL_TRAP
},
300 {STATUS_FLOAT_DIVIDE_BY_ZERO
, GDB_SIGNAL_FPE
}
305 struct windows_nat_target final
: public x86_nat_target
<inf_child_target
>
307 void close () override
;
309 void attach (const char *, int) override
;
311 bool attach_no_wait () override
314 void detach (inferior
*, int) override
;
316 void resume (ptid_t
, int , enum gdb_signal
) override
;
318 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
320 void fetch_registers (struct regcache
*, int) override
;
321 void store_registers (struct regcache
*, int) override
;
323 enum target_xfer_status
xfer_partial (enum target_object object
,
326 const gdb_byte
*writebuf
,
327 ULONGEST offset
, ULONGEST len
,
328 ULONGEST
*xfered_len
) override
;
330 void files_info () override
;
332 void kill () override
;
334 void create_inferior (const char *, const std::string
&,
335 char **, int) override
;
337 void mourn_inferior () override
;
339 bool thread_alive (ptid_t ptid
) override
;
341 std::string
pid_to_str (ptid_t
) override
;
343 void interrupt () override
;
345 char *pid_to_exec_file (int pid
) override
;
347 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
349 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
351 const char *thread_name (struct thread_info
*) override
;
354 static windows_nat_target the_windows_nat_target
;
356 /* Set the MAPPINGS static global to OFFSETS.
357 See the description of MAPPINGS for more details. */
360 windows_set_context_register_offsets (const int *offsets
)
365 /* See windows-nat.h. */
368 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
370 segment_register_p
= fun
;
374 check (BOOL ok
, const char *file
, int line
)
377 printf_filtered ("error return %s:%d was %u\n", file
, line
,
378 (unsigned) GetLastError ());
381 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
382 then also retrieve the context for this thread. If GET_CONTEXT is
383 negative, then don't suspend the thread. */
384 static windows_thread_info
*
385 thread_rec (DWORD id
, int get_context
)
387 windows_thread_info
*th
;
389 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
392 if (!th
->suspended
&& get_context
)
394 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
396 if (SuspendThread (th
->h
) == (DWORD
) -1)
398 DWORD err
= GetLastError ();
400 /* We get Access Denied (5) when trying to suspend
401 threads that Windows started on behalf of the
402 debuggee, usually when those threads are just
404 We can get Invalid Handle (6) if the main thread
406 if (err
!= ERROR_INVALID_HANDLE
407 && err
!= ERROR_ACCESS_DENIED
)
408 warning (_("SuspendThread (tid=0x%x) failed."
410 (unsigned) id
, (unsigned) err
);
416 else if (get_context
< 0)
418 th
->reload_context
= 1;
426 /* Add a thread to the thread list.
428 PTID is the ptid of the thread to be added.
429 H is its Windows handle.
430 TLB is its thread local base.
431 MAIN_THREAD_P should be true if the thread to be added is
432 the main thread, false otherwise. */
434 static windows_thread_info
*
435 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
, bool main_thread_p
)
437 windows_thread_info
*th
;
440 gdb_assert (ptid
.tid () != 0);
444 if ((th
= thread_rec (id
, FALSE
)))
447 th
= XCNEW (windows_thread_info
);
450 th
->thread_local_base
= (CORE_ADDR
) (uintptr_t) tlb
;
451 th
->next
= thread_head
.next
;
452 thread_head
.next
= th
;
454 /* Add this new thread to the list of threads.
456 To be consistent with what's done on other platforms, we add
457 the main thread silently (in reality, this thread is really
458 more of a process to the user than a thread). */
460 add_thread_silent (ptid
);
464 /* Set the debug registers for the new thread if they are used. */
465 if (debug_registers_used
)
467 /* Only change the value of the debug registers. */
468 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
469 CHECK (GetThreadContext (th
->h
, &th
->context
));
470 th
->context
.Dr0
= dr
[0];
471 th
->context
.Dr1
= dr
[1];
472 th
->context
.Dr2
= dr
[2];
473 th
->context
.Dr3
= dr
[3];
474 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
475 th
->context
.Dr7
= dr
[7];
476 CHECK (SetThreadContext (th
->h
, &th
->context
));
477 th
->context
.ContextFlags
= 0;
482 /* Clear out any old thread list and reinitialize it to a
485 windows_init_thread_list (void)
487 windows_thread_info
*th
= &thread_head
;
489 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
491 while (th
->next
!= NULL
)
493 windows_thread_info
*here
= th
->next
;
494 th
->next
= here
->next
;
497 thread_head
.next
= NULL
;
500 /* Delete a thread from the list of threads.
502 PTID is the ptid of the thread to be deleted.
503 EXIT_CODE is the thread's exit code.
504 MAIN_THREAD_P should be true if the thread to be deleted is
505 the main thread, false otherwise. */
508 windows_delete_thread (ptid_t ptid
, DWORD exit_code
, bool main_thread_p
)
510 windows_thread_info
*th
;
513 gdb_assert (ptid
.tid () != 0);
517 /* Emit a notification about the thread being deleted.
519 Note that no notification was printed when the main thread
520 was created, and thus, unless in verbose mode, we should be
521 symmetrical, and avoid that notification for the main thread
525 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
).c_str ());
526 else if (print_thread_events
&& !main_thread_p
)
527 printf_unfiltered (_("[%s exited with code %u]\n"),
528 target_pid_to_str (ptid
).c_str (),
529 (unsigned) exit_code
);
531 delete_thread (find_thread_ptid (ptid
));
533 for (th
= &thread_head
;
534 th
->next
!= NULL
&& th
->next
->id
!= id
;
538 if (th
->next
!= NULL
)
540 windows_thread_info
*here
= th
->next
;
541 th
->next
= here
->next
;
547 /* Fetches register number R from the given windows_thread_info,
548 and supplies its value to the given regcache.
550 This function assumes that R is non-negative. A failed assertion
551 is raised if that is not true.
553 This function assumes that TH->RELOAD_CONTEXT is not set, meaning
554 that the windows_thread_info has an up-to-date context. A failed
555 assertion is raised if that assumption is violated. */
558 windows_fetch_one_register (struct regcache
*regcache
,
559 windows_thread_info
*th
, int r
)
562 gdb_assert (!th
->reload_context
);
564 char *context_offset
= ((char *) &th
->context
) + mappings
[r
];
565 struct gdbarch
*gdbarch
= regcache
->arch ();
566 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
568 if (r
== I387_FISEG_REGNUM (tdep
))
570 long l
= *((long *) context_offset
) & 0xffff;
571 regcache
->raw_supply (r
, (char *) &l
);
573 else if (r
== I387_FOP_REGNUM (tdep
))
575 long l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
576 regcache
->raw_supply (r
, (char *) &l
);
578 else if (segment_register_p (r
))
580 /* GDB treats segment registers as 32bit registers, but they are
581 in fact only 16 bits long. Make sure we do not read extra
582 bits from our source buffer. */
583 long l
= *((long *) context_offset
) & 0xffff;
584 regcache
->raw_supply (r
, (char *) &l
);
587 regcache
->raw_supply (r
, context_offset
);
591 windows_nat_target::fetch_registers (struct regcache
*regcache
, int r
)
593 DWORD tid
= regcache
->ptid ().tid ();
594 windows_thread_info
*th
= thread_rec (tid
, TRUE
);
596 /* Check if TH exists. Windows sometimes uses a non-existent
597 thread id in its events. */
601 if (th
->reload_context
)
604 if (have_saved_context
)
606 /* Lie about where the program actually is stopped since
607 cygwin has informed us that we should consider the signal
608 to have occurred at another location which is stored in
610 memcpy (&th
->context
, &saved_context
,
611 __COPY_CONTEXT_SIZE
);
612 have_saved_context
= 0;
617 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
618 CHECK (GetThreadContext (th
->h
, &th
->context
));
619 /* Copy dr values from that thread.
620 But only if there were not modified since last stop.
622 if (!debug_registers_changed
)
624 dr
[0] = th
->context
.Dr0
;
625 dr
[1] = th
->context
.Dr1
;
626 dr
[2] = th
->context
.Dr2
;
627 dr
[3] = th
->context
.Dr3
;
628 dr
[6] = th
->context
.Dr6
;
629 dr
[7] = th
->context
.Dr7
;
632 th
->reload_context
= 0;
636 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch()); r
++)
637 windows_fetch_one_register (regcache
, th
, r
);
639 windows_fetch_one_register (regcache
, th
, r
);
642 /* Collect the register number R from the given regcache, and store
643 its value into the corresponding area of the given thread's context.
645 This function assumes that R is non-negative. A failed assertion
646 assertion is raised if that is not true. */
649 windows_store_one_register (const struct regcache
*regcache
,
650 windows_thread_info
*th
, int r
)
654 regcache
->raw_collect (r
, ((char *) &th
->context
) + mappings
[r
]);
657 /* Store a new register value into the context of the thread tied to
661 windows_nat_target::store_registers (struct regcache
*regcache
, int r
)
663 DWORD tid
= regcache
->ptid ().tid ();
664 windows_thread_info
*th
= thread_rec (tid
, TRUE
);
666 /* Check if TH exists. Windows sometimes uses a non-existent
667 thread id in its events. */
672 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch ()); r
++)
673 windows_store_one_register (regcache
, th
, r
);
675 windows_store_one_register (regcache
, th
, r
);
678 /* Maintain a linked list of "so" information. */
679 struct lm_info_windows
: public lm_info_base
681 LPVOID load_addr
= 0;
684 static struct so_list solib_start
, *solib_end
;
686 static struct so_list
*
687 windows_make_so (const char *name
, LPVOID load_addr
)
694 WIN32_FIND_DATA w32_fd
;
695 HANDLE h
= FindFirstFile(name
, &w32_fd
);
697 if (h
== INVALID_HANDLE_VALUE
)
703 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
705 p
= strrchr (buf
, '\\');
708 SetCurrentDirectory (buf
);
709 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
710 SetCurrentDirectory (cwd
);
713 if (strcasecmp (buf
, "ntdll.dll") == 0)
715 GetSystemDirectory (buf
, sizeof (buf
));
716 strcat (buf
, "\\ntdll.dll");
719 cygwin_buf_t buf
[__PMAX
];
722 if (access (name
, F_OK
) != 0)
724 if (strcasecmp (name
, "ntdll.dll") == 0)
727 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
728 wcscat (buf
, L
"\\ntdll.dll");
732 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
733 strcat (buf
, "\\ntdll.dll");
738 so
= XCNEW (struct so_list
);
739 lm_info_windows
*li
= new lm_info_windows
;
741 li
->load_addr
= load_addr
;
742 strcpy (so
->so_original_name
, name
);
744 strcpy (so
->so_name
, buf
);
747 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
748 SO_NAME_MAX_PATH_SIZE
);
751 char *rname
= realpath (name
, NULL
);
752 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
754 strcpy (so
->so_name
, rname
);
758 error (_("dll path too long"));
760 /* Record cygwin1.dll .text start/end. */
761 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
762 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
764 asection
*text
= NULL
;
766 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386", -1));
771 if (bfd_check_format (abfd
.get (), bfd_object
))
772 text
= bfd_get_section_by_name (abfd
.get (), ".text");
777 /* The symbols in a dll are offset by 0x1000, which is the
778 offset from 0 of the first byte in an image - because of the
779 file header and the section alignment. */
780 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
782 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (text
);
790 get_image_name (HANDLE h
, void *address
, int unicode
)
793 static char buf
[__PMAX
];
795 static char buf
[(2 * __PMAX
) + 1];
797 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
803 /* Attempt to read the name of the dll that was detected.
804 This is documented to work only when actively debugging
805 a program. It will not work for attached processes. */
809 /* See if we could read the address of a string, and that the
810 address isn't null. */
811 if (!ReadProcessMemory (h
, address
, &address_ptr
,
812 sizeof (address_ptr
), &done
)
813 || done
!= sizeof (address_ptr
) || !address_ptr
)
816 /* Find the length of the string. */
817 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
818 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
822 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
825 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
826 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
829 wcstombs (buf
, unicode_address
, __PMAX
);
831 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
839 /* Handle a DLL load event, and return 1.
841 This function assumes that this event did not occur during inferior
842 initialization, where their event info may be incomplete (see
843 do_initial_windows_stuff and windows_add_all_dlls for more info
844 on how we handle DLL loading during that phase). */
849 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
852 /* Try getting the DLL name via the lpImageName field of the event.
853 Note that Microsoft documents this fields as strictly optional,
854 in the sense that it might be NULL. And the first DLL event in
855 particular is explicitly documented as "likely not pass[ed]"
856 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
857 dll_name
= get_image_name (current_process_handle
,
858 event
->lpImageName
, event
->fUnicode
);
862 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
863 solib_end
= solib_end
->next
;
865 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
867 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
868 host_address_to_string (li
->load_addr
)));
872 windows_free_so (struct so_list
*so
)
874 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
880 /* Handle a DLL unload event.
881 Return 1 if successful, or zero otherwise.
883 This function assumes that this event did not occur during inferior
884 initialization, where their event info may be incomplete (see
885 do_initial_windows_stuff and windows_add_all_dlls for more info
886 on how we handle DLL loading during that phase). */
891 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
894 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
896 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
898 if (li_next
->load_addr
== lpBaseOfDll
)
900 struct so_list
*sodel
= so
->next
;
902 so
->next
= sodel
->next
;
905 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
907 windows_free_so (sodel
);
912 /* We did not find any DLL that was previously loaded at this address,
913 so register a complaint. We do not report an error, because we have
914 observed that this may be happening under some circumstances. For
915 instance, running 32bit applications on x64 Windows causes us to receive
916 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
917 events are apparently caused by the WOW layer, the interface between
918 32bit and 64bit worlds). */
919 complaint (_("dll starting at %s not found."),
920 host_address_to_string (lpBaseOfDll
));
923 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
927 catch_errors (void (*func
) ())
933 catch (const gdb_exception
&ex
)
935 exception_print (gdb_stderr
, ex
);
939 /* Clear list of loaded DLLs. */
941 windows_clear_solib (void)
945 for (so
= solib_start
.next
; so
; so
= solib_start
.next
)
947 solib_start
.next
= so
->next
;
948 windows_free_so (so
);
951 solib_end
= &solib_start
;
955 signal_event_command (const char *args
, int from_tty
)
957 uintptr_t event_id
= 0;
958 char *endargs
= NULL
;
961 error (_("signal-event requires an argument (integer event id)"));
963 event_id
= strtoumax (args
, &endargs
, 10);
965 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
966 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
967 error (_("Failed to convert `%s' to event id"), args
);
969 SetEvent ((HANDLE
) event_id
);
970 CloseHandle ((HANDLE
) event_id
);
973 /* Handle DEBUG_STRING output from child process.
974 Cygwin prepends its messages with a "cygwin:". Interpret this as
975 a Cygwin signal. Otherwise just print the string as a warning. */
977 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
979 gdb::unique_xmalloc_ptr
<char> s
;
982 if (!target_read_string
983 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
985 || !s
|| !*(s
.get ()))
987 else if (!startswith (s
.get (), _CYGWIN_SIGNAL_STRING
))
990 if (!startswith (s
.get (), "cYg"))
993 char *p
= strchr (s
.get (), '\0');
995 if (p
> s
.get () && *--p
== '\n')
997 warning (("%s"), s
.get ());
1003 /* Got a cygwin signal marker. A cygwin signal is followed by
1004 the signal number itself and then optionally followed by the
1005 thread id and address to saved context within the DLL. If
1006 these are supplied, then the given thread is assumed to have
1007 issued the signal and the context from the thread is assumed
1008 to be stored at the given address in the inferior. Tell gdb
1009 to treat this like a real signal. */
1011 int sig
= strtol (s
.get () + sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
1012 gdb_signal gotasig
= gdb_signal_from_host (sig
);
1014 ourstatus
->value
.sig
= gotasig
;
1020 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1021 retval
= strtoul (p
, &p
, 0);
1023 retval
= current_event
.dwThreadId
;
1024 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
1025 && ReadProcessMemory (current_process_handle
, x
,
1027 __COPY_CONTEXT_SIZE
, &n
)
1028 && n
== __COPY_CONTEXT_SIZE
)
1029 have_saved_context
= 1;
1038 display_selector (HANDLE thread
, DWORD sel
)
1041 if (GetThreadSelectorEntry (thread
, sel
, &info
))
1044 printf_filtered ("0x%03x: ", (unsigned) sel
);
1045 if (!info
.HighWord
.Bits
.Pres
)
1047 puts_filtered ("Segment not present\n");
1050 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1051 (info
.HighWord
.Bits
.BaseMid
<< 16)
1053 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1054 if (info
.HighWord
.Bits
.Granularity
)
1055 limit
= (limit
<< 12) | 0xfff;
1056 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1057 if (info
.HighWord
.Bits
.Default_Big
)
1058 puts_filtered(" 32-bit ");
1060 puts_filtered(" 16-bit ");
1061 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1064 puts_filtered ("Data (Read-Only, Exp-up");
1067 puts_filtered ("Data (Read/Write, Exp-up");
1070 puts_filtered ("Unused segment (");
1073 puts_filtered ("Data (Read/Write, Exp-down");
1076 puts_filtered ("Code (Exec-Only, N.Conf");
1079 puts_filtered ("Code (Exec/Read, N.Conf");
1082 puts_filtered ("Code (Exec-Only, Conf");
1085 puts_filtered ("Code (Exec/Read, Conf");
1088 printf_filtered ("Unknown type 0x%lx",
1089 (unsigned long) info
.HighWord
.Bits
.Type
);
1091 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1092 puts_filtered(", N.Acc");
1093 puts_filtered (")\n");
1094 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1095 puts_filtered("System selector ");
1096 printf_filtered ("Priviledge level = %ld. ",
1097 (unsigned long) info
.HighWord
.Bits
.Dpl
);
1098 if (info
.HighWord
.Bits
.Granularity
)
1099 puts_filtered ("Page granular.\n");
1101 puts_filtered ("Byte granular.\n");
1106 DWORD err
= GetLastError ();
1107 if (err
== ERROR_NOT_SUPPORTED
)
1108 printf_filtered ("Function not supported\n");
1110 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1116 display_selectors (const char * args
, int from_tty
)
1118 if (!current_thread
)
1120 puts_filtered ("Impossible to display selectors now.\n");
1126 puts_filtered ("Selector $cs\n");
1127 display_selector (current_thread
->h
,
1128 current_thread
->context
.SegCs
);
1129 puts_filtered ("Selector $ds\n");
1130 display_selector (current_thread
->h
,
1131 current_thread
->context
.SegDs
);
1132 puts_filtered ("Selector $es\n");
1133 display_selector (current_thread
->h
,
1134 current_thread
->context
.SegEs
);
1135 puts_filtered ("Selector $ss\n");
1136 display_selector (current_thread
->h
,
1137 current_thread
->context
.SegSs
);
1138 puts_filtered ("Selector $fs\n");
1139 display_selector (current_thread
->h
,
1140 current_thread
->context
.SegFs
);
1141 puts_filtered ("Selector $gs\n");
1142 display_selector (current_thread
->h
,
1143 current_thread
->context
.SegGs
);
1148 sel
= parse_and_eval_long (args
);
1149 printf_filtered ("Selector \"%s\"\n",args
);
1150 display_selector (current_thread
->h
, sel
);
1154 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1155 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1156 host_address_to_string (\
1157 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1159 static handle_exception_result
1160 handle_exception (struct target_waitstatus
*ourstatus
)
1162 EXCEPTION_RECORD
*rec
= ¤t_event
.u
.Exception
.ExceptionRecord
;
1163 DWORD code
= rec
->ExceptionCode
;
1164 handle_exception_result result
= HANDLE_EXCEPTION_HANDLED
;
1166 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1168 /* Record the context of the current thread. */
1169 thread_rec (current_event
.dwThreadId
, -1);
1173 case EXCEPTION_ACCESS_VIOLATION
:
1174 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1175 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1178 /* See if the access violation happened within the cygwin DLL
1179 itself. Cygwin uses a kind of exception handling to deal
1180 with passed-in invalid addresses. gdb should not treat
1181 these as real SEGVs since they will be silently handled by
1182 cygwin. A real SEGV will (theoretically) be caught by
1183 cygwin later in the process and will be sent as a
1184 cygwin-specific-signal. So, ignore SEGVs if they show up
1185 within the text segment of the DLL itself. */
1187 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1189 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1190 && addr
< cygwin_load_end
))
1191 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1192 && startswith (fn
, "KERNEL32!IsBad")))
1193 return HANDLE_EXCEPTION_UNHANDLED
;
1197 case STATUS_STACK_OVERFLOW
:
1198 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1199 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1201 case STATUS_FLOAT_DENORMAL_OPERAND
:
1202 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1203 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1205 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1206 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1207 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1209 case STATUS_FLOAT_INEXACT_RESULT
:
1210 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1211 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1213 case STATUS_FLOAT_INVALID_OPERATION
:
1214 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1215 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1217 case STATUS_FLOAT_OVERFLOW
:
1218 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1219 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1221 case STATUS_FLOAT_STACK_CHECK
:
1222 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1223 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1225 case STATUS_FLOAT_UNDERFLOW
:
1226 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1227 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1229 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1230 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1231 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1233 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1234 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1235 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1237 case STATUS_INTEGER_OVERFLOW
:
1238 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1239 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1241 case EXCEPTION_BREAKPOINT
:
1242 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1243 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1246 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1247 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1249 case DBG_CONTROL_BREAK
:
1250 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1251 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1253 case EXCEPTION_SINGLE_STEP
:
1254 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1255 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1257 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1258 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1259 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1261 case EXCEPTION_PRIV_INSTRUCTION
:
1262 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1263 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1265 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1266 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1267 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1269 case MS_VC_EXCEPTION
:
1270 if (rec
->NumberParameters
>= 3
1271 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1273 DWORD named_thread_id
;
1274 windows_thread_info
*named_thread
;
1275 CORE_ADDR thread_name_target
;
1277 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1279 thread_name_target
= rec
->ExceptionInformation
[1];
1280 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1282 if (named_thread_id
== (DWORD
) -1)
1283 named_thread_id
= current_event
.dwThreadId
;
1285 named_thread
= thread_rec (named_thread_id
, 0);
1286 if (named_thread
!= NULL
)
1288 int thread_name_len
;
1289 gdb::unique_xmalloc_ptr
<char> thread_name
;
1291 thread_name_len
= target_read_string (thread_name_target
,
1292 &thread_name
, 1025, NULL
);
1293 if (thread_name_len
> 0)
1295 thread_name
.get ()[thread_name_len
- 1] = '\0';
1296 xfree (named_thread
->name
);
1297 named_thread
->name
= thread_name
.release ();
1300 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1301 result
= HANDLE_EXCEPTION_IGNORED
;
1304 /* treat improperly formed exception as unknown */
1307 /* Treat unhandled first chance exceptions specially. */
1308 if (current_event
.u
.Exception
.dwFirstChance
)
1309 return HANDLE_EXCEPTION_UNHANDLED
;
1310 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1311 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1312 host_address_to_string (
1313 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1314 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1318 last_sig
= ourstatus
->value
.sig
;
1322 /* Resume thread specified by ID, or all artificially suspended
1323 threads, if we are continuing execution. KILLED non-zero means we
1324 have killed the inferior, so we should ignore weird errors due to
1325 threads shutting down. */
1327 windows_continue (DWORD continue_status
, int id
, int killed
)
1329 windows_thread_info
*th
;
1332 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1333 (unsigned) current_event
.dwProcessId
,
1334 (unsigned) current_event
.dwThreadId
,
1335 continue_status
== DBG_CONTINUE
?
1336 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1338 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1339 if ((id
== -1 || id
== (int) th
->id
)
1342 if (debug_registers_changed
)
1344 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1345 th
->context
.Dr0
= dr
[0];
1346 th
->context
.Dr1
= dr
[1];
1347 th
->context
.Dr2
= dr
[2];
1348 th
->context
.Dr3
= dr
[3];
1349 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1350 th
->context
.Dr7
= dr
[7];
1352 if (th
->context
.ContextFlags
)
1356 if (GetExitCodeThread (th
->h
, &ec
)
1357 && ec
== STILL_ACTIVE
)
1359 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1364 th
->context
.ContextFlags
= 0;
1366 if (th
->suspended
> 0)
1367 (void) ResumeThread (th
->h
);
1371 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1372 current_event
.dwThreadId
,
1376 error (_("Failed to resume program execution"
1377 " (ContinueDebugEvent failed, error %u)"),
1378 (unsigned int) GetLastError ());
1380 debug_registers_changed
= 0;
1384 /* Called in pathological case where Windows fails to send a
1385 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1387 fake_create_process (void)
1389 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1390 current_event
.dwProcessId
);
1391 if (current_process_handle
!= NULL
)
1392 open_process_used
= 1;
1395 error (_("OpenProcess call failed, GetLastError = %u"),
1396 (unsigned) GetLastError ());
1397 /* We can not debug anything in that case. */
1400 = windows_add_thread (ptid_t (current_event
.dwProcessId
, 0,
1401 current_event
.dwThreadId
),
1402 current_event
.u
.CreateThread
.hThread
,
1403 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1404 true /* main_thread_p */);
1405 return current_event
.dwThreadId
;
1409 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1411 windows_thread_info
*th
;
1412 DWORD continue_status
= DBG_CONTINUE
;
1414 /* A specific PTID means `step only this thread id'. */
1415 int resume_all
= ptid
== minus_one_ptid
;
1417 /* If we're continuing all threads, it's the current inferior that
1418 should be handled specially. */
1420 ptid
= inferior_ptid
;
1422 if (sig
!= GDB_SIGNAL_0
)
1424 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1426 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1428 else if (sig
== last_sig
)
1429 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1432 /* This code does not seem to work, because
1433 the kernel does probably not consider changes in the ExceptionRecord
1434 structure when passing the exception to the inferior.
1435 Note that this seems possible in the exception handler itself. */
1437 for (const xlate_exception
&x
: xlate
)
1440 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1442 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1445 if (continue_status
== DBG_CONTINUE
)
1447 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1451 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1455 last_sig
= GDB_SIGNAL_0
;
1457 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=0x%x, step=%d, sig=%d);\n",
1458 ptid
.pid (), (unsigned) ptid
.tid (), step
, sig
));
1460 /* Get context for currently selected thread. */
1461 th
= thread_rec (inferior_ptid
.tid (), FALSE
);
1466 /* Single step by setting t bit. */
1467 struct regcache
*regcache
= get_current_regcache ();
1468 struct gdbarch
*gdbarch
= regcache
->arch ();
1469 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1470 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1473 if (th
->context
.ContextFlags
)
1475 if (debug_registers_changed
)
1477 th
->context
.Dr0
= dr
[0];
1478 th
->context
.Dr1
= dr
[1];
1479 th
->context
.Dr2
= dr
[2];
1480 th
->context
.Dr3
= dr
[3];
1481 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1482 th
->context
.Dr7
= dr
[7];
1484 CHECK (SetThreadContext (th
->h
, &th
->context
));
1485 th
->context
.ContextFlags
= 0;
1489 /* Allow continuing with the same signal that interrupted us.
1490 Otherwise complain. */
1493 windows_continue (continue_status
, -1, 0);
1495 windows_continue (continue_status
, ptid
.tid (), 0);
1498 /* Ctrl-C handler used when the inferior is not run in the same console. The
1499 handler is in charge of interrupting the inferior using DebugBreakProcess.
1500 Note that this function is not available prior to Windows XP. In this case
1501 we emit a warning. */
1503 ctrl_c_handler (DWORD event_type
)
1505 const int attach_flag
= current_inferior ()->attach_flag
;
1507 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1508 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1511 /* If the inferior and the debugger share the same console, do nothing as
1512 the inferior has also received the Ctrl-C event. */
1513 if (!new_console
&& !attach_flag
)
1516 if (!DebugBreakProcess (current_process_handle
))
1517 warning (_("Could not interrupt program. "
1518 "Press Ctrl-c in the program console."));
1520 /* Return true to tell that Ctrl-C has been handled. */
1524 /* Get the next event from the child. Returns a non-zero thread id if the event
1525 requires handling by WFI (or whatever). */
1527 get_windows_debug_event (struct target_ops
*ops
,
1528 int pid
, struct target_waitstatus
*ourstatus
)
1531 DWORD continue_status
, event_code
;
1532 windows_thread_info
*th
;
1533 static windows_thread_info dummy_thread_info
;
1534 DWORD thread_id
= 0;
1536 last_sig
= GDB_SIGNAL_0
;
1538 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1542 continue_status
= DBG_CONTINUE
;
1544 event_code
= current_event
.dwDebugEventCode
;
1545 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1547 have_saved_context
= 0;
1551 case CREATE_THREAD_DEBUG_EVENT
:
1552 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1553 (unsigned) current_event
.dwProcessId
,
1554 (unsigned) current_event
.dwThreadId
,
1555 "CREATE_THREAD_DEBUG_EVENT"));
1556 if (saw_create
!= 1)
1558 struct inferior
*inf
;
1559 inf
= find_inferior_pid (current_event
.dwProcessId
);
1560 if (!saw_create
&& inf
->attach_flag
)
1562 /* Kludge around a Windows bug where first event is a create
1563 thread event. Caused when attached process does not have
1565 thread_id
= fake_create_process ();
1571 /* Record the existence of this thread. */
1572 thread_id
= current_event
.dwThreadId
;
1573 th
= windows_add_thread
1574 (ptid_t (current_event
.dwProcessId
, 0, current_event
.dwThreadId
),
1575 current_event
.u
.CreateThread
.hThread
,
1576 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1577 false /* main_thread_p */);
1581 case EXIT_THREAD_DEBUG_EVENT
:
1582 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1583 (unsigned) current_event
.dwProcessId
,
1584 (unsigned) current_event
.dwThreadId
,
1585 "EXIT_THREAD_DEBUG_EVENT"));
1586 windows_delete_thread (ptid_t (current_event
.dwProcessId
, 0,
1587 current_event
.dwThreadId
),
1588 current_event
.u
.ExitThread
.dwExitCode
,
1589 false /* main_thread_p */);
1590 th
= &dummy_thread_info
;
1593 case CREATE_PROCESS_DEBUG_EVENT
:
1594 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1595 (unsigned) current_event
.dwProcessId
,
1596 (unsigned) current_event
.dwThreadId
,
1597 "CREATE_PROCESS_DEBUG_EVENT"));
1598 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1599 if (++saw_create
!= 1)
1602 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1603 /* Add the main thread. */
1604 th
= windows_add_thread
1605 (ptid_t (current_event
.dwProcessId
, 0,
1606 current_event
.dwThreadId
),
1607 current_event
.u
.CreateProcessInfo
.hThread
,
1608 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
,
1609 true /* main_thread_p */);
1610 thread_id
= current_event
.dwThreadId
;
1613 case EXIT_PROCESS_DEBUG_EVENT
:
1614 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1615 (unsigned) current_event
.dwProcessId
,
1616 (unsigned) current_event
.dwThreadId
,
1617 "EXIT_PROCESS_DEBUG_EVENT"));
1618 if (!windows_initialization_done
)
1620 target_terminal::ours ();
1621 target_mourn_inferior (inferior_ptid
);
1622 error (_("During startup program exited with code 0x%x."),
1623 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1625 else if (saw_create
== 1)
1627 windows_delete_thread (ptid_t (current_event
.dwProcessId
, 0,
1628 current_event
.dwThreadId
),
1629 0, true /* main_thread_p */);
1630 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1631 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1632 thread_id
= current_event
.dwThreadId
;
1636 case LOAD_DLL_DEBUG_EVENT
:
1637 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1638 (unsigned) current_event
.dwProcessId
,
1639 (unsigned) current_event
.dwThreadId
,
1640 "LOAD_DLL_DEBUG_EVENT"));
1641 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1642 if (saw_create
!= 1 || ! windows_initialization_done
)
1644 catch_errors (handle_load_dll
);
1645 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1646 ourstatus
->value
.integer
= 0;
1647 thread_id
= current_event
.dwThreadId
;
1650 case UNLOAD_DLL_DEBUG_EVENT
:
1651 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1652 (unsigned) current_event
.dwProcessId
,
1653 (unsigned) current_event
.dwThreadId
,
1654 "UNLOAD_DLL_DEBUG_EVENT"));
1655 if (saw_create
!= 1 || ! windows_initialization_done
)
1657 catch_errors (handle_unload_dll
);
1658 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1659 ourstatus
->value
.integer
= 0;
1660 thread_id
= current_event
.dwThreadId
;
1663 case EXCEPTION_DEBUG_EVENT
:
1664 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1665 (unsigned) current_event
.dwProcessId
,
1666 (unsigned) current_event
.dwThreadId
,
1667 "EXCEPTION_DEBUG_EVENT"));
1668 if (saw_create
!= 1)
1670 switch (handle_exception (ourstatus
))
1672 case HANDLE_EXCEPTION_UNHANDLED
:
1674 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1676 case HANDLE_EXCEPTION_HANDLED
:
1677 thread_id
= current_event
.dwThreadId
;
1679 case HANDLE_EXCEPTION_IGNORED
:
1680 continue_status
= DBG_CONTINUE
;
1685 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1686 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1687 (unsigned) current_event
.dwProcessId
,
1688 (unsigned) current_event
.dwThreadId
,
1689 "OUTPUT_DEBUG_STRING_EVENT"));
1690 if (saw_create
!= 1)
1692 thread_id
= handle_output_debug_string (ourstatus
);
1696 if (saw_create
!= 1)
1698 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1699 (unsigned) current_event
.dwProcessId
,
1700 (unsigned) current_event
.dwThreadId
);
1701 printf_unfiltered (" unknown event code %u\n",
1702 (unsigned) current_event
.dwDebugEventCode
);
1706 if (!thread_id
|| saw_create
!= 1)
1708 CHECK (windows_continue (continue_status
, -1, 0));
1712 inferior_ptid
= ptid_t (current_event
.dwProcessId
, 0, thread_id
);
1713 current_thread
= th
;
1714 if (!current_thread
)
1715 current_thread
= thread_rec (thread_id
, TRUE
);
1722 /* Wait for interesting events to occur in the target process. */
1724 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1729 /* We loop when we get a non-standard exception rather than return
1730 with a SPURIOUS because resume can try and step or modify things,
1731 which needs a current_thread->h. But some of these exceptions mark
1732 the birth or death of threads, which mean that the current thread
1733 isn't necessarily what you think it is. */
1739 /* If the user presses Ctrl-c while the debugger is waiting
1740 for an event, he expects the debugger to interrupt his program
1741 and to get the prompt back. There are two possible situations:
1743 - The debugger and the program do not share the console, in
1744 which case the Ctrl-c event only reached the debugger.
1745 In that case, the ctrl_c handler will take care of interrupting
1746 the inferior. Note that this case is working starting with
1747 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1750 - The debugger and the program share the same console, in which
1751 case both debugger and inferior will receive the Ctrl-c event.
1752 In that case the ctrl_c handler will ignore the event, as the
1753 Ctrl-c event generated inside the inferior will trigger the
1754 expected debug event.
1756 FIXME: brobecker/2008-05-20: If the inferior receives the
1757 signal first and the delay until GDB receives that signal
1758 is sufficiently long, GDB can sometimes receive the SIGINT
1759 after we have unblocked the CTRL+C handler. This would
1760 lead to the debugger stopping prematurely while handling
1761 the new-thread event that comes with the handling of the SIGINT
1762 inside the inferior, and then stop again immediately when
1763 the user tries to resume the execution in the inferior.
1764 This is a classic race that we should try to fix one day. */
1765 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1766 retval
= get_windows_debug_event (this, pid
, ourstatus
);
1767 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1770 return ptid_t (current_event
.dwProcessId
, 0, retval
);
1775 if (deprecated_ui_loop_hook
!= NULL
)
1776 detach
= deprecated_ui_loop_hook (0);
1784 /* Iterate over all DLLs currently mapped by our inferior, and
1785 add them to our list of solibs. */
1788 windows_add_all_dlls (void)
1790 HMODULE dummy_hmodule
;
1795 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
1796 sizeof (HMODULE
), &cb_needed
) == 0)
1802 hmodules
= (HMODULE
*) alloca (cb_needed
);
1803 if (EnumProcessModules (current_process_handle
, hmodules
,
1804 cb_needed
, &cb_needed
) == 0)
1807 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
1811 wchar_t dll_name
[__PMAX
];
1814 char dll_name
[__PMAX
];
1817 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
1818 &mi
, sizeof (mi
)) == 0)
1820 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
1821 dll_name
, sizeof (dll_name
)) == 0)
1824 wcstombs (name
, dll_name
, __PMAX
);
1829 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
1830 solib_end
= solib_end
->next
;
1835 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1838 struct inferior
*inf
;
1840 last_sig
= GDB_SIGNAL_0
;
1842 exception_count
= 0;
1843 open_process_used
= 0;
1844 debug_registers_changed
= 0;
1845 debug_registers_used
= 0;
1846 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1849 cygwin_load_start
= cygwin_load_end
= 0;
1851 current_event
.dwProcessId
= pid
;
1852 memset (¤t_event
, 0, sizeof (current_event
));
1853 if (!target_is_pushed (ops
))
1855 disable_breakpoints_in_shlibs ();
1856 windows_clear_solib ();
1857 clear_proceed_status (0);
1858 init_wait_for_inferior ();
1860 inf
= current_inferior ();
1861 inferior_appeared (inf
, pid
);
1862 inf
->attach_flag
= attaching
;
1864 /* Make the new process the current inferior, so terminal handling
1865 can rely on it. When attaching, we don't know about any thread
1866 id here, but that's OK --- nothing should be referencing the
1867 current thread until we report an event out of windows_wait. */
1868 inferior_ptid
= ptid_t (pid
);
1870 target_terminal::init ();
1871 target_terminal::inferior ();
1873 windows_initialization_done
= 0;
1877 struct target_waitstatus status
;
1879 ops
->wait (minus_one_ptid
, &status
, 0);
1881 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
1883 if (status
.kind
!= TARGET_WAITKIND_LOADED
1884 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
1887 ops
->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
1890 /* Now that the inferior has been started and all DLLs have been mapped,
1891 we can iterate over all DLLs and load them in.
1893 We avoid doing it any earlier because, on certain versions of Windows,
1894 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
1895 we have seen on Windows 8.1 that the ntdll.dll load event does not
1896 include the DLL name, preventing us from creating an associated SO.
1897 A possible explanation is that ntdll.dll might be mapped before
1898 the SO info gets created by the Windows system -- ntdll.dll is
1899 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
1900 do not seem to suffer from that problem.
1902 Rather than try to work around this sort of issue, it is much
1903 simpler to just ignore DLL load/unload events during the startup
1904 phase, and then process them all in one batch now. */
1905 windows_add_all_dlls ();
1907 windows_initialization_done
= 1;
1911 /* Try to set or remove a user privilege to the current process. Return -1
1912 if that fails, the previous setting of that privilege otherwise.
1914 This code is copied from the Cygwin source code and rearranged to allow
1915 dynamically loading of the needed symbols from advapi32 which is only
1916 available on NT/2K/XP. */
1918 set_process_privilege (const char *privilege
, BOOL enable
)
1920 HANDLE token_hdl
= NULL
;
1922 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1926 if (!OpenProcessToken (GetCurrentProcess (),
1927 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1931 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
1934 new_priv
.PrivilegeCount
= 1;
1935 new_priv
.Privileges
[0].Luid
= restore_priv
;
1936 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1938 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1939 sizeof orig_priv
, &orig_priv
, &size
))
1942 /* Disabled, otherwise every `attach' in an unprivileged user session
1943 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1944 windows_attach(). */
1945 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1946 be enabled. GetLastError () returns an correct error code, though. */
1947 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1951 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1955 CloseHandle (token_hdl
);
1960 /* Attach to process PID, then initialize for debugging it. */
1963 windows_nat_target::attach (const char *args
, int from_tty
)
1968 pid
= parse_pid_to_attach (args
);
1970 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1972 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1973 printf_unfiltered ("This can cause attach to "
1974 "fail on Windows NT/2K/XP\n");
1977 windows_init_thread_list ();
1978 ok
= DebugActiveProcess (pid
);
1984 /* Try fall back to Cygwin pid. */
1985 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1988 ok
= DebugActiveProcess (pid
);
1993 error (_("Can't attach to process %u (error %u)"),
1994 (unsigned) pid
, (unsigned) GetLastError ());
1996 DebugSetProcessKillOnExit (FALSE
);
2000 const char *exec_file
= get_exec_file (0);
2003 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
2004 target_pid_to_str (ptid_t (pid
)).c_str ());
2006 printf_unfiltered ("Attaching to %s\n",
2007 target_pid_to_str (ptid_t (pid
)).c_str ());
2010 do_initial_windows_stuff (this, pid
, 1);
2011 target_terminal::ours ();
2015 windows_nat_target::detach (inferior
*inf
, int from_tty
)
2019 ptid_t ptid
= minus_one_ptid
;
2020 resume (ptid
, 0, GDB_SIGNAL_0
);
2022 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
2024 error (_("Can't detach process %u (error %u)"),
2025 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
2028 DebugSetProcessKillOnExit (FALSE
);
2030 if (detached
&& from_tty
)
2032 const char *exec_file
= get_exec_file (0);
2035 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
2036 (unsigned) current_event
.dwProcessId
);
2039 x86_cleanup_dregs ();
2040 inferior_ptid
= null_ptid
;
2041 detach_inferior (inf
);
2043 maybe_unpush_target ();
2046 /* Try to determine the executable filename.
2048 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2050 Upon success, the filename is stored inside EXE_NAME_RET, and
2051 this function returns nonzero.
2053 Otherwise, this function returns zero and the contents of
2054 EXE_NAME_RET is undefined. */
2057 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2064 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2065 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2068 /* We know the executable is always first in the list of modules,
2069 which we just fetched. So no need to fetch more. */
2073 /* Cygwin prefers that the path be in /x/y/z format, so extract
2074 the filename into a temporary buffer first, and then convert it
2075 to POSIX format into the destination buffer. */
2076 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2078 len
= GetModuleFileNameEx (current_process_handle
,
2079 dh_buf
, pathbuf
, exe_name_max_len
);
2081 error (_("Error getting executable filename: %u."),
2082 (unsigned) GetLastError ());
2083 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2084 exe_name_max_len
) < 0)
2085 error (_("Error converting executable filename to POSIX: %d."), errno
);
2088 len
= GetModuleFileNameEx (current_process_handle
,
2089 dh_buf
, exe_name_ret
, exe_name_max_len
);
2091 error (_("Error getting executable filename: %u."),
2092 (unsigned) GetLastError ());
2095 return 1; /* success */
2098 /* The pid_to_exec_file target_ops method for this platform. */
2101 windows_nat_target::pid_to_exec_file (int pid
)
2103 static char path
[__PMAX
];
2105 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2107 char procexe
[sizeof ("/proc/4294967295/exe")];
2109 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2110 nchars
= readlink (procexe
, path
, sizeof(path
));
2111 if (nchars
> 0 && nchars
< sizeof (path
))
2113 path
[nchars
] = '\0'; /* Got it */
2118 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2119 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2120 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2126 /* Print status information about what we're accessing. */
2129 windows_nat_target::files_info ()
2131 struct inferior
*inf
= current_inferior ();
2133 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2134 inf
->attach_flag
? "attached" : "child",
2135 target_pid_to_str (inferior_ptid
).c_str ());
2138 /* Modify CreateProcess parameters for use of a new separate console.
2140 *FLAGS: DWORD parameter for general process creation flags.
2141 *SI: STARTUPINFO structure, for which the console window size and
2142 console buffer size is filled in if GDB is running in a console.
2143 to create the new console.
2144 The size of the used font is not available on all versions of
2145 Windows OS. Furthermore, the current font might not be the default
2146 font, but this is still better than before.
2147 If the windows and buffer sizes are computed,
2148 SI->DWFLAGS is changed so that this information is used
2149 by CreateProcess function. */
2152 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2154 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2155 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2157 if (hconsole
!= INVALID_HANDLE_VALUE
)
2159 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2161 CONSOLE_FONT_INFO cfi
;
2163 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2164 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2165 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2166 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2167 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2169 si
->dwXSize
*= font_size
.X
;
2173 si
->dwYSize
*= font_size
.Y
;
2176 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2177 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2178 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2180 *flags
|= CREATE_NEW_CONSOLE
;
2184 /* Function called by qsort to sort environment strings. */
2187 envvar_cmp (const void *a
, const void *b
)
2189 const char **p
= (const char **) a
;
2190 const char **q
= (const char **) b
;
2191 return strcasecmp (*p
, *q
);
2197 clear_win32_environment (char **env
)
2201 wchar_t *copy
= NULL
, *equalpos
;
2203 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2205 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2206 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2207 mbstowcs (copy
, env
[i
], len
);
2208 equalpos
= wcschr (copy
, L
'=');
2211 SetEnvironmentVariableW (copy
, NULL
);
2219 /* Redirection of inferior I/O streams for native MS-Windows programs.
2220 Unlike on Unix, where this is handled by invoking the inferior via
2221 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2223 The official documentation of the cmd.exe redirection features is here:
2225 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2227 (That page talks about Windows XP, but there's no newer
2228 documentation, so we assume later versions of cmd.exe didn't change
2231 Caveat: the documentation on that page seems to include a few lies.
2232 For example, it describes strange constructs 1<&2 and 2<&1, which
2233 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2234 think the cmd.exe parser of the redirection symbols simply doesn't
2235 care about the < vs > distinction in these cases. Therefore, the
2236 supported features are explicitly documented below.
2238 The emulation below aims at supporting all the valid use cases
2239 supported by cmd.exe, which include:
2241 < FILE redirect standard input from FILE
2242 0< FILE redirect standard input from FILE
2243 <&N redirect standard input from file descriptor N
2244 0<&N redirect standard input from file descriptor N
2245 > FILE redirect standard output to FILE
2246 >> FILE append standard output to FILE
2247 1>> FILE append standard output to FILE
2248 >&N redirect standard output to file descriptor N
2249 1>&N redirect standard output to file descriptor N
2250 >>&N append standard output to file descriptor N
2251 1>>&N append standard output to file descriptor N
2252 2> FILE redirect standard error to FILE
2253 2>> FILE append standard error to FILE
2254 2>&N redirect standard error to file descriptor N
2255 2>>&N append standard error to file descriptor N
2257 Note that using N > 2 in the above construct is supported, but
2258 requires that the corresponding file descriptor be open by some
2259 means elsewhere or outside GDB. Also note that using ">&0" or
2260 "<&2" will generally fail, because the file descriptor redirected
2261 from is normally open in an incompatible mode (e.g., FD 0 is open
2262 for reading only). IOW, use of such tricks is not recommended;
2263 you are on your own.
2265 We do NOT support redirection of file descriptors above 2, as in
2266 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2267 that needs special handling in the startup code that MinGW
2268 doesn't have). Pipes are also not supported.
2270 As for invalid use cases, where the redirection contains some
2271 error, the emulation below will detect that and produce some
2272 error and/or failure. But the behavior in those cases is not
2273 bug-for-bug compatible with what cmd.exe does in those cases.
2274 That's because what cmd.exe does then is not well defined, and
2275 seems to be a side effect of the cmd.exe parsing of the command
2276 line more than anything else. For example, try redirecting to an
2277 invalid file name, as in "> foo:bar".
2279 There are also minor syntactic deviations from what cmd.exe does
2280 in some corner cases. For example, it doesn't support the likes
2281 of "> &foo" to mean redirect to file named literally "&foo"; we
2282 do support that here, because that, too, sounds like some issue
2283 with the cmd.exe parser. Another nicety is that we support
2284 redirection targets that use file names with forward slashes,
2285 something cmd.exe doesn't -- this comes in handy since GDB
2286 file-name completion can be used when typing the command line for
2289 /* Support routines for redirecting standard handles of the inferior. */
2291 /* Parse a single redirection spec, open/duplicate the specified
2292 file/fd, and assign the appropriate value to one of the 3 standard
2293 file descriptors. */
2295 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2297 int *fd
, ref_fd
= -2;
2299 const char *fname
= redir_string
+ 1;
2300 int rc
= *redir_string
;
2315 fd
= (rc
== '2') ? err
: out
;
2316 mode
= O_WRONLY
| O_CREAT
;
2329 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2331 /* A reference to a file descriptor. */
2333 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2334 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2336 /* Don't allow redirection when open modes are incompatible. */
2337 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2338 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2345 else if (ref_fd
== 1)
2347 else if (ref_fd
== 2)
2357 fname
++; /* skip the separator space */
2358 /* If the descriptor is already open, close it. This allows
2359 multiple specs of redirections for the same stream, which is
2360 somewhat nonsensical, but still valid and supported by cmd.exe.
2361 (But cmd.exe only opens a single file in this case, the one
2362 specified by the last redirection spec on the command line.) */
2367 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2371 else if (ref_fd
== -1)
2372 *fd
= -1; /* reset to default destination */
2375 *fd
= _dup (ref_fd
);
2379 /* _open just sets a flag for O_APPEND, which won't be passed to the
2380 inferior, so we need to actually move the file pointer. */
2381 if ((mode
& O_APPEND
) != 0)
2382 _lseek (*fd
, 0L, SEEK_END
);
2386 /* Canonicalize a single redirection spec and set up the corresponding
2387 file descriptor as specified. */
2389 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2391 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2393 const char *start
= s
;
2396 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2397 if ((*start
== '>' || *start
== '1' || *start
== '2')
2401 if (*s
== '>' && *start
!= '>')
2404 else if (*start
== '0' && *s
== '<')
2406 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2409 while (isspace (*s
)) /* skip whitespace before file name */
2411 *d
++ = ' '; /* separate file name with a single space */
2414 /* Copy the file name. */
2417 /* Remove quoting characters from the file name in buf[]. */
2418 if (*s
== '"') /* could support '..' quoting here */
2422 else if (*s
== quote
)
2430 else if (*s
== '\\')
2432 if (s
[1] == '"') /* could support '..' here */
2436 else if (isspace (*s
) && !quote
)
2440 if (d
- buf
>= sizeof (buf
) - 1)
2442 errno
= ENAMETOOLONG
;
2448 /* Windows doesn't allow redirection characters in file names, so we
2449 can bail out early if they use them, or if there's no target file
2450 name after the redirection symbol. */
2451 if (d
[-1] == '>' || d
[-1] == '<')
2456 if (redir_open (buf
, inp
, out
, err
) == 0)
2461 /* Parse the command line for redirection specs and prepare the file
2462 descriptors for the 3 standard streams accordingly. */
2464 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2465 int *inp
, int *out
, int *err
)
2467 const char *s
= cmd_orig
;
2470 bool retval
= false;
2472 while (isspace (*s
))
2477 if (*s
== '"') /* could also support '..' quoting here */
2481 else if (*s
== quote
)
2484 else if (*s
== '\\')
2486 if (s
[1] == '"') /* escaped quote char */
2491 /* Process a single redirection candidate. */
2492 if (*s
== '<' || *s
== '>'
2493 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2494 || (*s
== '0' && s
[1] == '<'))
2496 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2510 #endif /* !__CYGWIN__ */
2512 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2513 EXEC_FILE is the file to run.
2514 ALLARGS is a string containing the arguments to the program.
2515 ENV is the environment vector to pass. Errors reported with error(). */
2518 windows_nat_target::create_inferior (const char *exec_file
,
2519 const std::string
&origallargs
,
2520 char **in_env
, int from_tty
)
2524 cygwin_buf_t real_path
[__PMAX
];
2525 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2526 cygwin_buf_t infcwd
[__PMAX
];
2528 cygwin_buf_t
*toexec
;
2529 cygwin_buf_t
*cygallargs
;
2531 char **old_env
= NULL
;
2535 int ostdin
, ostdout
, ostderr
;
2536 #else /* !__CYGWIN__ */
2537 char shell
[__PMAX
]; /* Path to shell */
2539 char *args
, *allargs_copy
;
2540 size_t args_len
, allargs_len
;
2541 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2542 HANDLE tty
= INVALID_HANDLE_VALUE
;
2543 bool redirected
= false;
2550 #endif /* !__CYGWIN__ */
2551 const char *allargs
= origallargs
.c_str ();
2552 PROCESS_INFORMATION pi
;
2555 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2558 error (_("No executable specified, use `target exec'."));
2560 const char *inferior_cwd
= get_inferior_cwd ();
2561 std::string expanded_infcwd
;
2562 if (inferior_cwd
!= NULL
)
2564 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
2565 /* Mirror slashes on inferior's cwd. */
2566 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
2568 inferior_cwd
= expanded_infcwd
.c_str ();
2571 memset (&si
, 0, sizeof (si
));
2572 si
.cb
= sizeof (si
);
2575 flags
|= CREATE_NEW_PROCESS_GROUP
;
2578 windows_set_console_info (&si
, &flags
);
2583 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2584 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2585 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2586 error (_("Error starting executable: %d"), errno
);
2589 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2590 if (len
== (size_t) -1)
2591 error (_("Error starting executable: %d"), errno
);
2592 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2593 mbstowcs (cygallargs
, allargs
, len
);
2594 #else /* !__USEWIDE */
2595 cygallargs
= allargs
;
2601 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2602 error (_("Error starting executable via shell: %d"), errno
);
2604 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2605 + mbstowcs (NULL
, allargs
, 0) + 2;
2606 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2607 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2608 #else /* !__USEWIDE */
2609 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2610 + strlen (allargs
) + 2);
2611 cygallargs
= (char *) alloca (len
);
2612 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2613 #endif /* __USEWIDE */
2615 flags
|= DEBUG_PROCESS
;
2618 if (inferior_cwd
!= NULL
2619 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
2620 infcwd
, strlen (inferior_cwd
)) < 0)
2621 error (_("Error converting inferior cwd: %d"), errno
);
2624 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2625 * sizeof (wchar_t));
2626 wcscpy (args
, toexec
);
2627 wcscat (args
, L
" ");
2628 wcscat (args
, cygallargs
);
2629 #else /* !__USEWIDE */
2630 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2631 strcpy (args
, toexec
);
2633 strcat (args
, cygallargs
);
2634 #endif /* !__USEWIDE */
2636 #ifdef CW_CVT_ENV_TO_WINENV
2637 /* First try to create a direct Win32 copy of the POSIX environment. */
2638 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2639 if (w32_env
!= (PWCHAR
) -1)
2640 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2642 /* If that fails, fall back to old method tweaking GDB's environment. */
2643 #endif /* CW_CVT_ENV_TO_WINENV */
2645 /* Reset all Win32 environment variables to avoid leftover on next run. */
2646 clear_win32_environment (environ
);
2647 /* Prepare the environment vars for CreateProcess. */
2650 cygwin_internal (CW_SYNC_WINENV
);
2654 if (!inferior_io_terminal
)
2655 tty
= ostdin
= ostdout
= ostderr
= -1;
2658 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2661 print_sys_errmsg (inferior_io_terminal
, errno
);
2662 ostdin
= ostdout
= ostderr
= -1;
2675 windows_init_thread_list ();
2676 ret
= CreateProcess (0,
2677 args
, /* command line */
2678 NULL
, /* Security */
2680 TRUE
, /* inherit handles */
2681 flags
, /* start flags */
2682 w32_env
, /* environment */
2683 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
2688 /* Just free the Win32 environment, if it could be created. */
2692 /* Reset all environment variables to avoid leftover on next run. */
2693 clear_win32_environment (in_env
);
2694 /* Restore normal GDB environment variables. */
2696 cygwin_internal (CW_SYNC_WINENV
);
2709 #else /* !__CYGWIN__ */
2710 allargs_len
= strlen (allargs
);
2711 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
2712 if (strpbrk (allargs_copy
, "<>") != NULL
)
2717 redirect_inferior_handles (allargs
, allargs_copy
,
2718 &fd_inp
, &fd_out
, &fd_err
);
2720 warning (_("Error in redirection: %s."), safe_strerror (errno
));
2723 allargs_len
= strlen (allargs_copy
);
2725 /* If not all the standard streams are redirected by the command
2726 line, use inferior_io_terminal for those which aren't. */
2727 if (inferior_io_terminal
2728 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
2730 SECURITY_ATTRIBUTES sa
;
2731 sa
.nLength
= sizeof(sa
);
2732 sa
.lpSecurityDescriptor
= 0;
2733 sa
.bInheritHandle
= TRUE
;
2734 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2735 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2736 if (tty
== INVALID_HANDLE_VALUE
)
2737 warning (_("Warning: Failed to open TTY %s, error %#x."),
2738 inferior_io_terminal
, (unsigned) GetLastError ());
2740 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
2743 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
2744 else if (tty
!= INVALID_HANDLE_VALUE
)
2747 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
2749 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
2750 else if (tty
!= INVALID_HANDLE_VALUE
)
2751 si
.hStdOutput
= tty
;
2753 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
2755 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
2756 else if (tty
!= INVALID_HANDLE_VALUE
)
2759 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
2760 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2764 /* Build the command line, a space-separated list of tokens where
2765 the first token is the name of the module to be executed.
2766 To avoid ambiguities introduced by spaces in the module name,
2768 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
2769 args
= (char *) alloca (args_len
);
2770 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
2772 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2774 /* CreateProcess takes the environment list as a null terminated set of
2775 strings (i.e. two nulls terminate the list). */
2777 /* Get total size for env strings. */
2778 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2779 envlen
+= strlen (in_env
[i
]) + 1;
2781 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2782 env
= (char **) alloca (envsize
);
2783 memcpy (env
, in_env
, envsize
);
2784 /* Windows programs expect the environment block to be sorted. */
2785 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2787 w32env
= (char *) alloca (envlen
+ 1);
2789 /* Copy env strings into new buffer. */
2790 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2792 strcpy (temp
, env
[i
]);
2793 temp
+= strlen (temp
) + 1;
2796 /* Final nil string to terminate new env. */
2799 windows_init_thread_list ();
2800 ret
= CreateProcessA (0,
2801 args
, /* command line */
2802 NULL
, /* Security */
2804 TRUE
, /* inherit handles */
2805 flags
, /* start flags */
2806 w32env
, /* environment */
2807 inferior_cwd
, /* current directory */
2810 if (tty
!= INVALID_HANDLE_VALUE
)
2818 #endif /* !__CYGWIN__ */
2821 error (_("Error creating process %s, (error %u)."),
2822 exec_file
, (unsigned) GetLastError ());
2824 CloseHandle (pi
.hThread
);
2825 CloseHandle (pi
.hProcess
);
2827 if (useshell
&& shell
[0] != '\0')
2832 do_initial_windows_stuff (this, pi
.dwProcessId
, 0);
2834 /* windows_continue (DBG_CONTINUE, -1, 0); */
2838 windows_nat_target::mourn_inferior ()
2840 (void) windows_continue (DBG_CONTINUE
, -1, 0);
2841 x86_cleanup_dregs();
2842 if (open_process_used
)
2844 CHECK (CloseHandle (current_process_handle
));
2845 open_process_used
= 0;
2847 inf_child_target::mourn_inferior ();
2850 /* Send a SIGINT to the process group. This acts just like the user typed a
2851 ^C on the controlling terminal. */
2854 windows_nat_target::interrupt ()
2856 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2857 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
2858 registers_changed (); /* refresh register state */
2861 /* Helper for windows_xfer_partial that handles memory transfers.
2862 Arguments are like target_xfer_partial. */
2864 static enum target_xfer_status
2865 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2866 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2870 DWORD lasterror
= 0;
2872 if (writebuf
!= NULL
)
2874 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
2875 pulongest (len
), core_addr_to_string (memaddr
)));
2876 success
= WriteProcessMemory (current_process_handle
,
2877 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
2880 lasterror
= GetLastError ();
2881 FlushInstructionCache (current_process_handle
,
2882 (LPCVOID
) (uintptr_t) memaddr
, len
);
2886 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
2887 pulongest (len
), core_addr_to_string (memaddr
)));
2888 success
= ReadProcessMemory (current_process_handle
,
2889 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
2892 lasterror
= GetLastError ();
2894 *xfered_len
= (ULONGEST
) done
;
2895 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
2896 return TARGET_XFER_OK
;
2898 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
2902 windows_nat_target::kill ()
2904 CHECK (TerminateProcess (current_process_handle
, 0));
2908 if (!windows_continue (DBG_CONTINUE
, -1, 1))
2910 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
2912 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2916 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
2920 windows_nat_target::close ()
2922 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2923 inferior_ptid
.pid ()));
2926 /* Convert pid to printable format. */
2928 windows_nat_target::pid_to_str (ptid_t ptid
)
2930 if (ptid
.tid () != 0)
2931 return string_printf ("Thread %d.0x%lx", ptid
.pid (), ptid
.tid ());
2933 return normal_pid_to_str (ptid
);
2936 static enum target_xfer_status
2937 windows_xfer_shared_libraries (struct target_ops
*ops
,
2938 enum target_object object
, const char *annex
,
2939 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2940 ULONGEST offset
, ULONGEST len
,
2941 ULONGEST
*xfered_len
)
2943 struct obstack obstack
;
2949 return TARGET_XFER_E_IO
;
2951 obstack_init (&obstack
);
2952 obstack_grow_str (&obstack
, "<library-list>\n");
2953 for (so
= solib_start
.next
; so
; so
= so
->next
)
2955 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
2957 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
2958 (uintptr_t) li
->load_addr
,
2959 target_gdbarch (), &obstack
);
2961 obstack_grow_str0 (&obstack
, "</library-list>\n");
2963 buf
= (const char *) obstack_finish (&obstack
);
2964 len_avail
= strlen (buf
);
2965 if (offset
>= len_avail
)
2969 if (len
> len_avail
- offset
)
2970 len
= len_avail
- offset
;
2971 memcpy (readbuf
, buf
+ offset
, len
);
2974 obstack_free (&obstack
, NULL
);
2975 *xfered_len
= (ULONGEST
) len
;
2976 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
2979 enum target_xfer_status
2980 windows_nat_target::xfer_partial (enum target_object object
,
2981 const char *annex
, gdb_byte
*readbuf
,
2982 const gdb_byte
*writebuf
, ULONGEST offset
,
2983 ULONGEST len
, ULONGEST
*xfered_len
)
2987 case TARGET_OBJECT_MEMORY
:
2988 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
2990 case TARGET_OBJECT_LIBRARIES
:
2991 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
2992 writebuf
, offset
, len
, xfered_len
);
2995 if (beneath () == NULL
)
2997 /* This can happen when requesting the transfer of unsupported
2998 objects before a program has been started (and therefore
2999 with the current_target having no target beneath). */
3000 return TARGET_XFER_E_IO
;
3002 return beneath ()->xfer_partial (object
, annex
,
3003 readbuf
, writebuf
, offset
, len
,
3008 /* Provide thread local base, i.e. Thread Information Block address.
3009 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
3012 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
3014 windows_thread_info
*th
;
3016 th
= thread_rec (ptid
.tid (), 0);
3021 *addr
= th
->thread_local_base
;
3027 windows_nat_target::get_ada_task_ptid (long lwp
, long thread
)
3029 return ptid_t (inferior_ptid
.pid (), 0, lwp
);
3032 /* Implementation of the to_thread_name method. */
3035 windows_nat_target::thread_name (struct thread_info
*thr
)
3037 return thread_rec (thr
->ptid
.tid (), 0)->name
;
3042 _initialize_windows_nat (void)
3044 x86_dr_low
.set_control
= cygwin_set_dr7
;
3045 x86_dr_low
.set_addr
= cygwin_set_dr
;
3046 x86_dr_low
.get_addr
= cygwin_get_dr
;
3047 x86_dr_low
.get_status
= cygwin_get_dr6
;
3048 x86_dr_low
.get_control
= cygwin_get_dr7
;
3050 /* x86_dr_low.debug_register_length field is set by
3051 calling x86_set_debug_register_length function
3052 in processor windows specific native file. */
3054 add_inf_child_target (&the_windows_nat_target
);
3057 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3060 add_com ("signal-event", class_run
, signal_event_command
, _("\
3061 Signal a crashed process with event ID, to allow its debugging.\n\
3062 This command is needed in support of setting up GDB as JIT debugger on \
3063 MS-Windows. The command should be invoked from the GDB command line using \
3064 the '-ex' command-line option. The ID of the event that blocks the \
3065 crashed process will be supplied by the Windows JIT debugging mechanism."));
3068 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3069 Set use of shell to start subprocess."), _("\
3070 Show use of shell to start subprocess."), NULL
,
3072 NULL
, /* FIXME: i18n: */
3073 &setlist
, &showlist
);
3075 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3076 &cygwin_exceptions
, _("\
3077 Break when an exception is detected in the Cygwin DLL itself."), _("\
3078 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3080 NULL
, /* FIXME: i18n: */
3081 &setlist
, &showlist
);
3084 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3085 Set creation of new console when creating child process."), _("\
3086 Show creation of new console when creating child process."), NULL
,
3088 NULL
, /* FIXME: i18n: */
3089 &setlist
, &showlist
);
3091 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3092 Set creation of new group when creating child process."), _("\
3093 Show creation of new group when creating child process."), NULL
,
3095 NULL
, /* FIXME: i18n: */
3096 &setlist
, &showlist
);
3098 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3099 Set whether to display execution in child process."), _("\
3100 Show whether to display execution in child process."), NULL
,
3102 NULL
, /* FIXME: i18n: */
3103 &setlist
, &showlist
);
3105 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3106 Set whether to display kernel events in child process."), _("\
3107 Show whether to display kernel events in child process."), NULL
,
3109 NULL
, /* FIXME: i18n: */
3110 &setlist
, &showlist
);
3112 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3113 Set whether to display memory accesses in child process."), _("\
3114 Show whether to display memory accesses in child process."), NULL
,
3116 NULL
, /* FIXME: i18n: */
3117 &setlist
, &showlist
);
3119 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3120 &debug_exceptions
, _("\
3121 Set whether to display kernel exceptions in child process."), _("\
3122 Show whether to display kernel exceptions in child process."), NULL
,
3124 NULL
, /* FIXME: i18n: */
3125 &setlist
, &showlist
);
3127 init_w32_command_list ();
3129 add_cmd ("selector", class_info
, display_selectors
,
3130 _("Display selectors infos."),
3134 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3136 /* Pass the address ADDR to the inferior in the I'th debug register.
3137 Here we just store the address in dr array, the registers will be
3138 actually set up when windows_continue is called. */
3140 cygwin_set_dr (int i
, CORE_ADDR addr
)
3143 internal_error (__FILE__
, __LINE__
,
3144 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3146 debug_registers_changed
= 1;
3147 debug_registers_used
= 1;
3150 /* Pass the value VAL to the inferior in the DR7 debug control
3151 register. Here we just store the address in D_REGS, the watchpoint
3152 will be actually set up in windows_wait. */
3154 cygwin_set_dr7 (unsigned long val
)
3156 dr
[7] = (CORE_ADDR
) val
;
3157 debug_registers_changed
= 1;
3158 debug_registers_used
= 1;
3161 /* Get the value of debug register I from the inferior. */
3164 cygwin_get_dr (int i
)
3169 /* Get the value of the DR6 debug status register from the inferior.
3170 Here we just return the value stored in dr[6]
3171 by the last call to thread_rec for current_event.dwThreadId id. */
3172 static unsigned long
3173 cygwin_get_dr6 (void)
3175 return (unsigned long) dr
[6];
3178 /* Get the value of the DR7 debug status register from the inferior.
3179 Here we just return the value stored in dr[7] by the last call to
3180 thread_rec for current_event.dwThreadId id. */
3182 static unsigned long
3183 cygwin_get_dr7 (void)
3185 return (unsigned long) dr
[7];
3188 /* Determine if the thread referenced by "ptid" is alive
3189 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3190 it means that the thread has died. Otherwise it is assumed to be alive. */
3193 windows_nat_target::thread_alive (ptid_t ptid
)
3197 gdb_assert (ptid
.tid () != 0);
3200 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) != WAIT_OBJECT_0
;
3204 _initialize_check_for_gdb_ini (void)
3207 if (inhibit_gdbinit
)
3210 homedir
= getenv ("HOME");
3214 char *oldini
= (char *) alloca (strlen (homedir
) +
3215 sizeof ("gdb.ini") + 1);
3216 strcpy (oldini
, homedir
);
3217 p
= strchr (oldini
, '\0');
3218 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3220 strcpy (p
, "gdb.ini");
3221 if (access (oldini
, 0) == 0)
3223 int len
= strlen (oldini
);
3224 char *newini
= (char *) alloca (len
+ 2);
3226 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3227 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3228 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3233 /* Define dummy functions which always return error for the rare cases where
3234 these functions could not be found. */
3236 bad_DebugActiveProcessStop (DWORD w
)
3241 bad_DebugBreakProcess (HANDLE w
)
3246 bad_DebugSetProcessKillOnExit (BOOL w
)
3251 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3258 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3264 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3271 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3277 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3283 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3289 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3297 /* Load any functions which may not be available in ancient versions
3301 _initialize_loadable (void)
3305 #define GPA(m, func) \
3306 func = (func ## _ftype *) GetProcAddress (m, #func)
3308 hm
= LoadLibrary ("kernel32.dll");
3311 GPA (hm
, DebugActiveProcessStop
);
3312 GPA (hm
, DebugBreakProcess
);
3313 GPA (hm
, DebugSetProcessKillOnExit
);
3314 GPA (hm
, GetConsoleFontSize
);
3315 GPA (hm
, DebugActiveProcessStop
);
3316 GPA (hm
, GetCurrentConsoleFont
);
3319 /* Set variables to dummy versions of these processes if the function
3320 wasn't found in kernel32.dll. */
3321 if (!DebugBreakProcess
)
3322 DebugBreakProcess
= bad_DebugBreakProcess
;
3323 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3325 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3326 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3328 if (!GetConsoleFontSize
)
3329 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3330 if (!GetCurrentConsoleFont
)
3331 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3333 /* Load optional functions used for retrieving filename information
3334 associated with the currently debugged process or its dlls. */
3335 hm
= LoadLibrary ("psapi.dll");
3338 GPA (hm
, EnumProcessModules
);
3339 GPA (hm
, GetModuleInformation
);
3340 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3341 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3344 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3346 /* Set variables to dummy versions of these processes if the function
3347 wasn't found in psapi.dll. */
3348 EnumProcessModules
= bad_EnumProcessModules
;
3349 GetModuleInformation
= bad_GetModuleInformation
;
3350 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3351 /* This will probably fail on Windows 9x/Me. Let the user know
3352 that we're missing some functionality. */
3354 cannot automatically find executable file or library to read symbols.\n\
3355 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3358 hm
= LoadLibrary ("advapi32.dll");
3361 GPA (hm
, OpenProcessToken
);
3362 GPA (hm
, LookupPrivilegeValueA
);
3363 GPA (hm
, AdjustTokenPrivileges
);
3364 /* Only need to set one of these since if OpenProcessToken fails nothing
3366 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3367 || !AdjustTokenPrivileges
)
3368 OpenProcessToken
= bad_OpenProcessToken
;