1 /* Target-vector operations for controlling windows child processes, for GDB.
3 Copyright (C) 1995-2017 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"
70 #define AdjustTokenPrivileges dyn_AdjustTokenPrivileges
71 #define DebugActiveProcessStop dyn_DebugActiveProcessStop
72 #define DebugBreakProcess dyn_DebugBreakProcess
73 #define DebugSetProcessKillOnExit dyn_DebugSetProcessKillOnExit
74 #define EnumProcessModules dyn_EnumProcessModules
75 #define GetModuleInformation dyn_GetModuleInformation
76 #define LookupPrivilegeValueA dyn_LookupPrivilegeValueA
77 #define OpenProcessToken dyn_OpenProcessToken
78 #define GetConsoleFontSize dyn_GetConsoleFontSize
79 #define GetCurrentConsoleFont dyn_GetCurrentConsoleFont
81 typedef BOOL
WINAPI (AdjustTokenPrivileges_ftype
) (HANDLE
, BOOL
,
83 DWORD
, PTOKEN_PRIVILEGES
,
85 static AdjustTokenPrivileges_ftype
*AdjustTokenPrivileges
;
87 typedef BOOL
WINAPI (DebugActiveProcessStop_ftype
) (DWORD
);
88 static DebugActiveProcessStop_ftype
*DebugActiveProcessStop
;
90 typedef BOOL
WINAPI (DebugBreakProcess_ftype
) (HANDLE
);
91 static DebugBreakProcess_ftype
*DebugBreakProcess
;
93 typedef BOOL
WINAPI (DebugSetProcessKillOnExit_ftype
) (BOOL
);
94 static DebugSetProcessKillOnExit_ftype
*DebugSetProcessKillOnExit
;
96 typedef BOOL
WINAPI (EnumProcessModules_ftype
) (HANDLE
, HMODULE
*, DWORD
,
98 static EnumProcessModules_ftype
*EnumProcessModules
;
100 typedef BOOL
WINAPI (GetModuleInformation_ftype
) (HANDLE
, HMODULE
,
101 LPMODULEINFO
, DWORD
);
102 static GetModuleInformation_ftype
*GetModuleInformation
;
104 typedef BOOL
WINAPI (LookupPrivilegeValueA_ftype
) (LPCSTR
, LPCSTR
, PLUID
);
105 static LookupPrivilegeValueA_ftype
*LookupPrivilegeValueA
;
107 typedef BOOL
WINAPI (OpenProcessToken_ftype
) (HANDLE
, DWORD
, PHANDLE
);
108 static OpenProcessToken_ftype
*OpenProcessToken
;
110 typedef BOOL
WINAPI (GetCurrentConsoleFont_ftype
) (HANDLE
, BOOL
,
111 CONSOLE_FONT_INFO
*);
112 static GetCurrentConsoleFont_ftype
*GetCurrentConsoleFont
;
114 typedef COORD
WINAPI (GetConsoleFontSize_ftype
) (HANDLE
, DWORD
);
115 static GetConsoleFontSize_ftype
*GetConsoleFontSize
;
119 #undef GetModuleFileNameEx
122 # define __PMAX (MAX_PATH + 1)
123 typedef DWORD
WINAPI (GetModuleFileNameEx_ftype
) (HANDLE
, HMODULE
, LPSTR
, DWORD
);
124 static GetModuleFileNameEx_ftype
*GetModuleFileNameEx
;
125 # define STARTUPINFO STARTUPINFOA
126 # define CreateProcess CreateProcessA
127 # define GetModuleFileNameEx_name "GetModuleFileNameExA"
128 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
130 # define __PMAX PATH_MAX
131 /* The starting and ending address of the cygwin1.dll text segment. */
132 static CORE_ADDR cygwin_load_start
;
133 static CORE_ADDR cygwin_load_end
;
135 typedef wchar_t cygwin_buf_t
;
136 typedef DWORD
WINAPI (GetModuleFileNameEx_ftype
) (HANDLE
, HMODULE
,
138 static GetModuleFileNameEx_ftype
*GetModuleFileNameEx
;
139 # define STARTUPINFO STARTUPINFOW
140 # define CreateProcess CreateProcessW
141 # define GetModuleFileNameEx_name "GetModuleFileNameExW"
142 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExW
145 static int have_saved_context
; /* True if we've saved context from a
147 static CONTEXT saved_context
; /* Containes the saved context from a
150 /* If we're not using the old Cygwin header file set, define the
151 following which never should have been in the generic Win32 API
152 headers in the first place since they were our own invention... */
153 #ifndef _GNU_H_WINDOWS_H
156 FLAG_TRACE_BIT
= 0x100,
160 #ifndef CONTEXT_EXTENDED_REGISTERS
161 /* This macro is only defined on ia32. It only makes sense on this target,
162 so define it as zero if not already defined. */
163 #define CONTEXT_EXTENDED_REGISTERS 0
166 #define CONTEXT_DEBUGGER_DR CONTEXT_FULL | CONTEXT_FLOATING_POINT \
167 | CONTEXT_SEGMENTS | CONTEXT_DEBUG_REGISTERS \
168 | CONTEXT_EXTENDED_REGISTERS
170 static uintptr_t dr
[8];
171 static int debug_registers_changed
;
172 static int debug_registers_used
;
174 static int windows_initialization_done
;
175 #define DR6_CLEAR_VALUE 0xffff0ff0
177 /* The exception thrown by a program to tell the debugger the name of
178 a thread. The exception record contains an ID of a thread and a
179 name to give it. This exception has no documented name, but MSDN
180 dubs it "MS_VC_EXCEPTION" in one code example. */
181 #define MS_VC_EXCEPTION 0x406d1388
185 HANDLE_EXCEPTION_UNHANDLED
= 0,
186 HANDLE_EXCEPTION_HANDLED
,
187 HANDLE_EXCEPTION_IGNORED
188 } handle_exception_result
;
190 /* The string sent by cygwin when it processes a signal.
191 FIXME: This should be in a cygwin include file. */
192 #ifndef _CYGWIN_SIGNAL_STRING
193 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
196 #define CHECK(x) check (x, __FILE__,__LINE__)
197 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
198 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
199 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
200 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
202 static void windows_interrupt (struct target_ops
*self
, ptid_t
);
203 static int windows_thread_alive (struct target_ops
*, ptid_t
);
204 static void windows_kill_inferior (struct target_ops
*);
206 static void cygwin_set_dr (int i
, CORE_ADDR addr
);
207 static void cygwin_set_dr7 (unsigned long val
);
208 static CORE_ADDR
cygwin_get_dr (int i
);
209 static unsigned long cygwin_get_dr6 (void);
210 static unsigned long cygwin_get_dr7 (void);
212 static enum gdb_signal last_sig
= GDB_SIGNAL_0
;
213 /* Set if a signal was received from the debugged process. */
215 /* Thread information structure used to track information that is
216 not available in gdb's thread structure. */
217 typedef struct windows_thread_info_struct
219 struct windows_thread_info_struct
*next
;
222 CORE_ADDR thread_local_base
;
231 static windows_thread_info thread_head
;
233 /* The process and thread handles for the above context. */
235 static DEBUG_EVENT current_event
; /* The current debug event from
237 static HANDLE current_process_handle
; /* Currently executing process */
238 static windows_thread_info
*current_thread
; /* Info on currently selected thread */
239 static DWORD main_thread_id
; /* Thread ID of the main thread */
241 /* Counts of things. */
242 static int exception_count
= 0;
243 static int event_count
= 0;
244 static int saw_create
;
245 static int open_process_used
= 0;
248 static int new_console
= 0;
250 static int cygwin_exceptions
= 0;
252 static int new_group
= 1;
253 static int debug_exec
= 0; /* show execution */
254 static int debug_events
= 0; /* show events from kernel */
255 static int debug_memory
= 0; /* show target memory accesses */
256 static int debug_exceptions
= 0; /* show target exceptions */
257 static int useshell
= 0; /* use shell for subprocesses */
259 /* This vector maps GDB's idea of a register's number into an offset
260 in the windows exception context vector.
262 It also contains the bit mask needed to load the register in question.
264 The contents of this table can only be computed by the units
265 that provide CPU-specific support for Windows native debugging.
266 These units should set the table by calling
267 windows_set_context_register_offsets.
269 One day we could read a reg, we could inspect the context we
270 already have loaded, if it doesn't have the bit set that we need,
271 we read that set of registers in using GetThreadContext. If the
272 context already contains what we need, we just unpack it. Then to
273 write a register, first we have to ensure that the context contains
274 the other regs of the group, and then we copy the info in and set
277 static const int *mappings
;
279 /* The function to use in order to determine whether a register is
280 a segment register or not. */
281 static segment_register_p_ftype
*segment_register_p
;
283 /* This vector maps the target's idea of an exception (extracted
284 from the DEBUG_EVENT structure) to GDB's idea. */
286 struct xlate_exception
292 static const struct xlate_exception
295 {EXCEPTION_ACCESS_VIOLATION
, GDB_SIGNAL_SEGV
},
296 {STATUS_STACK_OVERFLOW
, GDB_SIGNAL_SEGV
},
297 {EXCEPTION_BREAKPOINT
, GDB_SIGNAL_TRAP
},
298 {DBG_CONTROL_C
, GDB_SIGNAL_INT
},
299 {EXCEPTION_SINGLE_STEP
, GDB_SIGNAL_TRAP
},
300 {STATUS_FLOAT_DIVIDE_BY_ZERO
, GDB_SIGNAL_FPE
},
301 {-1, GDB_SIGNAL_UNKNOWN
}};
303 /* Set the MAPPINGS static global to OFFSETS.
304 See the description of MAPPINGS for more details. */
307 windows_set_context_register_offsets (const int *offsets
)
312 /* See windows-nat.h. */
315 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
317 segment_register_p
= fun
;
321 check (BOOL ok
, const char *file
, int line
)
324 printf_filtered ("error return %s:%d was %u\n", file
, line
,
325 (unsigned) GetLastError ());
328 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
329 then also retrieve the context for this thread. If GET_CONTEXT is
330 negative, then don't suspend the thread. */
331 static windows_thread_info
*
332 thread_rec (DWORD id
, int get_context
)
334 windows_thread_info
*th
;
336 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
339 if (!th
->suspended
&& get_context
)
341 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
343 if (SuspendThread (th
->h
) == (DWORD
) -1)
345 DWORD err
= GetLastError ();
347 /* We get Access Denied (5) when trying to suspend
348 threads that Windows started on behalf of the
349 debuggee, usually when those threads are just
351 We can get Invalid Handle (6) if the main thread
353 if (err
!= ERROR_INVALID_HANDLE
354 && err
!= ERROR_ACCESS_DENIED
)
355 warning (_("SuspendThread (tid=0x%x) failed."
357 (unsigned) id
, (unsigned) err
);
363 else if (get_context
< 0)
365 th
->reload_context
= 1;
373 /* Add a thread to the thread list. */
374 static windows_thread_info
*
375 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
)
377 windows_thread_info
*th
;
380 gdb_assert (ptid_get_tid (ptid
) != 0);
382 id
= ptid_get_tid (ptid
);
384 if ((th
= thread_rec (id
, FALSE
)))
387 th
= XCNEW (windows_thread_info
);
390 th
->thread_local_base
= (CORE_ADDR
) (uintptr_t) tlb
;
391 th
->next
= thread_head
.next
;
392 thread_head
.next
= th
;
394 /* Set the debug registers for the new thread if they are used. */
395 if (debug_registers_used
)
397 /* Only change the value of the debug registers. */
398 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
399 CHECK (GetThreadContext (th
->h
, &th
->context
));
400 th
->context
.Dr0
= dr
[0];
401 th
->context
.Dr1
= dr
[1];
402 th
->context
.Dr2
= dr
[2];
403 th
->context
.Dr3
= dr
[3];
404 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
405 th
->context
.Dr7
= dr
[7];
406 CHECK (SetThreadContext (th
->h
, &th
->context
));
407 th
->context
.ContextFlags
= 0;
412 /* Clear out any old thread list and reinitialize it to a
415 windows_init_thread_list (void)
417 windows_thread_info
*th
= &thread_head
;
419 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
421 while (th
->next
!= NULL
)
423 windows_thread_info
*here
= th
->next
;
424 th
->next
= here
->next
;
427 thread_head
.next
= NULL
;
430 /* Delete a thread from the list of threads. */
432 windows_delete_thread (ptid_t ptid
, DWORD exit_code
)
434 windows_thread_info
*th
;
437 gdb_assert (ptid_get_tid (ptid
) != 0);
439 id
= ptid_get_tid (ptid
);
442 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
));
443 else if (print_thread_events
&& id
!= main_thread_id
)
444 printf_unfiltered (_("[%s exited with code %u]\n"),
445 target_pid_to_str (ptid
), (unsigned) exit_code
);
446 delete_thread (ptid
);
448 for (th
= &thread_head
;
449 th
->next
!= NULL
&& th
->next
->id
!= id
;
453 if (th
->next
!= NULL
)
455 windows_thread_info
*here
= th
->next
;
456 th
->next
= here
->next
;
463 do_windows_fetch_inferior_registers (struct regcache
*regcache
,
464 windows_thread_info
*th
, int r
)
466 char *context_offset
= ((char *) &th
->context
) + mappings
[r
];
467 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
468 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
471 if (th
->reload_context
)
474 if (have_saved_context
)
476 /* Lie about where the program actually is stopped since
477 cygwin has informed us that we should consider the signal
478 to have occurred at another location which is stored in
480 memcpy (&th
->context
, &saved_context
,
481 __COPY_CONTEXT_SIZE
);
482 have_saved_context
= 0;
487 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
488 CHECK (GetThreadContext (th
->h
, &th
->context
));
489 /* Copy dr values from that thread.
490 But only if there were not modified since last stop.
492 if (!debug_registers_changed
)
494 dr
[0] = th
->context
.Dr0
;
495 dr
[1] = th
->context
.Dr1
;
496 dr
[2] = th
->context
.Dr2
;
497 dr
[3] = th
->context
.Dr3
;
498 dr
[6] = th
->context
.Dr6
;
499 dr
[7] = th
->context
.Dr7
;
502 th
->reload_context
= 0;
505 if (r
== I387_FISEG_REGNUM (tdep
))
507 l
= *((long *) context_offset
) & 0xffff;
508 regcache_raw_supply (regcache
, r
, (char *) &l
);
510 else if (r
== I387_FOP_REGNUM (tdep
))
512 l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
513 regcache_raw_supply (regcache
, r
, (char *) &l
);
515 else if (segment_register_p (r
))
517 /* GDB treats segment registers as 32bit registers, but they are
518 in fact only 16 bits long. Make sure we do not read extra
519 bits from our source buffer. */
520 l
= *((long *) context_offset
) & 0xffff;
521 regcache_raw_supply (regcache
, r
, (char *) &l
);
524 regcache_raw_supply (regcache
, r
, context_offset
);
527 for (r
= 0; r
< gdbarch_num_regs (gdbarch
); r
++)
528 do_windows_fetch_inferior_registers (regcache
, th
, r
);
533 windows_fetch_inferior_registers (struct target_ops
*ops
,
534 struct regcache
*regcache
, int r
)
536 DWORD pid
= ptid_get_tid (regcache_get_ptid (regcache
));
537 windows_thread_info
*th
= thread_rec (pid
, TRUE
);
539 /* Check if TH exists. Windows sometimes uses a non-existent
540 thread id in its events. */
542 do_windows_fetch_inferior_registers (regcache
, th
, r
);
546 do_windows_store_inferior_registers (const struct regcache
*regcache
,
547 windows_thread_info
*th
, int r
)
550 regcache_raw_collect (regcache
, r
,
551 ((char *) &th
->context
) + mappings
[r
]);
554 for (r
= 0; r
< gdbarch_num_regs (get_regcache_arch (regcache
)); r
++)
555 do_windows_store_inferior_registers (regcache
, th
, r
);
559 /* Store a new register value into the context of the thread tied to
562 windows_store_inferior_registers (struct target_ops
*ops
,
563 struct regcache
*regcache
, int r
)
565 DWORD pid
= ptid_get_tid (regcache_get_ptid (regcache
));
566 windows_thread_info
*th
= thread_rec (pid
, TRUE
);
568 /* Check if TH exists. Windows sometimes uses a non-existent
569 thread id in its events. */
571 do_windows_store_inferior_registers (regcache
, th
, r
);
574 /* Encapsulate the information required in a call to
575 symbol_file_add_args. */
576 struct safe_symbol_file_add_args
580 struct section_addr_info
*addrs
;
583 struct ui_file
*err
, *out
;
587 /* Maintain a linked list of "so" information. */
593 static struct so_list solib_start
, *solib_end
;
595 static struct so_list
*
596 windows_make_so (const char *name
, LPVOID load_addr
)
603 WIN32_FIND_DATA w32_fd
;
604 HANDLE h
= FindFirstFile(name
, &w32_fd
);
606 if (h
== INVALID_HANDLE_VALUE
)
612 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
614 p
= strrchr (buf
, '\\');
617 SetCurrentDirectory (buf
);
618 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
619 SetCurrentDirectory (cwd
);
622 if (strcasecmp (buf
, "ntdll.dll") == 0)
624 GetSystemDirectory (buf
, sizeof (buf
));
625 strcat (buf
, "\\ntdll.dll");
628 cygwin_buf_t buf
[__PMAX
];
631 if (access (name
, F_OK
) != 0)
633 if (strcasecmp (name
, "ntdll.dll") == 0)
636 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
637 wcscat (buf
, L
"\\ntdll.dll");
641 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
642 strcat (buf
, "\\ntdll.dll");
647 so
= XCNEW (struct so_list
);
648 so
->lm_info
= XNEW (struct lm_info
);
649 so
->lm_info
->load_addr
= load_addr
;
650 strcpy (so
->so_original_name
, name
);
652 strcpy (so
->so_name
, buf
);
655 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
656 SO_NAME_MAX_PATH_SIZE
);
659 char *rname
= realpath (name
, NULL
);
660 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
662 strcpy (so
->so_name
, rname
);
666 error (_("dll path too long"));
668 /* Record cygwin1.dll .text start/end. */
669 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
670 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
672 asection
*text
= NULL
;
675 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386", -1));
680 if (bfd_check_format (abfd
.get (), bfd_object
))
681 text
= bfd_get_section_by_name (abfd
.get (), ".text");
686 /* The symbols in a dll are offset by 0x1000, which is the
687 offset from 0 of the first byte in an image - because of the
688 file header and the section alignment. */
689 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
691 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (abfd
.get (),
700 get_image_name (HANDLE h
, void *address
, int unicode
)
703 static char buf
[__PMAX
];
705 static char buf
[(2 * __PMAX
) + 1];
707 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
713 /* Attempt to read the name of the dll that was detected.
714 This is documented to work only when actively debugging
715 a program. It will not work for attached processes. */
719 /* See if we could read the address of a string, and that the
720 address isn't null. */
721 if (!ReadProcessMemory (h
, address
, &address_ptr
,
722 sizeof (address_ptr
), &done
)
723 || done
!= sizeof (address_ptr
) || !address_ptr
)
726 /* Find the length of the string. */
727 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
728 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
732 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
735 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
736 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
739 wcstombs (buf
, unicode_address
, __PMAX
);
741 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
749 /* Handle a DLL load event, and return 1.
751 This function assumes that this event did not occur during inferior
752 initialization, where their event info may be incomplete (see
753 do_initial_windows_stuff and windows_add_all_dlls for more info
754 on how we handle DLL loading during that phase). */
757 handle_load_dll (void *dummy
)
759 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
762 /* Try getting the DLL name via the lpImageName field of the event.
763 Note that Microsoft documents this fields as strictly optional,
764 in the sense that it might be NULL. And the first DLL event in
765 particular is explicitly documented as "likely not pass[ed]"
766 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
767 dll_name
= get_image_name (current_process_handle
,
768 event
->lpImageName
, event
->fUnicode
);
772 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
773 solib_end
= solib_end
->next
;
775 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
776 host_address_to_string (solib_end
->lm_info
->load_addr
)));
782 windows_free_so (struct so_list
*so
)
789 /* Handle a DLL unload event.
790 Return 1 if successful, or zero otherwise.
792 This function assumes that this event did not occur during inferior
793 initialization, where their event info may be incomplete (see
794 do_initial_windows_stuff and windows_add_all_dlls for more info
795 on how we handle DLL loading during that phase). */
798 handle_unload_dll (void *dummy
)
800 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
803 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
804 if (so
->next
->lm_info
->load_addr
== lpBaseOfDll
)
806 struct so_list
*sodel
= so
->next
;
808 so
->next
= sodel
->next
;
811 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
813 windows_free_so (sodel
);
817 /* We did not find any DLL that was previously loaded at this address,
818 so register a complaint. We do not report an error, because we have
819 observed that this may be happening under some circumstances. For
820 instance, running 32bit applications on x64 Windows causes us to receive
821 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
822 events are apparently caused by the WOW layer, the interface between
823 32bit and 64bit worlds). */
824 complaint (&symfile_complaints
, _("dll starting at %s not found."),
825 host_address_to_string (lpBaseOfDll
));
830 /* Clear list of loaded DLLs. */
832 windows_clear_solib (void)
834 solib_start
.next
= NULL
;
835 solib_end
= &solib_start
;
839 signal_event_command (char *args
, int from_tty
)
841 uintptr_t event_id
= 0;
842 char *endargs
= NULL
;
845 error (_("signal-event requires an argument (integer event id)"));
847 event_id
= strtoumax (args
, &endargs
, 10);
849 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
850 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
851 error (_("Failed to convert `%s' to event id"), args
);
853 SetEvent ((HANDLE
) event_id
);
854 CloseHandle ((HANDLE
) event_id
);
857 /* Handle DEBUG_STRING output from child process.
858 Cygwin prepends its messages with a "cygwin:". Interpret this as
859 a Cygwin signal. Otherwise just print the string as a warning. */
861 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
866 if (!target_read_string
867 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
871 else if (!startswith (s
, _CYGWIN_SIGNAL_STRING
))
874 if (!startswith (s
, "cYg"))
877 char *p
= strchr (s
, '\0');
879 if (p
> s
&& *--p
== '\n')
887 /* Got a cygwin signal marker. A cygwin signal is followed by
888 the signal number itself and then optionally followed by the
889 thread id and address to saved context within the DLL. If
890 these are supplied, then the given thread is assumed to have
891 issued the signal and the context from the thread is assumed
892 to be stored at the given address in the inferior. Tell gdb
893 to treat this like a real signal. */
895 int sig
= strtol (s
+ sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
896 gdb_signal gotasig
= gdb_signal_from_host (sig
);
898 ourstatus
->value
.sig
= gotasig
;
904 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
905 retval
= strtoul (p
, &p
, 0);
907 retval
= main_thread_id
;
908 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
909 && ReadProcessMemory (current_process_handle
, x
,
911 __COPY_CONTEXT_SIZE
, &n
)
912 && n
== __COPY_CONTEXT_SIZE
)
913 have_saved_context
= 1;
924 display_selector (HANDLE thread
, DWORD sel
)
927 if (GetThreadSelectorEntry (thread
, sel
, &info
))
930 printf_filtered ("0x%03x: ", (unsigned) sel
);
931 if (!info
.HighWord
.Bits
.Pres
)
933 puts_filtered ("Segment not present\n");
936 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
937 (info
.HighWord
.Bits
.BaseMid
<< 16)
939 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
940 if (info
.HighWord
.Bits
.Granularity
)
941 limit
= (limit
<< 12) | 0xfff;
942 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
943 if (info
.HighWord
.Bits
.Default_Big
)
944 puts_filtered(" 32-bit ");
946 puts_filtered(" 16-bit ");
947 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
950 puts_filtered ("Data (Read-Only, Exp-up");
953 puts_filtered ("Data (Read/Write, Exp-up");
956 puts_filtered ("Unused segment (");
959 puts_filtered ("Data (Read/Write, Exp-down");
962 puts_filtered ("Code (Exec-Only, N.Conf");
965 puts_filtered ("Code (Exec/Read, N.Conf");
968 puts_filtered ("Code (Exec-Only, Conf");
971 puts_filtered ("Code (Exec/Read, Conf");
974 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
976 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
977 puts_filtered(", N.Acc");
978 puts_filtered (")\n");
979 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
980 puts_filtered("System selector ");
981 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
982 if (info
.HighWord
.Bits
.Granularity
)
983 puts_filtered ("Page granular.\n");
985 puts_filtered ("Byte granular.\n");
990 DWORD err
= GetLastError ();
991 if (err
== ERROR_NOT_SUPPORTED
)
992 printf_filtered ("Function not supported\n");
994 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1000 display_selectors (char * args
, int from_tty
)
1002 if (!current_thread
)
1004 puts_filtered ("Impossible to display selectors now.\n");
1010 puts_filtered ("Selector $cs\n");
1011 display_selector (current_thread
->h
,
1012 current_thread
->context
.SegCs
);
1013 puts_filtered ("Selector $ds\n");
1014 display_selector (current_thread
->h
,
1015 current_thread
->context
.SegDs
);
1016 puts_filtered ("Selector $es\n");
1017 display_selector (current_thread
->h
,
1018 current_thread
->context
.SegEs
);
1019 puts_filtered ("Selector $ss\n");
1020 display_selector (current_thread
->h
,
1021 current_thread
->context
.SegSs
);
1022 puts_filtered ("Selector $fs\n");
1023 display_selector (current_thread
->h
,
1024 current_thread
->context
.SegFs
);
1025 puts_filtered ("Selector $gs\n");
1026 display_selector (current_thread
->h
,
1027 current_thread
->context
.SegGs
);
1032 sel
= parse_and_eval_long (args
);
1033 printf_filtered ("Selector \"%s\"\n",args
);
1034 display_selector (current_thread
->h
, sel
);
1038 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1039 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1040 host_address_to_string (\
1041 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1043 static handle_exception_result
1044 handle_exception (struct target_waitstatus
*ourstatus
)
1046 EXCEPTION_RECORD
*rec
= ¤t_event
.u
.Exception
.ExceptionRecord
;
1047 DWORD code
= rec
->ExceptionCode
;
1048 handle_exception_result result
= HANDLE_EXCEPTION_HANDLED
;
1050 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1052 /* Record the context of the current thread. */
1053 thread_rec (current_event
.dwThreadId
, -1);
1057 case EXCEPTION_ACCESS_VIOLATION
:
1058 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1059 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1062 /* See if the access violation happened within the cygwin DLL
1063 itself. Cygwin uses a kind of exception handling to deal
1064 with passed-in invalid addresses. gdb should not treat
1065 these as real SEGVs since they will be silently handled by
1066 cygwin. A real SEGV will (theoretically) be caught by
1067 cygwin later in the process and will be sent as a
1068 cygwin-specific-signal. So, ignore SEGVs if they show up
1069 within the text segment of the DLL itself. */
1071 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1073 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1074 && addr
< cygwin_load_end
))
1075 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1076 && startswith (fn
, "KERNEL32!IsBad")))
1077 return HANDLE_EXCEPTION_UNHANDLED
;
1081 case STATUS_STACK_OVERFLOW
:
1082 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1083 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1085 case STATUS_FLOAT_DENORMAL_OPERAND
:
1086 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1087 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1089 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1090 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1091 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1093 case STATUS_FLOAT_INEXACT_RESULT
:
1094 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1095 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1097 case STATUS_FLOAT_INVALID_OPERATION
:
1098 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1099 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1101 case STATUS_FLOAT_OVERFLOW
:
1102 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1103 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1105 case STATUS_FLOAT_STACK_CHECK
:
1106 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1107 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1109 case STATUS_FLOAT_UNDERFLOW
:
1110 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1111 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1113 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1114 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1115 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1117 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1118 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1119 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1121 case STATUS_INTEGER_OVERFLOW
:
1122 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1123 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1125 case EXCEPTION_BREAKPOINT
:
1126 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1127 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1130 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1131 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1133 case DBG_CONTROL_BREAK
:
1134 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1135 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1137 case EXCEPTION_SINGLE_STEP
:
1138 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1139 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1141 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1142 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1143 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1145 case EXCEPTION_PRIV_INSTRUCTION
:
1146 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1147 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1149 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1150 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1151 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1153 case MS_VC_EXCEPTION
:
1154 if (rec
->NumberParameters
>= 3
1155 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1157 DWORD named_thread_id
;
1158 windows_thread_info
*named_thread
;
1159 CORE_ADDR thread_name_target
;
1161 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1163 thread_name_target
= rec
->ExceptionInformation
[1];
1164 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1166 if (named_thread_id
== (DWORD
) -1)
1167 named_thread_id
= current_event
.dwThreadId
;
1169 named_thread
= thread_rec (named_thread_id
, 0);
1170 if (named_thread
!= NULL
)
1172 int thread_name_len
;
1175 thread_name_len
= target_read_string (thread_name_target
,
1176 &thread_name
, 1025, NULL
);
1177 if (thread_name_len
> 0)
1179 thread_name
[thread_name_len
- 1] = '\0';
1180 xfree (named_thread
->name
);
1181 named_thread
->name
= thread_name
;
1184 xfree (thread_name
);
1186 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1187 result
= HANDLE_EXCEPTION_IGNORED
;
1190 /* treat improperly formed exception as unknown, fallthrough */
1192 /* Treat unhandled first chance exceptions specially. */
1193 if (current_event
.u
.Exception
.dwFirstChance
)
1194 return HANDLE_EXCEPTION_UNHANDLED
;
1195 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1196 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1197 host_address_to_string (
1198 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1199 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1203 last_sig
= ourstatus
->value
.sig
;
1207 /* Resume thread specified by ID, or all artificially suspended
1208 threads, if we are continuing execution. KILLED non-zero means we
1209 have killed the inferior, so we should ignore weird errors due to
1210 threads shutting down. */
1212 windows_continue (DWORD continue_status
, int id
, int killed
)
1215 windows_thread_info
*th
;
1218 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1219 (unsigned) current_event
.dwProcessId
,
1220 (unsigned) current_event
.dwThreadId
,
1221 continue_status
== DBG_CONTINUE
?
1222 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1224 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1225 if ((id
== -1 || id
== (int) th
->id
)
1228 if (debug_registers_changed
)
1230 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1231 th
->context
.Dr0
= dr
[0];
1232 th
->context
.Dr1
= dr
[1];
1233 th
->context
.Dr2
= dr
[2];
1234 th
->context
.Dr3
= dr
[3];
1235 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1236 th
->context
.Dr7
= dr
[7];
1238 if (th
->context
.ContextFlags
)
1242 if (GetExitCodeThread (th
->h
, &ec
)
1243 && ec
== STILL_ACTIVE
)
1245 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1250 th
->context
.ContextFlags
= 0;
1252 if (th
->suspended
> 0)
1253 (void) ResumeThread (th
->h
);
1257 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1258 current_event
.dwThreadId
,
1262 error (_("Failed to resume program execution"
1263 " (ContinueDebugEvent failed, error %u)"),
1264 (unsigned int) GetLastError ());
1266 debug_registers_changed
= 0;
1270 /* Called in pathological case where Windows fails to send a
1271 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1273 fake_create_process (void)
1275 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1276 current_event
.dwProcessId
);
1277 if (current_process_handle
!= NULL
)
1278 open_process_used
= 1;
1281 error (_("OpenProcess call failed, GetLastError = %u"),
1282 (unsigned) GetLastError ());
1283 /* We can not debug anything in that case. */
1285 main_thread_id
= current_event
.dwThreadId
;
1286 current_thread
= windows_add_thread (
1287 ptid_build (current_event
.dwProcessId
, 0,
1288 current_event
.dwThreadId
),
1289 current_event
.u
.CreateThread
.hThread
,
1290 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1291 return main_thread_id
;
1295 windows_resume (struct target_ops
*ops
,
1296 ptid_t ptid
, int step
, enum gdb_signal sig
)
1298 windows_thread_info
*th
;
1299 DWORD continue_status
= DBG_CONTINUE
;
1301 /* A specific PTID means `step only this thread id'. */
1302 int resume_all
= ptid_equal (ptid
, minus_one_ptid
);
1304 /* If we're continuing all threads, it's the current inferior that
1305 should be handled specially. */
1307 ptid
= inferior_ptid
;
1309 if (sig
!= GDB_SIGNAL_0
)
1311 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1313 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1315 else if (sig
== last_sig
)
1316 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1319 /* This code does not seem to work, because
1320 the kernel does probably not consider changes in the ExceptionRecord
1321 structure when passing the exception to the inferior.
1322 Note that this seems possible in the exception handler itself. */
1325 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1326 if (xlate
[i
].us
== sig
)
1328 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1330 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1333 if (continue_status
== DBG_CONTINUE
)
1335 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1339 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1343 last_sig
= GDB_SIGNAL_0
;
1345 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1346 ptid_get_pid (ptid
), ptid_get_tid (ptid
), step
, sig
));
1348 /* Get context for currently selected thread. */
1349 th
= thread_rec (ptid_get_tid (inferior_ptid
), FALSE
);
1354 /* Single step by setting t bit. */
1355 struct regcache
*regcache
= get_current_regcache ();
1356 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1357 windows_fetch_inferior_registers (ops
, regcache
,
1358 gdbarch_ps_regnum (gdbarch
));
1359 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1362 if (th
->context
.ContextFlags
)
1364 if (debug_registers_changed
)
1366 th
->context
.Dr0
= dr
[0];
1367 th
->context
.Dr1
= dr
[1];
1368 th
->context
.Dr2
= dr
[2];
1369 th
->context
.Dr3
= dr
[3];
1370 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1371 th
->context
.Dr7
= dr
[7];
1373 CHECK (SetThreadContext (th
->h
, &th
->context
));
1374 th
->context
.ContextFlags
= 0;
1378 /* Allow continuing with the same signal that interrupted us.
1379 Otherwise complain. */
1382 windows_continue (continue_status
, -1, 0);
1384 windows_continue (continue_status
, ptid_get_tid (ptid
), 0);
1387 /* Ctrl-C handler used when the inferior is not run in the same console. The
1388 handler is in charge of interrupting the inferior using DebugBreakProcess.
1389 Note that this function is not available prior to Windows XP. In this case
1390 we emit a warning. */
1392 ctrl_c_handler (DWORD event_type
)
1394 const int attach_flag
= current_inferior ()->attach_flag
;
1396 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1397 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1400 /* If the inferior and the debugger share the same console, do nothing as
1401 the inferior has also received the Ctrl-C event. */
1402 if (!new_console
&& !attach_flag
)
1405 if (!DebugBreakProcess (current_process_handle
))
1406 warning (_("Could not interrupt program. "
1407 "Press Ctrl-c in the program console."));
1409 /* Return true to tell that Ctrl-C has been handled. */
1413 /* Get the next event from the child. Returns a non-zero thread id if the event
1414 requires handling by WFI (or whatever). */
1416 get_windows_debug_event (struct target_ops
*ops
,
1417 int pid
, struct target_waitstatus
*ourstatus
)
1420 DWORD continue_status
, event_code
;
1421 windows_thread_info
*th
;
1422 static windows_thread_info dummy_thread_info
;
1423 DWORD thread_id
= 0;
1425 last_sig
= GDB_SIGNAL_0
;
1427 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1431 continue_status
= DBG_CONTINUE
;
1433 event_code
= current_event
.dwDebugEventCode
;
1434 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1436 have_saved_context
= 0;
1440 case CREATE_THREAD_DEBUG_EVENT
:
1441 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1442 (unsigned) current_event
.dwProcessId
,
1443 (unsigned) current_event
.dwThreadId
,
1444 "CREATE_THREAD_DEBUG_EVENT"));
1445 if (saw_create
!= 1)
1447 struct inferior
*inf
;
1448 inf
= find_inferior_pid (current_event
.dwProcessId
);
1449 if (!saw_create
&& inf
->attach_flag
)
1451 /* Kludge around a Windows bug where first event is a create
1452 thread event. Caused when attached process does not have
1454 thread_id
= fake_create_process ();
1460 /* Record the existence of this thread. */
1461 thread_id
= current_event
.dwThreadId
;
1462 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1463 current_event
.dwThreadId
),
1464 current_event
.u
.CreateThread
.hThread
,
1465 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1469 case EXIT_THREAD_DEBUG_EVENT
:
1470 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1471 (unsigned) current_event
.dwProcessId
,
1472 (unsigned) current_event
.dwThreadId
,
1473 "EXIT_THREAD_DEBUG_EVENT"));
1475 if (current_event
.dwThreadId
!= main_thread_id
)
1477 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1478 current_event
.dwThreadId
),
1479 current_event
.u
.ExitThread
.dwExitCode
);
1480 th
= &dummy_thread_info
;
1484 case CREATE_PROCESS_DEBUG_EVENT
:
1485 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1486 (unsigned) current_event
.dwProcessId
,
1487 (unsigned) current_event
.dwThreadId
,
1488 "CREATE_PROCESS_DEBUG_EVENT"));
1489 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1490 if (++saw_create
!= 1)
1493 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1495 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1498 main_thread_id
= current_event
.dwThreadId
;
1499 /* Add the main thread. */
1500 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1501 current_event
.dwThreadId
),
1502 current_event
.u
.CreateProcessInfo
.hThread
,
1503 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
);
1504 thread_id
= current_event
.dwThreadId
;
1507 case EXIT_PROCESS_DEBUG_EVENT
:
1508 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1509 (unsigned) current_event
.dwProcessId
,
1510 (unsigned) current_event
.dwThreadId
,
1511 "EXIT_PROCESS_DEBUG_EVENT"));
1512 if (!windows_initialization_done
)
1514 target_terminal_ours ();
1515 target_mourn_inferior (inferior_ptid
);
1516 error (_("During startup program exited with code 0x%x."),
1517 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1519 else if (saw_create
== 1)
1521 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1522 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1523 thread_id
= main_thread_id
;
1527 case LOAD_DLL_DEBUG_EVENT
:
1528 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1529 (unsigned) current_event
.dwProcessId
,
1530 (unsigned) current_event
.dwThreadId
,
1531 "LOAD_DLL_DEBUG_EVENT"));
1532 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1533 if (saw_create
!= 1 || ! windows_initialization_done
)
1535 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1536 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1537 ourstatus
->value
.integer
= 0;
1538 thread_id
= main_thread_id
;
1541 case UNLOAD_DLL_DEBUG_EVENT
:
1542 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1543 (unsigned) current_event
.dwProcessId
,
1544 (unsigned) current_event
.dwThreadId
,
1545 "UNLOAD_DLL_DEBUG_EVENT"));
1546 if (saw_create
!= 1 || ! windows_initialization_done
)
1548 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1549 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1550 ourstatus
->value
.integer
= 0;
1551 thread_id
= main_thread_id
;
1554 case EXCEPTION_DEBUG_EVENT
:
1555 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1556 (unsigned) current_event
.dwProcessId
,
1557 (unsigned) current_event
.dwThreadId
,
1558 "EXCEPTION_DEBUG_EVENT"));
1559 if (saw_create
!= 1)
1561 switch (handle_exception (ourstatus
))
1563 case HANDLE_EXCEPTION_UNHANDLED
:
1565 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1567 case HANDLE_EXCEPTION_HANDLED
:
1568 thread_id
= current_event
.dwThreadId
;
1570 case HANDLE_EXCEPTION_IGNORED
:
1571 continue_status
= DBG_CONTINUE
;
1576 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1577 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1578 (unsigned) current_event
.dwProcessId
,
1579 (unsigned) current_event
.dwThreadId
,
1580 "OUTPUT_DEBUG_STRING_EVENT"));
1581 if (saw_create
!= 1)
1583 thread_id
= handle_output_debug_string (ourstatus
);
1587 if (saw_create
!= 1)
1589 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1590 (unsigned) current_event
.dwProcessId
,
1591 (unsigned) current_event
.dwThreadId
);
1592 printf_unfiltered (" unknown event code %u\n",
1593 (unsigned) current_event
.dwDebugEventCode
);
1597 if (!thread_id
|| saw_create
!= 1)
1599 CHECK (windows_continue (continue_status
, -1, 0));
1603 inferior_ptid
= ptid_build (current_event
.dwProcessId
, 0,
1605 current_thread
= th
;
1606 if (!current_thread
)
1607 current_thread
= thread_rec (thread_id
, TRUE
);
1614 /* Wait for interesting events to occur in the target process. */
1616 windows_wait (struct target_ops
*ops
,
1617 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
1621 target_terminal_ours ();
1623 /* We loop when we get a non-standard exception rather than return
1624 with a SPURIOUS because resume can try and step or modify things,
1625 which needs a current_thread->h. But some of these exceptions mark
1626 the birth or death of threads, which mean that the current thread
1627 isn't necessarily what you think it is. */
1633 /* If the user presses Ctrl-c while the debugger is waiting
1634 for an event, he expects the debugger to interrupt his program
1635 and to get the prompt back. There are two possible situations:
1637 - The debugger and the program do not share the console, in
1638 which case the Ctrl-c event only reached the debugger.
1639 In that case, the ctrl_c handler will take care of interrupting
1640 the inferior. Note that this case is working starting with
1641 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1644 - The debugger and the program share the same console, in which
1645 case both debugger and inferior will receive the Ctrl-c event.
1646 In that case the ctrl_c handler will ignore the event, as the
1647 Ctrl-c event generated inside the inferior will trigger the
1648 expected debug event.
1650 FIXME: brobecker/2008-05-20: If the inferior receives the
1651 signal first and the delay until GDB receives that signal
1652 is sufficiently long, GDB can sometimes receive the SIGINT
1653 after we have unblocked the CTRL+C handler. This would
1654 lead to the debugger stopping prematurely while handling
1655 the new-thread event that comes with the handling of the SIGINT
1656 inside the inferior, and then stop again immediately when
1657 the user tries to resume the execution in the inferior.
1658 This is a classic race that we should try to fix one day. */
1659 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1660 retval
= get_windows_debug_event (ops
, pid
, ourstatus
);
1661 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1664 return ptid_build (current_event
.dwProcessId
, 0, retval
);
1669 if (deprecated_ui_loop_hook
!= NULL
)
1670 detach
= deprecated_ui_loop_hook (0);
1673 windows_kill_inferior (ops
);
1678 /* Iterate over all DLLs currently mapped by our inferior, and
1679 add them to our list of solibs. */
1682 windows_add_all_dlls (void)
1685 HMODULE dummy_hmodule
;
1690 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
1691 sizeof (HMODULE
), &cb_needed
) == 0)
1697 hmodules
= (HMODULE
*) alloca (cb_needed
);
1698 if (EnumProcessModules (current_process_handle
, hmodules
,
1699 cb_needed
, &cb_needed
) == 0)
1702 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
1706 wchar_t dll_name
[__PMAX
];
1709 char dll_name
[__PMAX
];
1712 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
1713 &mi
, sizeof (mi
)) == 0)
1715 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
1716 dll_name
, sizeof (dll_name
)) == 0)
1719 wcstombs (name
, dll_name
, __PMAX
);
1724 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
1725 solib_end
= solib_end
->next
;
1730 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1733 struct inferior
*inf
;
1734 struct thread_info
*tp
;
1736 last_sig
= GDB_SIGNAL_0
;
1738 exception_count
= 0;
1739 open_process_used
= 0;
1740 debug_registers_changed
= 0;
1741 debug_registers_used
= 0;
1742 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1745 cygwin_load_start
= cygwin_load_end
= 0;
1747 current_event
.dwProcessId
= pid
;
1748 memset (¤t_event
, 0, sizeof (current_event
));
1749 if (!target_is_pushed (ops
))
1751 disable_breakpoints_in_shlibs ();
1752 windows_clear_solib ();
1753 clear_proceed_status (0);
1754 init_wait_for_inferior ();
1756 inf
= current_inferior ();
1757 inferior_appeared (inf
, pid
);
1758 inf
->attach_flag
= attaching
;
1760 /* Make the new process the current inferior, so terminal handling
1761 can rely on it. When attaching, we don't know about any thread
1762 id here, but that's OK --- nothing should be referencing the
1763 current thread until we report an event out of windows_wait. */
1764 inferior_ptid
= pid_to_ptid (pid
);
1766 target_terminal_init ();
1767 target_terminal_inferior ();
1769 windows_initialization_done
= 0;
1773 struct target_waitstatus status
;
1775 windows_wait (ops
, minus_one_ptid
, &status
, 0);
1777 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
1779 if (status
.kind
!= TARGET_WAITKIND_LOADED
1780 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
1783 windows_resume (ops
, minus_one_ptid
, 0, GDB_SIGNAL_0
);
1786 /* Now that the inferior has been started and all DLLs have been mapped,
1787 we can iterate over all DLLs and load them in.
1789 We avoid doing it any earlier because, on certain versions of Windows,
1790 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
1791 we have seen on Windows 8.1 that the ntdll.dll load event does not
1792 include the DLL name, preventing us from creating an associated SO.
1793 A possible explanation is that ntdll.dll might be mapped before
1794 the SO info gets created by the Windows system -- ntdll.dll is
1795 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
1796 do not seem to suffer from that problem.
1798 Rather than try to work around this sort of issue, it is much
1799 simpler to just ignore DLL load/unload events during the startup
1800 phase, and then process them all in one batch now. */
1801 windows_add_all_dlls ();
1803 windows_initialization_done
= 1;
1807 /* Try to set or remove a user privilege to the current process. Return -1
1808 if that fails, the previous setting of that privilege otherwise.
1810 This code is copied from the Cygwin source code and rearranged to allow
1811 dynamically loading of the needed symbols from advapi32 which is only
1812 available on NT/2K/XP. */
1814 set_process_privilege (const char *privilege
, BOOL enable
)
1816 HANDLE token_hdl
= NULL
;
1818 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1822 if (!OpenProcessToken (GetCurrentProcess (),
1823 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1827 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
1830 new_priv
.PrivilegeCount
= 1;
1831 new_priv
.Privileges
[0].Luid
= restore_priv
;
1832 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1834 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1835 sizeof orig_priv
, &orig_priv
, &size
))
1838 /* Disabled, otherwise every `attach' in an unprivileged user session
1839 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1840 windows_attach(). */
1841 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1842 be enabled. GetLastError () returns an correct error code, though. */
1843 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1847 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1851 CloseHandle (token_hdl
);
1856 /* Attach to process PID, then initialize for debugging it. */
1858 windows_attach (struct target_ops
*ops
, const char *args
, int from_tty
)
1863 pid
= parse_pid_to_attach (args
);
1865 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1867 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1868 printf_unfiltered ("This can cause attach to "
1869 "fail on Windows NT/2K/XP\n");
1872 windows_init_thread_list ();
1873 ok
= DebugActiveProcess (pid
);
1879 /* Try fall back to Cygwin pid. */
1880 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1883 ok
= DebugActiveProcess (pid
);
1888 error (_("Can't attach to process."));
1890 DebugSetProcessKillOnExit (FALSE
);
1894 char *exec_file
= (char *) get_exec_file (0);
1897 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1898 target_pid_to_str (pid_to_ptid (pid
)));
1900 printf_unfiltered ("Attaching to %s\n",
1901 target_pid_to_str (pid_to_ptid (pid
)));
1903 gdb_flush (gdb_stdout
);
1906 do_initial_windows_stuff (ops
, pid
, 1);
1907 target_terminal_ours ();
1911 windows_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
1916 windows_resume (ops
, ptid
, 0, GDB_SIGNAL_0
);
1918 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1920 error (_("Can't detach process %u (error %u)"),
1921 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
1924 DebugSetProcessKillOnExit (FALSE
);
1926 if (detached
&& from_tty
)
1928 char *exec_file
= get_exec_file (0);
1931 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
1932 (unsigned) current_event
.dwProcessId
);
1933 gdb_flush (gdb_stdout
);
1936 x86_cleanup_dregs ();
1937 inferior_ptid
= null_ptid
;
1938 detach_inferior (current_event
.dwProcessId
);
1940 inf_child_maybe_unpush_target (ops
);
1943 /* Try to determine the executable filename.
1945 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
1947 Upon success, the filename is stored inside EXE_NAME_RET, and
1948 this function returns nonzero.
1950 Otherwise, this function returns zero and the contents of
1951 EXE_NAME_RET is undefined. */
1954 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
1961 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
1962 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
1965 /* We know the executable is always first in the list of modules,
1966 which we just fetched. So no need to fetch more. */
1970 /* Cygwin prefers that the path be in /x/y/z format, so extract
1971 the filename into a temporary buffer first, and then convert it
1972 to POSIX format into the destination buffer. */
1973 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
1975 len
= GetModuleFileNameEx (current_process_handle
,
1976 dh_buf
, pathbuf
, exe_name_max_len
);
1978 error (_("Error getting executable filename: %u."),
1979 (unsigned) GetLastError ());
1980 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
1981 exe_name_max_len
) < 0)
1982 error (_("Error converting executable filename to POSIX: %d."), errno
);
1985 len
= GetModuleFileNameEx (current_process_handle
,
1986 dh_buf
, exe_name_ret
, exe_name_max_len
);
1988 error (_("Error getting executable filename: %u."),
1989 (unsigned) GetLastError ());
1992 return 1; /* success */
1995 /* The pid_to_exec_file target_ops method for this platform. */
1998 windows_pid_to_exec_file (struct target_ops
*self
, int pid
)
2000 static char path
[__PMAX
];
2002 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2004 char procexe
[sizeof ("/proc/4294967295/exe")];
2006 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2007 nchars
= readlink (procexe
, path
, sizeof(path
));
2008 if (nchars
> 0 && nchars
< sizeof (path
))
2010 path
[nchars
] = '\0'; /* Got it */
2015 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2016 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2017 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2023 /* Print status information about what we're accessing. */
2026 windows_files_info (struct target_ops
*ignore
)
2028 struct inferior
*inf
= current_inferior ();
2030 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2031 inf
->attach_flag
? "attached" : "child",
2032 target_pid_to_str (inferior_ptid
));
2035 /* Modify CreateProcess parameters for use of a new separate console.
2037 *FLAGS: DWORD parameter for general process creation flags.
2038 *SI: STARTUPINFO structure, for which the console window size and
2039 console buffer size is filled in if GDB is running in a console.
2040 to create the new console.
2041 The size of the used font is not available on all versions of
2042 Windows OS. Furthermore, the current font might not be the default
2043 font, but this is still better than before.
2044 If the windows and buffer sizes are computed,
2045 SI->DWFLAGS is changed so that this information is used
2046 by CreateProcess function. */
2049 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2051 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2052 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2054 if (hconsole
!= INVALID_HANDLE_VALUE
)
2056 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2058 CONSOLE_FONT_INFO cfi
;
2060 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2061 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2062 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2063 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2064 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2066 si
->dwXSize
*= font_size
.X
;
2070 si
->dwYSize
*= font_size
.Y
;
2073 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2074 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2075 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2077 *flags
|= CREATE_NEW_CONSOLE
;
2081 /* Function called by qsort to sort environment strings. */
2084 envvar_cmp (const void *a
, const void *b
)
2086 const char **p
= (const char **) a
;
2087 const char **q
= (const char **) b
;
2088 return strcasecmp (*p
, *q
);
2094 clear_win32_environment (char **env
)
2098 wchar_t *copy
= NULL
, *equalpos
;
2100 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2102 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2103 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2104 mbstowcs (copy
, env
[i
], len
);
2105 equalpos
= wcschr (copy
, L
'=');
2108 SetEnvironmentVariableW (copy
, NULL
);
2116 /* Redirection of inferior I/O streams for native MS-Windows programs.
2117 Unlike on Unix, where this is handled by invoking the inferior via
2118 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2120 The official documentation of the cmd.exe redirection features is here:
2122 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2124 (That page talks about Windows XP, but there's no newer
2125 documentation, so we assume later versions of cmd.exe didn't change
2128 Caveat: the documentation on that page seems to include a few lies.
2129 For example, it describes strange constructs 1<&2 and 2<&1, which
2130 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2131 think the cmd.exe parser of the redirection symbols simply doesn't
2132 care about the < vs > distinction in these cases. Therefore, the
2133 supported features are explicitly documented below.
2135 The emulation below aims at supporting all the valid use cases
2136 supported by cmd.exe, which include:
2138 < FILE redirect standard input from FILE
2139 0< FILE redirect standard input from FILE
2140 <&N redirect standard input from file descriptor N
2141 0<&N redirect standard input from file descriptor N
2142 > FILE redirect standard output to FILE
2143 >> FILE append standard output to FILE
2144 1>> FILE append standard output to FILE
2145 >&N redirect standard output to file descriptor N
2146 1>&N redirect standard output to file descriptor N
2147 >>&N append standard output to file descriptor N
2148 1>>&N append standard output to file descriptor N
2149 2> FILE redirect standard error to FILE
2150 2>> FILE append standard error to FILE
2151 2>&N redirect standard error to file descriptor N
2152 2>>&N append standard error to file descriptor N
2154 Note that using N > 2 in the above construct is supported, but
2155 requires that the corresponding file descriptor be open by some
2156 means elsewhere or outside GDB. Also note that using ">&0" or
2157 "<&2" will generally fail, because the file descriptor redirected
2158 from is normally open in an incompatible mode (e.g., FD 0 is open
2159 for reading only). IOW, use of such tricks is not recommended;
2160 you are on your own.
2162 We do NOT support redirection of file descriptors above 2, as in
2163 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2164 that needs special handling in the startup code that MinGW
2165 doesn't have). Pipes are also not supported.
2167 As for invalid use cases, where the redirection contains some
2168 error, the emulation below will detect that and produce some
2169 error and/or failure. But the behavior in those cases is not
2170 bug-for-bug compatible with what cmd.exe does in those cases.
2171 That's because what cmd.exe does then is not well defined, and
2172 seems to be a side effect of the cmd.exe parsing of the command
2173 line more than anything else. For example, try redirecting to an
2174 invalid file name, as in "> foo:bar".
2176 There are also minor syntactic deviations from what cmd.exe does
2177 in some corner cases. For example, it doesn't support the likes
2178 of "> &foo" to mean redirect to file named literally "&foo"; we
2179 do support that here, because that, too, sounds like some issue
2180 with the cmd.exe parser. Another nicety is that we support
2181 redirection targets that use file names with forward slashes,
2182 something cmd.exe doesn't -- this comes in handy since GDB
2183 file-name completion can be used when typing the command line for
2186 /* Support routines for redirecting standard handles of the inferior. */
2188 /* Parse a single redirection spec, open/duplicate the specified
2189 file/fd, and assign the appropriate value to one of the 3 standard
2190 file descriptors. */
2192 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2194 int *fd
, ref_fd
= -2;
2196 const char *fname
= redir_string
+ 1;
2197 int rc
= *redir_string
;
2212 fd
= (rc
== '2') ? err
: out
;
2213 mode
= O_WRONLY
| O_CREAT
;
2226 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2228 /* A reference to a file descriptor. */
2230 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2231 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2233 /* Don't allow redirection when open modes are incompatible. */
2234 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2235 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2242 else if (ref_fd
== 1)
2244 else if (ref_fd
== 2)
2254 fname
++; /* skip the separator space */
2255 /* If the descriptor is already open, close it. This allows
2256 multiple specs of redirections for the same stream, which is
2257 somewhat nonsensical, but still valid and supported by cmd.exe.
2258 (But cmd.exe only opens a single file in this case, the one
2259 specified by the last redirection spec on the command line.) */
2264 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2268 else if (ref_fd
== -1)
2269 *fd
= -1; /* reset to default destination */
2272 *fd
= _dup (ref_fd
);
2276 /* _open just sets a flag for O_APPEND, which won't be passed to the
2277 inferior, so we need to actually move the file pointer. */
2278 if ((mode
& O_APPEND
) != 0)
2279 _lseek (*fd
, 0L, SEEK_END
);
2283 /* Canonicalize a single redirection spec and set up the corresponding
2284 file descriptor as specified. */
2286 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2288 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2290 const char *start
= s
;
2293 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2294 if ((*start
== '>' || *start
== '1' || *start
== '2')
2298 if (*s
== '>' && *start
!= '>')
2301 else if (*start
== '0' && *s
== '<')
2303 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2306 while (isspace (*s
)) /* skip whitespace before file name */
2308 *d
++ = ' '; /* separate file name with a single space */
2311 /* Copy the file name. */
2314 /* Remove quoting characters from the file name in buf[]. */
2315 if (*s
== '"') /* could support '..' quoting here */
2319 else if (*s
== quote
)
2327 else if (*s
== '\\')
2329 if (s
[1] == '"') /* could support '..' here */
2333 else if (isspace (*s
) && !quote
)
2337 if (d
- buf
>= sizeof (buf
) - 1)
2339 errno
= ENAMETOOLONG
;
2345 /* Windows doesn't allow redirection characters in file names, so we
2346 can bail out early if they use them, or if there's no target file
2347 name after the redirection symbol. */
2348 if (d
[-1] == '>' || d
[-1] == '<')
2353 if (redir_open (buf
, inp
, out
, err
) == 0)
2358 /* Parse the command line for redirection specs and prepare the file
2359 descriptors for the 3 standard streams accordingly. */
2361 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2362 int *inp
, int *out
, int *err
)
2364 const char *s
= cmd_orig
;
2367 bool retval
= false;
2369 while (isspace (*s
))
2374 if (*s
== '"') /* could also support '..' quoting here */
2378 else if (*s
== quote
)
2381 else if (*s
== '\\')
2383 if (s
[1] == '"') /* escaped quote char */
2388 /* Process a single redirection candidate. */
2389 if (*s
== '<' || *s
== '>'
2390 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2391 || (*s
== '0' && s
[1] == '<'))
2393 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2407 #endif /* !__CYGWIN__ */
2409 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2410 EXEC_FILE is the file to run.
2411 ALLARGS is a string containing the arguments to the program.
2412 ENV is the environment vector to pass. Errors reported with error(). */
2415 windows_create_inferior (struct target_ops
*ops
, char *exec_file
,
2416 char *allargs
, char **in_env
, int from_tty
)
2420 cygwin_buf_t real_path
[__PMAX
];
2421 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2423 cygwin_buf_t
*toexec
;
2424 cygwin_buf_t
*cygallargs
;
2426 char **old_env
= NULL
;
2430 int ostdin
, ostdout
, ostderr
;
2431 #else /* !__CYGWIN__ */
2432 char real_path
[__PMAX
];
2433 char shell
[__PMAX
]; /* Path to shell */
2435 char *args
, *allargs_copy
;
2436 size_t args_len
, allargs_len
;
2437 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2438 HANDLE tty
= INVALID_HANDLE_VALUE
;
2439 HANDLE inf_stdin
= INVALID_HANDLE_VALUE
;
2440 HANDLE inf_stdout
= INVALID_HANDLE_VALUE
;
2441 HANDLE inf_stderr
= INVALID_HANDLE_VALUE
;
2442 bool redirected
= false;
2449 #endif /* !__CYGWIN__ */
2450 PROCESS_INFORMATION pi
;
2453 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2456 error (_("No executable specified, use `target exec'."));
2458 memset (&si
, 0, sizeof (si
));
2459 si
.cb
= sizeof (si
);
2462 flags
|= CREATE_NEW_PROCESS_GROUP
;
2465 windows_set_console_info (&si
, &flags
);
2470 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2471 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2472 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2473 error (_("Error starting executable: %d"), errno
);
2476 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2477 if (len
== (size_t) -1)
2478 error (_("Error starting executable: %d"), errno
);
2479 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2480 mbstowcs (cygallargs
, allargs
, len
);
2481 #else /* !__USEWIDE */
2482 cygallargs
= allargs
;
2487 sh
= getenv ("SHELL");
2490 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2491 error (_("Error starting executable via shell: %d"), errno
);
2493 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2494 + mbstowcs (NULL
, allargs
, 0) + 2;
2495 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2496 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2497 #else /* !__USEWIDE */
2498 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2499 + strlen (allargs
) + 2);
2500 cygallargs
= (char *) alloca (len
);
2501 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2502 #endif /* __USEWIDE */
2504 flags
|= DEBUG_PROCESS
;
2508 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2509 * sizeof (wchar_t));
2510 wcscpy (args
, toexec
);
2511 wcscat (args
, L
" ");
2512 wcscat (args
, cygallargs
);
2513 #else /* !__USEWIDE */
2514 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2515 strcpy (args
, toexec
);
2517 strcat (args
, cygallargs
);
2518 #endif /* !__USEWIDE */
2520 #ifdef CW_CVT_ENV_TO_WINENV
2521 /* First try to create a direct Win32 copy of the POSIX environment. */
2522 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2523 if (w32_env
!= (PWCHAR
) -1)
2524 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2526 /* If that fails, fall back to old method tweaking GDB's environment. */
2527 #endif /* CW_CVT_ENV_TO_WINENV */
2529 /* Reset all Win32 environment variables to avoid leftover on next run. */
2530 clear_win32_environment (environ
);
2531 /* Prepare the environment vars for CreateProcess. */
2534 cygwin_internal (CW_SYNC_WINENV
);
2538 if (!inferior_io_terminal
)
2539 tty
= ostdin
= ostdout
= ostderr
= -1;
2542 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2545 print_sys_errmsg (inferior_io_terminal
, errno
);
2546 ostdin
= ostdout
= ostderr
= -1;
2559 windows_init_thread_list ();
2560 ret
= CreateProcess (0,
2561 args
, /* command line */
2562 NULL
, /* Security */
2564 TRUE
, /* inherit handles */
2565 flags
, /* start flags */
2566 w32_env
, /* environment */
2567 NULL
, /* current directory */
2571 /* Just free the Win32 environment, if it could be created. */
2575 /* Reset all environment variables to avoid leftover on next run. */
2576 clear_win32_environment (in_env
);
2577 /* Restore normal GDB environment variables. */
2579 cygwin_internal (CW_SYNC_WINENV
);
2592 #else /* !__CYGWIN__ */
2593 allargs_len
= strlen (allargs
);
2594 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
2595 if (strpbrk (allargs_copy
, "<>") != NULL
)
2600 redirect_inferior_handles (allargs
, allargs_copy
,
2601 &fd_inp
, &fd_out
, &fd_err
);
2603 warning (_("Error in redirection: %s."), strerror (errno
));
2606 allargs_len
= strlen (allargs_copy
);
2608 /* If not all the standard streams are redirected by the command
2609 line, use inferior_io_terminal for those which aren't. */
2610 if (inferior_io_terminal
2611 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
2613 SECURITY_ATTRIBUTES sa
;
2614 sa
.nLength
= sizeof(sa
);
2615 sa
.lpSecurityDescriptor
= 0;
2616 sa
.bInheritHandle
= TRUE
;
2617 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2618 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2619 if (tty
== INVALID_HANDLE_VALUE
)
2620 warning (_("Warning: Failed to open TTY %s, error %#x."),
2621 inferior_io_terminal
, (unsigned) GetLastError ());
2623 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
2626 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
2627 else if (tty
!= INVALID_HANDLE_VALUE
)
2630 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
2632 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
2633 else if (tty
!= INVALID_HANDLE_VALUE
)
2634 si
.hStdOutput
= tty
;
2636 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
2638 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
2639 else if (tty
!= INVALID_HANDLE_VALUE
)
2642 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
2643 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2647 /* Build the command line, a space-separated list of tokens where
2648 the first token is the name of the module to be executed.
2649 To avoid ambiguities introduced by spaces in the module name,
2651 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
2652 args
= (char *) alloca (args_len
);
2653 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
2655 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2657 /* CreateProcess takes the environment list as a null terminated set of
2658 strings (i.e. two nulls terminate the list). */
2660 /* Get total size for env strings. */
2661 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2662 envlen
+= strlen (in_env
[i
]) + 1;
2664 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2665 env
= (char **) alloca (envsize
);
2666 memcpy (env
, in_env
, envsize
);
2667 /* Windows programs expect the environment block to be sorted. */
2668 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2670 w32env
= (char *) alloca (envlen
+ 1);
2672 /* Copy env strings into new buffer. */
2673 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2675 strcpy (temp
, env
[i
]);
2676 temp
+= strlen (temp
) + 1;
2679 /* Final nil string to terminate new env. */
2682 windows_init_thread_list ();
2683 ret
= CreateProcessA (0,
2684 args
, /* command line */
2685 NULL
, /* Security */
2687 TRUE
, /* inherit handles */
2688 flags
, /* start flags */
2689 w32env
, /* environment */
2690 NULL
, /* current directory */
2693 if (tty
!= INVALID_HANDLE_VALUE
)
2701 #endif /* !__CYGWIN__ */
2704 error (_("Error creating process %s, (error %u)."),
2705 exec_file
, (unsigned) GetLastError ());
2707 CloseHandle (pi
.hThread
);
2708 CloseHandle (pi
.hProcess
);
2710 if (useshell
&& shell
[0] != '\0')
2715 do_initial_windows_stuff (ops
, pi
.dwProcessId
, 0);
2717 /* windows_continue (DBG_CONTINUE, -1, 0); */
2721 windows_mourn_inferior (struct target_ops
*ops
)
2723 (void) windows_continue (DBG_CONTINUE
, -1, 0);
2724 x86_cleanup_dregs();
2725 if (open_process_used
)
2727 CHECK (CloseHandle (current_process_handle
));
2728 open_process_used
= 0;
2730 inf_child_mourn_inferior (ops
);
2733 /* Send a SIGINT to the process group. This acts just like the user typed a
2734 ^C on the controlling terminal. */
2737 windows_interrupt (struct target_ops
*self
, ptid_t ptid
)
2739 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2740 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
2741 registers_changed (); /* refresh register state */
2744 /* Helper for windows_xfer_partial that handles memory transfers.
2745 Arguments are like target_xfer_partial. */
2747 static enum target_xfer_status
2748 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2749 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2753 DWORD lasterror
= 0;
2755 if (writebuf
!= NULL
)
2757 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
2758 pulongest (len
), core_addr_to_string (memaddr
)));
2759 success
= WriteProcessMemory (current_process_handle
,
2760 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
2763 lasterror
= GetLastError ();
2764 FlushInstructionCache (current_process_handle
,
2765 (LPCVOID
) (uintptr_t) memaddr
, len
);
2769 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
2770 pulongest (len
), core_addr_to_string (memaddr
)));
2771 success
= ReadProcessMemory (current_process_handle
,
2772 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
2775 lasterror
= GetLastError ();
2777 *xfered_len
= (ULONGEST
) done
;
2778 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
2779 return TARGET_XFER_OK
;
2781 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
2785 windows_kill_inferior (struct target_ops
*ops
)
2787 CHECK (TerminateProcess (current_process_handle
, 0));
2791 if (!windows_continue (DBG_CONTINUE
, -1, 1))
2793 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
2795 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2799 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
2803 windows_close (struct target_ops
*self
)
2805 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2806 ptid_get_pid (inferior_ptid
)));
2809 /* Convert pid to printable format. */
2811 windows_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
2813 static char buf
[80];
2815 if (ptid_get_tid (ptid
) != 0)
2817 snprintf (buf
, sizeof (buf
), "Thread %d.0x%lx",
2818 ptid_get_pid (ptid
), ptid_get_tid (ptid
));
2822 return normal_pid_to_str (ptid
);
2825 static enum target_xfer_status
2826 windows_xfer_shared_libraries (struct target_ops
*ops
,
2827 enum target_object object
, const char *annex
,
2828 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2829 ULONGEST offset
, ULONGEST len
,
2830 ULONGEST
*xfered_len
)
2832 struct obstack obstack
;
2838 return TARGET_XFER_E_IO
;
2840 obstack_init (&obstack
);
2841 obstack_grow_str (&obstack
, "<library-list>\n");
2842 for (so
= solib_start
.next
; so
; so
= so
->next
)
2843 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
2844 (uintptr_t) so
->lm_info
->load_addr
,
2845 target_gdbarch (), &obstack
);
2846 obstack_grow_str0 (&obstack
, "</library-list>\n");
2848 buf
= (const char *) obstack_finish (&obstack
);
2849 len_avail
= strlen (buf
);
2850 if (offset
>= len_avail
)
2854 if (len
> len_avail
- offset
)
2855 len
= len_avail
- offset
;
2856 memcpy (readbuf
, buf
+ offset
, len
);
2859 obstack_free (&obstack
, NULL
);
2860 *xfered_len
= (ULONGEST
) len
;
2861 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
2864 static enum target_xfer_status
2865 windows_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2866 const char *annex
, gdb_byte
*readbuf
,
2867 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
2868 ULONGEST
*xfered_len
)
2872 case TARGET_OBJECT_MEMORY
:
2873 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
2875 case TARGET_OBJECT_LIBRARIES
:
2876 return windows_xfer_shared_libraries (ops
, object
, annex
, readbuf
,
2877 writebuf
, offset
, len
, xfered_len
);
2880 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2881 readbuf
, writebuf
, offset
, len
,
2886 /* Provide thread local base, i.e. Thread Information Block address.
2887 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
2890 windows_get_tib_address (struct target_ops
*self
,
2891 ptid_t ptid
, CORE_ADDR
*addr
)
2893 windows_thread_info
*th
;
2895 th
= thread_rec (ptid_get_tid (ptid
), 0);
2900 *addr
= th
->thread_local_base
;
2906 windows_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long thread
)
2908 return ptid_build (ptid_get_pid (inferior_ptid
), 0, lwp
);
2911 /* Implementation of the to_thread_name method. */
2914 windows_thread_name (struct target_ops
*self
, struct thread_info
*thr
)
2916 return thread_rec (ptid_get_tid (thr
->ptid
), 0)->name
;
2919 static struct target_ops
*
2920 windows_target (void)
2922 struct target_ops
*t
= inf_child_target ();
2924 t
->to_close
= windows_close
;
2925 t
->to_attach
= windows_attach
;
2926 t
->to_attach_no_wait
= 1;
2927 t
->to_detach
= windows_detach
;
2928 t
->to_resume
= windows_resume
;
2929 t
->to_wait
= windows_wait
;
2930 t
->to_fetch_registers
= windows_fetch_inferior_registers
;
2931 t
->to_store_registers
= windows_store_inferior_registers
;
2932 t
->to_xfer_partial
= windows_xfer_partial
;
2933 t
->to_files_info
= windows_files_info
;
2934 t
->to_kill
= windows_kill_inferior
;
2935 t
->to_create_inferior
= windows_create_inferior
;
2936 t
->to_mourn_inferior
= windows_mourn_inferior
;
2937 t
->to_thread_alive
= windows_thread_alive
;
2938 t
->to_pid_to_str
= windows_pid_to_str
;
2939 t
->to_interrupt
= windows_interrupt
;
2940 t
->to_pid_to_exec_file
= windows_pid_to_exec_file
;
2941 t
->to_get_ada_task_ptid
= windows_get_ada_task_ptid
;
2942 t
->to_get_tib_address
= windows_get_tib_address
;
2943 t
->to_thread_name
= windows_thread_name
;
2948 /* -Wmissing-prototypes */
2949 extern initialize_file_ftype _initialize_windows_nat
;
2952 _initialize_windows_nat (void)
2954 struct target_ops
*t
;
2956 t
= windows_target ();
2958 x86_use_watchpoints (t
);
2960 x86_dr_low
.set_control
= cygwin_set_dr7
;
2961 x86_dr_low
.set_addr
= cygwin_set_dr
;
2962 x86_dr_low
.get_addr
= cygwin_get_dr
;
2963 x86_dr_low
.get_status
= cygwin_get_dr6
;
2964 x86_dr_low
.get_control
= cygwin_get_dr7
;
2966 /* x86_dr_low.debug_register_length field is set by
2967 calling x86_set_debug_register_length function
2968 in processor windows specific native file. */
2973 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
2976 add_com ("signal-event", class_run
, signal_event_command
, _("\
2977 Signal a crashed process with event ID, to allow its debugging.\n\
2978 This command is needed in support of setting up GDB as JIT debugger on \
2979 MS-Windows. The command should be invoked from the GDB command line using \
2980 the '-ex' command-line option. The ID of the event that blocks the \
2981 crashed process will be supplied by the Windows JIT debugging mechanism."));
2984 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
2985 Set use of shell to start subprocess."), _("\
2986 Show use of shell to start subprocess."), NULL
,
2988 NULL
, /* FIXME: i18n: */
2989 &setlist
, &showlist
);
2991 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
2992 &cygwin_exceptions
, _("\
2993 Break when an exception is detected in the Cygwin DLL itself."), _("\
2994 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
2996 NULL
, /* FIXME: i18n: */
2997 &setlist
, &showlist
);
3000 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3001 Set creation of new console when creating child process."), _("\
3002 Show creation of new console when creating child process."), NULL
,
3004 NULL
, /* FIXME: i18n: */
3005 &setlist
, &showlist
);
3007 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3008 Set creation of new group when creating child process."), _("\
3009 Show creation of new group when creating child process."), NULL
,
3011 NULL
, /* FIXME: i18n: */
3012 &setlist
, &showlist
);
3014 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3015 Set whether to display execution in child process."), _("\
3016 Show whether to display execution in child process."), NULL
,
3018 NULL
, /* FIXME: i18n: */
3019 &setlist
, &showlist
);
3021 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3022 Set whether to display kernel events in child process."), _("\
3023 Show whether to display kernel events in child process."), NULL
,
3025 NULL
, /* FIXME: i18n: */
3026 &setlist
, &showlist
);
3028 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3029 Set whether to display memory accesses in child process."), _("\
3030 Show whether to display memory accesses in child process."), NULL
,
3032 NULL
, /* FIXME: i18n: */
3033 &setlist
, &showlist
);
3035 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3036 &debug_exceptions
, _("\
3037 Set whether to display kernel exceptions in child process."), _("\
3038 Show whether to display kernel exceptions in child process."), NULL
,
3040 NULL
, /* FIXME: i18n: */
3041 &setlist
, &showlist
);
3043 init_w32_command_list ();
3045 add_cmd ("selector", class_info
, display_selectors
,
3046 _("Display selectors infos."),
3050 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3052 /* Pass the address ADDR to the inferior in the I'th debug register.
3053 Here we just store the address in dr array, the registers will be
3054 actually set up when windows_continue is called. */
3056 cygwin_set_dr (int i
, CORE_ADDR addr
)
3059 internal_error (__FILE__
, __LINE__
,
3060 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3062 debug_registers_changed
= 1;
3063 debug_registers_used
= 1;
3066 /* Pass the value VAL to the inferior in the DR7 debug control
3067 register. Here we just store the address in D_REGS, the watchpoint
3068 will be actually set up in windows_wait. */
3070 cygwin_set_dr7 (unsigned long val
)
3072 dr
[7] = (CORE_ADDR
) val
;
3073 debug_registers_changed
= 1;
3074 debug_registers_used
= 1;
3077 /* Get the value of debug register I from the inferior. */
3080 cygwin_get_dr (int i
)
3085 /* Get the value of the DR6 debug status register from the inferior.
3086 Here we just return the value stored in dr[6]
3087 by the last call to thread_rec for current_event.dwThreadId id. */
3088 static unsigned long
3089 cygwin_get_dr6 (void)
3091 return (unsigned long) dr
[6];
3094 /* Get the value of the DR7 debug status register from the inferior.
3095 Here we just return the value stored in dr[7] by the last call to
3096 thread_rec for current_event.dwThreadId id. */
3098 static unsigned long
3099 cygwin_get_dr7 (void)
3101 return (unsigned long) dr
[7];
3104 /* Determine if the thread referenced by "ptid" is alive
3105 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3106 it means that the thread has died. Otherwise it is assumed to be alive. */
3108 windows_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
3112 gdb_assert (ptid_get_tid (ptid
) != 0);
3113 tid
= ptid_get_tid (ptid
);
3115 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
3119 /* -Wmissing-prototypes */
3120 extern initialize_file_ftype _initialize_check_for_gdb_ini
;
3123 _initialize_check_for_gdb_ini (void)
3126 if (inhibit_gdbinit
)
3129 homedir
= getenv ("HOME");
3133 char *oldini
= (char *) alloca (strlen (homedir
) +
3134 sizeof ("gdb.ini") + 1);
3135 strcpy (oldini
, homedir
);
3136 p
= strchr (oldini
, '\0');
3137 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3139 strcpy (p
, "gdb.ini");
3140 if (access (oldini
, 0) == 0)
3142 int len
= strlen (oldini
);
3143 char *newini
= (char *) alloca (len
+ 2);
3145 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3146 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3147 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3152 /* Define dummy functions which always return error for the rare cases where
3153 these functions could not be found. */
3155 bad_DebugActiveProcessStop (DWORD w
)
3160 bad_DebugBreakProcess (HANDLE w
)
3165 bad_DebugSetProcessKillOnExit (BOOL w
)
3170 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3177 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3183 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3190 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3196 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3202 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3208 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3216 /* -Wmissing-prototypes */
3217 extern initialize_file_ftype _initialize_loadable
;
3219 /* Load any functions which may not be available in ancient versions
3223 _initialize_loadable (void)
3227 #define GPA(m, func) \
3228 func = (func ## _ftype *) GetProcAddress (m, #func)
3230 hm
= LoadLibrary ("kernel32.dll");
3233 GPA (hm
, DebugActiveProcessStop
);
3234 GPA (hm
, DebugBreakProcess
);
3235 GPA (hm
, DebugSetProcessKillOnExit
);
3236 GPA (hm
, GetConsoleFontSize
);
3237 GPA (hm
, DebugActiveProcessStop
);
3238 GPA (hm
, GetCurrentConsoleFont
);
3241 /* Set variables to dummy versions of these processes if the function
3242 wasn't found in kernel32.dll. */
3243 if (!DebugBreakProcess
)
3244 DebugBreakProcess
= bad_DebugBreakProcess
;
3245 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3247 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3248 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3250 if (!GetConsoleFontSize
)
3251 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3252 if (!GetCurrentConsoleFont
)
3253 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3255 /* Load optional functions used for retrieving filename information
3256 associated with the currently debugged process or its dlls. */
3257 hm
= LoadLibrary ("psapi.dll");
3260 GPA (hm
, EnumProcessModules
);
3261 GPA (hm
, GetModuleInformation
);
3262 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3263 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3266 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3268 /* Set variables to dummy versions of these processes if the function
3269 wasn't found in psapi.dll. */
3270 EnumProcessModules
= bad_EnumProcessModules
;
3271 GetModuleInformation
= bad_GetModuleInformation
;
3272 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3273 /* This will probably fail on Windows 9x/Me. Let the user know
3274 that we're missing some functionality. */
3276 cannot automatically find executable file or library to read symbols.\n\
3277 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3280 hm
= LoadLibrary ("advapi32.dll");
3283 GPA (hm
, OpenProcessToken
);
3284 GPA (hm
, LookupPrivilegeValueA
);
3285 GPA (hm
, AdjustTokenPrivileges
);
3286 /* Only need to set one of these since if OpenProcessToken fails nothing
3288 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3289 || !AdjustTokenPrivileges
)
3290 OpenProcessToken
= bad_OpenProcessToken
;