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. */
430 static windows_thread_info
*
431 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
)
433 windows_thread_info
*th
;
436 gdb_assert (ptid
.tid () != 0);
440 if ((th
= thread_rec (id
, FALSE
)))
443 th
= XCNEW (windows_thread_info
);
446 th
->thread_local_base
= (CORE_ADDR
) (uintptr_t) tlb
;
447 th
->next
= thread_head
.next
;
448 thread_head
.next
= th
;
450 /* Set the debug registers for the new thread if they are used. */
451 if (debug_registers_used
)
453 /* Only change the value of the debug registers. */
454 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
455 CHECK (GetThreadContext (th
->h
, &th
->context
));
456 th
->context
.Dr0
= dr
[0];
457 th
->context
.Dr1
= dr
[1];
458 th
->context
.Dr2
= dr
[2];
459 th
->context
.Dr3
= dr
[3];
460 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
461 th
->context
.Dr7
= dr
[7];
462 CHECK (SetThreadContext (th
->h
, &th
->context
));
463 th
->context
.ContextFlags
= 0;
468 /* Clear out any old thread list and reinitialize it to a
471 windows_init_thread_list (void)
473 windows_thread_info
*th
= &thread_head
;
475 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
477 while (th
->next
!= NULL
)
479 windows_thread_info
*here
= th
->next
;
480 th
->next
= here
->next
;
483 thread_head
.next
= NULL
;
486 /* Delete a thread from the list of threads. */
488 windows_delete_thread (ptid_t ptid
, DWORD exit_code
)
490 windows_thread_info
*th
;
493 gdb_assert (ptid
.tid () != 0);
498 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
));
499 else if (print_thread_events
)
500 printf_unfiltered (_("[%s exited with code %u]\n"),
501 target_pid_to_str (ptid
), (unsigned) exit_code
);
502 delete_thread (find_thread_ptid (ptid
));
504 for (th
= &thread_head
;
505 th
->next
!= NULL
&& th
->next
->id
!= id
;
509 if (th
->next
!= NULL
)
511 windows_thread_info
*here
= th
->next
;
512 th
->next
= here
->next
;
518 /* Fetches register number R from the given windows_thread_info,
519 and supplies its value to the given regcache.
521 This function assumes that R is non-negative. A failed assertion
522 is raised if that is not true.
524 This function assumes that TH->RELOAD_CONTEXT is not set, meaning
525 that the windows_thread_info has an up-to-date context. A failed
526 assertion is raised if that assumption is violated. */
529 windows_fetch_one_register (struct regcache
*regcache
,
530 windows_thread_info
*th
, int r
)
533 gdb_assert (!th
->reload_context
);
535 char *context_offset
= ((char *) &th
->context
) + mappings
[r
];
536 struct gdbarch
*gdbarch
= regcache
->arch ();
537 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
539 if (r
== I387_FISEG_REGNUM (tdep
))
541 long l
= *((long *) context_offset
) & 0xffff;
542 regcache
->raw_supply (r
, (char *) &l
);
544 else if (r
== I387_FOP_REGNUM (tdep
))
546 long l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
547 regcache
->raw_supply (r
, (char *) &l
);
549 else if (segment_register_p (r
))
551 /* GDB treats segment registers as 32bit registers, but they are
552 in fact only 16 bits long. Make sure we do not read extra
553 bits from our source buffer. */
554 long l
= *((long *) context_offset
) & 0xffff;
555 regcache
->raw_supply (r
, (char *) &l
);
558 regcache
->raw_supply (r
, context_offset
);
562 windows_nat_target::fetch_registers (struct regcache
*regcache
, int r
)
564 DWORD pid
= regcache
->ptid ().tid ();
565 windows_thread_info
*th
= thread_rec (pid
, TRUE
);
567 /* Check if TH exists. Windows sometimes uses a non-existent
568 thread id in its events. */
572 if (th
->reload_context
)
575 if (have_saved_context
)
577 /* Lie about where the program actually is stopped since
578 cygwin has informed us that we should consider the signal
579 to have occurred at another location which is stored in
581 memcpy (&th
->context
, &saved_context
,
582 __COPY_CONTEXT_SIZE
);
583 have_saved_context
= 0;
588 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
589 CHECK (GetThreadContext (th
->h
, &th
->context
));
590 /* Copy dr values from that thread.
591 But only if there were not modified since last stop.
593 if (!debug_registers_changed
)
595 dr
[0] = th
->context
.Dr0
;
596 dr
[1] = th
->context
.Dr1
;
597 dr
[2] = th
->context
.Dr2
;
598 dr
[3] = th
->context
.Dr3
;
599 dr
[6] = th
->context
.Dr6
;
600 dr
[7] = th
->context
.Dr7
;
603 th
->reload_context
= 0;
607 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch()); r
++)
608 windows_fetch_one_register (regcache
, th
, r
);
610 windows_fetch_one_register (regcache
, th
, r
);
613 /* Collect the register number R from the given regcache, and store
614 its value into the corresponding area of the given thread's context.
616 This function assumes that R is non-negative. A failed assertion
617 assertion is raised if that is not true. */
620 windows_store_one_register (const struct regcache
*regcache
,
621 windows_thread_info
*th
, int r
)
625 regcache
->raw_collect (r
, ((char *) &th
->context
) + mappings
[r
]);
628 /* Store a new register value into the context of the thread tied to
632 windows_nat_target::store_registers (struct regcache
*regcache
, int r
)
634 DWORD pid
= regcache
->ptid ().tid ();
635 windows_thread_info
*th
= thread_rec (pid
, TRUE
);
637 /* Check if TH exists. Windows sometimes uses a non-existent
638 thread id in its events. */
643 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch ()); r
++)
644 windows_store_one_register (regcache
, th
, r
);
646 windows_store_one_register (regcache
, th
, r
);
649 /* Encapsulate the information required in a call to
650 symbol_file_add_args. */
651 struct safe_symbol_file_add_args
655 section_addr_info
*addrs
;
658 struct ui_file
*err
, *out
;
662 /* Maintain a linked list of "so" information. */
663 struct lm_info_windows
: public lm_info_base
665 LPVOID load_addr
= 0;
668 static struct so_list solib_start
, *solib_end
;
670 static struct so_list
*
671 windows_make_so (const char *name
, LPVOID load_addr
)
678 WIN32_FIND_DATA w32_fd
;
679 HANDLE h
= FindFirstFile(name
, &w32_fd
);
681 if (h
== INVALID_HANDLE_VALUE
)
687 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
689 p
= strrchr (buf
, '\\');
692 SetCurrentDirectory (buf
);
693 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
694 SetCurrentDirectory (cwd
);
697 if (strcasecmp (buf
, "ntdll.dll") == 0)
699 GetSystemDirectory (buf
, sizeof (buf
));
700 strcat (buf
, "\\ntdll.dll");
703 cygwin_buf_t buf
[__PMAX
];
706 if (access (name
, F_OK
) != 0)
708 if (strcasecmp (name
, "ntdll.dll") == 0)
711 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
712 wcscat (buf
, L
"\\ntdll.dll");
716 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
717 strcat (buf
, "\\ntdll.dll");
722 so
= XCNEW (struct so_list
);
723 lm_info_windows
*li
= new lm_info_windows
;
725 li
->load_addr
= load_addr
;
726 strcpy (so
->so_original_name
, name
);
728 strcpy (so
->so_name
, buf
);
731 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
732 SO_NAME_MAX_PATH_SIZE
);
735 char *rname
= realpath (name
, NULL
);
736 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
738 strcpy (so
->so_name
, rname
);
742 error (_("dll path too long"));
744 /* Record cygwin1.dll .text start/end. */
745 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
746 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
748 asection
*text
= NULL
;
751 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386", -1));
756 if (bfd_check_format (abfd
.get (), bfd_object
))
757 text
= bfd_get_section_by_name (abfd
.get (), ".text");
762 /* The symbols in a dll are offset by 0x1000, which is the
763 offset from 0 of the first byte in an image - because of the
764 file header and the section alignment. */
765 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
767 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (abfd
.get (),
776 get_image_name (HANDLE h
, void *address
, int unicode
)
779 static char buf
[__PMAX
];
781 static char buf
[(2 * __PMAX
) + 1];
783 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
789 /* Attempt to read the name of the dll that was detected.
790 This is documented to work only when actively debugging
791 a program. It will not work for attached processes. */
795 /* See if we could read the address of a string, and that the
796 address isn't null. */
797 if (!ReadProcessMemory (h
, address
, &address_ptr
,
798 sizeof (address_ptr
), &done
)
799 || done
!= sizeof (address_ptr
) || !address_ptr
)
802 /* Find the length of the string. */
803 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
804 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
808 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
811 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
812 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
815 wcstombs (buf
, unicode_address
, __PMAX
);
817 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
825 /* Handle a DLL load event, and return 1.
827 This function assumes that this event did not occur during inferior
828 initialization, where their event info may be incomplete (see
829 do_initial_windows_stuff and windows_add_all_dlls for more info
830 on how we handle DLL loading during that phase). */
835 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
838 /* Try getting the DLL name via the lpImageName field of the event.
839 Note that Microsoft documents this fields as strictly optional,
840 in the sense that it might be NULL. And the first DLL event in
841 particular is explicitly documented as "likely not pass[ed]"
842 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
843 dll_name
= get_image_name (current_process_handle
,
844 event
->lpImageName
, event
->fUnicode
);
848 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
849 solib_end
= solib_end
->next
;
851 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
853 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
854 host_address_to_string (li
->load_addr
)));
858 windows_free_so (struct so_list
*so
)
860 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
866 /* Handle a DLL unload event.
867 Return 1 if successful, or zero otherwise.
869 This function assumes that this event did not occur during inferior
870 initialization, where their event info may be incomplete (see
871 do_initial_windows_stuff and windows_add_all_dlls for more info
872 on how we handle DLL loading during that phase). */
877 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
880 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
882 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
884 if (li_next
->load_addr
== lpBaseOfDll
)
886 struct so_list
*sodel
= so
->next
;
888 so
->next
= sodel
->next
;
891 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
893 windows_free_so (sodel
);
898 /* We did not find any DLL that was previously loaded at this address,
899 so register a complaint. We do not report an error, because we have
900 observed that this may be happening under some circumstances. For
901 instance, running 32bit applications on x64 Windows causes us to receive
902 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
903 events are apparently caused by the WOW layer, the interface between
904 32bit and 64bit worlds). */
905 complaint (_("dll starting at %s not found."),
906 host_address_to_string (lpBaseOfDll
));
909 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
913 catch_errors (void (*func
) ())
919 CATCH (ex
, RETURN_MASK_ALL
)
921 exception_print (gdb_stderr
, ex
);
926 /* Clear list of loaded DLLs. */
928 windows_clear_solib (void)
930 solib_start
.next
= NULL
;
931 solib_end
= &solib_start
;
935 signal_event_command (const char *args
, int from_tty
)
937 uintptr_t event_id
= 0;
938 char *endargs
= NULL
;
941 error (_("signal-event requires an argument (integer event id)"));
943 event_id
= strtoumax (args
, &endargs
, 10);
945 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
946 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
947 error (_("Failed to convert `%s' to event id"), args
);
949 SetEvent ((HANDLE
) event_id
);
950 CloseHandle ((HANDLE
) event_id
);
953 /* Handle DEBUG_STRING output from child process.
954 Cygwin prepends its messages with a "cygwin:". Interpret this as
955 a Cygwin signal. Otherwise just print the string as a warning. */
957 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
959 gdb::unique_xmalloc_ptr
<char> s
;
962 if (!target_read_string
963 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
965 || !s
|| !*(s
.get ()))
967 else if (!startswith (s
.get (), _CYGWIN_SIGNAL_STRING
))
970 if (!startswith (s
.get (), "cYg"))
973 char *p
= strchr (s
.get (), '\0');
975 if (p
> s
.get () && *--p
== '\n')
977 warning (("%s"), s
.get ());
983 /* Got a cygwin signal marker. A cygwin signal is followed by
984 the signal number itself and then optionally followed by the
985 thread id and address to saved context within the DLL. If
986 these are supplied, then the given thread is assumed to have
987 issued the signal and the context from the thread is assumed
988 to be stored at the given address in the inferior. Tell gdb
989 to treat this like a real signal. */
991 int sig
= strtol (s
.get () + sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
992 gdb_signal gotasig
= gdb_signal_from_host (sig
);
994 ourstatus
->value
.sig
= gotasig
;
1000 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1001 retval
= strtoul (p
, &p
, 0);
1003 retval
= main_thread_id
;
1004 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
1005 && ReadProcessMemory (current_process_handle
, x
,
1007 __COPY_CONTEXT_SIZE
, &n
)
1008 && n
== __COPY_CONTEXT_SIZE
)
1009 have_saved_context
= 1;
1018 display_selector (HANDLE thread
, DWORD sel
)
1021 if (GetThreadSelectorEntry (thread
, sel
, &info
))
1024 printf_filtered ("0x%03x: ", (unsigned) sel
);
1025 if (!info
.HighWord
.Bits
.Pres
)
1027 puts_filtered ("Segment not present\n");
1030 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1031 (info
.HighWord
.Bits
.BaseMid
<< 16)
1033 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1034 if (info
.HighWord
.Bits
.Granularity
)
1035 limit
= (limit
<< 12) | 0xfff;
1036 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1037 if (info
.HighWord
.Bits
.Default_Big
)
1038 puts_filtered(" 32-bit ");
1040 puts_filtered(" 16-bit ");
1041 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1044 puts_filtered ("Data (Read-Only, Exp-up");
1047 puts_filtered ("Data (Read/Write, Exp-up");
1050 puts_filtered ("Unused segment (");
1053 puts_filtered ("Data (Read/Write, Exp-down");
1056 puts_filtered ("Code (Exec-Only, N.Conf");
1059 puts_filtered ("Code (Exec/Read, N.Conf");
1062 puts_filtered ("Code (Exec-Only, Conf");
1065 puts_filtered ("Code (Exec/Read, Conf");
1068 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
1070 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1071 puts_filtered(", N.Acc");
1072 puts_filtered (")\n");
1073 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1074 puts_filtered("System selector ");
1075 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
1076 if (info
.HighWord
.Bits
.Granularity
)
1077 puts_filtered ("Page granular.\n");
1079 puts_filtered ("Byte granular.\n");
1084 DWORD err
= GetLastError ();
1085 if (err
== ERROR_NOT_SUPPORTED
)
1086 printf_filtered ("Function not supported\n");
1088 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1094 display_selectors (const char * args
, int from_tty
)
1096 if (!current_thread
)
1098 puts_filtered ("Impossible to display selectors now.\n");
1104 puts_filtered ("Selector $cs\n");
1105 display_selector (current_thread
->h
,
1106 current_thread
->context
.SegCs
);
1107 puts_filtered ("Selector $ds\n");
1108 display_selector (current_thread
->h
,
1109 current_thread
->context
.SegDs
);
1110 puts_filtered ("Selector $es\n");
1111 display_selector (current_thread
->h
,
1112 current_thread
->context
.SegEs
);
1113 puts_filtered ("Selector $ss\n");
1114 display_selector (current_thread
->h
,
1115 current_thread
->context
.SegSs
);
1116 puts_filtered ("Selector $fs\n");
1117 display_selector (current_thread
->h
,
1118 current_thread
->context
.SegFs
);
1119 puts_filtered ("Selector $gs\n");
1120 display_selector (current_thread
->h
,
1121 current_thread
->context
.SegGs
);
1126 sel
= parse_and_eval_long (args
);
1127 printf_filtered ("Selector \"%s\"\n",args
);
1128 display_selector (current_thread
->h
, sel
);
1132 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1133 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1134 host_address_to_string (\
1135 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1137 static handle_exception_result
1138 handle_exception (struct target_waitstatus
*ourstatus
)
1140 EXCEPTION_RECORD
*rec
= ¤t_event
.u
.Exception
.ExceptionRecord
;
1141 DWORD code
= rec
->ExceptionCode
;
1142 handle_exception_result result
= HANDLE_EXCEPTION_HANDLED
;
1144 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1146 /* Record the context of the current thread. */
1147 thread_rec (current_event
.dwThreadId
, -1);
1151 case EXCEPTION_ACCESS_VIOLATION
:
1152 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1153 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1156 /* See if the access violation happened within the cygwin DLL
1157 itself. Cygwin uses a kind of exception handling to deal
1158 with passed-in invalid addresses. gdb should not treat
1159 these as real SEGVs since they will be silently handled by
1160 cygwin. A real SEGV will (theoretically) be caught by
1161 cygwin later in the process and will be sent as a
1162 cygwin-specific-signal. So, ignore SEGVs if they show up
1163 within the text segment of the DLL itself. */
1165 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1167 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1168 && addr
< cygwin_load_end
))
1169 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1170 && startswith (fn
, "KERNEL32!IsBad")))
1171 return HANDLE_EXCEPTION_UNHANDLED
;
1175 case STATUS_STACK_OVERFLOW
:
1176 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1177 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1179 case STATUS_FLOAT_DENORMAL_OPERAND
:
1180 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1181 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1183 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1184 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1185 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1187 case STATUS_FLOAT_INEXACT_RESULT
:
1188 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1189 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1191 case STATUS_FLOAT_INVALID_OPERATION
:
1192 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1193 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1195 case STATUS_FLOAT_OVERFLOW
:
1196 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1197 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1199 case STATUS_FLOAT_STACK_CHECK
:
1200 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1201 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1203 case STATUS_FLOAT_UNDERFLOW
:
1204 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1205 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1207 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1208 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1209 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1211 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1212 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1213 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1215 case STATUS_INTEGER_OVERFLOW
:
1216 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1217 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1219 case EXCEPTION_BREAKPOINT
:
1220 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1221 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1224 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1225 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1227 case DBG_CONTROL_BREAK
:
1228 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1229 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1231 case EXCEPTION_SINGLE_STEP
:
1232 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1233 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1235 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1236 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1237 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1239 case EXCEPTION_PRIV_INSTRUCTION
:
1240 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1241 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1243 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1244 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1245 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1247 case MS_VC_EXCEPTION
:
1248 if (rec
->NumberParameters
>= 3
1249 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1251 DWORD named_thread_id
;
1252 windows_thread_info
*named_thread
;
1253 CORE_ADDR thread_name_target
;
1255 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1257 thread_name_target
= rec
->ExceptionInformation
[1];
1258 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1260 if (named_thread_id
== (DWORD
) -1)
1261 named_thread_id
= current_event
.dwThreadId
;
1263 named_thread
= thread_rec (named_thread_id
, 0);
1264 if (named_thread
!= NULL
)
1266 int thread_name_len
;
1267 gdb::unique_xmalloc_ptr
<char> thread_name
;
1269 thread_name_len
= target_read_string (thread_name_target
,
1270 &thread_name
, 1025, NULL
);
1271 if (thread_name_len
> 0)
1273 thread_name
.get ()[thread_name_len
- 1] = '\0';
1274 xfree (named_thread
->name
);
1275 named_thread
->name
= thread_name
.release ();
1278 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1279 result
= HANDLE_EXCEPTION_IGNORED
;
1282 /* treat improperly formed exception as unknown */
1285 /* Treat unhandled first chance exceptions specially. */
1286 if (current_event
.u
.Exception
.dwFirstChance
)
1287 return HANDLE_EXCEPTION_UNHANDLED
;
1288 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1289 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1290 host_address_to_string (
1291 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1292 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1296 last_sig
= ourstatus
->value
.sig
;
1300 /* Resume thread specified by ID, or all artificially suspended
1301 threads, if we are continuing execution. KILLED non-zero means we
1302 have killed the inferior, so we should ignore weird errors due to
1303 threads shutting down. */
1305 windows_continue (DWORD continue_status
, int id
, int killed
)
1307 windows_thread_info
*th
;
1310 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1311 (unsigned) current_event
.dwProcessId
,
1312 (unsigned) current_event
.dwThreadId
,
1313 continue_status
== DBG_CONTINUE
?
1314 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1316 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1317 if ((id
== -1 || id
== (int) th
->id
)
1320 if (debug_registers_changed
)
1322 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1323 th
->context
.Dr0
= dr
[0];
1324 th
->context
.Dr1
= dr
[1];
1325 th
->context
.Dr2
= dr
[2];
1326 th
->context
.Dr3
= dr
[3];
1327 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1328 th
->context
.Dr7
= dr
[7];
1330 if (th
->context
.ContextFlags
)
1334 if (GetExitCodeThread (th
->h
, &ec
)
1335 && ec
== STILL_ACTIVE
)
1337 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1342 th
->context
.ContextFlags
= 0;
1344 if (th
->suspended
> 0)
1345 (void) ResumeThread (th
->h
);
1349 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1350 current_event
.dwThreadId
,
1354 error (_("Failed to resume program execution"
1355 " (ContinueDebugEvent failed, error %u)"),
1356 (unsigned int) GetLastError ());
1358 debug_registers_changed
= 0;
1362 /* Called in pathological case where Windows fails to send a
1363 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1365 fake_create_process (void)
1367 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1368 current_event
.dwProcessId
);
1369 if (current_process_handle
!= NULL
)
1370 open_process_used
= 1;
1373 error (_("OpenProcess call failed, GetLastError = %u"),
1374 (unsigned) GetLastError ());
1375 /* We can not debug anything in that case. */
1377 main_thread_id
= current_event
.dwThreadId
;
1378 current_thread
= windows_add_thread (
1379 ptid_t (current_event
.dwProcessId
, 0,
1380 current_event
.dwThreadId
),
1381 current_event
.u
.CreateThread
.hThread
,
1382 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1383 return main_thread_id
;
1387 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1389 windows_thread_info
*th
;
1390 DWORD continue_status
= DBG_CONTINUE
;
1392 /* A specific PTID means `step only this thread id'. */
1393 int resume_all
= ptid
== minus_one_ptid
;
1395 /* If we're continuing all threads, it's the current inferior that
1396 should be handled specially. */
1398 ptid
= inferior_ptid
;
1400 if (sig
!= GDB_SIGNAL_0
)
1402 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1404 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1406 else if (sig
== last_sig
)
1407 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1410 /* This code does not seem to work, because
1411 the kernel does probably not consider changes in the ExceptionRecord
1412 structure when passing the exception to the inferior.
1413 Note that this seems possible in the exception handler itself. */
1415 for (const xlate_exception
&x
: xlate
)
1418 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1420 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1423 if (continue_status
== DBG_CONTINUE
)
1425 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1429 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1433 last_sig
= GDB_SIGNAL_0
;
1435 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1436 ptid
.pid (), ptid
.tid (), step
, sig
));
1438 /* Get context for currently selected thread. */
1439 th
= thread_rec (inferior_ptid
.tid (), FALSE
);
1444 /* Single step by setting t bit. */
1445 struct regcache
*regcache
= get_current_regcache ();
1446 struct gdbarch
*gdbarch
= regcache
->arch ();
1447 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1448 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1451 if (th
->context
.ContextFlags
)
1453 if (debug_registers_changed
)
1455 th
->context
.Dr0
= dr
[0];
1456 th
->context
.Dr1
= dr
[1];
1457 th
->context
.Dr2
= dr
[2];
1458 th
->context
.Dr3
= dr
[3];
1459 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1460 th
->context
.Dr7
= dr
[7];
1462 CHECK (SetThreadContext (th
->h
, &th
->context
));
1463 th
->context
.ContextFlags
= 0;
1467 /* Allow continuing with the same signal that interrupted us.
1468 Otherwise complain. */
1471 windows_continue (continue_status
, -1, 0);
1473 windows_continue (continue_status
, ptid
.tid (), 0);
1476 /* Ctrl-C handler used when the inferior is not run in the same console. The
1477 handler is in charge of interrupting the inferior using DebugBreakProcess.
1478 Note that this function is not available prior to Windows XP. In this case
1479 we emit a warning. */
1481 ctrl_c_handler (DWORD event_type
)
1483 const int attach_flag
= current_inferior ()->attach_flag
;
1485 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1486 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1489 /* If the inferior and the debugger share the same console, do nothing as
1490 the inferior has also received the Ctrl-C event. */
1491 if (!new_console
&& !attach_flag
)
1494 if (!DebugBreakProcess (current_process_handle
))
1495 warning (_("Could not interrupt program. "
1496 "Press Ctrl-c in the program console."));
1498 /* Return true to tell that Ctrl-C has been handled. */
1502 /* Get the next event from the child. Returns a non-zero thread id if the event
1503 requires handling by WFI (or whatever). */
1505 get_windows_debug_event (struct target_ops
*ops
,
1506 int pid
, struct target_waitstatus
*ourstatus
)
1509 DWORD continue_status
, event_code
;
1510 windows_thread_info
*th
;
1511 static windows_thread_info dummy_thread_info
;
1512 DWORD thread_id
= 0;
1514 last_sig
= GDB_SIGNAL_0
;
1516 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1520 continue_status
= DBG_CONTINUE
;
1522 event_code
= current_event
.dwDebugEventCode
;
1523 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1525 have_saved_context
= 0;
1529 case CREATE_THREAD_DEBUG_EVENT
:
1530 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1531 (unsigned) current_event
.dwProcessId
,
1532 (unsigned) current_event
.dwThreadId
,
1533 "CREATE_THREAD_DEBUG_EVENT"));
1534 if (saw_create
!= 1)
1536 struct inferior
*inf
;
1537 inf
= find_inferior_pid (current_event
.dwProcessId
);
1538 if (!saw_create
&& inf
->attach_flag
)
1540 /* Kludge around a Windows bug where first event is a create
1541 thread event. Caused when attached process does not have
1543 thread_id
= fake_create_process ();
1549 /* Record the existence of this thread. */
1550 thread_id
= current_event
.dwThreadId
;
1551 th
= windows_add_thread (ptid_t (current_event
.dwProcessId
, 0,
1552 current_event
.dwThreadId
),
1553 current_event
.u
.CreateThread
.hThread
,
1554 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1558 case EXIT_THREAD_DEBUG_EVENT
:
1559 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1560 (unsigned) current_event
.dwProcessId
,
1561 (unsigned) current_event
.dwThreadId
,
1562 "EXIT_THREAD_DEBUG_EVENT"));
1563 windows_delete_thread (ptid_t (current_event
.dwProcessId
, 0,
1564 current_event
.dwThreadId
),
1565 current_event
.u
.ExitThread
.dwExitCode
);
1566 th
= &dummy_thread_info
;
1569 case CREATE_PROCESS_DEBUG_EVENT
:
1570 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1571 (unsigned) current_event
.dwProcessId
,
1572 (unsigned) current_event
.dwThreadId
,
1573 "CREATE_PROCESS_DEBUG_EVENT"));
1574 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1575 if (++saw_create
!= 1)
1578 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1579 main_thread_id
= current_event
.dwThreadId
;
1580 /* Add the main thread. */
1581 th
= windows_add_thread (ptid_t (current_event
.dwProcessId
, 0,
1582 current_event
.dwThreadId
),
1583 current_event
.u
.CreateProcessInfo
.hThread
,
1584 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
);
1585 thread_id
= current_event
.dwThreadId
;
1588 case EXIT_PROCESS_DEBUG_EVENT
:
1589 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1590 (unsigned) current_event
.dwProcessId
,
1591 (unsigned) current_event
.dwThreadId
,
1592 "EXIT_PROCESS_DEBUG_EVENT"));
1593 if (!windows_initialization_done
)
1595 target_terminal::ours ();
1596 target_mourn_inferior (inferior_ptid
);
1597 error (_("During startup program exited with code 0x%x."),
1598 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1600 else if (saw_create
== 1)
1602 windows_delete_thread (ptid_t (current_event
.dwProcessId
, 0,
1605 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1606 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1607 thread_id
= main_thread_id
;
1611 case LOAD_DLL_DEBUG_EVENT
:
1612 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1613 (unsigned) current_event
.dwProcessId
,
1614 (unsigned) current_event
.dwThreadId
,
1615 "LOAD_DLL_DEBUG_EVENT"));
1616 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1617 if (saw_create
!= 1 || ! windows_initialization_done
)
1619 catch_errors (handle_load_dll
);
1620 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1621 ourstatus
->value
.integer
= 0;
1622 thread_id
= main_thread_id
;
1625 case UNLOAD_DLL_DEBUG_EVENT
:
1626 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1627 (unsigned) current_event
.dwProcessId
,
1628 (unsigned) current_event
.dwThreadId
,
1629 "UNLOAD_DLL_DEBUG_EVENT"));
1630 if (saw_create
!= 1 || ! windows_initialization_done
)
1632 catch_errors (handle_unload_dll
);
1633 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1634 ourstatus
->value
.integer
= 0;
1635 thread_id
= main_thread_id
;
1638 case EXCEPTION_DEBUG_EVENT
:
1639 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1640 (unsigned) current_event
.dwProcessId
,
1641 (unsigned) current_event
.dwThreadId
,
1642 "EXCEPTION_DEBUG_EVENT"));
1643 if (saw_create
!= 1)
1645 switch (handle_exception (ourstatus
))
1647 case HANDLE_EXCEPTION_UNHANDLED
:
1649 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1651 case HANDLE_EXCEPTION_HANDLED
:
1652 thread_id
= current_event
.dwThreadId
;
1654 case HANDLE_EXCEPTION_IGNORED
:
1655 continue_status
= DBG_CONTINUE
;
1660 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1661 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1662 (unsigned) current_event
.dwProcessId
,
1663 (unsigned) current_event
.dwThreadId
,
1664 "OUTPUT_DEBUG_STRING_EVENT"));
1665 if (saw_create
!= 1)
1667 thread_id
= handle_output_debug_string (ourstatus
);
1671 if (saw_create
!= 1)
1673 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1674 (unsigned) current_event
.dwProcessId
,
1675 (unsigned) current_event
.dwThreadId
);
1676 printf_unfiltered (" unknown event code %u\n",
1677 (unsigned) current_event
.dwDebugEventCode
);
1681 if (!thread_id
|| saw_create
!= 1)
1683 CHECK (windows_continue (continue_status
, -1, 0));
1687 inferior_ptid
= ptid_t (current_event
.dwProcessId
, 0, thread_id
);
1688 current_thread
= th
;
1689 if (!current_thread
)
1690 current_thread
= thread_rec (thread_id
, TRUE
);
1697 /* Wait for interesting events to occur in the target process. */
1699 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1704 /* We loop when we get a non-standard exception rather than return
1705 with a SPURIOUS because resume can try and step or modify things,
1706 which needs a current_thread->h. But some of these exceptions mark
1707 the birth or death of threads, which mean that the current thread
1708 isn't necessarily what you think it is. */
1714 /* If the user presses Ctrl-c while the debugger is waiting
1715 for an event, he expects the debugger to interrupt his program
1716 and to get the prompt back. There are two possible situations:
1718 - The debugger and the program do not share the console, in
1719 which case the Ctrl-c event only reached the debugger.
1720 In that case, the ctrl_c handler will take care of interrupting
1721 the inferior. Note that this case is working starting with
1722 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1725 - The debugger and the program share the same console, in which
1726 case both debugger and inferior will receive the Ctrl-c event.
1727 In that case the ctrl_c handler will ignore the event, as the
1728 Ctrl-c event generated inside the inferior will trigger the
1729 expected debug event.
1731 FIXME: brobecker/2008-05-20: If the inferior receives the
1732 signal first and the delay until GDB receives that signal
1733 is sufficiently long, GDB can sometimes receive the SIGINT
1734 after we have unblocked the CTRL+C handler. This would
1735 lead to the debugger stopping prematurely while handling
1736 the new-thread event that comes with the handling of the SIGINT
1737 inside the inferior, and then stop again immediately when
1738 the user tries to resume the execution in the inferior.
1739 This is a classic race that we should try to fix one day. */
1740 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1741 retval
= get_windows_debug_event (this, pid
, ourstatus
);
1742 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1745 return ptid_t (current_event
.dwProcessId
, 0, retval
);
1750 if (deprecated_ui_loop_hook
!= NULL
)
1751 detach
= deprecated_ui_loop_hook (0);
1759 /* Iterate over all DLLs currently mapped by our inferior, and
1760 add them to our list of solibs. */
1763 windows_add_all_dlls (void)
1765 HMODULE dummy_hmodule
;
1770 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
1771 sizeof (HMODULE
), &cb_needed
) == 0)
1777 hmodules
= (HMODULE
*) alloca (cb_needed
);
1778 if (EnumProcessModules (current_process_handle
, hmodules
,
1779 cb_needed
, &cb_needed
) == 0)
1782 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
1786 wchar_t dll_name
[__PMAX
];
1789 char dll_name
[__PMAX
];
1792 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
1793 &mi
, sizeof (mi
)) == 0)
1795 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
1796 dll_name
, sizeof (dll_name
)) == 0)
1799 wcstombs (name
, dll_name
, __PMAX
);
1804 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
1805 solib_end
= solib_end
->next
;
1810 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1813 struct inferior
*inf
;
1815 last_sig
= GDB_SIGNAL_0
;
1817 exception_count
= 0;
1818 open_process_used
= 0;
1819 debug_registers_changed
= 0;
1820 debug_registers_used
= 0;
1821 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1824 cygwin_load_start
= cygwin_load_end
= 0;
1826 current_event
.dwProcessId
= pid
;
1827 memset (¤t_event
, 0, sizeof (current_event
));
1828 if (!target_is_pushed (ops
))
1830 disable_breakpoints_in_shlibs ();
1831 windows_clear_solib ();
1832 clear_proceed_status (0);
1833 init_wait_for_inferior ();
1835 inf
= current_inferior ();
1836 inferior_appeared (inf
, pid
);
1837 inf
->attach_flag
= attaching
;
1839 /* Make the new process the current inferior, so terminal handling
1840 can rely on it. When attaching, we don't know about any thread
1841 id here, but that's OK --- nothing should be referencing the
1842 current thread until we report an event out of windows_wait. */
1843 inferior_ptid
= ptid_t (pid
);
1845 target_terminal::init ();
1846 target_terminal::inferior ();
1848 windows_initialization_done
= 0;
1852 struct target_waitstatus status
;
1854 ops
->wait (minus_one_ptid
, &status
, 0);
1856 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
1858 if (status
.kind
!= TARGET_WAITKIND_LOADED
1859 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
1862 ops
->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
1865 /* Now that the inferior has been started and all DLLs have been mapped,
1866 we can iterate over all DLLs and load them in.
1868 We avoid doing it any earlier because, on certain versions of Windows,
1869 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
1870 we have seen on Windows 8.1 that the ntdll.dll load event does not
1871 include the DLL name, preventing us from creating an associated SO.
1872 A possible explanation is that ntdll.dll might be mapped before
1873 the SO info gets created by the Windows system -- ntdll.dll is
1874 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
1875 do not seem to suffer from that problem.
1877 Rather than try to work around this sort of issue, it is much
1878 simpler to just ignore DLL load/unload events during the startup
1879 phase, and then process them all in one batch now. */
1880 windows_add_all_dlls ();
1882 windows_initialization_done
= 1;
1886 /* Try to set or remove a user privilege to the current process. Return -1
1887 if that fails, the previous setting of that privilege otherwise.
1889 This code is copied from the Cygwin source code and rearranged to allow
1890 dynamically loading of the needed symbols from advapi32 which is only
1891 available on NT/2K/XP. */
1893 set_process_privilege (const char *privilege
, BOOL enable
)
1895 HANDLE token_hdl
= NULL
;
1897 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1901 if (!OpenProcessToken (GetCurrentProcess (),
1902 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1906 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
1909 new_priv
.PrivilegeCount
= 1;
1910 new_priv
.Privileges
[0].Luid
= restore_priv
;
1911 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1913 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1914 sizeof orig_priv
, &orig_priv
, &size
))
1917 /* Disabled, otherwise every `attach' in an unprivileged user session
1918 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1919 windows_attach(). */
1920 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1921 be enabled. GetLastError () returns an correct error code, though. */
1922 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1926 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1930 CloseHandle (token_hdl
);
1935 /* Attach to process PID, then initialize for debugging it. */
1938 windows_nat_target::attach (const char *args
, int from_tty
)
1943 pid
= parse_pid_to_attach (args
);
1945 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1947 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1948 printf_unfiltered ("This can cause attach to "
1949 "fail on Windows NT/2K/XP\n");
1952 windows_init_thread_list ();
1953 ok
= DebugActiveProcess (pid
);
1959 /* Try fall back to Cygwin pid. */
1960 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1963 ok
= DebugActiveProcess (pid
);
1968 error (_("Can't attach to process."));
1970 DebugSetProcessKillOnExit (FALSE
);
1974 char *exec_file
= (char *) get_exec_file (0);
1977 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1978 target_pid_to_str (ptid_t (pid
)));
1980 printf_unfiltered ("Attaching to %s\n",
1981 target_pid_to_str (ptid_t (pid
)));
1983 gdb_flush (gdb_stdout
);
1986 do_initial_windows_stuff (this, pid
, 1);
1987 target_terminal::ours ();
1991 windows_nat_target::detach (inferior
*inf
, int from_tty
)
1995 ptid_t ptid
= minus_one_ptid
;
1996 resume (ptid
, 0, GDB_SIGNAL_0
);
1998 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
2000 error (_("Can't detach process %u (error %u)"),
2001 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
2004 DebugSetProcessKillOnExit (FALSE
);
2006 if (detached
&& from_tty
)
2008 const char *exec_file
= get_exec_file (0);
2011 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
2012 (unsigned) current_event
.dwProcessId
);
2013 gdb_flush (gdb_stdout
);
2016 x86_cleanup_dregs ();
2017 inferior_ptid
= null_ptid
;
2018 detach_inferior (inf
);
2020 maybe_unpush_target ();
2023 /* Try to determine the executable filename.
2025 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2027 Upon success, the filename is stored inside EXE_NAME_RET, and
2028 this function returns nonzero.
2030 Otherwise, this function returns zero and the contents of
2031 EXE_NAME_RET is undefined. */
2034 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2041 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2042 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2045 /* We know the executable is always first in the list of modules,
2046 which we just fetched. So no need to fetch more. */
2050 /* Cygwin prefers that the path be in /x/y/z format, so extract
2051 the filename into a temporary buffer first, and then convert it
2052 to POSIX format into the destination buffer. */
2053 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2055 len
= GetModuleFileNameEx (current_process_handle
,
2056 dh_buf
, pathbuf
, exe_name_max_len
);
2058 error (_("Error getting executable filename: %u."),
2059 (unsigned) GetLastError ());
2060 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2061 exe_name_max_len
) < 0)
2062 error (_("Error converting executable filename to POSIX: %d."), errno
);
2065 len
= GetModuleFileNameEx (current_process_handle
,
2066 dh_buf
, exe_name_ret
, exe_name_max_len
);
2068 error (_("Error getting executable filename: %u."),
2069 (unsigned) GetLastError ());
2072 return 1; /* success */
2075 /* The pid_to_exec_file target_ops method for this platform. */
2078 windows_nat_target::pid_to_exec_file (int pid
)
2080 static char path
[__PMAX
];
2082 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2084 char procexe
[sizeof ("/proc/4294967295/exe")];
2086 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2087 nchars
= readlink (procexe
, path
, sizeof(path
));
2088 if (nchars
> 0 && nchars
< sizeof (path
))
2090 path
[nchars
] = '\0'; /* Got it */
2095 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2096 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2097 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2103 /* Print status information about what we're accessing. */
2106 windows_nat_target::files_info ()
2108 struct inferior
*inf
= current_inferior ();
2110 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2111 inf
->attach_flag
? "attached" : "child",
2112 target_pid_to_str (inferior_ptid
));
2115 /* Modify CreateProcess parameters for use of a new separate console.
2117 *FLAGS: DWORD parameter for general process creation flags.
2118 *SI: STARTUPINFO structure, for which the console window size and
2119 console buffer size is filled in if GDB is running in a console.
2120 to create the new console.
2121 The size of the used font is not available on all versions of
2122 Windows OS. Furthermore, the current font might not be the default
2123 font, but this is still better than before.
2124 If the windows and buffer sizes are computed,
2125 SI->DWFLAGS is changed so that this information is used
2126 by CreateProcess function. */
2129 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2131 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2132 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2134 if (hconsole
!= INVALID_HANDLE_VALUE
)
2136 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2138 CONSOLE_FONT_INFO cfi
;
2140 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2141 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2142 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2143 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2144 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2146 si
->dwXSize
*= font_size
.X
;
2150 si
->dwYSize
*= font_size
.Y
;
2153 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2154 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2155 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2157 *flags
|= CREATE_NEW_CONSOLE
;
2161 /* Function called by qsort to sort environment strings. */
2164 envvar_cmp (const void *a
, const void *b
)
2166 const char **p
= (const char **) a
;
2167 const char **q
= (const char **) b
;
2168 return strcasecmp (*p
, *q
);
2174 clear_win32_environment (char **env
)
2178 wchar_t *copy
= NULL
, *equalpos
;
2180 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2182 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2183 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2184 mbstowcs (copy
, env
[i
], len
);
2185 equalpos
= wcschr (copy
, L
'=');
2188 SetEnvironmentVariableW (copy
, NULL
);
2196 /* Redirection of inferior I/O streams for native MS-Windows programs.
2197 Unlike on Unix, where this is handled by invoking the inferior via
2198 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2200 The official documentation of the cmd.exe redirection features is here:
2202 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2204 (That page talks about Windows XP, but there's no newer
2205 documentation, so we assume later versions of cmd.exe didn't change
2208 Caveat: the documentation on that page seems to include a few lies.
2209 For example, it describes strange constructs 1<&2 and 2<&1, which
2210 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2211 think the cmd.exe parser of the redirection symbols simply doesn't
2212 care about the < vs > distinction in these cases. Therefore, the
2213 supported features are explicitly documented below.
2215 The emulation below aims at supporting all the valid use cases
2216 supported by cmd.exe, which include:
2218 < FILE redirect standard input from FILE
2219 0< FILE redirect standard input from FILE
2220 <&N redirect standard input from file descriptor N
2221 0<&N redirect standard input from file descriptor N
2222 > FILE redirect standard output to FILE
2223 >> FILE append standard output to FILE
2224 1>> FILE append standard output to FILE
2225 >&N redirect standard output to file descriptor N
2226 1>&N redirect standard output to file descriptor N
2227 >>&N append standard output to file descriptor N
2228 1>>&N append standard output to file descriptor N
2229 2> FILE redirect standard error to FILE
2230 2>> FILE append standard error to FILE
2231 2>&N redirect standard error to file descriptor N
2232 2>>&N append standard error to file descriptor N
2234 Note that using N > 2 in the above construct is supported, but
2235 requires that the corresponding file descriptor be open by some
2236 means elsewhere or outside GDB. Also note that using ">&0" or
2237 "<&2" will generally fail, because the file descriptor redirected
2238 from is normally open in an incompatible mode (e.g., FD 0 is open
2239 for reading only). IOW, use of such tricks is not recommended;
2240 you are on your own.
2242 We do NOT support redirection of file descriptors above 2, as in
2243 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2244 that needs special handling in the startup code that MinGW
2245 doesn't have). Pipes are also not supported.
2247 As for invalid use cases, where the redirection contains some
2248 error, the emulation below will detect that and produce some
2249 error and/or failure. But the behavior in those cases is not
2250 bug-for-bug compatible with what cmd.exe does in those cases.
2251 That's because what cmd.exe does then is not well defined, and
2252 seems to be a side effect of the cmd.exe parsing of the command
2253 line more than anything else. For example, try redirecting to an
2254 invalid file name, as in "> foo:bar".
2256 There are also minor syntactic deviations from what cmd.exe does
2257 in some corner cases. For example, it doesn't support the likes
2258 of "> &foo" to mean redirect to file named literally "&foo"; we
2259 do support that here, because that, too, sounds like some issue
2260 with the cmd.exe parser. Another nicety is that we support
2261 redirection targets that use file names with forward slashes,
2262 something cmd.exe doesn't -- this comes in handy since GDB
2263 file-name completion can be used when typing the command line for
2266 /* Support routines for redirecting standard handles of the inferior. */
2268 /* Parse a single redirection spec, open/duplicate the specified
2269 file/fd, and assign the appropriate value to one of the 3 standard
2270 file descriptors. */
2272 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2274 int *fd
, ref_fd
= -2;
2276 const char *fname
= redir_string
+ 1;
2277 int rc
= *redir_string
;
2292 fd
= (rc
== '2') ? err
: out
;
2293 mode
= O_WRONLY
| O_CREAT
;
2306 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2308 /* A reference to a file descriptor. */
2310 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2311 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2313 /* Don't allow redirection when open modes are incompatible. */
2314 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2315 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2322 else if (ref_fd
== 1)
2324 else if (ref_fd
== 2)
2334 fname
++; /* skip the separator space */
2335 /* If the descriptor is already open, close it. This allows
2336 multiple specs of redirections for the same stream, which is
2337 somewhat nonsensical, but still valid and supported by cmd.exe.
2338 (But cmd.exe only opens a single file in this case, the one
2339 specified by the last redirection spec on the command line.) */
2344 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2348 else if (ref_fd
== -1)
2349 *fd
= -1; /* reset to default destination */
2352 *fd
= _dup (ref_fd
);
2356 /* _open just sets a flag for O_APPEND, which won't be passed to the
2357 inferior, so we need to actually move the file pointer. */
2358 if ((mode
& O_APPEND
) != 0)
2359 _lseek (*fd
, 0L, SEEK_END
);
2363 /* Canonicalize a single redirection spec and set up the corresponding
2364 file descriptor as specified. */
2366 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2368 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2370 const char *start
= s
;
2373 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2374 if ((*start
== '>' || *start
== '1' || *start
== '2')
2378 if (*s
== '>' && *start
!= '>')
2381 else if (*start
== '0' && *s
== '<')
2383 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2386 while (isspace (*s
)) /* skip whitespace before file name */
2388 *d
++ = ' '; /* separate file name with a single space */
2391 /* Copy the file name. */
2394 /* Remove quoting characters from the file name in buf[]. */
2395 if (*s
== '"') /* could support '..' quoting here */
2399 else if (*s
== quote
)
2407 else if (*s
== '\\')
2409 if (s
[1] == '"') /* could support '..' here */
2413 else if (isspace (*s
) && !quote
)
2417 if (d
- buf
>= sizeof (buf
) - 1)
2419 errno
= ENAMETOOLONG
;
2425 /* Windows doesn't allow redirection characters in file names, so we
2426 can bail out early if they use them, or if there's no target file
2427 name after the redirection symbol. */
2428 if (d
[-1] == '>' || d
[-1] == '<')
2433 if (redir_open (buf
, inp
, out
, err
) == 0)
2438 /* Parse the command line for redirection specs and prepare the file
2439 descriptors for the 3 standard streams accordingly. */
2441 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2442 int *inp
, int *out
, int *err
)
2444 const char *s
= cmd_orig
;
2447 bool retval
= false;
2449 while (isspace (*s
))
2454 if (*s
== '"') /* could also support '..' quoting here */
2458 else if (*s
== quote
)
2461 else if (*s
== '\\')
2463 if (s
[1] == '"') /* escaped quote char */
2468 /* Process a single redirection candidate. */
2469 if (*s
== '<' || *s
== '>'
2470 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2471 || (*s
== '0' && s
[1] == '<'))
2473 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2487 #endif /* !__CYGWIN__ */
2489 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2490 EXEC_FILE is the file to run.
2491 ALLARGS is a string containing the arguments to the program.
2492 ENV is the environment vector to pass. Errors reported with error(). */
2495 windows_nat_target::create_inferior (const char *exec_file
,
2496 const std::string
&origallargs
,
2497 char **in_env
, int from_tty
)
2501 cygwin_buf_t real_path
[__PMAX
];
2502 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2503 cygwin_buf_t infcwd
[__PMAX
];
2505 cygwin_buf_t
*toexec
;
2506 cygwin_buf_t
*cygallargs
;
2508 char **old_env
= NULL
;
2512 int ostdin
, ostdout
, ostderr
;
2513 #else /* !__CYGWIN__ */
2514 char shell
[__PMAX
]; /* Path to shell */
2516 char *args
, *allargs_copy
;
2517 size_t args_len
, allargs_len
;
2518 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2519 HANDLE tty
= INVALID_HANDLE_VALUE
;
2520 bool redirected
= false;
2527 #endif /* !__CYGWIN__ */
2528 const char *allargs
= origallargs
.c_str ();
2529 PROCESS_INFORMATION pi
;
2532 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2535 error (_("No executable specified, use `target exec'."));
2537 const char *inferior_cwd
= get_inferior_cwd ();
2538 std::string expanded_infcwd
;
2539 if (inferior_cwd
!= NULL
)
2541 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
2542 /* Mirror slashes on inferior's cwd. */
2543 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
2545 inferior_cwd
= expanded_infcwd
.c_str ();
2548 memset (&si
, 0, sizeof (si
));
2549 si
.cb
= sizeof (si
);
2552 flags
|= CREATE_NEW_PROCESS_GROUP
;
2555 windows_set_console_info (&si
, &flags
);
2560 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2561 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2562 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2563 error (_("Error starting executable: %d"), errno
);
2566 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2567 if (len
== (size_t) -1)
2568 error (_("Error starting executable: %d"), errno
);
2569 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2570 mbstowcs (cygallargs
, allargs
, len
);
2571 #else /* !__USEWIDE */
2572 cygallargs
= allargs
;
2578 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2579 error (_("Error starting executable via shell: %d"), errno
);
2581 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2582 + mbstowcs (NULL
, allargs
, 0) + 2;
2583 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2584 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2585 #else /* !__USEWIDE */
2586 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2587 + strlen (allargs
) + 2);
2588 cygallargs
= (char *) alloca (len
);
2589 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2590 #endif /* __USEWIDE */
2592 flags
|= DEBUG_PROCESS
;
2595 if (inferior_cwd
!= NULL
2596 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
2597 infcwd
, strlen (inferior_cwd
)) < 0)
2598 error (_("Error converting inferior cwd: %d"), errno
);
2601 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2602 * sizeof (wchar_t));
2603 wcscpy (args
, toexec
);
2604 wcscat (args
, L
" ");
2605 wcscat (args
, cygallargs
);
2606 #else /* !__USEWIDE */
2607 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2608 strcpy (args
, toexec
);
2610 strcat (args
, cygallargs
);
2611 #endif /* !__USEWIDE */
2613 #ifdef CW_CVT_ENV_TO_WINENV
2614 /* First try to create a direct Win32 copy of the POSIX environment. */
2615 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2616 if (w32_env
!= (PWCHAR
) -1)
2617 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2619 /* If that fails, fall back to old method tweaking GDB's environment. */
2620 #endif /* CW_CVT_ENV_TO_WINENV */
2622 /* Reset all Win32 environment variables to avoid leftover on next run. */
2623 clear_win32_environment (environ
);
2624 /* Prepare the environment vars for CreateProcess. */
2627 cygwin_internal (CW_SYNC_WINENV
);
2631 if (!inferior_io_terminal
)
2632 tty
= ostdin
= ostdout
= ostderr
= -1;
2635 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2638 print_sys_errmsg (inferior_io_terminal
, errno
);
2639 ostdin
= ostdout
= ostderr
= -1;
2652 windows_init_thread_list ();
2653 ret
= CreateProcess (0,
2654 args
, /* command line */
2655 NULL
, /* Security */
2657 TRUE
, /* inherit handles */
2658 flags
, /* start flags */
2659 w32_env
, /* environment */
2660 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
2665 /* Just free the Win32 environment, if it could be created. */
2669 /* Reset all environment variables to avoid leftover on next run. */
2670 clear_win32_environment (in_env
);
2671 /* Restore normal GDB environment variables. */
2673 cygwin_internal (CW_SYNC_WINENV
);
2686 #else /* !__CYGWIN__ */
2687 allargs_len
= strlen (allargs
);
2688 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
2689 if (strpbrk (allargs_copy
, "<>") != NULL
)
2694 redirect_inferior_handles (allargs
, allargs_copy
,
2695 &fd_inp
, &fd_out
, &fd_err
);
2697 warning (_("Error in redirection: %s."), strerror (errno
));
2700 allargs_len
= strlen (allargs_copy
);
2702 /* If not all the standard streams are redirected by the command
2703 line, use inferior_io_terminal for those which aren't. */
2704 if (inferior_io_terminal
2705 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
2707 SECURITY_ATTRIBUTES sa
;
2708 sa
.nLength
= sizeof(sa
);
2709 sa
.lpSecurityDescriptor
= 0;
2710 sa
.bInheritHandle
= TRUE
;
2711 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2712 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2713 if (tty
== INVALID_HANDLE_VALUE
)
2714 warning (_("Warning: Failed to open TTY %s, error %#x."),
2715 inferior_io_terminal
, (unsigned) GetLastError ());
2717 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
2720 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
2721 else if (tty
!= INVALID_HANDLE_VALUE
)
2724 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
2726 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
2727 else if (tty
!= INVALID_HANDLE_VALUE
)
2728 si
.hStdOutput
= tty
;
2730 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
2732 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
2733 else if (tty
!= INVALID_HANDLE_VALUE
)
2736 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
2737 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2741 /* Build the command line, a space-separated list of tokens where
2742 the first token is the name of the module to be executed.
2743 To avoid ambiguities introduced by spaces in the module name,
2745 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
2746 args
= (char *) alloca (args_len
);
2747 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
2749 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2751 /* CreateProcess takes the environment list as a null terminated set of
2752 strings (i.e. two nulls terminate the list). */
2754 /* Get total size for env strings. */
2755 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2756 envlen
+= strlen (in_env
[i
]) + 1;
2758 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2759 env
= (char **) alloca (envsize
);
2760 memcpy (env
, in_env
, envsize
);
2761 /* Windows programs expect the environment block to be sorted. */
2762 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2764 w32env
= (char *) alloca (envlen
+ 1);
2766 /* Copy env strings into new buffer. */
2767 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2769 strcpy (temp
, env
[i
]);
2770 temp
+= strlen (temp
) + 1;
2773 /* Final nil string to terminate new env. */
2776 windows_init_thread_list ();
2777 ret
= CreateProcessA (0,
2778 args
, /* command line */
2779 NULL
, /* Security */
2781 TRUE
, /* inherit handles */
2782 flags
, /* start flags */
2783 w32env
, /* environment */
2784 inferior_cwd
, /* current directory */
2787 if (tty
!= INVALID_HANDLE_VALUE
)
2795 #endif /* !__CYGWIN__ */
2798 error (_("Error creating process %s, (error %u)."),
2799 exec_file
, (unsigned) GetLastError ());
2801 CloseHandle (pi
.hThread
);
2802 CloseHandle (pi
.hProcess
);
2804 if (useshell
&& shell
[0] != '\0')
2809 do_initial_windows_stuff (this, pi
.dwProcessId
, 0);
2811 /* windows_continue (DBG_CONTINUE, -1, 0); */
2815 windows_nat_target::mourn_inferior ()
2817 (void) windows_continue (DBG_CONTINUE
, -1, 0);
2818 x86_cleanup_dregs();
2819 if (open_process_used
)
2821 CHECK (CloseHandle (current_process_handle
));
2822 open_process_used
= 0;
2824 inf_child_target::mourn_inferior ();
2827 /* Send a SIGINT to the process group. This acts just like the user typed a
2828 ^C on the controlling terminal. */
2831 windows_nat_target::interrupt ()
2833 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2834 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
2835 registers_changed (); /* refresh register state */
2838 /* Helper for windows_xfer_partial that handles memory transfers.
2839 Arguments are like target_xfer_partial. */
2841 static enum target_xfer_status
2842 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2843 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2847 DWORD lasterror
= 0;
2849 if (writebuf
!= NULL
)
2851 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
2852 pulongest (len
), core_addr_to_string (memaddr
)));
2853 success
= WriteProcessMemory (current_process_handle
,
2854 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
2857 lasterror
= GetLastError ();
2858 FlushInstructionCache (current_process_handle
,
2859 (LPCVOID
) (uintptr_t) memaddr
, len
);
2863 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
2864 pulongest (len
), core_addr_to_string (memaddr
)));
2865 success
= ReadProcessMemory (current_process_handle
,
2866 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
2869 lasterror
= GetLastError ();
2871 *xfered_len
= (ULONGEST
) done
;
2872 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
2873 return TARGET_XFER_OK
;
2875 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
2879 windows_nat_target::kill ()
2881 CHECK (TerminateProcess (current_process_handle
, 0));
2885 if (!windows_continue (DBG_CONTINUE
, -1, 1))
2887 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
2889 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2893 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
2897 windows_nat_target::close ()
2899 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2900 inferior_ptid
.pid ()));
2903 /* Convert pid to printable format. */
2905 windows_nat_target::pid_to_str (ptid_t ptid
)
2907 static char buf
[80];
2909 if (ptid
.tid () != 0)
2911 snprintf (buf
, sizeof (buf
), "Thread %d.0x%lx",
2912 ptid
.pid (), ptid
.tid ());
2916 return normal_pid_to_str (ptid
);
2919 static enum target_xfer_status
2920 windows_xfer_shared_libraries (struct target_ops
*ops
,
2921 enum target_object object
, const char *annex
,
2922 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2923 ULONGEST offset
, ULONGEST len
,
2924 ULONGEST
*xfered_len
)
2926 struct obstack obstack
;
2932 return TARGET_XFER_E_IO
;
2934 obstack_init (&obstack
);
2935 obstack_grow_str (&obstack
, "<library-list>\n");
2936 for (so
= solib_start
.next
; so
; so
= so
->next
)
2938 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
2940 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
2941 (uintptr_t) li
->load_addr
,
2942 target_gdbarch (), &obstack
);
2944 obstack_grow_str0 (&obstack
, "</library-list>\n");
2946 buf
= (const char *) obstack_finish (&obstack
);
2947 len_avail
= strlen (buf
);
2948 if (offset
>= len_avail
)
2952 if (len
> len_avail
- offset
)
2953 len
= len_avail
- offset
;
2954 memcpy (readbuf
, buf
+ offset
, len
);
2957 obstack_free (&obstack
, NULL
);
2958 *xfered_len
= (ULONGEST
) len
;
2959 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
2962 enum target_xfer_status
2963 windows_nat_target::xfer_partial (enum target_object object
,
2964 const char *annex
, gdb_byte
*readbuf
,
2965 const gdb_byte
*writebuf
, ULONGEST offset
,
2966 ULONGEST len
, ULONGEST
*xfered_len
)
2970 case TARGET_OBJECT_MEMORY
:
2971 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
2973 case TARGET_OBJECT_LIBRARIES
:
2974 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
2975 writebuf
, offset
, len
, xfered_len
);
2978 if (beneath () == NULL
)
2980 /* This can happen when requesting the transfer of unsupported
2981 objects before a program has been started (and therefore
2982 with the current_target having no target beneath). */
2983 return TARGET_XFER_E_IO
;
2985 return beneath ()->xfer_partial (object
, annex
,
2986 readbuf
, writebuf
, offset
, len
,
2991 /* Provide thread local base, i.e. Thread Information Block address.
2992 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
2995 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
2997 windows_thread_info
*th
;
2999 th
= thread_rec (ptid
.tid (), 0);
3004 *addr
= th
->thread_local_base
;
3010 windows_nat_target::get_ada_task_ptid (long lwp
, long thread
)
3012 return ptid_t (inferior_ptid
.pid (), 0, lwp
);
3015 /* Implementation of the to_thread_name method. */
3018 windows_nat_target::thread_name (struct thread_info
*thr
)
3020 return thread_rec (thr
->ptid
.tid (), 0)->name
;
3025 _initialize_windows_nat (void)
3027 x86_dr_low
.set_control
= cygwin_set_dr7
;
3028 x86_dr_low
.set_addr
= cygwin_set_dr
;
3029 x86_dr_low
.get_addr
= cygwin_get_dr
;
3030 x86_dr_low
.get_status
= cygwin_get_dr6
;
3031 x86_dr_low
.get_control
= cygwin_get_dr7
;
3033 /* x86_dr_low.debug_register_length field is set by
3034 calling x86_set_debug_register_length function
3035 in processor windows specific native file. */
3037 add_inf_child_target (&the_windows_nat_target
);
3040 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3043 add_com ("signal-event", class_run
, signal_event_command
, _("\
3044 Signal a crashed process with event ID, to allow its debugging.\n\
3045 This command is needed in support of setting up GDB as JIT debugger on \
3046 MS-Windows. The command should be invoked from the GDB command line using \
3047 the '-ex' command-line option. The ID of the event that blocks the \
3048 crashed process will be supplied by the Windows JIT debugging mechanism."));
3051 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3052 Set use of shell to start subprocess."), _("\
3053 Show use of shell to start subprocess."), NULL
,
3055 NULL
, /* FIXME: i18n: */
3056 &setlist
, &showlist
);
3058 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3059 &cygwin_exceptions
, _("\
3060 Break when an exception is detected in the Cygwin DLL itself."), _("\
3061 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3063 NULL
, /* FIXME: i18n: */
3064 &setlist
, &showlist
);
3067 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3068 Set creation of new console when creating child process."), _("\
3069 Show creation of new console when creating child process."), NULL
,
3071 NULL
, /* FIXME: i18n: */
3072 &setlist
, &showlist
);
3074 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3075 Set creation of new group when creating child process."), _("\
3076 Show creation of new group when creating child process."), NULL
,
3078 NULL
, /* FIXME: i18n: */
3079 &setlist
, &showlist
);
3081 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3082 Set whether to display execution in child process."), _("\
3083 Show whether to display execution in child process."), NULL
,
3085 NULL
, /* FIXME: i18n: */
3086 &setlist
, &showlist
);
3088 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3089 Set whether to display kernel events in child process."), _("\
3090 Show whether to display kernel events in child process."), NULL
,
3092 NULL
, /* FIXME: i18n: */
3093 &setlist
, &showlist
);
3095 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3096 Set whether to display memory accesses in child process."), _("\
3097 Show whether to display memory accesses in child process."), NULL
,
3099 NULL
, /* FIXME: i18n: */
3100 &setlist
, &showlist
);
3102 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3103 &debug_exceptions
, _("\
3104 Set whether to display kernel exceptions in child process."), _("\
3105 Show whether to display kernel exceptions in child process."), NULL
,
3107 NULL
, /* FIXME: i18n: */
3108 &setlist
, &showlist
);
3110 init_w32_command_list ();
3112 add_cmd ("selector", class_info
, display_selectors
,
3113 _("Display selectors infos."),
3117 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3119 /* Pass the address ADDR to the inferior in the I'th debug register.
3120 Here we just store the address in dr array, the registers will be
3121 actually set up when windows_continue is called. */
3123 cygwin_set_dr (int i
, CORE_ADDR addr
)
3126 internal_error (__FILE__
, __LINE__
,
3127 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3129 debug_registers_changed
= 1;
3130 debug_registers_used
= 1;
3133 /* Pass the value VAL to the inferior in the DR7 debug control
3134 register. Here we just store the address in D_REGS, the watchpoint
3135 will be actually set up in windows_wait. */
3137 cygwin_set_dr7 (unsigned long val
)
3139 dr
[7] = (CORE_ADDR
) val
;
3140 debug_registers_changed
= 1;
3141 debug_registers_used
= 1;
3144 /* Get the value of debug register I from the inferior. */
3147 cygwin_get_dr (int i
)
3152 /* Get the value of the DR6 debug status register from the inferior.
3153 Here we just return the value stored in dr[6]
3154 by the last call to thread_rec for current_event.dwThreadId id. */
3155 static unsigned long
3156 cygwin_get_dr6 (void)
3158 return (unsigned long) dr
[6];
3161 /* Get the value of the DR7 debug status register from the inferior.
3162 Here we just return the value stored in dr[7] by the last call to
3163 thread_rec for current_event.dwThreadId id. */
3165 static unsigned long
3166 cygwin_get_dr7 (void)
3168 return (unsigned long) dr
[7];
3171 /* Determine if the thread referenced by "ptid" is alive
3172 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3173 it means that the thread has died. Otherwise it is assumed to be alive. */
3176 windows_nat_target::thread_alive (ptid_t ptid
)
3180 gdb_assert (ptid
.tid () != 0);
3183 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) != WAIT_OBJECT_0
;
3187 _initialize_check_for_gdb_ini (void)
3190 if (inhibit_gdbinit
)
3193 homedir
= getenv ("HOME");
3197 char *oldini
= (char *) alloca (strlen (homedir
) +
3198 sizeof ("gdb.ini") + 1);
3199 strcpy (oldini
, homedir
);
3200 p
= strchr (oldini
, '\0');
3201 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3203 strcpy (p
, "gdb.ini");
3204 if (access (oldini
, 0) == 0)
3206 int len
= strlen (oldini
);
3207 char *newini
= (char *) alloca (len
+ 2);
3209 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3210 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3211 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3216 /* Define dummy functions which always return error for the rare cases where
3217 these functions could not be found. */
3219 bad_DebugActiveProcessStop (DWORD w
)
3224 bad_DebugBreakProcess (HANDLE w
)
3229 bad_DebugSetProcessKillOnExit (BOOL w
)
3234 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3241 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3247 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3254 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3260 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3266 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3272 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3280 /* Load any functions which may not be available in ancient versions
3284 _initialize_loadable (void)
3288 #define GPA(m, func) \
3289 func = (func ## _ftype *) GetProcAddress (m, #func)
3291 hm
= LoadLibrary ("kernel32.dll");
3294 GPA (hm
, DebugActiveProcessStop
);
3295 GPA (hm
, DebugBreakProcess
);
3296 GPA (hm
, DebugSetProcessKillOnExit
);
3297 GPA (hm
, GetConsoleFontSize
);
3298 GPA (hm
, DebugActiveProcessStop
);
3299 GPA (hm
, GetCurrentConsoleFont
);
3302 /* Set variables to dummy versions of these processes if the function
3303 wasn't found in kernel32.dll. */
3304 if (!DebugBreakProcess
)
3305 DebugBreakProcess
= bad_DebugBreakProcess
;
3306 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3308 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3309 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3311 if (!GetConsoleFontSize
)
3312 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3313 if (!GetCurrentConsoleFont
)
3314 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3316 /* Load optional functions used for retrieving filename information
3317 associated with the currently debugged process or its dlls. */
3318 hm
= LoadLibrary ("psapi.dll");
3321 GPA (hm
, EnumProcessModules
);
3322 GPA (hm
, GetModuleInformation
);
3323 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3324 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3327 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3329 /* Set variables to dummy versions of these processes if the function
3330 wasn't found in psapi.dll. */
3331 EnumProcessModules
= bad_EnumProcessModules
;
3332 GetModuleInformation
= bad_GetModuleInformation
;
3333 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3334 /* This will probably fail on Windows 9x/Me. Let the user know
3335 that we're missing some functionality. */
3337 cannot automatically find executable file or library to read symbols.\n\
3338 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3341 hm
= LoadLibrary ("advapi32.dll");
3344 GPA (hm
, OpenProcessToken
);
3345 GPA (hm
, LookupPrivilegeValueA
);
3346 GPA (hm
, AdjustTokenPrivileges
);
3347 /* Only need to set one of these since if OpenProcessToken fails nothing
3349 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3350 || !AdjustTokenPrivileges
)
3351 OpenProcessToken
= bad_OpenProcessToken
;