1 /* Target-vector operations for controlling windows child processes, for GDB.
3 Copyright (C) 1995-2021 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>
41 #include <sys/cygwin.h>
42 #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"
71 #include "gdbsupport/gdb_wait.h"
72 #include "nat/windows-nat.h"
73 #include "gdbsupport/symbol.h"
75 using namespace windows_nat
;
79 #undef GetModuleFileNameEx
82 # define __PMAX (MAX_PATH + 1)
83 # define GetModuleFileNameEx GetModuleFileNameExA
84 # define STARTUPINFO STARTUPINFOA
85 # define CreateProcess CreateProcessA
87 # define __PMAX PATH_MAX
88 /* The starting and ending address of the cygwin1.dll text segment. */
89 static CORE_ADDR cygwin_load_start
;
90 static CORE_ADDR cygwin_load_end
;
92 typedef wchar_t cygwin_buf_t
;
93 # define GetModuleFileNameEx GetModuleFileNameExW
94 # define STARTUPINFO STARTUPINFOW
95 # define CreateProcess CreateProcessW
98 static int have_saved_context
; /* True if we've saved context from a
101 static CONTEXT saved_context
; /* Contains the saved context from a
105 /* If we're not using the old Cygwin header file set, define the
106 following which never should have been in the generic Win32 API
107 headers in the first place since they were our own invention... */
108 #ifndef _GNU_H_WINDOWS_H
111 FLAG_TRACE_BIT
= 0x100,
115 #ifndef CONTEXT_EXTENDED_REGISTERS
116 /* This macro is only defined on ia32. It only makes sense on this target,
117 so define it as zero if not already defined. */
118 #define CONTEXT_EXTENDED_REGISTERS 0
121 #define CONTEXT_DEBUGGER_DR CONTEXT_FULL | CONTEXT_FLOATING_POINT \
122 | CONTEXT_SEGMENTS | CONTEXT_DEBUG_REGISTERS \
123 | CONTEXT_EXTENDED_REGISTERS
125 static uintptr_t dr
[8];
127 static int windows_initialization_done
;
128 #define DR6_CLEAR_VALUE 0xffff0ff0
130 /* The string sent by cygwin when it processes a signal.
131 FIXME: This should be in a cygwin include file. */
132 #ifndef _CYGWIN_SIGNAL_STRING
133 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
136 #define CHECK(x) check (x, __FILE__,__LINE__)
137 #define DEBUG_EXEC(fmt, ...) \
138 debug_prefixed_printf_cond (debug_exec, "windows exec", fmt, ## __VA_ARGS__)
139 #define DEBUG_EVENTS(fmt, ...) \
140 debug_prefixed_printf_cond (debug_events, "windows events", fmt, \
142 #define DEBUG_MEM(fmt, ...) \
143 debug_prefixed_printf_cond (debug_memory, "windows mem", fmt, \
145 #define DEBUG_EXCEPT(fmt, ...) \
146 debug_prefixed_printf_cond (debug_exceptions, "windows except", fmt, \
149 static void cygwin_set_dr (int i
, CORE_ADDR addr
);
150 static void cygwin_set_dr7 (unsigned long val
);
151 static CORE_ADDR
cygwin_get_dr (int i
);
152 static unsigned long cygwin_get_dr6 (void);
153 static unsigned long cygwin_get_dr7 (void);
155 static std::vector
<windows_thread_info
*> thread_list
;
157 /* Counts of things. */
158 static int saw_create
;
159 static int open_process_used
= 0;
161 static void *wow64_dbgbreak
;
165 static bool new_console
= false;
167 static bool cygwin_exceptions
= false;
169 static bool new_group
= true;
170 static bool debug_exec
= false; /* show execution */
171 static bool debug_events
= false; /* show events from kernel */
172 static bool debug_memory
= false; /* show target memory accesses */
173 static bool debug_exceptions
= false; /* show target exceptions */
174 static bool useshell
= false; /* use shell for subprocesses */
176 /* This vector maps GDB's idea of a register's number into an offset
177 in the windows exception context vector.
179 It also contains the bit mask needed to load the register in question.
181 The contents of this table can only be computed by the units
182 that provide CPU-specific support for Windows native debugging.
183 These units should set the table by calling
184 windows_set_context_register_offsets.
186 One day we could read a reg, we could inspect the context we
187 already have loaded, if it doesn't have the bit set that we need,
188 we read that set of registers in using GetThreadContext. If the
189 context already contains what we need, we just unpack it. Then to
190 write a register, first we have to ensure that the context contains
191 the other regs of the group, and then we copy the info in and set
194 static const int *mappings
;
196 /* The function to use in order to determine whether a register is
197 a segment register or not. */
198 static segment_register_p_ftype
*segment_register_p
;
200 /* See windows_nat_target::resume to understand why this is commented
203 /* This vector maps the target's idea of an exception (extracted
204 from the DEBUG_EVENT structure) to GDB's idea. */
206 struct xlate_exception
212 static const struct xlate_exception xlate
[] =
214 {EXCEPTION_ACCESS_VIOLATION
, GDB_SIGNAL_SEGV
},
215 {STATUS_STACK_OVERFLOW
, GDB_SIGNAL_SEGV
},
216 {EXCEPTION_BREAKPOINT
, GDB_SIGNAL_TRAP
},
217 {DBG_CONTROL_C
, GDB_SIGNAL_INT
},
218 {EXCEPTION_SINGLE_STEP
, GDB_SIGNAL_TRAP
},
219 {STATUS_FLOAT_DIVIDE_BY_ZERO
, GDB_SIGNAL_FPE
}
224 struct windows_nat_target final
: public x86_nat_target
<inf_child_target
>
226 void close () override
;
228 void attach (const char *, int) override
;
230 bool attach_no_wait () override
233 void detach (inferior
*, int) override
;
235 void resume (ptid_t
, int , enum gdb_signal
) override
;
237 ptid_t
wait (ptid_t
, struct target_waitstatus
*, target_wait_flags
) override
;
239 void fetch_registers (struct regcache
*, int) override
;
240 void store_registers (struct regcache
*, int) override
;
242 bool stopped_by_sw_breakpoint () override
244 windows_thread_info
*th
245 = thread_rec (inferior_ptid
, DONT_INVALIDATE_CONTEXT
);
246 return th
->stopped_at_software_breakpoint
;
249 bool supports_stopped_by_sw_breakpoint () override
254 enum target_xfer_status
xfer_partial (enum target_object object
,
257 const gdb_byte
*writebuf
,
258 ULONGEST offset
, ULONGEST len
,
259 ULONGEST
*xfered_len
) override
;
261 void files_info () override
;
263 void kill () override
;
265 void create_inferior (const char *, const std::string
&,
266 char **, int) override
;
268 void mourn_inferior () override
;
270 bool thread_alive (ptid_t ptid
) override
;
272 std::string
pid_to_str (ptid_t
) override
;
274 void interrupt () override
;
276 char *pid_to_exec_file (int pid
) override
;
278 ptid_t
get_ada_task_ptid (long lwp
, ULONGEST thread
) override
;
280 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
282 const char *thread_name (struct thread_info
*) override
;
284 int get_windows_debug_event (int pid
, struct target_waitstatus
*ourstatus
);
286 void do_initial_windows_stuff (DWORD pid
, bool attaching
);
289 static windows_nat_target the_windows_nat_target
;
291 /* Set the MAPPINGS static global to OFFSETS.
292 See the description of MAPPINGS for more details. */
295 windows_set_context_register_offsets (const int *offsets
)
300 /* Set the function that should be used by this module to determine
301 whether a given register is a segment register or not. */
304 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
306 segment_register_p
= fun
;
310 check (BOOL ok
, const char *file
, int line
)
313 printf_filtered ("error return %s:%d was %u\n", file
, line
,
314 (unsigned) GetLastError ());
317 /* See nat/windows-nat.h. */
319 windows_thread_info
*
320 windows_nat::thread_rec (ptid_t ptid
, thread_disposition_type disposition
)
322 for (windows_thread_info
*th
: thread_list
)
323 if (th
->tid
== ptid
.lwp ())
329 case DONT_INVALIDATE_CONTEXT
:
332 case INVALIDATE_CONTEXT
:
333 if (ptid
.lwp () != current_event
.dwThreadId
)
335 th
->reload_context
= true;
338 th
->reload_context
= true;
349 /* Add a thread to the thread list.
351 PTID is the ptid of the thread to be added.
352 H is its Windows handle.
353 TLB is its thread local base.
354 MAIN_THREAD_P should be true if the thread to be added is
355 the main thread, false otherwise. */
357 static windows_thread_info
*
358 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
, bool main_thread_p
)
360 windows_thread_info
*th
;
362 gdb_assert (ptid
.lwp () != 0);
364 if ((th
= thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
)))
367 CORE_ADDR base
= (CORE_ADDR
) (uintptr_t) tlb
;
369 /* For WOW64 processes, this is actually the pointer to the 64bit TIB,
370 and the 32bit TIB is exactly 2 pages after it. */
374 th
= new windows_thread_info (ptid
.lwp (), h
, base
);
375 thread_list
.push_back (th
);
377 /* Add this new thread to the list of threads.
379 To be consistent with what's done on other platforms, we add
380 the main thread silently (in reality, this thread is really
381 more of a process to the user than a thread). */
383 add_thread_silent (&the_windows_nat_target
, ptid
);
385 add_thread (&the_windows_nat_target
, ptid
);
387 /* It's simplest to always set this and update the debug
389 th
->debug_registers_changed
= true;
394 /* Clear out any old thread list and reinitialize it to a
397 windows_init_thread_list (void)
399 DEBUG_EVENTS ("called");
402 for (windows_thread_info
*here
: thread_list
)
405 thread_list
.clear ();
408 /* Delete a thread from the list of threads.
410 PTID is the ptid of the thread to be deleted.
411 EXIT_CODE is the thread's exit code.
412 MAIN_THREAD_P should be true if the thread to be deleted is
413 the main thread, false otherwise. */
416 windows_delete_thread (ptid_t ptid
, DWORD exit_code
, bool main_thread_p
)
420 gdb_assert (ptid
.lwp () != 0);
424 /* Emit a notification about the thread being deleted.
426 Note that no notification was printed when the main thread
427 was created, and thus, unless in verbose mode, we should be
428 symmetrical, and avoid that notification for the main thread
432 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
).c_str ());
433 else if (print_thread_events
&& !main_thread_p
)
434 printf_unfiltered (_("[%s exited with code %u]\n"),
435 target_pid_to_str (ptid
).c_str (),
436 (unsigned) exit_code
);
438 delete_thread (find_thread_ptid (&the_windows_nat_target
, ptid
));
440 auto iter
= std::find_if (thread_list
.begin (), thread_list
.end (),
441 [=] (windows_thread_info
*th
)
443 return th
->tid
== id
;
446 if (iter
!= thread_list
.end ())
449 thread_list
.erase (iter
);
453 /* Fetches register number R from the given windows_thread_info,
454 and supplies its value to the given regcache.
456 This function assumes that R is non-negative. A failed assertion
457 is raised if that is not true.
459 This function assumes that TH->RELOAD_CONTEXT is not set, meaning
460 that the windows_thread_info has an up-to-date context. A failed
461 assertion is raised if that assumption is violated. */
464 windows_fetch_one_register (struct regcache
*regcache
,
465 windows_thread_info
*th
, int r
)
468 gdb_assert (!th
->reload_context
);
470 char *context_ptr
= (char *) &th
->context
;
473 context_ptr
= (char *) &th
->wow64_context
;
476 char *context_offset
= context_ptr
+ mappings
[r
];
477 struct gdbarch
*gdbarch
= regcache
->arch ();
478 i386_gdbarch_tdep
*tdep
= (i386_gdbarch_tdep
*) gdbarch_tdep (gdbarch
);
480 gdb_assert (!gdbarch_read_pc_p (gdbarch
));
481 gdb_assert (gdbarch_pc_regnum (gdbarch
) >= 0);
482 gdb_assert (!gdbarch_write_pc_p (gdbarch
));
484 if (r
== I387_FISEG_REGNUM (tdep
))
486 long l
= *((long *) context_offset
) & 0xffff;
487 regcache
->raw_supply (r
, (char *) &l
);
489 else if (r
== I387_FOP_REGNUM (tdep
))
491 long l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
492 regcache
->raw_supply (r
, (char *) &l
);
494 else if (segment_register_p (r
))
496 /* GDB treats segment registers as 32bit registers, but they are
497 in fact only 16 bits long. Make sure we do not read extra
498 bits from our source buffer. */
499 long l
= *((long *) context_offset
) & 0xffff;
500 regcache
->raw_supply (r
, (char *) &l
);
504 if (th
->stopped_at_software_breakpoint
506 && r
== gdbarch_pc_regnum (gdbarch
))
508 int size
= register_size (gdbarch
, r
);
512 memcpy (&value
, context_offset
, size
);
513 value
-= gdbarch_decr_pc_after_break (gdbarch
);
514 memcpy (context_offset
, &value
, size
);
518 gdb_assert (size
== 8);
520 memcpy (&value
, context_offset
, size
);
521 value
-= gdbarch_decr_pc_after_break (gdbarch
);
522 memcpy (context_offset
, &value
, size
);
524 /* Make sure we only rewrite the PC a single time. */
525 th
->pc_adjusted
= true;
527 regcache
->raw_supply (r
, context_offset
);
532 windows_nat_target::fetch_registers (struct regcache
*regcache
, int r
)
534 windows_thread_info
*th
= thread_rec (regcache
->ptid (), INVALIDATE_CONTEXT
);
536 /* Check if TH exists. Windows sometimes uses a non-existent
537 thread id in its events. */
541 if (th
->reload_context
)
544 if (have_saved_context
)
546 /* Lie about where the program actually is stopped since
547 cygwin has informed us that we should consider the signal
548 to have occurred at another location which is stored in
550 memcpy (&th
->context
, &saved_context
,
551 __COPY_CONTEXT_SIZE
);
552 have_saved_context
= 0;
559 th
->wow64_context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
560 CHECK (Wow64GetThreadContext (th
->h
, &th
->wow64_context
));
561 /* Copy dr values from that thread.
562 But only if there were not modified since last stop.
564 if (!th
->debug_registers_changed
)
566 dr
[0] = th
->wow64_context
.Dr0
;
567 dr
[1] = th
->wow64_context
.Dr1
;
568 dr
[2] = th
->wow64_context
.Dr2
;
569 dr
[3] = th
->wow64_context
.Dr3
;
570 dr
[6] = th
->wow64_context
.Dr6
;
571 dr
[7] = th
->wow64_context
.Dr7
;
577 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
578 CHECK (GetThreadContext (th
->h
, &th
->context
));
579 /* Copy dr values from that thread.
580 But only if there were not modified since last stop.
582 if (!th
->debug_registers_changed
)
584 dr
[0] = th
->context
.Dr0
;
585 dr
[1] = th
->context
.Dr1
;
586 dr
[2] = th
->context
.Dr2
;
587 dr
[3] = th
->context
.Dr3
;
588 dr
[6] = th
->context
.Dr6
;
589 dr
[7] = th
->context
.Dr7
;
592 th
->reload_context
= false;
596 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch()); r
++)
597 windows_fetch_one_register (regcache
, th
, r
);
599 windows_fetch_one_register (regcache
, th
, r
);
602 /* Collect the register number R from the given regcache, and store
603 its value into the corresponding area of the given thread's context.
605 This function assumes that R is non-negative. A failed assertion
606 assertion is raised if that is not true. */
609 windows_store_one_register (const struct regcache
*regcache
,
610 windows_thread_info
*th
, int r
)
614 char *context_ptr
= (char *) &th
->context
;
617 context_ptr
= (char *) &th
->wow64_context
;
620 regcache
->raw_collect (r
, context_ptr
+ mappings
[r
]);
623 /* Store a new register value into the context of the thread tied to
627 windows_nat_target::store_registers (struct regcache
*regcache
, int r
)
629 windows_thread_info
*th
= thread_rec (regcache
->ptid (), INVALIDATE_CONTEXT
);
631 /* Check if TH exists. Windows sometimes uses a non-existent
632 thread id in its events. */
637 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch ()); r
++)
638 windows_store_one_register (regcache
, th
, r
);
640 windows_store_one_register (regcache
, th
, r
);
643 /* Maintain a linked list of "so" information. */
644 struct lm_info_windows
: public lm_info_base
646 LPVOID load_addr
= 0;
647 CORE_ADDR text_offset
= 0;
650 static struct so_list solib_start
, *solib_end
;
652 static struct so_list
*
653 windows_make_so (const char *name
, LPVOID load_addr
)
660 WIN32_FIND_DATA w32_fd
;
661 HANDLE h
= FindFirstFile(name
, &w32_fd
);
663 if (h
== INVALID_HANDLE_VALUE
)
669 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
671 p
= strrchr (buf
, '\\');
674 SetCurrentDirectory (buf
);
675 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
676 SetCurrentDirectory (cwd
);
679 if (strcasecmp (buf
, "ntdll.dll") == 0)
681 GetSystemDirectory (buf
, sizeof (buf
));
682 strcat (buf
, "\\ntdll.dll");
685 cygwin_buf_t buf
[__PMAX
];
688 if (access (name
, F_OK
) != 0)
690 if (strcasecmp (name
, "ntdll.dll") == 0)
693 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
694 wcscat (buf
, L
"\\ntdll.dll");
698 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
699 strcat (buf
, "\\ntdll.dll");
704 so
= XCNEW (struct so_list
);
705 lm_info_windows
*li
= new lm_info_windows
;
707 li
->load_addr
= load_addr
;
708 strcpy (so
->so_original_name
, name
);
710 strcpy (so
->so_name
, buf
);
713 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
714 SO_NAME_MAX_PATH_SIZE
);
717 char *rname
= realpath (name
, NULL
);
718 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
720 strcpy (so
->so_name
, rname
);
725 warning (_("dll path for \"%s\" too long or inaccessible"), name
);
726 strcpy (so
->so_name
, so
->so_original_name
);
729 /* Record cygwin1.dll .text start/end. */
730 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
731 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
733 asection
*text
= NULL
;
735 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386"));
740 if (bfd_check_format (abfd
.get (), bfd_object
))
741 text
= bfd_get_section_by_name (abfd
.get (), ".text");
746 /* The symbols in a dll are offset by 0x1000, which is the
747 offset from 0 of the first byte in an image - because of the
748 file header and the section alignment. */
749 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
751 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (text
);
758 /* See nat/windows-nat.h. */
761 windows_nat::handle_load_dll (const char *dll_name
, LPVOID base
)
763 solib_end
->next
= windows_make_so (dll_name
, base
);
764 solib_end
= solib_end
->next
;
766 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
768 DEBUG_EVENTS ("Loading dll \"%s\" at %s.", solib_end
->so_name
,
769 host_address_to_string (li
->load_addr
));
773 windows_free_so (struct so_list
*so
)
775 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
781 /* See nat/windows-nat.h. */
784 windows_nat::handle_unload_dll ()
786 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
789 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
791 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
793 if (li_next
->load_addr
== lpBaseOfDll
)
795 struct so_list
*sodel
= so
->next
;
797 so
->next
= sodel
->next
;
800 DEBUG_EVENTS ("Unloading dll \"%s\".", sodel
->so_name
);
802 windows_free_so (sodel
);
807 /* We did not find any DLL that was previously loaded at this address,
808 so register a complaint. We do not report an error, because we have
809 observed that this may be happening under some circumstances. For
810 instance, running 32bit applications on x64 Windows causes us to receive
811 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
812 events are apparently caused by the WOW layer, the interface between
813 32bit and 64bit worlds). */
814 complaint (_("dll starting at %s not found."),
815 host_address_to_string (lpBaseOfDll
));
818 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
822 catch_errors (void (*func
) ())
828 catch (const gdb_exception
&ex
)
830 exception_print (gdb_stderr
, ex
);
834 /* Clear list of loaded DLLs. */
836 windows_clear_solib (void)
840 for (so
= solib_start
.next
; so
; so
= solib_start
.next
)
842 solib_start
.next
= so
->next
;
843 windows_free_so (so
);
846 solib_end
= &solib_start
;
850 signal_event_command (const char *args
, int from_tty
)
852 uintptr_t event_id
= 0;
853 char *endargs
= NULL
;
856 error (_("signal-event requires an argument (integer event id)"));
858 event_id
= strtoumax (args
, &endargs
, 10);
860 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
861 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
862 error (_("Failed to convert `%s' to event id"), args
);
864 SetEvent ((HANDLE
) event_id
);
865 CloseHandle ((HANDLE
) event_id
);
868 /* See nat/windows-nat.h. */
871 windows_nat::handle_output_debug_string (struct target_waitstatus
*ourstatus
)
875 gdb::unique_xmalloc_ptr
<char> s
876 = (target_read_string
877 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
879 if (s
== nullptr || !*(s
.get ()))
881 else if (!startswith (s
.get (), _CYGWIN_SIGNAL_STRING
))
884 if (!startswith (s
.get (), "cYg"))
887 char *p
= strchr (s
.get (), '\0');
889 if (p
> s
.get () && *--p
== '\n')
891 warning (("%s"), s
.get ());
897 /* Got a cygwin signal marker. A cygwin signal is followed by
898 the signal number itself and then optionally followed by the
899 thread id and address to saved context within the DLL. If
900 these are supplied, then the given thread is assumed to have
901 issued the signal and the context from the thread is assumed
902 to be stored at the given address in the inferior. Tell gdb
903 to treat this like a real signal. */
905 int sig
= strtol (s
.get () + sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
906 gdb_signal gotasig
= gdb_signal_from_host (sig
);
913 ourstatus
->set_stopped (gotasig
);
914 retval
= strtoul (p
, &p
, 0);
916 retval
= current_event
.dwThreadId
;
917 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
918 && ReadProcessMemory (current_process_handle
, x
,
920 __COPY_CONTEXT_SIZE
, &n
)
921 && n
== __COPY_CONTEXT_SIZE
)
922 have_saved_context
= 1;
931 display_selector (HANDLE thread
, DWORD sel
)
937 ret
= Wow64GetThreadSelectorEntry (thread
, sel
, &info
);
940 ret
= GetThreadSelectorEntry (thread
, sel
, &info
);
944 printf_filtered ("0x%03x: ", (unsigned) sel
);
945 if (!info
.HighWord
.Bits
.Pres
)
947 puts_filtered ("Segment not present\n");
950 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
951 (info
.HighWord
.Bits
.BaseMid
<< 16)
953 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
954 if (info
.HighWord
.Bits
.Granularity
)
955 limit
= (limit
<< 12) | 0xfff;
956 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
957 if (info
.HighWord
.Bits
.Default_Big
)
958 puts_filtered(" 32-bit ");
960 puts_filtered(" 16-bit ");
961 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
964 puts_filtered ("Data (Read-Only, Exp-up");
967 puts_filtered ("Data (Read/Write, Exp-up");
970 puts_filtered ("Unused segment (");
973 puts_filtered ("Data (Read/Write, Exp-down");
976 puts_filtered ("Code (Exec-Only, N.Conf");
979 puts_filtered ("Code (Exec/Read, N.Conf");
982 puts_filtered ("Code (Exec-Only, Conf");
985 puts_filtered ("Code (Exec/Read, Conf");
988 printf_filtered ("Unknown type 0x%lx",
989 (unsigned long) info
.HighWord
.Bits
.Type
);
991 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
992 puts_filtered(", N.Acc");
993 puts_filtered (")\n");
994 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
995 puts_filtered("System selector ");
996 printf_filtered ("Priviledge level = %ld. ",
997 (unsigned long) info
.HighWord
.Bits
.Dpl
);
998 if (info
.HighWord
.Bits
.Granularity
)
999 puts_filtered ("Page granular.\n");
1001 puts_filtered ("Byte granular.\n");
1006 DWORD err
= GetLastError ();
1007 if (err
== ERROR_NOT_SUPPORTED
)
1008 printf_filtered ("Function not supported\n");
1010 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1016 display_selectors (const char * args
, int from_tty
)
1018 if (inferior_ptid
== null_ptid
)
1020 puts_filtered ("Impossible to display selectors now.\n");
1024 windows_thread_info
*current_windows_thread
1025 = thread_rec (inferior_ptid
, DONT_INVALIDATE_CONTEXT
);
1032 puts_filtered ("Selector $cs\n");
1033 display_selector (current_windows_thread
->h
,
1034 current_windows_thread
->wow64_context
.SegCs
);
1035 puts_filtered ("Selector $ds\n");
1036 display_selector (current_windows_thread
->h
,
1037 current_windows_thread
->wow64_context
.SegDs
);
1038 puts_filtered ("Selector $es\n");
1039 display_selector (current_windows_thread
->h
,
1040 current_windows_thread
->wow64_context
.SegEs
);
1041 puts_filtered ("Selector $ss\n");
1042 display_selector (current_windows_thread
->h
,
1043 current_windows_thread
->wow64_context
.SegSs
);
1044 puts_filtered ("Selector $fs\n");
1045 display_selector (current_windows_thread
->h
,
1046 current_windows_thread
->wow64_context
.SegFs
);
1047 puts_filtered ("Selector $gs\n");
1048 display_selector (current_windows_thread
->h
,
1049 current_windows_thread
->wow64_context
.SegGs
);
1054 puts_filtered ("Selector $cs\n");
1055 display_selector (current_windows_thread
->h
,
1056 current_windows_thread
->context
.SegCs
);
1057 puts_filtered ("Selector $ds\n");
1058 display_selector (current_windows_thread
->h
,
1059 current_windows_thread
->context
.SegDs
);
1060 puts_filtered ("Selector $es\n");
1061 display_selector (current_windows_thread
->h
,
1062 current_windows_thread
->context
.SegEs
);
1063 puts_filtered ("Selector $ss\n");
1064 display_selector (current_windows_thread
->h
,
1065 current_windows_thread
->context
.SegSs
);
1066 puts_filtered ("Selector $fs\n");
1067 display_selector (current_windows_thread
->h
,
1068 current_windows_thread
->context
.SegFs
);
1069 puts_filtered ("Selector $gs\n");
1070 display_selector (current_windows_thread
->h
,
1071 current_windows_thread
->context
.SegGs
);
1077 sel
= parse_and_eval_long (args
);
1078 printf_filtered ("Selector \"%s\"\n",args
);
1079 display_selector (current_windows_thread
->h
, sel
);
1083 /* See nat/windows-nat.h. */
1086 windows_nat::handle_ms_vc_exception (const EXCEPTION_RECORD
*rec
)
1088 if (rec
->NumberParameters
>= 3
1089 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1091 DWORD named_thread_id
;
1092 windows_thread_info
*named_thread
;
1093 CORE_ADDR thread_name_target
;
1095 thread_name_target
= rec
->ExceptionInformation
[1];
1096 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1098 if (named_thread_id
== (DWORD
) -1)
1099 named_thread_id
= current_event
.dwThreadId
;
1101 named_thread
= thread_rec (ptid_t (current_event
.dwProcessId
,
1102 named_thread_id
, 0),
1103 DONT_INVALIDATE_CONTEXT
);
1104 if (named_thread
!= NULL
)
1106 int thread_name_len
;
1107 gdb::unique_xmalloc_ptr
<char> thread_name
1108 = target_read_string (thread_name_target
, 1025, &thread_name_len
);
1109 if (thread_name_len
> 0)
1111 thread_name
.get ()[thread_name_len
- 1] = '\0';
1112 named_thread
->name
= std::move (thread_name
);
1122 /* See nat/windows-nat.h. */
1125 windows_nat::handle_access_violation (const EXCEPTION_RECORD
*rec
)
1128 /* See if the access violation happened within the cygwin DLL
1129 itself. Cygwin uses a kind of exception handling to deal with
1130 passed-in invalid addresses. gdb should not treat these as real
1131 SEGVs since they will be silently handled by cygwin. A real SEGV
1132 will (theoretically) be caught by cygwin later in the process and
1133 will be sent as a cygwin-specific-signal. So, ignore SEGVs if
1134 they show up within the text segment of the DLL itself. */
1136 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1138 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1139 && addr
< cygwin_load_end
))
1140 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1141 && startswith (fn
, "KERNEL32!IsBad")))
1147 /* Resume thread specified by ID, or all artificially suspended
1148 threads, if we are continuing execution. KILLED non-zero means we
1149 have killed the inferior, so we should ignore weird errors due to
1150 threads shutting down. */
1152 windows_continue (DWORD continue_status
, int id
, int killed
)
1156 desired_stop_thread_id
= id
;
1158 if (matching_pending_stop (debug_events
))
1161 for (windows_thread_info
*th
: thread_list
)
1162 if (id
== -1 || id
== (int) th
->tid
)
1167 if (th
->debug_registers_changed
)
1169 th
->wow64_context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1170 th
->wow64_context
.Dr0
= dr
[0];
1171 th
->wow64_context
.Dr1
= dr
[1];
1172 th
->wow64_context
.Dr2
= dr
[2];
1173 th
->wow64_context
.Dr3
= dr
[3];
1174 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1175 th
->wow64_context
.Dr7
= dr
[7];
1176 th
->debug_registers_changed
= false;
1178 if (th
->wow64_context
.ContextFlags
)
1182 if (GetExitCodeThread (th
->h
, &ec
)
1183 && ec
== STILL_ACTIVE
)
1185 BOOL status
= Wow64SetThreadContext (th
->h
,
1186 &th
->wow64_context
);
1191 th
->wow64_context
.ContextFlags
= 0;
1197 if (th
->debug_registers_changed
)
1199 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1200 th
->context
.Dr0
= dr
[0];
1201 th
->context
.Dr1
= dr
[1];
1202 th
->context
.Dr2
= dr
[2];
1203 th
->context
.Dr3
= dr
[3];
1204 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1205 th
->context
.Dr7
= dr
[7];
1206 th
->debug_registers_changed
= false;
1208 if (th
->context
.ContextFlags
)
1212 if (GetExitCodeThread (th
->h
, &ec
)
1213 && ec
== STILL_ACTIVE
)
1215 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1220 th
->context
.ContextFlags
= 0;
1227 /* When single-stepping a specific thread, other threads must
1232 res
= continue_last_debug_event (continue_status
, debug_events
);
1235 error (_("Failed to resume program execution"
1236 " (ContinueDebugEvent failed, error %u)"),
1237 (unsigned int) GetLastError ());
1242 /* Called in pathological case where Windows fails to send a
1243 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1245 fake_create_process (void)
1247 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1248 current_event
.dwProcessId
);
1249 if (current_process_handle
!= NULL
)
1250 open_process_used
= 1;
1253 error (_("OpenProcess call failed, GetLastError = %u"),
1254 (unsigned) GetLastError ());
1255 /* We can not debug anything in that case. */
1257 windows_add_thread (ptid_t (current_event
.dwProcessId
, 0,
1258 current_event
.dwThreadId
),
1259 current_event
.u
.CreateThread
.hThread
,
1260 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1261 true /* main_thread_p */);
1262 return current_event
.dwThreadId
;
1266 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1268 windows_thread_info
*th
;
1269 DWORD continue_status
= DBG_CONTINUE
;
1271 /* A specific PTID means `step only this thread id'. */
1272 int resume_all
= ptid
== minus_one_ptid
;
1274 /* If we're continuing all threads, it's the current inferior that
1275 should be handled specially. */
1277 ptid
= inferior_ptid
;
1279 if (sig
!= GDB_SIGNAL_0
)
1281 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1283 DEBUG_EXCEPT ("Cannot continue with signal %d here.", sig
);
1285 else if (sig
== last_sig
)
1286 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1289 /* This code does not seem to work, because
1290 the kernel does probably not consider changes in the ExceptionRecord
1291 structure when passing the exception to the inferior.
1292 Note that this seems possible in the exception handler itself. */
1294 for (const xlate_exception
&x
: xlate
)
1297 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1299 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1302 if (continue_status
== DBG_CONTINUE
)
1304 DEBUG_EXCEPT ("Cannot continue with signal %d.", sig
);
1308 DEBUG_EXCEPT ("Can only continue with received signal %d.",
1312 last_sig
= GDB_SIGNAL_0
;
1314 DEBUG_EXEC ("pid=%d, tid=0x%x, step=%d, sig=%d",
1315 ptid
.pid (), (unsigned) ptid
.lwp (), step
, sig
);
1317 /* Get context for currently selected thread. */
1318 th
= thread_rec (inferior_ptid
, DONT_INVALIDATE_CONTEXT
);
1326 /* Single step by setting t bit. */
1327 struct regcache
*regcache
= get_current_regcache ();
1328 struct gdbarch
*gdbarch
= regcache
->arch ();
1329 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1330 th
->wow64_context
.EFlags
|= FLAG_TRACE_BIT
;
1333 if (th
->wow64_context
.ContextFlags
)
1335 if (th
->debug_registers_changed
)
1337 th
->wow64_context
.Dr0
= dr
[0];
1338 th
->wow64_context
.Dr1
= dr
[1];
1339 th
->wow64_context
.Dr2
= dr
[2];
1340 th
->wow64_context
.Dr3
= dr
[3];
1341 th
->wow64_context
.Dr6
= DR6_CLEAR_VALUE
;
1342 th
->wow64_context
.Dr7
= dr
[7];
1343 th
->debug_registers_changed
= false;
1345 CHECK (Wow64SetThreadContext (th
->h
, &th
->wow64_context
));
1346 th
->wow64_context
.ContextFlags
= 0;
1354 /* Single step by setting t bit. */
1355 struct regcache
*regcache
= get_current_regcache ();
1356 struct gdbarch
*gdbarch
= regcache
->arch ();
1357 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1358 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1361 if (th
->context
.ContextFlags
)
1363 if (th
->debug_registers_changed
)
1365 th
->context
.Dr0
= dr
[0];
1366 th
->context
.Dr1
= dr
[1];
1367 th
->context
.Dr2
= dr
[2];
1368 th
->context
.Dr3
= dr
[3];
1369 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1370 th
->context
.Dr7
= dr
[7];
1371 th
->debug_registers_changed
= false;
1373 CHECK (SetThreadContext (th
->h
, &th
->context
));
1374 th
->context
.ContextFlags
= 0;
1379 /* Allow continuing with the same signal that interrupted us.
1380 Otherwise complain. */
1383 windows_continue (continue_status
, -1, 0);
1385 windows_continue (continue_status
, ptid
.lwp (), 0);
1388 /* Ctrl-C handler used when the inferior is not run in the same console. The
1389 handler is in charge of interrupting the inferior using DebugBreakProcess.
1390 Note that this function is not available prior to Windows XP. In this case
1391 we emit a warning. */
1393 ctrl_c_handler (DWORD event_type
)
1395 const int attach_flag
= current_inferior ()->attach_flag
;
1397 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1398 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1401 /* If the inferior and the debugger share the same console, do nothing as
1402 the inferior has also received the Ctrl-C event. */
1403 if (!new_console
&& !attach_flag
)
1409 /* Call DbgUiRemoteBreakin of the 32bit ntdll.dll in the target process.
1410 DebugBreakProcess would call the one of the 64bit ntdll.dll, which
1411 can't be correctly handled by gdb. */
1412 if (wow64_dbgbreak
== nullptr)
1415 if (!find_minimal_symbol_address ("ntdll!DbgUiRemoteBreakin",
1417 wow64_dbgbreak
= (void *) addr
;
1420 if (wow64_dbgbreak
!= nullptr)
1422 HANDLE thread
= CreateRemoteThread (current_process_handle
, NULL
,
1423 0, (LPTHREAD_START_ROUTINE
)
1424 wow64_dbgbreak
, NULL
, 0, NULL
);
1426 CloseHandle (thread
);
1432 if (!DebugBreakProcess (current_process_handle
))
1433 warning (_("Could not interrupt program. "
1434 "Press Ctrl-c in the program console."));
1437 /* Return true to tell that Ctrl-C has been handled. */
1441 /* Get the next event from the child. Returns a non-zero thread id if the event
1442 requires handling by WFI (or whatever). */
1445 windows_nat_target::get_windows_debug_event (int pid
,
1446 struct target_waitstatus
*ourstatus
)
1449 DWORD continue_status
, event_code
;
1450 DWORD thread_id
= 0;
1452 /* If there is a relevant pending stop, report it now. See the
1453 comment by the definition of "pending_stops" for details on why
1455 gdb::optional
<pending_stop
> stop
= fetch_pending_stop (debug_events
);
1456 if (stop
.has_value ())
1458 thread_id
= stop
->thread_id
;
1459 *ourstatus
= stop
->status
;
1461 ptid_t
ptid (current_event
.dwProcessId
, thread_id
);
1462 windows_thread_info
*th
= thread_rec (ptid
, INVALIDATE_CONTEXT
);
1463 th
->reload_context
= true;
1468 last_sig
= GDB_SIGNAL_0
;
1470 if (!(debug_event
= wait_for_debug_event (¤t_event
, 1000)))
1473 continue_status
= DBG_CONTINUE
;
1475 event_code
= current_event
.dwDebugEventCode
;
1476 ourstatus
->set_spurious ();
1477 have_saved_context
= 0;
1481 case CREATE_THREAD_DEBUG_EVENT
:
1482 DEBUG_EVENTS ("kernel event for pid=%u tid=0x%x code=%s",
1483 (unsigned) current_event
.dwProcessId
,
1484 (unsigned) current_event
.dwThreadId
,
1485 "CREATE_THREAD_DEBUG_EVENT");
1486 if (saw_create
!= 1)
1488 inferior
*inf
= find_inferior_pid (this, current_event
.dwProcessId
);
1489 if (!saw_create
&& inf
->attach_flag
)
1491 /* Kludge around a Windows bug where first event is a create
1492 thread event. Caused when attached process does not have
1494 thread_id
= fake_create_process ();
1500 /* Record the existence of this thread. */
1501 thread_id
= current_event
.dwThreadId
;
1503 (ptid_t (current_event
.dwProcessId
, current_event
.dwThreadId
, 0),
1504 current_event
.u
.CreateThread
.hThread
,
1505 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1506 false /* main_thread_p */);
1510 case EXIT_THREAD_DEBUG_EVENT
:
1511 DEBUG_EVENTS ("kernel event for pid=%u tid=0x%x code=%s",
1512 (unsigned) current_event
.dwProcessId
,
1513 (unsigned) current_event
.dwThreadId
,
1514 "EXIT_THREAD_DEBUG_EVENT");
1515 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1516 current_event
.dwThreadId
, 0),
1517 current_event
.u
.ExitThread
.dwExitCode
,
1518 false /* main_thread_p */);
1521 case CREATE_PROCESS_DEBUG_EVENT
:
1522 DEBUG_EVENTS ("kernel event for pid=%u tid=0x%x code=%s",
1523 (unsigned) current_event
.dwProcessId
,
1524 (unsigned) current_event
.dwThreadId
,
1525 "CREATE_PROCESS_DEBUG_EVENT");
1526 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1527 if (++saw_create
!= 1)
1530 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1531 /* Add the main thread. */
1533 (ptid_t (current_event
.dwProcessId
,
1534 current_event
.dwThreadId
, 0),
1535 current_event
.u
.CreateProcessInfo
.hThread
,
1536 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
,
1537 true /* main_thread_p */);
1538 thread_id
= current_event
.dwThreadId
;
1541 case EXIT_PROCESS_DEBUG_EVENT
:
1542 DEBUG_EVENTS ("kernel event for pid=%u tid=0x%x code=%s",
1543 (unsigned) current_event
.dwProcessId
,
1544 (unsigned) current_event
.dwThreadId
,
1545 "EXIT_PROCESS_DEBUG_EVENT");
1546 if (!windows_initialization_done
)
1548 target_terminal::ours ();
1549 target_mourn_inferior (inferior_ptid
);
1550 error (_("During startup program exited with code 0x%x."),
1551 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1553 else if (saw_create
== 1)
1555 windows_delete_thread (ptid_t (current_event
.dwProcessId
,
1556 current_event
.dwThreadId
, 0),
1557 0, true /* main_thread_p */);
1558 DWORD exit_status
= current_event
.u
.ExitProcess
.dwExitCode
;
1559 /* If the exit status looks like a fatal exception, but we
1560 don't recognize the exception's code, make the original
1561 exit status value available, to avoid losing
1564 = WIFSIGNALED (exit_status
) ? WTERMSIG (exit_status
) : -1;
1565 if (exit_signal
== -1)
1566 ourstatus
->set_exited (exit_status
);
1568 ourstatus
->set_signalled (gdb_signal_from_host (exit_signal
));
1570 thread_id
= current_event
.dwThreadId
;
1574 case LOAD_DLL_DEBUG_EVENT
:
1575 DEBUG_EVENTS ("kernel event for pid=%u tid=0x%x code=%s",
1576 (unsigned) current_event
.dwProcessId
,
1577 (unsigned) current_event
.dwThreadId
,
1578 "LOAD_DLL_DEBUG_EVENT");
1579 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1580 if (saw_create
!= 1 || ! windows_initialization_done
)
1582 catch_errors (dll_loaded_event
);
1583 ourstatus
->set_loaded ();
1584 thread_id
= current_event
.dwThreadId
;
1587 case UNLOAD_DLL_DEBUG_EVENT
:
1588 DEBUG_EVENTS ("kernel event for pid=%u tid=0x%x code=%s",
1589 (unsigned) current_event
.dwProcessId
,
1590 (unsigned) current_event
.dwThreadId
,
1591 "UNLOAD_DLL_DEBUG_EVENT");
1592 if (saw_create
!= 1 || ! windows_initialization_done
)
1594 catch_errors (handle_unload_dll
);
1595 ourstatus
->set_loaded ();
1596 thread_id
= current_event
.dwThreadId
;
1599 case EXCEPTION_DEBUG_EVENT
:
1600 DEBUG_EVENTS ("kernel event for pid=%u tid=0x%x code=%s",
1601 (unsigned) current_event
.dwProcessId
,
1602 (unsigned) current_event
.dwThreadId
,
1603 "EXCEPTION_DEBUG_EVENT");
1604 if (saw_create
!= 1)
1606 switch (handle_exception (ourstatus
, debug_exceptions
))
1608 case HANDLE_EXCEPTION_UNHANDLED
:
1610 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1612 case HANDLE_EXCEPTION_HANDLED
:
1613 thread_id
= current_event
.dwThreadId
;
1615 case HANDLE_EXCEPTION_IGNORED
:
1616 continue_status
= DBG_CONTINUE
;
1621 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1622 DEBUG_EVENTS ("kernel event for pid=%u tid=0x%x code=%s",
1623 (unsigned) current_event
.dwProcessId
,
1624 (unsigned) current_event
.dwThreadId
,
1625 "OUTPUT_DEBUG_STRING_EVENT");
1626 if (saw_create
!= 1)
1628 thread_id
= handle_output_debug_string (ourstatus
);
1632 if (saw_create
!= 1)
1634 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1635 (unsigned) current_event
.dwProcessId
,
1636 (unsigned) current_event
.dwThreadId
);
1637 printf_unfiltered (" unknown event code %u\n",
1638 (unsigned) current_event
.dwDebugEventCode
);
1642 if (!thread_id
|| saw_create
!= 1)
1644 CHECK (windows_continue (continue_status
, desired_stop_thread_id
, 0));
1646 else if (desired_stop_thread_id
!= -1 && desired_stop_thread_id
!= thread_id
)
1648 /* Pending stop. See the comment by the definition of
1649 "pending_stops" for details on why this is needed. */
1650 DEBUG_EVENTS ("get_windows_debug_event - "
1651 "unexpected stop in 0x%x (expecting 0x%x)",
1652 thread_id
, desired_stop_thread_id
);
1654 if (current_event
.dwDebugEventCode
== EXCEPTION_DEBUG_EVENT
1655 && ((current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1656 == EXCEPTION_BREAKPOINT
)
1657 || (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1658 == STATUS_WX86_BREAKPOINT
))
1659 && windows_initialization_done
)
1661 ptid_t ptid
= ptid_t (current_event
.dwProcessId
, thread_id
, 0);
1662 windows_thread_info
*th
= thread_rec (ptid
, INVALIDATE_CONTEXT
);
1663 th
->stopped_at_software_breakpoint
= true;
1664 th
->pc_adjusted
= false;
1666 pending_stops
.push_back ({thread_id
, *ourstatus
, current_event
});
1668 CHECK (windows_continue (continue_status
, desired_stop_thread_id
, 0));
1675 /* Wait for interesting events to occur in the target process. */
1677 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1678 target_wait_flags options
)
1682 /* We loop when we get a non-standard exception rather than return
1683 with a SPURIOUS because resume can try and step or modify things,
1684 which needs a current_thread->h. But some of these exceptions mark
1685 the birth or death of threads, which mean that the current thread
1686 isn't necessarily what you think it is. */
1692 /* If the user presses Ctrl-c while the debugger is waiting
1693 for an event, he expects the debugger to interrupt his program
1694 and to get the prompt back. There are two possible situations:
1696 - The debugger and the program do not share the console, in
1697 which case the Ctrl-c event only reached the debugger.
1698 In that case, the ctrl_c handler will take care of interrupting
1699 the inferior. Note that this case is working starting with
1700 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1703 - The debugger and the program share the same console, in which
1704 case both debugger and inferior will receive the Ctrl-c event.
1705 In that case the ctrl_c handler will ignore the event, as the
1706 Ctrl-c event generated inside the inferior will trigger the
1707 expected debug event.
1709 FIXME: brobecker/2008-05-20: If the inferior receives the
1710 signal first and the delay until GDB receives that signal
1711 is sufficiently long, GDB can sometimes receive the SIGINT
1712 after we have unblocked the CTRL+C handler. This would
1713 lead to the debugger stopping prematurely while handling
1714 the new-thread event that comes with the handling of the SIGINT
1715 inside the inferior, and then stop again immediately when
1716 the user tries to resume the execution in the inferior.
1717 This is a classic race that we should try to fix one day. */
1718 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1719 retval
= get_windows_debug_event (pid
, ourstatus
);
1720 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1724 ptid_t result
= ptid_t (current_event
.dwProcessId
, retval
, 0);
1726 if (ourstatus
->kind () != TARGET_WAITKIND_EXITED
1727 && ourstatus
->kind () != TARGET_WAITKIND_SIGNALLED
)
1729 windows_thread_info
*th
= thread_rec (result
, INVALIDATE_CONTEXT
);
1733 th
->stopped_at_software_breakpoint
= false;
1734 if (current_event
.dwDebugEventCode
== EXCEPTION_DEBUG_EVENT
1735 && ((current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1736 == EXCEPTION_BREAKPOINT
)
1737 || (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1738 == STATUS_WX86_BREAKPOINT
))
1739 && windows_initialization_done
)
1741 th
->stopped_at_software_breakpoint
= true;
1742 th
->pc_adjusted
= false;
1753 if (deprecated_ui_loop_hook
!= NULL
)
1754 detach
= deprecated_ui_loop_hook (0);
1763 windows_nat_target::do_initial_windows_stuff (DWORD pid
, bool attaching
)
1766 struct inferior
*inf
;
1768 last_sig
= GDB_SIGNAL_0
;
1769 open_process_used
= 0;
1770 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1773 cygwin_load_start
= cygwin_load_end
= 0;
1775 current_event
.dwProcessId
= pid
;
1776 memset (¤t_event
, 0, sizeof (current_event
));
1777 inf
= current_inferior ();
1778 if (!inf
->target_is_pushed (this))
1779 inf
->push_target (this);
1780 disable_breakpoints_in_shlibs ();
1781 windows_clear_solib ();
1782 clear_proceed_status (0);
1783 init_wait_for_inferior ();
1786 ignore_first_breakpoint
= !attaching
&& wow64_process
;
1790 windows_set_context_register_offsets (amd64_mappings
);
1791 windows_set_segment_register_p (amd64_windows_segment_register_p
);
1796 windows_set_context_register_offsets (i386_mappings
);
1797 windows_set_segment_register_p (i386_windows_segment_register_p
);
1800 inferior_appeared (inf
, pid
);
1801 inf
->attach_flag
= attaching
;
1803 target_terminal::init ();
1804 target_terminal::inferior ();
1806 windows_initialization_done
= 0;
1812 struct target_waitstatus status
;
1814 last_ptid
= this->wait (minus_one_ptid
, &status
, 0);
1816 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
1818 if (status
.kind () != TARGET_WAITKIND_LOADED
1819 && status
.kind () != TARGET_WAITKIND_SPURIOUS
)
1822 this->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
1825 switch_to_thread (find_thread_ptid (this, last_ptid
));
1827 /* Now that the inferior has been started and all DLLs have been mapped,
1828 we can iterate over all DLLs and load them in.
1830 We avoid doing it any earlier because, on certain versions of Windows,
1831 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
1832 we have seen on Windows 8.1 that the ntdll.dll load event does not
1833 include the DLL name, preventing us from creating an associated SO.
1834 A possible explanation is that ntdll.dll might be mapped before
1835 the SO info gets created by the Windows system -- ntdll.dll is
1836 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
1837 do not seem to suffer from that problem.
1839 Rather than try to work around this sort of issue, it is much
1840 simpler to just ignore DLL load/unload events during the startup
1841 phase, and then process them all in one batch now. */
1842 windows_add_all_dlls ();
1844 windows_initialization_done
= 1;
1848 /* Try to set or remove a user privilege to the current process. Return -1
1849 if that fails, the previous setting of that privilege otherwise.
1851 This code is copied from the Cygwin source code and rearranged to allow
1852 dynamically loading of the needed symbols from advapi32 which is only
1853 available on NT/2K/XP. */
1855 set_process_privilege (const char *privilege
, BOOL enable
)
1857 HANDLE token_hdl
= NULL
;
1859 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1863 if (!OpenProcessToken (GetCurrentProcess (),
1864 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1868 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
1871 new_priv
.PrivilegeCount
= 1;
1872 new_priv
.Privileges
[0].Luid
= restore_priv
;
1873 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1875 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1876 sizeof orig_priv
, &orig_priv
, &size
))
1879 /* Disabled, otherwise every `attach' in an unprivileged user session
1880 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1881 windows_attach(). */
1882 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1883 be enabled. GetLastError () returns an correct error code, though. */
1884 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1888 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1892 CloseHandle (token_hdl
);
1897 /* Attach to process PID, then initialize for debugging it. */
1900 windows_nat_target::attach (const char *args
, int from_tty
)
1905 pid
= parse_pid_to_attach (args
);
1907 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1909 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1910 printf_unfiltered ("This can cause attach to "
1911 "fail on Windows NT/2K/XP\n");
1914 windows_init_thread_list ();
1915 ok
= DebugActiveProcess (pid
);
1921 /* Try fall back to Cygwin pid. */
1922 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1925 ok
= DebugActiveProcess (pid
);
1930 error (_("Can't attach to process %u (error %u)"),
1931 (unsigned) pid
, (unsigned) GetLastError ());
1933 DebugSetProcessKillOnExit (FALSE
);
1937 const char *exec_file
= get_exec_file (0);
1940 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1941 target_pid_to_str (ptid_t (pid
)).c_str ());
1943 printf_unfiltered ("Attaching to %s\n",
1944 target_pid_to_str (ptid_t (pid
)).c_str ());
1948 HANDLE h
= OpenProcess (PROCESS_QUERY_INFORMATION
, FALSE
, pid
);
1952 if (IsWow64Process (h
, &wow64
))
1953 wow64_process
= wow64
;
1958 do_initial_windows_stuff (pid
, 1);
1959 target_terminal::ours ();
1963 windows_nat_target::detach (inferior
*inf
, int from_tty
)
1967 ptid_t ptid
= minus_one_ptid
;
1968 resume (ptid
, 0, GDB_SIGNAL_0
);
1970 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1972 error (_("Can't detach process %u (error %u)"),
1973 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
1976 DebugSetProcessKillOnExit (FALSE
);
1978 if (detached
&& from_tty
)
1980 const char *exec_file
= get_exec_file (0);
1983 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
1984 (unsigned) current_event
.dwProcessId
);
1987 x86_cleanup_dregs ();
1988 switch_to_no_thread ();
1989 detach_inferior (inf
);
1991 maybe_unpush_target ();
1994 /* Try to determine the executable filename.
1996 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
1998 Upon success, the filename is stored inside EXE_NAME_RET, and
1999 this function returns nonzero.
2001 Otherwise, this function returns zero and the contents of
2002 EXE_NAME_RET is undefined. */
2005 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2015 if (!EnumProcessModulesEx (current_process_handle
, &dh_buf
,
2016 sizeof (HMODULE
), &cbNeeded
,
2017 LIST_MODULES_32BIT
) || !cbNeeded
)
2023 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2024 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2028 /* We know the executable is always first in the list of modules,
2029 which we just fetched. So no need to fetch more. */
2033 /* Cygwin prefers that the path be in /x/y/z format, so extract
2034 the filename into a temporary buffer first, and then convert it
2035 to POSIX format into the destination buffer. */
2036 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2038 len
= GetModuleFileNameEx (current_process_handle
,
2039 dh_buf
, pathbuf
, exe_name_max_len
);
2041 error (_("Error getting executable filename: %u."),
2042 (unsigned) GetLastError ());
2043 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2044 exe_name_max_len
) < 0)
2045 error (_("Error converting executable filename to POSIX: %d."), errno
);
2048 len
= GetModuleFileNameEx (current_process_handle
,
2049 dh_buf
, exe_name_ret
, exe_name_max_len
);
2051 error (_("Error getting executable filename: %u."),
2052 (unsigned) GetLastError ());
2055 return 1; /* success */
2058 /* The pid_to_exec_file target_ops method for this platform. */
2061 windows_nat_target::pid_to_exec_file (int pid
)
2063 static char path
[__PMAX
];
2065 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2067 char procexe
[sizeof ("/proc/4294967295/exe")];
2069 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2070 nchars
= readlink (procexe
, path
, sizeof(path
));
2071 if (nchars
> 0 && nchars
< sizeof (path
))
2073 path
[nchars
] = '\0'; /* Got it */
2078 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2079 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2080 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2086 /* Print status information about what we're accessing. */
2089 windows_nat_target::files_info ()
2091 struct inferior
*inf
= current_inferior ();
2093 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2094 inf
->attach_flag
? "attached" : "child",
2095 target_pid_to_str (inferior_ptid
).c_str ());
2098 /* Modify CreateProcess parameters for use of a new separate console.
2100 *FLAGS: DWORD parameter for general process creation flags.
2101 *SI: STARTUPINFO structure, for which the console window size and
2102 console buffer size is filled in if GDB is running in a console.
2103 to create the new console.
2104 The size of the used font is not available on all versions of
2105 Windows OS. Furthermore, the current font might not be the default
2106 font, but this is still better than before.
2107 If the windows and buffer sizes are computed,
2108 SI->DWFLAGS is changed so that this information is used
2109 by CreateProcess function. */
2112 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2114 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2115 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2117 if (hconsole
!= INVALID_HANDLE_VALUE
)
2119 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2121 CONSOLE_FONT_INFO cfi
;
2123 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2124 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2125 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2126 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2127 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2129 si
->dwXSize
*= font_size
.X
;
2133 si
->dwYSize
*= font_size
.Y
;
2136 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2137 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2138 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2140 *flags
|= CREATE_NEW_CONSOLE
;
2144 /* Function called by qsort to sort environment strings. */
2147 envvar_cmp (const void *a
, const void *b
)
2149 const char **p
= (const char **) a
;
2150 const char **q
= (const char **) b
;
2151 return strcasecmp (*p
, *q
);
2157 clear_win32_environment (char **env
)
2161 wchar_t *copy
= NULL
, *equalpos
;
2163 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2165 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2166 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2167 mbstowcs (copy
, env
[i
], len
);
2168 equalpos
= wcschr (copy
, L
'=');
2171 SetEnvironmentVariableW (copy
, NULL
);
2179 /* Redirection of inferior I/O streams for native MS-Windows programs.
2180 Unlike on Unix, where this is handled by invoking the inferior via
2181 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2183 The official documentation of the cmd.exe redirection features is here:
2185 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2187 (That page talks about Windows XP, but there's no newer
2188 documentation, so we assume later versions of cmd.exe didn't change
2191 Caveat: the documentation on that page seems to include a few lies.
2192 For example, it describes strange constructs 1<&2 and 2<&1, which
2193 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2194 think the cmd.exe parser of the redirection symbols simply doesn't
2195 care about the < vs > distinction in these cases. Therefore, the
2196 supported features are explicitly documented below.
2198 The emulation below aims at supporting all the valid use cases
2199 supported by cmd.exe, which include:
2201 < FILE redirect standard input from FILE
2202 0< FILE redirect standard input from FILE
2203 <&N redirect standard input from file descriptor N
2204 0<&N redirect standard input from file descriptor N
2205 > FILE redirect standard output to FILE
2206 >> FILE append standard output to FILE
2207 1>> FILE append standard output to FILE
2208 >&N redirect standard output to file descriptor N
2209 1>&N redirect standard output to file descriptor N
2210 >>&N append standard output to file descriptor N
2211 1>>&N append standard output to file descriptor N
2212 2> FILE redirect standard error to FILE
2213 2>> FILE append standard error to FILE
2214 2>&N redirect standard error to file descriptor N
2215 2>>&N append standard error to file descriptor N
2217 Note that using N > 2 in the above construct is supported, but
2218 requires that the corresponding file descriptor be open by some
2219 means elsewhere or outside GDB. Also note that using ">&0" or
2220 "<&2" will generally fail, because the file descriptor redirected
2221 from is normally open in an incompatible mode (e.g., FD 0 is open
2222 for reading only). IOW, use of such tricks is not recommended;
2223 you are on your own.
2225 We do NOT support redirection of file descriptors above 2, as in
2226 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2227 that needs special handling in the startup code that MinGW
2228 doesn't have). Pipes are also not supported.
2230 As for invalid use cases, where the redirection contains some
2231 error, the emulation below will detect that and produce some
2232 error and/or failure. But the behavior in those cases is not
2233 bug-for-bug compatible with what cmd.exe does in those cases.
2234 That's because what cmd.exe does then is not well defined, and
2235 seems to be a side effect of the cmd.exe parsing of the command
2236 line more than anything else. For example, try redirecting to an
2237 invalid file name, as in "> foo:bar".
2239 There are also minor syntactic deviations from what cmd.exe does
2240 in some corner cases. For example, it doesn't support the likes
2241 of "> &foo" to mean redirect to file named literally "&foo"; we
2242 do support that here, because that, too, sounds like some issue
2243 with the cmd.exe parser. Another nicety is that we support
2244 redirection targets that use file names with forward slashes,
2245 something cmd.exe doesn't -- this comes in handy since GDB
2246 file-name completion can be used when typing the command line for
2249 /* Support routines for redirecting standard handles of the inferior. */
2251 /* Parse a single redirection spec, open/duplicate the specified
2252 file/fd, and assign the appropriate value to one of the 3 standard
2253 file descriptors. */
2255 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2257 int *fd
, ref_fd
= -2;
2259 const char *fname
= redir_string
+ 1;
2260 int rc
= *redir_string
;
2275 fd
= (rc
== '2') ? err
: out
;
2276 mode
= O_WRONLY
| O_CREAT
;
2289 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2291 /* A reference to a file descriptor. */
2293 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2294 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2296 /* Don't allow redirection when open modes are incompatible. */
2297 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2298 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2305 else if (ref_fd
== 1)
2307 else if (ref_fd
== 2)
2317 fname
++; /* skip the separator space */
2318 /* If the descriptor is already open, close it. This allows
2319 multiple specs of redirections for the same stream, which is
2320 somewhat nonsensical, but still valid and supported by cmd.exe.
2321 (But cmd.exe only opens a single file in this case, the one
2322 specified by the last redirection spec on the command line.) */
2327 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2331 else if (ref_fd
== -1)
2332 *fd
= -1; /* reset to default destination */
2335 *fd
= _dup (ref_fd
);
2339 /* _open just sets a flag for O_APPEND, which won't be passed to the
2340 inferior, so we need to actually move the file pointer. */
2341 if ((mode
& O_APPEND
) != 0)
2342 _lseek (*fd
, 0L, SEEK_END
);
2346 /* Canonicalize a single redirection spec and set up the corresponding
2347 file descriptor as specified. */
2349 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2351 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2353 const char *start
= s
;
2356 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2357 if ((*start
== '>' || *start
== '1' || *start
== '2')
2361 if (*s
== '>' && *start
!= '>')
2364 else if (*start
== '0' && *s
== '<')
2366 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2369 while (isspace (*s
)) /* skip whitespace before file name */
2371 *d
++ = ' '; /* separate file name with a single space */
2374 /* Copy the file name. */
2377 /* Remove quoting characters from the file name in buf[]. */
2378 if (*s
== '"') /* could support '..' quoting here */
2382 else if (*s
== quote
)
2390 else if (*s
== '\\')
2392 if (s
[1] == '"') /* could support '..' here */
2396 else if (isspace (*s
) && !quote
)
2400 if (d
- buf
>= sizeof (buf
) - 1)
2402 errno
= ENAMETOOLONG
;
2408 /* Windows doesn't allow redirection characters in file names, so we
2409 can bail out early if they use them, or if there's no target file
2410 name after the redirection symbol. */
2411 if (d
[-1] == '>' || d
[-1] == '<')
2416 if (redir_open (buf
, inp
, out
, err
) == 0)
2421 /* Parse the command line for redirection specs and prepare the file
2422 descriptors for the 3 standard streams accordingly. */
2424 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2425 int *inp
, int *out
, int *err
)
2427 const char *s
= cmd_orig
;
2430 bool retval
= false;
2432 while (isspace (*s
))
2437 if (*s
== '"') /* could also support '..' quoting here */
2441 else if (*s
== quote
)
2444 else if (*s
== '\\')
2446 if (s
[1] == '"') /* escaped quote char */
2451 /* Process a single redirection candidate. */
2452 if (*s
== '<' || *s
== '>'
2453 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2454 || (*s
== '0' && s
[1] == '<'))
2456 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2470 #endif /* !__CYGWIN__ */
2472 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2473 EXEC_FILE is the file to run.
2474 ALLARGS is a string containing the arguments to the program.
2475 ENV is the environment vector to pass. Errors reported with error(). */
2478 windows_nat_target::create_inferior (const char *exec_file
,
2479 const std::string
&origallargs
,
2480 char **in_env
, int from_tty
)
2484 cygwin_buf_t real_path
[__PMAX
];
2485 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2486 cygwin_buf_t infcwd
[__PMAX
];
2488 cygwin_buf_t
*toexec
;
2489 cygwin_buf_t
*cygallargs
;
2491 char **old_env
= NULL
;
2495 int ostdin
, ostdout
, ostderr
;
2496 #else /* !__CYGWIN__ */
2497 char shell
[__PMAX
]; /* Path to shell */
2499 char *args
, *allargs_copy
;
2500 size_t args_len
, allargs_len
;
2501 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2502 HANDLE tty
= INVALID_HANDLE_VALUE
;
2503 bool redirected
= false;
2510 #endif /* !__CYGWIN__ */
2511 const char *allargs
= origallargs
.c_str ();
2512 PROCESS_INFORMATION pi
;
2515 const std::string
&inferior_tty
= current_inferior ()->tty ();
2518 error (_("No executable specified, use `target exec'."));
2520 const char *inferior_cwd
= current_inferior ()->cwd ().c_str ();
2521 std::string expanded_infcwd
;
2522 if (*inferior_cwd
== '\0')
2523 inferior_cwd
= nullptr;
2526 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
2527 /* Mirror slashes on inferior's cwd. */
2528 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
2530 inferior_cwd
= expanded_infcwd
.c_str ();
2533 memset (&si
, 0, sizeof (si
));
2534 si
.cb
= sizeof (si
);
2537 flags
|= CREATE_NEW_PROCESS_GROUP
;
2540 windows_set_console_info (&si
, &flags
);
2545 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2546 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2547 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2548 error (_("Error starting executable: %d"), errno
);
2551 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2552 if (len
== (size_t) -1)
2553 error (_("Error starting executable: %d"), errno
);
2554 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2555 mbstowcs (cygallargs
, allargs
, len
);
2556 #else /* !__USEWIDE */
2557 cygallargs
= allargs
;
2563 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2564 error (_("Error starting executable via shell: %d"), errno
);
2566 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2567 + mbstowcs (NULL
, allargs
, 0) + 2;
2568 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2569 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2570 #else /* !__USEWIDE */
2571 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2572 + strlen (allargs
) + 2);
2573 cygallargs
= (char *) alloca (len
);
2574 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2575 #endif /* __USEWIDE */
2577 flags
|= DEBUG_PROCESS
;
2580 if (inferior_cwd
!= NULL
2581 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
2582 infcwd
, strlen (inferior_cwd
)) < 0)
2583 error (_("Error converting inferior cwd: %d"), errno
);
2586 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2587 * sizeof (wchar_t));
2588 wcscpy (args
, toexec
);
2589 wcscat (args
, L
" ");
2590 wcscat (args
, cygallargs
);
2591 #else /* !__USEWIDE */
2592 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2593 strcpy (args
, toexec
);
2595 strcat (args
, cygallargs
);
2596 #endif /* !__USEWIDE */
2598 #ifdef CW_CVT_ENV_TO_WINENV
2599 /* First try to create a direct Win32 copy of the POSIX environment. */
2600 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2601 if (w32_env
!= (PWCHAR
) -1)
2602 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2604 /* If that fails, fall back to old method tweaking GDB's environment. */
2605 #endif /* CW_CVT_ENV_TO_WINENV */
2607 /* Reset all Win32 environment variables to avoid leftover on next run. */
2608 clear_win32_environment (environ
);
2609 /* Prepare the environment vars for CreateProcess. */
2612 cygwin_internal (CW_SYNC_WINENV
);
2616 if (inferior_tty
.empty ())
2617 tty
= ostdin
= ostdout
= ostderr
= -1;
2620 tty
= open (inferior_tty
.c_str (), O_RDWR
| O_NOCTTY
);
2623 print_sys_errmsg (inferior_tty
.c_str (), errno
);
2624 ostdin
= ostdout
= ostderr
= -1;
2637 windows_init_thread_list ();
2638 ret
= CreateProcess (0,
2639 args
, /* command line */
2640 NULL
, /* Security */
2642 TRUE
, /* inherit handles */
2643 flags
, /* start flags */
2644 w32_env
, /* environment */
2645 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
2650 /* Just free the Win32 environment, if it could be created. */
2654 /* Reset all environment variables to avoid leftover on next run. */
2655 clear_win32_environment (in_env
);
2656 /* Restore normal GDB environment variables. */
2658 cygwin_internal (CW_SYNC_WINENV
);
2671 #else /* !__CYGWIN__ */
2672 allargs_len
= strlen (allargs
);
2673 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
2674 if (strpbrk (allargs_copy
, "<>") != NULL
)
2679 redirect_inferior_handles (allargs
, allargs_copy
,
2680 &fd_inp
, &fd_out
, &fd_err
);
2682 warning (_("Error in redirection: %s."), safe_strerror (errno
));
2685 allargs_len
= strlen (allargs_copy
);
2687 /* If not all the standard streams are redirected by the command
2688 line, use INFERIOR_TTY for those which aren't. */
2689 if (!inferior_tty
.empty ()
2690 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
2692 SECURITY_ATTRIBUTES sa
;
2693 sa
.nLength
= sizeof(sa
);
2694 sa
.lpSecurityDescriptor
= 0;
2695 sa
.bInheritHandle
= TRUE
;
2696 tty
= CreateFileA (inferior_tty
.c_str (), GENERIC_READ
| GENERIC_WRITE
,
2697 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2698 if (tty
== INVALID_HANDLE_VALUE
)
2699 warning (_("Warning: Failed to open TTY %s, error %#x."),
2700 inferior_tty
.c_str (), (unsigned) GetLastError ());
2702 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
2705 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
2706 else if (tty
!= INVALID_HANDLE_VALUE
)
2709 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
2711 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
2712 else if (tty
!= INVALID_HANDLE_VALUE
)
2713 si
.hStdOutput
= tty
;
2715 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
2717 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
2718 else if (tty
!= INVALID_HANDLE_VALUE
)
2721 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
2722 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2726 /* Build the command line, a space-separated list of tokens where
2727 the first token is the name of the module to be executed.
2728 To avoid ambiguities introduced by spaces in the module name,
2730 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
2731 args
= (char *) alloca (args_len
);
2732 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
2734 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2736 /* CreateProcess takes the environment list as a null terminated set of
2737 strings (i.e. two nulls terminate the list). */
2739 /* Get total size for env strings. */
2740 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2741 envlen
+= strlen (in_env
[i
]) + 1;
2743 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2744 env
= (char **) alloca (envsize
);
2745 memcpy (env
, in_env
, envsize
);
2746 /* Windows programs expect the environment block to be sorted. */
2747 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2749 w32env
= (char *) alloca (envlen
+ 1);
2751 /* Copy env strings into new buffer. */
2752 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2754 strcpy (temp
, env
[i
]);
2755 temp
+= strlen (temp
) + 1;
2758 /* Final nil string to terminate new env. */
2761 windows_init_thread_list ();
2762 ret
= CreateProcessA (0,
2763 args
, /* command line */
2764 NULL
, /* Security */
2766 TRUE
, /* inherit handles */
2767 flags
, /* start flags */
2768 w32env
, /* environment */
2769 inferior_cwd
, /* current directory */
2772 if (tty
!= INVALID_HANDLE_VALUE
)
2780 #endif /* !__CYGWIN__ */
2783 error (_("Error creating process %s, (error %u)."),
2784 exec_file
, (unsigned) GetLastError ());
2788 if (IsWow64Process (pi
.hProcess
, &wow64
))
2789 wow64_process
= wow64
;
2792 CloseHandle (pi
.hThread
);
2793 CloseHandle (pi
.hProcess
);
2795 if (useshell
&& shell
[0] != '\0')
2800 do_initial_windows_stuff (pi
.dwProcessId
, 0);
2802 /* windows_continue (DBG_CONTINUE, -1, 0); */
2806 windows_nat_target::mourn_inferior ()
2808 (void) windows_continue (DBG_CONTINUE
, -1, 0);
2809 x86_cleanup_dregs();
2810 if (open_process_used
)
2812 CHECK (CloseHandle (current_process_handle
));
2813 open_process_used
= 0;
2815 siginfo_er
.ExceptionCode
= 0;
2816 inf_child_target::mourn_inferior ();
2819 /* Send a SIGINT to the process group. This acts just like the user typed a
2820 ^C on the controlling terminal. */
2823 windows_nat_target::interrupt ()
2825 DEBUG_EVENTS ("GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)");
2826 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
2827 registers_changed (); /* refresh register state */
2830 /* Helper for windows_xfer_partial that handles memory transfers.
2831 Arguments are like target_xfer_partial. */
2833 static enum target_xfer_status
2834 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2835 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2839 DWORD lasterror
= 0;
2841 if (writebuf
!= NULL
)
2843 DEBUG_MEM ("write target memory, %s bytes at %s",
2844 pulongest (len
), core_addr_to_string (memaddr
));
2845 success
= WriteProcessMemory (current_process_handle
,
2846 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
2849 lasterror
= GetLastError ();
2850 FlushInstructionCache (current_process_handle
,
2851 (LPCVOID
) (uintptr_t) memaddr
, len
);
2855 DEBUG_MEM ("read target memory, %s bytes at %s",
2856 pulongest (len
), core_addr_to_string (memaddr
));
2857 success
= ReadProcessMemory (current_process_handle
,
2858 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
2861 lasterror
= GetLastError ();
2863 *xfered_len
= (ULONGEST
) done
;
2864 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
2865 return TARGET_XFER_OK
;
2867 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
2871 windows_nat_target::kill ()
2873 CHECK (TerminateProcess (current_process_handle
, 0));
2877 if (!windows_continue (DBG_CONTINUE
, -1, 1))
2879 if (!wait_for_debug_event (¤t_event
, INFINITE
))
2881 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2885 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
2889 windows_nat_target::close ()
2891 DEBUG_EVENTS ("inferior_ptid=%d\n", inferior_ptid
.pid ());
2894 /* Convert pid to printable format. */
2896 windows_nat_target::pid_to_str (ptid_t ptid
)
2898 if (ptid
.lwp () != 0)
2899 return string_printf ("Thread %d.0x%lx", ptid
.pid (), ptid
.lwp ());
2901 return normal_pid_to_str (ptid
);
2904 static enum target_xfer_status
2905 windows_xfer_shared_libraries (struct target_ops
*ops
,
2906 enum target_object object
, const char *annex
,
2907 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2908 ULONGEST offset
, ULONGEST len
,
2909 ULONGEST
*xfered_len
)
2911 struct obstack obstack
;
2917 return TARGET_XFER_E_IO
;
2919 obstack_init (&obstack
);
2920 obstack_grow_str (&obstack
, "<library-list>\n");
2921 for (so
= solib_start
.next
; so
; so
= so
->next
)
2923 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
2925 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
2926 (uintptr_t) li
->load_addr
,
2928 target_gdbarch (), &obstack
);
2930 obstack_grow_str0 (&obstack
, "</library-list>\n");
2932 buf
= (const char *) obstack_finish (&obstack
);
2933 len_avail
= strlen (buf
);
2934 if (offset
>= len_avail
)
2938 if (len
> len_avail
- offset
)
2939 len
= len_avail
- offset
;
2940 memcpy (readbuf
, buf
+ offset
, len
);
2943 obstack_free (&obstack
, NULL
);
2944 *xfered_len
= (ULONGEST
) len
;
2945 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
2948 /* Helper for windows_nat_target::xfer_partial that handles signal info. */
2950 static enum target_xfer_status
2951 windows_xfer_siginfo (gdb_byte
*readbuf
, ULONGEST offset
, ULONGEST len
,
2952 ULONGEST
*xfered_len
)
2954 char *buf
= (char *) &siginfo_er
;
2955 size_t bufsize
= sizeof (siginfo_er
);
2958 EXCEPTION_RECORD32 er32
;
2961 buf
= (char *) &er32
;
2962 bufsize
= sizeof (er32
);
2964 er32
.ExceptionCode
= siginfo_er
.ExceptionCode
;
2965 er32
.ExceptionFlags
= siginfo_er
.ExceptionFlags
;
2966 er32
.ExceptionRecord
= (uintptr_t) siginfo_er
.ExceptionRecord
;
2967 er32
.ExceptionAddress
= (uintptr_t) siginfo_er
.ExceptionAddress
;
2968 er32
.NumberParameters
= siginfo_er
.NumberParameters
;
2970 for (i
= 0; i
< EXCEPTION_MAXIMUM_PARAMETERS
; i
++)
2971 er32
.ExceptionInformation
[i
] = siginfo_er
.ExceptionInformation
[i
];
2975 if (siginfo_er
.ExceptionCode
== 0)
2976 return TARGET_XFER_E_IO
;
2978 if (readbuf
== nullptr)
2979 return TARGET_XFER_E_IO
;
2981 if (offset
> bufsize
)
2982 return TARGET_XFER_E_IO
;
2984 if (offset
+ len
> bufsize
)
2985 len
= bufsize
- offset
;
2987 memcpy (readbuf
, buf
+ offset
, len
);
2990 return TARGET_XFER_OK
;
2993 enum target_xfer_status
2994 windows_nat_target::xfer_partial (enum target_object object
,
2995 const char *annex
, gdb_byte
*readbuf
,
2996 const gdb_byte
*writebuf
, ULONGEST offset
,
2997 ULONGEST len
, ULONGEST
*xfered_len
)
3001 case TARGET_OBJECT_MEMORY
:
3002 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
3004 case TARGET_OBJECT_LIBRARIES
:
3005 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
3006 writebuf
, offset
, len
, xfered_len
);
3008 case TARGET_OBJECT_SIGNAL_INFO
:
3009 return windows_xfer_siginfo (readbuf
, offset
, len
, xfered_len
);
3012 if (beneath () == NULL
)
3014 /* This can happen when requesting the transfer of unsupported
3015 objects before a program has been started (and therefore
3016 with the current_target having no target beneath). */
3017 return TARGET_XFER_E_IO
;
3019 return beneath ()->xfer_partial (object
, annex
,
3020 readbuf
, writebuf
, offset
, len
,
3025 /* Provide thread local base, i.e. Thread Information Block address.
3026 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
3029 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
3031 windows_thread_info
*th
;
3033 th
= thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
);
3038 *addr
= th
->thread_local_base
;
3044 windows_nat_target::get_ada_task_ptid (long lwp
, ULONGEST thread
)
3046 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
3049 /* Implementation of the to_thread_name method. */
3052 windows_nat_target::thread_name (struct thread_info
*thr
)
3054 return thread_rec (thr
->ptid
, DONT_INVALIDATE_CONTEXT
)->name
.get ();
3058 void _initialize_windows_nat ();
3060 _initialize_windows_nat ()
3062 x86_dr_low
.set_control
= cygwin_set_dr7
;
3063 x86_dr_low
.set_addr
= cygwin_set_dr
;
3064 x86_dr_low
.get_addr
= cygwin_get_dr
;
3065 x86_dr_low
.get_status
= cygwin_get_dr6
;
3066 x86_dr_low
.get_control
= cygwin_get_dr7
;
3068 /* x86_dr_low.debug_register_length field is set by
3069 calling x86_set_debug_register_length function
3070 in processor windows specific native file. */
3072 add_inf_child_target (&the_windows_nat_target
);
3075 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3078 add_com ("signal-event", class_run
, signal_event_command
, _("\
3079 Signal a crashed process with event ID, to allow its debugging.\n\
3080 This command is needed in support of setting up GDB as JIT debugger on \
3081 MS-Windows. The command should be invoked from the GDB command line using \
3082 the '-ex' command-line option. The ID of the event that blocks the \
3083 crashed process will be supplied by the Windows JIT debugging mechanism."));
3086 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3087 Set use of shell to start subprocess."), _("\
3088 Show use of shell to start subprocess."), NULL
,
3090 NULL
, /* FIXME: i18n: */
3091 &setlist
, &showlist
);
3093 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3094 &cygwin_exceptions
, _("\
3095 Break when an exception is detected in the Cygwin DLL itself."), _("\
3096 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3098 NULL
, /* FIXME: i18n: */
3099 &setlist
, &showlist
);
3102 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3103 Set creation of new console when creating child process."), _("\
3104 Show creation of new console when creating child process."), NULL
,
3106 NULL
, /* FIXME: i18n: */
3107 &setlist
, &showlist
);
3109 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3110 Set creation of new group when creating child process."), _("\
3111 Show creation of new group when creating child process."), NULL
,
3113 NULL
, /* FIXME: i18n: */
3114 &setlist
, &showlist
);
3116 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3117 Set whether to display execution in child process."), _("\
3118 Show whether to display execution in child process."), NULL
,
3120 NULL
, /* FIXME: i18n: */
3121 &setlist
, &showlist
);
3123 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3124 Set whether to display kernel events in child process."), _("\
3125 Show whether to display kernel events in child process."), NULL
,
3127 NULL
, /* FIXME: i18n: */
3128 &setlist
, &showlist
);
3130 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3131 Set whether to display memory accesses in child process."), _("\
3132 Show whether to display memory accesses in child process."), NULL
,
3134 NULL
, /* FIXME: i18n: */
3135 &setlist
, &showlist
);
3137 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3138 &debug_exceptions
, _("\
3139 Set whether to display kernel exceptions in child process."), _("\
3140 Show whether to display kernel exceptions in child process."), NULL
,
3142 NULL
, /* FIXME: i18n: */
3143 &setlist
, &showlist
);
3145 init_w32_command_list ();
3147 add_cmd ("selector", class_info
, display_selectors
,
3148 _("Display selectors infos."),
3151 if (!initialize_loadable ())
3153 /* This will probably fail on Windows 9x/Me. Let the user know
3154 that we're missing some functionality. */
3156 cannot automatically find executable file or library to read symbols.\n\
3157 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3161 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3163 /* Pass the address ADDR to the inferior in the I'th debug register.
3164 Here we just store the address in dr array, the registers will be
3165 actually set up when windows_continue is called. */
3167 cygwin_set_dr (int i
, CORE_ADDR addr
)
3170 internal_error (__FILE__
, __LINE__
,
3171 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3174 for (windows_thread_info
*th
: thread_list
)
3175 th
->debug_registers_changed
= true;
3178 /* Pass the value VAL to the inferior in the DR7 debug control
3179 register. Here we just store the address in D_REGS, the watchpoint
3180 will be actually set up in windows_wait. */
3182 cygwin_set_dr7 (unsigned long val
)
3184 dr
[7] = (CORE_ADDR
) val
;
3186 for (windows_thread_info
*th
: thread_list
)
3187 th
->debug_registers_changed
= true;
3190 /* Get the value of debug register I from the inferior. */
3193 cygwin_get_dr (int i
)
3198 /* Get the value of the DR6 debug status register from the inferior.
3199 Here we just return the value stored in dr[6]
3200 by the last call to thread_rec for current_event.dwThreadId id. */
3201 static unsigned long
3202 cygwin_get_dr6 (void)
3204 return (unsigned long) dr
[6];
3207 /* Get the value of the DR7 debug status register from the inferior.
3208 Here we just return the value stored in dr[7] by the last call to
3209 thread_rec for current_event.dwThreadId id. */
3211 static unsigned long
3212 cygwin_get_dr7 (void)
3214 return (unsigned long) dr
[7];
3217 /* Determine if the thread referenced by "ptid" is alive
3218 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3219 it means that the thread has died. Otherwise it is assumed to be alive. */
3222 windows_nat_target::thread_alive (ptid_t ptid
)
3224 gdb_assert (ptid
.lwp () != 0);
3226 return (WaitForSingleObject (thread_rec (ptid
, DONT_INVALIDATE_CONTEXT
)->h
, 0)
3230 void _initialize_check_for_gdb_ini ();
3232 _initialize_check_for_gdb_ini ()
3235 if (inhibit_gdbinit
)
3238 homedir
= getenv ("HOME");
3242 char *oldini
= (char *) alloca (strlen (homedir
) +
3243 sizeof ("gdb.ini") + 1);
3244 strcpy (oldini
, homedir
);
3245 p
= strchr (oldini
, '\0');
3246 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3248 strcpy (p
, "gdb.ini");
3249 if (access (oldini
, 0) == 0)
3251 int len
= strlen (oldini
);
3252 char *newini
= (char *) alloca (len
+ 2);
3254 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3255 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3256 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);