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 */
240 /* Counts of things. */
241 static int exception_count
= 0;
242 static int event_count
= 0;
243 static int saw_create
;
244 static int open_process_used
= 0;
247 static bool new_console
= false;
249 static bool cygwin_exceptions
= false;
251 static bool new_group
= true;
252 static bool debug_exec
= false; /* show execution */
253 static bool debug_events
= false; /* show events from kernel */
254 static bool debug_memory
= false; /* show target memory accesses */
255 static bool debug_exceptions
= false; /* show target exceptions */
256 static bool useshell
= false; /* use shell for subprocesses */
258 /* This vector maps GDB's idea of a register's number into an offset
259 in the windows exception context vector.
261 It also contains the bit mask needed to load the register in question.
263 The contents of this table can only be computed by the units
264 that provide CPU-specific support for Windows native debugging.
265 These units should set the table by calling
266 windows_set_context_register_offsets.
268 One day we could read a reg, we could inspect the context we
269 already have loaded, if it doesn't have the bit set that we need,
270 we read that set of registers in using GetThreadContext. If the
271 context already contains what we need, we just unpack it. Then to
272 write a register, first we have to ensure that the context contains
273 the other regs of the group, and then we copy the info in and set
276 static const int *mappings
;
278 /* The function to use in order to determine whether a register is
279 a segment register or not. */
280 static segment_register_p_ftype
*segment_register_p
;
282 /* See windows_nat_target::resume to understand why this is commented
285 /* This vector maps the target's idea of an exception (extracted
286 from the DEBUG_EVENT structure) to GDB's idea. */
288 struct xlate_exception
294 static const struct xlate_exception xlate
[] =
296 {EXCEPTION_ACCESS_VIOLATION
, GDB_SIGNAL_SEGV
},
297 {STATUS_STACK_OVERFLOW
, GDB_SIGNAL_SEGV
},
298 {EXCEPTION_BREAKPOINT
, GDB_SIGNAL_TRAP
},
299 {DBG_CONTROL_C
, GDB_SIGNAL_INT
},
300 {EXCEPTION_SINGLE_STEP
, GDB_SIGNAL_TRAP
},
301 {STATUS_FLOAT_DIVIDE_BY_ZERO
, GDB_SIGNAL_FPE
}
306 struct windows_nat_target final
: public x86_nat_target
<inf_child_target
>
308 void close () override
;
310 void attach (const char *, int) override
;
312 bool attach_no_wait () override
315 void detach (inferior
*, int) override
;
317 void resume (ptid_t
, int , enum gdb_signal
) override
;
319 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
321 void fetch_registers (struct regcache
*, int) override
;
322 void store_registers (struct regcache
*, int) override
;
324 enum target_xfer_status
xfer_partial (enum target_object object
,
327 const gdb_byte
*writebuf
,
328 ULONGEST offset
, ULONGEST len
,
329 ULONGEST
*xfered_len
) override
;
331 void files_info () override
;
333 void kill () override
;
335 void create_inferior (const char *, const std::string
&,
336 char **, int) override
;
338 void mourn_inferior () override
;
340 bool thread_alive (ptid_t ptid
) override
;
342 std::string
pid_to_str (ptid_t
) override
;
344 void interrupt () override
;
346 char *pid_to_exec_file (int pid
) override
;
348 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
350 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
352 const char *thread_name (struct thread_info
*) override
;
354 int get_windows_debug_event (int pid
, struct target_waitstatus
*ourstatus
);
357 static windows_nat_target the_windows_nat_target
;
359 /* Set the MAPPINGS static global to OFFSETS.
360 See the description of MAPPINGS for more details. */
363 windows_set_context_register_offsets (const int *offsets
)
368 /* See windows-nat.h. */
371 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
373 segment_register_p
= fun
;
377 check (BOOL ok
, const char *file
, int line
)
380 printf_filtered ("error return %s:%d was %u\n", file
, line
,
381 (unsigned) GetLastError ());
384 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
385 then also retrieve the context for this thread. If GET_CONTEXT is
386 negative, then don't suspend the thread. */
387 static windows_thread_info
*
388 thread_rec (DWORD id
, int get_context
)
390 windows_thread_info
*th
;
392 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
395 if (!th
->suspended
&& get_context
)
397 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
399 if (SuspendThread (th
->h
) == (DWORD
) -1)
401 DWORD err
= GetLastError ();
403 /* We get Access Denied (5) when trying to suspend
404 threads that Windows started on behalf of the
405 debuggee, usually when those threads are just
407 We can get Invalid Handle (6) if the main thread
409 if (err
!= ERROR_INVALID_HANDLE
410 && err
!= ERROR_ACCESS_DENIED
)
411 warning (_("SuspendThread (tid=0x%x) failed."
413 (unsigned) id
, (unsigned) err
);
419 else if (get_context
< 0)
421 th
->reload_context
= 1;
429 /* Add a thread to the thread list.
431 PTID is the ptid of the thread to be added.
432 H is its Windows handle.
433 TLB is its thread local base.
434 MAIN_THREAD_P should be true if the thread to be added is
435 the main thread, false otherwise. */
437 static windows_thread_info
*
438 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
, bool main_thread_p
)
440 windows_thread_info
*th
;
443 gdb_assert (ptid
.tid () != 0);
447 if ((th
= thread_rec (id
, FALSE
)))
450 th
= XCNEW (windows_thread_info
);
453 th
->thread_local_base
= (CORE_ADDR
) (uintptr_t) tlb
;
454 th
->next
= thread_head
.next
;
455 thread_head
.next
= th
;
457 /* Add this new thread to the list of threads.
459 To be consistent with what's done on other platforms, we add
460 the main thread silently (in reality, this thread is really
461 more of a process to the user than a thread). */
463 add_thread_silent (&the_windows_nat_target
, ptid
);
465 add_thread (&the_windows_nat_target
, ptid
);
467 /* Set the debug registers for the new thread if they are used. */
468 if (debug_registers_used
)
470 /* Only change the value of the debug registers. */
471 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
472 CHECK (GetThreadContext (th
->h
, &th
->context
));
473 th
->context
.Dr0
= dr
[0];
474 th
->context
.Dr1
= dr
[1];
475 th
->context
.Dr2
= dr
[2];
476 th
->context
.Dr3
= dr
[3];
477 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
478 th
->context
.Dr7
= dr
[7];
479 CHECK (SetThreadContext (th
->h
, &th
->context
));
480 th
->context
.ContextFlags
= 0;
485 /* Clear out any old thread list and reinitialize it to a
488 windows_init_thread_list (void)
490 windows_thread_info
*th
= &thread_head
;
492 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
494 while (th
->next
!= NULL
)
496 windows_thread_info
*here
= th
->next
;
497 th
->next
= here
->next
;
500 thread_head
.next
= NULL
;
503 /* Delete a thread from the list of threads.
505 PTID is the ptid of the thread to be deleted.
506 EXIT_CODE is the thread's exit code.
507 MAIN_THREAD_P should be true if the thread to be deleted is
508 the main thread, false otherwise. */
511 windows_delete_thread (ptid_t ptid
, DWORD exit_code
, bool main_thread_p
)
513 windows_thread_info
*th
;
516 gdb_assert (ptid
.tid () != 0);
520 /* Emit a notification about the thread being deleted.
522 Note that no notification was printed when the main thread
523 was created, and thus, unless in verbose mode, we should be
524 symmetrical, and avoid that notification for the main thread
528 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
).c_str ());
529 else if (print_thread_events
&& !main_thread_p
)
530 printf_unfiltered (_("[%s exited with code %u]\n"),
531 target_pid_to_str (ptid
).c_str (),
532 (unsigned) exit_code
);
534 delete_thread (find_thread_ptid (&the_windows_nat_target
, ptid
));
536 for (th
= &thread_head
;
537 th
->next
!= NULL
&& th
->next
->id
!= id
;
541 if (th
->next
!= NULL
)
543 windows_thread_info
*here
= th
->next
;
544 th
->next
= here
->next
;
550 /* Fetches register number R from the given windows_thread_info,
551 and supplies its value to the given regcache.
553 This function assumes that R is non-negative. A failed assertion
554 is raised if that is not true.
556 This function assumes that TH->RELOAD_CONTEXT is not set, meaning
557 that the windows_thread_info has an up-to-date context. A failed
558 assertion is raised if that assumption is violated. */
561 windows_fetch_one_register (struct regcache
*regcache
,
562 windows_thread_info
*th
, int r
)
565 gdb_assert (!th
->reload_context
);
567 char *context_offset
= ((char *) &th
->context
) + mappings
[r
];
568 struct gdbarch
*gdbarch
= regcache
->arch ();
569 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
571 if (r
== I387_FISEG_REGNUM (tdep
))
573 long l
= *((long *) context_offset
) & 0xffff;
574 regcache
->raw_supply (r
, (char *) &l
);
576 else if (r
== I387_FOP_REGNUM (tdep
))
578 long l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
579 regcache
->raw_supply (r
, (char *) &l
);
581 else if (segment_register_p (r
))
583 /* GDB treats segment registers as 32bit registers, but they are
584 in fact only 16 bits long. Make sure we do not read extra
585 bits from our source buffer. */
586 long l
= *((long *) context_offset
) & 0xffff;
587 regcache
->raw_supply (r
, (char *) &l
);
590 regcache
->raw_supply (r
, context_offset
);
594 windows_nat_target::fetch_registers (struct regcache
*regcache
, int r
)
596 DWORD tid
= regcache
->ptid ().tid ();
597 windows_thread_info
*th
= thread_rec (tid
, TRUE
);
599 /* Check if TH exists. Windows sometimes uses a non-existent
600 thread id in its events. */
604 if (th
->reload_context
)
607 if (have_saved_context
)
609 /* Lie about where the program actually is stopped since
610 cygwin has informed us that we should consider the signal
611 to have occurred at another location which is stored in
613 memcpy (&th
->context
, &saved_context
,
614 __COPY_CONTEXT_SIZE
);
615 have_saved_context
= 0;
620 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
621 CHECK (GetThreadContext (th
->h
, &th
->context
));
622 /* Copy dr values from that thread.
623 But only if there were not modified since last stop.
625 if (!debug_registers_changed
)
627 dr
[0] = th
->context
.Dr0
;
628 dr
[1] = th
->context
.Dr1
;
629 dr
[2] = th
->context
.Dr2
;
630 dr
[3] = th
->context
.Dr3
;
631 dr
[6] = th
->context
.Dr6
;
632 dr
[7] = th
->context
.Dr7
;
635 th
->reload_context
= 0;
639 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch()); r
++)
640 windows_fetch_one_register (regcache
, th
, r
);
642 windows_fetch_one_register (regcache
, th
, r
);
645 /* Collect the register number R from the given regcache, and store
646 its value into the corresponding area of the given thread's context.
648 This function assumes that R is non-negative. A failed assertion
649 assertion is raised if that is not true. */
652 windows_store_one_register (const struct regcache
*regcache
,
653 windows_thread_info
*th
, int r
)
657 regcache
->raw_collect (r
, ((char *) &th
->context
) + mappings
[r
]);
660 /* Store a new register value into the context of the thread tied to
664 windows_nat_target::store_registers (struct regcache
*regcache
, int r
)
666 DWORD tid
= regcache
->ptid ().tid ();
667 windows_thread_info
*th
= thread_rec (tid
, TRUE
);
669 /* Check if TH exists. Windows sometimes uses a non-existent
670 thread id in its events. */
675 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch ()); r
++)
676 windows_store_one_register (regcache
, th
, r
);
678 windows_store_one_register (regcache
, th
, r
);
681 /* Maintain a linked list of "so" information. */
682 struct lm_info_windows
: public lm_info_base
684 LPVOID load_addr
= 0;
685 CORE_ADDR text_offset
= 0;
688 static struct so_list solib_start
, *solib_end
;
690 static struct so_list
*
691 windows_make_so (const char *name
, LPVOID load_addr
)
698 WIN32_FIND_DATA w32_fd
;
699 HANDLE h
= FindFirstFile(name
, &w32_fd
);
701 if (h
== INVALID_HANDLE_VALUE
)
707 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
709 p
= strrchr (buf
, '\\');
712 SetCurrentDirectory (buf
);
713 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
714 SetCurrentDirectory (cwd
);
717 if (strcasecmp (buf
, "ntdll.dll") == 0)
719 GetSystemDirectory (buf
, sizeof (buf
));
720 strcat (buf
, "\\ntdll.dll");
723 cygwin_buf_t buf
[__PMAX
];
726 if (access (name
, F_OK
) != 0)
728 if (strcasecmp (name
, "ntdll.dll") == 0)
731 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
732 wcscat (buf
, L
"\\ntdll.dll");
736 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
737 strcat (buf
, "\\ntdll.dll");
742 so
= XCNEW (struct so_list
);
743 lm_info_windows
*li
= new lm_info_windows
;
745 li
->load_addr
= load_addr
;
746 strcpy (so
->so_original_name
, name
);
748 strcpy (so
->so_name
, buf
);
751 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
752 SO_NAME_MAX_PATH_SIZE
);
755 char *rname
= realpath (name
, NULL
);
756 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
758 strcpy (so
->so_name
, rname
);
762 error (_("dll path too long"));
764 /* Record cygwin1.dll .text start/end. */
765 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
766 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
768 asection
*text
= NULL
;
770 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386", -1));
775 if (bfd_check_format (abfd
.get (), bfd_object
))
776 text
= bfd_get_section_by_name (abfd
.get (), ".text");
781 /* The symbols in a dll are offset by 0x1000, which is the
782 offset from 0 of the first byte in an image - because of the
783 file header and the section alignment. */
784 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
786 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (text
);
794 get_image_name (HANDLE h
, void *address
, int unicode
)
797 static char buf
[__PMAX
];
799 static char buf
[(2 * __PMAX
) + 1];
801 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
807 /* Attempt to read the name of the dll that was detected.
808 This is documented to work only when actively debugging
809 a program. It will not work for attached processes. */
813 /* See if we could read the address of a string, and that the
814 address isn't null. */
815 if (!ReadProcessMemory (h
, address
, &address_ptr
,
816 sizeof (address_ptr
), &done
)
817 || done
!= sizeof (address_ptr
) || !address_ptr
)
820 /* Find the length of the string. */
821 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
822 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
826 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
829 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
830 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
833 wcstombs (buf
, unicode_address
, __PMAX
);
835 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
843 /* Handle a DLL load event, and return 1.
845 This function assumes that this event did not occur during inferior
846 initialization, where their event info may be incomplete (see
847 do_initial_windows_stuff and windows_add_all_dlls for more info
848 on how we handle DLL loading during that phase). */
853 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
856 /* Try getting the DLL name via the lpImageName field of the event.
857 Note that Microsoft documents this fields as strictly optional,
858 in the sense that it might be NULL. And the first DLL event in
859 particular is explicitly documented as "likely not pass[ed]"
860 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
861 dll_name
= get_image_name (current_process_handle
,
862 event
->lpImageName
, event
->fUnicode
);
866 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
867 solib_end
= solib_end
->next
;
869 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
871 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
872 host_address_to_string (li
->load_addr
)));
876 windows_free_so (struct so_list
*so
)
878 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
884 /* Handle a DLL unload event.
885 Return 1 if successful, or zero otherwise.
887 This function assumes that this event did not occur during inferior
888 initialization, where their event info may be incomplete (see
889 do_initial_windows_stuff and windows_add_all_dlls for more info
890 on how we handle DLL loading during that phase). */
895 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
898 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
900 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
902 if (li_next
->load_addr
== lpBaseOfDll
)
904 struct so_list
*sodel
= so
->next
;
906 so
->next
= sodel
->next
;
909 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
911 windows_free_so (sodel
);
916 /* We did not find any DLL that was previously loaded at this address,
917 so register a complaint. We do not report an error, because we have
918 observed that this may be happening under some circumstances. For
919 instance, running 32bit applications on x64 Windows causes us to receive
920 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
921 events are apparently caused by the WOW layer, the interface between
922 32bit and 64bit worlds). */
923 complaint (_("dll starting at %s not found."),
924 host_address_to_string (lpBaseOfDll
));
927 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
931 catch_errors (void (*func
) ())
937 catch (const gdb_exception
&ex
)
939 exception_print (gdb_stderr
, ex
);
943 /* Clear list of loaded DLLs. */
945 windows_clear_solib (void)
949 for (so
= solib_start
.next
; so
; so
= solib_start
.next
)
951 solib_start
.next
= so
->next
;
952 windows_free_so (so
);
955 solib_end
= &solib_start
;
959 signal_event_command (const char *args
, int from_tty
)
961 uintptr_t event_id
= 0;
962 char *endargs
= NULL
;
965 error (_("signal-event requires an argument (integer event id)"));
967 event_id
= strtoumax (args
, &endargs
, 10);
969 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
970 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
971 error (_("Failed to convert `%s' to event id"), args
);
973 SetEvent ((HANDLE
) event_id
);
974 CloseHandle ((HANDLE
) event_id
);
977 /* Handle DEBUG_STRING output from child process.
978 Cygwin prepends its messages with a "cygwin:". Interpret this as
979 a Cygwin signal. Otherwise just print the string as a warning. */
981 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
983 gdb::unique_xmalloc_ptr
<char> s
;
986 if (!target_read_string
987 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
989 || !s
|| !*(s
.get ()))
991 else if (!startswith (s
.get (), _CYGWIN_SIGNAL_STRING
))
994 if (!startswith (s
.get (), "cYg"))
997 char *p
= strchr (s
.get (), '\0');
999 if (p
> s
.get () && *--p
== '\n')
1001 warning (("%s"), s
.get ());
1007 /* Got a cygwin signal marker. A cygwin signal is followed by
1008 the signal number itself and then optionally followed by the
1009 thread id and address to saved context within the DLL. If
1010 these are supplied, then the given thread is assumed to have
1011 issued the signal and the context from the thread is assumed
1012 to be stored at the given address in the inferior. Tell gdb
1013 to treat this like a real signal. */
1015 int sig
= strtol (s
.get () + sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
1016 gdb_signal gotasig
= gdb_signal_from_host (sig
);
1018 ourstatus
->value
.sig
= gotasig
;
1024 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1025 retval
= strtoul (p
, &p
, 0);
1027 retval
= current_event
.dwThreadId
;
1028 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
1029 && ReadProcessMemory (current_process_handle
, x
,
1031 __COPY_CONTEXT_SIZE
, &n
)
1032 && n
== __COPY_CONTEXT_SIZE
)
1033 have_saved_context
= 1;
1042 display_selector (HANDLE thread
, DWORD sel
)
1045 if (GetThreadSelectorEntry (thread
, sel
, &info
))
1048 printf_filtered ("0x%03x: ", (unsigned) sel
);
1049 if (!info
.HighWord
.Bits
.Pres
)
1051 puts_filtered ("Segment not present\n");
1054 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1055 (info
.HighWord
.Bits
.BaseMid
<< 16)
1057 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1058 if (info
.HighWord
.Bits
.Granularity
)
1059 limit
= (limit
<< 12) | 0xfff;
1060 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1061 if (info
.HighWord
.Bits
.Default_Big
)
1062 puts_filtered(" 32-bit ");
1064 puts_filtered(" 16-bit ");
1065 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1068 puts_filtered ("Data (Read-Only, Exp-up");
1071 puts_filtered ("Data (Read/Write, Exp-up");
1074 puts_filtered ("Unused segment (");
1077 puts_filtered ("Data (Read/Write, Exp-down");
1080 puts_filtered ("Code (Exec-Only, N.Conf");
1083 puts_filtered ("Code (Exec/Read, N.Conf");
1086 puts_filtered ("Code (Exec-Only, Conf");
1089 puts_filtered ("Code (Exec/Read, Conf");
1092 printf_filtered ("Unknown type 0x%lx",
1093 (unsigned long) info
.HighWord
.Bits
.Type
);
1095 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1096 puts_filtered(", N.Acc");
1097 puts_filtered (")\n");
1098 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1099 puts_filtered("System selector ");
1100 printf_filtered ("Priviledge level = %ld. ",
1101 (unsigned long) info
.HighWord
.Bits
.Dpl
);
1102 if (info
.HighWord
.Bits
.Granularity
)
1103 puts_filtered ("Page granular.\n");
1105 puts_filtered ("Byte granular.\n");
1110 DWORD err
= GetLastError ();
1111 if (err
== ERROR_NOT_SUPPORTED
)
1112 printf_filtered ("Function not supported\n");
1114 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1120 display_selectors (const char * args
, int from_tty
)
1122 if (!current_thread
)
1124 puts_filtered ("Impossible to display selectors now.\n");
1130 puts_filtered ("Selector $cs\n");
1131 display_selector (current_thread
->h
,
1132 current_thread
->context
.SegCs
);
1133 puts_filtered ("Selector $ds\n");
1134 display_selector (current_thread
->h
,
1135 current_thread
->context
.SegDs
);
1136 puts_filtered ("Selector $es\n");
1137 display_selector (current_thread
->h
,
1138 current_thread
->context
.SegEs
);
1139 puts_filtered ("Selector $ss\n");
1140 display_selector (current_thread
->h
,
1141 current_thread
->context
.SegSs
);
1142 puts_filtered ("Selector $fs\n");
1143 display_selector (current_thread
->h
,
1144 current_thread
->context
.SegFs
);
1145 puts_filtered ("Selector $gs\n");
1146 display_selector (current_thread
->h
,
1147 current_thread
->context
.SegGs
);
1152 sel
= parse_and_eval_long (args
);
1153 printf_filtered ("Selector \"%s\"\n",args
);
1154 display_selector (current_thread
->h
, sel
);
1158 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1159 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1160 host_address_to_string (\
1161 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1163 static handle_exception_result
1164 handle_exception (struct target_waitstatus
*ourstatus
)
1166 EXCEPTION_RECORD
*rec
= ¤t_event
.u
.Exception
.ExceptionRecord
;
1167 DWORD code
= rec
->ExceptionCode
;
1168 handle_exception_result result
= HANDLE_EXCEPTION_HANDLED
;
1170 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1172 /* Record the context of the current thread. */
1173 thread_rec (current_event
.dwThreadId
, -1);
1177 case EXCEPTION_ACCESS_VIOLATION
:
1178 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1179 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1182 /* See if the access violation happened within the cygwin DLL
1183 itself. Cygwin uses a kind of exception handling to deal
1184 with passed-in invalid addresses. gdb should not treat
1185 these as real SEGVs since they will be silently handled by
1186 cygwin. A real SEGV will (theoretically) be caught by
1187 cygwin later in the process and will be sent as a
1188 cygwin-specific-signal. So, ignore SEGVs if they show up
1189 within the text segment of the DLL itself. */
1191 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1193 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1194 && addr
< cygwin_load_end
))
1195 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1196 && startswith (fn
, "KERNEL32!IsBad")))
1197 return HANDLE_EXCEPTION_UNHANDLED
;
1201 case STATUS_STACK_OVERFLOW
:
1202 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1203 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1205 case STATUS_FLOAT_DENORMAL_OPERAND
:
1206 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1207 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1209 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1210 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1211 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1213 case STATUS_FLOAT_INEXACT_RESULT
:
1214 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1215 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1217 case STATUS_FLOAT_INVALID_OPERATION
:
1218 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1219 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1221 case STATUS_FLOAT_OVERFLOW
:
1222 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1223 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1225 case STATUS_FLOAT_STACK_CHECK
:
1226 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1227 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1229 case STATUS_FLOAT_UNDERFLOW
:
1230 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1231 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1233 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1234 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1235 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1237 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1238 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1239 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1241 case STATUS_INTEGER_OVERFLOW
:
1242 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1243 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1245 case EXCEPTION_BREAKPOINT
:
1246 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1247 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1250 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1251 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1253 case DBG_CONTROL_BREAK
:
1254 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1255 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1257 case EXCEPTION_SINGLE_STEP
:
1258 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1259 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1261 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1262 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1263 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1265 case EXCEPTION_PRIV_INSTRUCTION
:
1266 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1267 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1269 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1270 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1271 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1273 case MS_VC_EXCEPTION
:
1274 if (rec
->NumberParameters
>= 3
1275 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1277 DWORD named_thread_id
;
1278 windows_thread_info
*named_thread
;
1279 CORE_ADDR thread_name_target
;
1281 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1283 thread_name_target
= rec
->ExceptionInformation
[1];
1284 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1286 if (named_thread_id
== (DWORD
) -1)
1287 named_thread_id
= current_event
.dwThreadId
;
1289 named_thread
= thread_rec (named_thread_id
, 0);
1290 if (named_thread
!= NULL
)
1292 int thread_name_len
;
1293 gdb::unique_xmalloc_ptr
<char> thread_name
;
1295 thread_name_len
= target_read_string (thread_name_target
,
1296 &thread_name
, 1025, NULL
);
1297 if (thread_name_len
> 0)
1299 thread_name
.get ()[thread_name_len
- 1] = '\0';
1300 xfree (named_thread
->name
);
1301 named_thread
->name
= thread_name
.release ();
1304 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1305 result
= HANDLE_EXCEPTION_IGNORED
;
1308 /* treat improperly formed exception as unknown */
1311 /* Treat unhandled first chance exceptions specially. */
1312 if (current_event
.u
.Exception
.dwFirstChance
)
1313 return HANDLE_EXCEPTION_UNHANDLED
;
1314 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1315 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1316 host_address_to_string (
1317 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1318 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1322 last_sig
= ourstatus
->value
.sig
;
1326 /* Resume thread specified by ID, or all artificially suspended
1327 threads, if we are continuing execution. KILLED non-zero means we
1328 have killed the inferior, so we should ignore weird errors due to
1329 threads shutting down. */
1331 windows_continue (DWORD continue_status
, int id
, int killed
)
1333 windows_thread_info
*th
;
1336 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1337 (unsigned) current_event
.dwProcessId
,
1338 (unsigned) current_event
.dwThreadId
,
1339 continue_status
== DBG_CONTINUE
?
1340 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1342 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1343 if ((id
== -1 || id
== (int) th
->id
)
1346 if (debug_registers_changed
)
1348 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1349 th
->context
.Dr0
= dr
[0];
1350 th
->context
.Dr1
= dr
[1];
1351 th
->context
.Dr2
= dr
[2];
1352 th
->context
.Dr3
= dr
[3];
1353 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1354 th
->context
.Dr7
= dr
[7];
1356 if (th
->context
.ContextFlags
)
1360 if (GetExitCodeThread (th
->h
, &ec
)
1361 && ec
== STILL_ACTIVE
)
1363 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1368 th
->context
.ContextFlags
= 0;
1370 if (th
->suspended
> 0)
1371 (void) ResumeThread (th
->h
);
1375 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1376 current_event
.dwThreadId
,
1380 error (_("Failed to resume program execution"
1381 " (ContinueDebugEvent failed, error %u)"),
1382 (unsigned int) GetLastError ());
1384 debug_registers_changed
= 0;
1388 /* Called in pathological case where Windows fails to send a
1389 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1391 fake_create_process (void)
1393 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1394 current_event
.dwProcessId
);
1395 if (current_process_handle
!= NULL
)
1396 open_process_used
= 1;
1399 error (_("OpenProcess call failed, GetLastError = %u"),
1400 (unsigned) GetLastError ());
1401 /* We can not debug anything in that case. */
1404 = windows_add_thread (ptid_t (current_event
.dwProcessId
, 0,
1405 current_event
.dwThreadId
),
1406 current_event
.u
.CreateThread
.hThread
,
1407 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1408 true /* main_thread_p */);
1409 return current_event
.dwThreadId
;
1413 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1415 windows_thread_info
*th
;
1416 DWORD continue_status
= DBG_CONTINUE
;
1418 /* A specific PTID means `step only this thread id'. */
1419 int resume_all
= ptid
== minus_one_ptid
;
1421 /* If we're continuing all threads, it's the current inferior that
1422 should be handled specially. */
1424 ptid
= inferior_ptid
;
1426 if (sig
!= GDB_SIGNAL_0
)
1428 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1430 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1432 else if (sig
== last_sig
)
1433 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1436 /* This code does not seem to work, because
1437 the kernel does probably not consider changes in the ExceptionRecord
1438 structure when passing the exception to the inferior.
1439 Note that this seems possible in the exception handler itself. */
1441 for (const xlate_exception
&x
: xlate
)
1444 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1446 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1449 if (continue_status
== DBG_CONTINUE
)
1451 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1455 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1459 last_sig
= GDB_SIGNAL_0
;
1461 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=0x%x, step=%d, sig=%d);\n",
1462 ptid
.pid (), (unsigned) ptid
.tid (), step
, sig
));
1464 /* Get context for currently selected thread. */
1465 th
= thread_rec (inferior_ptid
.tid (), FALSE
);
1470 /* Single step by setting t bit. */
1471 struct regcache
*regcache
= get_current_regcache ();
1472 struct gdbarch
*gdbarch
= regcache
->arch ();
1473 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1474 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1477 if (th
->context
.ContextFlags
)
1479 if (debug_registers_changed
)
1481 th
->context
.Dr0
= dr
[0];
1482 th
->context
.Dr1
= dr
[1];
1483 th
->context
.Dr2
= dr
[2];
1484 th
->context
.Dr3
= dr
[3];
1485 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1486 th
->context
.Dr7
= dr
[7];
1488 CHECK (SetThreadContext (th
->h
, &th
->context
));
1489 th
->context
.ContextFlags
= 0;
1493 /* Allow continuing with the same signal that interrupted us.
1494 Otherwise complain. */
1497 windows_continue (continue_status
, -1, 0);
1499 windows_continue (continue_status
, ptid
.tid (), 0);
1502 /* Ctrl-C handler used when the inferior is not run in the same console. The
1503 handler is in charge of interrupting the inferior using DebugBreakProcess.
1504 Note that this function is not available prior to Windows XP. In this case
1505 we emit a warning. */
1507 ctrl_c_handler (DWORD event_type
)
1509 const int attach_flag
= current_inferior ()->attach_flag
;
1511 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1512 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1515 /* If the inferior and the debugger share the same console, do nothing as
1516 the inferior has also received the Ctrl-C event. */
1517 if (!new_console
&& !attach_flag
)
1520 if (!DebugBreakProcess (current_process_handle
))
1521 warning (_("Could not interrupt program. "
1522 "Press Ctrl-c in the program console."));
1524 /* Return true to tell that Ctrl-C has been handled. */
1528 /* Get the next event from the child. Returns a non-zero thread id if the event
1529 requires handling by WFI (or whatever). */
1532 windows_nat_target::get_windows_debug_event (int pid
,
1533 struct target_waitstatus
*ourstatus
)
1536 DWORD continue_status
, event_code
;
1537 windows_thread_info
*th
;
1538 static windows_thread_info dummy_thread_info
;
1539 DWORD thread_id
= 0;
1541 last_sig
= GDB_SIGNAL_0
;
1543 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1547 continue_status
= DBG_CONTINUE
;
1549 event_code
= current_event
.dwDebugEventCode
;
1550 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1552 have_saved_context
= 0;
1556 case CREATE_THREAD_DEBUG_EVENT
:
1557 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1558 (unsigned) current_event
.dwProcessId
,
1559 (unsigned) current_event
.dwThreadId
,
1560 "CREATE_THREAD_DEBUG_EVENT"));
1561 if (saw_create
!= 1)
1563 inferior
*inf
= find_inferior_pid (this, current_event
.dwProcessId
);
1564 if (!saw_create
&& inf
->attach_flag
)
1566 /* Kludge around a Windows bug where first event is a create
1567 thread event. Caused when attached process does not have
1569 thread_id
= fake_create_process ();
1575 /* Record the existence of this thread. */
1576 thread_id
= current_event
.dwThreadId
;
1577 th
= windows_add_thread
1578 (ptid_t (current_event
.dwProcessId
, 0, current_event
.dwThreadId
),
1579 current_event
.u
.CreateThread
.hThread
,
1580 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1581 false /* main_thread_p */);
1585 case EXIT_THREAD_DEBUG_EVENT
:
1586 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1587 (unsigned) current_event
.dwProcessId
,
1588 (unsigned) current_event
.dwThreadId
,
1589 "EXIT_THREAD_DEBUG_EVENT"));
1590 windows_delete_thread (ptid_t (current_event
.dwProcessId
, 0,
1591 current_event
.dwThreadId
),
1592 current_event
.u
.ExitThread
.dwExitCode
,
1593 false /* main_thread_p */);
1594 th
= &dummy_thread_info
;
1597 case CREATE_PROCESS_DEBUG_EVENT
:
1598 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1599 (unsigned) current_event
.dwProcessId
,
1600 (unsigned) current_event
.dwThreadId
,
1601 "CREATE_PROCESS_DEBUG_EVENT"));
1602 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1603 if (++saw_create
!= 1)
1606 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1607 /* Add the main thread. */
1608 th
= windows_add_thread
1609 (ptid_t (current_event
.dwProcessId
, 0,
1610 current_event
.dwThreadId
),
1611 current_event
.u
.CreateProcessInfo
.hThread
,
1612 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
,
1613 true /* main_thread_p */);
1614 thread_id
= current_event
.dwThreadId
;
1617 case EXIT_PROCESS_DEBUG_EVENT
:
1618 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1619 (unsigned) current_event
.dwProcessId
,
1620 (unsigned) current_event
.dwThreadId
,
1621 "EXIT_PROCESS_DEBUG_EVENT"));
1622 if (!windows_initialization_done
)
1624 target_terminal::ours ();
1625 target_mourn_inferior (inferior_ptid
);
1626 error (_("During startup program exited with code 0x%x."),
1627 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1629 else if (saw_create
== 1)
1631 windows_delete_thread (ptid_t (current_event
.dwProcessId
, 0,
1632 current_event
.dwThreadId
),
1633 0, true /* main_thread_p */);
1634 DWORD exit_status
= current_event
.u
.ExitProcess
.dwExitCode
;
1635 /* If the exit status looks like a fatal exception, but we
1636 don't recognize the exception's code, make the original
1637 exit status value available, to avoid losing
1640 = WIFSIGNALED (exit_status
) ? WTERMSIG (exit_status
) : -1;
1641 if (exit_signal
== -1)
1643 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1644 ourstatus
->value
.integer
= exit_status
;
1648 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1649 ourstatus
->value
.sig
= gdb_signal_from_host (exit_signal
);
1651 thread_id
= current_event
.dwThreadId
;
1655 case LOAD_DLL_DEBUG_EVENT
:
1656 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1657 (unsigned) current_event
.dwProcessId
,
1658 (unsigned) current_event
.dwThreadId
,
1659 "LOAD_DLL_DEBUG_EVENT"));
1660 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1661 if (saw_create
!= 1 || ! windows_initialization_done
)
1663 catch_errors (handle_load_dll
);
1664 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1665 ourstatus
->value
.integer
= 0;
1666 thread_id
= current_event
.dwThreadId
;
1669 case UNLOAD_DLL_DEBUG_EVENT
:
1670 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1671 (unsigned) current_event
.dwProcessId
,
1672 (unsigned) current_event
.dwThreadId
,
1673 "UNLOAD_DLL_DEBUG_EVENT"));
1674 if (saw_create
!= 1 || ! windows_initialization_done
)
1676 catch_errors (handle_unload_dll
);
1677 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1678 ourstatus
->value
.integer
= 0;
1679 thread_id
= current_event
.dwThreadId
;
1682 case EXCEPTION_DEBUG_EVENT
:
1683 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1684 (unsigned) current_event
.dwProcessId
,
1685 (unsigned) current_event
.dwThreadId
,
1686 "EXCEPTION_DEBUG_EVENT"));
1687 if (saw_create
!= 1)
1689 switch (handle_exception (ourstatus
))
1691 case HANDLE_EXCEPTION_UNHANDLED
:
1693 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1695 case HANDLE_EXCEPTION_HANDLED
:
1696 thread_id
= current_event
.dwThreadId
;
1698 case HANDLE_EXCEPTION_IGNORED
:
1699 continue_status
= DBG_CONTINUE
;
1704 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1705 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1706 (unsigned) current_event
.dwProcessId
,
1707 (unsigned) current_event
.dwThreadId
,
1708 "OUTPUT_DEBUG_STRING_EVENT"));
1709 if (saw_create
!= 1)
1711 thread_id
= handle_output_debug_string (ourstatus
);
1715 if (saw_create
!= 1)
1717 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1718 (unsigned) current_event
.dwProcessId
,
1719 (unsigned) current_event
.dwThreadId
);
1720 printf_unfiltered (" unknown event code %u\n",
1721 (unsigned) current_event
.dwDebugEventCode
);
1725 if (!thread_id
|| saw_create
!= 1)
1727 CHECK (windows_continue (continue_status
, -1, 0));
1731 inferior_ptid
= ptid_t (current_event
.dwProcessId
, 0, thread_id
);
1732 current_thread
= th
;
1733 if (!current_thread
)
1734 current_thread
= thread_rec (thread_id
, TRUE
);
1741 /* Wait for interesting events to occur in the target process. */
1743 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1748 /* We loop when we get a non-standard exception rather than return
1749 with a SPURIOUS because resume can try and step or modify things,
1750 which needs a current_thread->h. But some of these exceptions mark
1751 the birth or death of threads, which mean that the current thread
1752 isn't necessarily what you think it is. */
1758 /* If the user presses Ctrl-c while the debugger is waiting
1759 for an event, he expects the debugger to interrupt his program
1760 and to get the prompt back. There are two possible situations:
1762 - The debugger and the program do not share the console, in
1763 which case the Ctrl-c event only reached the debugger.
1764 In that case, the ctrl_c handler will take care of interrupting
1765 the inferior. Note that this case is working starting with
1766 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1769 - The debugger and the program share the same console, in which
1770 case both debugger and inferior will receive the Ctrl-c event.
1771 In that case the ctrl_c handler will ignore the event, as the
1772 Ctrl-c event generated inside the inferior will trigger the
1773 expected debug event.
1775 FIXME: brobecker/2008-05-20: If the inferior receives the
1776 signal first and the delay until GDB receives that signal
1777 is sufficiently long, GDB can sometimes receive the SIGINT
1778 after we have unblocked the CTRL+C handler. This would
1779 lead to the debugger stopping prematurely while handling
1780 the new-thread event that comes with the handling of the SIGINT
1781 inside the inferior, and then stop again immediately when
1782 the user tries to resume the execution in the inferior.
1783 This is a classic race that we should try to fix one day. */
1784 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1785 retval
= get_windows_debug_event (pid
, ourstatus
);
1786 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1789 return ptid_t (current_event
.dwProcessId
, 0, retval
);
1794 if (deprecated_ui_loop_hook
!= NULL
)
1795 detach
= deprecated_ui_loop_hook (0);
1803 /* Iterate over all DLLs currently mapped by our inferior, and
1804 add them to our list of solibs. */
1807 windows_add_all_dlls (void)
1809 HMODULE dummy_hmodule
;
1814 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
1815 sizeof (HMODULE
), &cb_needed
) == 0)
1821 hmodules
= (HMODULE
*) alloca (cb_needed
);
1822 if (EnumProcessModules (current_process_handle
, hmodules
,
1823 cb_needed
, &cb_needed
) == 0)
1826 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
1830 wchar_t dll_name
[__PMAX
];
1833 char dll_name
[__PMAX
];
1836 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
1837 &mi
, sizeof (mi
)) == 0)
1839 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
1840 dll_name
, sizeof (dll_name
)) == 0)
1843 wcstombs (name
, dll_name
, __PMAX
);
1848 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
1849 solib_end
= solib_end
->next
;
1854 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1857 struct inferior
*inf
;
1859 last_sig
= GDB_SIGNAL_0
;
1861 exception_count
= 0;
1862 open_process_used
= 0;
1863 debug_registers_changed
= 0;
1864 debug_registers_used
= 0;
1865 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1868 cygwin_load_start
= cygwin_load_end
= 0;
1870 current_event
.dwProcessId
= pid
;
1871 memset (¤t_event
, 0, sizeof (current_event
));
1872 if (!target_is_pushed (ops
))
1874 disable_breakpoints_in_shlibs ();
1875 windows_clear_solib ();
1876 clear_proceed_status (0);
1877 init_wait_for_inferior ();
1879 inf
= current_inferior ();
1880 inferior_appeared (inf
, pid
);
1881 inf
->attach_flag
= attaching
;
1883 /* Make the new process the current inferior, so terminal handling
1884 can rely on it. When attaching, we don't know about any thread
1885 id here, but that's OK --- nothing should be referencing the
1886 current thread until we report an event out of windows_wait. */
1887 inferior_ptid
= ptid_t (pid
);
1889 target_terminal::init ();
1890 target_terminal::inferior ();
1892 windows_initialization_done
= 0;
1896 struct target_waitstatus status
;
1898 ops
->wait (minus_one_ptid
, &status
, 0);
1900 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
1902 if (status
.kind
!= TARGET_WAITKIND_LOADED
1903 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
1906 ops
->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
1909 /* Now that the inferior has been started and all DLLs have been mapped,
1910 we can iterate over all DLLs and load them in.
1912 We avoid doing it any earlier because, on certain versions of Windows,
1913 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
1914 we have seen on Windows 8.1 that the ntdll.dll load event does not
1915 include the DLL name, preventing us from creating an associated SO.
1916 A possible explanation is that ntdll.dll might be mapped before
1917 the SO info gets created by the Windows system -- ntdll.dll is
1918 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
1919 do not seem to suffer from that problem.
1921 Rather than try to work around this sort of issue, it is much
1922 simpler to just ignore DLL load/unload events during the startup
1923 phase, and then process them all in one batch now. */
1924 windows_add_all_dlls ();
1926 windows_initialization_done
= 1;
1930 /* Try to set or remove a user privilege to the current process. Return -1
1931 if that fails, the previous setting of that privilege otherwise.
1933 This code is copied from the Cygwin source code and rearranged to allow
1934 dynamically loading of the needed symbols from advapi32 which is only
1935 available on NT/2K/XP. */
1937 set_process_privilege (const char *privilege
, BOOL enable
)
1939 HANDLE token_hdl
= NULL
;
1941 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1945 if (!OpenProcessToken (GetCurrentProcess (),
1946 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1950 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
1953 new_priv
.PrivilegeCount
= 1;
1954 new_priv
.Privileges
[0].Luid
= restore_priv
;
1955 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1957 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1958 sizeof orig_priv
, &orig_priv
, &size
))
1961 /* Disabled, otherwise every `attach' in an unprivileged user session
1962 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1963 windows_attach(). */
1964 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1965 be enabled. GetLastError () returns an correct error code, though. */
1966 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1970 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1974 CloseHandle (token_hdl
);
1979 /* Attach to process PID, then initialize for debugging it. */
1982 windows_nat_target::attach (const char *args
, int from_tty
)
1987 pid
= parse_pid_to_attach (args
);
1989 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1991 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1992 printf_unfiltered ("This can cause attach to "
1993 "fail on Windows NT/2K/XP\n");
1996 windows_init_thread_list ();
1997 ok
= DebugActiveProcess (pid
);
2003 /* Try fall back to Cygwin pid. */
2004 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
2007 ok
= DebugActiveProcess (pid
);
2012 error (_("Can't attach to process %u (error %u)"),
2013 (unsigned) pid
, (unsigned) GetLastError ());
2015 DebugSetProcessKillOnExit (FALSE
);
2019 const char *exec_file
= get_exec_file (0);
2022 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
2023 target_pid_to_str (ptid_t (pid
)).c_str ());
2025 printf_unfiltered ("Attaching to %s\n",
2026 target_pid_to_str (ptid_t (pid
)).c_str ());
2029 do_initial_windows_stuff (this, pid
, 1);
2030 target_terminal::ours ();
2034 windows_nat_target::detach (inferior
*inf
, int from_tty
)
2038 ptid_t ptid
= minus_one_ptid
;
2039 resume (ptid
, 0, GDB_SIGNAL_0
);
2041 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
2043 error (_("Can't detach process %u (error %u)"),
2044 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
2047 DebugSetProcessKillOnExit (FALSE
);
2049 if (detached
&& from_tty
)
2051 const char *exec_file
= get_exec_file (0);
2054 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
2055 (unsigned) current_event
.dwProcessId
);
2058 x86_cleanup_dregs ();
2059 inferior_ptid
= null_ptid
;
2060 detach_inferior (inf
);
2062 maybe_unpush_target ();
2065 /* Try to determine the executable filename.
2067 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2069 Upon success, the filename is stored inside EXE_NAME_RET, and
2070 this function returns nonzero.
2072 Otherwise, this function returns zero and the contents of
2073 EXE_NAME_RET is undefined. */
2076 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2083 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2084 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2087 /* We know the executable is always first in the list of modules,
2088 which we just fetched. So no need to fetch more. */
2092 /* Cygwin prefers that the path be in /x/y/z format, so extract
2093 the filename into a temporary buffer first, and then convert it
2094 to POSIX format into the destination buffer. */
2095 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2097 len
= GetModuleFileNameEx (current_process_handle
,
2098 dh_buf
, pathbuf
, exe_name_max_len
);
2100 error (_("Error getting executable filename: %u."),
2101 (unsigned) GetLastError ());
2102 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2103 exe_name_max_len
) < 0)
2104 error (_("Error converting executable filename to POSIX: %d."), errno
);
2107 len
= GetModuleFileNameEx (current_process_handle
,
2108 dh_buf
, exe_name_ret
, exe_name_max_len
);
2110 error (_("Error getting executable filename: %u."),
2111 (unsigned) GetLastError ());
2114 return 1; /* success */
2117 /* The pid_to_exec_file target_ops method for this platform. */
2120 windows_nat_target::pid_to_exec_file (int pid
)
2122 static char path
[__PMAX
];
2124 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2126 char procexe
[sizeof ("/proc/4294967295/exe")];
2128 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2129 nchars
= readlink (procexe
, path
, sizeof(path
));
2130 if (nchars
> 0 && nchars
< sizeof (path
))
2132 path
[nchars
] = '\0'; /* Got it */
2137 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2138 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2139 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2145 /* Print status information about what we're accessing. */
2148 windows_nat_target::files_info ()
2150 struct inferior
*inf
= current_inferior ();
2152 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2153 inf
->attach_flag
? "attached" : "child",
2154 target_pid_to_str (inferior_ptid
).c_str ());
2157 /* Modify CreateProcess parameters for use of a new separate console.
2159 *FLAGS: DWORD parameter for general process creation flags.
2160 *SI: STARTUPINFO structure, for which the console window size and
2161 console buffer size is filled in if GDB is running in a console.
2162 to create the new console.
2163 The size of the used font is not available on all versions of
2164 Windows OS. Furthermore, the current font might not be the default
2165 font, but this is still better than before.
2166 If the windows and buffer sizes are computed,
2167 SI->DWFLAGS is changed so that this information is used
2168 by CreateProcess function. */
2171 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2173 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2174 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2176 if (hconsole
!= INVALID_HANDLE_VALUE
)
2178 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2180 CONSOLE_FONT_INFO cfi
;
2182 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2183 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2184 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2185 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2186 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2188 si
->dwXSize
*= font_size
.X
;
2192 si
->dwYSize
*= font_size
.Y
;
2195 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2196 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2197 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2199 *flags
|= CREATE_NEW_CONSOLE
;
2203 /* Function called by qsort to sort environment strings. */
2206 envvar_cmp (const void *a
, const void *b
)
2208 const char **p
= (const char **) a
;
2209 const char **q
= (const char **) b
;
2210 return strcasecmp (*p
, *q
);
2216 clear_win32_environment (char **env
)
2220 wchar_t *copy
= NULL
, *equalpos
;
2222 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2224 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2225 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2226 mbstowcs (copy
, env
[i
], len
);
2227 equalpos
= wcschr (copy
, L
'=');
2230 SetEnvironmentVariableW (copy
, NULL
);
2238 /* Redirection of inferior I/O streams for native MS-Windows programs.
2239 Unlike on Unix, where this is handled by invoking the inferior via
2240 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2242 The official documentation of the cmd.exe redirection features is here:
2244 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2246 (That page talks about Windows XP, but there's no newer
2247 documentation, so we assume later versions of cmd.exe didn't change
2250 Caveat: the documentation on that page seems to include a few lies.
2251 For example, it describes strange constructs 1<&2 and 2<&1, which
2252 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2253 think the cmd.exe parser of the redirection symbols simply doesn't
2254 care about the < vs > distinction in these cases. Therefore, the
2255 supported features are explicitly documented below.
2257 The emulation below aims at supporting all the valid use cases
2258 supported by cmd.exe, which include:
2260 < FILE redirect standard input from FILE
2261 0< FILE redirect standard input from FILE
2262 <&N redirect standard input from file descriptor N
2263 0<&N redirect standard input from file descriptor N
2264 > FILE redirect standard output to FILE
2265 >> FILE append standard output to FILE
2266 1>> FILE append standard output to FILE
2267 >&N redirect standard output to file descriptor N
2268 1>&N redirect standard output to file descriptor N
2269 >>&N append standard output to file descriptor N
2270 1>>&N append standard output to file descriptor N
2271 2> FILE redirect standard error to FILE
2272 2>> FILE append standard error to FILE
2273 2>&N redirect standard error to file descriptor N
2274 2>>&N append standard error to file descriptor N
2276 Note that using N > 2 in the above construct is supported, but
2277 requires that the corresponding file descriptor be open by some
2278 means elsewhere or outside GDB. Also note that using ">&0" or
2279 "<&2" will generally fail, because the file descriptor redirected
2280 from is normally open in an incompatible mode (e.g., FD 0 is open
2281 for reading only). IOW, use of such tricks is not recommended;
2282 you are on your own.
2284 We do NOT support redirection of file descriptors above 2, as in
2285 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2286 that needs special handling in the startup code that MinGW
2287 doesn't have). Pipes are also not supported.
2289 As for invalid use cases, where the redirection contains some
2290 error, the emulation below will detect that and produce some
2291 error and/or failure. But the behavior in those cases is not
2292 bug-for-bug compatible with what cmd.exe does in those cases.
2293 That's because what cmd.exe does then is not well defined, and
2294 seems to be a side effect of the cmd.exe parsing of the command
2295 line more than anything else. For example, try redirecting to an
2296 invalid file name, as in "> foo:bar".
2298 There are also minor syntactic deviations from what cmd.exe does
2299 in some corner cases. For example, it doesn't support the likes
2300 of "> &foo" to mean redirect to file named literally "&foo"; we
2301 do support that here, because that, too, sounds like some issue
2302 with the cmd.exe parser. Another nicety is that we support
2303 redirection targets that use file names with forward slashes,
2304 something cmd.exe doesn't -- this comes in handy since GDB
2305 file-name completion can be used when typing the command line for
2308 /* Support routines for redirecting standard handles of the inferior. */
2310 /* Parse a single redirection spec, open/duplicate the specified
2311 file/fd, and assign the appropriate value to one of the 3 standard
2312 file descriptors. */
2314 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2316 int *fd
, ref_fd
= -2;
2318 const char *fname
= redir_string
+ 1;
2319 int rc
= *redir_string
;
2334 fd
= (rc
== '2') ? err
: out
;
2335 mode
= O_WRONLY
| O_CREAT
;
2348 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2350 /* A reference to a file descriptor. */
2352 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2353 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2355 /* Don't allow redirection when open modes are incompatible. */
2356 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2357 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2364 else if (ref_fd
== 1)
2366 else if (ref_fd
== 2)
2376 fname
++; /* skip the separator space */
2377 /* If the descriptor is already open, close it. This allows
2378 multiple specs of redirections for the same stream, which is
2379 somewhat nonsensical, but still valid and supported by cmd.exe.
2380 (But cmd.exe only opens a single file in this case, the one
2381 specified by the last redirection spec on the command line.) */
2386 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2390 else if (ref_fd
== -1)
2391 *fd
= -1; /* reset to default destination */
2394 *fd
= _dup (ref_fd
);
2398 /* _open just sets a flag for O_APPEND, which won't be passed to the
2399 inferior, so we need to actually move the file pointer. */
2400 if ((mode
& O_APPEND
) != 0)
2401 _lseek (*fd
, 0L, SEEK_END
);
2405 /* Canonicalize a single redirection spec and set up the corresponding
2406 file descriptor as specified. */
2408 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2410 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2412 const char *start
= s
;
2415 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2416 if ((*start
== '>' || *start
== '1' || *start
== '2')
2420 if (*s
== '>' && *start
!= '>')
2423 else if (*start
== '0' && *s
== '<')
2425 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2428 while (isspace (*s
)) /* skip whitespace before file name */
2430 *d
++ = ' '; /* separate file name with a single space */
2433 /* Copy the file name. */
2436 /* Remove quoting characters from the file name in buf[]. */
2437 if (*s
== '"') /* could support '..' quoting here */
2441 else if (*s
== quote
)
2449 else if (*s
== '\\')
2451 if (s
[1] == '"') /* could support '..' here */
2455 else if (isspace (*s
) && !quote
)
2459 if (d
- buf
>= sizeof (buf
) - 1)
2461 errno
= ENAMETOOLONG
;
2467 /* Windows doesn't allow redirection characters in file names, so we
2468 can bail out early if they use them, or if there's no target file
2469 name after the redirection symbol. */
2470 if (d
[-1] == '>' || d
[-1] == '<')
2475 if (redir_open (buf
, inp
, out
, err
) == 0)
2480 /* Parse the command line for redirection specs and prepare the file
2481 descriptors for the 3 standard streams accordingly. */
2483 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2484 int *inp
, int *out
, int *err
)
2486 const char *s
= cmd_orig
;
2489 bool retval
= false;
2491 while (isspace (*s
))
2496 if (*s
== '"') /* could also support '..' quoting here */
2500 else if (*s
== quote
)
2503 else if (*s
== '\\')
2505 if (s
[1] == '"') /* escaped quote char */
2510 /* Process a single redirection candidate. */
2511 if (*s
== '<' || *s
== '>'
2512 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2513 || (*s
== '0' && s
[1] == '<'))
2515 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2529 #endif /* !__CYGWIN__ */
2531 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2532 EXEC_FILE is the file to run.
2533 ALLARGS is a string containing the arguments to the program.
2534 ENV is the environment vector to pass. Errors reported with error(). */
2537 windows_nat_target::create_inferior (const char *exec_file
,
2538 const std::string
&origallargs
,
2539 char **in_env
, int from_tty
)
2543 cygwin_buf_t real_path
[__PMAX
];
2544 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2545 cygwin_buf_t infcwd
[__PMAX
];
2547 cygwin_buf_t
*toexec
;
2548 cygwin_buf_t
*cygallargs
;
2550 char **old_env
= NULL
;
2554 int ostdin
, ostdout
, ostderr
;
2555 #else /* !__CYGWIN__ */
2556 char shell
[__PMAX
]; /* Path to shell */
2558 char *args
, *allargs_copy
;
2559 size_t args_len
, allargs_len
;
2560 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2561 HANDLE tty
= INVALID_HANDLE_VALUE
;
2562 bool redirected
= false;
2569 #endif /* !__CYGWIN__ */
2570 const char *allargs
= origallargs
.c_str ();
2571 PROCESS_INFORMATION pi
;
2574 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2577 error (_("No executable specified, use `target exec'."));
2579 const char *inferior_cwd
= get_inferior_cwd ();
2580 std::string expanded_infcwd
;
2581 if (inferior_cwd
!= NULL
)
2583 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
2584 /* Mirror slashes on inferior's cwd. */
2585 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
2587 inferior_cwd
= expanded_infcwd
.c_str ();
2590 memset (&si
, 0, sizeof (si
));
2591 si
.cb
= sizeof (si
);
2594 flags
|= CREATE_NEW_PROCESS_GROUP
;
2597 windows_set_console_info (&si
, &flags
);
2602 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2603 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2604 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2605 error (_("Error starting executable: %d"), errno
);
2608 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2609 if (len
== (size_t) -1)
2610 error (_("Error starting executable: %d"), errno
);
2611 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2612 mbstowcs (cygallargs
, allargs
, len
);
2613 #else /* !__USEWIDE */
2614 cygallargs
= allargs
;
2620 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2621 error (_("Error starting executable via shell: %d"), errno
);
2623 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2624 + mbstowcs (NULL
, allargs
, 0) + 2;
2625 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2626 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2627 #else /* !__USEWIDE */
2628 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2629 + strlen (allargs
) + 2);
2630 cygallargs
= (char *) alloca (len
);
2631 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2632 #endif /* __USEWIDE */
2634 flags
|= DEBUG_PROCESS
;
2637 if (inferior_cwd
!= NULL
2638 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
2639 infcwd
, strlen (inferior_cwd
)) < 0)
2640 error (_("Error converting inferior cwd: %d"), errno
);
2643 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2644 * sizeof (wchar_t));
2645 wcscpy (args
, toexec
);
2646 wcscat (args
, L
" ");
2647 wcscat (args
, cygallargs
);
2648 #else /* !__USEWIDE */
2649 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2650 strcpy (args
, toexec
);
2652 strcat (args
, cygallargs
);
2653 #endif /* !__USEWIDE */
2655 #ifdef CW_CVT_ENV_TO_WINENV
2656 /* First try to create a direct Win32 copy of the POSIX environment. */
2657 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2658 if (w32_env
!= (PWCHAR
) -1)
2659 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2661 /* If that fails, fall back to old method tweaking GDB's environment. */
2662 #endif /* CW_CVT_ENV_TO_WINENV */
2664 /* Reset all Win32 environment variables to avoid leftover on next run. */
2665 clear_win32_environment (environ
);
2666 /* Prepare the environment vars for CreateProcess. */
2669 cygwin_internal (CW_SYNC_WINENV
);
2673 if (!inferior_io_terminal
)
2674 tty
= ostdin
= ostdout
= ostderr
= -1;
2677 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2680 print_sys_errmsg (inferior_io_terminal
, errno
);
2681 ostdin
= ostdout
= ostderr
= -1;
2694 windows_init_thread_list ();
2695 ret
= CreateProcess (0,
2696 args
, /* command line */
2697 NULL
, /* Security */
2699 TRUE
, /* inherit handles */
2700 flags
, /* start flags */
2701 w32_env
, /* environment */
2702 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
2707 /* Just free the Win32 environment, if it could be created. */
2711 /* Reset all environment variables to avoid leftover on next run. */
2712 clear_win32_environment (in_env
);
2713 /* Restore normal GDB environment variables. */
2715 cygwin_internal (CW_SYNC_WINENV
);
2728 #else /* !__CYGWIN__ */
2729 allargs_len
= strlen (allargs
);
2730 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
2731 if (strpbrk (allargs_copy
, "<>") != NULL
)
2736 redirect_inferior_handles (allargs
, allargs_copy
,
2737 &fd_inp
, &fd_out
, &fd_err
);
2739 warning (_("Error in redirection: %s."), safe_strerror (errno
));
2742 allargs_len
= strlen (allargs_copy
);
2744 /* If not all the standard streams are redirected by the command
2745 line, use inferior_io_terminal for those which aren't. */
2746 if (inferior_io_terminal
2747 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
2749 SECURITY_ATTRIBUTES sa
;
2750 sa
.nLength
= sizeof(sa
);
2751 sa
.lpSecurityDescriptor
= 0;
2752 sa
.bInheritHandle
= TRUE
;
2753 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2754 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2755 if (tty
== INVALID_HANDLE_VALUE
)
2756 warning (_("Warning: Failed to open TTY %s, error %#x."),
2757 inferior_io_terminal
, (unsigned) GetLastError ());
2759 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
2762 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
2763 else if (tty
!= INVALID_HANDLE_VALUE
)
2766 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
2768 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
2769 else if (tty
!= INVALID_HANDLE_VALUE
)
2770 si
.hStdOutput
= tty
;
2772 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
2774 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
2775 else if (tty
!= INVALID_HANDLE_VALUE
)
2778 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
2779 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2783 /* Build the command line, a space-separated list of tokens where
2784 the first token is the name of the module to be executed.
2785 To avoid ambiguities introduced by spaces in the module name,
2787 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
2788 args
= (char *) alloca (args_len
);
2789 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
2791 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2793 /* CreateProcess takes the environment list as a null terminated set of
2794 strings (i.e. two nulls terminate the list). */
2796 /* Get total size for env strings. */
2797 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2798 envlen
+= strlen (in_env
[i
]) + 1;
2800 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2801 env
= (char **) alloca (envsize
);
2802 memcpy (env
, in_env
, envsize
);
2803 /* Windows programs expect the environment block to be sorted. */
2804 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2806 w32env
= (char *) alloca (envlen
+ 1);
2808 /* Copy env strings into new buffer. */
2809 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2811 strcpy (temp
, env
[i
]);
2812 temp
+= strlen (temp
) + 1;
2815 /* Final nil string to terminate new env. */
2818 windows_init_thread_list ();
2819 ret
= CreateProcessA (0,
2820 args
, /* command line */
2821 NULL
, /* Security */
2823 TRUE
, /* inherit handles */
2824 flags
, /* start flags */
2825 w32env
, /* environment */
2826 inferior_cwd
, /* current directory */
2829 if (tty
!= INVALID_HANDLE_VALUE
)
2837 #endif /* !__CYGWIN__ */
2840 error (_("Error creating process %s, (error %u)."),
2841 exec_file
, (unsigned) GetLastError ());
2843 CloseHandle (pi
.hThread
);
2844 CloseHandle (pi
.hProcess
);
2846 if (useshell
&& shell
[0] != '\0')
2851 do_initial_windows_stuff (this, pi
.dwProcessId
, 0);
2853 /* windows_continue (DBG_CONTINUE, -1, 0); */
2857 windows_nat_target::mourn_inferior ()
2859 (void) windows_continue (DBG_CONTINUE
, -1, 0);
2860 x86_cleanup_dregs();
2861 if (open_process_used
)
2863 CHECK (CloseHandle (current_process_handle
));
2864 open_process_used
= 0;
2866 inf_child_target::mourn_inferior ();
2869 /* Send a SIGINT to the process group. This acts just like the user typed a
2870 ^C on the controlling terminal. */
2873 windows_nat_target::interrupt ()
2875 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2876 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
2877 registers_changed (); /* refresh register state */
2880 /* Helper for windows_xfer_partial that handles memory transfers.
2881 Arguments are like target_xfer_partial. */
2883 static enum target_xfer_status
2884 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2885 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2889 DWORD lasterror
= 0;
2891 if (writebuf
!= NULL
)
2893 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
2894 pulongest (len
), core_addr_to_string (memaddr
)));
2895 success
= WriteProcessMemory (current_process_handle
,
2896 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
2899 lasterror
= GetLastError ();
2900 FlushInstructionCache (current_process_handle
,
2901 (LPCVOID
) (uintptr_t) memaddr
, len
);
2905 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
2906 pulongest (len
), core_addr_to_string (memaddr
)));
2907 success
= ReadProcessMemory (current_process_handle
,
2908 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
2911 lasterror
= GetLastError ();
2913 *xfered_len
= (ULONGEST
) done
;
2914 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
2915 return TARGET_XFER_OK
;
2917 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
2921 windows_nat_target::kill ()
2923 CHECK (TerminateProcess (current_process_handle
, 0));
2927 if (!windows_continue (DBG_CONTINUE
, -1, 1))
2929 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
2931 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2935 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
2939 windows_nat_target::close ()
2941 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2942 inferior_ptid
.pid ()));
2945 /* Convert pid to printable format. */
2947 windows_nat_target::pid_to_str (ptid_t ptid
)
2949 if (ptid
.tid () != 0)
2950 return string_printf ("Thread %d.0x%lx", ptid
.pid (), ptid
.tid ());
2952 return normal_pid_to_str (ptid
);
2955 static enum target_xfer_status
2956 windows_xfer_shared_libraries (struct target_ops
*ops
,
2957 enum target_object object
, const char *annex
,
2958 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2959 ULONGEST offset
, ULONGEST len
,
2960 ULONGEST
*xfered_len
)
2962 struct obstack obstack
;
2968 return TARGET_XFER_E_IO
;
2970 obstack_init (&obstack
);
2971 obstack_grow_str (&obstack
, "<library-list>\n");
2972 for (so
= solib_start
.next
; so
; so
= so
->next
)
2974 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
2976 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
2977 (uintptr_t) li
->load_addr
,
2979 target_gdbarch (), &obstack
);
2981 obstack_grow_str0 (&obstack
, "</library-list>\n");
2983 buf
= (const char *) obstack_finish (&obstack
);
2984 len_avail
= strlen (buf
);
2985 if (offset
>= len_avail
)
2989 if (len
> len_avail
- offset
)
2990 len
= len_avail
- offset
;
2991 memcpy (readbuf
, buf
+ offset
, len
);
2994 obstack_free (&obstack
, NULL
);
2995 *xfered_len
= (ULONGEST
) len
;
2996 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
2999 enum target_xfer_status
3000 windows_nat_target::xfer_partial (enum target_object object
,
3001 const char *annex
, gdb_byte
*readbuf
,
3002 const gdb_byte
*writebuf
, ULONGEST offset
,
3003 ULONGEST len
, ULONGEST
*xfered_len
)
3007 case TARGET_OBJECT_MEMORY
:
3008 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
3010 case TARGET_OBJECT_LIBRARIES
:
3011 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
3012 writebuf
, offset
, len
, xfered_len
);
3015 if (beneath () == NULL
)
3017 /* This can happen when requesting the transfer of unsupported
3018 objects before a program has been started (and therefore
3019 with the current_target having no target beneath). */
3020 return TARGET_XFER_E_IO
;
3022 return beneath ()->xfer_partial (object
, annex
,
3023 readbuf
, writebuf
, offset
, len
,
3028 /* Provide thread local base, i.e. Thread Information Block address.
3029 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
3032 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
3034 windows_thread_info
*th
;
3036 th
= thread_rec (ptid
.tid (), 0);
3041 *addr
= th
->thread_local_base
;
3047 windows_nat_target::get_ada_task_ptid (long lwp
, long thread
)
3049 return ptid_t (inferior_ptid
.pid (), 0, lwp
);
3052 /* Implementation of the to_thread_name method. */
3055 windows_nat_target::thread_name (struct thread_info
*thr
)
3057 return thread_rec (thr
->ptid
.tid (), 0)->name
;
3061 void _initialize_windows_nat ();
3063 _initialize_windows_nat ()
3065 x86_dr_low
.set_control
= cygwin_set_dr7
;
3066 x86_dr_low
.set_addr
= cygwin_set_dr
;
3067 x86_dr_low
.get_addr
= cygwin_get_dr
;
3068 x86_dr_low
.get_status
= cygwin_get_dr6
;
3069 x86_dr_low
.get_control
= cygwin_get_dr7
;
3071 /* x86_dr_low.debug_register_length field is set by
3072 calling x86_set_debug_register_length function
3073 in processor windows specific native file. */
3075 add_inf_child_target (&the_windows_nat_target
);
3078 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3081 add_com ("signal-event", class_run
, signal_event_command
, _("\
3082 Signal a crashed process with event ID, to allow its debugging.\n\
3083 This command is needed in support of setting up GDB as JIT debugger on \
3084 MS-Windows. The command should be invoked from the GDB command line using \
3085 the '-ex' command-line option. The ID of the event that blocks the \
3086 crashed process will be supplied by the Windows JIT debugging mechanism."));
3089 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3090 Set use of shell to start subprocess."), _("\
3091 Show use of shell to start subprocess."), NULL
,
3093 NULL
, /* FIXME: i18n: */
3094 &setlist
, &showlist
);
3096 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3097 &cygwin_exceptions
, _("\
3098 Break when an exception is detected in the Cygwin DLL itself."), _("\
3099 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3101 NULL
, /* FIXME: i18n: */
3102 &setlist
, &showlist
);
3105 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3106 Set creation of new console when creating child process."), _("\
3107 Show creation of new console when creating child process."), NULL
,
3109 NULL
, /* FIXME: i18n: */
3110 &setlist
, &showlist
);
3112 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3113 Set creation of new group when creating child process."), _("\
3114 Show creation of new group when creating child process."), NULL
,
3116 NULL
, /* FIXME: i18n: */
3117 &setlist
, &showlist
);
3119 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3120 Set whether to display execution in child process."), _("\
3121 Show whether to display execution in child process."), NULL
,
3123 NULL
, /* FIXME: i18n: */
3124 &setlist
, &showlist
);
3126 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3127 Set whether to display kernel events in child process."), _("\
3128 Show whether to display kernel events in child process."), NULL
,
3130 NULL
, /* FIXME: i18n: */
3131 &setlist
, &showlist
);
3133 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3134 Set whether to display memory accesses in child process."), _("\
3135 Show whether to display memory accesses in child process."), NULL
,
3137 NULL
, /* FIXME: i18n: */
3138 &setlist
, &showlist
);
3140 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3141 &debug_exceptions
, _("\
3142 Set whether to display kernel exceptions in child process."), _("\
3143 Show whether to display kernel exceptions in child process."), NULL
,
3145 NULL
, /* FIXME: i18n: */
3146 &setlist
, &showlist
);
3148 init_w32_command_list ();
3150 add_cmd ("selector", class_info
, display_selectors
,
3151 _("Display selectors infos."),
3155 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3157 /* Pass the address ADDR to the inferior in the I'th debug register.
3158 Here we just store the address in dr array, the registers will be
3159 actually set up when windows_continue is called. */
3161 cygwin_set_dr (int i
, CORE_ADDR addr
)
3164 internal_error (__FILE__
, __LINE__
,
3165 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3167 debug_registers_changed
= 1;
3168 debug_registers_used
= 1;
3171 /* Pass the value VAL to the inferior in the DR7 debug control
3172 register. Here we just store the address in D_REGS, the watchpoint
3173 will be actually set up in windows_wait. */
3175 cygwin_set_dr7 (unsigned long val
)
3177 dr
[7] = (CORE_ADDR
) val
;
3178 debug_registers_changed
= 1;
3179 debug_registers_used
= 1;
3182 /* Get the value of debug register I from the inferior. */
3185 cygwin_get_dr (int i
)
3190 /* Get the value of the DR6 debug status register from the inferior.
3191 Here we just return the value stored in dr[6]
3192 by the last call to thread_rec for current_event.dwThreadId id. */
3193 static unsigned long
3194 cygwin_get_dr6 (void)
3196 return (unsigned long) dr
[6];
3199 /* Get the value of the DR7 debug status register from the inferior.
3200 Here we just return the value stored in dr[7] by the last call to
3201 thread_rec for current_event.dwThreadId id. */
3203 static unsigned long
3204 cygwin_get_dr7 (void)
3206 return (unsigned long) dr
[7];
3209 /* Determine if the thread referenced by "ptid" is alive
3210 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3211 it means that the thread has died. Otherwise it is assumed to be alive. */
3214 windows_nat_target::thread_alive (ptid_t ptid
)
3218 gdb_assert (ptid
.tid () != 0);
3221 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) != WAIT_OBJECT_0
;
3224 void _initialize_check_for_gdb_ini ();
3226 _initialize_check_for_gdb_ini ()
3229 if (inhibit_gdbinit
)
3232 homedir
= getenv ("HOME");
3236 char *oldini
= (char *) alloca (strlen (homedir
) +
3237 sizeof ("gdb.ini") + 1);
3238 strcpy (oldini
, homedir
);
3239 p
= strchr (oldini
, '\0');
3240 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3242 strcpy (p
, "gdb.ini");
3243 if (access (oldini
, 0) == 0)
3245 int len
= strlen (oldini
);
3246 char *newini
= (char *) alloca (len
+ 2);
3248 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3249 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3250 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3255 /* Define dummy functions which always return error for the rare cases where
3256 these functions could not be found. */
3258 bad_DebugActiveProcessStop (DWORD w
)
3263 bad_DebugBreakProcess (HANDLE w
)
3268 bad_DebugSetProcessKillOnExit (BOOL w
)
3273 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3280 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3286 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3293 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3299 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3305 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3311 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3319 /* Load any functions which may not be available in ancient versions
3322 void _initialize_loadable ();
3324 _initialize_loadable ()
3328 #define GPA(m, func) \
3329 func = (func ## _ftype *) GetProcAddress (m, #func)
3331 hm
= LoadLibrary ("kernel32.dll");
3334 GPA (hm
, DebugActiveProcessStop
);
3335 GPA (hm
, DebugBreakProcess
);
3336 GPA (hm
, DebugSetProcessKillOnExit
);
3337 GPA (hm
, GetConsoleFontSize
);
3338 GPA (hm
, DebugActiveProcessStop
);
3339 GPA (hm
, GetCurrentConsoleFont
);
3342 /* Set variables to dummy versions of these processes if the function
3343 wasn't found in kernel32.dll. */
3344 if (!DebugBreakProcess
)
3345 DebugBreakProcess
= bad_DebugBreakProcess
;
3346 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3348 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3349 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3351 if (!GetConsoleFontSize
)
3352 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3353 if (!GetCurrentConsoleFont
)
3354 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3356 /* Load optional functions used for retrieving filename information
3357 associated with the currently debugged process or its dlls. */
3358 hm
= LoadLibrary ("psapi.dll");
3361 GPA (hm
, EnumProcessModules
);
3362 GPA (hm
, GetModuleInformation
);
3363 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3364 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3367 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3369 /* Set variables to dummy versions of these processes if the function
3370 wasn't found in psapi.dll. */
3371 EnumProcessModules
= bad_EnumProcessModules
;
3372 GetModuleInformation
= bad_GetModuleInformation
;
3373 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3374 /* This will probably fail on Windows 9x/Me. Let the user know
3375 that we're missing some functionality. */
3377 cannot automatically find executable file or library to read symbols.\n\
3378 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3381 hm
= LoadLibrary ("advapi32.dll");
3384 GPA (hm
, OpenProcessToken
);
3385 GPA (hm
, LookupPrivilegeValueA
);
3386 GPA (hm
, AdjustTokenPrivileges
);
3387 /* Only need to set one of these since if OpenProcessToken fails nothing
3389 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3390 || !AdjustTokenPrivileges
)
3391 OpenProcessToken
= bad_OpenProcessToken
;