1 /* Target-vector operations for controlling windows child processes, for GDB.
3 Copyright (C) 1995-2019 Free Software Foundation, Inc.
5 Contributed by Cygnus Solutions, A Red Hat Company.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 /* Originally by Steve Chamberlain, sac@cygnus.com */
25 #include "frame.h" /* required by inferior.h */
31 #include "completer.h"
35 #include <sys/types.h>
42 #include <sys/cygwin.h>
43 #include <cygwin/version.h>
47 #include "buildsym-legacy.h"
48 #include "filenames.h"
52 #include "gdb_obstack.h"
53 #include "gdbthread.h"
59 #include "xml-support.h"
62 #include "i386-tdep.h"
63 #include "i387-tdep.h"
65 #include "windows-tdep.h"
66 #include "windows-nat.h"
68 #include "complaints.h"
69 #include "inf-child.h"
70 #include "common/gdb_tilde_expand.h"
71 #include "common/pathstuff.h"
73 #define AdjustTokenPrivileges dyn_AdjustTokenPrivileges
74 #define DebugActiveProcessStop dyn_DebugActiveProcessStop
75 #define DebugBreakProcess dyn_DebugBreakProcess
76 #define DebugSetProcessKillOnExit dyn_DebugSetProcessKillOnExit
77 #define EnumProcessModules dyn_EnumProcessModules
78 #define GetModuleInformation dyn_GetModuleInformation
79 #define LookupPrivilegeValueA dyn_LookupPrivilegeValueA
80 #define OpenProcessToken dyn_OpenProcessToken
81 #define GetConsoleFontSize dyn_GetConsoleFontSize
82 #define GetCurrentConsoleFont dyn_GetCurrentConsoleFont
84 typedef BOOL
WINAPI (AdjustTokenPrivileges_ftype
) (HANDLE
, BOOL
,
86 DWORD
, PTOKEN_PRIVILEGES
,
88 static AdjustTokenPrivileges_ftype
*AdjustTokenPrivileges
;
90 typedef BOOL
WINAPI (DebugActiveProcessStop_ftype
) (DWORD
);
91 static DebugActiveProcessStop_ftype
*DebugActiveProcessStop
;
93 typedef BOOL
WINAPI (DebugBreakProcess_ftype
) (HANDLE
);
94 static DebugBreakProcess_ftype
*DebugBreakProcess
;
96 typedef BOOL
WINAPI (DebugSetProcessKillOnExit_ftype
) (BOOL
);
97 static DebugSetProcessKillOnExit_ftype
*DebugSetProcessKillOnExit
;
99 typedef BOOL
WINAPI (EnumProcessModules_ftype
) (HANDLE
, HMODULE
*, DWORD
,
101 static EnumProcessModules_ftype
*EnumProcessModules
;
103 typedef BOOL
WINAPI (GetModuleInformation_ftype
) (HANDLE
, HMODULE
,
104 LPMODULEINFO
, DWORD
);
105 static GetModuleInformation_ftype
*GetModuleInformation
;
107 typedef BOOL
WINAPI (LookupPrivilegeValueA_ftype
) (LPCSTR
, LPCSTR
, PLUID
);
108 static LookupPrivilegeValueA_ftype
*LookupPrivilegeValueA
;
110 typedef BOOL
WINAPI (OpenProcessToken_ftype
) (HANDLE
, DWORD
, PHANDLE
);
111 static OpenProcessToken_ftype
*OpenProcessToken
;
113 typedef BOOL
WINAPI (GetCurrentConsoleFont_ftype
) (HANDLE
, BOOL
,
114 CONSOLE_FONT_INFO
*);
115 static GetCurrentConsoleFont_ftype
*GetCurrentConsoleFont
;
117 typedef COORD
WINAPI (GetConsoleFontSize_ftype
) (HANDLE
, DWORD
);
118 static GetConsoleFontSize_ftype
*GetConsoleFontSize
;
122 #undef GetModuleFileNameEx
125 # define __PMAX (MAX_PATH + 1)
126 typedef DWORD
WINAPI (GetModuleFileNameEx_ftype
) (HANDLE
, HMODULE
, LPSTR
, DWORD
);
127 static GetModuleFileNameEx_ftype
*GetModuleFileNameEx
;
128 # define STARTUPINFO STARTUPINFOA
129 # define CreateProcess CreateProcessA
130 # define GetModuleFileNameEx_name "GetModuleFileNameExA"
131 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
133 # define __PMAX PATH_MAX
134 /* The starting and ending address of the cygwin1.dll text segment. */
135 static CORE_ADDR cygwin_load_start
;
136 static CORE_ADDR cygwin_load_end
;
138 typedef wchar_t cygwin_buf_t
;
139 typedef DWORD
WINAPI (GetModuleFileNameEx_ftype
) (HANDLE
, HMODULE
,
141 static GetModuleFileNameEx_ftype
*GetModuleFileNameEx
;
142 # define STARTUPINFO STARTUPINFOW
143 # define CreateProcess CreateProcessW
144 # define GetModuleFileNameEx_name "GetModuleFileNameExW"
145 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExW
148 static int have_saved_context
; /* True if we've saved context from a
151 static CONTEXT saved_context
; /* Containes the saved context from a
155 /* If we're not using the old Cygwin header file set, define the
156 following which never should have been in the generic Win32 API
157 headers in the first place since they were our own invention... */
158 #ifndef _GNU_H_WINDOWS_H
161 FLAG_TRACE_BIT
= 0x100,
165 #ifndef CONTEXT_EXTENDED_REGISTERS
166 /* This macro is only defined on ia32. It only makes sense on this target,
167 so define it as zero if not already defined. */
168 #define CONTEXT_EXTENDED_REGISTERS 0
171 #define CONTEXT_DEBUGGER_DR CONTEXT_FULL | CONTEXT_FLOATING_POINT \
172 | CONTEXT_SEGMENTS | CONTEXT_DEBUG_REGISTERS \
173 | CONTEXT_EXTENDED_REGISTERS
175 static uintptr_t dr
[8];
176 static int debug_registers_changed
;
177 static int debug_registers_used
;
179 static int windows_initialization_done
;
180 #define DR6_CLEAR_VALUE 0xffff0ff0
182 /* The exception thrown by a program to tell the debugger the name of
183 a thread. The exception record contains an ID of a thread and a
184 name to give it. This exception has no documented name, but MSDN
185 dubs it "MS_VC_EXCEPTION" in one code example. */
186 #define MS_VC_EXCEPTION 0x406d1388
190 HANDLE_EXCEPTION_UNHANDLED
= 0,
191 HANDLE_EXCEPTION_HANDLED
,
192 HANDLE_EXCEPTION_IGNORED
193 } handle_exception_result
;
195 /* The string sent by cygwin when it processes a signal.
196 FIXME: This should be in a cygwin include file. */
197 #ifndef _CYGWIN_SIGNAL_STRING
198 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
201 #define CHECK(x) check (x, __FILE__,__LINE__)
202 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
203 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
204 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
205 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
207 static void cygwin_set_dr (int i
, CORE_ADDR addr
);
208 static void cygwin_set_dr7 (unsigned long val
);
209 static CORE_ADDR
cygwin_get_dr (int i
);
210 static unsigned long cygwin_get_dr6 (void);
211 static unsigned long cygwin_get_dr7 (void);
213 static enum gdb_signal last_sig
= GDB_SIGNAL_0
;
214 /* Set if a signal was received from the debugged process. */
216 /* Thread information structure used to track information that is
217 not available in gdb's thread structure. */
218 typedef struct windows_thread_info_struct
220 struct windows_thread_info_struct
*next
;
223 CORE_ADDR thread_local_base
;
232 static windows_thread_info thread_head
;
234 /* The process and thread handles for the above context. */
236 static DEBUG_EVENT current_event
; /* The current debug event from
238 static HANDLE current_process_handle
; /* Currently executing process */
239 static windows_thread_info
*current_thread
; /* Info on currently selected thread */
240 static DWORD main_thread_id
; /* Thread ID of the main thread */
242 /* Counts of things. */
243 static int exception_count
= 0;
244 static int event_count
= 0;
245 static int saw_create
;
246 static int open_process_used
= 0;
249 static int new_console
= 0;
251 static int cygwin_exceptions
= 0;
253 static int new_group
= 1;
254 static int debug_exec
= 0; /* show execution */
255 static int debug_events
= 0; /* show events from kernel */
256 static int debug_memory
= 0; /* show target memory accesses */
257 static int debug_exceptions
= 0; /* show target exceptions */
258 static int useshell
= 0; /* use shell for subprocesses */
260 /* This vector maps GDB's idea of a register's number into an offset
261 in the windows exception context vector.
263 It also contains the bit mask needed to load the register in question.
265 The contents of this table can only be computed by the units
266 that provide CPU-specific support for Windows native debugging.
267 These units should set the table by calling
268 windows_set_context_register_offsets.
270 One day we could read a reg, we could inspect the context we
271 already have loaded, if it doesn't have the bit set that we need,
272 we read that set of registers in using GetThreadContext. If the
273 context already contains what we need, we just unpack it. Then to
274 write a register, first we have to ensure that the context contains
275 the other regs of the group, and then we copy the info in and set
278 static const int *mappings
;
280 /* The function to use in order to determine whether a register is
281 a segment register or not. */
282 static segment_register_p_ftype
*segment_register_p
;
284 /* See windows_nat_target::resume to understand why this is commented
287 /* This vector maps the target's idea of an exception (extracted
288 from the DEBUG_EVENT structure) to GDB's idea. */
290 struct xlate_exception
296 static const struct xlate_exception xlate
[] =
298 {EXCEPTION_ACCESS_VIOLATION
, GDB_SIGNAL_SEGV
},
299 {STATUS_STACK_OVERFLOW
, GDB_SIGNAL_SEGV
},
300 {EXCEPTION_BREAKPOINT
, GDB_SIGNAL_TRAP
},
301 {DBG_CONTROL_C
, GDB_SIGNAL_INT
},
302 {EXCEPTION_SINGLE_STEP
, GDB_SIGNAL_TRAP
},
303 {STATUS_FLOAT_DIVIDE_BY_ZERO
, GDB_SIGNAL_FPE
}
308 struct windows_nat_target final
: public x86_nat_target
<inf_child_target
>
310 void close () override
;
312 void attach (const char *, int) override
;
314 bool attach_no_wait () override
317 void detach (inferior
*, int) override
;
319 void resume (ptid_t
, int , enum gdb_signal
) override
;
321 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
323 void fetch_registers (struct regcache
*, int) override
;
324 void store_registers (struct regcache
*, int) override
;
326 enum target_xfer_status
xfer_partial (enum target_object object
,
329 const gdb_byte
*writebuf
,
330 ULONGEST offset
, ULONGEST len
,
331 ULONGEST
*xfered_len
) override
;
333 void files_info () override
;
335 void kill () override
;
337 void create_inferior (const char *, const std::string
&,
338 char **, int) override
;
340 void mourn_inferior () override
;
342 bool thread_alive (ptid_t ptid
) override
;
344 std::string
pid_to_str (ptid_t
) override
;
346 void interrupt () override
;
348 char *pid_to_exec_file (int pid
) override
;
350 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
352 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
354 const char *thread_name (struct thread_info
*) override
;
357 static windows_nat_target the_windows_nat_target
;
359 /* Set the MAPPINGS static global to OFFSETS.
360 See the description of MAPPINGS for more details. */
363 windows_set_context_register_offsets (const int *offsets
)
368 /* See windows-nat.h. */
371 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
373 segment_register_p
= fun
;
377 check (BOOL ok
, const char *file
, int line
)
380 printf_filtered ("error return %s:%d was %u\n", file
, line
,
381 (unsigned) GetLastError ());
384 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
385 then also retrieve the context for this thread. If GET_CONTEXT is
386 negative, then don't suspend the thread. */
387 static windows_thread_info
*
388 thread_rec (DWORD id
, int get_context
)
390 windows_thread_info
*th
;
392 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
395 if (!th
->suspended
&& get_context
)
397 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
399 if (SuspendThread (th
->h
) == (DWORD
) -1)
401 DWORD err
= GetLastError ();
403 /* We get Access Denied (5) when trying to suspend
404 threads that Windows started on behalf of the
405 debuggee, usually when those threads are just
407 We can get Invalid Handle (6) if the main thread
409 if (err
!= ERROR_INVALID_HANDLE
410 && err
!= ERROR_ACCESS_DENIED
)
411 warning (_("SuspendThread (tid=0x%x) failed."
413 (unsigned) id
, (unsigned) err
);
419 else if (get_context
< 0)
421 th
->reload_context
= 1;
429 /* Add a thread to the thread list.
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 (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 symetrical, 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 (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 pid
= regcache
->ptid ().tid ();
597 windows_thread_info
*th
= thread_rec (pid
, 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 pid
= regcache
->ptid ().tid ();
667 windows_thread_info
*th
= thread_rec (pid
, 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 /* Encapsulate the information required in a call to
682 symbol_file_add_args. */
683 struct safe_symbol_file_add_args
687 section_addr_info
*addrs
;
690 struct ui_file
*err
, *out
;
694 /* Maintain a linked list of "so" information. */
695 struct lm_info_windows
: public lm_info_base
697 LPVOID load_addr
= 0;
700 static struct so_list solib_start
, *solib_end
;
702 static struct so_list
*
703 windows_make_so (const char *name
, LPVOID load_addr
)
710 WIN32_FIND_DATA w32_fd
;
711 HANDLE h
= FindFirstFile(name
, &w32_fd
);
713 if (h
== INVALID_HANDLE_VALUE
)
719 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
721 p
= strrchr (buf
, '\\');
724 SetCurrentDirectory (buf
);
725 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
726 SetCurrentDirectory (cwd
);
729 if (strcasecmp (buf
, "ntdll.dll") == 0)
731 GetSystemDirectory (buf
, sizeof (buf
));
732 strcat (buf
, "\\ntdll.dll");
735 cygwin_buf_t buf
[__PMAX
];
738 if (access (name
, F_OK
) != 0)
740 if (strcasecmp (name
, "ntdll.dll") == 0)
743 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
744 wcscat (buf
, L
"\\ntdll.dll");
748 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
749 strcat (buf
, "\\ntdll.dll");
754 so
= XCNEW (struct so_list
);
755 lm_info_windows
*li
= new lm_info_windows
;
757 li
->load_addr
= load_addr
;
758 strcpy (so
->so_original_name
, name
);
760 strcpy (so
->so_name
, buf
);
763 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
764 SO_NAME_MAX_PATH_SIZE
);
767 char *rname
= realpath (name
, NULL
);
768 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
770 strcpy (so
->so_name
, rname
);
774 error (_("dll path too long"));
776 /* Record cygwin1.dll .text start/end. */
777 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
778 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
780 asection
*text
= NULL
;
782 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386", -1));
787 if (bfd_check_format (abfd
.get (), bfd_object
))
788 text
= bfd_get_section_by_name (abfd
.get (), ".text");
793 /* The symbols in a dll are offset by 0x1000, which is the
794 offset from 0 of the first byte in an image - because of the
795 file header and the section alignment. */
796 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
798 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (abfd
.get (),
807 get_image_name (HANDLE h
, void *address
, int unicode
)
810 static char buf
[__PMAX
];
812 static char buf
[(2 * __PMAX
) + 1];
814 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
820 /* Attempt to read the name of the dll that was detected.
821 This is documented to work only when actively debugging
822 a program. It will not work for attached processes. */
826 /* See if we could read the address of a string, and that the
827 address isn't null. */
828 if (!ReadProcessMemory (h
, address
, &address_ptr
,
829 sizeof (address_ptr
), &done
)
830 || done
!= sizeof (address_ptr
) || !address_ptr
)
833 /* Find the length of the string. */
834 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
835 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
839 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
842 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
843 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
846 wcstombs (buf
, unicode_address
, __PMAX
);
848 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
856 /* Handle a DLL load event, and return 1.
858 This function assumes that this event did not occur during inferior
859 initialization, where their event info may be incomplete (see
860 do_initial_windows_stuff and windows_add_all_dlls for more info
861 on how we handle DLL loading during that phase). */
866 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
869 /* Try getting the DLL name via the lpImageName field of the event.
870 Note that Microsoft documents this fields as strictly optional,
871 in the sense that it might be NULL. And the first DLL event in
872 particular is explicitly documented as "likely not pass[ed]"
873 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
874 dll_name
= get_image_name (current_process_handle
,
875 event
->lpImageName
, event
->fUnicode
);
879 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
880 solib_end
= solib_end
->next
;
882 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
884 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
885 host_address_to_string (li
->load_addr
)));
889 windows_free_so (struct so_list
*so
)
891 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
897 /* Handle a DLL unload event.
898 Return 1 if successful, or zero otherwise.
900 This function assumes that this event did not occur during inferior
901 initialization, where their event info may be incomplete (see
902 do_initial_windows_stuff and windows_add_all_dlls for more info
903 on how we handle DLL loading during that phase). */
908 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
911 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
913 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
915 if (li_next
->load_addr
== lpBaseOfDll
)
917 struct so_list
*sodel
= so
->next
;
919 so
->next
= sodel
->next
;
922 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
924 windows_free_so (sodel
);
929 /* We did not find any DLL that was previously loaded at this address,
930 so register a complaint. We do not report an error, because we have
931 observed that this may be happening under some circumstances. For
932 instance, running 32bit applications on x64 Windows causes us to receive
933 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
934 events are apparently caused by the WOW layer, the interface between
935 32bit and 64bit worlds). */
936 complaint (_("dll starting at %s not found."),
937 host_address_to_string (lpBaseOfDll
));
940 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
944 catch_errors (void (*func
) ())
950 CATCH (ex
, RETURN_MASK_ALL
)
952 exception_print (gdb_stderr
, ex
);
957 /* Clear list of loaded DLLs. */
959 windows_clear_solib (void)
961 solib_start
.next
= NULL
;
962 solib_end
= &solib_start
;
966 signal_event_command (const char *args
, int from_tty
)
968 uintptr_t event_id
= 0;
969 char *endargs
= NULL
;
972 error (_("signal-event requires an argument (integer event id)"));
974 event_id
= strtoumax (args
, &endargs
, 10);
976 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
977 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
978 error (_("Failed to convert `%s' to event id"), args
);
980 SetEvent ((HANDLE
) event_id
);
981 CloseHandle ((HANDLE
) event_id
);
984 /* Handle DEBUG_STRING output from child process.
985 Cygwin prepends its messages with a "cygwin:". Interpret this as
986 a Cygwin signal. Otherwise just print the string as a warning. */
988 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
990 gdb::unique_xmalloc_ptr
<char> s
;
993 if (!target_read_string
994 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
996 || !s
|| !*(s
.get ()))
998 else if (!startswith (s
.get (), _CYGWIN_SIGNAL_STRING
))
1001 if (!startswith (s
.get (), "cYg"))
1004 char *p
= strchr (s
.get (), '\0');
1006 if (p
> s
.get () && *--p
== '\n')
1008 warning (("%s"), s
.get ());
1014 /* Got a cygwin signal marker. A cygwin signal is followed by
1015 the signal number itself and then optionally followed by the
1016 thread id and address to saved context within the DLL. If
1017 these are supplied, then the given thread is assumed to have
1018 issued the signal and the context from the thread is assumed
1019 to be stored at the given address in the inferior. Tell gdb
1020 to treat this like a real signal. */
1022 int sig
= strtol (s
.get () + sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
1023 gdb_signal gotasig
= gdb_signal_from_host (sig
);
1025 ourstatus
->value
.sig
= gotasig
;
1031 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1032 retval
= strtoul (p
, &p
, 0);
1034 retval
= main_thread_id
;
1035 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
1036 && ReadProcessMemory (current_process_handle
, x
,
1038 __COPY_CONTEXT_SIZE
, &n
)
1039 && n
== __COPY_CONTEXT_SIZE
)
1040 have_saved_context
= 1;
1049 display_selector (HANDLE thread
, DWORD sel
)
1052 if (GetThreadSelectorEntry (thread
, sel
, &info
))
1055 printf_filtered ("0x%03x: ", (unsigned) sel
);
1056 if (!info
.HighWord
.Bits
.Pres
)
1058 puts_filtered ("Segment not present\n");
1061 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1062 (info
.HighWord
.Bits
.BaseMid
<< 16)
1064 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1065 if (info
.HighWord
.Bits
.Granularity
)
1066 limit
= (limit
<< 12) | 0xfff;
1067 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1068 if (info
.HighWord
.Bits
.Default_Big
)
1069 puts_filtered(" 32-bit ");
1071 puts_filtered(" 16-bit ");
1072 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1075 puts_filtered ("Data (Read-Only, Exp-up");
1078 puts_filtered ("Data (Read/Write, Exp-up");
1081 puts_filtered ("Unused segment (");
1084 puts_filtered ("Data (Read/Write, Exp-down");
1087 puts_filtered ("Code (Exec-Only, N.Conf");
1090 puts_filtered ("Code (Exec/Read, N.Conf");
1093 puts_filtered ("Code (Exec-Only, Conf");
1096 puts_filtered ("Code (Exec/Read, Conf");
1099 printf_filtered ("Unknown type 0x%lx",
1100 (unsigned long) info
.HighWord
.Bits
.Type
);
1102 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1103 puts_filtered(", N.Acc");
1104 puts_filtered (")\n");
1105 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1106 puts_filtered("System selector ");
1107 printf_filtered ("Priviledge level = %ld. ",
1108 (unsigned long) info
.HighWord
.Bits
.Dpl
);
1109 if (info
.HighWord
.Bits
.Granularity
)
1110 puts_filtered ("Page granular.\n");
1112 puts_filtered ("Byte granular.\n");
1117 DWORD err
= GetLastError ();
1118 if (err
== ERROR_NOT_SUPPORTED
)
1119 printf_filtered ("Function not supported\n");
1121 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1127 display_selectors (const char * args
, int from_tty
)
1129 if (!current_thread
)
1131 puts_filtered ("Impossible to display selectors now.\n");
1137 puts_filtered ("Selector $cs\n");
1138 display_selector (current_thread
->h
,
1139 current_thread
->context
.SegCs
);
1140 puts_filtered ("Selector $ds\n");
1141 display_selector (current_thread
->h
,
1142 current_thread
->context
.SegDs
);
1143 puts_filtered ("Selector $es\n");
1144 display_selector (current_thread
->h
,
1145 current_thread
->context
.SegEs
);
1146 puts_filtered ("Selector $ss\n");
1147 display_selector (current_thread
->h
,
1148 current_thread
->context
.SegSs
);
1149 puts_filtered ("Selector $fs\n");
1150 display_selector (current_thread
->h
,
1151 current_thread
->context
.SegFs
);
1152 puts_filtered ("Selector $gs\n");
1153 display_selector (current_thread
->h
,
1154 current_thread
->context
.SegGs
);
1159 sel
= parse_and_eval_long (args
);
1160 printf_filtered ("Selector \"%s\"\n",args
);
1161 display_selector (current_thread
->h
, sel
);
1165 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1166 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1167 host_address_to_string (\
1168 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1170 static handle_exception_result
1171 handle_exception (struct target_waitstatus
*ourstatus
)
1173 EXCEPTION_RECORD
*rec
= ¤t_event
.u
.Exception
.ExceptionRecord
;
1174 DWORD code
= rec
->ExceptionCode
;
1175 handle_exception_result result
= HANDLE_EXCEPTION_HANDLED
;
1177 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1179 /* Record the context of the current thread. */
1180 thread_rec (current_event
.dwThreadId
, -1);
1184 case EXCEPTION_ACCESS_VIOLATION
:
1185 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1186 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1189 /* See if the access violation happened within the cygwin DLL
1190 itself. Cygwin uses a kind of exception handling to deal
1191 with passed-in invalid addresses. gdb should not treat
1192 these as real SEGVs since they will be silently handled by
1193 cygwin. A real SEGV will (theoretically) be caught by
1194 cygwin later in the process and will be sent as a
1195 cygwin-specific-signal. So, ignore SEGVs if they show up
1196 within the text segment of the DLL itself. */
1198 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1200 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1201 && addr
< cygwin_load_end
))
1202 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1203 && startswith (fn
, "KERNEL32!IsBad")))
1204 return HANDLE_EXCEPTION_UNHANDLED
;
1208 case STATUS_STACK_OVERFLOW
:
1209 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1210 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1212 case STATUS_FLOAT_DENORMAL_OPERAND
:
1213 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1214 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1216 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1217 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1218 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1220 case STATUS_FLOAT_INEXACT_RESULT
:
1221 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1222 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1224 case STATUS_FLOAT_INVALID_OPERATION
:
1225 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1226 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1228 case STATUS_FLOAT_OVERFLOW
:
1229 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1230 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1232 case STATUS_FLOAT_STACK_CHECK
:
1233 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1234 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1236 case STATUS_FLOAT_UNDERFLOW
:
1237 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1238 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1240 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1241 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1242 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1244 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1245 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1246 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1248 case STATUS_INTEGER_OVERFLOW
:
1249 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1250 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1252 case EXCEPTION_BREAKPOINT
:
1253 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1254 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1257 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1258 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1260 case DBG_CONTROL_BREAK
:
1261 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1262 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1264 case EXCEPTION_SINGLE_STEP
:
1265 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1266 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1268 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1269 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1270 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1272 case EXCEPTION_PRIV_INSTRUCTION
:
1273 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1274 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1276 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1277 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1278 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1280 case MS_VC_EXCEPTION
:
1281 if (rec
->NumberParameters
>= 3
1282 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1284 DWORD named_thread_id
;
1285 windows_thread_info
*named_thread
;
1286 CORE_ADDR thread_name_target
;
1288 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1290 thread_name_target
= rec
->ExceptionInformation
[1];
1291 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1293 if (named_thread_id
== (DWORD
) -1)
1294 named_thread_id
= current_event
.dwThreadId
;
1296 named_thread
= thread_rec (named_thread_id
, 0);
1297 if (named_thread
!= NULL
)
1299 int thread_name_len
;
1300 gdb::unique_xmalloc_ptr
<char> thread_name
;
1302 thread_name_len
= target_read_string (thread_name_target
,
1303 &thread_name
, 1025, NULL
);
1304 if (thread_name_len
> 0)
1306 thread_name
.get ()[thread_name_len
- 1] = '\0';
1307 xfree (named_thread
->name
);
1308 named_thread
->name
= thread_name
.release ();
1311 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1312 result
= HANDLE_EXCEPTION_IGNORED
;
1315 /* treat improperly formed exception as unknown */
1318 /* Treat unhandled first chance exceptions specially. */
1319 if (current_event
.u
.Exception
.dwFirstChance
)
1320 return HANDLE_EXCEPTION_UNHANDLED
;
1321 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1322 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1323 host_address_to_string (
1324 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1325 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1329 last_sig
= ourstatus
->value
.sig
;
1333 /* Resume thread specified by ID, or all artificially suspended
1334 threads, if we are continuing execution. KILLED non-zero means we
1335 have killed the inferior, so we should ignore weird errors due to
1336 threads shutting down. */
1338 windows_continue (DWORD continue_status
, int id
, int killed
)
1340 windows_thread_info
*th
;
1343 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1344 (unsigned) current_event
.dwProcessId
,
1345 (unsigned) current_event
.dwThreadId
,
1346 continue_status
== DBG_CONTINUE
?
1347 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1349 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1350 if ((id
== -1 || id
== (int) th
->id
)
1353 if (debug_registers_changed
)
1355 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1356 th
->context
.Dr0
= dr
[0];
1357 th
->context
.Dr1
= dr
[1];
1358 th
->context
.Dr2
= dr
[2];
1359 th
->context
.Dr3
= dr
[3];
1360 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1361 th
->context
.Dr7
= dr
[7];
1363 if (th
->context
.ContextFlags
)
1367 if (GetExitCodeThread (th
->h
, &ec
)
1368 && ec
== STILL_ACTIVE
)
1370 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1375 th
->context
.ContextFlags
= 0;
1377 if (th
->suspended
> 0)
1378 (void) ResumeThread (th
->h
);
1382 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1383 current_event
.dwThreadId
,
1387 error (_("Failed to resume program execution"
1388 " (ContinueDebugEvent failed, error %u)"),
1389 (unsigned int) GetLastError ());
1391 debug_registers_changed
= 0;
1395 /* Called in pathological case where Windows fails to send a
1396 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1398 fake_create_process (void)
1400 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1401 current_event
.dwProcessId
);
1402 if (current_process_handle
!= NULL
)
1403 open_process_used
= 1;
1406 error (_("OpenProcess call failed, GetLastError = %u"),
1407 (unsigned) GetLastError ());
1408 /* We can not debug anything in that case. */
1410 main_thread_id
= current_event
.dwThreadId
;
1412 = windows_add_thread (ptid_t (current_event
.dwProcessId
, 0,
1413 current_event
.dwThreadId
),
1414 current_event
.u
.CreateThread
.hThread
,
1415 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1416 true /* main_thread_p */);
1417 return main_thread_id
;
1421 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1423 windows_thread_info
*th
;
1424 DWORD continue_status
= DBG_CONTINUE
;
1426 /* A specific PTID means `step only this thread id'. */
1427 int resume_all
= ptid
== minus_one_ptid
;
1429 /* If we're continuing all threads, it's the current inferior that
1430 should be handled specially. */
1432 ptid
= inferior_ptid
;
1434 if (sig
!= GDB_SIGNAL_0
)
1436 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1438 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1440 else if (sig
== last_sig
)
1441 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1444 /* This code does not seem to work, because
1445 the kernel does probably not consider changes in the ExceptionRecord
1446 structure when passing the exception to the inferior.
1447 Note that this seems possible in the exception handler itself. */
1449 for (const xlate_exception
&x
: xlate
)
1452 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1454 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1457 if (continue_status
== DBG_CONTINUE
)
1459 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1463 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1467 last_sig
= GDB_SIGNAL_0
;
1469 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1470 ptid
.pid (), ptid
.tid (), step
, sig
));
1472 /* Get context for currently selected thread. */
1473 th
= thread_rec (inferior_ptid
.tid (), FALSE
);
1478 /* Single step by setting t bit. */
1479 struct regcache
*regcache
= get_current_regcache ();
1480 struct gdbarch
*gdbarch
= regcache
->arch ();
1481 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1482 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1485 if (th
->context
.ContextFlags
)
1487 if (debug_registers_changed
)
1489 th
->context
.Dr0
= dr
[0];
1490 th
->context
.Dr1
= dr
[1];
1491 th
->context
.Dr2
= dr
[2];
1492 th
->context
.Dr3
= dr
[3];
1493 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1494 th
->context
.Dr7
= dr
[7];
1496 CHECK (SetThreadContext (th
->h
, &th
->context
));
1497 th
->context
.ContextFlags
= 0;
1501 /* Allow continuing with the same signal that interrupted us.
1502 Otherwise complain. */
1505 windows_continue (continue_status
, -1, 0);
1507 windows_continue (continue_status
, ptid
.tid (), 0);
1510 /* Ctrl-C handler used when the inferior is not run in the same console. The
1511 handler is in charge of interrupting the inferior using DebugBreakProcess.
1512 Note that this function is not available prior to Windows XP. In this case
1513 we emit a warning. */
1515 ctrl_c_handler (DWORD event_type
)
1517 const int attach_flag
= current_inferior ()->attach_flag
;
1519 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1520 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1523 /* If the inferior and the debugger share the same console, do nothing as
1524 the inferior has also received the Ctrl-C event. */
1525 if (!new_console
&& !attach_flag
)
1528 if (!DebugBreakProcess (current_process_handle
))
1529 warning (_("Could not interrupt program. "
1530 "Press Ctrl-c in the program console."));
1532 /* Return true to tell that Ctrl-C has been handled. */
1536 /* Get the next event from the child. Returns a non-zero thread id if the event
1537 requires handling by WFI (or whatever). */
1539 get_windows_debug_event (struct target_ops
*ops
,
1540 int pid
, struct target_waitstatus
*ourstatus
)
1543 DWORD continue_status
, event_code
;
1544 windows_thread_info
*th
;
1545 static windows_thread_info dummy_thread_info
;
1546 DWORD thread_id
= 0;
1548 last_sig
= GDB_SIGNAL_0
;
1550 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1554 continue_status
= DBG_CONTINUE
;
1556 event_code
= current_event
.dwDebugEventCode
;
1557 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1559 have_saved_context
= 0;
1563 case CREATE_THREAD_DEBUG_EVENT
:
1564 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1565 (unsigned) current_event
.dwProcessId
,
1566 (unsigned) current_event
.dwThreadId
,
1567 "CREATE_THREAD_DEBUG_EVENT"));
1568 if (saw_create
!= 1)
1570 struct inferior
*inf
;
1571 inf
= find_inferior_pid (current_event
.dwProcessId
);
1572 if (!saw_create
&& inf
->attach_flag
)
1574 /* Kludge around a Windows bug where first event is a create
1575 thread event. Caused when attached process does not have
1577 thread_id
= fake_create_process ();
1583 /* Record the existence of this thread. */
1584 thread_id
= current_event
.dwThreadId
;
1585 th
= windows_add_thread
1586 (ptid_t (current_event
.dwProcessId
, 0, current_event
.dwThreadId
),
1587 current_event
.u
.CreateThread
.hThread
,
1588 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1589 false /* main_thread_p */);
1593 case EXIT_THREAD_DEBUG_EVENT
:
1594 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1595 (unsigned) current_event
.dwProcessId
,
1596 (unsigned) current_event
.dwThreadId
,
1597 "EXIT_THREAD_DEBUG_EVENT"));
1598 windows_delete_thread (ptid_t (current_event
.dwProcessId
, 0,
1599 current_event
.dwThreadId
),
1600 current_event
.u
.ExitThread
.dwExitCode
,
1601 false /* main_thread_p */);
1602 th
= &dummy_thread_info
;
1605 case CREATE_PROCESS_DEBUG_EVENT
:
1606 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1607 (unsigned) current_event
.dwProcessId
,
1608 (unsigned) current_event
.dwThreadId
,
1609 "CREATE_PROCESS_DEBUG_EVENT"));
1610 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1611 if (++saw_create
!= 1)
1614 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1615 main_thread_id
= current_event
.dwThreadId
;
1616 /* Add the main thread. */
1617 th
= windows_add_thread
1618 (ptid_t (current_event
.dwProcessId
, 0,
1619 current_event
.dwThreadId
),
1620 current_event
.u
.CreateProcessInfo
.hThread
,
1621 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
,
1622 true /* main_thread_p */);
1623 thread_id
= current_event
.dwThreadId
;
1626 case EXIT_PROCESS_DEBUG_EVENT
:
1627 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1628 (unsigned) current_event
.dwProcessId
,
1629 (unsigned) current_event
.dwThreadId
,
1630 "EXIT_PROCESS_DEBUG_EVENT"));
1631 if (!windows_initialization_done
)
1633 target_terminal::ours ();
1634 target_mourn_inferior (inferior_ptid
);
1635 error (_("During startup program exited with code 0x%x."),
1636 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1638 else if (saw_create
== 1)
1640 windows_delete_thread (ptid_t (current_event
.dwProcessId
, 0,
1642 0, true /* main_thread_p */);
1643 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1644 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1645 thread_id
= main_thread_id
;
1649 case LOAD_DLL_DEBUG_EVENT
:
1650 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1651 (unsigned) current_event
.dwProcessId
,
1652 (unsigned) current_event
.dwThreadId
,
1653 "LOAD_DLL_DEBUG_EVENT"));
1654 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1655 if (saw_create
!= 1 || ! windows_initialization_done
)
1657 catch_errors (handle_load_dll
);
1658 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1659 ourstatus
->value
.integer
= 0;
1660 thread_id
= main_thread_id
;
1663 case UNLOAD_DLL_DEBUG_EVENT
:
1664 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1665 (unsigned) current_event
.dwProcessId
,
1666 (unsigned) current_event
.dwThreadId
,
1667 "UNLOAD_DLL_DEBUG_EVENT"));
1668 if (saw_create
!= 1 || ! windows_initialization_done
)
1670 catch_errors (handle_unload_dll
);
1671 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1672 ourstatus
->value
.integer
= 0;
1673 thread_id
= main_thread_id
;
1676 case EXCEPTION_DEBUG_EVENT
:
1677 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1678 (unsigned) current_event
.dwProcessId
,
1679 (unsigned) current_event
.dwThreadId
,
1680 "EXCEPTION_DEBUG_EVENT"));
1681 if (saw_create
!= 1)
1683 switch (handle_exception (ourstatus
))
1685 case HANDLE_EXCEPTION_UNHANDLED
:
1687 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1689 case HANDLE_EXCEPTION_HANDLED
:
1690 thread_id
= current_event
.dwThreadId
;
1692 case HANDLE_EXCEPTION_IGNORED
:
1693 continue_status
= DBG_CONTINUE
;
1698 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1699 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1700 (unsigned) current_event
.dwProcessId
,
1701 (unsigned) current_event
.dwThreadId
,
1702 "OUTPUT_DEBUG_STRING_EVENT"));
1703 if (saw_create
!= 1)
1705 thread_id
= handle_output_debug_string (ourstatus
);
1709 if (saw_create
!= 1)
1711 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1712 (unsigned) current_event
.dwProcessId
,
1713 (unsigned) current_event
.dwThreadId
);
1714 printf_unfiltered (" unknown event code %u\n",
1715 (unsigned) current_event
.dwDebugEventCode
);
1719 if (!thread_id
|| saw_create
!= 1)
1721 CHECK (windows_continue (continue_status
, -1, 0));
1725 inferior_ptid
= ptid_t (current_event
.dwProcessId
, 0, thread_id
);
1726 current_thread
= th
;
1727 if (!current_thread
)
1728 current_thread
= thread_rec (thread_id
, TRUE
);
1735 /* Wait for interesting events to occur in the target process. */
1737 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1742 /* We loop when we get a non-standard exception rather than return
1743 with a SPURIOUS because resume can try and step or modify things,
1744 which needs a current_thread->h. But some of these exceptions mark
1745 the birth or death of threads, which mean that the current thread
1746 isn't necessarily what you think it is. */
1752 /* If the user presses Ctrl-c while the debugger is waiting
1753 for an event, he expects the debugger to interrupt his program
1754 and to get the prompt back. There are two possible situations:
1756 - The debugger and the program do not share the console, in
1757 which case the Ctrl-c event only reached the debugger.
1758 In that case, the ctrl_c handler will take care of interrupting
1759 the inferior. Note that this case is working starting with
1760 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1763 - The debugger and the program share the same console, in which
1764 case both debugger and inferior will receive the Ctrl-c event.
1765 In that case the ctrl_c handler will ignore the event, as the
1766 Ctrl-c event generated inside the inferior will trigger the
1767 expected debug event.
1769 FIXME: brobecker/2008-05-20: If the inferior receives the
1770 signal first and the delay until GDB receives that signal
1771 is sufficiently long, GDB can sometimes receive the SIGINT
1772 after we have unblocked the CTRL+C handler. This would
1773 lead to the debugger stopping prematurely while handling
1774 the new-thread event that comes with the handling of the SIGINT
1775 inside the inferior, and then stop again immediately when
1776 the user tries to resume the execution in the inferior.
1777 This is a classic race that we should try to fix one day. */
1778 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1779 retval
= get_windows_debug_event (this, pid
, ourstatus
);
1780 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1783 return ptid_t (current_event
.dwProcessId
, 0, retval
);
1788 if (deprecated_ui_loop_hook
!= NULL
)
1789 detach
= deprecated_ui_loop_hook (0);
1797 /* Iterate over all DLLs currently mapped by our inferior, and
1798 add them to our list of solibs. */
1801 windows_add_all_dlls (void)
1803 HMODULE dummy_hmodule
;
1808 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
1809 sizeof (HMODULE
), &cb_needed
) == 0)
1815 hmodules
= (HMODULE
*) alloca (cb_needed
);
1816 if (EnumProcessModules (current_process_handle
, hmodules
,
1817 cb_needed
, &cb_needed
) == 0)
1820 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
1824 wchar_t dll_name
[__PMAX
];
1827 char dll_name
[__PMAX
];
1830 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
1831 &mi
, sizeof (mi
)) == 0)
1833 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
1834 dll_name
, sizeof (dll_name
)) == 0)
1837 wcstombs (name
, dll_name
, __PMAX
);
1842 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
1843 solib_end
= solib_end
->next
;
1848 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1851 struct inferior
*inf
;
1853 last_sig
= GDB_SIGNAL_0
;
1855 exception_count
= 0;
1856 open_process_used
= 0;
1857 debug_registers_changed
= 0;
1858 debug_registers_used
= 0;
1859 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1862 cygwin_load_start
= cygwin_load_end
= 0;
1864 current_event
.dwProcessId
= pid
;
1865 memset (¤t_event
, 0, sizeof (current_event
));
1866 if (!target_is_pushed (ops
))
1868 disable_breakpoints_in_shlibs ();
1869 windows_clear_solib ();
1870 clear_proceed_status (0);
1871 init_wait_for_inferior ();
1873 inf
= current_inferior ();
1874 inferior_appeared (inf
, pid
);
1875 inf
->attach_flag
= attaching
;
1877 /* Make the new process the current inferior, so terminal handling
1878 can rely on it. When attaching, we don't know about any thread
1879 id here, but that's OK --- nothing should be referencing the
1880 current thread until we report an event out of windows_wait. */
1881 inferior_ptid
= ptid_t (pid
);
1883 target_terminal::init ();
1884 target_terminal::inferior ();
1886 windows_initialization_done
= 0;
1890 struct target_waitstatus status
;
1892 ops
->wait (minus_one_ptid
, &status
, 0);
1894 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
1896 if (status
.kind
!= TARGET_WAITKIND_LOADED
1897 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
1900 ops
->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
1903 /* Now that the inferior has been started and all DLLs have been mapped,
1904 we can iterate over all DLLs and load them in.
1906 We avoid doing it any earlier because, on certain versions of Windows,
1907 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
1908 we have seen on Windows 8.1 that the ntdll.dll load event does not
1909 include the DLL name, preventing us from creating an associated SO.
1910 A possible explanation is that ntdll.dll might be mapped before
1911 the SO info gets created by the Windows system -- ntdll.dll is
1912 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
1913 do not seem to suffer from that problem.
1915 Rather than try to work around this sort of issue, it is much
1916 simpler to just ignore DLL load/unload events during the startup
1917 phase, and then process them all in one batch now. */
1918 windows_add_all_dlls ();
1920 windows_initialization_done
= 1;
1924 /* Try to set or remove a user privilege to the current process. Return -1
1925 if that fails, the previous setting of that privilege otherwise.
1927 This code is copied from the Cygwin source code and rearranged to allow
1928 dynamically loading of the needed symbols from advapi32 which is only
1929 available on NT/2K/XP. */
1931 set_process_privilege (const char *privilege
, BOOL enable
)
1933 HANDLE token_hdl
= NULL
;
1935 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1939 if (!OpenProcessToken (GetCurrentProcess (),
1940 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1944 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
1947 new_priv
.PrivilegeCount
= 1;
1948 new_priv
.Privileges
[0].Luid
= restore_priv
;
1949 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1951 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1952 sizeof orig_priv
, &orig_priv
, &size
))
1955 /* Disabled, otherwise every `attach' in an unprivileged user session
1956 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1957 windows_attach(). */
1958 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1959 be enabled. GetLastError () returns an correct error code, though. */
1960 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1964 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1968 CloseHandle (token_hdl
);
1973 /* Attach to process PID, then initialize for debugging it. */
1976 windows_nat_target::attach (const char *args
, int from_tty
)
1981 pid
= parse_pid_to_attach (args
);
1983 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1985 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1986 printf_unfiltered ("This can cause attach to "
1987 "fail on Windows NT/2K/XP\n");
1990 windows_init_thread_list ();
1991 ok
= DebugActiveProcess (pid
);
1997 /* Try fall back to Cygwin pid. */
1998 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
2001 ok
= DebugActiveProcess (pid
);
2006 error (_("Can't attach to process."));
2008 DebugSetProcessKillOnExit (FALSE
);
2012 char *exec_file
= (char *) get_exec_file (0);
2015 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
2016 target_pid_to_str (ptid_t (pid
)).c_str ());
2018 printf_unfiltered ("Attaching to %s\n",
2019 target_pid_to_str (ptid_t (pid
)).c_str ());
2022 do_initial_windows_stuff (this, pid
, 1);
2023 target_terminal::ours ();
2027 windows_nat_target::detach (inferior
*inf
, int from_tty
)
2031 ptid_t ptid
= minus_one_ptid
;
2032 resume (ptid
, 0, GDB_SIGNAL_0
);
2034 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
2036 error (_("Can't detach process %u (error %u)"),
2037 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
2040 DebugSetProcessKillOnExit (FALSE
);
2042 if (detached
&& from_tty
)
2044 const char *exec_file
= get_exec_file (0);
2047 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
2048 (unsigned) current_event
.dwProcessId
);
2051 x86_cleanup_dregs ();
2052 inferior_ptid
= null_ptid
;
2053 detach_inferior (inf
);
2055 maybe_unpush_target ();
2058 /* Try to determine the executable filename.
2060 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2062 Upon success, the filename is stored inside EXE_NAME_RET, and
2063 this function returns nonzero.
2065 Otherwise, this function returns zero and the contents of
2066 EXE_NAME_RET is undefined. */
2069 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2076 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2077 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2080 /* We know the executable is always first in the list of modules,
2081 which we just fetched. So no need to fetch more. */
2085 /* Cygwin prefers that the path be in /x/y/z format, so extract
2086 the filename into a temporary buffer first, and then convert it
2087 to POSIX format into the destination buffer. */
2088 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2090 len
= GetModuleFileNameEx (current_process_handle
,
2091 dh_buf
, pathbuf
, exe_name_max_len
);
2093 error (_("Error getting executable filename: %u."),
2094 (unsigned) GetLastError ());
2095 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2096 exe_name_max_len
) < 0)
2097 error (_("Error converting executable filename to POSIX: %d."), errno
);
2100 len
= GetModuleFileNameEx (current_process_handle
,
2101 dh_buf
, exe_name_ret
, exe_name_max_len
);
2103 error (_("Error getting executable filename: %u."),
2104 (unsigned) GetLastError ());
2107 return 1; /* success */
2110 /* The pid_to_exec_file target_ops method for this platform. */
2113 windows_nat_target::pid_to_exec_file (int pid
)
2115 static char path
[__PMAX
];
2117 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2119 char procexe
[sizeof ("/proc/4294967295/exe")];
2121 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2122 nchars
= readlink (procexe
, path
, sizeof(path
));
2123 if (nchars
> 0 && nchars
< sizeof (path
))
2125 path
[nchars
] = '\0'; /* Got it */
2130 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2131 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2132 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2138 /* Print status information about what we're accessing. */
2141 windows_nat_target::files_info ()
2143 struct inferior
*inf
= current_inferior ();
2145 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2146 inf
->attach_flag
? "attached" : "child",
2147 target_pid_to_str (inferior_ptid
).c_str ());
2150 /* Modify CreateProcess parameters for use of a new separate console.
2152 *FLAGS: DWORD parameter for general process creation flags.
2153 *SI: STARTUPINFO structure, for which the console window size and
2154 console buffer size is filled in if GDB is running in a console.
2155 to create the new console.
2156 The size of the used font is not available on all versions of
2157 Windows OS. Furthermore, the current font might not be the default
2158 font, but this is still better than before.
2159 If the windows and buffer sizes are computed,
2160 SI->DWFLAGS is changed so that this information is used
2161 by CreateProcess function. */
2164 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2166 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2167 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2169 if (hconsole
!= INVALID_HANDLE_VALUE
)
2171 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2173 CONSOLE_FONT_INFO cfi
;
2175 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2176 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2177 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2178 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2179 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2181 si
->dwXSize
*= font_size
.X
;
2185 si
->dwYSize
*= font_size
.Y
;
2188 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2189 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2190 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2192 *flags
|= CREATE_NEW_CONSOLE
;
2196 /* Function called by qsort to sort environment strings. */
2199 envvar_cmp (const void *a
, const void *b
)
2201 const char **p
= (const char **) a
;
2202 const char **q
= (const char **) b
;
2203 return strcasecmp (*p
, *q
);
2209 clear_win32_environment (char **env
)
2213 wchar_t *copy
= NULL
, *equalpos
;
2215 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2217 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2218 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2219 mbstowcs (copy
, env
[i
], len
);
2220 equalpos
= wcschr (copy
, L
'=');
2223 SetEnvironmentVariableW (copy
, NULL
);
2231 /* Redirection of inferior I/O streams for native MS-Windows programs.
2232 Unlike on Unix, where this is handled by invoking the inferior via
2233 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2235 The official documentation of the cmd.exe redirection features is here:
2237 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2239 (That page talks about Windows XP, but there's no newer
2240 documentation, so we assume later versions of cmd.exe didn't change
2243 Caveat: the documentation on that page seems to include a few lies.
2244 For example, it describes strange constructs 1<&2 and 2<&1, which
2245 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2246 think the cmd.exe parser of the redirection symbols simply doesn't
2247 care about the < vs > distinction in these cases. Therefore, the
2248 supported features are explicitly documented below.
2250 The emulation below aims at supporting all the valid use cases
2251 supported by cmd.exe, which include:
2253 < FILE redirect standard input from FILE
2254 0< FILE redirect standard input from FILE
2255 <&N redirect standard input from file descriptor N
2256 0<&N redirect standard input from file descriptor N
2257 > FILE redirect standard output to FILE
2258 >> FILE append standard output to FILE
2259 1>> FILE append standard output to FILE
2260 >&N redirect standard output to file descriptor N
2261 1>&N redirect standard output to file descriptor N
2262 >>&N append standard output to file descriptor N
2263 1>>&N append standard output to file descriptor N
2264 2> FILE redirect standard error to FILE
2265 2>> FILE append standard error to FILE
2266 2>&N redirect standard error to file descriptor N
2267 2>>&N append standard error to file descriptor N
2269 Note that using N > 2 in the above construct is supported, but
2270 requires that the corresponding file descriptor be open by some
2271 means elsewhere or outside GDB. Also note that using ">&0" or
2272 "<&2" will generally fail, because the file descriptor redirected
2273 from is normally open in an incompatible mode (e.g., FD 0 is open
2274 for reading only). IOW, use of such tricks is not recommended;
2275 you are on your own.
2277 We do NOT support redirection of file descriptors above 2, as in
2278 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2279 that needs special handling in the startup code that MinGW
2280 doesn't have). Pipes are also not supported.
2282 As for invalid use cases, where the redirection contains some
2283 error, the emulation below will detect that and produce some
2284 error and/or failure. But the behavior in those cases is not
2285 bug-for-bug compatible with what cmd.exe does in those cases.
2286 That's because what cmd.exe does then is not well defined, and
2287 seems to be a side effect of the cmd.exe parsing of the command
2288 line more than anything else. For example, try redirecting to an
2289 invalid file name, as in "> foo:bar".
2291 There are also minor syntactic deviations from what cmd.exe does
2292 in some corner cases. For example, it doesn't support the likes
2293 of "> &foo" to mean redirect to file named literally "&foo"; we
2294 do support that here, because that, too, sounds like some issue
2295 with the cmd.exe parser. Another nicety is that we support
2296 redirection targets that use file names with forward slashes,
2297 something cmd.exe doesn't -- this comes in handy since GDB
2298 file-name completion can be used when typing the command line for
2301 /* Support routines for redirecting standard handles of the inferior. */
2303 /* Parse a single redirection spec, open/duplicate the specified
2304 file/fd, and assign the appropriate value to one of the 3 standard
2305 file descriptors. */
2307 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2309 int *fd
, ref_fd
= -2;
2311 const char *fname
= redir_string
+ 1;
2312 int rc
= *redir_string
;
2327 fd
= (rc
== '2') ? err
: out
;
2328 mode
= O_WRONLY
| O_CREAT
;
2341 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2343 /* A reference to a file descriptor. */
2345 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2346 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2348 /* Don't allow redirection when open modes are incompatible. */
2349 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2350 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2357 else if (ref_fd
== 1)
2359 else if (ref_fd
== 2)
2369 fname
++; /* skip the separator space */
2370 /* If the descriptor is already open, close it. This allows
2371 multiple specs of redirections for the same stream, which is
2372 somewhat nonsensical, but still valid and supported by cmd.exe.
2373 (But cmd.exe only opens a single file in this case, the one
2374 specified by the last redirection spec on the command line.) */
2379 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2383 else if (ref_fd
== -1)
2384 *fd
= -1; /* reset to default destination */
2387 *fd
= _dup (ref_fd
);
2391 /* _open just sets a flag for O_APPEND, which won't be passed to the
2392 inferior, so we need to actually move the file pointer. */
2393 if ((mode
& O_APPEND
) != 0)
2394 _lseek (*fd
, 0L, SEEK_END
);
2398 /* Canonicalize a single redirection spec and set up the corresponding
2399 file descriptor as specified. */
2401 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2403 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2405 const char *start
= s
;
2408 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2409 if ((*start
== '>' || *start
== '1' || *start
== '2')
2413 if (*s
== '>' && *start
!= '>')
2416 else if (*start
== '0' && *s
== '<')
2418 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2421 while (isspace (*s
)) /* skip whitespace before file name */
2423 *d
++ = ' '; /* separate file name with a single space */
2426 /* Copy the file name. */
2429 /* Remove quoting characters from the file name in buf[]. */
2430 if (*s
== '"') /* could support '..' quoting here */
2434 else if (*s
== quote
)
2442 else if (*s
== '\\')
2444 if (s
[1] == '"') /* could support '..' here */
2448 else if (isspace (*s
) && !quote
)
2452 if (d
- buf
>= sizeof (buf
) - 1)
2454 errno
= ENAMETOOLONG
;
2460 /* Windows doesn't allow redirection characters in file names, so we
2461 can bail out early if they use them, or if there's no target file
2462 name after the redirection symbol. */
2463 if (d
[-1] == '>' || d
[-1] == '<')
2468 if (redir_open (buf
, inp
, out
, err
) == 0)
2473 /* Parse the command line for redirection specs and prepare the file
2474 descriptors for the 3 standard streams accordingly. */
2476 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2477 int *inp
, int *out
, int *err
)
2479 const char *s
= cmd_orig
;
2482 bool retval
= false;
2484 while (isspace (*s
))
2489 if (*s
== '"') /* could also support '..' quoting here */
2493 else if (*s
== quote
)
2496 else if (*s
== '\\')
2498 if (s
[1] == '"') /* escaped quote char */
2503 /* Process a single redirection candidate. */
2504 if (*s
== '<' || *s
== '>'
2505 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2506 || (*s
== '0' && s
[1] == '<'))
2508 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2522 #endif /* !__CYGWIN__ */
2524 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2525 EXEC_FILE is the file to run.
2526 ALLARGS is a string containing the arguments to the program.
2527 ENV is the environment vector to pass. Errors reported with error(). */
2530 windows_nat_target::create_inferior (const char *exec_file
,
2531 const std::string
&origallargs
,
2532 char **in_env
, int from_tty
)
2536 cygwin_buf_t real_path
[__PMAX
];
2537 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2538 cygwin_buf_t infcwd
[__PMAX
];
2540 cygwin_buf_t
*toexec
;
2541 cygwin_buf_t
*cygallargs
;
2543 char **old_env
= NULL
;
2547 int ostdin
, ostdout
, ostderr
;
2548 #else /* !__CYGWIN__ */
2549 char shell
[__PMAX
]; /* Path to shell */
2551 char *args
, *allargs_copy
;
2552 size_t args_len
, allargs_len
;
2553 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2554 HANDLE tty
= INVALID_HANDLE_VALUE
;
2555 bool redirected
= false;
2562 #endif /* !__CYGWIN__ */
2563 const char *allargs
= origallargs
.c_str ();
2564 PROCESS_INFORMATION pi
;
2567 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2570 error (_("No executable specified, use `target exec'."));
2572 const char *inferior_cwd
= get_inferior_cwd ();
2573 std::string expanded_infcwd
;
2574 if (inferior_cwd
!= NULL
)
2576 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
2577 /* Mirror slashes on inferior's cwd. */
2578 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
2580 inferior_cwd
= expanded_infcwd
.c_str ();
2583 memset (&si
, 0, sizeof (si
));
2584 si
.cb
= sizeof (si
);
2587 flags
|= CREATE_NEW_PROCESS_GROUP
;
2590 windows_set_console_info (&si
, &flags
);
2595 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2596 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2597 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2598 error (_("Error starting executable: %d"), errno
);
2601 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2602 if (len
== (size_t) -1)
2603 error (_("Error starting executable: %d"), errno
);
2604 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2605 mbstowcs (cygallargs
, allargs
, len
);
2606 #else /* !__USEWIDE */
2607 cygallargs
= allargs
;
2613 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2614 error (_("Error starting executable via shell: %d"), errno
);
2616 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2617 + mbstowcs (NULL
, allargs
, 0) + 2;
2618 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2619 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2620 #else /* !__USEWIDE */
2621 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2622 + strlen (allargs
) + 2);
2623 cygallargs
= (char *) alloca (len
);
2624 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2625 #endif /* __USEWIDE */
2627 flags
|= DEBUG_PROCESS
;
2630 if (inferior_cwd
!= NULL
2631 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
2632 infcwd
, strlen (inferior_cwd
)) < 0)
2633 error (_("Error converting inferior cwd: %d"), errno
);
2636 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2637 * sizeof (wchar_t));
2638 wcscpy (args
, toexec
);
2639 wcscat (args
, L
" ");
2640 wcscat (args
, cygallargs
);
2641 #else /* !__USEWIDE */
2642 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2643 strcpy (args
, toexec
);
2645 strcat (args
, cygallargs
);
2646 #endif /* !__USEWIDE */
2648 #ifdef CW_CVT_ENV_TO_WINENV
2649 /* First try to create a direct Win32 copy of the POSIX environment. */
2650 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2651 if (w32_env
!= (PWCHAR
) -1)
2652 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2654 /* If that fails, fall back to old method tweaking GDB's environment. */
2655 #endif /* CW_CVT_ENV_TO_WINENV */
2657 /* Reset all Win32 environment variables to avoid leftover on next run. */
2658 clear_win32_environment (environ
);
2659 /* Prepare the environment vars for CreateProcess. */
2662 cygwin_internal (CW_SYNC_WINENV
);
2666 if (!inferior_io_terminal
)
2667 tty
= ostdin
= ostdout
= ostderr
= -1;
2670 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2673 print_sys_errmsg (inferior_io_terminal
, errno
);
2674 ostdin
= ostdout
= ostderr
= -1;
2687 windows_init_thread_list ();
2688 ret
= CreateProcess (0,
2689 args
, /* command line */
2690 NULL
, /* Security */
2692 TRUE
, /* inherit handles */
2693 flags
, /* start flags */
2694 w32_env
, /* environment */
2695 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
2700 /* Just free the Win32 environment, if it could be created. */
2704 /* Reset all environment variables to avoid leftover on next run. */
2705 clear_win32_environment (in_env
);
2706 /* Restore normal GDB environment variables. */
2708 cygwin_internal (CW_SYNC_WINENV
);
2721 #else /* !__CYGWIN__ */
2722 allargs_len
= strlen (allargs
);
2723 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
2724 if (strpbrk (allargs_copy
, "<>") != NULL
)
2729 redirect_inferior_handles (allargs
, allargs_copy
,
2730 &fd_inp
, &fd_out
, &fd_err
);
2732 warning (_("Error in redirection: %s."), strerror (errno
));
2735 allargs_len
= strlen (allargs_copy
);
2737 /* If not all the standard streams are redirected by the command
2738 line, use inferior_io_terminal for those which aren't. */
2739 if (inferior_io_terminal
2740 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
2742 SECURITY_ATTRIBUTES sa
;
2743 sa
.nLength
= sizeof(sa
);
2744 sa
.lpSecurityDescriptor
= 0;
2745 sa
.bInheritHandle
= TRUE
;
2746 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2747 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2748 if (tty
== INVALID_HANDLE_VALUE
)
2749 warning (_("Warning: Failed to open TTY %s, error %#x."),
2750 inferior_io_terminal
, (unsigned) GetLastError ());
2752 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
2755 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
2756 else if (tty
!= INVALID_HANDLE_VALUE
)
2759 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
2761 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
2762 else if (tty
!= INVALID_HANDLE_VALUE
)
2763 si
.hStdOutput
= tty
;
2765 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
2767 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
2768 else if (tty
!= INVALID_HANDLE_VALUE
)
2771 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
2772 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2776 /* Build the command line, a space-separated list of tokens where
2777 the first token is the name of the module to be executed.
2778 To avoid ambiguities introduced by spaces in the module name,
2780 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
2781 args
= (char *) alloca (args_len
);
2782 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
2784 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2786 /* CreateProcess takes the environment list as a null terminated set of
2787 strings (i.e. two nulls terminate the list). */
2789 /* Get total size for env strings. */
2790 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2791 envlen
+= strlen (in_env
[i
]) + 1;
2793 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2794 env
= (char **) alloca (envsize
);
2795 memcpy (env
, in_env
, envsize
);
2796 /* Windows programs expect the environment block to be sorted. */
2797 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2799 w32env
= (char *) alloca (envlen
+ 1);
2801 /* Copy env strings into new buffer. */
2802 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2804 strcpy (temp
, env
[i
]);
2805 temp
+= strlen (temp
) + 1;
2808 /* Final nil string to terminate new env. */
2811 windows_init_thread_list ();
2812 ret
= CreateProcessA (0,
2813 args
, /* command line */
2814 NULL
, /* Security */
2816 TRUE
, /* inherit handles */
2817 flags
, /* start flags */
2818 w32env
, /* environment */
2819 inferior_cwd
, /* current directory */
2822 if (tty
!= INVALID_HANDLE_VALUE
)
2830 #endif /* !__CYGWIN__ */
2833 error (_("Error creating process %s, (error %u)."),
2834 exec_file
, (unsigned) GetLastError ());
2836 CloseHandle (pi
.hThread
);
2837 CloseHandle (pi
.hProcess
);
2839 if (useshell
&& shell
[0] != '\0')
2844 do_initial_windows_stuff (this, pi
.dwProcessId
, 0);
2846 /* windows_continue (DBG_CONTINUE, -1, 0); */
2850 windows_nat_target::mourn_inferior ()
2852 (void) windows_continue (DBG_CONTINUE
, -1, 0);
2853 x86_cleanup_dregs();
2854 if (open_process_used
)
2856 CHECK (CloseHandle (current_process_handle
));
2857 open_process_used
= 0;
2859 inf_child_target::mourn_inferior ();
2862 /* Send a SIGINT to the process group. This acts just like the user typed a
2863 ^C on the controlling terminal. */
2866 windows_nat_target::interrupt ()
2868 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2869 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
2870 registers_changed (); /* refresh register state */
2873 /* Helper for windows_xfer_partial that handles memory transfers.
2874 Arguments are like target_xfer_partial. */
2876 static enum target_xfer_status
2877 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2878 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2882 DWORD lasterror
= 0;
2884 if (writebuf
!= NULL
)
2886 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
2887 pulongest (len
), core_addr_to_string (memaddr
)));
2888 success
= WriteProcessMemory (current_process_handle
,
2889 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
2892 lasterror
= GetLastError ();
2893 FlushInstructionCache (current_process_handle
,
2894 (LPCVOID
) (uintptr_t) memaddr
, len
);
2898 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
2899 pulongest (len
), core_addr_to_string (memaddr
)));
2900 success
= ReadProcessMemory (current_process_handle
,
2901 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
2904 lasterror
= GetLastError ();
2906 *xfered_len
= (ULONGEST
) done
;
2907 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
2908 return TARGET_XFER_OK
;
2910 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
2914 windows_nat_target::kill ()
2916 CHECK (TerminateProcess (current_process_handle
, 0));
2920 if (!windows_continue (DBG_CONTINUE
, -1, 1))
2922 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
2924 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2928 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
2932 windows_nat_target::close ()
2934 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2935 inferior_ptid
.pid ()));
2938 /* Convert pid to printable format. */
2940 windows_nat_target::pid_to_str (ptid_t ptid
)
2942 if (ptid
.tid () != 0)
2943 return string_printf ("Thread %d.0x%lx", ptid
.pid (), ptid
.tid ());
2945 return normal_pid_to_str (ptid
);
2948 static enum target_xfer_status
2949 windows_xfer_shared_libraries (struct target_ops
*ops
,
2950 enum target_object object
, const char *annex
,
2951 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2952 ULONGEST offset
, ULONGEST len
,
2953 ULONGEST
*xfered_len
)
2955 struct obstack obstack
;
2961 return TARGET_XFER_E_IO
;
2963 obstack_init (&obstack
);
2964 obstack_grow_str (&obstack
, "<library-list>\n");
2965 for (so
= solib_start
.next
; so
; so
= so
->next
)
2967 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
2969 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
2970 (uintptr_t) li
->load_addr
,
2971 target_gdbarch (), &obstack
);
2973 obstack_grow_str0 (&obstack
, "</library-list>\n");
2975 buf
= (const char *) obstack_finish (&obstack
);
2976 len_avail
= strlen (buf
);
2977 if (offset
>= len_avail
)
2981 if (len
> len_avail
- offset
)
2982 len
= len_avail
- offset
;
2983 memcpy (readbuf
, buf
+ offset
, len
);
2986 obstack_free (&obstack
, NULL
);
2987 *xfered_len
= (ULONGEST
) len
;
2988 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
2991 enum target_xfer_status
2992 windows_nat_target::xfer_partial (enum target_object object
,
2993 const char *annex
, gdb_byte
*readbuf
,
2994 const gdb_byte
*writebuf
, ULONGEST offset
,
2995 ULONGEST len
, ULONGEST
*xfered_len
)
2999 case TARGET_OBJECT_MEMORY
:
3000 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
3002 case TARGET_OBJECT_LIBRARIES
:
3003 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
3004 writebuf
, offset
, len
, xfered_len
);
3007 if (beneath () == NULL
)
3009 /* This can happen when requesting the transfer of unsupported
3010 objects before a program has been started (and therefore
3011 with the current_target having no target beneath). */
3012 return TARGET_XFER_E_IO
;
3014 return beneath ()->xfer_partial (object
, annex
,
3015 readbuf
, writebuf
, offset
, len
,
3020 /* Provide thread local base, i.e. Thread Information Block address.
3021 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
3024 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
3026 windows_thread_info
*th
;
3028 th
= thread_rec (ptid
.tid (), 0);
3033 *addr
= th
->thread_local_base
;
3039 windows_nat_target::get_ada_task_ptid (long lwp
, long thread
)
3041 return ptid_t (inferior_ptid
.pid (), 0, lwp
);
3044 /* Implementation of the to_thread_name method. */
3047 windows_nat_target::thread_name (struct thread_info
*thr
)
3049 return thread_rec (thr
->ptid
.tid (), 0)->name
;
3054 _initialize_windows_nat (void)
3056 x86_dr_low
.set_control
= cygwin_set_dr7
;
3057 x86_dr_low
.set_addr
= cygwin_set_dr
;
3058 x86_dr_low
.get_addr
= cygwin_get_dr
;
3059 x86_dr_low
.get_status
= cygwin_get_dr6
;
3060 x86_dr_low
.get_control
= cygwin_get_dr7
;
3062 /* x86_dr_low.debug_register_length field is set by
3063 calling x86_set_debug_register_length function
3064 in processor windows specific native file. */
3066 add_inf_child_target (&the_windows_nat_target
);
3069 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3072 add_com ("signal-event", class_run
, signal_event_command
, _("\
3073 Signal a crashed process with event ID, to allow its debugging.\n\
3074 This command is needed in support of setting up GDB as JIT debugger on \
3075 MS-Windows. The command should be invoked from the GDB command line using \
3076 the '-ex' command-line option. The ID of the event that blocks the \
3077 crashed process will be supplied by the Windows JIT debugging mechanism."));
3080 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3081 Set use of shell to start subprocess."), _("\
3082 Show use of shell to start subprocess."), NULL
,
3084 NULL
, /* FIXME: i18n: */
3085 &setlist
, &showlist
);
3087 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3088 &cygwin_exceptions
, _("\
3089 Break when an exception is detected in the Cygwin DLL itself."), _("\
3090 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3092 NULL
, /* FIXME: i18n: */
3093 &setlist
, &showlist
);
3096 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3097 Set creation of new console when creating child process."), _("\
3098 Show creation of new console when creating child process."), NULL
,
3100 NULL
, /* FIXME: i18n: */
3101 &setlist
, &showlist
);
3103 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3104 Set creation of new group when creating child process."), _("\
3105 Show creation of new group when creating child process."), NULL
,
3107 NULL
, /* FIXME: i18n: */
3108 &setlist
, &showlist
);
3110 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3111 Set whether to display execution in child process."), _("\
3112 Show whether to display execution in child process."), NULL
,
3114 NULL
, /* FIXME: i18n: */
3115 &setlist
, &showlist
);
3117 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3118 Set whether to display kernel events in child process."), _("\
3119 Show whether to display kernel events in child process."), NULL
,
3121 NULL
, /* FIXME: i18n: */
3122 &setlist
, &showlist
);
3124 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3125 Set whether to display memory accesses in child process."), _("\
3126 Show whether to display memory accesses in child process."), NULL
,
3128 NULL
, /* FIXME: i18n: */
3129 &setlist
, &showlist
);
3131 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3132 &debug_exceptions
, _("\
3133 Set whether to display kernel exceptions in child process."), _("\
3134 Show whether to display kernel exceptions in child process."), NULL
,
3136 NULL
, /* FIXME: i18n: */
3137 &setlist
, &showlist
);
3139 init_w32_command_list ();
3141 add_cmd ("selector", class_info
, display_selectors
,
3142 _("Display selectors infos."),
3146 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3148 /* Pass the address ADDR to the inferior in the I'th debug register.
3149 Here we just store the address in dr array, the registers will be
3150 actually set up when windows_continue is called. */
3152 cygwin_set_dr (int i
, CORE_ADDR addr
)
3155 internal_error (__FILE__
, __LINE__
,
3156 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3158 debug_registers_changed
= 1;
3159 debug_registers_used
= 1;
3162 /* Pass the value VAL to the inferior in the DR7 debug control
3163 register. Here we just store the address in D_REGS, the watchpoint
3164 will be actually set up in windows_wait. */
3166 cygwin_set_dr7 (unsigned long val
)
3168 dr
[7] = (CORE_ADDR
) val
;
3169 debug_registers_changed
= 1;
3170 debug_registers_used
= 1;
3173 /* Get the value of debug register I from the inferior. */
3176 cygwin_get_dr (int i
)
3181 /* Get the value of the DR6 debug status register from the inferior.
3182 Here we just return the value stored in dr[6]
3183 by the last call to thread_rec for current_event.dwThreadId id. */
3184 static unsigned long
3185 cygwin_get_dr6 (void)
3187 return (unsigned long) dr
[6];
3190 /* Get the value of the DR7 debug status register from the inferior.
3191 Here we just return the value stored in dr[7] by the last call to
3192 thread_rec for current_event.dwThreadId id. */
3194 static unsigned long
3195 cygwin_get_dr7 (void)
3197 return (unsigned long) dr
[7];
3200 /* Determine if the thread referenced by "ptid" is alive
3201 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3202 it means that the thread has died. Otherwise it is assumed to be alive. */
3205 windows_nat_target::thread_alive (ptid_t ptid
)
3209 gdb_assert (ptid
.tid () != 0);
3212 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) != WAIT_OBJECT_0
;
3216 _initialize_check_for_gdb_ini (void)
3219 if (inhibit_gdbinit
)
3222 homedir
= getenv ("HOME");
3226 char *oldini
= (char *) alloca (strlen (homedir
) +
3227 sizeof ("gdb.ini") + 1);
3228 strcpy (oldini
, homedir
);
3229 p
= strchr (oldini
, '\0');
3230 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3232 strcpy (p
, "gdb.ini");
3233 if (access (oldini
, 0) == 0)
3235 int len
= strlen (oldini
);
3236 char *newini
= (char *) alloca (len
+ 2);
3238 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3239 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3240 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3245 /* Define dummy functions which always return error for the rare cases where
3246 these functions could not be found. */
3248 bad_DebugActiveProcessStop (DWORD w
)
3253 bad_DebugBreakProcess (HANDLE w
)
3258 bad_DebugSetProcessKillOnExit (BOOL w
)
3263 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3270 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3276 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3283 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3289 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3295 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3301 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3309 /* Load any functions which may not be available in ancient versions
3313 _initialize_loadable (void)
3317 #define GPA(m, func) \
3318 func = (func ## _ftype *) GetProcAddress (m, #func)
3320 hm
= LoadLibrary ("kernel32.dll");
3323 GPA (hm
, DebugActiveProcessStop
);
3324 GPA (hm
, DebugBreakProcess
);
3325 GPA (hm
, DebugSetProcessKillOnExit
);
3326 GPA (hm
, GetConsoleFontSize
);
3327 GPA (hm
, DebugActiveProcessStop
);
3328 GPA (hm
, GetCurrentConsoleFont
);
3331 /* Set variables to dummy versions of these processes if the function
3332 wasn't found in kernel32.dll. */
3333 if (!DebugBreakProcess
)
3334 DebugBreakProcess
= bad_DebugBreakProcess
;
3335 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3337 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3338 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3340 if (!GetConsoleFontSize
)
3341 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3342 if (!GetCurrentConsoleFont
)
3343 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3345 /* Load optional functions used for retrieving filename information
3346 associated with the currently debugged process or its dlls. */
3347 hm
= LoadLibrary ("psapi.dll");
3350 GPA (hm
, EnumProcessModules
);
3351 GPA (hm
, GetModuleInformation
);
3352 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3353 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3356 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3358 /* Set variables to dummy versions of these processes if the function
3359 wasn't found in psapi.dll. */
3360 EnumProcessModules
= bad_EnumProcessModules
;
3361 GetModuleInformation
= bad_GetModuleInformation
;
3362 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3363 /* This will probably fail on Windows 9x/Me. Let the user know
3364 that we're missing some functionality. */
3366 cannot automatically find executable file or library to read symbols.\n\
3367 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3370 hm
= LoadLibrary ("advapi32.dll");
3373 GPA (hm
, OpenProcessToken
);
3374 GPA (hm
, LookupPrivilegeValueA
);
3375 GPA (hm
, AdjustTokenPrivileges
);
3376 /* Only need to set one of these since if OpenProcessToken fails nothing
3378 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3379 || !AdjustTokenPrivileges
)
3380 OpenProcessToken
= bad_OpenProcessToken
;