1 /* Target-vector operations for controlling windows child processes, for GDB.
3 Copyright (C) 1995-2020 Free Software Foundation, Inc.
5 Contributed by Cygnus Solutions, A Red Hat Company.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 /* Originally by Steve Chamberlain, sac@cygnus.com */
25 #include "frame.h" /* required by inferior.h */
31 #include "completer.h"
35 #include <sys/types.h>
42 #include <sys/cygwin.h>
43 #include <cygwin/version.h>
47 #include "filenames.h"
51 #include "gdb_obstack.h"
52 #include "gdbthread.h"
58 #include "xml-support.h"
61 #include "i386-tdep.h"
62 #include "i387-tdep.h"
64 #include "windows-tdep.h"
65 #include "windows-nat.h"
67 #include "complaints.h"
68 #include "inf-child.h"
69 #include "gdbsupport/gdb_tilde_expand.h"
70 #include "gdbsupport/pathstuff.h"
71 #include "gdbsupport/gdb_wait.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
; /* Contains 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
;
231 static windows_thread_info thread_head
;
233 /* The process and thread handles for the above context. */
235 static DEBUG_EVENT current_event
; /* The current debug event from
237 static HANDLE current_process_handle
; /* Currently executing process */
238 static windows_thread_info
*current_thread
; /* Info on currently selected thread */
239 static EXCEPTION_RECORD siginfo_er
; /* Contents of $_siginfo */
241 /* Counts of things. */
242 static int exception_count
= 0;
243 static int event_count
= 0;
244 static int saw_create
;
245 static int open_process_used
= 0;
248 static bool new_console
= false;
250 static bool cygwin_exceptions
= false;
252 static bool new_group
= true;
253 static bool debug_exec
= false; /* show execution */
254 static bool debug_events
= false; /* show events from kernel */
255 static bool debug_memory
= false; /* show target memory accesses */
256 static bool debug_exceptions
= false; /* show target exceptions */
257 static bool useshell
= false; /* use shell for subprocesses */
259 /* This vector maps GDB's idea of a register's number into an offset
260 in the windows exception context vector.
262 It also contains the bit mask needed to load the register in question.
264 The contents of this table can only be computed by the units
265 that provide CPU-specific support for Windows native debugging.
266 These units should set the table by calling
267 windows_set_context_register_offsets.
269 One day we could read a reg, we could inspect the context we
270 already have loaded, if it doesn't have the bit set that we need,
271 we read that set of registers in using GetThreadContext. If the
272 context already contains what we need, we just unpack it. Then to
273 write a register, first we have to ensure that the context contains
274 the other regs of the group, and then we copy the info in and set
277 static const int *mappings
;
279 /* The function to use in order to determine whether a register is
280 a segment register or not. */
281 static segment_register_p_ftype
*segment_register_p
;
283 /* See windows_nat_target::resume to understand why this is commented
286 /* This vector maps the target's idea of an exception (extracted
287 from the DEBUG_EVENT structure) to GDB's idea. */
289 struct xlate_exception
295 static const struct xlate_exception xlate
[] =
297 {EXCEPTION_ACCESS_VIOLATION
, GDB_SIGNAL_SEGV
},
298 {STATUS_STACK_OVERFLOW
, GDB_SIGNAL_SEGV
},
299 {EXCEPTION_BREAKPOINT
, GDB_SIGNAL_TRAP
},
300 {DBG_CONTROL_C
, GDB_SIGNAL_INT
},
301 {EXCEPTION_SINGLE_STEP
, GDB_SIGNAL_TRAP
},
302 {STATUS_FLOAT_DIVIDE_BY_ZERO
, GDB_SIGNAL_FPE
}
307 struct windows_nat_target final
: public x86_nat_target
<inf_child_target
>
309 void close () override
;
311 void attach (const char *, int) override
;
313 bool attach_no_wait () override
316 void detach (inferior
*, int) override
;
318 void resume (ptid_t
, int , enum gdb_signal
) override
;
320 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
322 void fetch_registers (struct regcache
*, int) override
;
323 void store_registers (struct regcache
*, int) override
;
325 enum target_xfer_status
xfer_partial (enum target_object object
,
328 const gdb_byte
*writebuf
,
329 ULONGEST offset
, ULONGEST len
,
330 ULONGEST
*xfered_len
) override
;
332 void files_info () override
;
334 void kill () override
;
336 void create_inferior (const char *, const std::string
&,
337 char **, int) override
;
339 void mourn_inferior () override
;
341 bool thread_alive (ptid_t ptid
) override
;
343 std::string
pid_to_str (ptid_t
) override
;
345 void interrupt () override
;
347 char *pid_to_exec_file (int pid
) override
;
349 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
351 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
353 const char *thread_name (struct thread_info
*) override
;
355 int get_windows_debug_event (int pid
, struct target_waitstatus
*ourstatus
);
358 static windows_nat_target the_windows_nat_target
;
360 /* Set the MAPPINGS static global to OFFSETS.
361 See the description of MAPPINGS for more details. */
364 windows_set_context_register_offsets (const int *offsets
)
369 /* See windows-nat.h. */
372 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
374 segment_register_p
= fun
;
378 check (BOOL ok
, const char *file
, int line
)
381 printf_filtered ("error return %s:%d was %u\n", file
, line
,
382 (unsigned) GetLastError ());
385 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
386 then also retrieve the context for this thread. If GET_CONTEXT is
387 negative, then don't suspend the thread. */
388 static windows_thread_info
*
389 thread_rec (DWORD id
, int get_context
)
391 windows_thread_info
*th
;
393 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
396 if (!th
->suspended
&& get_context
)
398 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
400 if (SuspendThread (th
->h
) == (DWORD
) -1)
402 DWORD err
= GetLastError ();
404 /* We get Access Denied (5) when trying to suspend
405 threads that Windows started on behalf of the
406 debuggee, usually when those threads are just
408 We can get Invalid Handle (6) if the main thread
410 if (err
!= ERROR_INVALID_HANDLE
411 && err
!= ERROR_ACCESS_DENIED
)
412 warning (_("SuspendThread (tid=0x%x) failed."
414 (unsigned) id
, (unsigned) err
);
420 else if (get_context
< 0)
422 th
->reload_context
= 1;
430 /* Add a thread to the thread list.
432 PTID is the ptid of the thread to be added.
433 H is its Windows handle.
434 TLB is its thread local base.
435 MAIN_THREAD_P should be true if the thread to be added is
436 the main thread, false otherwise. */
438 static windows_thread_info
*
439 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
, bool main_thread_p
)
441 windows_thread_info
*th
;
444 gdb_assert (ptid
.tid () != 0);
448 if ((th
= thread_rec (id
, FALSE
)))
451 th
= XCNEW (windows_thread_info
);
454 th
->thread_local_base
= (CORE_ADDR
) (uintptr_t) tlb
;
455 th
->next
= thread_head
.next
;
456 thread_head
.next
= th
;
458 /* Add this new thread to the list of threads.
460 To be consistent with what's done on other platforms, we add
461 the main thread silently (in reality, this thread is really
462 more of a process to the user than a thread). */
464 add_thread_silent (&the_windows_nat_target
, ptid
);
466 add_thread (&the_windows_nat_target
, ptid
);
468 /* Set the debug registers for the new thread if they are used. */
469 if (debug_registers_used
)
471 /* Only change the value of the debug registers. */
472 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
473 CHECK (GetThreadContext (th
->h
, &th
->context
));
474 th
->context
.Dr0
= dr
[0];
475 th
->context
.Dr1
= dr
[1];
476 th
->context
.Dr2
= dr
[2];
477 th
->context
.Dr3
= dr
[3];
478 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
479 th
->context
.Dr7
= dr
[7];
480 CHECK (SetThreadContext (th
->h
, &th
->context
));
481 th
->context
.ContextFlags
= 0;
486 /* Clear out any old thread list and reinitialize it to a
489 windows_init_thread_list (void)
491 windows_thread_info
*th
= &thread_head
;
493 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
495 while (th
->next
!= NULL
)
497 windows_thread_info
*here
= th
->next
;
498 th
->next
= here
->next
;
501 thread_head
.next
= NULL
;
504 /* Delete a thread from the list of threads.
506 PTID is the ptid of the thread to be deleted.
507 EXIT_CODE is the thread's exit code.
508 MAIN_THREAD_P should be true if the thread to be deleted is
509 the main thread, false otherwise. */
512 windows_delete_thread (ptid_t ptid
, DWORD exit_code
, bool main_thread_p
)
514 windows_thread_info
*th
;
517 gdb_assert (ptid
.tid () != 0);
521 /* Emit a notification about the thread being deleted.
523 Note that no notification was printed when the main thread
524 was created, and thus, unless in verbose mode, we should be
525 symmetrical, and avoid that notification for the main thread
529 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
).c_str ());
530 else if (print_thread_events
&& !main_thread_p
)
531 printf_unfiltered (_("[%s exited with code %u]\n"),
532 target_pid_to_str (ptid
).c_str (),
533 (unsigned) exit_code
);
535 delete_thread (find_thread_ptid (&the_windows_nat_target
, ptid
));
537 for (th
= &thread_head
;
538 th
->next
!= NULL
&& th
->next
->id
!= id
;
542 if (th
->next
!= NULL
)
544 windows_thread_info
*here
= th
->next
;
545 th
->next
= here
->next
;
551 /* Fetches register number R from the given windows_thread_info,
552 and supplies its value to the given regcache.
554 This function assumes that R is non-negative. A failed assertion
555 is raised if that is not true.
557 This function assumes that TH->RELOAD_CONTEXT is not set, meaning
558 that the windows_thread_info has an up-to-date context. A failed
559 assertion is raised if that assumption is violated. */
562 windows_fetch_one_register (struct regcache
*regcache
,
563 windows_thread_info
*th
, int r
)
566 gdb_assert (!th
->reload_context
);
568 char *context_offset
= ((char *) &th
->context
) + mappings
[r
];
569 struct gdbarch
*gdbarch
= regcache
->arch ();
570 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
572 if (r
== I387_FISEG_REGNUM (tdep
))
574 long l
= *((long *) context_offset
) & 0xffff;
575 regcache
->raw_supply (r
, (char *) &l
);
577 else if (r
== I387_FOP_REGNUM (tdep
))
579 long l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
580 regcache
->raw_supply (r
, (char *) &l
);
582 else if (segment_register_p (r
))
584 /* GDB treats segment registers as 32bit registers, but they are
585 in fact only 16 bits long. Make sure we do not read extra
586 bits from our source buffer. */
587 long l
= *((long *) context_offset
) & 0xffff;
588 regcache
->raw_supply (r
, (char *) &l
);
591 regcache
->raw_supply (r
, context_offset
);
595 windows_nat_target::fetch_registers (struct regcache
*regcache
, int r
)
597 DWORD tid
= regcache
->ptid ().tid ();
598 windows_thread_info
*th
= thread_rec (tid
, TRUE
);
600 /* Check if TH exists. Windows sometimes uses a non-existent
601 thread id in its events. */
605 if (th
->reload_context
)
608 if (have_saved_context
)
610 /* Lie about where the program actually is stopped since
611 cygwin has informed us that we should consider the signal
612 to have occurred at another location which is stored in
614 memcpy (&th
->context
, &saved_context
,
615 __COPY_CONTEXT_SIZE
);
616 have_saved_context
= 0;
621 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
622 CHECK (GetThreadContext (th
->h
, &th
->context
));
623 /* Copy dr values from that thread.
624 But only if there were not modified since last stop.
626 if (!debug_registers_changed
)
628 dr
[0] = th
->context
.Dr0
;
629 dr
[1] = th
->context
.Dr1
;
630 dr
[2] = th
->context
.Dr2
;
631 dr
[3] = th
->context
.Dr3
;
632 dr
[6] = th
->context
.Dr6
;
633 dr
[7] = th
->context
.Dr7
;
636 th
->reload_context
= 0;
640 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch()); r
++)
641 windows_fetch_one_register (regcache
, th
, r
);
643 windows_fetch_one_register (regcache
, th
, r
);
646 /* Collect the register number R from the given regcache, and store
647 its value into the corresponding area of the given thread's context.
649 This function assumes that R is non-negative. A failed assertion
650 assertion is raised if that is not true. */
653 windows_store_one_register (const struct regcache
*regcache
,
654 windows_thread_info
*th
, int r
)
658 regcache
->raw_collect (r
, ((char *) &th
->context
) + mappings
[r
]);
661 /* Store a new register value into the context of the thread tied to
665 windows_nat_target::store_registers (struct regcache
*regcache
, int r
)
667 DWORD tid
= regcache
->ptid ().tid ();
668 windows_thread_info
*th
= thread_rec (tid
, TRUE
);
670 /* Check if TH exists. Windows sometimes uses a non-existent
671 thread id in its events. */
676 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch ()); r
++)
677 windows_store_one_register (regcache
, th
, r
);
679 windows_store_one_register (regcache
, th
, r
);
682 /* Maintain a linked list of "so" information. */
683 struct lm_info_windows
: public lm_info_base
685 LPVOID load_addr
= 0;
686 CORE_ADDR text_offset
= 0;
689 static struct so_list solib_start
, *solib_end
;
691 static struct so_list
*
692 windows_make_so (const char *name
, LPVOID load_addr
)
699 WIN32_FIND_DATA w32_fd
;
700 HANDLE h
= FindFirstFile(name
, &w32_fd
);
702 if (h
== INVALID_HANDLE_VALUE
)
708 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
710 p
= strrchr (buf
, '\\');
713 SetCurrentDirectory (buf
);
714 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
715 SetCurrentDirectory (cwd
);
718 if (strcasecmp (buf
, "ntdll.dll") == 0)
720 GetSystemDirectory (buf
, sizeof (buf
));
721 strcat (buf
, "\\ntdll.dll");
724 cygwin_buf_t buf
[__PMAX
];
727 if (access (name
, F_OK
) != 0)
729 if (strcasecmp (name
, "ntdll.dll") == 0)
732 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
733 wcscat (buf
, L
"\\ntdll.dll");
737 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
738 strcat (buf
, "\\ntdll.dll");
743 so
= XCNEW (struct so_list
);
744 lm_info_windows
*li
= new lm_info_windows
;
746 li
->load_addr
= load_addr
;
747 strcpy (so
->so_original_name
, name
);
749 strcpy (so
->so_name
, buf
);
752 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
753 SO_NAME_MAX_PATH_SIZE
);
756 char *rname
= realpath (name
, NULL
);
757 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
759 strcpy (so
->so_name
, rname
);
763 error (_("dll path too long"));
765 /* Record cygwin1.dll .text start/end. */
766 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
767 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
769 asection
*text
= NULL
;
771 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386", -1));
776 if (bfd_check_format (abfd
.get (), bfd_object
))
777 text
= bfd_get_section_by_name (abfd
.get (), ".text");
782 /* The symbols in a dll are offset by 0x1000, which is the
783 offset from 0 of the first byte in an image - because of the
784 file header and the section alignment. */
785 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
787 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (text
);
795 get_image_name (HANDLE h
, void *address
, int unicode
)
798 static char buf
[__PMAX
];
800 static char buf
[(2 * __PMAX
) + 1];
802 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
808 /* Attempt to read the name of the dll that was detected.
809 This is documented to work only when actively debugging
810 a program. It will not work for attached processes. */
814 /* See if we could read the address of a string, and that the
815 address isn't null. */
816 if (!ReadProcessMemory (h
, address
, &address_ptr
,
817 sizeof (address_ptr
), &done
)
818 || done
!= sizeof (address_ptr
) || !address_ptr
)
821 /* Find the length of the string. */
822 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
823 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
827 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
830 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
831 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
834 wcstombs (buf
, unicode_address
, __PMAX
);
836 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
844 /* Handle a DLL load event, and return 1.
846 This function assumes that this event did not occur during inferior
847 initialization, where their event info may be incomplete (see
848 do_initial_windows_stuff and windows_add_all_dlls for more info
849 on how we handle DLL loading during that phase). */
854 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
857 /* Try getting the DLL name via the lpImageName field of the event.
858 Note that Microsoft documents this fields as strictly optional,
859 in the sense that it might be NULL. And the first DLL event in
860 particular is explicitly documented as "likely not pass[ed]"
861 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
862 dll_name
= get_image_name (current_process_handle
,
863 event
->lpImageName
, event
->fUnicode
);
867 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
868 solib_end
= solib_end
->next
;
870 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
872 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
873 host_address_to_string (li
->load_addr
)));
877 windows_free_so (struct so_list
*so
)
879 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
885 /* Handle a DLL unload event.
886 Return 1 if successful, or zero otherwise.
888 This function assumes that this event did not occur during inferior
889 initialization, where their event info may be incomplete (see
890 do_initial_windows_stuff and windows_add_all_dlls for more info
891 on how we handle DLL loading during that phase). */
896 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
899 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
901 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
903 if (li_next
->load_addr
== lpBaseOfDll
)
905 struct so_list
*sodel
= so
->next
;
907 so
->next
= sodel
->next
;
910 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
912 windows_free_so (sodel
);
917 /* We did not find any DLL that was previously loaded at this address,
918 so register a complaint. We do not report an error, because we have
919 observed that this may be happening under some circumstances. For
920 instance, running 32bit applications on x64 Windows causes us to receive
921 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
922 events are apparently caused by the WOW layer, the interface between
923 32bit and 64bit worlds). */
924 complaint (_("dll starting at %s not found."),
925 host_address_to_string (lpBaseOfDll
));
928 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
932 catch_errors (void (*func
) ())
938 catch (const gdb_exception
&ex
)
940 exception_print (gdb_stderr
, ex
);
944 /* Clear list of loaded DLLs. */
946 windows_clear_solib (void)
950 for (so
= solib_start
.next
; so
; so
= solib_start
.next
)
952 solib_start
.next
= so
->next
;
953 windows_free_so (so
);
956 solib_end
= &solib_start
;
960 signal_event_command (const char *args
, int from_tty
)
962 uintptr_t event_id
= 0;
963 char *endargs
= NULL
;
966 error (_("signal-event requires an argument (integer event id)"));
968 event_id
= strtoumax (args
, &endargs
, 10);
970 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
971 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
972 error (_("Failed to convert `%s' to event id"), args
);
974 SetEvent ((HANDLE
) event_id
);
975 CloseHandle ((HANDLE
) event_id
);
978 /* Handle DEBUG_STRING output from child process.
979 Cygwin prepends its messages with a "cygwin:". Interpret this as
980 a Cygwin signal. Otherwise just print the string as a warning. */
982 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
984 gdb::unique_xmalloc_ptr
<char> s
;
987 if (!target_read_string
988 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
990 || !s
|| !*(s
.get ()))
992 else if (!startswith (s
.get (), _CYGWIN_SIGNAL_STRING
))
995 if (!startswith (s
.get (), "cYg"))
998 char *p
= strchr (s
.get (), '\0');
1000 if (p
> s
.get () && *--p
== '\n')
1002 warning (("%s"), s
.get ());
1008 /* Got a cygwin signal marker. A cygwin signal is followed by
1009 the signal number itself and then optionally followed by the
1010 thread id and address to saved context within the DLL. If
1011 these are supplied, then the given thread is assumed to have
1012 issued the signal and the context from the thread is assumed
1013 to be stored at the given address in the inferior. Tell gdb
1014 to treat this like a real signal. */
1016 int sig
= strtol (s
.get () + sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
1017 gdb_signal gotasig
= gdb_signal_from_host (sig
);
1019 ourstatus
->value
.sig
= gotasig
;
1025 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1026 retval
= strtoul (p
, &p
, 0);
1028 retval
= current_event
.dwThreadId
;
1029 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
1030 && ReadProcessMemory (current_process_handle
, x
,
1032 __COPY_CONTEXT_SIZE
, &n
)
1033 && n
== __COPY_CONTEXT_SIZE
)
1034 have_saved_context
= 1;
1043 display_selector (HANDLE thread
, DWORD sel
)
1046 if (GetThreadSelectorEntry (thread
, sel
, &info
))
1049 printf_filtered ("0x%03x: ", (unsigned) sel
);
1050 if (!info
.HighWord
.Bits
.Pres
)
1052 puts_filtered ("Segment not present\n");
1055 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1056 (info
.HighWord
.Bits
.BaseMid
<< 16)
1058 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1059 if (info
.HighWord
.Bits
.Granularity
)
1060 limit
= (limit
<< 12) | 0xfff;
1061 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1062 if (info
.HighWord
.Bits
.Default_Big
)
1063 puts_filtered(" 32-bit ");
1065 puts_filtered(" 16-bit ");
1066 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1069 puts_filtered ("Data (Read-Only, Exp-up");
1072 puts_filtered ("Data (Read/Write, Exp-up");
1075 puts_filtered ("Unused segment (");
1078 puts_filtered ("Data (Read/Write, Exp-down");
1081 puts_filtered ("Code (Exec-Only, N.Conf");
1084 puts_filtered ("Code (Exec/Read, N.Conf");
1087 puts_filtered ("Code (Exec-Only, Conf");
1090 puts_filtered ("Code (Exec/Read, Conf");
1093 printf_filtered ("Unknown type 0x%lx",
1094 (unsigned long) info
.HighWord
.Bits
.Type
);
1096 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1097 puts_filtered(", N.Acc");
1098 puts_filtered (")\n");
1099 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1100 puts_filtered("System selector ");
1101 printf_filtered ("Priviledge level = %ld. ",
1102 (unsigned long) info
.HighWord
.Bits
.Dpl
);
1103 if (info
.HighWord
.Bits
.Granularity
)
1104 puts_filtered ("Page granular.\n");
1106 puts_filtered ("Byte granular.\n");
1111 DWORD err
= GetLastError ();
1112 if (err
== ERROR_NOT_SUPPORTED
)
1113 printf_filtered ("Function not supported\n");
1115 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1121 display_selectors (const char * args
, int from_tty
)
1123 if (!current_thread
)
1125 puts_filtered ("Impossible to display selectors now.\n");
1131 puts_filtered ("Selector $cs\n");
1132 display_selector (current_thread
->h
,
1133 current_thread
->context
.SegCs
);
1134 puts_filtered ("Selector $ds\n");
1135 display_selector (current_thread
->h
,
1136 current_thread
->context
.SegDs
);
1137 puts_filtered ("Selector $es\n");
1138 display_selector (current_thread
->h
,
1139 current_thread
->context
.SegEs
);
1140 puts_filtered ("Selector $ss\n");
1141 display_selector (current_thread
->h
,
1142 current_thread
->context
.SegSs
);
1143 puts_filtered ("Selector $fs\n");
1144 display_selector (current_thread
->h
,
1145 current_thread
->context
.SegFs
);
1146 puts_filtered ("Selector $gs\n");
1147 display_selector (current_thread
->h
,
1148 current_thread
->context
.SegGs
);
1153 sel
= parse_and_eval_long (args
);
1154 printf_filtered ("Selector \"%s\"\n",args
);
1155 display_selector (current_thread
->h
, sel
);
1159 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1160 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1161 host_address_to_string (\
1162 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1164 static handle_exception_result
1165 handle_exception (struct target_waitstatus
*ourstatus
)
1167 EXCEPTION_RECORD
*rec
= ¤t_event
.u
.Exception
.ExceptionRecord
;
1168 DWORD code
= rec
->ExceptionCode
;
1169 handle_exception_result result
= HANDLE_EXCEPTION_HANDLED
;
1171 memcpy (&siginfo_er
, rec
, sizeof siginfo_er
);
1173 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1175 /* Record the context of the current thread. */
1176 thread_rec (current_event
.dwThreadId
, -1);
1180 case EXCEPTION_ACCESS_VIOLATION
:
1181 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1182 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1185 /* See if the access violation happened within the cygwin DLL
1186 itself. Cygwin uses a kind of exception handling to deal
1187 with passed-in invalid addresses. gdb should not treat
1188 these as real SEGVs since they will be silently handled by
1189 cygwin. A real SEGV will (theoretically) be caught by
1190 cygwin later in the process and will be sent as a
1191 cygwin-specific-signal. So, ignore SEGVs if they show up
1192 within the text segment of the DLL itself. */
1194 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1196 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1197 && addr
< cygwin_load_end
))
1198 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1199 && startswith (fn
, "KERNEL32!IsBad")))
1200 return HANDLE_EXCEPTION_UNHANDLED
;
1204 case STATUS_STACK_OVERFLOW
:
1205 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1206 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1208 case STATUS_FLOAT_DENORMAL_OPERAND
:
1209 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1210 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1212 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1213 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1214 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1216 case STATUS_FLOAT_INEXACT_RESULT
:
1217 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1218 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1220 case STATUS_FLOAT_INVALID_OPERATION
:
1221 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1222 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1224 case STATUS_FLOAT_OVERFLOW
:
1225 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1226 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1228 case STATUS_FLOAT_STACK_CHECK
:
1229 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1230 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1232 case STATUS_FLOAT_UNDERFLOW
:
1233 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1234 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1236 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1237 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1238 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1240 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1241 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1242 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1244 case STATUS_INTEGER_OVERFLOW
:
1245 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1246 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1248 case EXCEPTION_BREAKPOINT
:
1249 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1250 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1253 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1254 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1256 case DBG_CONTROL_BREAK
:
1257 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1258 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1260 case EXCEPTION_SINGLE_STEP
:
1261 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1262 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1264 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1265 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1266 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1268 case EXCEPTION_PRIV_INSTRUCTION
:
1269 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1270 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1272 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1273 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1274 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1276 case MS_VC_EXCEPTION
:
1277 if (rec
->NumberParameters
>= 3
1278 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1280 DWORD named_thread_id
;
1281 windows_thread_info
*named_thread
;
1282 CORE_ADDR thread_name_target
;
1284 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1286 thread_name_target
= rec
->ExceptionInformation
[1];
1287 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1289 if (named_thread_id
== (DWORD
) -1)
1290 named_thread_id
= current_event
.dwThreadId
;
1292 named_thread
= thread_rec (named_thread_id
, 0);
1293 if (named_thread
!= NULL
)
1295 int thread_name_len
;
1296 gdb::unique_xmalloc_ptr
<char> thread_name
;
1298 thread_name_len
= target_read_string (thread_name_target
,
1299 &thread_name
, 1025, NULL
);
1300 if (thread_name_len
> 0)
1302 thread_name
.get ()[thread_name_len
- 1] = '\0';
1303 xfree (named_thread
->name
);
1304 named_thread
->name
= thread_name
.release ();
1307 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1308 result
= HANDLE_EXCEPTION_IGNORED
;
1311 /* treat improperly formed exception as unknown */
1314 /* Treat unhandled first chance exceptions specially. */
1315 if (current_event
.u
.Exception
.dwFirstChance
)
1316 return HANDLE_EXCEPTION_UNHANDLED
;
1317 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1318 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1319 host_address_to_string (
1320 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1321 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1325 last_sig
= ourstatus
->value
.sig
;
1329 /* Resume thread specified by ID, or all artificially suspended
1330 threads, if we are continuing execution. KILLED non-zero means we
1331 have killed the inferior, so we should ignore weird errors due to
1332 threads shutting down. */
1334 windows_continue (DWORD continue_status
, int id
, int killed
)
1336 windows_thread_info
*th
;
1339 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1340 (unsigned) current_event
.dwProcessId
,
1341 (unsigned) current_event
.dwThreadId
,
1342 continue_status
== DBG_CONTINUE
?
1343 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1345 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1346 if ((id
== -1 || id
== (int) th
->id
)
1349 if (debug_registers_changed
)
1351 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1352 th
->context
.Dr0
= dr
[0];
1353 th
->context
.Dr1
= dr
[1];
1354 th
->context
.Dr2
= dr
[2];
1355 th
->context
.Dr3
= dr
[3];
1356 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1357 th
->context
.Dr7
= dr
[7];
1359 if (th
->context
.ContextFlags
)
1363 if (GetExitCodeThread (th
->h
, &ec
)
1364 && ec
== STILL_ACTIVE
)
1366 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1371 th
->context
.ContextFlags
= 0;
1373 if (th
->suspended
> 0)
1374 (void) ResumeThread (th
->h
);
1378 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1379 current_event
.dwThreadId
,
1383 error (_("Failed to resume program execution"
1384 " (ContinueDebugEvent failed, error %u)"),
1385 (unsigned int) GetLastError ());
1387 debug_registers_changed
= 0;
1391 /* Called in pathological case where Windows fails to send a
1392 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1394 fake_create_process (void)
1396 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1397 current_event
.dwProcessId
);
1398 if (current_process_handle
!= NULL
)
1399 open_process_used
= 1;
1402 error (_("OpenProcess call failed, GetLastError = %u"),
1403 (unsigned) GetLastError ());
1404 /* We can not debug anything in that case. */
1407 = windows_add_thread (ptid_t (current_event
.dwProcessId
, 0,
1408 current_event
.dwThreadId
),
1409 current_event
.u
.CreateThread
.hThread
,
1410 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1411 true /* main_thread_p */);
1412 return current_event
.dwThreadId
;
1416 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1418 windows_thread_info
*th
;
1419 DWORD continue_status
= DBG_CONTINUE
;
1421 /* A specific PTID means `step only this thread id'. */
1422 int resume_all
= ptid
== minus_one_ptid
;
1424 /* If we're continuing all threads, it's the current inferior that
1425 should be handled specially. */
1427 ptid
= inferior_ptid
;
1429 if (sig
!= GDB_SIGNAL_0
)
1431 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1433 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1435 else if (sig
== last_sig
)
1436 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1439 /* This code does not seem to work, because
1440 the kernel does probably not consider changes in the ExceptionRecord
1441 structure when passing the exception to the inferior.
1442 Note that this seems possible in the exception handler itself. */
1444 for (const xlate_exception
&x
: xlate
)
1447 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1449 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1452 if (continue_status
== DBG_CONTINUE
)
1454 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1458 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1462 last_sig
= GDB_SIGNAL_0
;
1464 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=0x%x, step=%d, sig=%d);\n",
1465 ptid
.pid (), (unsigned) ptid
.tid (), step
, sig
));
1467 /* Get context for currently selected thread. */
1468 th
= thread_rec (inferior_ptid
.tid (), FALSE
);
1473 /* Single step by setting t bit. */
1474 struct regcache
*regcache
= get_current_regcache ();
1475 struct gdbarch
*gdbarch
= regcache
->arch ();
1476 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1477 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1480 if (th
->context
.ContextFlags
)
1482 if (debug_registers_changed
)
1484 th
->context
.Dr0
= dr
[0];
1485 th
->context
.Dr1
= dr
[1];
1486 th
->context
.Dr2
= dr
[2];
1487 th
->context
.Dr3
= dr
[3];
1488 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1489 th
->context
.Dr7
= dr
[7];
1491 CHECK (SetThreadContext (th
->h
, &th
->context
));
1492 th
->context
.ContextFlags
= 0;
1496 /* Allow continuing with the same signal that interrupted us.
1497 Otherwise complain. */
1500 windows_continue (continue_status
, -1, 0);
1502 windows_continue (continue_status
, ptid
.tid (), 0);
1505 /* Ctrl-C handler used when the inferior is not run in the same console. The
1506 handler is in charge of interrupting the inferior using DebugBreakProcess.
1507 Note that this function is not available prior to Windows XP. In this case
1508 we emit a warning. */
1510 ctrl_c_handler (DWORD event_type
)
1512 const int attach_flag
= current_inferior ()->attach_flag
;
1514 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1515 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1518 /* If the inferior and the debugger share the same console, do nothing as
1519 the inferior has also received the Ctrl-C event. */
1520 if (!new_console
&& !attach_flag
)
1523 if (!DebugBreakProcess (current_process_handle
))
1524 warning (_("Could not interrupt program. "
1525 "Press Ctrl-c in the program console."));
1527 /* Return true to tell that Ctrl-C has been handled. */
1531 /* Get the next event from the child. Returns a non-zero thread id if the event
1532 requires handling by WFI (or whatever). */
1535 windows_nat_target::get_windows_debug_event (int pid
,
1536 struct target_waitstatus
*ourstatus
)
1539 DWORD continue_status
, event_code
;
1540 windows_thread_info
*th
;
1541 static windows_thread_info dummy_thread_info
;
1542 DWORD thread_id
= 0;
1544 last_sig
= GDB_SIGNAL_0
;
1546 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1550 continue_status
= DBG_CONTINUE
;
1552 event_code
= current_event
.dwDebugEventCode
;
1553 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1555 have_saved_context
= 0;
1559 case CREATE_THREAD_DEBUG_EVENT
:
1560 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1561 (unsigned) current_event
.dwProcessId
,
1562 (unsigned) current_event
.dwThreadId
,
1563 "CREATE_THREAD_DEBUG_EVENT"));
1564 if (saw_create
!= 1)
1566 inferior
*inf
= find_inferior_pid (this, current_event
.dwProcessId
);
1567 if (!saw_create
&& inf
->attach_flag
)
1569 /* Kludge around a Windows bug where first event is a create
1570 thread event. Caused when attached process does not have
1572 thread_id
= fake_create_process ();
1578 /* Record the existence of this thread. */
1579 thread_id
= current_event
.dwThreadId
;
1580 th
= windows_add_thread
1581 (ptid_t (current_event
.dwProcessId
, 0, current_event
.dwThreadId
),
1582 current_event
.u
.CreateThread
.hThread
,
1583 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1584 false /* main_thread_p */);
1588 case EXIT_THREAD_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_THREAD_DEBUG_EVENT"));
1593 windows_delete_thread (ptid_t (current_event
.dwProcessId
, 0,
1594 current_event
.dwThreadId
),
1595 current_event
.u
.ExitThread
.dwExitCode
,
1596 false /* main_thread_p */);
1597 th
= &dummy_thread_info
;
1600 case CREATE_PROCESS_DEBUG_EVENT
:
1601 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1602 (unsigned) current_event
.dwProcessId
,
1603 (unsigned) current_event
.dwThreadId
,
1604 "CREATE_PROCESS_DEBUG_EVENT"));
1605 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1606 if (++saw_create
!= 1)
1609 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1610 /* Add the main thread. */
1611 th
= windows_add_thread
1612 (ptid_t (current_event
.dwProcessId
, 0,
1613 current_event
.dwThreadId
),
1614 current_event
.u
.CreateProcessInfo
.hThread
,
1615 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
,
1616 true /* main_thread_p */);
1617 thread_id
= current_event
.dwThreadId
;
1620 case EXIT_PROCESS_DEBUG_EVENT
:
1621 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1622 (unsigned) current_event
.dwProcessId
,
1623 (unsigned) current_event
.dwThreadId
,
1624 "EXIT_PROCESS_DEBUG_EVENT"));
1625 if (!windows_initialization_done
)
1627 target_terminal::ours ();
1628 target_mourn_inferior (inferior_ptid
);
1629 error (_("During startup program exited with code 0x%x."),
1630 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1632 else if (saw_create
== 1)
1634 windows_delete_thread (ptid_t (current_event
.dwProcessId
, 0,
1635 current_event
.dwThreadId
),
1636 0, true /* main_thread_p */);
1637 DWORD exit_status
= current_event
.u
.ExitProcess
.dwExitCode
;
1638 /* If the exit status looks like a fatal exception, but we
1639 don't recognize the exception's code, make the original
1640 exit status value available, to avoid losing
1643 = WIFSIGNALED (exit_status
) ? WTERMSIG (exit_status
) : -1;
1644 if (exit_signal
== -1)
1646 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1647 ourstatus
->value
.integer
= exit_status
;
1651 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1652 ourstatus
->value
.sig
= gdb_signal_from_host (exit_signal
);
1654 thread_id
= current_event
.dwThreadId
;
1658 case LOAD_DLL_DEBUG_EVENT
:
1659 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1660 (unsigned) current_event
.dwProcessId
,
1661 (unsigned) current_event
.dwThreadId
,
1662 "LOAD_DLL_DEBUG_EVENT"));
1663 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1664 if (saw_create
!= 1 || ! windows_initialization_done
)
1666 catch_errors (handle_load_dll
);
1667 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1668 ourstatus
->value
.integer
= 0;
1669 thread_id
= current_event
.dwThreadId
;
1672 case UNLOAD_DLL_DEBUG_EVENT
:
1673 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1674 (unsigned) current_event
.dwProcessId
,
1675 (unsigned) current_event
.dwThreadId
,
1676 "UNLOAD_DLL_DEBUG_EVENT"));
1677 if (saw_create
!= 1 || ! windows_initialization_done
)
1679 catch_errors (handle_unload_dll
);
1680 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1681 ourstatus
->value
.integer
= 0;
1682 thread_id
= current_event
.dwThreadId
;
1685 case EXCEPTION_DEBUG_EVENT
:
1686 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1687 (unsigned) current_event
.dwProcessId
,
1688 (unsigned) current_event
.dwThreadId
,
1689 "EXCEPTION_DEBUG_EVENT"));
1690 if (saw_create
!= 1)
1692 switch (handle_exception (ourstatus
))
1694 case HANDLE_EXCEPTION_UNHANDLED
:
1696 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1698 case HANDLE_EXCEPTION_HANDLED
:
1699 thread_id
= current_event
.dwThreadId
;
1701 case HANDLE_EXCEPTION_IGNORED
:
1702 continue_status
= DBG_CONTINUE
;
1707 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1708 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1709 (unsigned) current_event
.dwProcessId
,
1710 (unsigned) current_event
.dwThreadId
,
1711 "OUTPUT_DEBUG_STRING_EVENT"));
1712 if (saw_create
!= 1)
1714 thread_id
= handle_output_debug_string (ourstatus
);
1718 if (saw_create
!= 1)
1720 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1721 (unsigned) current_event
.dwProcessId
,
1722 (unsigned) current_event
.dwThreadId
);
1723 printf_unfiltered (" unknown event code %u\n",
1724 (unsigned) current_event
.dwDebugEventCode
);
1728 if (!thread_id
|| saw_create
!= 1)
1730 CHECK (windows_continue (continue_status
, -1, 0));
1734 inferior_ptid
= ptid_t (current_event
.dwProcessId
, 0, thread_id
);
1735 current_thread
= th
;
1736 if (!current_thread
)
1737 current_thread
= thread_rec (thread_id
, TRUE
);
1744 /* Wait for interesting events to occur in the target process. */
1746 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1751 /* We loop when we get a non-standard exception rather than return
1752 with a SPURIOUS because resume can try and step or modify things,
1753 which needs a current_thread->h. But some of these exceptions mark
1754 the birth or death of threads, which mean that the current thread
1755 isn't necessarily what you think it is. */
1761 /* If the user presses Ctrl-c while the debugger is waiting
1762 for an event, he expects the debugger to interrupt his program
1763 and to get the prompt back. There are two possible situations:
1765 - The debugger and the program do not share the console, in
1766 which case the Ctrl-c event only reached the debugger.
1767 In that case, the ctrl_c handler will take care of interrupting
1768 the inferior. Note that this case is working starting with
1769 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1772 - The debugger and the program share the same console, in which
1773 case both debugger and inferior will receive the Ctrl-c event.
1774 In that case the ctrl_c handler will ignore the event, as the
1775 Ctrl-c event generated inside the inferior will trigger the
1776 expected debug event.
1778 FIXME: brobecker/2008-05-20: If the inferior receives the
1779 signal first and the delay until GDB receives that signal
1780 is sufficiently long, GDB can sometimes receive the SIGINT
1781 after we have unblocked the CTRL+C handler. This would
1782 lead to the debugger stopping prematurely while handling
1783 the new-thread event that comes with the handling of the SIGINT
1784 inside the inferior, and then stop again immediately when
1785 the user tries to resume the execution in the inferior.
1786 This is a classic race that we should try to fix one day. */
1787 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1788 retval
= get_windows_debug_event (pid
, ourstatus
);
1789 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1792 return ptid_t (current_event
.dwProcessId
, 0, retval
);
1797 if (deprecated_ui_loop_hook
!= NULL
)
1798 detach
= deprecated_ui_loop_hook (0);
1806 /* Iterate over all DLLs currently mapped by our inferior, and
1807 add them to our list of solibs. */
1810 windows_add_all_dlls (void)
1812 HMODULE dummy_hmodule
;
1817 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
1818 sizeof (HMODULE
), &cb_needed
) == 0)
1824 hmodules
= (HMODULE
*) alloca (cb_needed
);
1825 if (EnumProcessModules (current_process_handle
, hmodules
,
1826 cb_needed
, &cb_needed
) == 0)
1829 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
1833 wchar_t dll_name
[__PMAX
];
1836 char dll_name
[__PMAX
];
1839 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
1840 &mi
, sizeof (mi
)) == 0)
1842 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
1843 dll_name
, sizeof (dll_name
)) == 0)
1846 wcstombs (name
, dll_name
, __PMAX
);
1851 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
1852 solib_end
= solib_end
->next
;
1857 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1860 struct inferior
*inf
;
1862 last_sig
= GDB_SIGNAL_0
;
1864 exception_count
= 0;
1865 open_process_used
= 0;
1866 debug_registers_changed
= 0;
1867 debug_registers_used
= 0;
1868 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1871 cygwin_load_start
= cygwin_load_end
= 0;
1873 current_event
.dwProcessId
= pid
;
1874 memset (¤t_event
, 0, sizeof (current_event
));
1875 if (!target_is_pushed (ops
))
1877 disable_breakpoints_in_shlibs ();
1878 windows_clear_solib ();
1879 clear_proceed_status (0);
1880 init_wait_for_inferior ();
1882 inf
= current_inferior ();
1883 inferior_appeared (inf
, pid
);
1884 inf
->attach_flag
= attaching
;
1886 /* Make the new process the current inferior, so terminal handling
1887 can rely on it. When attaching, we don't know about any thread
1888 id here, but that's OK --- nothing should be referencing the
1889 current thread until we report an event out of windows_wait. */
1890 inferior_ptid
= ptid_t (pid
);
1892 target_terminal::init ();
1893 target_terminal::inferior ();
1895 windows_initialization_done
= 0;
1899 struct target_waitstatus status
;
1901 ops
->wait (minus_one_ptid
, &status
, 0);
1903 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
1905 if (status
.kind
!= TARGET_WAITKIND_LOADED
1906 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
1909 ops
->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
1912 /* Now that the inferior has been started and all DLLs have been mapped,
1913 we can iterate over all DLLs and load them in.
1915 We avoid doing it any earlier because, on certain versions of Windows,
1916 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
1917 we have seen on Windows 8.1 that the ntdll.dll load event does not
1918 include the DLL name, preventing us from creating an associated SO.
1919 A possible explanation is that ntdll.dll might be mapped before
1920 the SO info gets created by the Windows system -- ntdll.dll is
1921 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
1922 do not seem to suffer from that problem.
1924 Rather than try to work around this sort of issue, it is much
1925 simpler to just ignore DLL load/unload events during the startup
1926 phase, and then process them all in one batch now. */
1927 windows_add_all_dlls ();
1929 windows_initialization_done
= 1;
1933 /* Try to set or remove a user privilege to the current process. Return -1
1934 if that fails, the previous setting of that privilege otherwise.
1936 This code is copied from the Cygwin source code and rearranged to allow
1937 dynamically loading of the needed symbols from advapi32 which is only
1938 available on NT/2K/XP. */
1940 set_process_privilege (const char *privilege
, BOOL enable
)
1942 HANDLE token_hdl
= NULL
;
1944 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1948 if (!OpenProcessToken (GetCurrentProcess (),
1949 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1953 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
1956 new_priv
.PrivilegeCount
= 1;
1957 new_priv
.Privileges
[0].Luid
= restore_priv
;
1958 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1960 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1961 sizeof orig_priv
, &orig_priv
, &size
))
1964 /* Disabled, otherwise every `attach' in an unprivileged user session
1965 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1966 windows_attach(). */
1967 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1968 be enabled. GetLastError () returns an correct error code, though. */
1969 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1973 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1977 CloseHandle (token_hdl
);
1982 /* Attach to process PID, then initialize for debugging it. */
1985 windows_nat_target::attach (const char *args
, int from_tty
)
1990 pid
= parse_pid_to_attach (args
);
1992 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1994 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1995 printf_unfiltered ("This can cause attach to "
1996 "fail on Windows NT/2K/XP\n");
1999 windows_init_thread_list ();
2000 ok
= DebugActiveProcess (pid
);
2006 /* Try fall back to Cygwin pid. */
2007 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
2010 ok
= DebugActiveProcess (pid
);
2015 error (_("Can't attach to process %u (error %u)"),
2016 (unsigned) pid
, (unsigned) GetLastError ());
2018 DebugSetProcessKillOnExit (FALSE
);
2022 const char *exec_file
= get_exec_file (0);
2025 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
2026 target_pid_to_str (ptid_t (pid
)).c_str ());
2028 printf_unfiltered ("Attaching to %s\n",
2029 target_pid_to_str (ptid_t (pid
)).c_str ());
2032 do_initial_windows_stuff (this, pid
, 1);
2033 target_terminal::ours ();
2037 windows_nat_target::detach (inferior
*inf
, int from_tty
)
2041 ptid_t ptid
= minus_one_ptid
;
2042 resume (ptid
, 0, GDB_SIGNAL_0
);
2044 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
2046 error (_("Can't detach process %u (error %u)"),
2047 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
2050 DebugSetProcessKillOnExit (FALSE
);
2052 if (detached
&& from_tty
)
2054 const char *exec_file
= get_exec_file (0);
2057 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
2058 (unsigned) current_event
.dwProcessId
);
2061 x86_cleanup_dregs ();
2062 inferior_ptid
= null_ptid
;
2063 detach_inferior (inf
);
2065 maybe_unpush_target ();
2068 /* Try to determine the executable filename.
2070 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2072 Upon success, the filename is stored inside EXE_NAME_RET, and
2073 this function returns nonzero.
2075 Otherwise, this function returns zero and the contents of
2076 EXE_NAME_RET is undefined. */
2079 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2086 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2087 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2090 /* We know the executable is always first in the list of modules,
2091 which we just fetched. So no need to fetch more. */
2095 /* Cygwin prefers that the path be in /x/y/z format, so extract
2096 the filename into a temporary buffer first, and then convert it
2097 to POSIX format into the destination buffer. */
2098 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2100 len
= GetModuleFileNameEx (current_process_handle
,
2101 dh_buf
, pathbuf
, exe_name_max_len
);
2103 error (_("Error getting executable filename: %u."),
2104 (unsigned) GetLastError ());
2105 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2106 exe_name_max_len
) < 0)
2107 error (_("Error converting executable filename to POSIX: %d."), errno
);
2110 len
= GetModuleFileNameEx (current_process_handle
,
2111 dh_buf
, exe_name_ret
, exe_name_max_len
);
2113 error (_("Error getting executable filename: %u."),
2114 (unsigned) GetLastError ());
2117 return 1; /* success */
2120 /* The pid_to_exec_file target_ops method for this platform. */
2123 windows_nat_target::pid_to_exec_file (int pid
)
2125 static char path
[__PMAX
];
2127 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2129 char procexe
[sizeof ("/proc/4294967295/exe")];
2131 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2132 nchars
= readlink (procexe
, path
, sizeof(path
));
2133 if (nchars
> 0 && nchars
< sizeof (path
))
2135 path
[nchars
] = '\0'; /* Got it */
2140 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2141 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2142 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2148 /* Print status information about what we're accessing. */
2151 windows_nat_target::files_info ()
2153 struct inferior
*inf
= current_inferior ();
2155 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2156 inf
->attach_flag
? "attached" : "child",
2157 target_pid_to_str (inferior_ptid
).c_str ());
2160 /* Modify CreateProcess parameters for use of a new separate console.
2162 *FLAGS: DWORD parameter for general process creation flags.
2163 *SI: STARTUPINFO structure, for which the console window size and
2164 console buffer size is filled in if GDB is running in a console.
2165 to create the new console.
2166 The size of the used font is not available on all versions of
2167 Windows OS. Furthermore, the current font might not be the default
2168 font, but this is still better than before.
2169 If the windows and buffer sizes are computed,
2170 SI->DWFLAGS is changed so that this information is used
2171 by CreateProcess function. */
2174 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2176 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2177 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2179 if (hconsole
!= INVALID_HANDLE_VALUE
)
2181 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2183 CONSOLE_FONT_INFO cfi
;
2185 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2186 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2187 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2188 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2189 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2191 si
->dwXSize
*= font_size
.X
;
2195 si
->dwYSize
*= font_size
.Y
;
2198 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2199 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2200 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2202 *flags
|= CREATE_NEW_CONSOLE
;
2206 /* Function called by qsort to sort environment strings. */
2209 envvar_cmp (const void *a
, const void *b
)
2211 const char **p
= (const char **) a
;
2212 const char **q
= (const char **) b
;
2213 return strcasecmp (*p
, *q
);
2219 clear_win32_environment (char **env
)
2223 wchar_t *copy
= NULL
, *equalpos
;
2225 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2227 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2228 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2229 mbstowcs (copy
, env
[i
], len
);
2230 equalpos
= wcschr (copy
, L
'=');
2233 SetEnvironmentVariableW (copy
, NULL
);
2241 /* Redirection of inferior I/O streams for native MS-Windows programs.
2242 Unlike on Unix, where this is handled by invoking the inferior via
2243 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2245 The official documentation of the cmd.exe redirection features is here:
2247 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2249 (That page talks about Windows XP, but there's no newer
2250 documentation, so we assume later versions of cmd.exe didn't change
2253 Caveat: the documentation on that page seems to include a few lies.
2254 For example, it describes strange constructs 1<&2 and 2<&1, which
2255 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2256 think the cmd.exe parser of the redirection symbols simply doesn't
2257 care about the < vs > distinction in these cases. Therefore, the
2258 supported features are explicitly documented below.
2260 The emulation below aims at supporting all the valid use cases
2261 supported by cmd.exe, which include:
2263 < FILE redirect standard input from FILE
2264 0< FILE redirect standard input from FILE
2265 <&N redirect standard input from file descriptor N
2266 0<&N redirect standard input from file descriptor N
2267 > FILE redirect standard output to FILE
2268 >> FILE append standard output to FILE
2269 1>> FILE append standard output to FILE
2270 >&N redirect standard output to file descriptor N
2271 1>&N redirect standard output to file descriptor N
2272 >>&N append standard output to file descriptor N
2273 1>>&N append standard output to file descriptor N
2274 2> FILE redirect standard error to FILE
2275 2>> FILE append standard error to FILE
2276 2>&N redirect standard error to file descriptor N
2277 2>>&N append standard error to file descriptor N
2279 Note that using N > 2 in the above construct is supported, but
2280 requires that the corresponding file descriptor be open by some
2281 means elsewhere or outside GDB. Also note that using ">&0" or
2282 "<&2" will generally fail, because the file descriptor redirected
2283 from is normally open in an incompatible mode (e.g., FD 0 is open
2284 for reading only). IOW, use of such tricks is not recommended;
2285 you are on your own.
2287 We do NOT support redirection of file descriptors above 2, as in
2288 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2289 that needs special handling in the startup code that MinGW
2290 doesn't have). Pipes are also not supported.
2292 As for invalid use cases, where the redirection contains some
2293 error, the emulation below will detect that and produce some
2294 error and/or failure. But the behavior in those cases is not
2295 bug-for-bug compatible with what cmd.exe does in those cases.
2296 That's because what cmd.exe does then is not well defined, and
2297 seems to be a side effect of the cmd.exe parsing of the command
2298 line more than anything else. For example, try redirecting to an
2299 invalid file name, as in "> foo:bar".
2301 There are also minor syntactic deviations from what cmd.exe does
2302 in some corner cases. For example, it doesn't support the likes
2303 of "> &foo" to mean redirect to file named literally "&foo"; we
2304 do support that here, because that, too, sounds like some issue
2305 with the cmd.exe parser. Another nicety is that we support
2306 redirection targets that use file names with forward slashes,
2307 something cmd.exe doesn't -- this comes in handy since GDB
2308 file-name completion can be used when typing the command line for
2311 /* Support routines for redirecting standard handles of the inferior. */
2313 /* Parse a single redirection spec, open/duplicate the specified
2314 file/fd, and assign the appropriate value to one of the 3 standard
2315 file descriptors. */
2317 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2319 int *fd
, ref_fd
= -2;
2321 const char *fname
= redir_string
+ 1;
2322 int rc
= *redir_string
;
2337 fd
= (rc
== '2') ? err
: out
;
2338 mode
= O_WRONLY
| O_CREAT
;
2351 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2353 /* A reference to a file descriptor. */
2355 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2356 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2358 /* Don't allow redirection when open modes are incompatible. */
2359 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2360 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2367 else if (ref_fd
== 1)
2369 else if (ref_fd
== 2)
2379 fname
++; /* skip the separator space */
2380 /* If the descriptor is already open, close it. This allows
2381 multiple specs of redirections for the same stream, which is
2382 somewhat nonsensical, but still valid and supported by cmd.exe.
2383 (But cmd.exe only opens a single file in this case, the one
2384 specified by the last redirection spec on the command line.) */
2389 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2393 else if (ref_fd
== -1)
2394 *fd
= -1; /* reset to default destination */
2397 *fd
= _dup (ref_fd
);
2401 /* _open just sets a flag for O_APPEND, which won't be passed to the
2402 inferior, so we need to actually move the file pointer. */
2403 if ((mode
& O_APPEND
) != 0)
2404 _lseek (*fd
, 0L, SEEK_END
);
2408 /* Canonicalize a single redirection spec and set up the corresponding
2409 file descriptor as specified. */
2411 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2413 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2415 const char *start
= s
;
2418 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2419 if ((*start
== '>' || *start
== '1' || *start
== '2')
2423 if (*s
== '>' && *start
!= '>')
2426 else if (*start
== '0' && *s
== '<')
2428 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2431 while (isspace (*s
)) /* skip whitespace before file name */
2433 *d
++ = ' '; /* separate file name with a single space */
2436 /* Copy the file name. */
2439 /* Remove quoting characters from the file name in buf[]. */
2440 if (*s
== '"') /* could support '..' quoting here */
2444 else if (*s
== quote
)
2452 else if (*s
== '\\')
2454 if (s
[1] == '"') /* could support '..' here */
2458 else if (isspace (*s
) && !quote
)
2462 if (d
- buf
>= sizeof (buf
) - 1)
2464 errno
= ENAMETOOLONG
;
2470 /* Windows doesn't allow redirection characters in file names, so we
2471 can bail out early if they use them, or if there's no target file
2472 name after the redirection symbol. */
2473 if (d
[-1] == '>' || d
[-1] == '<')
2478 if (redir_open (buf
, inp
, out
, err
) == 0)
2483 /* Parse the command line for redirection specs and prepare the file
2484 descriptors for the 3 standard streams accordingly. */
2486 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2487 int *inp
, int *out
, int *err
)
2489 const char *s
= cmd_orig
;
2492 bool retval
= false;
2494 while (isspace (*s
))
2499 if (*s
== '"') /* could also support '..' quoting here */
2503 else if (*s
== quote
)
2506 else if (*s
== '\\')
2508 if (s
[1] == '"') /* escaped quote char */
2513 /* Process a single redirection candidate. */
2514 if (*s
== '<' || *s
== '>'
2515 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2516 || (*s
== '0' && s
[1] == '<'))
2518 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2532 #endif /* !__CYGWIN__ */
2534 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2535 EXEC_FILE is the file to run.
2536 ALLARGS is a string containing the arguments to the program.
2537 ENV is the environment vector to pass. Errors reported with error(). */
2540 windows_nat_target::create_inferior (const char *exec_file
,
2541 const std::string
&origallargs
,
2542 char **in_env
, int from_tty
)
2546 cygwin_buf_t real_path
[__PMAX
];
2547 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2548 cygwin_buf_t infcwd
[__PMAX
];
2550 cygwin_buf_t
*toexec
;
2551 cygwin_buf_t
*cygallargs
;
2553 char **old_env
= NULL
;
2557 int ostdin
, ostdout
, ostderr
;
2558 #else /* !__CYGWIN__ */
2559 char shell
[__PMAX
]; /* Path to shell */
2561 char *args
, *allargs_copy
;
2562 size_t args_len
, allargs_len
;
2563 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2564 HANDLE tty
= INVALID_HANDLE_VALUE
;
2565 bool redirected
= false;
2572 #endif /* !__CYGWIN__ */
2573 const char *allargs
= origallargs
.c_str ();
2574 PROCESS_INFORMATION pi
;
2577 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2580 error (_("No executable specified, use `target exec'."));
2582 const char *inferior_cwd
= get_inferior_cwd ();
2583 std::string expanded_infcwd
;
2584 if (inferior_cwd
!= NULL
)
2586 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
2587 /* Mirror slashes on inferior's cwd. */
2588 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
2590 inferior_cwd
= expanded_infcwd
.c_str ();
2593 memset (&si
, 0, sizeof (si
));
2594 si
.cb
= sizeof (si
);
2597 flags
|= CREATE_NEW_PROCESS_GROUP
;
2600 windows_set_console_info (&si
, &flags
);
2605 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2606 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2607 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2608 error (_("Error starting executable: %d"), errno
);
2611 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2612 if (len
== (size_t) -1)
2613 error (_("Error starting executable: %d"), errno
);
2614 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2615 mbstowcs (cygallargs
, allargs
, len
);
2616 #else /* !__USEWIDE */
2617 cygallargs
= allargs
;
2623 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2624 error (_("Error starting executable via shell: %d"), errno
);
2626 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2627 + mbstowcs (NULL
, allargs
, 0) + 2;
2628 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2629 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2630 #else /* !__USEWIDE */
2631 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2632 + strlen (allargs
) + 2);
2633 cygallargs
= (char *) alloca (len
);
2634 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2635 #endif /* __USEWIDE */
2637 flags
|= DEBUG_PROCESS
;
2640 if (inferior_cwd
!= NULL
2641 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
2642 infcwd
, strlen (inferior_cwd
)) < 0)
2643 error (_("Error converting inferior cwd: %d"), errno
);
2646 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2647 * sizeof (wchar_t));
2648 wcscpy (args
, toexec
);
2649 wcscat (args
, L
" ");
2650 wcscat (args
, cygallargs
);
2651 #else /* !__USEWIDE */
2652 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2653 strcpy (args
, toexec
);
2655 strcat (args
, cygallargs
);
2656 #endif /* !__USEWIDE */
2658 #ifdef CW_CVT_ENV_TO_WINENV
2659 /* First try to create a direct Win32 copy of the POSIX environment. */
2660 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2661 if (w32_env
!= (PWCHAR
) -1)
2662 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2664 /* If that fails, fall back to old method tweaking GDB's environment. */
2665 #endif /* CW_CVT_ENV_TO_WINENV */
2667 /* Reset all Win32 environment variables to avoid leftover on next run. */
2668 clear_win32_environment (environ
);
2669 /* Prepare the environment vars for CreateProcess. */
2672 cygwin_internal (CW_SYNC_WINENV
);
2676 if (!inferior_io_terminal
)
2677 tty
= ostdin
= ostdout
= ostderr
= -1;
2680 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2683 print_sys_errmsg (inferior_io_terminal
, errno
);
2684 ostdin
= ostdout
= ostderr
= -1;
2697 windows_init_thread_list ();
2698 ret
= CreateProcess (0,
2699 args
, /* command line */
2700 NULL
, /* Security */
2702 TRUE
, /* inherit handles */
2703 flags
, /* start flags */
2704 w32_env
, /* environment */
2705 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
2710 /* Just free the Win32 environment, if it could be created. */
2714 /* Reset all environment variables to avoid leftover on next run. */
2715 clear_win32_environment (in_env
);
2716 /* Restore normal GDB environment variables. */
2718 cygwin_internal (CW_SYNC_WINENV
);
2731 #else /* !__CYGWIN__ */
2732 allargs_len
= strlen (allargs
);
2733 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
2734 if (strpbrk (allargs_copy
, "<>") != NULL
)
2739 redirect_inferior_handles (allargs
, allargs_copy
,
2740 &fd_inp
, &fd_out
, &fd_err
);
2742 warning (_("Error in redirection: %s."), safe_strerror (errno
));
2745 allargs_len
= strlen (allargs_copy
);
2747 /* If not all the standard streams are redirected by the command
2748 line, use inferior_io_terminal for those which aren't. */
2749 if (inferior_io_terminal
2750 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
2752 SECURITY_ATTRIBUTES sa
;
2753 sa
.nLength
= sizeof(sa
);
2754 sa
.lpSecurityDescriptor
= 0;
2755 sa
.bInheritHandle
= TRUE
;
2756 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2757 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2758 if (tty
== INVALID_HANDLE_VALUE
)
2759 warning (_("Warning: Failed to open TTY %s, error %#x."),
2760 inferior_io_terminal
, (unsigned) GetLastError ());
2762 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
2765 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
2766 else if (tty
!= INVALID_HANDLE_VALUE
)
2769 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
2771 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
2772 else if (tty
!= INVALID_HANDLE_VALUE
)
2773 si
.hStdOutput
= tty
;
2775 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
2777 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
2778 else if (tty
!= INVALID_HANDLE_VALUE
)
2781 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
2782 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2786 /* Build the command line, a space-separated list of tokens where
2787 the first token is the name of the module to be executed.
2788 To avoid ambiguities introduced by spaces in the module name,
2790 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
2791 args
= (char *) alloca (args_len
);
2792 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
2794 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2796 /* CreateProcess takes the environment list as a null terminated set of
2797 strings (i.e. two nulls terminate the list). */
2799 /* Get total size for env strings. */
2800 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2801 envlen
+= strlen (in_env
[i
]) + 1;
2803 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2804 env
= (char **) alloca (envsize
);
2805 memcpy (env
, in_env
, envsize
);
2806 /* Windows programs expect the environment block to be sorted. */
2807 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2809 w32env
= (char *) alloca (envlen
+ 1);
2811 /* Copy env strings into new buffer. */
2812 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2814 strcpy (temp
, env
[i
]);
2815 temp
+= strlen (temp
) + 1;
2818 /* Final nil string to terminate new env. */
2821 windows_init_thread_list ();
2822 ret
= CreateProcessA (0,
2823 args
, /* command line */
2824 NULL
, /* Security */
2826 TRUE
, /* inherit handles */
2827 flags
, /* start flags */
2828 w32env
, /* environment */
2829 inferior_cwd
, /* current directory */
2832 if (tty
!= INVALID_HANDLE_VALUE
)
2840 #endif /* !__CYGWIN__ */
2843 error (_("Error creating process %s, (error %u)."),
2844 exec_file
, (unsigned) GetLastError ());
2846 CloseHandle (pi
.hThread
);
2847 CloseHandle (pi
.hProcess
);
2849 if (useshell
&& shell
[0] != '\0')
2854 do_initial_windows_stuff (this, pi
.dwProcessId
, 0);
2856 /* windows_continue (DBG_CONTINUE, -1, 0); */
2860 windows_nat_target::mourn_inferior ()
2862 (void) windows_continue (DBG_CONTINUE
, -1, 0);
2863 x86_cleanup_dregs();
2864 if (open_process_used
)
2866 CHECK (CloseHandle (current_process_handle
));
2867 open_process_used
= 0;
2869 siginfo_er
.ExceptionCode
= 0;
2870 inf_child_target::mourn_inferior ();
2873 /* Send a SIGINT to the process group. This acts just like the user typed a
2874 ^C on the controlling terminal. */
2877 windows_nat_target::interrupt ()
2879 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2880 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
2881 registers_changed (); /* refresh register state */
2884 /* Helper for windows_xfer_partial that handles memory transfers.
2885 Arguments are like target_xfer_partial. */
2887 static enum target_xfer_status
2888 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2889 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2893 DWORD lasterror
= 0;
2895 if (writebuf
!= NULL
)
2897 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
2898 pulongest (len
), core_addr_to_string (memaddr
)));
2899 success
= WriteProcessMemory (current_process_handle
,
2900 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
2903 lasterror
= GetLastError ();
2904 FlushInstructionCache (current_process_handle
,
2905 (LPCVOID
) (uintptr_t) memaddr
, len
);
2909 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
2910 pulongest (len
), core_addr_to_string (memaddr
)));
2911 success
= ReadProcessMemory (current_process_handle
,
2912 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
2915 lasterror
= GetLastError ();
2917 *xfered_len
= (ULONGEST
) done
;
2918 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
2919 return TARGET_XFER_OK
;
2921 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
2925 windows_nat_target::kill ()
2927 CHECK (TerminateProcess (current_process_handle
, 0));
2931 if (!windows_continue (DBG_CONTINUE
, -1, 1))
2933 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
2935 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2939 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
2943 windows_nat_target::close ()
2945 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2946 inferior_ptid
.pid ()));
2949 /* Convert pid to printable format. */
2951 windows_nat_target::pid_to_str (ptid_t ptid
)
2953 if (ptid
.tid () != 0)
2954 return string_printf ("Thread %d.0x%lx", ptid
.pid (), ptid
.tid ());
2956 return normal_pid_to_str (ptid
);
2959 static enum target_xfer_status
2960 windows_xfer_shared_libraries (struct target_ops
*ops
,
2961 enum target_object object
, const char *annex
,
2962 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2963 ULONGEST offset
, ULONGEST len
,
2964 ULONGEST
*xfered_len
)
2966 struct obstack obstack
;
2972 return TARGET_XFER_E_IO
;
2974 obstack_init (&obstack
);
2975 obstack_grow_str (&obstack
, "<library-list>\n");
2976 for (so
= solib_start
.next
; so
; so
= so
->next
)
2978 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
2980 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
2981 (uintptr_t) li
->load_addr
,
2983 target_gdbarch (), &obstack
);
2985 obstack_grow_str0 (&obstack
, "</library-list>\n");
2987 buf
= (const char *) obstack_finish (&obstack
);
2988 len_avail
= strlen (buf
);
2989 if (offset
>= len_avail
)
2993 if (len
> len_avail
- offset
)
2994 len
= len_avail
- offset
;
2995 memcpy (readbuf
, buf
+ offset
, len
);
2998 obstack_free (&obstack
, NULL
);
2999 *xfered_len
= (ULONGEST
) len
;
3000 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
3003 /* Helper for windows_nat_target::xfer_partial that handles signal info. */
3005 static enum target_xfer_status
3006 windows_xfer_siginfo (gdb_byte
*readbuf
, ULONGEST offset
, ULONGEST len
,
3007 ULONGEST
*xfered_len
)
3009 if (siginfo_er
.ExceptionCode
== 0)
3010 return TARGET_XFER_E_IO
;
3012 if (readbuf
== nullptr)
3013 return TARGET_XFER_E_IO
;
3015 if (offset
> sizeof (siginfo_er
))
3016 return TARGET_XFER_E_IO
;
3018 if (offset
+ len
> sizeof (siginfo_er
))
3019 len
= sizeof (siginfo_er
) - offset
;
3021 memcpy (readbuf
, (char *) &siginfo_er
+ offset
, len
);
3024 return TARGET_XFER_OK
;
3027 enum target_xfer_status
3028 windows_nat_target::xfer_partial (enum target_object object
,
3029 const char *annex
, gdb_byte
*readbuf
,
3030 const gdb_byte
*writebuf
, ULONGEST offset
,
3031 ULONGEST len
, ULONGEST
*xfered_len
)
3035 case TARGET_OBJECT_MEMORY
:
3036 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
3038 case TARGET_OBJECT_LIBRARIES
:
3039 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
3040 writebuf
, offset
, len
, xfered_len
);
3042 case TARGET_OBJECT_SIGNAL_INFO
:
3043 return windows_xfer_siginfo (readbuf
, offset
, len
, xfered_len
);
3046 if (beneath () == NULL
)
3048 /* This can happen when requesting the transfer of unsupported
3049 objects before a program has been started (and therefore
3050 with the current_target having no target beneath). */
3051 return TARGET_XFER_E_IO
;
3053 return beneath ()->xfer_partial (object
, annex
,
3054 readbuf
, writebuf
, offset
, len
,
3059 /* Provide thread local base, i.e. Thread Information Block address.
3060 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
3063 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
3065 windows_thread_info
*th
;
3067 th
= thread_rec (ptid
.tid (), 0);
3072 *addr
= th
->thread_local_base
;
3078 windows_nat_target::get_ada_task_ptid (long lwp
, long thread
)
3080 return ptid_t (inferior_ptid
.pid (), 0, lwp
);
3083 /* Implementation of the to_thread_name method. */
3086 windows_nat_target::thread_name (struct thread_info
*thr
)
3088 return thread_rec (thr
->ptid
.tid (), 0)->name
;
3092 void _initialize_windows_nat ();
3094 _initialize_windows_nat ()
3096 x86_dr_low
.set_control
= cygwin_set_dr7
;
3097 x86_dr_low
.set_addr
= cygwin_set_dr
;
3098 x86_dr_low
.get_addr
= cygwin_get_dr
;
3099 x86_dr_low
.get_status
= cygwin_get_dr6
;
3100 x86_dr_low
.get_control
= cygwin_get_dr7
;
3102 /* x86_dr_low.debug_register_length field is set by
3103 calling x86_set_debug_register_length function
3104 in processor windows specific native file. */
3106 add_inf_child_target (&the_windows_nat_target
);
3109 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3112 add_com ("signal-event", class_run
, signal_event_command
, _("\
3113 Signal a crashed process with event ID, to allow its debugging.\n\
3114 This command is needed in support of setting up GDB as JIT debugger on \
3115 MS-Windows. The command should be invoked from the GDB command line using \
3116 the '-ex' command-line option. The ID of the event that blocks the \
3117 crashed process will be supplied by the Windows JIT debugging mechanism."));
3120 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3121 Set use of shell to start subprocess."), _("\
3122 Show use of shell to start subprocess."), NULL
,
3124 NULL
, /* FIXME: i18n: */
3125 &setlist
, &showlist
);
3127 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3128 &cygwin_exceptions
, _("\
3129 Break when an exception is detected in the Cygwin DLL itself."), _("\
3130 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3132 NULL
, /* FIXME: i18n: */
3133 &setlist
, &showlist
);
3136 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3137 Set creation of new console when creating child process."), _("\
3138 Show creation of new console when creating child process."), NULL
,
3140 NULL
, /* FIXME: i18n: */
3141 &setlist
, &showlist
);
3143 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3144 Set creation of new group when creating child process."), _("\
3145 Show creation of new group when creating child process."), NULL
,
3147 NULL
, /* FIXME: i18n: */
3148 &setlist
, &showlist
);
3150 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3151 Set whether to display execution in child process."), _("\
3152 Show whether to display execution in child process."), NULL
,
3154 NULL
, /* FIXME: i18n: */
3155 &setlist
, &showlist
);
3157 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3158 Set whether to display kernel events in child process."), _("\
3159 Show whether to display kernel events in child process."), NULL
,
3161 NULL
, /* FIXME: i18n: */
3162 &setlist
, &showlist
);
3164 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3165 Set whether to display memory accesses in child process."), _("\
3166 Show whether to display memory accesses in child process."), NULL
,
3168 NULL
, /* FIXME: i18n: */
3169 &setlist
, &showlist
);
3171 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3172 &debug_exceptions
, _("\
3173 Set whether to display kernel exceptions in child process."), _("\
3174 Show whether to display kernel exceptions in child process."), NULL
,
3176 NULL
, /* FIXME: i18n: */
3177 &setlist
, &showlist
);
3179 init_w32_command_list ();
3181 add_cmd ("selector", class_info
, display_selectors
,
3182 _("Display selectors infos."),
3186 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3188 /* Pass the address ADDR to the inferior in the I'th debug register.
3189 Here we just store the address in dr array, the registers will be
3190 actually set up when windows_continue is called. */
3192 cygwin_set_dr (int i
, CORE_ADDR addr
)
3195 internal_error (__FILE__
, __LINE__
,
3196 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3198 debug_registers_changed
= 1;
3199 debug_registers_used
= 1;
3202 /* Pass the value VAL to the inferior in the DR7 debug control
3203 register. Here we just store the address in D_REGS, the watchpoint
3204 will be actually set up in windows_wait. */
3206 cygwin_set_dr7 (unsigned long val
)
3208 dr
[7] = (CORE_ADDR
) val
;
3209 debug_registers_changed
= 1;
3210 debug_registers_used
= 1;
3213 /* Get the value of debug register I from the inferior. */
3216 cygwin_get_dr (int i
)
3221 /* Get the value of the DR6 debug status register from the inferior.
3222 Here we just return the value stored in dr[6]
3223 by the last call to thread_rec for current_event.dwThreadId id. */
3224 static unsigned long
3225 cygwin_get_dr6 (void)
3227 return (unsigned long) dr
[6];
3230 /* Get the value of the DR7 debug status register from the inferior.
3231 Here we just return the value stored in dr[7] by the last call to
3232 thread_rec for current_event.dwThreadId id. */
3234 static unsigned long
3235 cygwin_get_dr7 (void)
3237 return (unsigned long) dr
[7];
3240 /* Determine if the thread referenced by "ptid" is alive
3241 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3242 it means that the thread has died. Otherwise it is assumed to be alive. */
3245 windows_nat_target::thread_alive (ptid_t ptid
)
3249 gdb_assert (ptid
.tid () != 0);
3252 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) != WAIT_OBJECT_0
;
3255 void _initialize_check_for_gdb_ini ();
3257 _initialize_check_for_gdb_ini ()
3260 if (inhibit_gdbinit
)
3263 homedir
= getenv ("HOME");
3267 char *oldini
= (char *) alloca (strlen (homedir
) +
3268 sizeof ("gdb.ini") + 1);
3269 strcpy (oldini
, homedir
);
3270 p
= strchr (oldini
, '\0');
3271 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3273 strcpy (p
, "gdb.ini");
3274 if (access (oldini
, 0) == 0)
3276 int len
= strlen (oldini
);
3277 char *newini
= (char *) alloca (len
+ 2);
3279 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3280 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3281 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3286 /* Define dummy functions which always return error for the rare cases where
3287 these functions could not be found. */
3289 bad_DebugActiveProcessStop (DWORD w
)
3294 bad_DebugBreakProcess (HANDLE w
)
3299 bad_DebugSetProcessKillOnExit (BOOL w
)
3304 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3311 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3317 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3324 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3330 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3336 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3342 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3350 /* Load any functions which may not be available in ancient versions
3353 void _initialize_loadable ();
3355 _initialize_loadable ()
3359 #define GPA(m, func) \
3360 func = (func ## _ftype *) GetProcAddress (m, #func)
3362 hm
= LoadLibrary ("kernel32.dll");
3365 GPA (hm
, DebugActiveProcessStop
);
3366 GPA (hm
, DebugBreakProcess
);
3367 GPA (hm
, DebugSetProcessKillOnExit
);
3368 GPA (hm
, GetConsoleFontSize
);
3369 GPA (hm
, DebugActiveProcessStop
);
3370 GPA (hm
, GetCurrentConsoleFont
);
3373 /* Set variables to dummy versions of these processes if the function
3374 wasn't found in kernel32.dll. */
3375 if (!DebugBreakProcess
)
3376 DebugBreakProcess
= bad_DebugBreakProcess
;
3377 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3379 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3380 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3382 if (!GetConsoleFontSize
)
3383 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3384 if (!GetCurrentConsoleFont
)
3385 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3387 /* Load optional functions used for retrieving filename information
3388 associated with the currently debugged process or its dlls. */
3389 hm
= LoadLibrary ("psapi.dll");
3392 GPA (hm
, EnumProcessModules
);
3393 GPA (hm
, GetModuleInformation
);
3394 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3395 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3398 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3400 /* Set variables to dummy versions of these processes if the function
3401 wasn't found in psapi.dll. */
3402 EnumProcessModules
= bad_EnumProcessModules
;
3403 GetModuleInformation
= bad_GetModuleInformation
;
3404 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3405 /* This will probably fail on Windows 9x/Me. Let the user know
3406 that we're missing some functionality. */
3408 cannot automatically find executable file or library to read symbols.\n\
3409 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3412 hm
= LoadLibrary ("advapi32.dll");
3415 GPA (hm
, OpenProcessToken
);
3416 GPA (hm
, LookupPrivilegeValueA
);
3417 GPA (hm
, AdjustTokenPrivileges
);
3418 /* Only need to set one of these since if OpenProcessToken fails nothing
3420 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3421 || !AdjustTokenPrivileges
)
3422 OpenProcessToken
= bad_OpenProcessToken
;